1/* 2 * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26// -*- C++ -*- 27// Small program for unpacking specially compressed Java packages. 28// John R. Rose 29 30#include <sys/types.h> 31 32#include <stdio.h> 33#include <string.h> 34#include <stdlib.h> 35#include <stdarg.h> 36 37#include "defines.h" 38#include "bytes.h" 39#include "utils.h" 40#include "coding.h" 41#include "bands.h" 42 43#include "constants.h" 44#include "unpack.h" 45 46inline void band::abort(const char* msg) { u->abort(msg); } 47inline bool band::aborting() { return u->aborting(); } 48 49void band::readData(int expectedLength) { 50 CHECK; 51 assert(expectedLength >= 0); 52 assert(vs[0].cmk == cmk_ERROR); 53 if (expectedLength != 0) { 54 assert(length == 0); 55 length = expectedLength; 56 } 57 if (length == 0) { 58 assert((rplimit = cm.vs0.rp = u->rp) != null); 59 return; 60 } 61 assert(length > 0); 62 63 bool is_BYTE1 = (defc->spec == BYTE1_spec); 64 65 if (is_BYTE1) { 66 // No possibility of coding change. Sizing is exact. 67 u->ensure_input(length); 68 } else { 69 // Make a conservatively generous estimate of band size in bytes. 70 // Assume B == 5 everywhere. 71 // Assume awkward pop with all {U} values (2*5 per value) 72 jlong generous = (jlong) length * (B_MAX*3+1) + C_SLOP; 73 u->ensure_input(generous); 74 } 75 76 // Read one value to see what it might be. 77 int XB = _meta_default; 78 int cp1 = 0, cp2 = 0; 79 if (!is_BYTE1) { 80 // must be a variable-length coding 81 assert(defc->B() > 1 && defc->L() > 0); 82 // must have already read from previous band: 83 assert(bn >= BAND_LIMIT || bn <= 0 84 || bn == e_cp_Utf8_big_chars 85 || endsWith(name, "_lo") // preceded by _hi conditional band 86 || bn == e_file_options // preceded by conditional band 87 || u->rp == u->all_bands[bn-1].maxRP() 88 || u->all_bands[bn-1].defc == null); 89 90 value_stream xvs; 91 coding* valc = defc; 92 if (valc->D() != 0) { 93 valc = coding::findBySpec(defc->B(), defc->H(), defc->S()); 94 assert(!valc->isMalloc); 95 } 96 xvs.init(u->rp, u->rplimit, valc); 97 CHECK; 98 int X = xvs.getInt(); 99 if (valc->S() != 0) { 100 assert(valc->min <= -256); 101 XB = -1-X; 102 } else { 103 int L = valc->L(); 104 assert(valc->max >= L+255); 105 XB = X-L; 106 } 107 if (0 <= XB && XB < 256) { 108 // Skip over the escape value. 109 u->rp = xvs.rp; 110 cp1 = 1; 111 } else { 112 // No, it's still default. 113 XB = _meta_default; 114 } 115 } 116 117 if (XB <= _meta_canon_max) { 118 byte XB_byte = (byte) XB; 119 byte* XB_ptr = &XB_byte; 120 cm.init(u->rp, u->rplimit, XB_ptr, 0, defc, length, null); 121 CHECK; 122 } else { 123 NOT_PRODUCT(byte* meta_rp0 = u->meta_rp); 124 assert(u->meta_rp != null); 125 // Scribble the initial byte onto the band. 126 byte* save_meta_rp = --u->meta_rp; 127 byte save_meta_xb = (*save_meta_rp); 128 (*save_meta_rp) = (byte) XB; 129 cm.init(u->rp, u->rplimit, u->meta_rp, 0, defc, length, null); 130 (*save_meta_rp) = save_meta_xb; // put it back, just to be tidy 131 NOT_PRODUCT(cp2 = (int)(u->meta_rp - meta_rp0)); 132 } 133 rplimit = u->rp; 134 135 rewind(); 136 137#ifndef PRODUCT 138 PRINTCR((3,"readFrom %s at %p [%d values, %d bytes, cp=%d/%d]", 139 (name?name:"(band)"), minRP(), length, size(), cp1, cp2)); 140 if (u->verbose_bands || u->verbose >= 4) dump(); 141 142 if (ix != null && u->verbose != 0 && length > 0) { 143 // Check referential integrity early, for easier debugging. 144 band saved = (*this); // save state 145 for (int i = 0; i < length; i++) { 146 int n = vs[0].getInt() - nullOK; 147 entry *ref = ix->get(n); 148 assert(ref != null || n == -1); 149 } 150 (*this) = saved; 151 } 152#endif 153} 154 155#ifndef PRODUCT 156void band::dump() { 157 band saved = (*this); // save state 158 const char* b_name = name; 159 char b_name_buf[100]; 160 if (b_name == null) { 161 char* bp = &b_name_buf[0]; 162 b_name = bp; 163 sprintf(bp, "#%d/%d", bn, le_kind); bp += strlen(bp); 164 if (le_bci != 0) { sprintf(bp, "/bci%d", le_bci); bp += strlen(bp); } 165 if (le_back != 0) { sprintf(bp, "/back%d", le_back); bp += strlen(bp); } 166 if (le_len != 0) { sprintf(bp, "/len%d", le_len); bp += strlen(bp); } 167 } 168 fprintf(u->errstrm, "band %s[%d]%s", b_name, length, (length==0?"\n":" {")); 169 if (length > 0) { 170 for (int i = 0; i < length; i++) { 171 const char* eol = (length > 10 && i % 10 == 0) ? "\n" : " "; 172 fprintf(u->errstrm, "%s%d", eol, vs[0].getInt()); 173 } 174 fprintf(u->errstrm, " }\n"); 175 } 176 (*this) = saved; 177} 178#endif 179 180void band::setIndex(cpindex* ix_) { 181 assert(ix_ == null || ixTag == ix_->ixTag); 182 ix = ix_; 183} 184void band::setIndexByTag(byte tag) { 185 setIndex(u->cp.getIndex(tag)); 186} 187 188entry* band::getRefCommon(cpindex* ix_, bool nullOKwithCaller) { 189 CHECK_0; 190 if (ix_ == NULL) { 191 abort("no index"); 192 return NULL; 193 } 194 assert(ix_->ixTag == ixTag 195 || ((ixTag == CONSTANT_All || 196 ixTag == CONSTANT_LoadableValue || 197 ixTag == CONSTANT_AnyMember) 198 || (ixTag == CONSTANT_FieldSpecific && 199 ix_->ixTag >= CONSTANT_Integer && 200 ix_->ixTag <= CONSTANT_String)) 201 ); 202 int n = vs[0].getInt() - nullOK; 203 // Note: band-local nullOK means null encodes as 0. 204 // But nullOKwithCaller means caller is willing to tolerate a null. 205 entry *ref = ix_->get(n); 206 if (ref == null && !(nullOKwithCaller && n == -1)) 207 abort(n == -1 ? "null ref" : "bad ref"); 208 return ref; 209} 210 211jlong band::getLong(band& lo_band, bool have_hi) { 212 band& hi_band = (*this); 213 assert(lo_band.bn == hi_band.bn + 1); 214 uint lo = lo_band.getInt(); 215 if (!have_hi) { 216 assert(hi_band.length == 0); 217 return makeLong(0, lo); 218 } 219 uint hi = hi_band.getInt(); 220 return makeLong(hi, lo); 221} 222 223int band::getIntTotal() { 224 CHECK_0; 225 if (length == 0) return 0; 226 if (total_memo > 0) return total_memo-1; 227 int total = getInt(); 228 // overflow checks require that none of the addends are <0, 229 // and that the partial sums never overflow (wrap negative) 230 if (total < 0) { 231 abort("overflow detected"); 232 return 0; 233 } 234 for (int k = length-1; k > 0; k--) { 235 int prev_total = total; 236 total += vs[0].getInt(); 237 if (total < prev_total) { 238 abort("overflow detected"); 239 return 0; 240 } 241 } 242 rewind(); 243 total_memo = total+1; 244 return total; 245} 246 247int band::getIntCount(int tag) { 248 CHECK_0; 249 if (length == 0) return 0; 250 if (tag >= HIST0_MIN && tag <= HIST0_MAX) { 251 if (hist0 == null) { 252 // Lazily calculate an approximate histogram. 253 hist0 = U_NEW(int, (HIST0_MAX - HIST0_MIN)+1); 254 CHECK_0; 255 for (int k = length; k > 0; k--) { 256 int x = vs[0].getInt(); 257 if (x >= HIST0_MIN && x <= HIST0_MAX) 258 hist0[x - HIST0_MIN] += 1; 259 } 260 rewind(); 261 } 262 return hist0[tag - HIST0_MIN]; 263 } 264 int total = 0; 265 for (int k = length; k > 0; k--) { 266 total += (vs[0].getInt() == tag) ? 1 : 0; 267 } 268 rewind(); 269 return total; 270} 271 272#define INDEX_INIT(tag, nullOK, subindex) \ 273 ((tag) + (subindex)*SUBINDEX_BIT + (nullOK)*256) 274 275#define INDEX(tag) INDEX_INIT(tag, 0, 0) 276#define NULL_OR_INDEX(tag) INDEX_INIT(tag, 1, 0) 277#define SUB_INDEX(tag) INDEX_INIT(tag, 0, 1) 278#define NO_INDEX 0 279 280struct band_init { 281 int bn; 282 const char* name; 283 int defc; 284 int index; 285}; 286 287#define BAND_INIT(name, cspec, ix) \ 288 { e_##name, #name, /*debug only*/ \ 289 cspec, ix } 290 291const band_init all_band_inits[BAND_LIMIT+1] = { 292//BAND_INIT(archive_magic, BYTE1_spec, 0), 293//BAND_INIT(archive_header, UNSIGNED5_spec, 0), 294//BAND_INIT(band_headers, BYTE1_spec, 0), 295 BAND_INIT(cp_Utf8_prefix, DELTA5_spec, 0), 296 BAND_INIT(cp_Utf8_suffix, UNSIGNED5_spec, 0), 297 BAND_INIT(cp_Utf8_chars, CHAR3_spec, 0), 298 BAND_INIT(cp_Utf8_big_suffix, DELTA5_spec, 0), 299 BAND_INIT(cp_Utf8_big_chars, DELTA5_spec, 0), 300 BAND_INIT(cp_Int, UDELTA5_spec, 0), 301 BAND_INIT(cp_Float, UDELTA5_spec, 0), 302 BAND_INIT(cp_Long_hi, UDELTA5_spec, 0), 303 BAND_INIT(cp_Long_lo, DELTA5_spec, 0), 304 BAND_INIT(cp_Double_hi, UDELTA5_spec, 0), 305 BAND_INIT(cp_Double_lo, DELTA5_spec, 0), 306 BAND_INIT(cp_String, UDELTA5_spec, INDEX(CONSTANT_Utf8)), 307 BAND_INIT(cp_Class, UDELTA5_spec, INDEX(CONSTANT_Utf8)), 308 BAND_INIT(cp_Signature_form, DELTA5_spec, INDEX(CONSTANT_Utf8)), 309 BAND_INIT(cp_Signature_classes, UDELTA5_spec, INDEX(CONSTANT_Class)), 310 BAND_INIT(cp_Descr_name, DELTA5_spec, INDEX(CONSTANT_Utf8)), 311 BAND_INIT(cp_Descr_type, UDELTA5_spec, INDEX(CONSTANT_Signature)), 312 BAND_INIT(cp_Field_class, DELTA5_spec, INDEX(CONSTANT_Class)), 313 BAND_INIT(cp_Field_desc, UDELTA5_spec, INDEX(CONSTANT_NameandType)), 314 BAND_INIT(cp_Method_class, DELTA5_spec, INDEX(CONSTANT_Class)), 315 BAND_INIT(cp_Method_desc, UDELTA5_spec, INDEX(CONSTANT_NameandType)), 316 BAND_INIT(cp_Imethod_class, DELTA5_spec, INDEX(CONSTANT_Class)), 317 BAND_INIT(cp_Imethod_desc, UDELTA5_spec, INDEX(CONSTANT_NameandType)), 318 BAND_INIT(cp_MethodHandle_refkind, DELTA5_spec, 0), 319 BAND_INIT(cp_MethodHandle_member, UDELTA5_spec, INDEX(CONSTANT_AnyMember)), 320 BAND_INIT(cp_MethodType, UDELTA5_spec, INDEX(CONSTANT_Signature)), 321 BAND_INIT(cp_BootstrapMethod_ref, DELTA5_spec, INDEX(CONSTANT_MethodHandle)), 322 BAND_INIT(cp_BootstrapMethod_arg_count, UDELTA5_spec, 0), 323 BAND_INIT(cp_BootstrapMethod_arg, DELTA5_spec, INDEX(CONSTANT_LoadableValue)), 324 BAND_INIT(cp_InvokeDynamic_spec, DELTA5_spec, INDEX(CONSTANT_BootstrapMethod)), 325 BAND_INIT(cp_InvokeDynamic_desc, UDELTA5_spec, INDEX(CONSTANT_NameandType)), 326 BAND_INIT(attr_definition_headers, BYTE1_spec, 0), 327 BAND_INIT(attr_definition_name, UNSIGNED5_spec, INDEX(CONSTANT_Utf8)), 328 BAND_INIT(attr_definition_layout, UNSIGNED5_spec, INDEX(CONSTANT_Utf8)), 329 BAND_INIT(ic_this_class, UDELTA5_spec, INDEX(CONSTANT_Class)), 330 BAND_INIT(ic_flags, UNSIGNED5_spec, 0), 331 BAND_INIT(ic_outer_class, DELTA5_spec, NULL_OR_INDEX(CONSTANT_Class)), 332 BAND_INIT(ic_name, DELTA5_spec, NULL_OR_INDEX(CONSTANT_Utf8)), 333 BAND_INIT(class_this, DELTA5_spec, INDEX(CONSTANT_Class)), 334 BAND_INIT(class_super, DELTA5_spec, INDEX(CONSTANT_Class)), 335 BAND_INIT(class_interface_count, DELTA5_spec, 0), 336 BAND_INIT(class_interface, DELTA5_spec, INDEX(CONSTANT_Class)), 337 BAND_INIT(class_field_count, DELTA5_spec, 0), 338 BAND_INIT(class_method_count, DELTA5_spec, 0), 339 BAND_INIT(field_descr, DELTA5_spec, INDEX(CONSTANT_NameandType)), 340 BAND_INIT(field_flags_hi, UNSIGNED5_spec, 0), 341 BAND_INIT(field_flags_lo, UNSIGNED5_spec, 0), 342 BAND_INIT(field_attr_count, UNSIGNED5_spec, 0), 343 BAND_INIT(field_attr_indexes, UNSIGNED5_spec, 0), 344 BAND_INIT(field_attr_calls, UNSIGNED5_spec, 0), 345 BAND_INIT(field_ConstantValue_KQ, UNSIGNED5_spec, INDEX(CONSTANT_FieldSpecific)), 346 BAND_INIT(field_Signature_RS, UNSIGNED5_spec, INDEX(CONSTANT_Signature)), 347 BAND_INIT(field_metadata_bands, -1, -1), 348 BAND_INIT(field_attr_bands, -1, -1), 349 BAND_INIT(method_descr, MDELTA5_spec, INDEX(CONSTANT_NameandType)), 350 BAND_INIT(method_flags_hi, UNSIGNED5_spec, 0), 351 BAND_INIT(method_flags_lo, UNSIGNED5_spec, 0), 352 BAND_INIT(method_attr_count, UNSIGNED5_spec, 0), 353 BAND_INIT(method_attr_indexes, UNSIGNED5_spec, 0), 354 BAND_INIT(method_attr_calls, UNSIGNED5_spec, 0), 355 BAND_INIT(method_Exceptions_N, UNSIGNED5_spec, 0), 356 BAND_INIT(method_Exceptions_RC, UNSIGNED5_spec, INDEX(CONSTANT_Class)), 357 BAND_INIT(method_Signature_RS, UNSIGNED5_spec, INDEX(CONSTANT_Signature)), 358 BAND_INIT(method_metadata_bands, -1, -1), 359 BAND_INIT(method_MethodParameters_NB, BYTE1_spec, 0), 360 BAND_INIT(method_MethodParameters_name_RUN, UNSIGNED5_spec, NULL_OR_INDEX(CONSTANT_Utf8)), 361 BAND_INIT(method_MethodParameters_flag_FH, UNSIGNED5_spec, 0), 362 BAND_INIT(method_attr_bands, -1, -1), 363 BAND_INIT(class_flags_hi, UNSIGNED5_spec, 0), 364 BAND_INIT(class_flags_lo, UNSIGNED5_spec, 0), 365 BAND_INIT(class_attr_count, UNSIGNED5_spec, 0), 366 BAND_INIT(class_attr_indexes, UNSIGNED5_spec, 0), 367 BAND_INIT(class_attr_calls, UNSIGNED5_spec, 0), 368 BAND_INIT(class_SourceFile_RUN, UNSIGNED5_spec, NULL_OR_INDEX(CONSTANT_Utf8)), 369 BAND_INIT(class_EnclosingMethod_RC, UNSIGNED5_spec, INDEX(CONSTANT_Class)), 370 BAND_INIT(class_EnclosingMethod_RDN, UNSIGNED5_spec, NULL_OR_INDEX(CONSTANT_NameandType)), 371 BAND_INIT(class_Signature_RS, UNSIGNED5_spec, INDEX(CONSTANT_Signature)), 372 BAND_INIT(class_metadata_bands, -1, -1), 373 BAND_INIT(class_InnerClasses_N, UNSIGNED5_spec, 0), 374 BAND_INIT(class_InnerClasses_RC, UNSIGNED5_spec, INDEX(CONSTANT_Class)), 375 BAND_INIT(class_InnerClasses_F, UNSIGNED5_spec, 0), 376 BAND_INIT(class_InnerClasses_outer_RCN, UNSIGNED5_spec, NULL_OR_INDEX(CONSTANT_Class)), 377 BAND_INIT(class_InnerClasses_name_RUN, UNSIGNED5_spec, NULL_OR_INDEX(CONSTANT_Utf8)), 378 BAND_INIT(class_ClassFile_version_minor_H, UNSIGNED5_spec, 0), 379 BAND_INIT(class_ClassFile_version_major_H, UNSIGNED5_spec, 0), 380 BAND_INIT(class_attr_bands, -1, -1), 381 BAND_INIT(code_headers, BYTE1_spec, 0), 382 BAND_INIT(code_max_stack, UNSIGNED5_spec, 0), 383 BAND_INIT(code_max_na_locals, UNSIGNED5_spec, 0), 384 BAND_INIT(code_handler_count, UNSIGNED5_spec, 0), 385 BAND_INIT(code_handler_start_P, BCI5_spec, 0), 386 BAND_INIT(code_handler_end_PO, BRANCH5_spec, 0), 387 BAND_INIT(code_handler_catch_PO, BRANCH5_spec, 0), 388 BAND_INIT(code_handler_class_RCN, UNSIGNED5_spec, NULL_OR_INDEX(CONSTANT_Class)), 389 BAND_INIT(code_flags_hi, UNSIGNED5_spec, 0), 390 BAND_INIT(code_flags_lo, UNSIGNED5_spec, 0), 391 BAND_INIT(code_attr_count, UNSIGNED5_spec, 0), 392 BAND_INIT(code_attr_indexes, UNSIGNED5_spec, 0), 393 BAND_INIT(code_attr_calls, UNSIGNED5_spec, 0), 394 BAND_INIT(code_StackMapTable_N, UNSIGNED5_spec, 0), 395 BAND_INIT(code_StackMapTable_frame_T, BYTE1_spec, 0), 396 BAND_INIT(code_StackMapTable_local_N, UNSIGNED5_spec, 0), 397 BAND_INIT(code_StackMapTable_stack_N, UNSIGNED5_spec, 0), 398 BAND_INIT(code_StackMapTable_offset, UNSIGNED5_spec, 0), 399 BAND_INIT(code_StackMapTable_T, BYTE1_spec, 0), 400 BAND_INIT(code_StackMapTable_RC, UNSIGNED5_spec, INDEX(CONSTANT_Class)), 401 BAND_INIT(code_StackMapTable_P, BCI5_spec, 0), 402 BAND_INIT(code_LineNumberTable_N, UNSIGNED5_spec, 0), 403 BAND_INIT(code_LineNumberTable_bci_P, BCI5_spec, 0), 404 BAND_INIT(code_LineNumberTable_line, UNSIGNED5_spec, 0), 405 BAND_INIT(code_LocalVariableTable_N, UNSIGNED5_spec, 0), 406 BAND_INIT(code_LocalVariableTable_bci_P, BCI5_spec, 0), 407 BAND_INIT(code_LocalVariableTable_span_O, BRANCH5_spec, 0), 408 BAND_INIT(code_LocalVariableTable_name_RU, UNSIGNED5_spec, INDEX(CONSTANT_Utf8)), 409 BAND_INIT(code_LocalVariableTable_type_RS, UNSIGNED5_spec, INDEX(CONSTANT_Signature)), 410 BAND_INIT(code_LocalVariableTable_slot, UNSIGNED5_spec, 0), 411 BAND_INIT(code_LocalVariableTypeTable_N, UNSIGNED5_spec, 0), 412 BAND_INIT(code_LocalVariableTypeTable_bci_P, BCI5_spec, 0), 413 BAND_INIT(code_LocalVariableTypeTable_span_O, BRANCH5_spec, 0), 414 BAND_INIT(code_LocalVariableTypeTable_name_RU, UNSIGNED5_spec, INDEX(CONSTANT_Utf8)), 415 BAND_INIT(code_LocalVariableTypeTable_type_RS, UNSIGNED5_spec, INDEX(CONSTANT_Signature)), 416 BAND_INIT(code_LocalVariableTypeTable_slot, UNSIGNED5_spec, 0), 417 BAND_INIT(code_attr_bands, -1, -1), 418 BAND_INIT(bc_codes, BYTE1_spec, 0), 419 BAND_INIT(bc_case_count, UNSIGNED5_spec, 0), 420 BAND_INIT(bc_case_value, DELTA5_spec, 0), 421 BAND_INIT(bc_byte, BYTE1_spec, 0), 422 BAND_INIT(bc_short, DELTA5_spec, 0), 423 BAND_INIT(bc_local, UNSIGNED5_spec, 0), 424 BAND_INIT(bc_label, BRANCH5_spec, 0), 425 BAND_INIT(bc_intref, DELTA5_spec, INDEX(CONSTANT_Integer)), 426 BAND_INIT(bc_floatref, DELTA5_spec, INDEX(CONSTANT_Float)), 427 BAND_INIT(bc_longref, DELTA5_spec, INDEX(CONSTANT_Long)), 428 BAND_INIT(bc_doubleref, DELTA5_spec, INDEX(CONSTANT_Double)), 429 BAND_INIT(bc_stringref, DELTA5_spec, INDEX(CONSTANT_String)), 430 BAND_INIT(bc_loadablevalueref, DELTA5_spec, INDEX(CONSTANT_LoadableValue)), 431 BAND_INIT(bc_classref, UNSIGNED5_spec, NULL_OR_INDEX(CONSTANT_Class)), 432 BAND_INIT(bc_fieldref, DELTA5_spec, INDEX(CONSTANT_Fieldref)), 433 BAND_INIT(bc_methodref, UNSIGNED5_spec, INDEX(CONSTANT_Methodref)), 434 BAND_INIT(bc_imethodref, DELTA5_spec, INDEX(CONSTANT_InterfaceMethodref)), 435 BAND_INIT(bc_indyref, DELTA5_spec, INDEX(CONSTANT_InvokeDynamic)), 436 BAND_INIT(bc_thisfield, UNSIGNED5_spec, SUB_INDEX(CONSTANT_Fieldref)), 437 BAND_INIT(bc_superfield, UNSIGNED5_spec, SUB_INDEX(CONSTANT_Fieldref)), 438 BAND_INIT(bc_thismethod, UNSIGNED5_spec, SUB_INDEX(CONSTANT_Methodref)), 439 BAND_INIT(bc_supermethod, UNSIGNED5_spec, SUB_INDEX(CONSTANT_Methodref)), 440 BAND_INIT(bc_initref, UNSIGNED5_spec, SUB_INDEX(CONSTANT_Methodref)), 441 BAND_INIT(bc_escref, UNSIGNED5_spec, INDEX(CONSTANT_All)), 442 BAND_INIT(bc_escrefsize, UNSIGNED5_spec, 0), 443 BAND_INIT(bc_escsize, UNSIGNED5_spec, 0), 444 BAND_INIT(bc_escbyte, BYTE1_spec, 0), 445 BAND_INIT(file_name, UNSIGNED5_spec, INDEX(CONSTANT_Utf8)), 446 BAND_INIT(file_size_hi, UNSIGNED5_spec, 0), 447 BAND_INIT(file_size_lo, UNSIGNED5_spec, 0), 448 BAND_INIT(file_modtime, DELTA5_spec, 0), 449 BAND_INIT(file_options, UNSIGNED5_spec, 0), 450//BAND_INIT(file_bits, BYTE1_spec, 0), 451 { 0, NULL, 0, 0 } 452}; 453 454band* band::makeBands(unpacker* u) { 455 band* tmp_all_bands = U_NEW(band, BAND_LIMIT); 456 for (int i = 0; i < BAND_LIMIT; i++) { 457 assert((byte*)&all_band_inits[i+1] 458 < (byte*)all_band_inits+sizeof(all_band_inits)); 459 const band_init& bi = all_band_inits[i]; 460 band& b = tmp_all_bands[i]; 461 coding* defc = coding::findBySpec(bi.defc); 462 assert((defc == null) == (bi.defc == -1)); // no garbage, please 463 assert(defc == null || !defc->isMalloc); 464 assert(bi.bn == i); // band array consistent w/ band enum 465 b.init(u, i, defc); 466 if (bi.index > 0) { 467 b.nullOK = ((bi.index >> 8) & 1); 468 b.ixTag = (bi.index & 0xFF); 469 } 470#ifndef PRODUCT 471 b.name = bi.name; 472#endif 473 } 474 return tmp_all_bands; 475} 476 477void band::initIndexes(unpacker* u) { 478 band* tmp_all_bands = u->all_bands; 479 for (int i = 0; i < BAND_LIMIT; i++) { 480 band* scan = &tmp_all_bands[i]; 481 uint tag = scan->ixTag; // Cf. #define INDEX(tag) above 482 if (tag != 0 && tag != CONSTANT_FieldSpecific && (tag & SUBINDEX_BIT) == 0) { 483 scan->setIndex(u->cp.getIndex(tag)); 484 } 485 } 486} 487