1/* 2 * Copyright (c) 2001, 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 26package com.sun.java.util.jar.pack; 27 28import com.sun.java.util.jar.pack.ConstantPool.Entry; 29import com.sun.java.util.jar.pack.ConstantPool.Index; 30import com.sun.java.util.jar.pack.Package.Class.Field; 31import java.io.BufferedOutputStream; 32import java.io.ByteArrayInputStream; 33import java.io.ByteArrayOutputStream; 34import java.io.EOFException; 35import java.io.File; 36import java.io.FileOutputStream; 37import java.io.FilterInputStream; 38import java.io.FilterOutputStream; 39import java.io.IOException; 40import java.io.InputStream; 41import java.io.OutputStream; 42import java.io.PrintStream; 43import java.util.ArrayList; 44import java.util.Arrays; 45import java.util.Collections; 46import java.util.HashMap; 47import java.util.List; 48import java.util.Map; 49import java.util.jar.Pack200; 50import static com.sun.java.util.jar.pack.Constants.*; 51import java.util.LinkedList; 52 53/** 54 * Define the structure and ordering of "bands" in a packed file. 55 * @author John Rose 56 */ 57abstract 58class BandStructure { 59 static final int MAX_EFFORT = 9; 60 static final int MIN_EFFORT = 1; 61 static final int DEFAULT_EFFORT = 5; 62 63 // Inherit options from Pack200: 64 PropMap p200 = Utils.currentPropMap(); 65 66 int verbose = p200.getInteger(Utils.DEBUG_VERBOSE); 67 int effort = p200.getInteger(Pack200.Packer.EFFORT); 68 { if (effort == 0) effort = DEFAULT_EFFORT; } 69 boolean optDumpBands = p200.getBoolean(Utils.COM_PREFIX+"dump.bands"); 70 boolean optDebugBands = p200.getBoolean(Utils.COM_PREFIX+"debug.bands"); 71 72 // Various heuristic options. 73 boolean optVaryCodings = !p200.getBoolean(Utils.COM_PREFIX+"no.vary.codings"); 74 boolean optBigStrings = !p200.getBoolean(Utils.COM_PREFIX+"no.big.strings"); 75 76 protected abstract Index getCPIndex(byte tag); 77 78 // Local copy of highest class version. 79 private Package.Version highestClassVersion = null; 80 81 /** Call this exactly once, early, to specify the archive major version. */ 82 public void initHighestClassVersion(Package.Version highestClassVersion) throws IOException { 83 if (this.highestClassVersion != null) { 84 throw new IOException( 85 "Highest class major version is already initialized to " + 86 this.highestClassVersion + "; new setting is " + highestClassVersion); 87 } 88 this.highestClassVersion = highestClassVersion; 89 adjustToClassVersion(); 90 } 91 92 public Package.Version getHighestClassVersion() { 93 return highestClassVersion; 94 } 95 96 private final boolean isReader = this instanceof PackageReader; 97 98 protected BandStructure() {} 99 100 static final Coding BYTE1 = Coding.of(1,256); 101 102 static final Coding CHAR3 = Coding.of(3,128); 103 // Note: Tried sharper (3,16) with no post-zip benefit. 104 105 // This is best used with BCI values: 106 static final Coding BCI5 = Coding.of(5,4); // mostly 1-byte offsets 107 static final Coding BRANCH5 = Coding.of(5,4,2); // mostly forward branches 108 109 static final Coding UNSIGNED5 = Coding.of(5,64); 110 static final Coding UDELTA5 = UNSIGNED5.getDeltaCoding(); 111 // "sharp" (5,64) zips 0.4% better than "medium" (5,128) 112 // It zips 1.1% better than "flat" (5,192) 113 114 static final Coding SIGNED5 = Coding.of(5,64,1); //sharp 115 static final Coding DELTA5 = SIGNED5.getDeltaCoding(); 116 // Note: Tried (5,128,2) and (5,192,2) with no benefit. 117 118 static final Coding MDELTA5 = Coding.of(5,64,2).getDeltaCoding(); 119 120 private static final Coding[] basicCodings = { 121 // Table of "Canonical BHSD Codings" from Pack200 spec. 122 null, // _meta_default 123 124 // Fixed-length codings: 125 Coding.of(1,256,0), 126 Coding.of(1,256,1), 127 Coding.of(1,256,0).getDeltaCoding(), 128 Coding.of(1,256,1).getDeltaCoding(), 129 Coding.of(2,256,0), 130 Coding.of(2,256,1), 131 Coding.of(2,256,0).getDeltaCoding(), 132 Coding.of(2,256,1).getDeltaCoding(), 133 Coding.of(3,256,0), 134 Coding.of(3,256,1), 135 Coding.of(3,256,0).getDeltaCoding(), 136 Coding.of(3,256,1).getDeltaCoding(), 137 Coding.of(4,256,0), 138 Coding.of(4,256,1), 139 Coding.of(4,256,0).getDeltaCoding(), 140 Coding.of(4,256,1).getDeltaCoding(), 141 142 // Full-range variable-length codings: 143 Coding.of(5, 4,0), 144 Coding.of(5, 4,1), 145 Coding.of(5, 4,2), 146 Coding.of(5, 16,0), 147 Coding.of(5, 16,1), 148 Coding.of(5, 16,2), 149 Coding.of(5, 32,0), 150 Coding.of(5, 32,1), 151 Coding.of(5, 32,2), 152 Coding.of(5, 64,0), 153 Coding.of(5, 64,1), 154 Coding.of(5, 64,2), 155 Coding.of(5,128,0), 156 Coding.of(5,128,1), 157 Coding.of(5,128,2), 158 159 Coding.of(5, 4,0).getDeltaCoding(), 160 Coding.of(5, 4,1).getDeltaCoding(), 161 Coding.of(5, 4,2).getDeltaCoding(), 162 Coding.of(5, 16,0).getDeltaCoding(), 163 Coding.of(5, 16,1).getDeltaCoding(), 164 Coding.of(5, 16,2).getDeltaCoding(), 165 Coding.of(5, 32,0).getDeltaCoding(), 166 Coding.of(5, 32,1).getDeltaCoding(), 167 Coding.of(5, 32,2).getDeltaCoding(), 168 Coding.of(5, 64,0).getDeltaCoding(), 169 Coding.of(5, 64,1).getDeltaCoding(), 170 Coding.of(5, 64,2).getDeltaCoding(), 171 Coding.of(5,128,0).getDeltaCoding(), 172 Coding.of(5,128,1).getDeltaCoding(), 173 Coding.of(5,128,2).getDeltaCoding(), 174 175 // Variable length subrange codings: 176 Coding.of(2,192,0), 177 Coding.of(2,224,0), 178 Coding.of(2,240,0), 179 Coding.of(2,248,0), 180 Coding.of(2,252,0), 181 182 Coding.of(2, 8,0).getDeltaCoding(), 183 Coding.of(2, 8,1).getDeltaCoding(), 184 Coding.of(2, 16,0).getDeltaCoding(), 185 Coding.of(2, 16,1).getDeltaCoding(), 186 Coding.of(2, 32,0).getDeltaCoding(), 187 Coding.of(2, 32,1).getDeltaCoding(), 188 Coding.of(2, 64,0).getDeltaCoding(), 189 Coding.of(2, 64,1).getDeltaCoding(), 190 Coding.of(2,128,0).getDeltaCoding(), 191 Coding.of(2,128,1).getDeltaCoding(), 192 Coding.of(2,192,0).getDeltaCoding(), 193 Coding.of(2,192,1).getDeltaCoding(), 194 Coding.of(2,224,0).getDeltaCoding(), 195 Coding.of(2,224,1).getDeltaCoding(), 196 Coding.of(2,240,0).getDeltaCoding(), 197 Coding.of(2,240,1).getDeltaCoding(), 198 Coding.of(2,248,0).getDeltaCoding(), 199 Coding.of(2,248,1).getDeltaCoding(), 200 201 Coding.of(3,192,0), 202 Coding.of(3,224,0), 203 Coding.of(3,240,0), 204 Coding.of(3,248,0), 205 Coding.of(3,252,0), 206 207 Coding.of(3, 8,0).getDeltaCoding(), 208 Coding.of(3, 8,1).getDeltaCoding(), 209 Coding.of(3, 16,0).getDeltaCoding(), 210 Coding.of(3, 16,1).getDeltaCoding(), 211 Coding.of(3, 32,0).getDeltaCoding(), 212 Coding.of(3, 32,1).getDeltaCoding(), 213 Coding.of(3, 64,0).getDeltaCoding(), 214 Coding.of(3, 64,1).getDeltaCoding(), 215 Coding.of(3,128,0).getDeltaCoding(), 216 Coding.of(3,128,1).getDeltaCoding(), 217 Coding.of(3,192,0).getDeltaCoding(), 218 Coding.of(3,192,1).getDeltaCoding(), 219 Coding.of(3,224,0).getDeltaCoding(), 220 Coding.of(3,224,1).getDeltaCoding(), 221 Coding.of(3,240,0).getDeltaCoding(), 222 Coding.of(3,240,1).getDeltaCoding(), 223 Coding.of(3,248,0).getDeltaCoding(), 224 Coding.of(3,248,1).getDeltaCoding(), 225 226 Coding.of(4,192,0), 227 Coding.of(4,224,0), 228 Coding.of(4,240,0), 229 Coding.of(4,248,0), 230 Coding.of(4,252,0), 231 232 Coding.of(4, 8,0).getDeltaCoding(), 233 Coding.of(4, 8,1).getDeltaCoding(), 234 Coding.of(4, 16,0).getDeltaCoding(), 235 Coding.of(4, 16,1).getDeltaCoding(), 236 Coding.of(4, 32,0).getDeltaCoding(), 237 Coding.of(4, 32,1).getDeltaCoding(), 238 Coding.of(4, 64,0).getDeltaCoding(), 239 Coding.of(4, 64,1).getDeltaCoding(), 240 Coding.of(4,128,0).getDeltaCoding(), 241 Coding.of(4,128,1).getDeltaCoding(), 242 Coding.of(4,192,0).getDeltaCoding(), 243 Coding.of(4,192,1).getDeltaCoding(), 244 Coding.of(4,224,0).getDeltaCoding(), 245 Coding.of(4,224,1).getDeltaCoding(), 246 Coding.of(4,240,0).getDeltaCoding(), 247 Coding.of(4,240,1).getDeltaCoding(), 248 Coding.of(4,248,0).getDeltaCoding(), 249 Coding.of(4,248,1).getDeltaCoding(), 250 251 null 252 }; 253 private static final Map<Coding, Integer> basicCodingIndexes; 254 static { 255 assert(basicCodings[_meta_default] == null); 256 assert(basicCodings[_meta_canon_min] != null); 257 assert(basicCodings[_meta_canon_max] != null); 258 Map<Coding, Integer> map = new HashMap<>(); 259 for (int i = 0; i < basicCodings.length; i++) { 260 Coding c = basicCodings[i]; 261 if (c == null) continue; 262 assert(i >= _meta_canon_min); 263 assert(i <= _meta_canon_max); 264 map.put(c, i); 265 } 266 basicCodingIndexes = map; 267 } 268 public static Coding codingForIndex(int i) { 269 return i < basicCodings.length ? basicCodings[i] : null; 270 } 271 public static int indexOf(Coding c) { 272 Integer i = basicCodingIndexes.get(c); 273 if (i == null) return 0; 274 return i.intValue(); 275 } 276 public static Coding[] getBasicCodings() { 277 return basicCodings.clone(); 278 } 279 280 protected byte[] bandHeaderBytes; // used for input only 281 protected int bandHeaderBytePos; // BHB read pointer, for input only 282 protected int bandHeaderBytePos0; // for debug 283 284 protected CodingMethod getBandHeader(int XB, Coding regularCoding) { 285 CodingMethod[] res = {null}; 286 // push back XB onto the band header bytes 287 bandHeaderBytes[--bandHeaderBytePos] = (byte) XB; 288 bandHeaderBytePos0 = bandHeaderBytePos; 289 // scan forward through XB and any additional band header bytes 290 bandHeaderBytePos = parseMetaCoding(bandHeaderBytes, 291 bandHeaderBytePos, 292 regularCoding, 293 res); 294 return res[0]; 295 } 296 297 public static int parseMetaCoding(byte[] bytes, int pos, Coding dflt, CodingMethod[] res) { 298 if ((bytes[pos] & 0xFF) == _meta_default) { 299 res[0] = dflt; 300 return pos+1; 301 } 302 int pos2; 303 pos2 = Coding.parseMetaCoding(bytes, pos, dflt, res); 304 if (pos2 > pos) return pos2; 305 pos2 = PopulationCoding.parseMetaCoding(bytes, pos, dflt, res); 306 if (pos2 > pos) return pos2; 307 pos2 = AdaptiveCoding.parseMetaCoding(bytes, pos, dflt, res); 308 if (pos2 > pos) return pos2; 309 throw new RuntimeException("Bad meta-coding op "+(bytes[pos]&0xFF)); 310 } 311 312 static final int SHORT_BAND_HEURISTIC = 100; 313 314 public static final int NO_PHASE = 0; 315 316 // package writing phases: 317 public static final int COLLECT_PHASE = 1; // collect data before write 318 public static final int FROZEN_PHASE = 3; // no longer collecting 319 public static final int WRITE_PHASE = 5; // ready to write bytes 320 321 // package reading phases: 322 public static final int EXPECT_PHASE = 2; // gather expected counts 323 public static final int READ_PHASE = 4; // ready to read bytes 324 public static final int DISBURSE_PHASE = 6; // pass out data after read 325 326 public static final int DONE_PHASE = 8; // done writing or reading 327 328 static boolean phaseIsRead(int p) { 329 return (p % 2) == 0; 330 } 331 static int phaseCmp(int p0, int p1) { 332 assert((p0 % 2) == (p1 % 2) || (p0 % 8) == 0 || (p1 % 8) == 0); 333 return p0 - p1; 334 } 335 336 /** The packed file is divided up into a number of segments. 337 * Most segments are typed as ValueBand, strongly-typed sequences 338 * of integer values, all interpreted in a single way. 339 * A few segments are ByteBands, which hetergeneous sequences 340 * of bytes. 341 * 342 * The two phases for writing a packed file are COLLECT and WRITE. 343 * 1. When writing a packed file, each band collects 344 * data in an ad-hoc order. 345 * 2. At the end, each band is assigned a coding scheme, 346 * and then all the bands are written in their global order. 347 * 348 * The three phases for reading a packed file are EXPECT, READ, 349 * and DISBURSE. 350 * 1. For each band, the expected number of integers is determined. 351 * 2. The data is actually read from the file into the band. 352 * 3. The band pays out its values as requested, in an ad hoc order. 353 * 354 * When the last phase of a band is done, it is marked so (DONE). 355 * Clearly, these phases must be properly ordered WRT each other. 356 */ 357 abstract class Band { 358 private int phase = NO_PHASE; 359 private final String name; 360 361 private int valuesExpected; 362 363 protected long outputSize = -1; // cache 364 365 public final Coding regularCoding; 366 367 public final int seqForDebug; 368 public int elementCountForDebug; 369 370 371 protected Band(String name, Coding regularCoding) { 372 this.name = name; 373 this.regularCoding = regularCoding; 374 this.seqForDebug = ++nextSeqForDebug; 375 if (verbose > 2) 376 Utils.log.fine("Band "+seqForDebug+" is "+name); 377 // caller must call init 378 } 379 380 public Band init() { 381 // Cannot due this from the constructor, because constructor 382 // may wish to initialize some subclass variables. 383 // Set initial phase for reading or writing: 384 if (isReader) 385 readyToExpect(); 386 else 387 readyToCollect(); 388 return this; 389 } 390 391 // common operations 392 boolean isReader() { return isReader; } 393 int phase() { return phase; } 394 String name() { return name; } 395 396 /** Return -1 if data buffer not allocated, else max length. */ 397 public abstract int capacity(); 398 399 /** Allocate data buffer to specified length. */ 400 protected abstract void setCapacity(int cap); 401 402 /** Return current number of values in buffer, which must exist. */ 403 public abstract int length(); 404 405 protected abstract int valuesRemainingForDebug(); 406 407 public final int valuesExpected() { 408 return valuesExpected; 409 } 410 411 /** Write out bytes, encoding the values. */ 412 public final void writeTo(OutputStream out) throws IOException { 413 assert(assertReadyToWriteTo(this, out)); 414 setPhase(WRITE_PHASE); 415 // subclasses continue by writing their contents to output 416 writeDataTo(out); 417 doneWriting(); 418 } 419 420 abstract void chooseBandCodings() throws IOException; 421 422 public final long outputSize() { 423 if (outputSize >= 0) { 424 long size = outputSize; 425 assert(size == computeOutputSize()); 426 return size; 427 } 428 return computeOutputSize(); 429 } 430 431 protected abstract long computeOutputSize(); 432 433 protected abstract void writeDataTo(OutputStream out) throws IOException; 434 435 /** Expect a certain number of values. */ 436 void expectLength(int l) { 437 assert(assertPhase(this, EXPECT_PHASE)); 438 assert(valuesExpected == 0); // all at once 439 assert(l >= 0); 440 valuesExpected = l; 441 } 442 /** Expect more values. (Multiple calls accumulate.) */ 443 void expectMoreLength(int l) { 444 assert(assertPhase(this, EXPECT_PHASE)); 445 valuesExpected += l; 446 } 447 448 449 /// Phase change markers. 450 451 private void readyToCollect() { // called implicitly by constructor 452 setCapacity(1); 453 setPhase(COLLECT_PHASE); 454 } 455 protected void doneWriting() { 456 assert(assertPhase(this, WRITE_PHASE)); 457 setPhase(DONE_PHASE); 458 } 459 private void readyToExpect() { // called implicitly by constructor 460 setPhase(EXPECT_PHASE); 461 } 462 /** Read in bytes, decoding the values. */ 463 public final void readFrom(InputStream in) throws IOException { 464 assert(assertReadyToReadFrom(this, in)); 465 setCapacity(valuesExpected()); 466 setPhase(READ_PHASE); 467 // subclasses continue by reading their contents from input: 468 readDataFrom(in); 469 readyToDisburse(); 470 } 471 protected abstract void readDataFrom(InputStream in) throws IOException; 472 protected void readyToDisburse() { 473 if (verbose > 1) Utils.log.fine("readyToDisburse "+this); 474 setPhase(DISBURSE_PHASE); 475 } 476 public void doneDisbursing() { 477 assert(assertPhase(this, DISBURSE_PHASE)); 478 setPhase(DONE_PHASE); 479 } 480 public final void doneWithUnusedBand() { 481 if (isReader) { 482 assert(assertPhase(this, EXPECT_PHASE)); 483 assert(valuesExpected() == 0); 484 // Fast forward: 485 setPhase(READ_PHASE); 486 setPhase(DISBURSE_PHASE); 487 setPhase(DONE_PHASE); 488 } else { 489 setPhase(FROZEN_PHASE); 490 } 491 } 492 493 protected void setPhase(int newPhase) { 494 assert(assertPhaseChangeOK(this, phase, newPhase)); 495 this.phase = newPhase; 496 } 497 498 protected int lengthForDebug = -1; // DEBUG ONLY 499 @Override 500 public String toString() { // DEBUG ONLY 501 int length = (lengthForDebug != -1 ? lengthForDebug : length()); 502 String str = name; 503 if (length != 0) 504 str += "[" + length + "]"; 505 if (elementCountForDebug != 0) 506 str += "(" + elementCountForDebug + ")"; 507 return str; 508 } 509 } 510 511 class ValueBand extends Band { 512 private int[] values; // must be null in EXPECT phase 513 private int length; 514 private int valuesDisbursed; 515 516 private CodingMethod bandCoding; 517 private byte[] metaCoding; 518 519 protected ValueBand(String name, Coding regularCoding) { 520 super(name, regularCoding); 521 } 522 523 @Override 524 public int capacity() { 525 return values == null ? -1 : values.length; 526 } 527 528 /** Declare predicted or needed capacity. */ 529 @Override 530 protected void setCapacity(int cap) { 531 assert(length <= cap); 532 if (cap == -1) { values = null; return; } 533 values = realloc(values, cap); 534 } 535 536 @Override 537 public int length() { 538 return length; 539 } 540 @Override 541 protected int valuesRemainingForDebug() { 542 return length - valuesDisbursed; 543 } 544 protected int valueAtForDebug(int i) { 545 return values[i]; 546 } 547 548 void patchValue(int i, int value) { 549 // Only one use for this. 550 assert(this == archive_header_S); 551 assert(i == AH_ARCHIVE_SIZE_HI || i == AH_ARCHIVE_SIZE_LO); 552 assert(i < length); // must have already output a dummy 553 values[i] = value; 554 outputSize = -1; // decache 555 } 556 557 protected void initializeValues(int[] values) { 558 assert(assertCanChangeLength(this)); 559 assert(length == 0); 560 this.values = values; 561 this.length = values.length; 562 } 563 564 /** Collect one value, or store one decoded value. */ 565 protected void addValue(int x) { 566 assert(assertCanChangeLength(this)); 567 if (length == values.length) 568 setCapacity(length < 1000 ? length * 10 : length * 2); 569 values[length++] = x; 570 } 571 572 private boolean canVaryCoding() { 573 if (!optVaryCodings) return false; 574 if (length == 0) return false; 575 // Can't read band_headers w/o the archive header: 576 if (this == archive_header_0) return false; 577 if (this == archive_header_S) return false; 578 if (this == archive_header_1) return false; 579 // BYTE1 bands can't vary codings, but the others can. 580 // All that's needed for the initial escape is at least 581 // 256 negative values or more than 256 non-negative values 582 return (regularCoding.min() <= -256 || regularCoding.max() >= 256); 583 } 584 585 private boolean shouldVaryCoding() { 586 assert(canVaryCoding()); 587 if (effort < MAX_EFFORT && length < SHORT_BAND_HEURISTIC) 588 return false; 589 return true; 590 } 591 592 @Override 593 protected void chooseBandCodings() throws IOException { 594 boolean canVary = canVaryCoding(); 595 if (!canVary || !shouldVaryCoding()) { 596 if (regularCoding.canRepresent(values, 0, length)) { 597 bandCoding = regularCoding; 598 } else { 599 assert(canVary); 600 if (verbose > 1) 601 Utils.log.fine("regular coding fails in band "+name()); 602 bandCoding = UNSIGNED5; 603 } 604 outputSize = -1; 605 } else { 606 int[] sizes = {0,0}; 607 bandCoding = chooseCoding(values, 0, length, 608 regularCoding, name(), 609 sizes); 610 outputSize = sizes[CodingChooser.BYTE_SIZE]; 611 if (outputSize == 0) // CodingChooser failed to size it. 612 outputSize = -1; 613 } 614 615 // Compute and save the meta-coding bytes also. 616 if (bandCoding != regularCoding) { 617 metaCoding = bandCoding.getMetaCoding(regularCoding); 618 if (verbose > 1) { 619 Utils.log.fine("alternate coding "+this+" "+bandCoding); 620 } 621 } else if (canVary && 622 decodeEscapeValue(values[0], regularCoding) >= 0) { 623 // Need an explicit default. 624 metaCoding = defaultMetaCoding; 625 } else { 626 // Common case: Zero bytes of meta coding. 627 metaCoding = noMetaCoding; 628 } 629 if (metaCoding.length > 0 630 && (verbose > 2 || verbose > 1 && metaCoding.length > 1)) { 631 StringBuilder sb = new StringBuilder(); 632 for (int i = 0; i < metaCoding.length; i++) { 633 if (i == 1) sb.append(" /"); 634 sb.append(" ").append(metaCoding[i] & 0xFF); 635 } 636 Utils.log.fine(" meta-coding "+sb); 637 } 638 639 assert((outputSize < 0) || 640 !(bandCoding instanceof Coding) || 641 (outputSize == ((Coding)bandCoding) 642 .getLength(values, 0, length))) 643 : (bandCoding+" : "+ 644 outputSize+" != "+ 645 ((Coding)bandCoding).getLength(values, 0, length) 646 +" ?= "+getCodingChooser().computeByteSize(bandCoding,values,0,length) 647 ); 648 649 // Compute outputSize of the escape value X, if any. 650 if (metaCoding.length > 0) { 651 // First byte XB of meta-coding is treated specially, 652 // but any other bytes go into the band headers band. 653 // This must be done before any other output happens. 654 if (outputSize >= 0) 655 outputSize += computeEscapeSize(); // good cache 656 // Other bytes go into band_headers. 657 for (int i = 1; i < metaCoding.length; i++) { 658 band_headers.putByte(metaCoding[i] & 0xFF); 659 } 660 } 661 } 662 663 @Override 664 protected long computeOutputSize() { 665 outputSize = getCodingChooser().computeByteSize(bandCoding, 666 values, 0, length); 667 assert(outputSize < Integer.MAX_VALUE); 668 outputSize += computeEscapeSize(); 669 return outputSize; 670 } 671 672 protected int computeEscapeSize() { 673 if (metaCoding.length == 0) return 0; 674 int XB = metaCoding[0] & 0xFF; 675 int X = encodeEscapeValue(XB, regularCoding); 676 return regularCoding.setD(0).getLength(X); 677 } 678 679 @Override 680 protected void writeDataTo(OutputStream out) throws IOException { 681 if (length == 0) return; // nothing to write 682 long len0 = 0; 683 if (out == outputCounter) { 684 len0 = outputCounter.getCount(); 685 } 686 if (metaCoding.length > 0) { 687 int XB = metaCoding[0] & 0xFF; 688 // We need an explicit band header, either because 689 // there is a non-default coding method, or because 690 // the first value would be parsed as an escape value. 691 int X = encodeEscapeValue(XB, regularCoding); 692 //System.out.println("X="+X+" XB="+XB+" in "+this); 693 regularCoding.setD(0).writeTo(out, X); 694 } 695 bandCoding.writeArrayTo(out, values, 0, length); 696 if (out == outputCounter) { 697 assert(outputSize == outputCounter.getCount() - len0) 698 : (outputSize+" != "+outputCounter.getCount()+"-"+len0); 699 } 700 if (optDumpBands) dumpBand(); 701 } 702 703 @Override 704 protected void readDataFrom(InputStream in) throws IOException { 705 length = valuesExpected(); 706 if (length == 0) return; // nothing to read 707 if (verbose > 1) 708 Utils.log.fine("Reading band "+this); 709 if (!canVaryCoding()) { 710 bandCoding = regularCoding; 711 metaCoding = noMetaCoding; 712 } else { 713 assert(in.markSupported()); // input must be buffered 714 in.mark(Coding.B_MAX); 715 int X = regularCoding.setD(0).readFrom(in); 716 int XB = decodeEscapeValue(X, regularCoding); 717 if (XB < 0) { 718 // Do not consume this value. No alternate coding. 719 in.reset(); 720 bandCoding = regularCoding; 721 metaCoding = noMetaCoding; 722 } else if (XB == _meta_default) { 723 bandCoding = regularCoding; 724 metaCoding = defaultMetaCoding; 725 } else { 726 if (verbose > 2) 727 Utils.log.fine("found X="+X+" => XB="+XB); 728 bandCoding = getBandHeader(XB, regularCoding); 729 // This is really used only by dumpBands. 730 int p0 = bandHeaderBytePos0; 731 int p1 = bandHeaderBytePos; 732 metaCoding = new byte[p1-p0]; 733 System.arraycopy(bandHeaderBytes, p0, 734 metaCoding, 0, metaCoding.length); 735 } 736 } 737 if (bandCoding != regularCoding) { 738 if (verbose > 1) 739 Utils.log.fine(name()+": irregular coding "+bandCoding); 740 } 741 bandCoding.readArrayFrom(in, values, 0, length); 742 if (optDumpBands) dumpBand(); 743 } 744 745 @Override 746 public void doneDisbursing() { 747 super.doneDisbursing(); 748 values = null; // for GC 749 } 750 751 private void dumpBand() throws IOException { 752 assert(optDumpBands); 753 try (PrintStream ps = new PrintStream(getDumpStream(this, ".txt"))) { 754 String irr = (bandCoding == regularCoding) ? "" : " irregular"; 755 ps.print("# length="+length+ 756 " size="+outputSize()+ 757 irr+" coding="+bandCoding); 758 if (metaCoding != noMetaCoding) { 759 StringBuilder sb = new StringBuilder(); 760 for (int i = 0; i < metaCoding.length; i++) { 761 if (i == 1) sb.append(" /"); 762 sb.append(" ").append(metaCoding[i] & 0xFF); 763 } 764 ps.print(" //header: "+sb); 765 } 766 printArrayTo(ps, values, 0, length); 767 } 768 try (OutputStream ds = getDumpStream(this, ".bnd")) { 769 bandCoding.writeArrayTo(ds, values, 0, length); 770 } 771 } 772 773 /** Disburse one value. */ 774 protected int getValue() { 775 assert(phase() == DISBURSE_PHASE); 776 // when debugging return a zero if lengths are zero 777 if (optDebugBands && length == 0 && valuesDisbursed == length) 778 return 0; 779 assert(valuesDisbursed <= length); 780 return values[valuesDisbursed++]; 781 } 782 783 /** Reset for another pass over the same value set. */ 784 public void resetForSecondPass() { 785 assert(phase() == DISBURSE_PHASE); 786 assert(valuesDisbursed == length()); // 1st pass is complete 787 valuesDisbursed = 0; 788 } 789 } 790 791 class ByteBand extends Band { 792 private ByteArrayOutputStream bytes; // input buffer 793 private ByteArrayOutputStream bytesForDump; 794 private InputStream in; 795 796 public ByteBand(String name) { 797 super(name, BYTE1); 798 } 799 800 @Override 801 public int capacity() { 802 return bytes == null ? -1 : Integer.MAX_VALUE; 803 } 804 @Override 805 protected void setCapacity(int cap) { 806 assert(bytes == null); // do this just once 807 bytes = new ByteArrayOutputStream(cap); 808 } 809 public void destroy() { 810 lengthForDebug = length(); 811 bytes = null; 812 } 813 814 @Override 815 public int length() { 816 return bytes == null ? -1 : bytes.size(); 817 } 818 public void reset() { 819 bytes.reset(); 820 } 821 @Override 822 protected int valuesRemainingForDebug() { 823 return (bytes == null) ? -1 : ((ByteArrayInputStream)in).available(); 824 } 825 826 @Override 827 protected void chooseBandCodings() throws IOException { 828 // No-op. 829 assert(decodeEscapeValue(regularCoding.min(), regularCoding) < 0); 830 assert(decodeEscapeValue(regularCoding.max(), regularCoding) < 0); 831 } 832 833 @Override 834 protected long computeOutputSize() { 835 // do not cache 836 return bytes.size(); 837 } 838 839 @Override 840 public void writeDataTo(OutputStream out) throws IOException { 841 if (length() == 0) return; 842 bytes.writeTo(out); 843 if (optDumpBands) dumpBand(); 844 destroy(); // done with the bits! 845 } 846 847 private void dumpBand() throws IOException { 848 assert(optDumpBands); 849 try (OutputStream ds = getDumpStream(this, ".bnd")) { 850 if (bytesForDump != null) 851 bytesForDump.writeTo(ds); 852 else 853 bytes.writeTo(ds); 854 } 855 } 856 857 @Override 858 public void readDataFrom(InputStream in) throws IOException { 859 int vex = valuesExpected(); 860 if (vex == 0) return; 861 if (verbose > 1) { 862 lengthForDebug = vex; 863 Utils.log.fine("Reading band "+this); 864 lengthForDebug = -1; 865 } 866 byte[] buf = new byte[Math.min(vex, 1<<14)]; 867 while (vex > 0) { 868 int nr = in.read(buf, 0, Math.min(vex, buf.length)); 869 if (nr < 0) throw new EOFException(); 870 bytes.write(buf, 0, nr); 871 vex -= nr; 872 } 873 if (optDumpBands) dumpBand(); 874 } 875 876 @Override 877 public void readyToDisburse() { 878 in = new ByteArrayInputStream(bytes.toByteArray()); 879 super.readyToDisburse(); 880 } 881 882 @Override 883 public void doneDisbursing() { 884 super.doneDisbursing(); 885 if (optDumpBands 886 && bytesForDump != null && bytesForDump.size() > 0) { 887 try { 888 dumpBand(); 889 } catch (IOException ee) { 890 throw new RuntimeException(ee); 891 } 892 } 893 in = null; // GC 894 bytes = null; // GC 895 bytesForDump = null; // GC 896 } 897 898 // alternative to readFrom: 899 public void setInputStreamFrom(InputStream in) throws IOException { 900 assert(bytes == null); 901 assert(assertReadyToReadFrom(this, in)); 902 setPhase(READ_PHASE); 903 this.in = in; 904 if (optDumpBands) { 905 // Tap the stream. 906 bytesForDump = new ByteArrayOutputStream(); 907 this.in = new FilterInputStream(in) { 908 @Override 909 public int read() throws IOException { 910 int ch = in.read(); 911 if (ch >= 0) bytesForDump.write(ch); 912 return ch; 913 } 914 @Override 915 public int read(byte b[], int off, int len) throws IOException { 916 int nr = in.read(b, off, len); 917 if (nr >= 0) bytesForDump.write(b, off, nr); 918 return nr; 919 } 920 }; 921 } 922 super.readyToDisburse(); 923 } 924 925 public OutputStream collectorStream() { 926 assert(phase() == COLLECT_PHASE); 927 assert(bytes != null); 928 return bytes; 929 } 930 931 public InputStream getInputStream() { 932 assert(phase() == DISBURSE_PHASE); 933 assert(in != null); 934 return in; 935 } 936 public int getByte() throws IOException { 937 int b = getInputStream().read(); 938 if (b < 0) throw new EOFException(); 939 return b; 940 } 941 public void putByte(int b) throws IOException { 942 assert(b == (b & 0xFF)); 943 collectorStream().write(b); 944 } 945 @Override 946 public String toString() { 947 return "byte "+super.toString(); 948 } 949 } 950 951 class IntBand extends ValueBand { 952 // The usual coding for bands is 7bit/5byte/delta. 953 public IntBand(String name, Coding regularCoding) { 954 super(name, regularCoding); 955 } 956 957 public void putInt(int x) { 958 assert(phase() == COLLECT_PHASE); 959 addValue(x); 960 } 961 962 public int getInt() { 963 return getValue(); 964 } 965 /** Return the sum of all values in this band. */ 966 public int getIntTotal() { 967 assert(phase() == DISBURSE_PHASE); 968 // assert that this is the whole pass; no other reads allowed 969 assert(valuesRemainingForDebug() == length()); 970 int total = 0; 971 for (int k = length(); k > 0; k--) { 972 total += getInt(); 973 } 974 resetForSecondPass(); 975 return total; 976 } 977 /** Return the occurrence count of a specific value in this band. */ 978 public int getIntCount(int value) { 979 assert(phase() == DISBURSE_PHASE); 980 // assert that this is the whole pass; no other reads allowed 981 assert(valuesRemainingForDebug() == length()); 982 int total = 0; 983 for (int k = length(); k > 0; k--) { 984 if (getInt() == value) { 985 total += 1; 986 } 987 } 988 resetForSecondPass(); 989 return total; 990 } 991 } 992 993 static int getIntTotal(int[] values) { 994 int total = 0; 995 for (int i = 0; i < values.length; i++) { 996 total += values[i]; 997 } 998 return total; 999 } 1000 1001 class CPRefBand extends ValueBand { 1002 Index index; 1003 boolean nullOK; 1004 1005 public CPRefBand(String name, Coding regularCoding, byte cpTag, boolean nullOK) { 1006 super(name, regularCoding); 1007 this.nullOK = nullOK; 1008 if (cpTag != CONSTANT_None) 1009 setBandIndex(this, cpTag); 1010 } 1011 public CPRefBand(String name, Coding regularCoding, byte cpTag) { 1012 this(name, regularCoding, cpTag, false); 1013 } 1014 public CPRefBand(String name, Coding regularCoding, Object undef) { 1015 this(name, regularCoding, CONSTANT_None, false); 1016 } 1017 1018 public void setIndex(Index index) { 1019 this.index = index; 1020 } 1021 1022 protected void readDataFrom(InputStream in) throws IOException { 1023 super.readDataFrom(in); 1024 assert(assertValidCPRefs(this)); 1025 } 1026 1027 /** Write a constant pool reference. */ 1028 public void putRef(Entry e) { 1029 addValue(encodeRefOrNull(e, index)); 1030 } 1031 public void putRef(Entry e, Index index) { 1032 assert(this.index == null); 1033 addValue(encodeRefOrNull(e, index)); 1034 } 1035 public void putRef(Entry e, byte cptag) { 1036 putRef(e, getCPIndex(cptag)); 1037 } 1038 1039 public Entry getRef() { 1040 if (index == null) Utils.log.warning("No index for "+this); 1041 assert(index != null); 1042 return decodeRefOrNull(getValue(), index); 1043 } 1044 public Entry getRef(Index index) { 1045 assert(this.index == null); 1046 return decodeRefOrNull(getValue(), index); 1047 } 1048 public Entry getRef(byte cptag) { 1049 return getRef(getCPIndex(cptag)); 1050 } 1051 1052 private int encodeRefOrNull(Entry e, Index index) { 1053 int nonNullCode; // NNC is the coding which assumes nulls are rare 1054 if (e == null) { 1055 nonNullCode = -1; // negative values are rare 1056 } else { 1057 nonNullCode = encodeRef(e, index); 1058 } 1059 // If nulls are expected, increment, to make -1 code turn to 0. 1060 return (nullOK ? 1 : 0) + nonNullCode; 1061 } 1062 private Entry decodeRefOrNull(int code, Index index) { 1063 // Inverse to encodeRefOrNull... 1064 int nonNullCode = code - (nullOK ? 1 : 0); 1065 if (nonNullCode == -1) { 1066 return null; 1067 } else { 1068 return decodeRef(nonNullCode, index); 1069 } 1070 } 1071 } 1072 1073 // Bootstrap support for CPRefBands. These are needed to record 1074 // intended CP indexes, before the CP has been created. 1075 private final List<CPRefBand> allKQBands = new ArrayList<>(); 1076 private List<Object[]> needPredefIndex = new ArrayList<>(); 1077 1078 1079 int encodeRef(Entry e, Index ix) { 1080 if (ix == null) 1081 throw new RuntimeException("null index for " + e.stringValue()); 1082 int coding = ix.indexOf(e); 1083 if (verbose > 2) 1084 Utils.log.fine("putRef "+coding+" => "+e); 1085 return coding; 1086 } 1087 1088 Entry decodeRef(int n, Index ix) { 1089 if (n < 0 || n >= ix.size()) 1090 Utils.log.warning("decoding bad ref "+n+" in "+ix); 1091 Entry e = ix.getEntry(n); 1092 if (verbose > 2) 1093 Utils.log.fine("getRef "+n+" => "+e); 1094 return e; 1095 } 1096 1097 private CodingChooser codingChooser; 1098 protected CodingChooser getCodingChooser() { 1099 if (codingChooser == null) { 1100 codingChooser = new CodingChooser(effort, basicCodings); 1101 if (codingChooser.stress != null 1102 && this instanceof PackageWriter) { 1103 // Twist the random state based on my first file. 1104 // This sends each segment off in a different direction. 1105 List<Package.Class> classes = ((PackageWriter)this).pkg.classes; 1106 if (!classes.isEmpty()) { 1107 Package.Class cls = classes.get(0); 1108 codingChooser.addStressSeed(cls.getName().hashCode()); 1109 } 1110 } 1111 } 1112 return codingChooser; 1113 } 1114 1115 public CodingMethod chooseCoding(int[] values, int start, int end, 1116 Coding regular, String bandName, 1117 int[] sizes) { 1118 assert(optVaryCodings); 1119 if (effort <= MIN_EFFORT) { 1120 return regular; 1121 } 1122 CodingChooser cc = getCodingChooser(); 1123 if (verbose > 1 || cc.verbose > 1) { 1124 Utils.log.fine("--- chooseCoding "+bandName); 1125 } 1126 return cc.choose(values, start, end, regular, sizes); 1127 } 1128 1129 static final byte[] defaultMetaCoding = { _meta_default }; 1130 static final byte[] noMetaCoding = {}; 1131 1132 // The first value in a band is always coded with the default coding D. 1133 // If this first value X is an escape value, it actually represents the 1134 // first (and perhaps only) byte of a meta-coding. 1135 // 1136 // If D.S != 0 and D includes the range [-256..-1], 1137 // the escape values are in that range, 1138 // and the first byte XB is -1-X. 1139 // 1140 // If D.S == 0 and D includes the range [(D.L)..(D.L)+255], 1141 // the escape values are in that range, 1142 // and XB is X-(D.L). 1143 // 1144 // This representation is designed so that a band header is unlikely 1145 // to be confused with the initial value of a headerless band, 1146 // and yet so that a band header is likely to occupy only a byte or two. 1147 // 1148 // Result is in [0..255] if XB was successfully extracted, else -1. 1149 // See section "Coding Specifier Meta-Encoding" in the JSR 200 spec. 1150 protected static int decodeEscapeValue(int X, Coding regularCoding) { 1151 // The first value in a band is always coded with the default coding D. 1152 // If this first value X is an escape value, it actually represents the 1153 // first (and perhaps only) byte of a meta-coding. 1154 // Result is in [0..255] if XB was successfully extracted, else -1. 1155 if (regularCoding.B() == 1 || regularCoding.L() == 0) 1156 return -1; // degenerate regular coding (BYTE1) 1157 if (regularCoding.S() != 0) { 1158 if (-256 <= X && X <= -1 && regularCoding.min() <= -256) { 1159 int XB = -1-X; 1160 assert(XB >= 0 && XB < 256); 1161 return XB; 1162 } 1163 } else { 1164 int L = regularCoding.L(); 1165 if (L <= X && X <= L+255 && regularCoding.max() >= L+255) { 1166 int XB = X-L; 1167 assert(XB >= 0 && XB < 256); 1168 return XB; 1169 } 1170 } 1171 return -1; // negative value for failure 1172 } 1173 // Inverse to decodeEscapeValue(). 1174 protected static int encodeEscapeValue(int XB, Coding regularCoding) { 1175 assert(XB >= 0 && XB < 256); 1176 assert(regularCoding.B() > 1 && regularCoding.L() > 0); 1177 int X; 1178 if (regularCoding.S() != 0) { 1179 assert(regularCoding.min() <= -256); 1180 X = -1-XB; 1181 } else { 1182 int L = regularCoding.L(); 1183 assert(regularCoding.max() >= L+255); 1184 X = XB+L; 1185 } 1186 assert(decodeEscapeValue(X, regularCoding) == XB) 1187 : (regularCoding+" XB="+XB+" X="+X); 1188 return X; 1189 } 1190 1191 static { 1192 boolean checkXB = false; 1193 assert(checkXB = true); 1194 if (checkXB) { 1195 for (int i = 0; i < basicCodings.length; i++) { 1196 Coding D = basicCodings[i]; 1197 if (D == null) continue; 1198 if (D.B() == 1) continue; 1199 if (D.L() == 0) continue; 1200 for (int XB = 0; XB <= 255; XB++) { 1201 // The following exercises decodeEscapeValue also: 1202 encodeEscapeValue(XB, D); 1203 } 1204 } 1205 } 1206 } 1207 1208 class MultiBand extends Band { 1209 MultiBand(String name, Coding regularCoding) { 1210 super(name, regularCoding); 1211 } 1212 1213 @Override 1214 public Band init() { 1215 super.init(); 1216 // This is all just to keep the asserts happy: 1217 setCapacity(0); 1218 if (phase() == EXPECT_PHASE) { 1219 // Fast forward: 1220 setPhase(READ_PHASE); 1221 setPhase(DISBURSE_PHASE); 1222 } 1223 return this; 1224 } 1225 1226 Band[] bands = new Band[10]; 1227 int bandCount = 0; 1228 1229 int size() { 1230 return bandCount; 1231 } 1232 Band get(int i) { 1233 assert(i < bandCount); 1234 return bands[i]; 1235 } 1236 Band[] toArray() { 1237 return (Band[]) realloc(bands, bandCount); 1238 } 1239 1240 void add(Band b) { 1241 assert(bandCount == 0 || notePrevForAssert(b, bands[bandCount-1])); 1242 if (bandCount == bands.length) { 1243 bands = (Band[]) realloc(bands); 1244 } 1245 bands[bandCount++] = b; 1246 } 1247 1248 ByteBand newByteBand(String name) { 1249 ByteBand b = new ByteBand(name); 1250 b.init(); add(b); 1251 return b; 1252 } 1253 IntBand newIntBand(String name) { 1254 IntBand b = new IntBand(name, regularCoding); 1255 b.init(); add(b); 1256 return b; 1257 } 1258 IntBand newIntBand(String name, Coding regularCoding) { 1259 IntBand b = new IntBand(name, regularCoding); 1260 b.init(); add(b); 1261 return b; 1262 } 1263 MultiBand newMultiBand(String name, Coding regularCoding) { 1264 MultiBand b = new MultiBand(name, regularCoding); 1265 b.init(); add(b); 1266 return b; 1267 } 1268 CPRefBand newCPRefBand(String name, byte cpTag) { 1269 CPRefBand b = new CPRefBand(name, regularCoding, cpTag); 1270 b.init(); add(b); 1271 return b; 1272 } 1273 CPRefBand newCPRefBand(String name, Coding regularCoding, 1274 byte cpTag) { 1275 CPRefBand b = new CPRefBand(name, regularCoding, cpTag); 1276 b.init(); add(b); 1277 return b; 1278 } 1279 CPRefBand newCPRefBand(String name, Coding regularCoding, 1280 byte cpTag, boolean nullOK) { 1281 CPRefBand b = new CPRefBand(name, regularCoding, cpTag, nullOK); 1282 b.init(); add(b); 1283 return b; 1284 } 1285 1286 int bandCount() { return bandCount; } 1287 1288 private int cap = -1; 1289 @Override 1290 public int capacity() { return cap; } 1291 @Override 1292 public void setCapacity(int cap) { this.cap = cap; } 1293 1294 @Override 1295 public int length() { return 0; } 1296 @Override 1297 public int valuesRemainingForDebug() { return 0; } 1298 1299 @Override 1300 protected void chooseBandCodings() throws IOException { 1301 // coding decision pass 1302 for (int i = 0; i < bandCount; i++) { 1303 Band b = bands[i]; 1304 b.chooseBandCodings(); 1305 } 1306 } 1307 1308 @Override 1309 protected long computeOutputSize() { 1310 // coding decision pass 1311 long sum = 0; 1312 for (int i = 0; i < bandCount; i++) { 1313 Band b = bands[i]; 1314 long bsize = b.outputSize(); 1315 assert(bsize >= 0) : b; 1316 sum += bsize; 1317 } 1318 // do not cache 1319 return sum; 1320 } 1321 1322 @Override 1323 protected void writeDataTo(OutputStream out) throws IOException { 1324 long preCount = 0; 1325 if (outputCounter != null) preCount = outputCounter.getCount(); 1326 for (int i = 0; i < bandCount; i++) { 1327 Band b = bands[i]; 1328 b.writeTo(out); 1329 if (outputCounter != null) { 1330 long postCount = outputCounter.getCount(); 1331 long len = postCount - preCount; 1332 preCount = postCount; 1333 if ((verbose > 0 && len > 0) || verbose > 1) { 1334 Utils.log.info(" ...wrote "+len+" bytes from "+b); 1335 } 1336 } 1337 } 1338 } 1339 1340 @Override 1341 protected void readDataFrom(InputStream in) throws IOException { 1342 assert(false); // not called? 1343 for (int i = 0; i < bandCount; i++) { 1344 Band b = bands[i]; 1345 b.readFrom(in); 1346 if ((verbose > 0 && b.length() > 0) || verbose > 1) { 1347 Utils.log.info(" ...read "+b); 1348 } 1349 } 1350 } 1351 1352 @Override 1353 public String toString() { 1354 return "{"+bandCount()+" bands: "+super.toString()+"}"; 1355 } 1356 } 1357 1358 /** 1359 * An output stream which counts the number of bytes written. 1360 */ 1361 private static 1362 class ByteCounter extends FilterOutputStream { 1363 // (should go public under the name CountingOutputStream?) 1364 1365 private long count; 1366 1367 public ByteCounter(OutputStream out) { 1368 super(out); 1369 } 1370 1371 public long getCount() { return count; } 1372 public void setCount(long c) { count = c; } 1373 1374 @Override 1375 public void write(int b) throws IOException { 1376 count++; 1377 if (out != null) out.write(b); 1378 } 1379 @Override 1380 public void write(byte b[], int off, int len) throws IOException { 1381 count += len; 1382 if (out != null) out.write(b, off, len); 1383 } 1384 @Override 1385 public String toString() { 1386 return String.valueOf(getCount()); 1387 } 1388 } 1389 ByteCounter outputCounter; 1390 1391 void writeAllBandsTo(OutputStream out) throws IOException { 1392 // Wrap a byte-counter around the output stream. 1393 outputCounter = new ByteCounter(out); 1394 out = outputCounter; 1395 all_bands.writeTo(out); 1396 if (verbose > 0) { 1397 long nbytes = outputCounter.getCount(); 1398 Utils.log.info("Wrote total of "+nbytes+" bytes."); 1399 assert(nbytes == archiveSize0+archiveSize1); 1400 } 1401 outputCounter = null; 1402 } 1403 1404 // random AO_XXX bits, decoded from the archive header 1405 protected int archiveOptions; 1406 1407 // archiveSize1 sizes most of the archive [archive_options..file_bits). 1408 protected long archiveSize0; // size through archive_size_lo 1409 protected long archiveSize1; // size reported in archive_header 1410 protected int archiveNextCount; // reported in archive_header 1411 1412 static final int AH_LENGTH_0 = 3; // archive_header_0 = {minver, majver, options} 1413 static final int AH_LENGTH_MIN = 15; // observed in spec {header_0[3], cp_counts[8], class_counts[4]} 1414 // Length contributions from optional archive size fields: 1415 static final int AH_LENGTH_S = 2; // archive_header_S = optional {size_hi, size_lo} 1416 static final int AH_ARCHIVE_SIZE_HI = 0; // offset in archive_header_S 1417 static final int AH_ARCHIVE_SIZE_LO = 1; // offset in archive_header_S 1418 // Length contributions from optional header fields: 1419 static final int AH_FILE_HEADER_LEN = 5; // file_counts = {{size_hi, size_lo}, next, modtime, files} 1420 static final int AH_SPECIAL_FORMAT_LEN = 2; // special_counts = {layouts, band_headers} 1421 static final int AH_CP_NUMBER_LEN = 4; // cp_number_counts = {int, float, long, double} 1422 static final int AH_CP_EXTRA_LEN = 4; // cp_attr_counts = {MH, MT, InDy, BSM} 1423 1424 // Common structure of attribute band groups: 1425 static final int AB_FLAGS_HI = 0; 1426 static final int AB_FLAGS_LO = 1; 1427 static final int AB_ATTR_COUNT = 2; 1428 static final int AB_ATTR_INDEXES = 3; 1429 static final int AB_ATTR_CALLS = 4; 1430 1431 static IntBand getAttrBand(MultiBand xxx_attr_bands, int which) { 1432 IntBand b = (IntBand) xxx_attr_bands.get(which); 1433 switch (which) { 1434 case AB_FLAGS_HI: 1435 assert(b.name().endsWith("_flags_hi")); break; 1436 case AB_FLAGS_LO: 1437 assert(b.name().endsWith("_flags_lo")); break; 1438 case AB_ATTR_COUNT: 1439 assert(b.name().endsWith("_attr_count")); break; 1440 case AB_ATTR_INDEXES: 1441 assert(b.name().endsWith("_attr_indexes")); break; 1442 case AB_ATTR_CALLS: 1443 assert(b.name().endsWith("_attr_calls")); break; 1444 default: 1445 assert(false); break; 1446 } 1447 return b; 1448 } 1449 1450 private static final boolean NULL_IS_OK = true; 1451 1452 MultiBand all_bands = (MultiBand) new MultiBand("(package)", UNSIGNED5).init(); 1453 1454 // file header (various random bytes) 1455 ByteBand archive_magic = all_bands.newByteBand("archive_magic"); 1456 IntBand archive_header_0 = all_bands.newIntBand("archive_header_0", UNSIGNED5); 1457 IntBand archive_header_S = all_bands.newIntBand("archive_header_S", UNSIGNED5); 1458 IntBand archive_header_1 = all_bands.newIntBand("archive_header_1", UNSIGNED5); 1459 ByteBand band_headers = all_bands.newByteBand("band_headers"); 1460 1461 // constant pool contents 1462 MultiBand cp_bands = all_bands.newMultiBand("(constant_pool)", DELTA5); 1463 IntBand cp_Utf8_prefix = cp_bands.newIntBand("cp_Utf8_prefix"); 1464 IntBand cp_Utf8_suffix = cp_bands.newIntBand("cp_Utf8_suffix", UNSIGNED5); 1465 IntBand cp_Utf8_chars = cp_bands.newIntBand("cp_Utf8_chars", CHAR3); 1466 IntBand cp_Utf8_big_suffix = cp_bands.newIntBand("cp_Utf8_big_suffix"); 1467 MultiBand cp_Utf8_big_chars = cp_bands.newMultiBand("(cp_Utf8_big_chars)", DELTA5); 1468 IntBand cp_Int = cp_bands.newIntBand("cp_Int", UDELTA5); 1469 IntBand cp_Float = cp_bands.newIntBand("cp_Float", UDELTA5); 1470 IntBand cp_Long_hi = cp_bands.newIntBand("cp_Long_hi", UDELTA5); 1471 IntBand cp_Long_lo = cp_bands.newIntBand("cp_Long_lo"); 1472 IntBand cp_Double_hi = cp_bands.newIntBand("cp_Double_hi", UDELTA5); 1473 IntBand cp_Double_lo = cp_bands.newIntBand("cp_Double_lo"); 1474 CPRefBand cp_String = cp_bands.newCPRefBand("cp_String", UDELTA5, CONSTANT_Utf8); 1475 CPRefBand cp_Class = cp_bands.newCPRefBand("cp_Class", UDELTA5, CONSTANT_Utf8); 1476 CPRefBand cp_Signature_form = cp_bands.newCPRefBand("cp_Signature_form", CONSTANT_Utf8); 1477 CPRefBand cp_Signature_classes = cp_bands.newCPRefBand("cp_Signature_classes", UDELTA5, CONSTANT_Class); 1478 CPRefBand cp_Descr_name = cp_bands.newCPRefBand("cp_Descr_name", CONSTANT_Utf8); 1479 CPRefBand cp_Descr_type = cp_bands.newCPRefBand("cp_Descr_type", UDELTA5, CONSTANT_Signature); 1480 CPRefBand cp_Field_class = cp_bands.newCPRefBand("cp_Field_class", CONSTANT_Class); 1481 CPRefBand cp_Field_desc = cp_bands.newCPRefBand("cp_Field_desc", UDELTA5, CONSTANT_NameandType); 1482 CPRefBand cp_Method_class = cp_bands.newCPRefBand("cp_Method_class", CONSTANT_Class); 1483 CPRefBand cp_Method_desc = cp_bands.newCPRefBand("cp_Method_desc", UDELTA5, CONSTANT_NameandType); 1484 CPRefBand cp_Imethod_class = cp_bands.newCPRefBand("cp_Imethod_class", CONSTANT_Class); 1485 CPRefBand cp_Imethod_desc = cp_bands.newCPRefBand("cp_Imethod_desc", UDELTA5, CONSTANT_NameandType); 1486 IntBand cp_MethodHandle_refkind = cp_bands.newIntBand("cp_MethodHandle_refkind", DELTA5); 1487 CPRefBand cp_MethodHandle_member = cp_bands.newCPRefBand("cp_MethodHandle_member", UDELTA5, CONSTANT_AnyMember); 1488 CPRefBand cp_MethodType = cp_bands.newCPRefBand("cp_MethodType", UDELTA5, CONSTANT_Signature); 1489 CPRefBand cp_BootstrapMethod_ref = cp_bands.newCPRefBand("cp_BootstrapMethod_ref", DELTA5, CONSTANT_MethodHandle); 1490 IntBand cp_BootstrapMethod_arg_count = cp_bands.newIntBand("cp_BootstrapMethod_arg_count", UDELTA5); 1491 CPRefBand cp_BootstrapMethod_arg = cp_bands.newCPRefBand("cp_BootstrapMethod_arg", DELTA5, CONSTANT_LoadableValue); 1492 CPRefBand cp_InvokeDynamic_spec = cp_bands.newCPRefBand("cp_InvokeDynamic_spec", DELTA5, CONSTANT_BootstrapMethod); 1493 CPRefBand cp_InvokeDynamic_desc = cp_bands.newCPRefBand("cp_InvokeDynamic_desc", UDELTA5, CONSTANT_NameandType); 1494 1495 // bands for carrying attribute definitions: 1496 MultiBand attr_definition_bands = all_bands.newMultiBand("(attr_definition_bands)", UNSIGNED5); 1497 ByteBand attr_definition_headers = attr_definition_bands.newByteBand("attr_definition_headers"); 1498 CPRefBand attr_definition_name = attr_definition_bands.newCPRefBand("attr_definition_name", CONSTANT_Utf8); 1499 CPRefBand attr_definition_layout = attr_definition_bands.newCPRefBand("attr_definition_layout", CONSTANT_Utf8); 1500 1501 // bands for hardwired InnerClasses attribute (shared across the package) 1502 MultiBand ic_bands = all_bands.newMultiBand("(ic_bands)", DELTA5); 1503 CPRefBand ic_this_class = ic_bands.newCPRefBand("ic_this_class", UDELTA5, CONSTANT_Class); 1504 IntBand ic_flags = ic_bands.newIntBand("ic_flags", UNSIGNED5); 1505 // These bands contain data only where flags sets ACC_IC_LONG_FORM: 1506 CPRefBand ic_outer_class = ic_bands.newCPRefBand("ic_outer_class", DELTA5, CONSTANT_Class, NULL_IS_OK); 1507 CPRefBand ic_name = ic_bands.newCPRefBand("ic_name", DELTA5, CONSTANT_Utf8, NULL_IS_OK); 1508 1509 // bands for carrying class schema information: 1510 MultiBand class_bands = all_bands.newMultiBand("(class_bands)", DELTA5); 1511 CPRefBand class_this = class_bands.newCPRefBand("class_this", CONSTANT_Class); 1512 CPRefBand class_super = class_bands.newCPRefBand("class_super", CONSTANT_Class); 1513 IntBand class_interface_count = class_bands.newIntBand("class_interface_count"); 1514 CPRefBand class_interface = class_bands.newCPRefBand("class_interface", CONSTANT_Class); 1515 1516 // bands for class members 1517 IntBand class_field_count = class_bands.newIntBand("class_field_count"); 1518 IntBand class_method_count = class_bands.newIntBand("class_method_count"); 1519 1520 CPRefBand field_descr = class_bands.newCPRefBand("field_descr", CONSTANT_NameandType); 1521 MultiBand field_attr_bands = class_bands.newMultiBand("(field_attr_bands)", UNSIGNED5); 1522 IntBand field_flags_hi = field_attr_bands.newIntBand("field_flags_hi"); 1523 IntBand field_flags_lo = field_attr_bands.newIntBand("field_flags_lo"); 1524 IntBand field_attr_count = field_attr_bands.newIntBand("field_attr_count"); 1525 IntBand field_attr_indexes = field_attr_bands.newIntBand("field_attr_indexes"); 1526 IntBand field_attr_calls = field_attr_bands.newIntBand("field_attr_calls"); 1527 1528 // bands for predefined field attributes 1529 CPRefBand field_ConstantValue_KQ = field_attr_bands.newCPRefBand("field_ConstantValue_KQ", CONSTANT_FieldSpecific); 1530 CPRefBand field_Signature_RS = field_attr_bands.newCPRefBand("field_Signature_RS", CONSTANT_Signature); 1531 MultiBand field_metadata_bands = field_attr_bands.newMultiBand("(field_metadata_bands)", UNSIGNED5); 1532 MultiBand field_type_metadata_bands = field_attr_bands.newMultiBand("(field_type_metadata_bands)", UNSIGNED5); 1533 1534 CPRefBand method_descr = class_bands.newCPRefBand("method_descr", MDELTA5, CONSTANT_NameandType); 1535 MultiBand method_attr_bands = class_bands.newMultiBand("(method_attr_bands)", UNSIGNED5); 1536 IntBand method_flags_hi = method_attr_bands.newIntBand("method_flags_hi"); 1537 IntBand method_flags_lo = method_attr_bands.newIntBand("method_flags_lo"); 1538 IntBand method_attr_count = method_attr_bands.newIntBand("method_attr_count"); 1539 IntBand method_attr_indexes = method_attr_bands.newIntBand("method_attr_indexes"); 1540 IntBand method_attr_calls = method_attr_bands.newIntBand("method_attr_calls"); 1541 // band for predefined method attributes 1542 IntBand method_Exceptions_N = method_attr_bands.newIntBand("method_Exceptions_N"); 1543 CPRefBand method_Exceptions_RC = method_attr_bands.newCPRefBand("method_Exceptions_RC", CONSTANT_Class); 1544 CPRefBand method_Signature_RS = method_attr_bands.newCPRefBand("method_Signature_RS", CONSTANT_Signature); 1545 MultiBand method_metadata_bands = method_attr_bands.newMultiBand("(method_metadata_bands)", UNSIGNED5); 1546 // band for predefine method parameters 1547 IntBand method_MethodParameters_NB = method_attr_bands.newIntBand("method_MethodParameters_NB", BYTE1); 1548 CPRefBand method_MethodParameters_name_RUN = method_attr_bands.newCPRefBand("method_MethodParameters_name_RUN", UNSIGNED5, CONSTANT_Utf8, NULL_IS_OK); 1549 IntBand method_MethodParameters_flag_FH = method_attr_bands.newIntBand("method_MethodParameters_flag_FH"); 1550 MultiBand method_type_metadata_bands = method_attr_bands.newMultiBand("(method_type_metadata_bands)", UNSIGNED5); 1551 1552 MultiBand class_attr_bands = class_bands.newMultiBand("(class_attr_bands)", UNSIGNED5); 1553 IntBand class_flags_hi = class_attr_bands.newIntBand("class_flags_hi"); 1554 IntBand class_flags_lo = class_attr_bands.newIntBand("class_flags_lo"); 1555 IntBand class_attr_count = class_attr_bands.newIntBand("class_attr_count"); 1556 IntBand class_attr_indexes = class_attr_bands.newIntBand("class_attr_indexes"); 1557 IntBand class_attr_calls = class_attr_bands.newIntBand("class_attr_calls"); 1558 // band for predefined SourceFile and other class attributes 1559 CPRefBand class_SourceFile_RUN = class_attr_bands.newCPRefBand("class_SourceFile_RUN", UNSIGNED5, CONSTANT_Utf8, NULL_IS_OK); 1560 CPRefBand class_EnclosingMethod_RC = class_attr_bands.newCPRefBand("class_EnclosingMethod_RC", CONSTANT_Class); 1561 CPRefBand class_EnclosingMethod_RDN = class_attr_bands.newCPRefBand("class_EnclosingMethod_RDN", UNSIGNED5, CONSTANT_NameandType, NULL_IS_OK); 1562 CPRefBand class_Signature_RS = class_attr_bands.newCPRefBand("class_Signature_RS", CONSTANT_Signature); 1563 MultiBand class_metadata_bands = class_attr_bands.newMultiBand("(class_metadata_bands)", UNSIGNED5); 1564 IntBand class_InnerClasses_N = class_attr_bands.newIntBand("class_InnerClasses_N"); 1565 CPRefBand class_InnerClasses_RC = class_attr_bands.newCPRefBand("class_InnerClasses_RC", CONSTANT_Class); 1566 IntBand class_InnerClasses_F = class_attr_bands.newIntBand("class_InnerClasses_F"); 1567 CPRefBand class_InnerClasses_outer_RCN = class_attr_bands.newCPRefBand("class_InnerClasses_outer_RCN", UNSIGNED5, CONSTANT_Class, NULL_IS_OK); 1568 CPRefBand class_InnerClasses_name_RUN = class_attr_bands.newCPRefBand("class_InnerClasses_name_RUN", UNSIGNED5, CONSTANT_Utf8, NULL_IS_OK); 1569 IntBand class_ClassFile_version_minor_H = class_attr_bands.newIntBand("class_ClassFile_version_minor_H"); 1570 IntBand class_ClassFile_version_major_H = class_attr_bands.newIntBand("class_ClassFile_version_major_H"); 1571 MultiBand class_type_metadata_bands = class_attr_bands.newMultiBand("(class_type_metadata_bands)", UNSIGNED5); 1572 1573 MultiBand code_bands = class_bands.newMultiBand("(code_bands)", UNSIGNED5); 1574 ByteBand code_headers = code_bands.newByteBand("code_headers"); //BYTE1 1575 IntBand code_max_stack = code_bands.newIntBand("code_max_stack", UNSIGNED5); 1576 IntBand code_max_na_locals = code_bands.newIntBand("code_max_na_locals", UNSIGNED5); 1577 IntBand code_handler_count = code_bands.newIntBand("code_handler_count", UNSIGNED5); 1578 IntBand code_handler_start_P = code_bands.newIntBand("code_handler_start_P", BCI5); 1579 IntBand code_handler_end_PO = code_bands.newIntBand("code_handler_end_PO", BRANCH5); 1580 IntBand code_handler_catch_PO = code_bands.newIntBand("code_handler_catch_PO", BRANCH5); 1581 CPRefBand code_handler_class_RCN = code_bands.newCPRefBand("code_handler_class_RCN", UNSIGNED5, CONSTANT_Class, NULL_IS_OK); 1582 1583 MultiBand code_attr_bands = class_bands.newMultiBand("(code_attr_bands)", UNSIGNED5); 1584 IntBand code_flags_hi = code_attr_bands.newIntBand("code_flags_hi"); 1585 IntBand code_flags_lo = code_attr_bands.newIntBand("code_flags_lo"); 1586 IntBand code_attr_count = code_attr_bands.newIntBand("code_attr_count"); 1587 IntBand code_attr_indexes = code_attr_bands.newIntBand("code_attr_indexes"); 1588 IntBand code_attr_calls = code_attr_bands.newIntBand("code_attr_calls"); 1589 1590 MultiBand stackmap_bands = code_attr_bands.newMultiBand("(StackMapTable_bands)", UNSIGNED5); 1591 IntBand code_StackMapTable_N = stackmap_bands.newIntBand("code_StackMapTable_N"); 1592 IntBand code_StackMapTable_frame_T = stackmap_bands.newIntBand("code_StackMapTable_frame_T",BYTE1); 1593 IntBand code_StackMapTable_local_N = stackmap_bands.newIntBand("code_StackMapTable_local_N"); 1594 IntBand code_StackMapTable_stack_N = stackmap_bands.newIntBand("code_StackMapTable_stack_N"); 1595 IntBand code_StackMapTable_offset = stackmap_bands.newIntBand("code_StackMapTable_offset", UNSIGNED5); 1596 IntBand code_StackMapTable_T = stackmap_bands.newIntBand("code_StackMapTable_T", BYTE1); 1597 CPRefBand code_StackMapTable_RC = stackmap_bands.newCPRefBand("code_StackMapTable_RC", CONSTANT_Class); 1598 IntBand code_StackMapTable_P = stackmap_bands.newIntBand("code_StackMapTable_P", BCI5); 1599 1600 // bands for predefined LineNumberTable attribute 1601 IntBand code_LineNumberTable_N = code_attr_bands.newIntBand("code_LineNumberTable_N"); 1602 IntBand code_LineNumberTable_bci_P = code_attr_bands.newIntBand("code_LineNumberTable_bci_P", BCI5); 1603 IntBand code_LineNumberTable_line = code_attr_bands.newIntBand("code_LineNumberTable_line"); 1604 1605 // bands for predefined LocalVariable{Type}Table attributes 1606 IntBand code_LocalVariableTable_N = code_attr_bands.newIntBand("code_LocalVariableTable_N"); 1607 IntBand code_LocalVariableTable_bci_P = code_attr_bands.newIntBand("code_LocalVariableTable_bci_P", BCI5); 1608 IntBand code_LocalVariableTable_span_O = code_attr_bands.newIntBand("code_LocalVariableTable_span_O", BRANCH5); 1609 CPRefBand code_LocalVariableTable_name_RU = code_attr_bands.newCPRefBand("code_LocalVariableTable_name_RU", CONSTANT_Utf8); 1610 CPRefBand code_LocalVariableTable_type_RS = code_attr_bands.newCPRefBand("code_LocalVariableTable_type_RS", CONSTANT_Signature); 1611 IntBand code_LocalVariableTable_slot = code_attr_bands.newIntBand("code_LocalVariableTable_slot"); 1612 IntBand code_LocalVariableTypeTable_N = code_attr_bands.newIntBand("code_LocalVariableTypeTable_N"); 1613 IntBand code_LocalVariableTypeTable_bci_P = code_attr_bands.newIntBand("code_LocalVariableTypeTable_bci_P", BCI5); 1614 IntBand code_LocalVariableTypeTable_span_O = code_attr_bands.newIntBand("code_LocalVariableTypeTable_span_O", BRANCH5); 1615 CPRefBand code_LocalVariableTypeTable_name_RU = code_attr_bands.newCPRefBand("code_LocalVariableTypeTable_name_RU", CONSTANT_Utf8); 1616 CPRefBand code_LocalVariableTypeTable_type_RS = code_attr_bands.newCPRefBand("code_LocalVariableTypeTable_type_RS", CONSTANT_Signature); 1617 IntBand code_LocalVariableTypeTable_slot = code_attr_bands.newIntBand("code_LocalVariableTypeTable_slot"); 1618 MultiBand code_type_metadata_bands = code_attr_bands.newMultiBand("(code_type_metadata_bands)", UNSIGNED5); 1619 1620 // bands for bytecodes 1621 MultiBand bc_bands = all_bands.newMultiBand("(byte_codes)", UNSIGNED5); 1622 ByteBand bc_codes = bc_bands.newByteBand("bc_codes"); //BYTE1 1623 // remaining bands provide typed opcode fields required by the bc_codes 1624 1625 IntBand bc_case_count = bc_bands.newIntBand("bc_case_count"); // *switch 1626 IntBand bc_case_value = bc_bands.newIntBand("bc_case_value", DELTA5); // *switch 1627 ByteBand bc_byte = bc_bands.newByteBand("bc_byte"); //BYTE1 // bipush, iinc, *newarray 1628 IntBand bc_short = bc_bands.newIntBand("bc_short", DELTA5); // sipush, wide iinc 1629 IntBand bc_local = bc_bands.newIntBand("bc_local"); // *load, *store, iinc, ret 1630 IntBand bc_label = bc_bands.newIntBand("bc_label", BRANCH5); // if*, goto*, jsr*, *switch 1631 1632 // Most CP refs exhibit some correlation, and benefit from delta coding. 1633 // The notable exceptions are class and method references. 1634 1635 // ldc* operands: 1636 CPRefBand bc_intref = bc_bands.newCPRefBand("bc_intref", DELTA5, CONSTANT_Integer); 1637 CPRefBand bc_floatref = bc_bands.newCPRefBand("bc_floatref", DELTA5, CONSTANT_Float); 1638 CPRefBand bc_longref = bc_bands.newCPRefBand("bc_longref", DELTA5, CONSTANT_Long); 1639 CPRefBand bc_doubleref = bc_bands.newCPRefBand("bc_doubleref", DELTA5, CONSTANT_Double); 1640 CPRefBand bc_stringref = bc_bands.newCPRefBand("bc_stringref", DELTA5, CONSTANT_String); 1641 CPRefBand bc_loadablevalueref = bc_bands.newCPRefBand("bc_loadablevalueref", DELTA5, CONSTANT_LoadableValue); 1642 1643 // nulls produced by bc_classref are taken to mean the current class 1644 CPRefBand bc_classref = bc_bands.newCPRefBand("bc_classref", UNSIGNED5, CONSTANT_Class, NULL_IS_OK); // new, *anew*, c*cast, i*of, ldc 1645 CPRefBand bc_fieldref = bc_bands.newCPRefBand("bc_fieldref", DELTA5, CONSTANT_Fieldref); // get*, put* 1646 CPRefBand bc_methodref = bc_bands.newCPRefBand("bc_methodref", CONSTANT_Methodref); // invoke[vs]* 1647 CPRefBand bc_imethodref = bc_bands.newCPRefBand("bc_imethodref", DELTA5, CONSTANT_InterfaceMethodref); // invokeinterface 1648 CPRefBand bc_indyref = bc_bands.newCPRefBand("bc_indyref", DELTA5, CONSTANT_InvokeDynamic); // invokedynamic 1649 1650 // _self_linker_op family 1651 CPRefBand bc_thisfield = bc_bands.newCPRefBand("bc_thisfield", CONSTANT_None); // any field within cur. class 1652 CPRefBand bc_superfield = bc_bands.newCPRefBand("bc_superfield", CONSTANT_None); // any field within superclass 1653 CPRefBand bc_thismethod = bc_bands.newCPRefBand("bc_thismethod", CONSTANT_None); // any method within cur. class 1654 CPRefBand bc_supermethod = bc_bands.newCPRefBand("bc_supermethod", CONSTANT_None); // any method within superclass 1655 // bc_invokeinit family: 1656 IntBand bc_initref = bc_bands.newIntBand("bc_initref"); 1657 // escapes 1658 CPRefBand bc_escref = bc_bands.newCPRefBand("bc_escref", CONSTANT_All); 1659 IntBand bc_escrefsize = bc_bands.newIntBand("bc_escrefsize"); 1660 IntBand bc_escsize = bc_bands.newIntBand("bc_escsize"); 1661 ByteBand bc_escbyte = bc_bands.newByteBand("bc_escbyte"); 1662 1663 // bands for carrying resource files and file attributes: 1664 MultiBand file_bands = all_bands.newMultiBand("(file_bands)", UNSIGNED5); 1665 CPRefBand file_name = file_bands.newCPRefBand("file_name", CONSTANT_Utf8); 1666 IntBand file_size_hi = file_bands.newIntBand("file_size_hi"); 1667 IntBand file_size_lo = file_bands.newIntBand("file_size_lo"); 1668 IntBand file_modtime = file_bands.newIntBand("file_modtime", DELTA5); 1669 IntBand file_options = file_bands.newIntBand("file_options"); 1670 ByteBand file_bits = file_bands.newByteBand("file_bits"); 1671 1672 // End of band definitions! 1673 1674 /** Given CP indexes, distribute tag-specific indexes to bands. */ 1675 protected void setBandIndexes() { 1676 // Handle prior calls to setBandIndex: 1677 for (Object[] need : needPredefIndex) { 1678 CPRefBand b = (CPRefBand) need[0]; 1679 Byte which = (Byte) need[1]; 1680 b.setIndex(getCPIndex(which.byteValue())); 1681 } 1682 needPredefIndex = null; // no more predefs 1683 1684 if (verbose > 3) { 1685 printCDecl(all_bands); 1686 } 1687 } 1688 1689 protected void setBandIndex(CPRefBand b, byte which) { 1690 Object[] need = { b, Byte.valueOf(which) }; 1691 if (which == CONSTANT_FieldSpecific) { 1692 // I.e., attribute layouts KQ (no null) or KQN (null ok). 1693 allKQBands.add(b); 1694 } else if (needPredefIndex != null) { 1695 needPredefIndex.add(need); 1696 } else { 1697 // Not in predefinition mode; getCPIndex now works. 1698 b.setIndex(getCPIndex(which)); 1699 } 1700 } 1701 1702 protected void setConstantValueIndex(Field f) { 1703 Index ix = null; 1704 if (f != null) { 1705 byte tag = f.getLiteralTag(); 1706 ix = getCPIndex(tag); 1707 if (verbose > 2) 1708 Utils.log.fine("setConstantValueIndex "+f+" "+ConstantPool.tagName(tag)+" => "+ix); 1709 assert(ix != null); 1710 } 1711 // Typically, allKQBands is the singleton of field_ConstantValue_KQ. 1712 for (CPRefBand xxx_KQ : allKQBands) { 1713 xxx_KQ.setIndex(ix); 1714 } 1715 } 1716 1717 // Table of bands which contain metadata. 1718 protected MultiBand[] metadataBands = new MultiBand[ATTR_CONTEXT_LIMIT]; 1719 { 1720 metadataBands[ATTR_CONTEXT_CLASS] = class_metadata_bands; 1721 metadataBands[ATTR_CONTEXT_FIELD] = field_metadata_bands; 1722 metadataBands[ATTR_CONTEXT_METHOD] = method_metadata_bands; 1723 } 1724 // Table of bands which contains type_metadata (TypeAnnotations) 1725 protected MultiBand[] typeMetadataBands = new MultiBand[ATTR_CONTEXT_LIMIT]; 1726 { 1727 typeMetadataBands[ATTR_CONTEXT_CLASS] = class_type_metadata_bands; 1728 typeMetadataBands[ATTR_CONTEXT_FIELD] = field_type_metadata_bands; 1729 typeMetadataBands[ATTR_CONTEXT_METHOD] = method_type_metadata_bands; 1730 typeMetadataBands[ATTR_CONTEXT_CODE] = code_type_metadata_bands; 1731 } 1732 1733 // Attribute layouts. 1734 public static final int ADH_CONTEXT_MASK = 0x3; // (ad_hdr & ADH_CONTEXT_MASK) 1735 public static final int ADH_BIT_SHIFT = 0x2; // (ad_hdr >> ADH_BIT_SHIFT) 1736 public static final int ADH_BIT_IS_LSB = 1; 1737 public static final int ATTR_INDEX_OVERFLOW = -1; 1738 1739 public int[] attrIndexLimit = new int[ATTR_CONTEXT_LIMIT]; 1740 // Each index limit is either 32 or 63, depending on AO_HAVE_XXX_FLAGS_HI. 1741 1742 // Which flag bits are taken over by attributes? 1743 protected long[] attrFlagMask = new long[ATTR_CONTEXT_LIMIT]; 1744 // Which flag bits have been taken over explicitly? 1745 protected long[] attrDefSeen = new long[ATTR_CONTEXT_LIMIT]; 1746 1747 // What pseudo-attribute bits are there to watch for? 1748 protected int[] attrOverflowMask = new int[ATTR_CONTEXT_LIMIT]; 1749 protected int attrClassFileVersionMask; 1750 1751 // Mapping from Attribute.Layout to Band[] (layout element bands). 1752 protected Map<Attribute.Layout, Band[]> attrBandTable = new HashMap<>(); 1753 1754 // Well-known attributes: 1755 protected final Attribute.Layout attrCodeEmpty; 1756 protected final Attribute.Layout attrInnerClassesEmpty; 1757 protected final Attribute.Layout attrClassFileVersion; 1758 protected final Attribute.Layout attrConstantValue; 1759 1760 // Mapping from Attribute.Layout to Integer (inverse of attrDefs) 1761 Map<Attribute.Layout, Integer> attrIndexTable = new HashMap<>(); 1762 1763 // Mapping from attribute index (<32 are flag bits) to attributes. 1764 protected List<List<Attribute.Layout>> attrDefs = 1765 new FixedList<>(ATTR_CONTEXT_LIMIT); 1766 { 1767 for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) { 1768 assert(attrIndexLimit[i] == 0); 1769 attrIndexLimit[i] = 32; // just for the sake of predefs. 1770 attrDefs.set(i, new ArrayList<>(Collections.nCopies( 1771 attrIndexLimit[i], (Attribute.Layout)null))); 1772 1773 } 1774 1775 // Add predefined attribute definitions: 1776 attrInnerClassesEmpty = 1777 predefineAttribute(CLASS_ATTR_InnerClasses, ATTR_CONTEXT_CLASS, null, 1778 "InnerClasses", ""); 1779 assert(attrInnerClassesEmpty == Package.attrInnerClassesEmpty); 1780 predefineAttribute(CLASS_ATTR_SourceFile, ATTR_CONTEXT_CLASS, 1781 new Band[] { class_SourceFile_RUN }, 1782 "SourceFile", "RUNH"); 1783 predefineAttribute(CLASS_ATTR_EnclosingMethod, ATTR_CONTEXT_CLASS, 1784 new Band[] { 1785 class_EnclosingMethod_RC, 1786 class_EnclosingMethod_RDN 1787 }, 1788 "EnclosingMethod", "RCHRDNH"); 1789 attrClassFileVersion = 1790 predefineAttribute(CLASS_ATTR_ClassFile_version, ATTR_CONTEXT_CLASS, 1791 new Band[] { 1792 class_ClassFile_version_minor_H, 1793 class_ClassFile_version_major_H 1794 }, 1795 ".ClassFile.version", "HH"); 1796 predefineAttribute(X_ATTR_Signature, ATTR_CONTEXT_CLASS, 1797 new Band[] { class_Signature_RS }, 1798 "Signature", "RSH"); 1799 predefineAttribute(X_ATTR_Deprecated, ATTR_CONTEXT_CLASS, null, 1800 "Deprecated", ""); 1801 //predefineAttribute(X_ATTR_Synthetic, ATTR_CONTEXT_CLASS, null, 1802 // "Synthetic", ""); 1803 predefineAttribute(X_ATTR_OVERFLOW, ATTR_CONTEXT_CLASS, null, 1804 ".Overflow", ""); 1805 attrConstantValue = 1806 predefineAttribute(FIELD_ATTR_ConstantValue, ATTR_CONTEXT_FIELD, 1807 new Band[] { field_ConstantValue_KQ }, 1808 "ConstantValue", "KQH"); 1809 predefineAttribute(X_ATTR_Signature, ATTR_CONTEXT_FIELD, 1810 new Band[] { field_Signature_RS }, 1811 "Signature", "RSH"); 1812 predefineAttribute(X_ATTR_Deprecated, ATTR_CONTEXT_FIELD, null, 1813 "Deprecated", ""); 1814 //predefineAttribute(X_ATTR_Synthetic, ATTR_CONTEXT_FIELD, null, 1815 // "Synthetic", ""); 1816 predefineAttribute(X_ATTR_OVERFLOW, ATTR_CONTEXT_FIELD, null, 1817 ".Overflow", ""); 1818 attrCodeEmpty = 1819 predefineAttribute(METHOD_ATTR_Code, ATTR_CONTEXT_METHOD, null, 1820 "Code", ""); 1821 predefineAttribute(METHOD_ATTR_Exceptions, ATTR_CONTEXT_METHOD, 1822 new Band[] { 1823 method_Exceptions_N, 1824 method_Exceptions_RC 1825 }, 1826 "Exceptions", "NH[RCH]"); 1827 predefineAttribute(METHOD_ATTR_MethodParameters, ATTR_CONTEXT_METHOD, 1828 new Band[]{ 1829 method_MethodParameters_NB, 1830 method_MethodParameters_name_RUN, 1831 method_MethodParameters_flag_FH 1832 }, 1833 "MethodParameters", "NB[RUNHFH]"); 1834 assert(attrCodeEmpty == Package.attrCodeEmpty); 1835 predefineAttribute(X_ATTR_Signature, ATTR_CONTEXT_METHOD, 1836 new Band[] { method_Signature_RS }, 1837 "Signature", "RSH"); 1838 predefineAttribute(X_ATTR_Deprecated, ATTR_CONTEXT_METHOD, null, 1839 "Deprecated", ""); 1840 //predefineAttribute(X_ATTR_Synthetic, ATTR_CONTEXT_METHOD, null, 1841 // "Synthetic", ""); 1842 predefineAttribute(X_ATTR_OVERFLOW, ATTR_CONTEXT_METHOD, null, 1843 ".Overflow", ""); 1844 1845 for (int ctype = 0; ctype < ATTR_CONTEXT_LIMIT; ctype++) { 1846 MultiBand xxx_metadata_bands = metadataBands[ctype]; 1847 if (ctype != ATTR_CONTEXT_CODE) { 1848 // These arguments cause the bands to be built 1849 // automatically for this complicated layout: 1850 predefineAttribute(X_ATTR_RuntimeVisibleAnnotations, 1851 ATTR_CONTEXT_NAME[ctype]+"_RVA_", 1852 xxx_metadata_bands, 1853 Attribute.lookup(null, ctype, 1854 "RuntimeVisibleAnnotations")); 1855 predefineAttribute(X_ATTR_RuntimeInvisibleAnnotations, 1856 ATTR_CONTEXT_NAME[ctype]+"_RIA_", 1857 xxx_metadata_bands, 1858 Attribute.lookup(null, ctype, 1859 "RuntimeInvisibleAnnotations")); 1860 1861 if (ctype == ATTR_CONTEXT_METHOD) { 1862 predefineAttribute(METHOD_ATTR_RuntimeVisibleParameterAnnotations, 1863 "method_RVPA_", xxx_metadata_bands, 1864 Attribute.lookup(null, ctype, 1865 "RuntimeVisibleParameterAnnotations")); 1866 predefineAttribute(METHOD_ATTR_RuntimeInvisibleParameterAnnotations, 1867 "method_RIPA_", xxx_metadata_bands, 1868 Attribute.lookup(null, ctype, 1869 "RuntimeInvisibleParameterAnnotations")); 1870 predefineAttribute(METHOD_ATTR_AnnotationDefault, 1871 "method_AD_", xxx_metadata_bands, 1872 Attribute.lookup(null, ctype, 1873 "AnnotationDefault")); 1874 } 1875 } 1876 // All contexts have these 1877 MultiBand xxx_type_metadata_bands = typeMetadataBands[ctype]; 1878 predefineAttribute(X_ATTR_RuntimeVisibleTypeAnnotations, 1879 ATTR_CONTEXT_NAME[ctype] + "_RVTA_", 1880 xxx_type_metadata_bands, 1881 Attribute.lookup(null, ctype, 1882 "RuntimeVisibleTypeAnnotations")); 1883 predefineAttribute(X_ATTR_RuntimeInvisibleTypeAnnotations, 1884 ATTR_CONTEXT_NAME[ctype] + "_RITA_", 1885 xxx_type_metadata_bands, 1886 Attribute.lookup(null, ctype, 1887 "RuntimeInvisibleTypeAnnotations")); 1888 } 1889 1890 1891 Attribute.Layout stackMapDef = Attribute.lookup(null, ATTR_CONTEXT_CODE, "StackMapTable").layout(); 1892 predefineAttribute(CODE_ATTR_StackMapTable, ATTR_CONTEXT_CODE, 1893 stackmap_bands.toArray(), 1894 stackMapDef.name(), stackMapDef.layout()); 1895 1896 predefineAttribute(CODE_ATTR_LineNumberTable, ATTR_CONTEXT_CODE, 1897 new Band[] { 1898 code_LineNumberTable_N, 1899 code_LineNumberTable_bci_P, 1900 code_LineNumberTable_line 1901 }, 1902 "LineNumberTable", "NH[PHH]"); 1903 predefineAttribute(CODE_ATTR_LocalVariableTable, ATTR_CONTEXT_CODE, 1904 new Band[] { 1905 code_LocalVariableTable_N, 1906 code_LocalVariableTable_bci_P, 1907 code_LocalVariableTable_span_O, 1908 code_LocalVariableTable_name_RU, 1909 code_LocalVariableTable_type_RS, 1910 code_LocalVariableTable_slot 1911 }, 1912 "LocalVariableTable", "NH[PHOHRUHRSHH]"); 1913 predefineAttribute(CODE_ATTR_LocalVariableTypeTable, ATTR_CONTEXT_CODE, 1914 new Band[] { 1915 code_LocalVariableTypeTable_N, 1916 code_LocalVariableTypeTable_bci_P, 1917 code_LocalVariableTypeTable_span_O, 1918 code_LocalVariableTypeTable_name_RU, 1919 code_LocalVariableTypeTable_type_RS, 1920 code_LocalVariableTypeTable_slot 1921 }, 1922 "LocalVariableTypeTable", "NH[PHOHRUHRSHH]"); 1923 predefineAttribute(X_ATTR_OVERFLOW, ATTR_CONTEXT_CODE, null, 1924 ".Overflow", ""); 1925 1926 // Clear the record of having seen these definitions, 1927 // so they may be redefined without error. 1928 for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) { 1929 attrDefSeen[i] = 0; 1930 } 1931 1932 // Set up the special masks: 1933 for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) { 1934 attrOverflowMask[i] = (1<<X_ATTR_OVERFLOW); 1935 attrIndexLimit[i] = 0; // will make a final decision later 1936 } 1937 attrClassFileVersionMask = (1<<CLASS_ATTR_ClassFile_version); 1938 } 1939 1940 private void adjustToClassVersion() throws IOException { 1941 if (getHighestClassVersion().lessThan(JAVA6_MAX_CLASS_VERSION)) { 1942 if (verbose > 0) Utils.log.fine("Legacy package version"); 1943 // Revoke definition of pre-1.6 attribute type. 1944 undefineAttribute(CODE_ATTR_StackMapTable, ATTR_CONTEXT_CODE); 1945 } 1946 } 1947 1948 protected void initAttrIndexLimit() { 1949 for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) { 1950 assert(attrIndexLimit[i] == 0); // decide on it now! 1951 attrIndexLimit[i] = (haveFlagsHi(i)? 63: 32); 1952 List<Attribute.Layout> defList = attrDefs.get(i); 1953 assert(defList.size() == 32); // all predef indexes are <32 1954 int addMore = attrIndexLimit[i] - defList.size(); 1955 defList.addAll(Collections.nCopies(addMore, (Attribute.Layout) null)); 1956 } 1957 } 1958 1959 protected boolean haveFlagsHi(int ctype) { 1960 int mask = 1<<(LG_AO_HAVE_XXX_FLAGS_HI+ctype); 1961 switch (ctype) { 1962 case ATTR_CONTEXT_CLASS: 1963 assert(mask == AO_HAVE_CLASS_FLAGS_HI); break; 1964 case ATTR_CONTEXT_FIELD: 1965 assert(mask == AO_HAVE_FIELD_FLAGS_HI); break; 1966 case ATTR_CONTEXT_METHOD: 1967 assert(mask == AO_HAVE_METHOD_FLAGS_HI); break; 1968 case ATTR_CONTEXT_CODE: 1969 assert(mask == AO_HAVE_CODE_FLAGS_HI); break; 1970 default: 1971 assert(false); 1972 } 1973 return testBit(archiveOptions, mask); 1974 } 1975 1976 protected List<Attribute.Layout> getPredefinedAttrs(int ctype) { 1977 assert(attrIndexLimit[ctype] != 0); 1978 List<Attribute.Layout> res = new ArrayList<>(attrIndexLimit[ctype]); 1979 // Remove nulls and non-predefs. 1980 for (int ai = 0; ai < attrIndexLimit[ctype]; ai++) { 1981 if (testBit(attrDefSeen[ctype], 1L<<ai)) continue; 1982 Attribute.Layout def = attrDefs.get(ctype).get(ai); 1983 if (def == null) continue; // unused flag bit 1984 assert(isPredefinedAttr(ctype, ai)); 1985 res.add(def); 1986 } 1987 return res; 1988 } 1989 1990 protected boolean isPredefinedAttr(int ctype, int ai) { 1991 assert(attrIndexLimit[ctype] != 0); 1992 // Overflow attrs are never predefined. 1993 if (ai >= attrIndexLimit[ctype]) return false; 1994 // If the bit is set, it was explicitly def'd. 1995 if (testBit(attrDefSeen[ctype], 1L<<ai)) return false; 1996 return (attrDefs.get(ctype).get(ai) != null); 1997 } 1998 1999 protected void adjustSpecialAttrMasks() { 2000 // Clear special masks if new definitions have been seen for them. 2001 attrClassFileVersionMask &= ~ attrDefSeen[ATTR_CONTEXT_CLASS]; 2002 // It is possible to clear the overflow mask (bit 16). 2003 for (int i = 0; i < ATTR_CONTEXT_LIMIT; i++) { 2004 attrOverflowMask[i] &= ~ attrDefSeen[i]; 2005 } 2006 } 2007 2008 protected Attribute makeClassFileVersionAttr(Package.Version ver) { 2009 return attrClassFileVersion.addContent(ver.asBytes()); 2010 } 2011 2012 protected Package.Version parseClassFileVersionAttr(Attribute attr) { 2013 assert(attr.layout() == attrClassFileVersion); 2014 assert(attr.size() == 4); 2015 return Package.Version.of(attr.bytes()); 2016 } 2017 2018 private boolean assertBandOKForElems(Band[] ab, Attribute.Layout.Element[] elems) { 2019 for (int i = 0; i < elems.length; i++) { 2020 assert(assertBandOKForElem(ab, elems[i])); 2021 } 2022 return true; 2023 } 2024 private boolean assertBandOKForElem(Band[] ab, Attribute.Layout.Element e) { 2025 Band b = null; 2026 if (e.bandIndex != Attribute.NO_BAND_INDEX) 2027 b = ab[e.bandIndex]; 2028 Coding rc = UNSIGNED5; 2029 boolean wantIntBand = true; 2030 switch (e.kind) { 2031 case Attribute.EK_INT: 2032 if (e.flagTest(Attribute.EF_SIGN)) { 2033 rc = SIGNED5; 2034 } else if (e.len == 1) { 2035 rc = BYTE1; 2036 } 2037 break; 2038 case Attribute.EK_BCI: 2039 if (!e.flagTest(Attribute.EF_DELTA)) { 2040 rc = BCI5; 2041 } else { 2042 rc = BRANCH5; 2043 } 2044 break; 2045 case Attribute.EK_BCO: 2046 rc = BRANCH5; 2047 break; 2048 case Attribute.EK_FLAG: 2049 if (e.len == 1) rc = BYTE1; 2050 break; 2051 case Attribute.EK_REPL: 2052 if (e.len == 1) rc = BYTE1; 2053 assertBandOKForElems(ab, e.body); 2054 break; 2055 case Attribute.EK_UN: 2056 if (e.flagTest(Attribute.EF_SIGN)) { 2057 rc = SIGNED5; 2058 } else if (e.len == 1) { 2059 rc = BYTE1; 2060 } 2061 assertBandOKForElems(ab, e.body); 2062 break; 2063 case Attribute.EK_CASE: 2064 assert(b == null); 2065 assertBandOKForElems(ab, e.body); 2066 return true; // no direct band 2067 case Attribute.EK_CALL: 2068 assert(b == null); 2069 return true; // no direct band 2070 case Attribute.EK_CBLE: 2071 assert(b == null); 2072 assertBandOKForElems(ab, e.body); 2073 return true; // no direct band 2074 case Attribute.EK_REF: 2075 wantIntBand = false; 2076 assert(b instanceof CPRefBand); 2077 assert(((CPRefBand)b).nullOK == e.flagTest(Attribute.EF_NULL)); 2078 break; 2079 default: assert(false); 2080 } 2081 assert(b.regularCoding == rc) 2082 : (e+" // "+b); 2083 if (wantIntBand) 2084 assert(b instanceof IntBand); 2085 return true; 2086 } 2087 2088 private 2089 Attribute.Layout predefineAttribute(int index, int ctype, Band[] ab, 2090 String name, String layout) { 2091 // Use Attribute.find to get uniquification of layouts. 2092 Attribute.Layout def = Attribute.find(ctype, name, layout).layout(); 2093 //def.predef = true; 2094 if (index >= 0) { 2095 setAttributeLayoutIndex(def, index); 2096 } 2097 if (ab == null) { 2098 ab = new Band[0]; 2099 } 2100 assert(attrBandTable.get(def) == null); // no redef 2101 attrBandTable.put(def, ab); 2102 assert(def.bandCount == ab.length) 2103 : (def+" // "+Arrays.asList(ab)); 2104 // Let's make sure the band types match: 2105 assert(assertBandOKForElems(ab, def.elems)); 2106 return def; 2107 } 2108 2109 // This version takes bandPrefix/addHere instead of prebuilt Band[] ab. 2110 private 2111 Attribute.Layout predefineAttribute(int index, 2112 String bandPrefix, MultiBand addHere, 2113 Attribute attr) { 2114 //Attribute.Layout def = Attribute.find(ctype, name, layout).layout(); 2115 Attribute.Layout def = attr.layout(); 2116 int ctype = def.ctype(); 2117 return predefineAttribute(index, ctype, 2118 makeNewAttributeBands(bandPrefix, def, addHere), 2119 def.name(), def.layout()); 2120 } 2121 2122 private 2123 void undefineAttribute(int index, int ctype) { 2124 if (verbose > 1) { 2125 System.out.println("Removing predefined "+ATTR_CONTEXT_NAME[ctype]+ 2126 " attribute on bit "+index); 2127 } 2128 List<Attribute.Layout> defList = attrDefs.get(ctype); 2129 Attribute.Layout def = defList.get(index); 2130 assert(def != null); 2131 defList.set(index, null); 2132 attrIndexTable.put(def, null); 2133 // Clear the def bit. (For predefs, it's already clear.) 2134 assert(index < 64); 2135 attrDefSeen[ctype] &= ~(1L<<index); 2136 attrFlagMask[ctype] &= ~(1L<<index); 2137 Band[] ab = attrBandTable.get(def); 2138 for (int j = 0; j < ab.length; j++) { 2139 ab[j].doneWithUnusedBand(); 2140 } 2141 } 2142 2143 // Bands which contain non-predefined attrs. 2144 protected MultiBand[] attrBands = new MultiBand[ATTR_CONTEXT_LIMIT]; 2145 { 2146 attrBands[ATTR_CONTEXT_CLASS] = class_attr_bands; 2147 attrBands[ATTR_CONTEXT_FIELD] = field_attr_bands; 2148 attrBands[ATTR_CONTEXT_METHOD] = method_attr_bands; 2149 attrBands[ATTR_CONTEXT_CODE] = code_attr_bands; 2150 } 2151 2152 // Create bands for all non-predefined attrs. 2153 void makeNewAttributeBands() { 2154 // Retract special flag bit bindings, if they were taken over. 2155 adjustSpecialAttrMasks(); 2156 2157 for (int ctype = 0; ctype < ATTR_CONTEXT_LIMIT; ctype++) { 2158 String cname = ATTR_CONTEXT_NAME[ctype]; 2159 MultiBand xxx_attr_bands = attrBands[ctype]; 2160 long defSeen = attrDefSeen[ctype]; 2161 // Note: attrDefSeen is always a subset of attrFlagMask. 2162 assert((defSeen & ~attrFlagMask[ctype]) == 0); 2163 for (int i = 0; i < attrDefs.get(ctype).size(); i++) { 2164 Attribute.Layout def = attrDefs.get(ctype).get(i); 2165 if (def == null) continue; // unused flag bit 2166 if (def.bandCount == 0) continue; // empty attr 2167 if (i < attrIndexLimit[ctype] && !testBit(defSeen, 1L<<i)) { 2168 // There are already predefined bands here. 2169 assert(attrBandTable.get(def) != null); 2170 continue; 2171 } 2172 int base = xxx_attr_bands.size(); 2173 String pfx = cname+"_"+def.name()+"_"; // debug only 2174 if (verbose > 1) 2175 Utils.log.fine("Making new bands for "+def); 2176 Band[] newAB = makeNewAttributeBands(pfx, def, 2177 xxx_attr_bands); 2178 assert(newAB.length == def.bandCount); 2179 Band[] prevAB = attrBandTable.put(def, newAB); 2180 if (prevAB != null) { 2181 // We won't be using these predefined bands. 2182 for (int j = 0; j < prevAB.length; j++) { 2183 prevAB[j].doneWithUnusedBand(); 2184 } 2185 } 2186 } 2187 } 2188 //System.out.println(prevForAssertMap); 2189 } 2190 private 2191 Band[] makeNewAttributeBands(String pfx, Attribute.Layout def, 2192 MultiBand addHere) { 2193 int base = addHere.size(); 2194 makeNewAttributeBands(pfx, def.elems, addHere); 2195 int nb = addHere.size() - base; 2196 Band[] newAB = new Band[nb]; 2197 for (int i = 0; i < nb; i++) { 2198 newAB[i] = addHere.get(base+i); 2199 } 2200 return newAB; 2201 } 2202 // Recursive helper, operates on a "body" or other sequence of elems: 2203 private 2204 void makeNewAttributeBands(String pfx, Attribute.Layout.Element[] elems, 2205 MultiBand ab) { 2206 for (int i = 0; i < elems.length; i++) { 2207 Attribute.Layout.Element e = elems[i]; 2208 String name = pfx+ab.size()+"_"+e.layout; 2209 { 2210 int tem; 2211 if ((tem = name.indexOf('[')) > 0) 2212 name = name.substring(0, tem); 2213 if ((tem = name.indexOf('(')) > 0) 2214 name = name.substring(0, tem); 2215 if (name.endsWith("H")) 2216 name = name.substring(0, name.length()-1); 2217 } 2218 Band nb; 2219 switch (e.kind) { 2220 case Attribute.EK_INT: 2221 nb = newElemBand(e, name, ab); 2222 break; 2223 case Attribute.EK_BCI: 2224 if (!e.flagTest(Attribute.EF_DELTA)) { 2225 // PH: transmit R(bci), store bci 2226 nb = ab.newIntBand(name, BCI5); 2227 } else { 2228 // POH: transmit D(R(bci)), store bci 2229 nb = ab.newIntBand(name, BRANCH5); 2230 } 2231 // Note: No case for BYTE1 here. 2232 break; 2233 case Attribute.EK_BCO: 2234 // OH: transmit D(R(bci)), store D(bci) 2235 nb = ab.newIntBand(name, BRANCH5); 2236 // Note: No case for BYTE1 here. 2237 break; 2238 case Attribute.EK_FLAG: 2239 assert(!e.flagTest(Attribute.EF_SIGN)); 2240 nb = newElemBand(e, name, ab); 2241 break; 2242 case Attribute.EK_REPL: 2243 assert(!e.flagTest(Attribute.EF_SIGN)); 2244 nb = newElemBand(e, name, ab); 2245 makeNewAttributeBands(pfx, e.body, ab); 2246 break; 2247 case Attribute.EK_UN: 2248 nb = newElemBand(e, name, ab); 2249 makeNewAttributeBands(pfx, e.body, ab); 2250 break; 2251 case Attribute.EK_CASE: 2252 if (!e.flagTest(Attribute.EF_BACK)) { 2253 // If it's not a duplicate body, make the bands. 2254 makeNewAttributeBands(pfx, e.body, ab); 2255 } 2256 continue; // no new band to make 2257 case Attribute.EK_REF: 2258 byte refKind = e.refKind; 2259 boolean nullOK = e.flagTest(Attribute.EF_NULL); 2260 nb = ab.newCPRefBand(name, UNSIGNED5, refKind, nullOK); 2261 // Note: No case for BYTE1 here. 2262 break; 2263 case Attribute.EK_CALL: 2264 continue; // no new band to make 2265 case Attribute.EK_CBLE: 2266 makeNewAttributeBands(pfx, e.body, ab); 2267 continue; // no new band to make 2268 default: assert(false); continue; 2269 } 2270 if (verbose > 1) { 2271 Utils.log.fine("New attribute band "+nb); 2272 } 2273 } 2274 } 2275 private 2276 Band newElemBand(Attribute.Layout.Element e, String name, MultiBand ab) { 2277 if (e.flagTest(Attribute.EF_SIGN)) { 2278 return ab.newIntBand(name, SIGNED5); 2279 } else if (e.len == 1) { 2280 return ab.newIntBand(name, BYTE1); // Not ByteBand, please. 2281 } else { 2282 return ab.newIntBand(name, UNSIGNED5); 2283 } 2284 } 2285 2286 protected int setAttributeLayoutIndex(Attribute.Layout def, int index) { 2287 int ctype = def.ctype; 2288 assert(ATTR_INDEX_OVERFLOW <= index && index < attrIndexLimit[ctype]); 2289 List<Attribute.Layout> defList = attrDefs.get(ctype); 2290 if (index == ATTR_INDEX_OVERFLOW) { 2291 // Overflow attribute. 2292 index = defList.size(); 2293 defList.add(def); 2294 if (verbose > 0) 2295 Utils.log.info("Adding new attribute at "+def +": "+index); 2296 attrIndexTable.put(def, index); 2297 return index; 2298 } 2299 2300 // Detect redefinitions: 2301 if (testBit(attrDefSeen[ctype], 1L<<index)) { 2302 throw new RuntimeException("Multiple explicit definition at "+index+": "+def); 2303 } 2304 attrDefSeen[ctype] |= (1L<<index); 2305 2306 // Adding a new fixed attribute. 2307 assert(0 <= index && index < attrIndexLimit[ctype]); 2308 if (verbose > (attrClassFileVersionMask == 0? 2:0)) 2309 Utils.log.fine("Fixing new attribute at "+index 2310 +": "+def 2311 +(defList.get(index) == null? "": 2312 "; replacing "+defList.get(index))); 2313 attrFlagMask[ctype] |= (1L<<index); 2314 // Remove index binding of any previous fixed attr. 2315 attrIndexTable.put(defList.get(index), null); 2316 defList.set(index, def); 2317 attrIndexTable.put(def, index); 2318 return index; 2319 } 2320 2321 // encodings found in the code_headers band 2322 private static final int[][] shortCodeLimits = { 2323 { 12, 12 }, // s<12, l<12, e=0 [1..144] 2324 { 8, 8 }, // s<8, l<8, e=1 [145..208] 2325 { 7, 7 }, // s<7, l<7, e=2 [209..256] 2326 }; 2327 public final int shortCodeHeader_h_limit = shortCodeLimits.length; 2328 2329 // return 0 if it won't encode, else a number in [1..255] 2330 static int shortCodeHeader(Code code) { 2331 int s = code.max_stack; 2332 int l0 = code.max_locals; 2333 int h = code.handler_class.length; 2334 if (h >= shortCodeLimits.length) return LONG_CODE_HEADER; 2335 int siglen = code.getMethod().getArgumentSize(); 2336 assert(l0 >= siglen); // enough locals for signature! 2337 if (l0 < siglen) return LONG_CODE_HEADER; 2338 int l1 = l0 - siglen; // do not count locals required by the signature 2339 int lims = shortCodeLimits[h][0]; 2340 int liml = shortCodeLimits[h][1]; 2341 if (s >= lims || l1 >= liml) return LONG_CODE_HEADER; 2342 int sc = shortCodeHeader_h_base(h); 2343 sc += s + lims*l1; 2344 if (sc > 255) return LONG_CODE_HEADER; 2345 assert(shortCodeHeader_max_stack(sc) == s); 2346 assert(shortCodeHeader_max_na_locals(sc) == l1); 2347 assert(shortCodeHeader_handler_count(sc) == h); 2348 return sc; 2349 } 2350 2351 static final int LONG_CODE_HEADER = 0; 2352 static int shortCodeHeader_handler_count(int sc) { 2353 assert(sc > 0 && sc <= 255); 2354 for (int h = 0; ; h++) { 2355 if (sc < shortCodeHeader_h_base(h+1)) 2356 return h; 2357 } 2358 } 2359 static int shortCodeHeader_max_stack(int sc) { 2360 int h = shortCodeHeader_handler_count(sc); 2361 int lims = shortCodeLimits[h][0]; 2362 return (sc - shortCodeHeader_h_base(h)) % lims; 2363 } 2364 static int shortCodeHeader_max_na_locals(int sc) { 2365 int h = shortCodeHeader_handler_count(sc); 2366 int lims = shortCodeLimits[h][0]; 2367 return (sc - shortCodeHeader_h_base(h)) / lims; 2368 } 2369 2370 private static int shortCodeHeader_h_base(int h) { 2371 assert(h <= shortCodeLimits.length); 2372 int sc = 1; 2373 for (int h0 = 0; h0 < h; h0++) { 2374 int lims = shortCodeLimits[h0][0]; 2375 int liml = shortCodeLimits[h0][1]; 2376 sc += lims * liml; 2377 } 2378 return sc; 2379 } 2380 2381 // utilities for accessing the bc_label band: 2382 protected void putLabel(IntBand bc_label, Code c, int pc, int targetPC) { 2383 bc_label.putInt(c.encodeBCI(targetPC) - c.encodeBCI(pc)); 2384 } 2385 protected int getLabel(IntBand bc_label, Code c, int pc) { 2386 return c.decodeBCI(bc_label.getInt() + c.encodeBCI(pc)); 2387 } 2388 2389 protected CPRefBand getCPRefOpBand(int bc) { 2390 switch (Instruction.getCPRefOpTag(bc)) { 2391 case CONSTANT_Class: 2392 return bc_classref; 2393 case CONSTANT_Fieldref: 2394 return bc_fieldref; 2395 case CONSTANT_Methodref: 2396 return bc_methodref; 2397 case CONSTANT_InterfaceMethodref: 2398 return bc_imethodref; 2399 case CONSTANT_InvokeDynamic: 2400 return bc_indyref; 2401 case CONSTANT_LoadableValue: 2402 switch (bc) { 2403 case _ildc: case _ildc_w: 2404 return bc_intref; 2405 case _fldc: case _fldc_w: 2406 return bc_floatref; 2407 case _lldc2_w: 2408 return bc_longref; 2409 case _dldc2_w: 2410 return bc_doubleref; 2411 case _sldc: case _sldc_w: 2412 return bc_stringref; 2413 case _cldc: case _cldc_w: 2414 return bc_classref; 2415 case _qldc: case _qldc_w: 2416 return bc_loadablevalueref; 2417 } 2418 break; 2419 } 2420 assert(false); 2421 return null; 2422 } 2423 2424 protected CPRefBand selfOpRefBand(int self_bc) { 2425 assert(Instruction.isSelfLinkerOp(self_bc)); 2426 int idx = (self_bc - _self_linker_op); 2427 boolean isSuper = (idx >= _self_linker_super_flag); 2428 if (isSuper) idx -= _self_linker_super_flag; 2429 boolean isAload = (idx >= _self_linker_aload_flag); 2430 if (isAload) idx -= _self_linker_aload_flag; 2431 int origBC = _first_linker_op + idx; 2432 boolean isField = Instruction.isFieldOp(origBC); 2433 if (!isSuper) 2434 return isField? bc_thisfield: bc_thismethod; 2435 else 2436 return isField? bc_superfield: bc_supermethod; 2437 } 2438 2439 //////////////////////////////////////////////////////////////////// 2440 2441 static int nextSeqForDebug; 2442 static File dumpDir = null; 2443 static OutputStream getDumpStream(Band b, String ext) throws IOException { 2444 return getDumpStream(b.name, b.seqForDebug, ext, b); 2445 } 2446 static OutputStream getDumpStream(Index ix, String ext) throws IOException { 2447 if (ix.size() == 0) return new ByteArrayOutputStream(); 2448 int seq = ConstantPool.TAG_ORDER[ix.cpMap[0].tag]; 2449 return getDumpStream(ix.debugName, seq, ext, ix); 2450 } 2451 static OutputStream getDumpStream(String name, int seq, String ext, Object b) throws IOException { 2452 if (dumpDir == null) { 2453 dumpDir = File.createTempFile("BD_", "", new File(".")); 2454 dumpDir.delete(); 2455 if (dumpDir.mkdir()) 2456 Utils.log.info("Dumping bands to "+dumpDir); 2457 } 2458 name = name.replace('(', ' ').replace(')', ' '); 2459 name = name.replace('/', ' '); 2460 name = name.replace('*', ' '); 2461 name = name.trim().replace(' ','_'); 2462 name = ((10000+seq) + "_" + name).substring(1); 2463 File dumpFile = new File(dumpDir, name+ext); 2464 Utils.log.info("Dumping "+b+" to "+dumpFile); 2465 return new BufferedOutputStream(new FileOutputStream(dumpFile)); 2466 } 2467 2468 // DEBUG ONLY: Validate me at each length change. 2469 static boolean assertCanChangeLength(Band b) { 2470 switch (b.phase) { 2471 case COLLECT_PHASE: 2472 case READ_PHASE: 2473 return true; 2474 } 2475 return false; 2476 } 2477 2478 // DEBUG ONLY: Validate a phase. 2479 static boolean assertPhase(Band b, int phaseExpected) { 2480 if (b.phase() != phaseExpected) { 2481 Utils.log.warning("phase expected "+phaseExpected+" was "+b.phase()+" in "+b); 2482 return false; 2483 } 2484 return true; 2485 } 2486 2487 2488 // DEBUG ONLY: Tells whether verbosity is turned on. 2489 static int verbose() { 2490 return Utils.currentPropMap().getInteger(Utils.DEBUG_VERBOSE); 2491 } 2492 2493 2494 // DEBUG ONLY: Validate me at each phase change. 2495 static boolean assertPhaseChangeOK(Band b, int p0, int p1) { 2496 switch (p0*10+p1) { 2497 /// Writing phases: 2498 case NO_PHASE*10+COLLECT_PHASE: 2499 // Ready to collect data from the input classes. 2500 assert(!b.isReader()); 2501 assert(b.capacity() >= 0); 2502 assert(b.length() == 0); 2503 return true; 2504 case COLLECT_PHASE*10+FROZEN_PHASE: 2505 case FROZEN_PHASE*10+FROZEN_PHASE: 2506 assert(b.length() == 0); 2507 return true; 2508 case COLLECT_PHASE*10+WRITE_PHASE: 2509 case FROZEN_PHASE*10+WRITE_PHASE: 2510 // Data is all collected. Ready to write bytes to disk. 2511 return true; 2512 case WRITE_PHASE*10+DONE_PHASE: 2513 // Done writing to disk. Ready to reset, in principle. 2514 return true; 2515 2516 /// Reading phases: 2517 case NO_PHASE*10+EXPECT_PHASE: 2518 assert(b.isReader()); 2519 assert(b.capacity() < 0); 2520 return true; 2521 case EXPECT_PHASE*10+READ_PHASE: 2522 // Ready to read values from disk. 2523 assert(Math.max(0,b.capacity()) >= b.valuesExpected()); 2524 assert(b.length() <= 0); 2525 return true; 2526 case READ_PHASE*10+DISBURSE_PHASE: 2527 // Ready to disburse values. 2528 assert(b.valuesRemainingForDebug() == b.length()); 2529 return true; 2530 case DISBURSE_PHASE*10+DONE_PHASE: 2531 // Done disbursing values. Ready to reset, in principle. 2532 assert(assertDoneDisbursing(b)); 2533 return true; 2534 } 2535 if (p0 == p1) 2536 Utils.log.warning("Already in phase "+p0); 2537 else 2538 Utils.log.warning("Unexpected phase "+p0+" -> "+p1); 2539 return false; 2540 } 2541 2542 private static boolean assertDoneDisbursing(Band b) { 2543 if (b.phase != DISBURSE_PHASE) { 2544 Utils.log.warning("assertDoneDisbursing: still in phase "+b.phase+": "+b); 2545 if (verbose() <= 1) return false; // fail now 2546 } 2547 int left = b.valuesRemainingForDebug(); 2548 if (left > 0) { 2549 Utils.log.warning("assertDoneDisbursing: "+left+" values left in "+b); 2550 if (verbose() <= 1) return false; // fail now 2551 } 2552 if (b instanceof MultiBand) { 2553 MultiBand mb = (MultiBand) b; 2554 for (int i = 0; i < mb.bandCount; i++) { 2555 Band sub = mb.bands[i]; 2556 if (sub.phase != DONE_PHASE) { 2557 Utils.log.warning("assertDoneDisbursing: sub-band still in phase "+sub.phase+": "+sub); 2558 if (verbose() <= 1) return false; // fail now 2559 } 2560 } 2561 } 2562 return true; 2563 } 2564 2565 private static void printCDecl(Band b) { 2566 if (b instanceof MultiBand) { 2567 MultiBand mb = (MultiBand) b; 2568 for (int i = 0; i < mb.bandCount; i++) { 2569 printCDecl(mb.bands[i]); 2570 } 2571 return; 2572 } 2573 String ixS = "NULL"; 2574 if (b instanceof CPRefBand) { 2575 Index ix = ((CPRefBand)b).index; 2576 if (ix != null) ixS = "INDEX("+ix.debugName+")"; 2577 } 2578 Coding[] knownc = { BYTE1, CHAR3, BCI5, BRANCH5, UNSIGNED5, 2579 UDELTA5, SIGNED5, DELTA5, MDELTA5 }; 2580 String[] knowns = { "BYTE1", "CHAR3", "BCI5", "BRANCH5", "UNSIGNED5", 2581 "UDELTA5", "SIGNED5", "DELTA5", "MDELTA5" }; 2582 Coding rc = b.regularCoding; 2583 int rci = Arrays.asList(knownc).indexOf(rc); 2584 String cstr; 2585 if (rci >= 0) 2586 cstr = knowns[rci]; 2587 else 2588 cstr = "CODING"+rc.keyString(); 2589 System.out.println(" BAND_INIT(\""+b.name()+"\"" 2590 +", "+cstr+", "+ixS+"),"); 2591 } 2592 2593 private Map<Band, Band> prevForAssertMap; 2594 2595 // DEBUG ONLY: Record something about the band order. 2596 boolean notePrevForAssert(Band b, Band p) { 2597 if (prevForAssertMap == null) 2598 prevForAssertMap = new HashMap<>(); 2599 prevForAssertMap.put(b, p); 2600 return true; 2601 } 2602 2603 // DEBUG ONLY: Validate next input band, ensure bands are read in sequence 2604 private boolean assertReadyToReadFrom(Band b, InputStream in) throws IOException { 2605 Band p = prevForAssertMap.get(b); 2606 // Any previous band must be done reading before this one starts. 2607 if (p != null && phaseCmp(p.phase(), DISBURSE_PHASE) < 0) { 2608 Utils.log.warning("Previous band not done reading."); 2609 Utils.log.info(" Previous band: "+p); 2610 Utils.log.info(" Next band: "+b); 2611 assert(verbose > 0); // die unless verbose is true 2612 } 2613 String name = b.name; 2614 if (optDebugBands && !name.startsWith("(")) { 2615 assert(bandSequenceList != null); 2616 // Verify synchronization between reader & writer: 2617 String inName = bandSequenceList.removeFirst(); 2618 // System.out.println("Reading: " + name); 2619 if (!inName.equals(name)) { 2620 Utils.log.warning("Expected " + name + " but read: " + inName); 2621 return false; 2622 } 2623 Utils.log.info("Read band in sequence: " + name); 2624 } 2625 return true; 2626 } 2627 2628 // DEBUG ONLY: Make sure a bunch of cprefs are correct. 2629 private boolean assertValidCPRefs(CPRefBand b) { 2630 if (b.index == null) return true; 2631 int limit = b.index.size()+1; 2632 for (int i = 0; i < b.length(); i++) { 2633 int v = b.valueAtForDebug(i); 2634 if (v < 0 || v >= limit) { 2635 Utils.log.warning("CP ref out of range "+ 2636 "["+i+"] = "+v+" in "+b); 2637 return false; 2638 } 2639 } 2640 return true; 2641 } 2642 2643 /* 2644 * DEBUG ONLY: write the bands to a list and read back the list in order, 2645 * this works perfectly if we use the java packer and unpacker, typically 2646 * this will work with --repack or if they are in the same jvm instance. 2647 */ 2648 static LinkedList<String> bandSequenceList = null; 2649 private boolean assertReadyToWriteTo(Band b, OutputStream out) throws IOException { 2650 Band p = prevForAssertMap.get(b); 2651 // Any previous band must be done writing before this one starts. 2652 if (p != null && phaseCmp(p.phase(), DONE_PHASE) < 0) { 2653 Utils.log.warning("Previous band not done writing."); 2654 Utils.log.info(" Previous band: "+p); 2655 Utils.log.info(" Next band: "+b); 2656 assert(verbose > 0); // die unless verbose is true 2657 } 2658 String name = b.name; 2659 if (optDebugBands && !name.startsWith("(")) { 2660 if (bandSequenceList == null) 2661 bandSequenceList = new LinkedList<>(); 2662 // Verify synchronization between reader & writer: 2663 bandSequenceList.add(name); 2664 // System.out.println("Writing: " + b); 2665 } 2666 return true; 2667 } 2668 2669 protected static boolean testBit(int flags, int bitMask) { 2670 return (flags & bitMask) != 0; 2671 } 2672 protected static int setBit(int flags, int bitMask, boolean z) { 2673 return z ? (flags | bitMask) : (flags &~ bitMask); 2674 } 2675 protected static boolean testBit(long flags, long bitMask) { 2676 return (flags & bitMask) != 0; 2677 } 2678 protected static long setBit(long flags, long bitMask, boolean z) { 2679 return z ? (flags | bitMask) : (flags &~ bitMask); 2680 } 2681 2682 2683 static void printArrayTo(PrintStream ps, int[] values, int start, int end) { 2684 int len = end-start; 2685 for (int i = 0; i < len; i++) { 2686 if (i % 10 == 0) 2687 ps.println(); 2688 else 2689 ps.print(" "); 2690 ps.print(values[start+i]); 2691 } 2692 ps.println(); 2693 } 2694 2695 static void printArrayTo(PrintStream ps, Entry[] cpMap, int start, int end) { 2696 printArrayTo(ps, cpMap, start, end, false); 2697 } 2698 static void printArrayTo(PrintStream ps, Entry[] cpMap, int start, int end, boolean showTags) { 2699 StringBuffer buf = new StringBuffer(); 2700 int len = end-start; 2701 for (int i = 0; i < len; i++) { 2702 Entry e = cpMap[start+i]; 2703 ps.print(start+i); ps.print("="); 2704 if (showTags) { ps.print(e.tag); ps.print(":"); } 2705 String s = e.stringValue(); 2706 buf.setLength(0); 2707 for (int j = 0; j < s.length(); j++) { 2708 char ch = s.charAt(j); 2709 if (!(ch < ' ' || ch > '~' || ch == '\\')) { 2710 buf.append(ch); 2711 } else if (ch == '\\') { 2712 buf.append("\\\\"); 2713 } else if (ch == '\n') { 2714 buf.append("\\n"); 2715 } else if (ch == '\t') { 2716 buf.append("\\t"); 2717 } else if (ch == '\r') { 2718 buf.append("\\r"); 2719 } else { 2720 String str = "000"+Integer.toHexString(ch); 2721 buf.append("\\u").append(str.substring(str.length()-4)); 2722 } 2723 } 2724 ps.println(buf); 2725 } 2726 } 2727 2728 2729 // Utilities for reallocating: 2730 protected static Object[] realloc(Object[] a, int len) { 2731 java.lang.Class<?> elt = a.getClass().getComponentType(); 2732 Object[] na = (Object[]) java.lang.reflect.Array.newInstance(elt, len); 2733 System.arraycopy(a, 0, na, 0, Math.min(a.length, len)); 2734 return na; 2735 } 2736 protected static Object[] realloc(Object[] a) { 2737 return realloc(a, Math.max(10, a.length*2)); 2738 } 2739 2740 protected static int[] realloc(int[] a, int len) { 2741 if (len == 0) return noInts; 2742 if (a == null) return new int[len]; 2743 int[] na = new int[len]; 2744 System.arraycopy(a, 0, na, 0, Math.min(a.length, len)); 2745 return na; 2746 } 2747 protected static int[] realloc(int[] a) { 2748 return realloc(a, Math.max(10, a.length*2)); 2749 } 2750 2751 protected static byte[] realloc(byte[] a, int len) { 2752 if (len == 0) return noBytes; 2753 if (a == null) return new byte[len]; 2754 byte[] na = new byte[len]; 2755 System.arraycopy(a, 0, na, 0, Math.min(a.length, len)); 2756 return na; 2757 } 2758 protected static byte[] realloc(byte[] a) { 2759 return realloc(a, Math.max(10, a.length*2)); 2760 } 2761} 2762