# File tk/lib/tk/variable.rb, line 45
  def TkVariable.callback(id, name1, name2, op)
    #name1,name2,op = tk_split_list(args)
    #name1,name2,op = tk_split_simplelist(args)
    if TkVar_CB_TBL[id]
      #_get_eval_string(TkVar_CB_TBL[name1].trace_callback(name2,op))
      begin
        _get_eval_string(TkVar_CB_TBL[id].trace_callback(name2, op))
      rescue SystemExit
        exit(0)
      rescue Interrupt
        exit!(1)
      rescue Exception => e
        begin
          msg = _toUTF8(e.class.inspect) + ': ' + 
                _toUTF8(e.message) + "\n" + 
                "\n---< backtrace of Ruby side >-----\n" + 
                _toUTF8(e.backtrace.join("\n")) + 
                "\n---< backtrace of Tk side >-------"
          msg.instance_variable_set(:@encoding, 'utf-8')
        rescue Exception
          msg = e.class.inspect + ': ' + e.message + "\n" + 
                "\n---< backtrace of Ruby side >-----\n" + 
                e.backtrace.join("\n") + 
                "\n---< backtrace of Tk side >-------"
        end
        fail(e, msg)
      end
??
    else
      ''
    end
  end

# File tk/lib/tk/variable.rb, line 268
  def initialize(val="", type=nil)
    # @id = Tk_VARIABLE_ID.join('')
    begin
      @id = Tk_VARIABLE_ID.join(TkCore::INTERP._ip_id_)
      Tk_VARIABLE_ID[1].succ!
    end until INTERP._invoke_without_enc('info', 'globals', @id).empty?

    TkVar_ID_TBL[@id] = self

    @var  = @id
    @elem = nil

    @def_default = false
    @default_val = nil

    @trace_var  = nil
    @trace_elem = nil
    @trace_opts = nil

    @type = nil
    var = self
    @element_type = Hash.new{|k,v| var.default_value_type }

    self.default_value_type = type

    # teach Tk-ip that @id is global var
    INTERP._invoke_without_enc('global', @id)
    #INTERP._invoke('global', @id)

    # create and init
    if val.kind_of?(Hash)
      # assoc-array variable
      self[''] = 0
      self.clear
    end
    self.value = val

??
??
  end

# File tk/lib/tk/variable.rb, line 92
  def self.new_hash(val = {})
    if val.kind_of?(Hash)
      self.new(val)
    else
      fail ArgumentError, 'Hash is expected'
    end
  end

# File tk/lib/tk/variable.rb, line 1185
  def %(other)
    num_or_str(self._value) % other.to_i
    #begin
    #  number(self._value) % other
    #rescue
    #  self._value % other
    #end
  end

# File tk/lib/tk/variable.rb, line 1139
  def &(other)
    if other.kind_of?(Array)
      self.to_a & other.to_a
    else
      self.to_i & other.to_i
    end
  end

# File tk/lib/tk/variable.rb, line 1174
  def *(other)
    num_or_str(self._value) * other.to_i
    #begin
    #  number(self._value) * other
    #rescue
    #  self._value * other
    #end
  end

# File tk/lib/tk/variable.rb, line 1193
  def **(other)
    number(self._value) ** other
  end

# File tk/lib/tk/variable.rb, line 1153
  def +(other)
    case other
    when Array
      self.to_a + other
    when String
      self._value + other
    else
      begin
        number(self._value) + other
      rescue
        self._value + other.to_s
      end
    end
  end

# File tk/lib/tk/variable.rb, line 1167
  def -(other)
    if other.kind_of?(Array)
      self.to_a - other
    else
      number(self._value) - other
    end
  end

# File tk/lib/tk/variable.rb, line 1182
  def /(other)
    number(self._value) / other
  end

# File tk/lib/tk/variable.rb, line 1231
  def <=>(other)
    if other.kind_of?(TkVariable)
      begin
        val = other.numeric
        other = val
      rescue
        other = other._value
      end
    elsif other.kind_of?(Numeric)
      begin
        return self.numeric <=> other
      rescue
        return self._value <=> other.to_s
      end
    elsif other.kind_of?(Array)
      return self.list <=> other
    else
      return self._value <=> other
    end
  end

# File tk/lib/tk/variable.rb, line 1200
  def ==(other)
    case other
    when TkVariable
      #self.equal?(other)
      self._value == other._value
    when String
      self.to_s == other
    when Symbol
      self.to_sym == other
    when Integer
      self.to_i == other
    when Float
      self.to_f == other
    when Array
      self.to_a == other
    when Hash
      # false if self is not an assoc array
      self._value == other
    else
      # false
      self._value == _get_eval_string(other)
    end
  end

