Mercurial > paraspace
annotate paraspace/dexfile.py @ 12:8101024c942b
Document class man_off
| author | Thinker K.F. Li <thinker@codemud.net> |
|---|---|
| date | Wed, 25 May 2011 01:15:07 +0800 |
| parents | 409e2cd76f72 |
| children | c05fac334ab1 |
| rev | line source |
|---|---|
| 0 | 1 class _DEX_header(object): |
| 2 magic = None # 0x00, 8 bytes | |
| 3 checksum = None # 0x08, 4 bytes | |
| 4 signature = None # 0x0c, 20 bytes | |
| 5 fileSize = None # 0x20, 4 bytes | |
| 6 headerSize = None # 0x24 | |
| 7 endianTag = None # 0x28 | |
| 8 linkSize = None # 0x2c | |
| 9 linkOff = None # 0x30 | |
| 10 mapOff = None # 0x34 | |
| 11 stringIdsSize = None # 0x38 | |
| 12 stringIdsOff = None # 0x3c | |
| 13 typeIdsSize = None # 0x40 | |
| 14 typeIdsOff = None # 0x44 | |
| 15 protoIdsSize = None # 0x48 | |
| 16 protoIdsOff = None # 0x4c | |
| 17 fieldIdsSize = None # 0x50 | |
| 18 fieldIdsOff = None # 0x54 | |
| 19 methodIdsSize = None # 0x58 | |
| 20 methodIdsOff = None # 0x5c | |
| 21 classDefsSize = None # 0x60 | |
| 22 classDefsOff = None # 0x64 | |
| 23 dataSize = None # 0x68 | |
| 24 dataOff = None # 0x6c | |
| 25 | |
| 2 | 26 header_fields = \ |
| 27 'magic checksum signature fileSize headerSize endianTag ' \ | |
| 28 'linkSize linkOff mapOff stringIdsSize stringIdsOff typeIdsSize ' \ | |
| 29 'typeIdsOff protoIdsSize protoIdsOff fieldIdsSize fieldIdsOff ' \ | |
| 30 'methodIdsSize methodIdsOff classDefsSize classDefsOff ' \ | |
| 31 'dataSize dataOff'.split() | |
| 32 | |
| 0 | 33 def parse(self, data): |
| 34 self.magic = data[:8] | |
| 35 self.checksum = data[8: 0x0c] | |
| 36 self.signature = data[0x0c: 0x20] | |
| 37 | |
| 38 idx = 0x20 | |
| 39 fields = 'fileSize headerSize endianTag linkSize linkOff mapOff ' \ | |
| 40 'stringIdsSize stringIdsOff typeIdsSize typeIdsOff ' \ | |
| 41 'protoIdsSize protoIdsOff fieldIdsSize fieldIdsOff ' \ | |
| 42 'methodIdsSize methodIdsOff classDefsSize classDefsOff ' \ | |
| 43 'dataSize dataOff'.split() | |
| 44 for field in fields: | |
| 45 d = data[idx: idx + 4] | |
| 46 value = _to_uint(d) | |
| 47 setattr(self, field, value) | |
| 48 idx = idx + 4 | |
| 49 pass | |
| 50 pass | |
| 51 pass | |
| 52 | |
| 53 | |
|
12
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
54 ## \brief Manage offset |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
55 # |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
56 # The instances are initialized with a offset. Every time an instance |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
57 # is called, it return the offset before advancing offset with specify |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
58 # size. |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
59 # |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
60 # moff = man_off(init_off) |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
61 # assert moff(5) == init_off |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
62 # assert moff() == (init_off + 5) |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
63 # assert moff() == (init_off + 5) |
|
8101024c942b
Document class man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
11
diff
changeset
|
64 # |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
65 class man_off(object): |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
66 off = None |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
67 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
68 def __init__(self, off): |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
69 self.off = off |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
70 pass |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
71 |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
72 def __call__(self, sz=0): |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
73 off = self.off |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
74 self.off = off + sz |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
75 return off |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
76 pass |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
77 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
78 |
| 0 | 79 def _to_uint(data): |
| 80 v = 0 | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
81 sh = 0 |
| 0 | 82 for c in data: |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
83 v = v + (ord(c) << sh) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
84 sh = sh + 8 |
| 0 | 85 pass |
| 86 return v | |
| 87 | |
| 88 | |
| 8 | 89 def _to_int(data): |
| 90 v = _to_uint(data) | |
| 91 sz = len(data) | |
| 92 if sz and ((1 << (sz * 8 - 1)) & v): | |
| 93 v = -((1 << (sz * 8)) - v) | |
| 94 pass | |
| 95 return v | |
| 96 | |
| 97 | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
98 def _uleb128(data): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
99 sh = 0 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
100 v = 0 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
101 for c in data: |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
102 cv = ord(c) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
103 v = v + ((cv & 0x7f) << sh) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
104 sh = sh + 7 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
105 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
106 if cv <= 0x7f: |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
107 break |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
108 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
109 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
110 nbytes = sh / 7 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
111 return v, nbytes |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
112 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
113 |
| 2 | 114 def _leb128(data): |
| 115 v, sh = _uleb128(data) | |
| 116 if v & (1 << (sh * 7 - 1)): | |
| 117 v = -((1 << (sh * 7)) - v) | |
| 118 pass | |
| 119 return v, sh | |
| 120 | |
| 121 | |
| 0 | 122 class _DEX_MapItem(object): |
| 123 type = None # 2 bytes | |
| 124 unused = None # 2 bytes | |
| 125 size = None # 4 bytes | |
| 126 offset = None # 4 bytes | |
| 127 | |
| 128 data_size = 12 | |
| 2 | 129 types = { |
| 130 0x0000: 'kDexTypeHeaderItem', | |
| 131 0x0001: 'kDexTypeStringIdItem', | |
| 132 0x0002: 'kDexTypeTypeIdItem', | |
| 133 0x0003: 'kDexTypeProtoIdItem', | |
| 134 0x0004: 'kDexTypeFieldIdItem', | |
| 135 0x0005: 'kDexTypeMethodIdItem', | |
| 136 0x0006: 'kDexTypeClassDefItem', | |
| 137 0x1000: 'kDexTypeMapList', | |
| 138 0x1001: 'kDexTypeTypeList', | |
| 139 0x1002: 'kDexTypeAnnotationSetRefList', | |
| 140 0x1003: 'kDexTypeAnnotationSetItem', | |
| 141 0x2000: 'kDexTypeClassDataItem', | |
| 142 0x2001: 'kDexTypeCodeItem', | |
| 143 0x2002: 'kDexTypeStringDataItem', | |
| 144 0x2003: 'kDexTypeDebugInfoItem', | |
| 145 0x2004: 'kDexTypeAnnotationItem', | |
| 146 0x2005: 'kDexTypeEncodedArrayItem', | |
| 147 0x2006: 'kDexTypeAnnotationsDirectoryItem' | |
| 148 } | |
| 0 | 149 |
| 150 def parse(self, data): | |
| 151 self.type = _to_uint(data[:2]) | |
| 152 self.size = _to_uint(data[4:8]) | |
| 153 self.offset = _to_uint(data[8:12]) | |
| 154 pass | |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
155 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
156 @classmethod |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
157 def find_type_name(self, type_name): |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
158 type_value = [v |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
159 for v, name in _DEX_MapItem.types.items() |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
160 if name == type_name][0] |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
161 return type_value |
| 0 | 162 pass |
| 163 | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
164 |
| 0 | 165 class _DEX_TypeId(object): |
| 166 descriptorIdx = None # 4 bytes | |
| 167 | |
| 168 data_size = 4 | |
| 169 | |
| 170 def parse(self, data): | |
| 171 self.descriptorIdx = _to_uint(data[:4]) | |
| 172 pass | |
| 173 pass | |
| 174 | |
| 175 | |
| 176 class _DEX_ProtoId(object): | |
| 177 shortyIdx = None # 4 bytes | |
| 178 returnTypeIdx = None # 4 bytes | |
| 179 parametersOff = None # 4 bytes | |
| 180 | |
| 181 data_size = 12 | |
| 182 | |
| 183 def parse(self, data): | |
| 184 self.shortyIdx = _to_uint(data[:4]) | |
| 185 self.returnTypeIdx = _to_uint(data[4:8]) | |
| 186 self.parametersOff = _to_uint(data[8:12]) | |
| 187 pass | |
| 188 pass | |
| 189 | |
| 190 | |
| 191 class _DEX_FieldId(object): | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
192 classIdx = None # 2 bytes |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
193 typeIdx = None # 2 bytes |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
194 nameIdx = None # 4 bytes |
| 0 | 195 |
| 196 data_size = 8 | |
| 197 | |
| 198 def parse(self, data): | |
| 199 self.classIdx = _to_uint(data[:2]) | |
| 200 self.typeIdx = _to_uint(data[2:4]) | |
| 201 self.nameIdx = _to_uint(data[4:8]) | |
| 202 pass | |
| 203 pass | |
| 204 | |
| 205 | |
| 206 class _DEX_MethodId(object): | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
207 classIdx = None # 2 bytes |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
208 protoIdx = None # 2 bytes |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
209 nameIdx = None # 4 bytes |
| 0 | 210 |
| 211 data_size = 8 | |
| 212 | |
| 213 def parse(self, data): | |
| 214 self.classIdx = _to_uint(data[:2]) | |
| 215 self.protoIdx = _to_uint(data[2:4]) | |
| 216 self.nameIdx = _to_uint(data[4:8]) | |
| 217 pass | |
| 218 pass | |
| 219 | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
220 |
| 0 | 221 class _DEX_ClassDef(object): |
| 222 classIdx = None # 0x00 | |
| 223 accessFlags = None # 0x04 | |
| 224 superclassIdx = None # 0x08 | |
| 225 interfacesOff = None # 0x0c | |
| 226 sourceFileIdx = None # 0x10 | |
| 227 annotationsOff = None # 0x14 | |
| 228 classDataOff = None # 0x18 | |
| 229 staticValuesOff = None # 0x1c | |
| 230 | |
| 231 data_size = 0x20 | |
| 232 | |
| 233 def parse(self, data): | |
| 234 self.classIdx = _to_uint(data[:4]) | |
| 235 self.accessFlags = _to_uint(data[4:8]) | |
| 236 self.superclassIdx = _to_uint(data[8:0xc]) | |
| 237 self.interfacesOff = _to_uint(data[0xc:0x10]) | |
| 238 self.sourceFileIdx = _to_uint(data[0x10:0x14]) | |
| 239 self.annotationsOff = _to_uint(data[0x14:0x18]) | |
| 240 self.classDataOff = _to_uint(data[0x18:0x1c]) | |
| 241 self.staticValuesOff = _to_uint(data[0x1c:0x20]) | |
| 242 pass | |
| 243 pass | |
| 244 | |
| 245 | |
| 2 | 246 class _DEX_ClassDataHeader(object): |
| 247 staticFieldsSize = None | |
| 248 instanceFieldsSize = None | |
| 249 directMethodsSize = None | |
| 250 virtualMethodsSize = None | |
| 251 | |
| 252 data_size = None | |
| 253 | |
| 254 def parse(self, data, off): | |
| 255 self.staticFieldsSize, sh = _uleb128(data[off:off + 10]) | |
| 256 sz = sh | |
| 257 off = off + sh | |
| 258 self.instanceFieldsSize, sh = _uleb128(data[off:off + 10]) | |
| 259 sz = sz + sh | |
| 260 off = off + sh | |
| 261 self.directMethodsSize, sh = _uleb128(data[off:off + 10]) | |
| 262 sz = sz + sh | |
| 263 off = off + sh | |
| 264 self.virtualMethodsSize, sh = _uleb128(data[off:off + 10]) | |
| 265 sz = sz + sh | |
| 266 | |
| 267 self.data_size = sz | |
| 268 pass | |
| 269 pass | |
| 270 | |
| 271 | |
| 272 class _DEX_Field(object): | |
| 273 fieldIdx = None | |
| 274 accessFlags = None | |
| 275 | |
| 276 data_size = None | |
| 277 | |
| 278 def parse(self, data, off): | |
| 279 self.fieldIdx, sh = _uleb128(data[off:off + 10]) | |
| 280 sz = sh | |
| 281 off = off + sh | |
| 282 self.accessFlags, sh = _uleb128(data[off:off + 10]) | |
| 283 sz = sz + sh | |
| 284 | |
| 285 self.data_size = sz | |
| 286 pass | |
| 287 pass | |
| 288 | |
| 289 | |
| 290 class _DEX_Method(object): | |
| 291 methodIdx = None | |
| 292 accessFlags = None | |
| 293 codeOff = None | |
| 294 | |
| 295 data_size = None | |
| 296 | |
| 297 def parse(self, data, off): | |
| 298 self.methodIdx, sh = _uleb128(data[off:off + 10]) | |
| 299 sz = sh | |
| 300 off = off + sh | |
| 301 | |
| 302 self.accessFlags, sh = _uleb128(data[off:off + 10]) | |
| 303 sz = sz + sh | |
| 304 off = off + sh | |
| 305 | |
| 306 self.codeOff, sh = _uleb128(data[off:off + 10]) | |
| 307 sz = sz + sh | |
| 308 | |
| 309 self.data_size = sz | |
| 310 pass | |
| 311 pass | |
| 312 | |
| 313 class _DEX_ClassData(object): | |
| 314 header = None # DexClassDataHeader | |
| 315 staticFields = None # DexField* | |
| 316 instanceFields = None # DexField* | |
| 317 directMethods = None # DexMethod* | |
| 318 virtualMethods = None # DexMethod* | |
| 319 | |
| 320 data_size = None | |
| 321 | |
| 322 def parse(self, data, off): | |
| 323 header = _DEX_ClassDataHeader() | |
| 324 header.parse(data, off) | |
| 325 self.header = header | |
| 326 | |
| 327 cur_off = [off + header.data_size] | |
| 328 | |
| 329 def parse_field(): | |
| 330 field = _DEX_Field() | |
| 331 off = cur_off[0] | |
| 332 field.parse(data, off) | |
| 333 cur_off[0] = cur_off[0] + field.data_size | |
| 334 | |
| 335 # | |
| 336 # field index depends previous one to reduce size | |
| 337 # | |
| 338 field.fieldIdx = field.fieldIdx + idx[0] | |
| 339 idx[0] = field.fieldIdx | |
| 340 | |
| 341 return field | |
| 342 | |
| 343 def parse_method(): | |
| 344 method = _DEX_Method() | |
| 345 off = cur_off[0] | |
| 346 method.parse(data, off) | |
| 347 cur_off[0] = cur_off[0] + method.data_size | |
| 348 | |
| 349 # | |
| 350 # method index depends previous one to reduce size | |
| 351 # | |
| 352 method.methodIdx = method.methodIdx + idx[0] | |
| 353 idx[0] = method.methodIdx | |
| 354 | |
| 355 return method | |
| 356 | |
| 357 idx = [0] | |
| 358 self.staticFields = [parse_field() | |
| 359 for i in range(header.staticFieldsSize)] | |
| 360 idx = [0] | |
| 361 self.instanceFields = [parse_field() | |
| 362 for i in range(header.instanceFieldsSize)] | |
| 363 idx = [0] | |
| 364 self.directMethods = [parse_method() | |
| 365 for i in range(header.directMethodsSize)] | |
| 366 idx = [0] | |
| 367 self.virtualMethods = [parse_method() | |
| 368 for i in range(header.virtualMethodsSize)] | |
| 369 | |
| 370 self.data_size = cur_off[0] - off | |
| 371 pass | |
| 372 pass | |
| 373 | |
| 374 | |
|
6
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
375 class _DEX_TypeItem(object): |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
376 typeIdx = None # 2 bytes |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
377 |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
378 data_size = 2 |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
379 |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
380 def parse(self, data, off): |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
381 self.typeIdx = _to_uint(data[off:off + 2]) |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
382 pass |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
383 pass |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
384 |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
385 |
| 2 | 386 class _DEX_TypeList(object): |
| 387 typeItems = None | |
| 388 | |
| 389 data_size = None | |
| 390 | |
| 391 def parse(self, data, off): | |
|
6
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
392 moff = man_off(off) |
| 2 | 393 |
|
6
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
394 size = _to_uint(data[moff(4):moff()]) |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
395 |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
396 def parse_type_item(): |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
397 item = _DEX_TypeItem() |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
398 item.parse(data, moff()) |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
399 moff(item.data_size) |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
400 return item |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
401 |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
402 typeItems = [parse_type_item() |
|
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
403 for i in range(size)] |
| 2 | 404 |
| 405 self.typeItems = typeItems | |
|
6
917f0a9b9d06
Refactor _DEX_TypeItem from _DEX_TypeList for layout info tracking
Thinker K.F. Li <thinker@codemud.net>
parents:
5
diff
changeset
|
406 self.data_size = moff() - off |
| 2 | 407 pass |
| 408 pass | |
| 409 | |
| 410 | |
| 411 class _DEX_TypeLists(object): | |
| 412 typeLists = None | |
| 413 | |
| 414 data_size = None | |
| 415 | |
| 416 def parse(self, num, data, off): | |
| 417 def parse(): | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
418 off = (cur_off[0] + 3) & ~0x3 # type list must aligned for 4 bytes |
| 2 | 419 typeList = _DEX_TypeList() |
| 420 typeList.parse(data, off) | |
| 421 cur_off[0] = off + typeList.data_size | |
| 422 | |
| 423 return typeList | |
| 424 | |
| 425 cur_off = [off] | |
| 426 typeLists = [parse() for i in range(num)] | |
| 427 | |
| 428 self.typeLists = typeLists | |
| 429 self.data_size = cur_off[0] - off | |
| 430 pass | |
| 431 pass | |
| 432 | |
| 433 | |
| 434 class _DEX_Try(object): | |
| 435 startAddr = None # 4 bytes | |
| 436 insnCount = None # 2 bytes | |
| 437 handlerOff = None # 2 bytes | |
| 438 | |
| 439 data_size = 8 | |
| 440 | |
| 441 def parse(self, data, off): | |
| 442 cur_off = off | |
| 443 self.startAddr = _to_uint(data[cur_off:cur_off + 4]) | |
| 444 cur_off = cur_off + 4 | |
| 445 self.insnCount = _to_uint(data[cur_off:cur_off + 2]) | |
| 446 cur_off = cur_off + 2 | |
| 447 self.handlerOff = _to_uint(data[cur_off:cur_off + 2]) | |
| 448 pass | |
| 449 pass | |
| 450 | |
| 451 | |
| 452 class _DEX_CatchHandler(object): | |
| 453 typeIdx = None | |
| 454 address = None | |
| 455 | |
| 456 data_size = None | |
| 457 | |
| 458 def parse(self, data, off): | |
| 459 cur_off = off | |
| 460 self.typeIdx, sh = _uleb128(data[cur_off:cur_off + 5]) | |
| 461 cur_off = cur_off + sh | |
| 462 self.address, sh = _uleb128(data[cur_off:cur_off + 5]) | |
| 463 cur_off = cur_off + sh | |
| 464 | |
| 465 self.data_size = cur_off - off | |
| 466 pass | |
| 467 | |
| 468 def parse1(self, data, off): | |
| 469 self.address, sh = _uleb128(data[off:off + 5]) | |
| 470 | |
| 471 self.data_size = sh | |
| 472 pass | |
| 473 pass | |
| 474 | |
| 475 | |
| 476 class _DEX_Catch(object): | |
| 477 catchesAll = None | |
| 478 handlers = None | |
| 479 | |
| 480 data_size = None | |
| 481 | |
| 482 def parse(self, data, off): | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
483 moff = man_off(off) |
| 2 | 484 |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
485 count, sh = _leb128(data[moff():moff() + 5]) |
| 2 | 486 moff(sh) |
| 487 | |
| 488 if count > 0: | |
| 489 self.catchesAll = False | |
| 490 else: | |
| 491 self.catchesAll = True | |
| 492 count = -count | |
| 493 pass | |
| 494 | |
| 495 def parse_handler(): | |
| 496 handler = _DEX_CatchHandler() | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
497 handler.parse(data, moff()) |
| 2 | 498 moff(handler.data_size) |
| 499 return handler | |
| 500 | |
| 501 self.handlers = [parse_handler() for i in range(count)] | |
| 502 | |
| 503 if self.catchesAll: | |
| 504 # | |
| 505 # Additional handler for catching all | |
| 506 # | |
| 507 handler = _DEX_CatchHandler() | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
508 handler.parse1(data, moff()) |
| 2 | 509 moff(handler.data_size) |
| 510 self.handlers.append(handler) | |
| 511 pass | |
| 512 | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
513 self.data_size = moff() - off |
| 2 | 514 pass |
| 515 pass | |
| 516 | |
| 517 | |
| 518 class _DEX_Code(object): | |
| 519 registersSize = None # 2 bytes | |
| 520 insSize = None # 2 bytes | |
| 521 outsSize = None # 2 bytes | |
| 522 triesSize = None # 2 bytes | |
| 523 debugInfoOff = None # 4 bytes | |
| 524 insnsSize = None # 4 bytes | |
| 525 insns = None | |
| 526 try_items = None | |
| 527 catch_handler_items = None | |
| 528 | |
| 529 data_size = None | |
| 530 | |
| 531 def parse(self, data, off): | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
532 moff = man_off(off) |
| 2 | 533 |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
534 self.registersSize = _to_uint(data[moff(2):moff()]) |
|
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
535 self.insSize = _to_uint(data[moff(2):moff()]) |
|
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
536 self.outsSize = _to_uint(data[moff(2):moff()]) |
|
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
537 self.triesSize = _to_uint(data[moff(2):moff()]) |
|
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
538 self.debugInfoOff = _to_uint(data[moff(4):moff()]) |
|
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
539 self.insnsSize = _to_uint(data[moff(4):moff()]) |
| 2 | 540 |
| 541 moff(self.insnsSize * 2) # skip insns | |
| 542 | |
| 543 if self.triesSize > 0: | |
| 544 def parse_try_item(): | |
| 545 try_item = _DEX_Try() | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
546 try_item.parse(data, moff()) |
| 2 | 547 moff(try_item.data_size) |
| 548 return try_item | |
| 549 | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
550 moff.off = (moff.off + 3) & ~0x3 # align tries to 4 bytes |
| 2 | 551 self.try_items = [parse_try_item() for i in range(self.triesSize)] |
| 552 | |
| 553 def parse_catch_handler(): | |
| 554 catch = _DEX_Catch() | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
555 catch.parse(data, moff()) |
| 2 | 556 moff(catch.data_size) |
| 557 return catch | |
| 558 | |
| 559 # | |
| 560 # No tries, no catch handlers | |
| 561 # | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
562 handlersSize, sh = _uleb128(data[moff():moff() + 5]) |
| 2 | 563 moff(sh) |
| 564 self.catch_handler_items = [parse_catch_handler() | |
| 565 for i in range(handlersSize)] | |
| 566 pass | |
| 567 | |
|
5
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
568 moff.off = (moff() + 3) & ~0x3 # round code item to 4 bytes |
|
97b7006ced5f
Move move_off imps. to man_off
Thinker K.F. Li <thinker@codemud.net>
parents:
4
diff
changeset
|
569 self.data_size = moff() - off |
| 2 | 570 pass |
| 571 pass | |
| 572 | |
| 573 | |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
574 ## \brief File offset to Annotation item. |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
575 # |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
576 # This type is not in libdex of Dalvik. We add this class to tracking |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
577 # information for layout algorithm. |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
578 # |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
579 class _DEX_AnnotationRefItem(object): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
580 annotationOff = None # 4 bytes |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
581 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
582 data_size = 4 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
583 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
584 def parse(self, data, off): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
585 self.annotationOff = _to_uint(data[off:off + 4]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
586 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
587 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
588 |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
589 class _DEX_AnnotationSetItem(object): |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
590 # size = None # 4 bytes |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
591 annotations = None # 4 * size bytes |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
592 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
593 data_size = None |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
594 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
595 def parse(self, data, off): |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
596 moff = man_off(off) |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
597 |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
598 size = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
599 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
600 def parse_annotation_ref(): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
601 ref = _DEX_AnnotationRefItem() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
602 ref.parse(data, moff()) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
603 moff(ref.data_size) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
604 return ref |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
605 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
606 self.annotations = [parse_annotation_ref() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
607 for i in range(size)] |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
608 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
609 self.data_size = moff() - off |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
610 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
611 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
612 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
613 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
614 class _DEX_FieldAnnotationsItem(object): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
615 fieldIdx = None # 4 bytes |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
616 annotationsOff = None # 4 bytes |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
617 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
618 data_size = 8 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
619 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
620 def parse(self, data, off): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
621 moff = man_off(off) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
622 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
623 self.fieldIdx = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
624 self.annotationsOff = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
625 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
626 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
627 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
628 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
629 class _DEX_MethodAnnotationsItem(object): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
630 methodIdx = None # 4 bytes |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
631 annotationsOff = None # 4 bytes |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
632 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
633 data_size = 8 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
634 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
635 def parse(self, data, off): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
636 moff = man_off(off) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
637 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
638 self.methodIdx = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
639 self.annotationsOff = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
640 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
641 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
642 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
643 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
644 class _DEX_ParameterAnnotationsItem(object): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
645 methodIdx = None # 4 bytes |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
646 annotationsOff = None # 4 bytes |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
647 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
648 data_size = 8 |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
649 |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
650 def parse(self, data, off): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
651 moff = man_off(off) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
652 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
653 self.methodIdx = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
654 self.annotationsOff = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
655 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
656 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
657 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
658 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
659 class _DEX_AnnotationsDirectoryItem(object): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
660 classAnnotationsOff = None # 4 bytes |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
661 fieldAnnotationsItems = None |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
662 methodAnnotationsItems = None |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
663 parameterAnnotationsItems = None |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
664 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
665 data_size = None |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
666 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
667 def parse(self, data, off): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
668 moff = man_off(off) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
669 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
670 self.classAnnotationsOff = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
671 fieldsSize = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
672 methodsSize = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
673 parametersSize = _to_uint(data[moff(4):moff()]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
674 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
675 def parse_fieldAnnotationsItem(): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
676 item = _DEX_FieldAnnotationsItem() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
677 item.parse(data, moff()) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
678 moff(item.data_size) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
679 return item |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
680 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
681 def parse_methodAnnotationsItem(): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
682 item = _DEX_MethodAnnotationsItem() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
683 item.parse(data, moff()) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
684 moff(item.data_size) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
685 return item |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
686 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
687 def parse_parameterAnnotationsItem(): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
688 item = _DEX_ParameterAnnotationsItem() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
689 item.parse(data, moff()) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
690 moff(item.data_size) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
691 return item |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
692 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
693 self.fieldAnnotationsItems = [parse_fieldAnnotationsItem() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
694 for i in range(fieldsSize)] |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
695 self.methodAnnotationsItems = [parse_methodAnnotationsItem() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
696 for i in range(methodsSize)] |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
697 self.parameterAnnotationsItems = [parse_parameterAnnotationsItem() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
698 for i in range(parametersSize)] |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
699 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
700 self.data_size = moff() - off |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
701 pass |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
702 pass |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
703 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
704 |
| 8 | 705 ## |
| 706 # | |
| 707 # \see createAnnotationMember() in dalvik/vm/reflect/Annotation.c | |
| 708 # | |
| 709 class _DEX_AnnotationMember(object): | |
| 710 nameIdx = None # optional | |
| 711 valueType = None # 1 byte | |
| 712 value = None | |
| 713 | |
| 714 # | |
| 715 # Constants from DexFile.h | |
| 716 # | |
| 717 kDexAnnotationByte = 0x00 | |
| 718 kDexAnnotationShort = 0x02 | |
| 719 kDexAnnotationChar = 0x03 | |
| 720 kDexAnnotationInt = 0x04 | |
| 721 kDexAnnotationLong = 0x06 | |
| 722 kDexAnnotationFloat = 0x10 | |
| 723 kDexAnnotationDouble = 0x11 | |
| 724 kDexAnnotationString = 0x17 | |
| 725 kDexAnnotationType = 0x18 | |
| 726 kDexAnnotationField = 0x19 | |
| 727 kDexAnnotationMethod = 0x1a | |
| 728 kDexAnnotationEnum = 0x1b | |
| 729 kDexAnnotationArray = 0x1c | |
| 730 kDexAnnotationAnnotation = 0x1d | |
| 731 kDexAnnotationNull = 0x1e | |
| 732 kDexAnnotationBoolean = 0x1f | |
| 733 | |
| 734 kDexAnnotationValueTypeMask = 0x1f | |
| 735 kDexAnnotationValueArgShift = 5 | |
| 736 | |
| 737 data_size = None | |
| 738 | |
| 739 def parse(self, data, off): | |
| 740 self.nameIdx, sh = _uleb128(data[off:off + 5]) | |
| 741 | |
| 742 self.parse_noname(data, off + sh) | |
| 743 | |
| 744 self.data_size = self.data_size + sh | |
| 745 pass | |
| 746 | |
| 747 def parse_noname(self, data, off): | |
| 748 moff = man_off(off) | |
| 749 | |
| 750 valueType = _to_uint(data[moff(1):moff()]) | |
| 751 self.valueType = valueType | |
| 752 width = valueType >> self.kDexAnnotationValueArgShift | |
| 753 | |
| 754 vtype = valueType & self.kDexAnnotationValueTypeMask | |
| 755 | |
| 756 if vtype == self.kDexAnnotationByte: | |
| 757 self.value = _to_int(data[moff(width):moff()]) | |
| 758 moff(1) | |
| 759 pass | |
| 760 elif vtype == self.kDexAnnotationShort: | |
| 761 self.value = _to_int(data[moff(width):moff()]) | |
| 762 pass | |
| 763 elif vtype == self.kDexAnnotationChar: | |
| 764 self.value = _to_uint(data[moff(width):moff()]) | |
| 765 moff(1) | |
| 766 pass | |
| 767 elif vtype == self.kDexAnnotationInt: | |
| 768 self.value = _to_int(data[moff(width):moff()]) | |
| 769 moff(1) | |
| 770 pass | |
| 771 elif vtype == self.kDexAnnotationLong: | |
| 772 self.value = _to_int(data[moff(width):moff()]) | |
| 773 moff(1) | |
| 774 pass | |
| 775 elif vtype == self.kDexAnnotationFloat: | |
| 776 self.value = _to_uint(data[moff(width):moff()]) | |
| 777 moff(1) | |
| 778 pass | |
| 779 elif vtype == self.kDexAnnotationDouble: | |
| 780 self.value = _to_uint(data[moff(width):moff()]) | |
| 781 moff(1) | |
| 782 pass | |
| 783 elif vtype == self.kDexAnnotationBoolean: | |
| 784 self.value = width != 0 | |
| 785 pass | |
| 786 elif vtype == self.kDexAnnotationString: # string index | |
| 787 self.value = _to_uint(data[moff(width):moff()]) | |
| 788 moff(1) | |
| 789 pass | |
| 790 elif vtype == self.kDexAnnotationType: # TypeId index | |
| 791 self.value = _to_uint(data[moff(width):moff()]) | |
| 792 moff(1) | |
| 793 pass | |
| 794 elif vtype == self.kDexAnnotationMethod: # MethodId index | |
| 795 self.value = _to_uint(data[moff(width):moff()]) | |
| 796 moff(1) | |
| 797 pass | |
| 798 elif vtype == self.kDexAnnotationField: | |
| 799 self.value = _to_uint(data[moff(width):moff()]) | |
| 800 moff(1) | |
| 801 pass | |
| 802 elif vtype == self.kDexAnnotationEnum: # FieldId index | |
| 803 self.value = _to_uint(data[moff(width):moff()]) | |
| 804 moff(1) | |
| 805 pass | |
| 806 elif vtype == self.kDexAnnotationArray: | |
| 807 size, sh = _uleb128(data[moff():moff() + 5]) | |
| 808 moff(sh) | |
| 809 | |
| 810 def parse_array_elm(): | |
| 811 elm = _DEX_AnnotationMember() | |
| 812 elm.parse_noname(data, moff()) | |
| 813 moff(elm.data_size) | |
| 814 return elm | |
| 815 | |
| 816 self.value = [parse_array_elm() | |
| 817 for i in range(size)] | |
| 818 pass | |
| 819 elif vtype == self.kDexAnnotationAnnotation: | |
| 820 annoitem = _DEX_AnnotationItem() | |
| 821 annoitem.parse_novisibility(data, moff()) | |
| 822 moff(annoitem.data_size) | |
| 823 self.value = annoitem | |
| 824 pass | |
| 825 elif vtype == self.kDexAnnotationNull: | |
| 826 self.value = 0 | |
| 827 pass | |
| 828 else: | |
| 829 raise ValueError, \ | |
| 830 'Bad annotation element value byte 0x02x' % (valueType) | |
| 831 | |
| 832 self.data_size = moff() - off | |
| 833 pass | |
| 834 pass | |
| 835 | |
| 836 | |
| 837 ## \brief Annotation item | |
| 838 # | |
| 839 # \see processEncodedAnnotation() in dalvik/vm/reflect/Annotation.c | |
| 840 # | |
| 841 class _DEX_AnnotationItem(object): | |
| 842 visibility = None # 1 byte (optional) | |
| 843 typeIdx = None | |
| 844 members = None | |
| 845 | |
| 846 kDexVisibilityBuild = 0x00 | |
| 847 kDexVisibilityRuntime = 0x01 | |
| 848 kDexVisibilitySystem = 0x02 | |
| 849 | |
| 850 data_size = None | |
| 851 | |
| 852 def parse(self, data, off): | |
| 853 self.visibility = _to_uint(data[off:off + 1]) | |
| 854 | |
| 855 self.parse_novisibility(data, off + 1) | |
| 856 | |
| 857 self.data_size = self.data_size + 1 | |
| 858 pass | |
| 859 | |
| 860 def parse_novisibility(self, data, off): | |
| 861 moff = man_off(off) | |
| 862 | |
| 863 self.typeIdx, sh = _uleb128(data[moff():moff() + 5]) | |
| 864 moff(sh) | |
| 865 size, sh = _uleb128(data[moff():moff() + 5]) | |
| 866 moff(sh) | |
| 867 | |
| 868 def parse_AnnotationMemmber(): | |
| 869 member = _DEX_AnnotationMember() | |
| 870 member.parse(data, moff()) | |
| 871 moff(member.data_size) | |
| 872 return member | |
| 873 | |
| 874 self.members = [parse_AnnotationMemmber() | |
| 875 for i in range(size)] | |
| 876 | |
| 877 self.data_size = moff() - off | |
| 878 pass | |
| 879 pass | |
| 880 | |
| 881 | |
|
10
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
882 class _DEX_EncodedArrayItem(object): |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
883 elements = None |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
884 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
885 data_size = None |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
886 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
887 def parse(self, data, off): |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
888 moff = man_off(off) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
889 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
890 size, sh = _uleb128(data[moff():moff() + 5]) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
891 moff(sh) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
892 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
893 def parse_element(): |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
894 element = _DEX_AnnotationMember() |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
895 element.parse_noname(data, moff()) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
896 moff(element.data_size) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
897 return element |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
898 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
899 self.elements = [parse_element() |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
900 for i in range(size)] |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
901 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
902 self.data_size = moff() - off |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
903 pass |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
904 pass |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
905 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
906 |
| 11 | 907 class _DEX_DebugInfoItem(object): |
| 908 start_line = None | |
| 909 parameters = None | |
| 910 opcodes = None | |
| 911 | |
| 912 DBG_END_SEQUENCE = 0x00 | |
| 913 DBG_ADVANCE_PC = 0x01 | |
| 914 DBG_ADVANCE_LINE = 0x02 | |
| 915 DBG_START_LOCAL = 0x03 | |
| 916 DBG_START_LOCAL_EXTENDED = 0x04 | |
| 917 DBG_END_LOCAL = 0x05 | |
| 918 DBG_RESTART_LOCAL = 0x06 | |
| 919 DBG_SET_PROLOGUE_END = 0x07 | |
| 920 DBG_SET_EPILOGUE_BEGIN = 0x08 | |
| 921 DBG_SET_FILE = 0x09 | |
| 922 DBG_FIRST_SPECIAL = 0x0a | |
| 923 DBG_LINE_BASE = -4 | |
| 924 DBG_LINE_RANGE = 15 | |
| 925 | |
| 926 data_size = None | |
| 927 | |
| 928 def parse(self, data, off): | |
| 929 moff = man_off(off) | |
| 930 | |
| 931 self.start_line, sh = _uleb128(data[moff():moff() + 5]) | |
| 932 moff(sh) | |
| 933 parameters_size, sh = _uleb128(data[moff():moff() + 5]) | |
| 934 moff(sh) | |
| 935 | |
| 936 # | |
| 937 # Parse parameters | |
| 938 # | |
| 939 def parse_parameter(): | |
| 940 paramter, sh = _uleb128(data[moff():moff() + 5]) | |
| 941 moff(sh) | |
| 942 return paramter | |
| 943 | |
| 944 self.parameters = [parse_parameter() | |
| 945 for i in range(parameters_size)] | |
| 946 | |
| 947 # | |
| 948 # Parse debug opcodes | |
| 949 # | |
| 950 opcodes = [] | |
| 951 while True: | |
| 952 opcode = _to_uint(data[moff(1):moff()]) | |
| 953 | |
| 954 if opcode == self.DBG_END_SEQUENCE: | |
| 955 opcodes.append((opcode,)) | |
| 956 break | |
| 957 elif opcode == self.DBG_ADVANCE_PC: | |
| 958 adv, sh = _uleb128(data[moff():moff() + 5]) | |
| 959 moff(sh) | |
| 960 opcodes.append((opcode, adv)) | |
| 961 pass | |
| 962 elif opcode == self.DBG_ADVANCE_LINE: | |
| 963 adv, sh = _uleb128(data[moff():moff() + 5]) | |
| 964 moff(sh) | |
| 965 opcodes.append((opcode, adv)) | |
| 966 pass | |
| 967 elif opcode in (self.DBG_START_LOCAL, | |
| 968 self.DBG_START_LOCAL_EXTENDED): | |
| 969 reg, sh = _uleb128(data[moff():moff() + 5]) | |
| 970 moff(sh) | |
| 971 name, sh = _uleb128(data[moff():moff() + 5]) | |
| 972 moff(sh) | |
| 973 descriptor, sh = _uleb128(data[moff():moff() + 5]) | |
| 974 moff(sh) | |
| 975 if opcode == self.DBG_START_LOCAL_EXTENDED: | |
| 976 signature, sh = _uleb128(data[moff():moff() + 5]) | |
| 977 moff(sh) | |
| 978 opcodes.append((opcode, reg, name, descriptor, signature)) | |
| 979 else: | |
| 980 opcodes.append((opcode, reg, name, descriptor)) | |
| 981 pass | |
| 982 pass | |
| 983 elif opcode == self.DBG_END_LOCAL: | |
| 984 reg, sh = _uleb128(data[moff():moff() + 5]) | |
| 985 moff(sh) | |
| 986 opcodes.append((opcode, reg)) | |
| 987 pass | |
| 988 elif opcode == self.DBG_RESTART_LOCAL: | |
| 989 reg, sh = _uleb128(data[moff():moff() + 5]) | |
| 990 moff(sh) | |
| 991 opcodes.append((opcode, reg)) | |
| 992 pass | |
| 993 elif opcode in (self.DBG_SET_PROLOGUE_END, | |
| 994 self.DBG_SET_EPILOGUE_BEGIN, | |
| 995 self.DBG_SET_FILE): | |
| 996 opcodes.append((opcode,)) | |
| 997 pass | |
| 998 else: | |
| 999 opcodes.append((opcode,)) | |
| 1000 pass | |
| 1001 pass | |
| 1002 self.opcodes = opcodes | |
| 1003 | |
| 1004 self.data_size = moff() - off | |
| 1005 pass | |
| 1006 pass | |
| 1007 | |
| 1008 | |
| 0 | 1009 class DEXFile(object): |
| 1010 _data = None | |
| 1011 _header = None | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1012 _maps = None |
| 0 | 1013 _strings = None |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1014 _typeIds = None |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1015 _protoIds = None |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1016 _fieldIds = None |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1017 _methodIds = None |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1018 _classDefs = None |
| 2 | 1019 _classDatas = None |
| 1020 _typeLists = None | |
| 1021 _codeItems = None | |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1022 _annotationSetItems = None |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1023 _annotationsDirectoryItems = None |
| 8 | 1024 _annotationItems = None |
|
10
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1025 _encodedArrayItems = None |
| 11 | 1026 _debugInfoItems = None |
| 0 | 1027 |
| 1028 def __init__(self): | |
| 1029 pass | |
| 1030 | |
| 1031 def open(self, filename): | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1032 fo = file(filename, 'r') |
| 0 | 1033 data = fo.read() |
| 1034 | |
| 1035 self.parse(data) | |
| 1036 pass | |
| 1037 | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1038 def _parse_maps(self): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1039 data = self._data |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1040 header = self._header |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1041 off = header.mapOff |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1042 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1043 num = _to_uint(data[off:off + 4]) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1044 off = off + 4 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1045 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1046 maps = [] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1047 for i in range(num): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1048 item_data = data[off:off + _DEX_MapItem.data_size] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1049 item = _DEX_MapItem() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1050 item.parse(item_data) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1051 maps.append(item) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1052 off = off + _DEX_MapItem.data_size |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1053 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1054 |
| 2 | 1055 self._maps = maps |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1056 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1057 |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1058 def find_map_item(self, type_value): |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1059 maps = self._maps |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1060 try: |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1061 codeItem_map = [map for map in maps if map.type == type_value][0] |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1062 except IndexError: |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1063 return None |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1064 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1065 return codeItem_map |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1066 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1067 def find_map_item_name(self, type_name): |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1068 type_value = _DEX_MapItem.find_type_name(type_name) |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1069 map = self.find_map_item(type_value) |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1070 return map |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1071 |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1072 def _parse_strings(self): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1073 data = self._data |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1074 header = self._header |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1075 strings = [] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1076 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1077 num = header.stringIdsSize |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1078 off = header.stringIdsOff |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1079 for i in range(num): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1080 str_start_off = _to_uint(data[off:off + 4]) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1081 str_stop_off = data.index('\x00', str_start_off) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1082 string = data[str_start_off:str_stop_off] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1083 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1084 sz, sh = _uleb128(string) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1085 string = string[sh:] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1086 strings.append(string) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1087 off = off + 4 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1088 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1089 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1090 self._strings = strings |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1091 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1092 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1093 def _parse_typeIds(self): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1094 data = self._data |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1095 header = self._header |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1096 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1097 num = header.typeIdsSize |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1098 off = header.typeIdsOff |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1099 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1100 def parse(item_data): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1101 type_id = _DEX_TypeId() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1102 type_id.parse(item_data) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1103 return type_id |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1104 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1105 item_size = _DEX_TypeId.data_size |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1106 item_offs = range(off, off + item_size * num, item_size) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1107 item_datas = [data[item_off:item_off + item_size] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1108 for item_off in item_offs] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1109 typeIds = [parse(item_data) for item_data in item_datas] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1110 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1111 self._typeIds = typeIds |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1112 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1113 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1114 def _parse_protoIds(self): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1115 data = self._data |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1116 header = self._header |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1117 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1118 num = header.protoIdsSize |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1119 off = header.protoIdsOff |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1120 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1121 def parse(item_data): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1122 proto_id = _DEX_ProtoId() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1123 proto_id.parse(item_data) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1124 return proto_id |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1125 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1126 item_size = _DEX_ProtoId.data_size |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1127 item_offs = range(off, off + item_size * num, item_size) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1128 item_datas = [data[item_off:item_off + item_size] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1129 for item_off in item_offs] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1130 protoIds = [parse(item_data) for item_data in item_datas] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1131 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1132 self._protoIds = protoIds |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1133 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1134 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1135 def _parse_fieldIds(self): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1136 data = self._data |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1137 header = self._header |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1138 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1139 num = header.fieldIdsSize |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1140 off = header.fieldIdsOff |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1141 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1142 def parse(item_data): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1143 field_id = _DEX_FieldId() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1144 field_id.parse(item_data) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1145 return field_id |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1146 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1147 item_size = _DEX_FieldId.data_size |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1148 item_offs = range(off, off + item_size * num, item_size) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1149 item_datas = [data[item_off:item_off + item_size] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1150 for item_off in item_offs] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1151 fieldIds = [parse(item_data) for item_data in item_datas] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1152 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1153 self._fieldIds = fieldIds |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1154 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1155 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1156 def _parse_methodIds(self): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1157 data = self._data |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1158 header = self._header |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1159 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1160 num = header.methodIdsSize |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1161 off = header.methodIdsOff |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1162 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1163 def parse(item_data): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1164 method_id = _DEX_MethodId() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1165 method_id.parse(item_data) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1166 return method_id |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1167 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1168 item_size = _DEX_MethodId.data_size |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1169 item_offs = range(off, off + item_size * num, item_size) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1170 item_datas = [data[item_off:item_off + item_size] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1171 for item_off in item_offs] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1172 methodIds = [parse(item_data) for item_data in item_datas] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1173 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1174 self._methodIds = methodIds |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1175 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1176 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1177 def _parse_classDefs(self): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1178 data = self._data |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1179 header = self._header |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1180 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1181 num = header.classDefsSize |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1182 off = header.classDefsOff |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1183 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1184 def parse(item_data): |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1185 class_def = _DEX_ClassDef() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1186 class_def.parse(item_data) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1187 return class_def |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1188 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1189 item_size = _DEX_ClassDef.data_size |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1190 item_offs = range(off, off + item_size * num, item_size) |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1191 item_datas = [data[item_off:item_off + item_size] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1192 for item_off in item_offs] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1193 classDefs = [parse(item_data) for item_data in item_datas] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1194 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1195 self._classDefs = classDefs |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1196 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1197 |
| 2 | 1198 def _parse_classDatas(self): |
| 1199 header = self._header | |
| 1200 data = self._data | |
| 1201 | |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1202 class_data_map = self.find_map_item_name('kDexTypeClassDataItem') |
| 2 | 1203 |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1204 moff = man_off(class_data_map.offset) |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1205 |
| 2 | 1206 def parse_class_data(): |
| 1207 class_data = _DEX_ClassData() | |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1208 class_data.parse(data, moff()) |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1209 moff(class_data.data_size) |
| 2 | 1210 return class_data |
| 1211 class_datas = [parse_class_data() for i in range(class_data_map.size)] | |
| 1212 | |
| 1213 self._classDatas = class_datas | |
| 1214 pass | |
| 1215 | |
| 1216 def _parse_typeLists(self): | |
| 1217 data = self._data | |
| 1218 | |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1219 typeList_map = self.find_map_item_name('kDexTypeTypeList') |
| 2 | 1220 num_typeLists = typeList_map.size |
| 1221 | |
| 1222 typeLists = _DEX_TypeLists() | |
| 1223 typeLists.parse(num_typeLists, data, typeList_map.offset) | |
| 1224 | |
| 1225 self._typeLists = typeLists | |
| 1226 pass | |
| 1227 | |
| 1228 def _parse_codeItems(self): | |
| 1229 data = self._data | |
| 1230 | |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1231 codeItem_map = self.find_map_item_name('kDexTypeCodeItem') |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1232 if codeItem_map is None: |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1233 return |
| 2 | 1234 num_codeItems = codeItem_map.size |
| 1235 | |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1236 moff = man_off(codeItem_map.offset) |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1237 |
| 2 | 1238 def parse_code(): |
| 1239 code = _DEX_Code() | |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1240 code.parse(data, moff()) |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1241 moff(code.data_size) |
| 2 | 1242 return code |
| 1243 | |
| 1244 codeItems = [parse_code() for i in range(num_codeItems)] | |
| 1245 | |
| 1246 self._codeItems = codeItems | |
| 1247 pass | |
| 1248 | |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1249 def _parse_annotationSetItems(self): |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1250 data = self._data |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1251 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1252 annoset_map = self.find_map_item_name('kDexTypeAnnotationSetItem') |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1253 if annoset_map is None: |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1254 return |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1255 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1256 moff = man_off(annoset_map.offset) |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1257 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1258 def parse_annotationSetItem(): |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1259 item = _DEX_AnnotationSetItem() |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1260 item.parse(data, moff()) |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1261 moff(item.data_size) |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1262 return item |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1263 |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1264 self._annotationSetItems = [parse_annotationSetItem() |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1265 for i in range(annoset_map.size)] |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1266 pass |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1267 |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1268 def _parse_annotationsDirectoryItems(self): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1269 data = self._data |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1270 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1271 annodir_map = \ |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1272 self.find_map_item_name('kDexTypeAnnotationsDirectoryItem') |
|
7
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1273 if annodir_map is None: |
|
1d776ec496e5
Migrate all to find_map_item_name()
Thinker K.F. Li <thinker@codemud.net>
parents:
6
diff
changeset
|
1274 return |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1275 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1276 moff = man_off(annodir_map.offset) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1277 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1278 def parse_annotationDirItem(): |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1279 item = _DEX_AnnotationsDirectoryItem() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1280 item.parse(data, moff()) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1281 moff(item.data_size) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1282 return item |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1283 |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1284 self._annotationsDirectoryItems = [parse_annotationDirItem() |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1285 for i in range(annodir_map.size)] |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1286 pass |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1287 |
| 8 | 1288 def _parse_annotationItems(self): |
| 1289 data = self._data | |
| 1290 | |
| 1291 annoitem_map = self.find_map_item_name('kDexTypeAnnotationItem') | |
| 1292 if annoitem_map is None: | |
| 1293 return | |
| 1294 | |
| 1295 moff = man_off(annoitem_map.offset) | |
| 1296 | |
| 1297 def parse_annotationItem(): | |
| 1298 item = _DEX_AnnotationItem() | |
| 1299 item.parse(data, moff()) | |
| 1300 moff(item.data_size) | |
| 1301 return item | |
| 1302 | |
| 1303 self._annotationItems = [parse_annotationItem() | |
| 1304 for i in range(annoitem_map.size)] | |
| 1305 pass | |
| 1306 | |
|
9
9a49826b26d4
Refactor _parse_header()
Thinker K.F. Li <thinker@codemud.net>
parents:
8
diff
changeset
|
1307 def _parse_header(self): |
|
9a49826b26d4
Refactor _parse_header()
Thinker K.F. Li <thinker@codemud.net>
parents:
8
diff
changeset
|
1308 data = self._data |
| 0 | 1309 header = _DEX_header() |
| 1310 header.parse(data) | |
| 1311 self._header = header | |
|
9
9a49826b26d4
Refactor _parse_header()
Thinker K.F. Li <thinker@codemud.net>
parents:
8
diff
changeset
|
1312 pass |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1313 |
|
10
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1314 def _parse_encodedArrayItems(self): |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1315 data = self._data |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1316 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1317 encodedArrayItem_map = \ |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1318 self.find_map_item_name('kDexTypeEncodedArrayItem') |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1319 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1320 moff = man_off(encodedArrayItem_map.offset) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1321 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1322 def parse_encodedArrayItem(): |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1323 item = _DEX_EncodedArrayItem() |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1324 item.parse(data, moff()) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1325 moff(item.data_size) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1326 return item |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1327 |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1328 self._encodedArrayItems = [parse_encodedArrayItem() |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1329 for i in range(encodedArrayItem_map.size)] |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1330 pass |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1331 |
| 11 | 1332 def _parse_debugInfoItems(self): |
| 1333 data = self._data | |
| 1334 | |
| 1335 debugInfoItem_map = \ | |
| 1336 self.find_map_item_name('kDexTypeDebugInfoItem') | |
| 1337 | |
| 1338 moff = man_off(debugInfoItem_map.offset) | |
| 1339 | |
| 1340 def parse_debugInfoItem(): | |
| 1341 item = _DEX_DebugInfoItem() | |
| 1342 item.parse(data, moff()) | |
| 1343 moff(item.data_size) | |
| 1344 return item | |
| 1345 | |
| 1346 self._debugInfoItems = [parse_debugInfoItem() | |
| 1347 for i in range(debugInfoItem_map.size)] | |
| 1348 pass | |
| 1349 | |
|
9
9a49826b26d4
Refactor _parse_header()
Thinker K.F. Li <thinker@codemud.net>
parents:
8
diff
changeset
|
1350 def parse(self, data): |
|
9a49826b26d4
Refactor _parse_header()
Thinker K.F. Li <thinker@codemud.net>
parents:
8
diff
changeset
|
1351 self._data = data |
|
9a49826b26d4
Refactor _parse_header()
Thinker K.F. Li <thinker@codemud.net>
parents:
8
diff
changeset
|
1352 self._parse_header() |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1353 self._parse_maps() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1354 self._parse_strings() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1355 self._parse_typeIds() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1356 self._parse_protoIds() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1357 self._parse_fieldIds() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1358 self._parse_methodIds() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1359 self._parse_classDefs() |
| 2 | 1360 self._parse_classDatas() |
| 1361 self._parse_typeLists() | |
| 1362 self._parse_codeItems() | |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1363 self._parse_annotationSetItems() |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1364 self._parse_annotationsDirectoryItems() |
| 8 | 1365 self._parse_annotationItems() |
|
10
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1366 self._parse_encodedArrayItems() |
| 11 | 1367 self._parse_debugInfoItems() |
| 0 | 1368 pass |
| 1369 pass | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1370 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1371 if __name__ == '__main__': |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1372 dex = DEXFile() |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1373 dex.open('test.dex') |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1374 |
| 2 | 1375 print 'Header' |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1376 h = dex._header |
| 2 | 1377 for attr in h.header_fields: |
| 1378 print '\t%s: %s' % (attr, repr(getattr(h, attr))) | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1379 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1380 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1381 print |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1382 print 'Define Classes' |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1383 strings = dex._strings |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1384 classDefs = dex._classDefs |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1385 typeIds = dex._typeIds |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1386 for classDef in classDefs: |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1387 typeId = typeIds[classDef.classIdx] |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1388 descriptor = strings[typeId.descriptorIdx] |
| 2 | 1389 data_off = classDef.classDataOff |
| 1390 print '\t%s @0x%x' % (descriptor, data_off) | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1391 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1392 |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1393 print |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1394 print 'Reference Classes' |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1395 for typeId in typeIds: |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1396 descriptor = strings[typeId.descriptorIdx] |
| 2 | 1397 print '\t%s' % (descriptor) |
| 1398 pass | |
| 1399 | |
| 1400 print | |
| 1401 print 'Class data' | |
| 1402 methodIds = dex._methodIds | |
| 1403 classDatas = dex._classDatas | |
| 1404 for classData in classDatas: | |
| 1405 print '\tclass' | |
| 1406 for method in classData.directMethods: | |
| 1407 code_off = method.codeOff | |
| 1408 methodId = methodIds[method.methodIdx] | |
| 1409 name = strings[methodId.nameIdx] | |
| 1410 print '\t\t%s@0x%x' % (name, code_off) | |
| 1411 pass | |
| 1412 for method in classData.virtualMethods: | |
| 1413 code_off = method.codeOff | |
| 1414 methodId = methodIds[method.methodIdx] | |
| 1415 name = strings[methodId.nameIdx] | |
| 1416 print '\t\t%s@0x%x' % (name, code_off) | |
| 1417 pass | |
| 1418 pass | |
| 1419 | |
| 1420 print | |
| 1421 print 'TypeLists size is %d bytes' % (dex._typeLists.data_size) | |
| 1422 | |
| 1423 bytes = sum([code.data_size for code in dex._codeItems]) | |
| 1424 print | |
| 1425 print 'CodeItems size is %d bytes' % (bytes) | |
| 1426 | |
|
3
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1427 bytes = sum([annoset.data_size for annoset in dex._annotationSetItems]) |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1428 print |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1429 print 'AnnotationSetItems size is %d bytes' % (bytes) |
|
a78db169b0c8
parse AnnotationSetItems
Thinker K.F. Li <thinker@codemud.net>
parents:
2
diff
changeset
|
1430 |
|
4
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1431 bytes = sum([annodir.data_size |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1432 for annodir in dex._annotationsDirectoryItems]) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1433 print |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1434 print 'AnnotationsDirtoryItems size is %d bytes' % (bytes) |
|
b0766f1984bb
parse annotationsDirectoryItem
Thinker K.F. Li <thinker@codemud.net>
parents:
3
diff
changeset
|
1435 |
| 8 | 1436 bytes = sum([annoitem.data_size |
| 1437 for annoitem in dex._annotationItems]) | |
| 1438 print | |
| 1439 print 'AnnotationItems size is %d bytes' % (bytes) | |
| 1440 | |
|
10
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1441 bytes = sum([encodeditem.data_size |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1442 for encodeditem in dex._encodedArrayItems]) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1443 print |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1444 print 'EncodedArrayItems size is %d bytes' % (bytes) |
|
123c7a8bbf4c
Parse EncodedArrayItems
Thinker K.F. Li <thinker@codemud.net>
parents:
9
diff
changeset
|
1445 |
| 11 | 1446 bytes = sum([debuginfoitem.data_size |
| 1447 for debuginfoitem in dex._debugInfoItems]) | |
| 1448 print | |
| 1449 print 'DebugInfoItems size is %d bytes' % (bytes) | |
| 1450 | |
| 2 | 1451 print |
| 1452 print 'Data maps' | |
| 1453 maps = dex._maps | |
| 1454 for map in maps: | |
| 1455 print '\t0x%04x(%s) size=%d offset=0x%08x' % (map.type, | |
| 1456 map.types[map.type], | |
| 1457 map.size, | |
| 1458 map.offset) | |
|
1
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1459 pass |
|
05346b632adb
Parse records mentioned in file header
Thinker K.F. Li <thinker@codemud.net>
parents:
0
diff
changeset
|
1460 pass |