ruby_android_apk 0.7.7.1

data/lib/android/axml_parser.rb

@@ -0,0 +1,174 @@
+require 'rexml/document'
+require 'stringio'
+
+
+module Android
+  # binary AXML parser
+  # @see https://android.googlesource.com/platform/frameworks/base.git Android OS frameworks source
+  # @note
+  #   refer to Android OS framework code:
+  #   
+  #   /frameworks/base/include/androidfw/ResourceTypes.h,
+  #   
+  #   /frameworks/base/libs/androidfw/ResourceTypes.cpp
+  class AXMLParser
+    def self.axml?(data)
+      (data[0..3] == "\x03\x00\x08\x00")
+    end
+
+    # axml parse error
+    class ReadError < StandardError; end
+
+    TAG_START_DOC = 0x00100100
+    TAG_END_DOC =   0x00100101
+    TAG_START =     0x00100102
+    TAG_END =       0x00100103
+    TAG_TEXT =      0x00100104
+    TAG_CDSECT =    0x00100105
+    TAG_ENTITY_REF= 0x00100106
+
+    VAL_TYPE_NULL              =0
+    VAL_TYPE_REFERENCE         =1
+    VAL_TYPE_ATTRIBUTE         =2
+    VAL_TYPE_STRING            =3
+    VAL_TYPE_FLOAT             =4
+    VAL_TYPE_DIMENSION         =5
+    VAL_TYPE_FRACTION          =6
+    VAL_TYPE_INT_DEC           =16
+    VAL_TYPE_INT_HEX           =17
+    VAL_TYPE_INT_BOOLEAN       =18
+    VAL_TYPE_INT_COLOR_ARGB8   =28
+    VAL_TYPE_INT_COLOR_RGB8    =29
+    VAL_TYPE_INT_COLOR_ARGB4   =30
+    VAL_TYPE_INT_COLOR_RGB4    =31
+
+    # @return [Array<String>] strings defined in axml
+    attr_reader :strings
+
+    # @param [String] axml binary xml data
+    def initialize(axml)
+      @io = StringIO.new(axml, "rb")
+      @strings = []
+    end
+
+    # parse binary xml
+    # @return [REXML::Document]
+    def parse
+      @doc = REXML::Document.new
+      @doc << REXML::XMLDecl.new
+
+      @num_str = word(4*4)
+      @xml_offset = word(3*4)
+
+      @parents = [@doc]
+      @ns = []
+      parse_strings
+      parse_tags
+      @doc
+    end
+
+
+    # read one word(4byte) as integer
+    # @param [Integer] offset offset from top position. current position is used if ofset is nil
+    # @return [Integer] little endian word value
+    def word(offset=nil)
+      @io.pos = offset unless offset.nil?
+      @io.read(4).unpack("V")[0]
+    end
+
+    # read 2byte as short integer
+    # @param [Integer] offset offset from top position. current position is used if ofset is nil
+    # @return [Integer] little endian unsign short value
+    def short(offset)
+      @io.pos = offset unless offset.nil?
+      @io.read(2).unpack("v")[0]
+    end
+
+    # relace string table parser
+    def parse_strings
+      strpool = Resource::ResStringPool.new(@io.string, 8) # ugh!
+      @strings = strpool.strings
+    end
+
+    # parse tag
+    def parse_tags
+      # skip until START_TAG
+      pos = @xml_offset
+      pos += 4 until (word(pos) == TAG_START) #ugh!
+      @io.pos -= 4
+
+      # read tags
+      #puts "start tag parse: %d(%#x)" % [@io.pos, @io.pos]
+      until @io.eof?
+        last_pos = @io.pos
+        tag, tag1, line, tag3, ns_id, name_id = @io.read(4*6).unpack("V*")
+        case tag
+        when TAG_START
+          tag6, num_attrs, tag8  = @io.read(4*3).unpack("V*")
+          elem = REXML::Element.new(@strings[name_id])
+          #puts "start tag %d(%#x): #{@strings[name_id]} attrs:#{num_attrs}" % [last_pos, last_pos]
+          @parents.last.add_element elem
+          num_attrs.times do
+            key, val = parse_attribute
+            elem.add_attribute(key, val)
+          end
+          @parents.push elem
+        when TAG_END
+          @parents.pop
+        when TAG_END_DOC
+          #fix multi tag_end_doc
+          #break
+        when TAG_TEXT
+          text = REXML::Text.new(@strings[ns_id])
+          @parents.last.text = text
+          dummy = @io.read(4*1).unpack("V*") # skip 4bytes
+        when TAG_START_DOC, TAG_CDSECT, TAG_ENTITY_REF
+          # not implemented yet.
+        else
+          raise ReadError, "pos=%d(%#x)[tag:%#x]" % [last_pos, last_pos, tag]
+        end
+      end
+    end
+
+    # parse attribute of a element
+    def parse_attribute
+      ns_id, name_id, val_str_id, flags, val = @io.read(4*5).unpack("V*")
+      key = @strings[name_id]
+      unless ns_id == 0xFFFFFFFF
+        ns = @strings[ns_id] 
+        prefix = ns.sub(/.*\//,'')
+        unless @ns.include? ns
+          @ns << ns
+          @doc.root.add_namespace(prefix, ns)
+        end
+        key = "#{prefix}:#{key}"
+      end
+      value = convert_value(val_str_id, flags, val)
+      return key, value
+    end
+
+
+    def convert_value(val_str_id, flags, val)
+      unless val_str_id == 0xFFFFFFFF
+        value = @strings[val_str_id]
+      else
+        type = flags >> 24
+        case type
+        when VAL_TYPE_NULL
+          value = nil
+        when VAL_TYPE_REFERENCE
+          value = "@%#x" % val # refered resource id.
+        when VAL_TYPE_INT_DEC
+          value = val
+        when VAL_TYPE_INT_HEX
+          value = "%#x" % val
+        when VAL_TYPE_INT_BOOLEAN
+          value = ((val == 0xFFFFFFFF) || (val==1)) ? true : false
+        else
+          value = "[%#x, flag=%#x]" % [val, flags]
+        end
+      end
+    end
+  end
+
+end

data/lib/android/dex.rb

@@ -0,0 +1,92 @@
+require_relative 'dex/dex_object'
+require_relative 'dex/info'
+require_relative 'dex/access_flag'
+require_relative 'dex/utils'
+
+module Android
+  # parsed dex object
+  # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+  # @attr_reader strings [Array<String>] strings in dex file.
+  class Dex
+    # @return [Dex::Header] dex header information
+    attr_reader :header
+    alias :h :header
+
+    # @return [String] dex binary data
+    attr_reader :data
+    # @return [Array<Dex::ClassInfo>] array of class information
+    attr_reader :classes
+
+    attr_reader :field_ids, :method_ids, :proto_ids
+    # @param [String] data dex binary data
+    def initialize(data)
+      @data = data
+      @data.force_encoding(Encoding::ASCII_8BIT)
+      @classes = []
+      parse()
+    end
+
+    def strings
+      @strings ||= @string_data_items.map{|item| item.to_s }
+    end
+
+    def inspect
+      "<Android::Dex @classes => #{@classes.size}, datasize => #{@data.size}>"
+    end
+
+
+    # @private
+    TYPE_DESCRIPTOR = { 
+      'V' => 'void',
+      'Z' => 'boolean',
+      'B' => 'byte',
+      'S' => 'short',
+      'C' => 'short',
+      'I' => 'int',
+      'J' => 'long',
+      'F' => 'float',
+      'D' => 'double'
+    }
+
+
+    def type_resolve(typeid)
+      type = strings[@type_ids[typeid]]
+      if type.start_with? '['
+        type = type[1..type.size]
+        return TYPE_DESCRIPTOR.fetch(type, type) + "[]" # TODO: recursive
+      else
+        return TYPE_DESCRIPTOR.fetch(type, type)
+      end
+    end
+
+
+    private
+    def parse
+      @header = DexObject::Header.new(@data)
+      @map_list = DexObject::MapList.new(@data, h[:map_off])
+
+      # parse strings
+      @string_ids = DexObject::StringIdItem.new(@data, h[:string_ids_off], h[:string_ids_size])
+      @string_data_items = []
+      @string_ids[:string_data_off].each { |off| @string_data_items << DexObject::StringDataItem.new(@data, off) }
+
+      @type_ids = DexObject::TypeIdItem.new(@data, h[:type_ids_off], h[:type_ids_size])
+      @proto_ids = ids_list_array(DexObject::ProtoIdItem, h[:proto_ids_off], h[:proto_ids_size])
+      @field_ids = ids_list_array(DexObject::FieldIdItem, h[:field_ids_off], h[:field_ids_size])
+      @method_ids = ids_list_array(DexObject::MethodIdItem, h[:method_ids_off], h[:method_ids_size])
+      @class_defs = ids_list_array(DexObject::ClassDefItem, h[:class_defs_off], h[:class_defs_size])
+
+      @classes = []
+      @class_defs.each do |cls_def|
+        @classes << ClassInfo.new(cls_def, self)
+      end
+    end
+
+    def ids_list_array(cls, offset, size)
+      ret_array = []
+      size.times { |i| ret_array << cls.new(@data, offset + cls.size * i) }
+      ret_array
+    end
+  end
+end
+

data/lib/android/dex/access_flag.rb

@@ -0,0 +1,74 @@
+
+module Android
+  class Dex
+    # access flag object
+    class AccessFlag
+      # @return [Integer] flag value
+      attr_reader :flag
+      def initialize(flag)
+        @flag = flag
+      end
+    end
+
+    # access flag object for class in dex
+    class ClassAccessFlag < AccessFlag
+      ACCESSORS = [
+        {value:0x1,     name:'public'},
+        {value:0x2,     name:'private'},
+        {value:0x4,     name:'protected'},
+        {value:0x8,     name:'static'},
+        {value:0x10,    name:'final'},
+        {value:0x20,    name:'synchronized'},
+        {value:0x40,    name:'volatile'},
+        {value:0x80,    name:'transient'},
+        {value:0x100,   name:'native'},
+        {value:0x200,   name:'interface'},
+        {value:0x400,   name:'abstract'},
+        {value:0x800,   name:'strict'},
+        {value:0x1000,  name:'synthetic'},
+        {value:0x2000,  name:'annotation'},
+        {value:0x4000,  name:'enum'},
+        #{value:0x8000,  name:'unused'},
+        {value:0x10000, name:'constructor'},
+        {value:0x20000, name:'declared-synchronized'},
+      ]
+
+      # convert access flag to string
+      # @return [String]
+      def to_s
+        ACCESSORS.select{|e| ((e[:value] & @flag) != 0) }.map{|e| e[:name] }.join(' ')
+      end
+    end
+   
+    # access flag object for method in dex
+    class MethodAccessFlag < AccessFlag
+      ACCESSORS = [
+        {value: 0x1,     name:'public'},
+        {value: 0x2,     name:'private'},
+        {value: 0x4,     name:'protected'},
+        {value: 0x8,     name:'static'},
+        {value: 0x10,    name:'final'},
+        {value: 0x20,    name:'synchronized'},
+        {value: 0x40,    name:'bridge'},
+        {value: 0x80,    name:'varargs'},
+        {value: 0x100,   name:'native'},
+        {value: 0x200,   name:'interface'},
+        {value: 0x400,   name:'abstract'},
+        {value: 0x800,   name:'strict'},
+        {value: 0x1000,  name:'synthetic'},
+        {value: 0x2000,  name:'annotation'},
+        {value: 0x4000,  name:'enum'},
+        #{value: 0x8000,  name:'unused'},
+        {value: 0x10000, name:'constructor'},
+        {value: 0x20000, name:'declared-synchronized'},
+      ]
+      # convert access flag to string
+      # @return [String]
+      def to_s
+        ACCESSORS.select{|e| ((e[:value] & @flag) != 0) }.map{|e| e[:name] }.join(' ')
+      end
+    end
+  end
+end
+
+

data/lib/android/dex/dex_object.rb

@@ -0,0 +1,475 @@
+
+module Android
+  class Dex
+    # parsing dex object
+    # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+    class DexObject
+      # @return [Integer] object size
+      attr_reader :size
+
+      def initialize(data, offset)
+        @data = data
+        @offset = offset
+
+        @params = {}
+        @parsing_off = 0 # parsing offset
+        parse()
+        @size = @parsing_off
+      end
+ 
+      # returns symbol keys
+      # @return [Array<Symbol>] header key
+      def symbols
+        @params.keys
+      end
+
+      # @param [Symbol] sym should be included in #symbols
+      # @return [Object] dex header value which is related with sym
+      def [](sym)
+        @params[sym.to_sym]
+      end
+
+      # @return [String]
+      def inspect
+        str = "<#{self.class}\n"
+        @params.each  do |key,val|
+          str.concat "    #{key}: #{val}\n"
+        end
+        str.concat '>'
+      end
+
+      private
+      def parse
+        raise 'this method should be overloaded.'
+      end
+
+      def read_value(type)
+        types = {
+          :byte   => [1, 'c'],
+          :ubyte  => [1, 'C'],
+          :short  => [2, 's'], #ugh!:depend on machine endian
+          :ushort => [2, 'v'],
+          :int    => [4, 'i'], #ugh!:depend on machine endian
+          :uint   => [4, 'V'],
+          :long   => [8, 'q'],
+          :ulong  => [8, 'Q'],
+        }
+        len, pack_str = types.fetch(type)
+        value = @data[@offset+@parsing_off, len].unpack(pack_str)[0]
+        @parsing_off += len
+        return value
+      end
+
+      # read short int from data buffer
+      # @return [Integer] short value
+      def read_sleb
+        value, len = Dex::sleb128(@data, @offset + @parsing_off)
+        @parsing_off += len
+        value
+      end
+      # read integer from data buffer
+      # @return [Integer] integer value
+      def read_uleb
+        value, len = Dex::uleb128(@data, @offset + @parsing_off)
+        @parsing_off += len
+        value
+      end
+      # read integer from data buffer and plus 1
+      # @return [Integer] integer value
+      def read_uleb128p1
+        value, len = Dex::uleb128p1(@data, @offset + @parsing_off)
+        @parsing_off += len
+        value
+      end
+      # read various values from data buffer as array
+      # @param [Symbol] type 
+      # @param [Integer] size num of data
+      # @return [Array] value array
+      def read_value_array(type, size)
+        ret_array = []
+        size.times { ret_array << read_value(type) }
+        ret_array
+      end
+      # read class values from data buffer as array
+      # @param [Class] cls target class
+      # @param [Integer] size num of data
+      # @return [Array<cls>] object array
+      def read_class_array(cls, size)
+        ret_array = []
+        size.times do
+          item = cls.new(@data, @offset + @parsing_off)
+          ret_array << item
+          @parsing_off += item.size
+        end
+        ret_array
+      end
+
+      public
+      # header_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class Header < DexObject
+        def initialize(data)
+          super(data, 0)
+        end
+
+        private
+        def parse
+          @params[:magic] = @data[0, 8]
+          @parsing_off += 8
+          @params[:checksum] = read_value(:uint)
+          @params[:signature] = @data[12, 20]
+          @parsing_off += 20
+          [
+            :file_size, :header_size, :endian_tag, :link_size, :link_off, :map_off,
+            :string_ids_size, :string_ids_off, :type_ids_size, :type_ids_off,
+            :proto_ids_size, :proto_ids_off, :field_ids_size, :field_ids_off,
+            :method_ids_size, :method_ids_off, :class_defs_size, :class_defs_off,
+            :data_size, :data_off
+          ].each do |key|
+            @params[key] = read_value(:uint)
+          end
+        end
+      end
+
+      # map_list
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class MapList < DexObject
+        private
+        def parse
+          @params[:size] = read_value(:uint)
+          @params[:list] = read_class_array(MapItem, @params[:size])
+        end
+      end
+
+      # map_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class MapItem < DexObject
+        private
+        def parse
+          @params[:type] = read_value(:short)
+          @params[:unused] = read_value(:short)
+          @params[:size] = read_value(:uint)
+          @params[:offset] = read_value(:uint)
+        end
+      end
+
+      # id_list
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class IdsList < DexObject
+        attr_reader :ids_size
+        def initialize(data, off, ids_size)
+          @ids_size = ids_size
+          super(data, off)
+        end
+      end
+
+      # string_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class StringIdItem < IdsList
+        private
+        def parse
+          @params[:string_data_off] = read_value_array(:uint, @ids_size)
+        end
+      end
+
+      # string_data_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class StringDataItem < DexObject
+        def to_s
+          @params[:data]
+        end
+        private
+        def mutf8_to_utf8(data, off, ulen)
+          mi = 0 # index of mutf8 data
+          codepoints = []
+          while ulen > 0 do
+            b0 = data[off + mi].ord
+            bu = (b0 & 0xf0) # b0's upper nibble
+            if (b0 & 0x80) == 0 # single byte encoding (0b0xxx_xxxx)
+              c = b0
+              mi += 1
+              ulen -= 1
+            elsif bu == 0xc0 || bu == 0xd0 # two-byte encoding (0b110x_xxxx)
+              b1 = data[off + mi + 1].ord
+              c = (b0 & 0x1f) << 6 | (b1 & 0x3f)
+              mi += 2
+              ulen -= 1
+            elsif bu == 0xe0 # three-byte encoding (0b1110_xxxx)
+              b1 = data[off + mi + 1].ord
+              b2 = data[off + mi + 2].ord
+              c = (b0 & 0x0f) << 12 | (b1 & 0x3f) << 6 | (b2 & 0x3f)
+              mi += 3
+              ulen -= 1
+              if 0xD800 <= c && c <= 0xDBFF  # this must be a surrogate pair
+                b4 = data[off + mi + 1].ord
+                b5 = data[off + mi + 2].ord
+                c = ((b1 & 0x0f) + 1) << 16 | (b2 & 0x3f) << 10 | (b4 & 0x0f) << 6 | (b5 & 0x3f)
+                mi += 3
+                ulen -= 1
+              end
+            else
+              STDERR.puts "unsupported byte: 0x#{'%02X' % b0} @#{mi}"
+              c = 0
+              mi += 1
+              next
+            end
+            if c != 0
+              codepoints << c
+            end
+          end
+          codepoints.pack("U*")
+        end
+        def parse
+          @params[:utf16_size] = read_uleb
+          @params[:data] = mutf8_to_utf8(@data, @offset + @parsing_off, @params[:utf16_size])
+        end
+      end
+
+      # type_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class TypeIdItem < IdsList
+        def [](idx)
+          raise ArgumentError if idx >= @params[:descriptor_idx].size or idx < 0
+          @params[:descriptor_idx][idx]
+        end
+
+        private
+        def parse
+          @params[:descriptor_idx] = read_value_array(:uint, @ids_size)
+        end
+      end
+
+      # proto_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class ProtoIdItem < DexObject
+        # return parse data size
+        # @return bytes
+        # @note this method for DexObject#read_class_array (private method)
+        def self.size
+          4 * 3
+        end
+        private
+        def parse
+          @params[:shorty_idx] = read_value(:uint)
+          @params[:return_type_idx] = read_value(:uint)
+          @params[:parameters_off] = read_value(:uint)
+        end
+      end
+
+      # field_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class FieldIdItem < DexObject
+        # return parse data size
+        # @return bytes
+        # @note this method for DexObject#read_class_array (private method)
+        def self.size
+          2 * 2 + 4 
+        end
+        private
+        def parse
+          @params[:class_idx] = read_value(:ushort)
+          @params[:type_idx] = read_value(:ushort)
+          @params[:name_idx] = read_value(:uint)
+        end
+      end
+
+      # method_id_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class MethodIdItem < DexObject
+        # return parse data size
+        # @return bytes
+        # @note this method for DexObject#read_class_array (private method)
+        def self.size
+          2 * 2 + 4 
+        end
+        def parse
+          @params[:class_idx] = read_value(:ushort)
+          @params[:proto_idx] = read_value(:ushort)
+          @params[:name_idx] = read_value(:uint)
+        end
+      end
+
+      # class_def_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      # @!attribute [r] class_data_item
+      #  @return [ClassDataItem] class_data_item of this class
+      class ClassDefItem < DexObject
+        # @return [Integer] bytes
+        def self.size
+          4 * 8
+        end
+
+        def class_data_item
+          # description of class_data_off of class_def_item.
+          #   offset from the start of the file to the associated class data
+          #   for this item, or 0 if there is no class data for this class.
+          if @params[:class_data_off] != 0
+            @class_data_item ||= ClassDataItem.new(@data, @params[:class_data_off])
+          else
+            nil
+          end
+        end
+
+        private
+        def parse
+          @params[:class_idx] = read_value(:uint)
+          @params[:access_flags] = read_value(:uint)
+          @params[:superclass_idx] = read_value(:uint)
+          @params[:interfaces_off] = read_value(:uint)
+          @params[:source_file_idx] = read_value(:uint)
+          @params[:annotations_off] = read_value(:uint)
+          @params[:class_data_off] = read_value(:uint)
+          @params[:static_values_off] = read_value(:uint) # TODO: not implemented encoded_array_item
+        end
+      end
+
+      # class_data_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class ClassDataItem < DexObject
+        private
+        def parse
+          @params[:static_fields_size] = read_uleb
+          @params[:instance_fields_size] = read_uleb
+          @params[:direct_methods_size] = read_uleb
+          @params[:virtual_methods_size] = read_uleb
+          @params[:static_fields] = read_class_array(EncodedField, @params[:static_fields_size])
+          @params[:instance_fields] = read_class_array(EncodedField, @params[:instance_fields_size])
+          @params[:direct_methods] = read_class_array(EncodedMethod, @params[:direct_methods_size])
+          @params[:virtual_methods] = read_class_array(EncodedMethod, @params[:virtual_methods_size])
+        end
+      end
+
+      # encoded_field
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class EncodedField < DexObject
+        private
+        def parse
+          @params[:field_idx_diff] = read_uleb
+          @params[:access_flags] = read_uleb
+        end
+      end
+
+      # encoded_method
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      # @!attribute [r] code_item
+      #  @return [CodeItem] code_item of the method
+      class EncodedMethod < DexObject
+        def code_item
+          # description of code_off in code_data_item.
+          #   offset from the start of the file to the code structure for this method,
+          #   or 0 if this method is either abstract or native.
+          unless @params[:code_off] == 0
+            @code_item ||= CodeItem.new(@data, @params[:code_off])
+          else
+            nil
+          end
+        end
+
+        private
+        def parse
+          @params[:method_idx_diff] = read_uleb
+          @params[:access_flags] = read_uleb
+          @params[:code_off] = read_uleb
+        end
+      end
+
+
+      # type_list
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class TypeList < DexObject
+        private
+        def parse
+          @params[:size] = read_value(:uint)
+          @params[:list] = read_value_array(:ushort, @params[:size])
+        end
+      end
+
+      # code_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      # @!attribute [r] debug_info_item
+      #  @return [DebugInfoItem] debug_info_item of this code
+      class CodeItem < DexObject
+        def debug_info_item
+          unless @params[:debug_info_off] == 0
+            @debug_info_item ||= DebugInfoItem.new(@data, @params[:debug_info_off])
+          else
+            nil
+          end
+        end
+
+        private
+        def parse
+          @params[:registers_size] = read_value(:ushort)
+          @params[:ins_size] = read_value(:ushort)
+          @params[:outs_size] = read_value(:ushort)
+          @params[:tries_size] = read_value(:ushort)
+          @params[:debug_info_off] = read_value(:uint)
+          @params[:insns_size] = read_value(:uint) # size of the instructions list
+          @params[:insns] = read_value_array(:ushort, @params[:insns_size])
+          read_value(:ushort) if ((@params[:insns_size] % 2) == 1) # for four-byte aligned
+          if @params[:tries_size] > 0
+            # This element is only present if tries_size is non-zero.
+            @params[:tries] = read_class_array(TryItem, @params[:tries_size])
+            # This element is only present if tries_size is non-zero.
+            @params[:handlers] = EncodedCatchHandlerList.new(@data, @offset + @parsing_off)
+            @parsing_off += @params[:handlers].size
+          end
+        end
+      end
+
+      # try_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class TryItem < DexObject
+        private
+        def parse
+          @params[:start_addr] = read_value(:uint)
+          @params[:insn_count] = read_value(:ushort)
+          @params[:handler_off] = read_value(:ushort)
+        end
+      end
+
+      # encoded_catch_handler_list
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class EncodedCatchHandlerList < DexObject
+        private
+        def parse
+          @params[:size] = read_uleb
+          @params[:list] = read_class_array(EncodedCatchHandler, @params[:size])
+        end
+      end
+
+      # encoded_catch_handler
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class EncodedCatchHandler < DexObject
+        private
+        def parse
+          @params[:size] = read_sleb
+          @params[:list] = read_class_array(EncodedTypeAddrPair, @params[:size].abs)
+          @params[:catch_all_addr] = read_uleb if @params[:size] <= 0
+        end
+      end
+
+      # encoded_type_addr_pair
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class EncodedTypeAddrPair < DexObject
+        private
+        def parse
+          @params[:type_idx] = read_uleb
+          @params[:addr] = read_uleb
+        end
+      end
+
+      # debug_info_item
+      # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+      class DebugInfoItem < DexObject
+        private
+        def parse
+          @params[:line_start] = read_uleb
+          @params[:parameters_size] = read_uleb
+          @params[:parameter_names] = []
+          @params[:parameters_size].times { @params[:parameter_names] << read_uleb128p1 }
+        end
+      end
+    end
+  end
+end