# File tk/lib/tk/variable.rb, line 1196
  def =~(other)
    self._value =~ other
  end

# File tk/lib/tk/variable.rb, line 670
  def [](*idxs)
    _to_default_element_type(idxs, _element_value(*idxs))
  end

# File tk/lib/tk/variable.rb, line 514
  def []=(*args)
    val = args.pop
    type = default_element_value_type(args)
    val = val._value if !type && type != :variable && val.kind_of?(TkVariable)
    index = args.collect{|idx| _get_eval_string(idx, true)}.join(',')
    _fromUTF8(INTERP._set_global_var2(@id, index, _get_eval_string(val, true)))
    #_fromUTF8(INTERP._set_global_var2(@id, _toUTF8(_get_eval_string(index)), 
    #                                 _toUTF8(_get_eval_string(val))))
    #_fromUTF8(INTERP._set_global_var2(@id, _get_eval_string(index, true), 
    #                                 _get_eval_string(val, true)))
  end

# File tk/lib/tk/variable.rb, line 631
  def []=(*args)
    val = args.pop
    type = default_element_value_type(args)
    val = val._value if !type && type != :variable && val.kind_of?(TkVariable)
    index = args.collect{|idx| _get_eval_string(idx)}.join(',')
    INTERP._eval(Kernel.format('global %s; set %s(%s) %s', @id, @id, 
                              index, _get_eval_string(val)))
    #INTERP._eval(Kernel.format('global %s; set %s(%s) %s', @id, @id, 
    #                          _get_eval_string(index), _get_eval_string(val)))
    #INTERP._eval(Kernel.format('set %s(%s) %s', @id, 
    #                          _get_eval_string(index), _get_eval_string(val)))
    #INTERP._eval('set ' + @id + '(' + _get_eval_string(index) + ') ' + 
    #            _get_eval_string(val))
  end

# File tk/lib/tk/variable.rb, line 1383
  def _trace_vinfo_for_element(elem)
    if @elem
      fail(RuntimeError, 
           "invalid for a TkVariable which denotes an element of Tcl's array")
    end
    return [] unless @trace_elem
    return [] unless @trace_elem[elem]
    @trace_elem[elem].dup
  end

# File tk/lib/tk/variable.rb, line 751
  def bool
    TkComm.bool(_value)
??
  end

# File tk/lib/tk/variable.rb, line 763
  def bool_element(*idxs)
    TkComm.bool(_element_value(*idxs))
  end

# File tk/lib/tk/variable.rb, line 427
  def clear
    if (is_scalar?)
      fail RuntimeError, 'cannot clear a scalar variable'
    end
    keys.each{|k| unset(k)}
    self
  end

# File tk/lib/tk/variable.rb, line 1120
  def coerce(other)
    case other
    when TkVariable
      [other._value, self._value]
    when String
      [other, self.to_s]
    when Symbol
      [other, self.to_sym]
    when Integer
      [other, self.to_i]
    when Float
      [other, self.to_f]
    when Array
      [other, self.to_a]
    else
      [other, self._value]
    end
  end

# File tk/lib/tk/variable.rb, line 134
  def default_element_value_type(idxs)
    if idxs.kind_of?(Array)
      index = idxs.collect{|idx| _get_eval_string(idx, true)}.join(',')
    else
      index = _get_eval_string(idxs, true)
    end
    @element_type[index]
  end

# File tk/lib/tk/variable.rb, line 119
  def default_proc(cmd = Proc.new)
    @def_default = :proc
    @default_val = cmd
    self
  end

# File tk/lib/tk/variable.rb, line 103
  def default_value(val=nil, &b)
    if b
      @def_default = :proc
      @default_val = proc(&b)
    else
      @def_default = :val
      @default_val = val
    end
    self
  end

# File tk/lib/tk/variable.rb, line 131
  def default_value_type
    @type
  end

# File tk/lib/tk/variable.rb, line 1067
  def element_lappend(idxs, *elems)
    if idxs.kind_of?(Array)
      idxs = idxs.collect{|idx| _get_eval_string(idx, true)}.join(',')
    end
    tk_call('lappend', "#{@id}(#{idxs})", *elems)
    self
  end

# File tk/lib/tk/variable.rb, line 1099
  def element_lget_f(elem_idxs, idx)
    number(element_lget(elem_idxs, idx)).to_f
  end

