# need interpolation 
puts "word_tokens 1!"
if {$eval_stmt_debug > -2} {
puts "evalObj dump2 i!$i!"
$script dumpToken $i
puts "argv!$argv!"
}
          switch [::Parser::Token::token2String [[lindex $token $i] getToken]] {
          TOKEN_COMMENT {
            set had_comment true
            incr num_comments

            }
          TOKEN_QUOTE_ESC -

          TOKEN_ESC -
          TOKEN_STR {
            set word_obj_ptr [[lindex $token $i] getObjPtr]

puts "TOK_ESC_STR![$word_obj_ptr toDebugString]!"
            }
          TOKEN_VAR_ARRAY_NAME {
//print("stmt var_array_name");
            word_obj_ptr = interp.array_obj_type.expandArray(token.get(i).obj_ptr);

            }
          TOKEN_VAR {
//print("evalObj! VAR!"+token.get(i).obj_ptr+"!"+token.get(i).obj_ptr.getString()+"!"+interp.frame_ptr.ns_ptr.toDebugString()+"!");
            ArrayList<Variable> result_var_ptr = new ArrayList<Variable>();
            word_obj_ptr = interp.variable_obj_type.getVariable(token.get(i).obj_ptr, FUNCTION_FLAGS_LEAVE_ERR_MSG, result_var_ptr);
            Variable result_var = result_var_ptr.get(0);
            /* special case for ::itcl::type type variable !! */
            if (word_obj_ptr == null && result_var != null && token.get(i).obj_ptr.getString().equals("type")) {
              word_obj_ptr = interp.string_obj_type.newStringObj(result_var.namespace.full_name, -1, "EVAL_STATEMENT_7");
              word_obj_ptr.incrRefCount("I_EVAL_STATEMENT_5");
            }

            }
          TOKEN_EXPRSUGAR {
            word_obj_ptr = interp.expr_obj_type.expandExprSugar(token.get(i).obj_ptr);
            break;
          case TOKEN_BRACE:
            if (!in_quotes) {
              if (argc == 1) {
                /* seems to be the special of setting a variable which is a list
                 * in a ::itcl::macro and then executing the variable!!

            } else {
              ArrayList<ApwtclObj> result_ptr2 = new ArrayList<ApwtclObj>();
              retcode = interp.script_obj_type.substObj(token.get(i).obj_ptr, result_ptr2, FUNCTION_FLAGS_LEAVE_ERR_MSG);
              if (retcode == OK) {
                word_obj_ptr = result_ptr2.get(0);
              }
                }
            }
          TOKEN_BRACKET {
            set word_obj_ptr [[lindex $token $i] getObjPtr]
puts "BRACKET reached![$word_obj_ptr toDebugString]!"
            }
          TOKEN_BRACE {
            set word_obj_ptr [[lindex $token $i] getObjPtr]
puts "BRACE reached![$word_obj_ptr toDebugString]!"
            }
          TOKEN_TAG_NAME {
            set word_obj_ptr [[lindex $token $i] getObjPtr]
puts "TAG_NAME reached![$word_obj_ptr toDebugString]!"
            }

          default {
            ::Interp::panic true "default token type reached in evalObj(): [::Parser::Token::token2String [[lindex $token $i] getToken]]"
            }
          }
        } else {
          # For interpolation we call a helper
          # function to do the work for us. 
          
          set word_obj_ptr [interpolateTokens $script $i $word_tokens TOKEN_NONE]
#puts "interpolate![$word_obj_ptr ToDebugString]!"
          if {$word_obj_ptr != [list] && [$word_obj_ptr getLen] == 0} {
            # we had only comment tokens, nothing to do
            set had_comment true
          }
        }
puts "EVALOBJ9"
        incr i $word_tokens
        if {!$had_comment} {
          if {$word_obj_ptr == [list]} {
            if {$retcode == [::Interp::string2ReturnCode OK]} {
              set retcode [::Interp::string2ReturnCode ERROR]
            }
            break
          }
          $word_obj_ptr incrRefCount "I_EVAL_STATEMENT_6"
          if {!$expand} {
            if {!$had_comment} {
              lappend argv $word_obj_ptr
puts "lappend argv![$word_obj_ptr toDebugString]!"
            }
          } else {
            # Need to expand word_obj_ptr into multiple args from argv[j] ... 
            set len [$::Interp::list_obj_type listLength $word_obj_ptr]
            int k;
  
//print(">>>EXPAND!"+argc+"!"+len+"!"+newargc+"!"+word_obj_ptr.toDebugString()+"!");
            /* Now copy in the expanded version */
            for (k = 0; k < len; k++) {
              argv.add(word_obj_ptr.listValue_GetElem().get(k));
              j++;
              word_obj_ptr.listValue_GetElem().get(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;
          }
        }
	incr j
      }
puts "EVALOBJ10"
      if {$had_comment} {
        continue
      }
      incr argc [expr {-$num_comments}]
      if {$retcode == [::Interp::string2ReturnCode OK] && $argc != 0} {
        # Lookup the command to call
puts "lookup command!$argv!"

foreach arg $argv {
puts "arg!$arg![$arg toDebugString]!"
}
	set extra_args_ptr [list]
        set cmd [::Interp::getCommand [lindex $argv 0] 0 extra_args_ptr]
        extra_args = extra_args_ptr.get(0);
//print("EVALOBJ11!"+cmd+"!"+argc+"!");
        if ((cmd == null) && (argc == 1)) {
          /* check if the argument looks like a list and the expand it (old style!!) */
          int len = interp.list_obj_type.listLength(argv.get(0));
          ArrayList<ApwtclObj> result_ptr3 = new ArrayList<ApwtclObj>();
//print("EVALOBJ11a");

            /* Call [unknown] */
            retcode = 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
puts "EVALOBJ10a!$retcode!$argv!"
      foreach arg $argv {
        $arg decrRefCount "D_EVAL_STATEMENT_7![$arg getObjType]![$arg getBytes]!"
      }
      set argv [list]
    }

    # Possibly add to the error stack trace 
#    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 setObjType [::Interp::string2ObjType OBJ_TYPE_SCRIPT]
    $script_obj_ptr setIntRepPtr $script
    $script_obj_ptr decrRefCount "D_EVAL_STATEMENT_8"
if {$eval_stmt_debug > 0} {
puts "EVALOBJ end level!$eval_level!$retcode!"
}
    if {$macro_cmd_level == $eval_level} {
      set had_macro_cmd false
    }
    incr eval_level -1
    return $retcode
  }

  # ==================== _evalObjVector ===================================== */
  # Eval the object vector 'objv' composed of 'objc' elements.
  # Every element is used as single argument.
  # evalObj() will call this function every time its object
  # argument is of "list" type, with no string representation.

  public variable ref_count
  public variable obj_type

  constructor {} {}
  public method mySelf {}
  public method toString {}
  public method toDebugString {}
  public method ptrAndLongRepValue_GetPtr {}
  public method ptrAndLongRepValue_SetPtr {ptr}
  public method ptrAndLongRepValue_GetValue {}
  public method ptrAndLongRepValue_SetValue {val}
  public method ptrValue_GetPtr {}
  public method ptrValue_SetPtr {ptr}
  public method scriptLineValue_GetLine {}
  public method scriptLineValue_SetLine {val}
  public method scriptLineValue_GetArgc {}
  public method scriptLineValue_SetArgc {val}
  public method scriptValue_GetScript {}
  public method scriptValue_SetScript {script}
  public method sourceValue_GetFileNameObj {}

    set bytes ""
    set len 0;
    set allocated ""
    set freed ""
    set obj_type_base [::Parser::ObjTypeBase #auto]
    set incr_lst [list]
    set decr_lst [list]
    set prev_obj_ptr [list]
    set next_obj_ptr [list]
    set check_allocate true
    set ref_count 0
    set value1 ""
    set value2 ""
    set value3 ""
  }

  /* ==================== paramInfoValue_SetOrigParams ================================== */
  public FunctionArgList paramInfoValue_SetOrigParams(FunctionArgList orig_params) {
//print("paramInfoValue_SetOrigParams!"+this.mySelf()+"!");
    value2 = (Object)orig_params;
    return orig_params;
  }
}

  # ==================== ptrAndLongRepValue_GetPtr ==================================
::itcl::body LatexObj::ptrAndLongRepValue_GetPtr {} {
    return $value1
  }

  # ==================== ptrAndLongRepValue_SetPtr ==================================
::itcl::body LatexObj::ptrAndLongRepValue_SetPtr {ptr} {
#puts "ptrAndLongRepValue_SetPtr![mySelf]!"
    set value1 $ptr
    return $ptr;
  }

  # ==================== ptrAndLongRepValue_GetValue =============================
::itcl::body LatexObj::ptrAndLongRepValue_GetValue {} {
    return $value2
  }

  # ==================== ptrAndLongRepValue_SetValue =============================
::itcl::body LatexObj::ptrAndLongRepValue_SetValue {val} {
#puts "ptrAndLongRepValue_SetValue![mySelf]!"
    set value2 $val
    return $val
  }

  # ==================== ptrValue_GetPtr ==================================
::itcl::body LatexObj::ptrValue_GetPtr {} {
    return $value1
  }

  # ==================== ptrValue_SetPtr ==================================
::itcl::body LatexObj::ptrValue_SetPtr {ptr} {
#puts "ptrValue_SetPtr![mySelf]!"
    set value1 $ptr
    return $ptr
  }

if {0} {
  /* ==================== refValue_GetRefPtr ================================== */
  public LatexObj refValue_GetRefPtr() {
    return (LatexObj)value1;
  }

  /* ==================== refValue_SetRefPtr ================================== */
  public LatexObj refValue_SetRefPtr(LatexObj ref_ptr) {

    if {$next_obj_ptr != [list]} {
      $next_obj_ptr setPrevObjPtr $prev_obj_ptr
    }
    if {$live_obj_list == $this} {
      set live_obj_list $next_obj_ptr
    }
    # Link the object into the free objects list
    set prev_obj_ptr [list]
    set next_obj_ptr $free_obj_list
    if {$free_obj_list != [list]} {
      $free_obj_list setPrevObjPtr $this
    }
    set free_obj_list $this
    set ref_count -1
    set freed $where

      if {[$parse_info getState] eq [::Parser::Token::string2ParserState "PARSER_STATE_DEFAULT"]} {
        return [parseEol]
      } else {
        return [parseString]
      }
      }
    "\{" {
puts "ARG1![$parse_info getArgument]![$parse_info getWordSep]!"
      if {[$parse_info getArgument]} {
        if {[$parse_info getWordSep]} {
          # we have to simulate a TOKEN_ESC here so 
          # EvalStatement will use the optional and mandatory arguments
          # as those and not as a combined string!!
	  $parse_info setStart [$parse_info getIndex]
	  $parse_info setEnd [expr {[$parse_info getIndex] - 1}]
          $parse_info setToken [::Parser::Token::string2Token "TOKEN_WORD_SEP"]
          $parse_info setWordSep false
          return true
        }
      }
      if {[$parse_info getArgument]} {
        $parse_info setWordSep true
      }
      $parse_info setComment false
      return [parseBrace]
      }
    "\[" {
puts "BRK1![$parse_info getArgument]![$parse_info getWordSep]!"
      if {[$parse_info getArgument]} {
        if {[$parse_info getWordSep]} {
          # we have to simulate a TOKEN_ESC here so 
          # EvalStatement will use the optional and mandatory arguments
          # as those and not as a combined string!!
	  $parse_info setStart [$parse_info getIndex]
	  $parse_info setEnd [expr {[$parse_info getIndex] - 1}]
          $parse_info setToken [::Parser::Token::string2Token "TOKEN_WORD_SEP"]
puts "BRK![$parse_info getText]!"
          $parse_info setWordSep false
          return true
        }
      }
      if {[$parse_info getArgument]} {
          $parse_info setWordSep true
      }
      $parse_info setComment false
      return [parseBracket]
      }
    "\(" {
      if {[$parse_info getArgument]} {
        if {![$parse_info getWordSep]} {
          # we have to simulate a TOKEN_ESC here so 
          # EvalStatement will use the optional and mandatory arguments
          # as those and not as a combined string!!
	  $parse_info setStart [$parse_info getIndex]
	  $parse_info setEnd [expr {[$parse_info getIndex] - 1}]
          $parse_info setToken [::Parser::Token::string2Token "TOKEN_WORD_SEP"]
          $parse_info setWordSep false
          return true
        }
      }
      if {[$parse_info getArgument]} {
        $parse_info setWordSep true
      }
      $parse_info setComment false
      return [parseParen]
      }
    "$" {
      $parse_info setWordSep false
      $parse_info setComment false
      if {[parseVar] == false} {

# ==================== parseTagName ===================================== */
::itcl::body Parse::parseTagName {} {
  $parse_info setStart [$parse_info getIndex]
  $parse_info setLine [$parse_info getLineNo]
  $parse_info setToken [::Parser::Token::string2Token "TOKEN_TAG_NAME"]
  $parse_info setArgument true
  $parse_info setWordSep true
  feedChar
  while {[$parse_info getLen] > 0} {
    switch [$parse_info getCur] {
    "\{" -
    "\[" -
    "\(" -
    "\t" -

  $parse_info setIndex [expr {[$parse_info getIndex] + 1}]
  $parse_info setLen [expr {[$parse_info getLen] -1}]
  if {[$parse_info getLen] < 0} {
#      throw new PanicException("End of file reached");
    puts stderr "PANIC! End of file reached"
  }
  $parse_info setCur [string range [$parse_info getText] [$parse_info getIndex] [$parse_info getIndex]]
puts "FDCH![$parse_info getLen]![$parse_info getIndex]![$parse_info getCur]![getText]!"
}

}

  }

  # ==================== newStringObj ================================== 
  # len is in bytes -- see also newStringObjUtf8() 
::itcl::body StringObjType::newStringObj {str len where} {
    set obj_ptr [uplevel #0 ::Parser::LatexObj #auto]

puts "NEWSTR!$obj_ptr!"
    # Need to find out how many bytes the string requires 
    if {$len == -1} {
      set len [string length $str]
    }
    $obj_ptr strValue_SetCharLength $len
    $obj_ptr strValue_SetMaxLength $len
    if {$len == 0} {

buildCmdList $latex_cmds_info

::Parser::Token::Init
::Interp::Init
::LaTeX::CommandInfo::Init
set str "\\begin\[pf1\]{document}\n abc \n\\end{document}"
set script [$::Interp::string_obj_type newStringObj "$str" -1 "BASE_2"]
puts "SCRIPT![$script toDebugString]!"
$::Interp::eval_statement evalObj $script

if {0} {
set parser [::Parser::Parse #auto]
$parser parserInit $str [string length $str] 1
while {true} {