# File tk/lib/tk/variable.rb, line 1092
  def element_lget_i(elem_idxs, idx)
    number(element_lget(elem_idxs, idx)).to_i
  end

# File tk/lib/tk/variable.rb, line 1079
  def element_lindex(elem_idxs, idx)
    if elem_idxs.kind_of?(Array)
      val = _element_value(*elem_idxs)
    else
      val = _element_value(elem_idxs)
    end
    tk_call('lindex', val, idx)
  end

# File tk/lib/tk/variable.rb, line 1107
  def element_lset(elem_idxs, idx, val)
    if elem_idxs.kind_of?(Array)
      idxs = elem_idxs.collect{|i| _get_eval_string(i, true)}.join(',')
    end
    tk_call('lset', "#{@id}(#{idxs})", idx, val)
    self
  end

# File tk/lib/tk/variable.rb, line 916
  def element_to_f(*idxs)
    number(_element_value(*idxs)).to_f
  end

# File tk/lib/tk/variable.rb, line 909
  def element_to_i(*idxs)
    number(_element_value(*idxs)).to_i
  end

# File tk/lib/tk/variable.rb, line 925
  def element_to_s(*idxs)
    _element_value(*idxs)
  end

# File tk/lib/tk/variable.rb, line 961
  def element_to_sym(*idxs)
    _element_value(*idxs).intern
  end

# File tk/lib/tk/variable.rb, line 372
  def eventloop_tkwait
    wait(false, true)
  end

# File tk/lib/tk/variable.rb, line 363
  def eventloop_wait(check_root = false)
    wait(false, check_root)
  end

# File tk/lib/tk/variable.rb, line 399
  def exist?(*elems)
    INTERP._invoke_without_enc('global', @id)
    if elems.empty?
      TkComm.bool(tk_call('info', 'exist', @id))
    else
      # array
      index = elems.collect{|idx| _get_eval_string(idx, true)}.join(',')
      TkComm.bool(tk_call('info', 'exist', "#{@id}")) && 
        TkComm.bool(tk_call('info', 'exist', "#{@id}(#{index})"))
    end
  end

# File tk/lib/tk/variable.rb, line 379
  def id
    @id
  end

# File tk/lib/tk/variable.rb, line 1115
  def inspect
    #Kernel.format "#<TkVariable: %s>", @id
    '#<TkVariable: ' + @id + '>'
  end

# File tk/lib/tk/variable.rb, line 388
  def is_hash?
    #ITNERP._eval("global #{@id}; array exist #{@id}") == '1'
    INTERP._invoke_without_enc('global', @id)
    # INTERP._invoke_without_enc('array', 'exist', @id) == '1'
    TkComm.bool(INTERP._invoke_without_enc('array', 'exist', @id))
  end

# File tk/lib/tk/variable.rb, line 395
  def is_scalar?
    ! is_hash?
  end

# File tk/lib/tk/variable.rb, line 411
  def keys
    if (is_scalar?)
      fail RuntimeError, 'cannot get keys from a scalar variable'
    end
    #tk_split_simplelist(INTERP._eval("global #{@id}; array get #{@id}"))
    INTERP._invoke_without_enc('global', @id)
    #tk_split_simplelist(INTERP._fromUTF8(INTERP._invoke_without_enc('array', 'names', @id)))
    tk_split_simplelist(INTERP._invoke_without_enc('array', 'names', @id), 
                        false, true)
  end

# File tk/lib/tk/variable.rb, line 1063
  def lappend(*elems)
    tk_call('lappend', @id, *elems)
    self
  end

# File tk/lib/tk/variable.rb, line 1096
  def lget_f(idx)
    number(lget(idx)).to_f
  end

# File tk/lib/tk/variable.rb, line 1089
  def lget_i(idx)
    number(lget(idx)).to_i
  end

# File tk/lib/tk/variable.rb, line 1075
  def lindex(idx)
    tk_call('lindex', self._value, idx)
  end

# File tk/lib/tk/variable.rb, line 991
  def list
    #tk_split_list(value)
    tk_split_simplelist(_value)
  end

# File tk/lib/tk/variable.rb, line 996
  def list_element(*idxs)
    tk_split_simplelist(_element_value(*idxs))
  end

# File tk/lib/tk/variable.rb, line 1103
  def lset(idx, val)
    tk_call('lset', @id, idx, val)
    self
  end

# File tk/lib/tk/variable.rb, line 1227
  def nonzero?
    !(numeric.zero?)
  end

# File tk/lib/tk/variable.rb, line 706
  def numeric
    number(_value)
  end

# File tk/lib/tk/variable.rb, line 709
  def numeric_element(*idxs)
    number(_element_value(*idxs))
  end

# File tk/lib/tk/variable.rb, line 1001
  def numlist
    list.collect!{|val| number(val)}
  end

# File tk/lib/tk/variable.rb, line 1004
  def numlist_element(*idxs)
    list_element(*idxs).collect!{|val| number(val)}
  end

# File tk/lib/tk/variable.rb, line 875
  def procedure
    TkComm.procedure(self._value)
  end

# File tk/lib/tk/variable.rb, line 878
  def procedure_element(*idxs)
    TkComm.procedure(_element_value(*idxs))
  end

# File tk/lib/tk/variable.rb, line 383
  def ref(*idxs)
    # "#{@id}(#{idxs.collect{|idx| _get_eval_string(idx)}.join(',')})"
    TkVarAccess.new("#{@id}(#{idxs.collect{|idx| _get_eval_string(idx)}.join(',')})")
  end

# File tk/lib/tk/variable.rb, line 766
  def set_bool(val)
    if ! val
      self.value = '0'
    else
      case val.to_s.downcase
      when 'false', '0', 'no', 'off'
        self.value = '0'
      else
        self.value = '1'
      end
    end
    self
  end

# File tk/lib/tk/variable.rb, line 780
  def set_bool_element(idxs, val)
    if ! val
      val = '0'
    else
      case val.to_s.downcase
      when 'false', '0', 'no', 'off'
        val = '0'
      else
        val = '1'
      end
    end
    if idxs.kind_of?(Array)
      self[*idxs]=val
    else
      self[idxs]=val
    end
    self
  end

# File tk/lib/tk/variable.rb, line 804
  def set_bool_element_type(idxs, val)
    self.set_default_element_value_type(idxs, :bool)
    self.set_bool_element(idxs, val)
  end

# File tk/lib/tk/variable.rb, line 798
  def set_bool_type(val)
    @type = :bool
    self.bool=(val)
    self
  end

# File tk/lib/tk/variable.rb, line 212
  def set_default_element_value_type(idxs, type)
    _set_default_value_type_core(type, idxs)
    self
  end

# File tk/lib/tk/variable.rb, line 113
  def set_default_value(val)
    @def_default = :val
    @default_val = val
    self
  end

# File tk/lib/tk/variable.rb, line 206
  def set_default_value_type(type)
    _set_default_value_type_core(type, nil)
    self
  end

# File tk/lib/tk/variable.rb, line 679
  def set_element_value(idxs, val)
    if idxs.kind_of?(Array)
      self[*idxs]=val
    else
      self[idxs]=val
    end
    self
  end

# File tk/lib/tk/variable.rb, line 696
  def set_element_value_type(idxs, val)
    self.set_default_element_value_type(idxs, val.class)
    if idxs.kind_of?(Array)
      self[*idxs]=val
    else
      self[idxs]=val
    end
    self
  end

# File tk/lib/tk/variable.rb, line 1008
  def set_list(val)
    case val
    when Array
      self.value=(val)
    when TkVariable
      self.value=(val.list)
    else
      raise ArgumentError, "Array is expected"
    end
    self
  end

# File tk/lib/tk/variable.rb, line 1024
  def set_list_element(idxs, val)
    case val
    when Array
      val
    when TkVariable
      val = val.list
    else
      raise ArgumentError, "Array is expected"
    end
    if idxs.kind_of?(Array)
      self[*idxs]=val
    else
      self[idxs]=val
    end
    self
  end

# File tk/lib/tk/variable.rb, line 1048
  def set_list_element_type(idxs, val)
    self.set_default_element_value_type(idxs, :list)
    self.set_list_element(idxs, val)
  end

# File tk/lib/tk/variable.rb, line 1042
  def set_list_type(val)
    @type = :list
    self.list=(val)
    self
  end

# File tk/lib/tk/variable.rb, line 712
  def set_numeric(val)
    case val
    when Numeric
      self.value=(val)
    when TkVariable
      self.value=(val.numeric)
    else
      raise ArgumentError, "Numeric is expected"
    end
    self
  end

# File tk/lib/tk/variable.rb, line 724
  def set_numeric_element(idxs, val)
    case val
    when Numeric
      val
    when TkVariable
      val = val.numeric
    else
      raise ArgumentError, "Numeric is expected"
    end
    if idxs.