Source code

001/*
002 *  Licensed to the Apache Software Foundation (ASF) under one or more
003 *  contributor license agreements.  See the NOTICE file distributed with
004 *  this work for additional information regarding copyright ownership.
005 *  The ASF licenses this file to You under the Apache License, Version 2.0
006 *  (the "License"); you may not use this file except in compliance with
007 *  the License.  You may obtain a copy of the License at
008 *
009 *     http://www.apache.org/licenses/LICENSE-2.0
010 *
011 *  Unless required by applicable law or agreed to in writing, software
012 *  distributed under the License is distributed on an "AS IS" BASIS,
013 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 *  See the License for the specific language governing permissions and
015 *  limitations under the License.
016 */
017package org.apache.commons.compress.harmony.unpack200;
018
019import java.io.IOException;
020import java.io.InputStream;
021import java.io.StringReader;
022import java.util.ArrayList;
023import java.util.Collections;
024import java.util.List;
025
026import org.apache.commons.compress.harmony.pack200.BHSDCodec;
027import org.apache.commons.compress.harmony.pack200.Codec;
028import org.apache.commons.compress.harmony.pack200.Pack200Exception;
029import org.apache.commons.compress.harmony.unpack200.bytecode.Attribute;
030import org.apache.commons.compress.harmony.unpack200.bytecode.CPClass;
031import org.apache.commons.compress.harmony.unpack200.bytecode.CPDouble;
032import org.apache.commons.compress.harmony.unpack200.bytecode.CPFieldRef;
033import org.apache.commons.compress.harmony.unpack200.bytecode.CPFloat;
034import org.apache.commons.compress.harmony.unpack200.bytecode.CPInteger;
035import org.apache.commons.compress.harmony.unpack200.bytecode.CPInterfaceMethodRef;
036import org.apache.commons.compress.harmony.unpack200.bytecode.CPLong;
037import org.apache.commons.compress.harmony.unpack200.bytecode.CPMethodRef;
038import org.apache.commons.compress.harmony.unpack200.bytecode.CPNameAndType;
039import org.apache.commons.compress.harmony.unpack200.bytecode.CPString;
040import org.apache.commons.compress.harmony.unpack200.bytecode.CPUTF8;
041import org.apache.commons.compress.harmony.unpack200.bytecode.NewAttribute;
042import org.apache.commons.compress.utils.ParsingUtils;
043
044/**
045 * Sets of bands relating to a non-predefined attribute
046 */
047public class NewAttributeBands extends BandSet {
048
049    /**
050     * An AttributeLayoutElement is a part of an attribute layout and has one or more bands associated with it, which transmit the AttributeElement data for
051     * successive Attributes of this type.
052     */
053    private interface AttributeLayoutElement {
054
055        /**
056         * Adds the band data for this element at the given index to the attribute.
057         *
058         * @param index     Index position to add the attribute.
059         * @param attribute The attribute to add.
060         */
061        void addToAttribute(int index, NewAttribute attribute);
062
063        /**
064         * Read the bands associated with this part of the layout.
065         *
066         * @param in    TODO
067         * @param count TODO
068         * @throws Pack200Exception Bad archive.
069         * @throws IOException      If an I/O error occurs.
070         */
071        void readBands(InputStream in, int count) throws IOException, Pack200Exception;
072
073    }
074
075    public class Call extends LayoutElement {
076
077        private final int callableIndex;
078        private Callable callable;
079
080        public Call(final int callableIndex) {
081            this.callableIndex = callableIndex;
082        }
083
084        @Override
085        public void addToAttribute(final int n, final NewAttribute attribute) {
086            callable.addNextToAttribute(attribute);
087        }
088
089        public Callable getCallable() {
090            return callable;
091        }
092
093        public int getCallableIndex() {
094            return callableIndex;
095        }
096
097        @Override
098        public void readBands(final InputStream in, final int count) {
099            /*
100             * We don't read anything here, but we need to pass the extra count to the callable if it's a forwards call. For backwards callables the count is
101             * transmitted directly in the attribute bands and so it is added later.
102             */
103            if (callableIndex > 0) {
104                callable.addCount(count);
105            }
106        }
107
108        public void setCallable(final Callable callable) {
109            this.callable = callable;
110            if (callableIndex < 1) {
111                callable.setBackwardsCallable();
112            }
113        }
114    }
115
116    public static class Callable implements AttributeLayoutElement {
117
118        private final List<LayoutElement> body;
119
120        private boolean isBackwardsCallable;
121
122        private boolean isFirstCallable;
123
124        private int count;
125
126        private int index;
127
128        public Callable(final List<LayoutElement> body) {
129            this.body = body;
130        }
131
132        /**
133         * Adds the count of a call to this callable (ie the number of calls)
134         *
135         * @param count TODO
136         */
137        public void addCount(final int count) {
138            this.count += count;
139        }
140
141        /**
142         * Used by calls when adding band contents to attributes, so they don't have to keep track of the internal index of the callable.
143         *
144         * @param attribute TODO
145         */
146        public void addNextToAttribute(final NewAttribute attribute) {
147            for (final LayoutElement element : body) {
148                element.addToAttribute(index, attribute);
149            }
150            index++;
151        }
152
153        @Override
154        public void addToAttribute(final int n, final NewAttribute attribute) {
155            if (isFirstCallable) {
156                // Ignore n because bands also contain element parts from calls
157                for (final LayoutElement element : body) {
158                    element.addToAttribute(index, attribute);
159                }
160                index++;
161            }
162        }
163
164        public List<LayoutElement> getBody() {
165            return body;
166        }
167
168        public boolean isBackwardsCallable() {
169            return isBackwardsCallable;
170        }
171
172        @Override
173        public void readBands(final InputStream in, int count) throws IOException, Pack200Exception {
174            if (isFirstCallable) {
175                count += this.count;
176            } else {
177                count = this.count;
178            }
179            for (final LayoutElement element : body) {
180                element.readBands(in, count);
181            }
182        }
183
184        /**
185         * Tells this Callable that it is a backwards callable
186         */
187        public void setBackwardsCallable() {
188            this.isBackwardsCallable = true;
189        }
190
191        public void setFirstCallable(final boolean isFirstCallable) {
192            this.isFirstCallable = isFirstCallable;
193        }
194    }
195
196    public class Integral extends LayoutElement {
197
198        private final String tag;
199
200        private int[] band;
201
202        public Integral(final String tag) {
203            this.tag = tag;
204        }
205
206        @Override
207        public void addToAttribute(final int n, final NewAttribute attribute) {
208            int value = band[n];
209            if (tag.equals("B") || tag.equals("FB")) {
210                attribute.addInteger(1, value);
211            } else if (tag.equals("SB")) {
212                attribute.addInteger(1, (byte) value);
213            } else if (tag.equals("H") || tag.equals("FH")) {
214                attribute.addInteger(2, value);
215            } else if (tag.equals("SH")) {
216                attribute.addInteger(2, (short) value);
217            } else if (tag.equals("I") || tag.equals("FI") || tag.equals("SI")) {
218                attribute.addInteger(4, value);
219            } else if (tag.equals("V") || tag.equals("FV") || tag.equals("SV")) {
220                // Don't add V's - they shouldn't be written out to the class
221                // file
222            } else if (tag.startsWith("PO")) {
223                final char uintType = tag.substring(2).toCharArray()[0];
224                final int length = getLength(uintType);
225                attribute.addBCOffset(length, value);
226            } else if (tag.startsWith("P")) {
227                final char uintType = tag.substring(1).toCharArray()[0];
228                final int length = getLength(uintType);
229                attribute.addBCIndex(length, value);
230            } else if (tag.startsWith("OS")) {
231                final char uintType = tag.substring(2).toCharArray()[0];
232                final int length = getLength(uintType);
233                switch (length) {
234                case 1:
235                    value = (byte) value;
236                    break;
237                case 2:
238                    value = (short) value;
239                    break;
240                case 4:
241                    value = value;
242                    break;
243                default:
244                    break;
245                }
246                attribute.addBCLength(length, value);
247            } else if (tag.startsWith("O")) {
248                final char uintType = tag.substring(1).toCharArray()[0];
249                final int length = getLength(uintType);
250                attribute.addBCLength(length, value);
251            }
252        }
253
254        public String getTag() {
255            return tag;
256        }
257
258        int getValue(final int index) {
259            return band[index];
260        }
261
262        @Override
263        public void readBands(final InputStream in, final int count) throws IOException, Pack200Exception {
264            band = decodeBandInt(attributeLayout.getName() + "_" + tag, in, getCodec(tag), count);
265        }
266
267    }
268
269    private abstract static class LayoutElement implements AttributeLayoutElement {
270
271        protected int getLength(final char uintType) {
272            int length = 0;
273            switch (uintType) {
274            case 'B':
275                length = 1;
276                break;
277            case 'H':
278                length = 2;
279                break;
280            case 'I':
281                length = 4;
282                break;
283            case 'V':
284                length = 0;
285                break;
286            }
287            return length;
288        }
289    }
290
291    /**
292     * Constant Pool Reference
293     */
294    public class Reference extends LayoutElement {
295
296        private final String tag;
297
298        private Object band;
299
300        private final int length;
301
302        public Reference(final String tag) {
303            this.tag = tag;
304            length = getLength(tag.charAt(tag.length() - 1));
305        }
306
307        @Override
308        public void addToAttribute(final int n, final NewAttribute attribute) {
309            if (tag.startsWith("KI")) { // Integer
310                attribute.addToBody(length, ((CPInteger[]) band)[n]);
311            } else if (tag.startsWith("KJ")) { // Long
312                attribute.addToBody(length, ((CPLong[]) band)[n]);
313            } else if (tag.startsWith("KF")) { // Float
314                attribute.addToBody(length, ((CPFloat[]) band)[n]);
315            } else if (tag.startsWith("KD")) { // Double
316                attribute.addToBody(length, ((CPDouble[]) band)[n]);
317            } else if (tag.startsWith("KS")) { // String
318                attribute.addToBody(length, ((CPString[]) band)[n]);
319            } else if (tag.startsWith("RC")) { // Class
320                attribute.addToBody(length, ((CPClass[]) band)[n]);
321            } else if (tag.startsWith("RS")) { // Signature
322                attribute.addToBody(length, ((CPUTF8[]) band)[n]);
323            } else if (tag.startsWith("RD")) { // Descriptor
324                attribute.addToBody(length, ((CPNameAndType[]) band)[n]);
325            } else if (tag.startsWith("RF")) { // Field Reference
326                attribute.addToBody(length, ((CPFieldRef[]) band)[n]);
327            } else if (tag.startsWith("RM")) { // Method Reference
328                attribute.addToBody(length, ((CPMethodRef[]) band)[n]);
329            } else if (tag.startsWith("RI")) { // Interface Method Reference
330                attribute.addToBody(length, ((CPInterfaceMethodRef[]) band)[n]);
331            } else if (tag.startsWith("RU")) { // UTF8 String
332                attribute.addToBody(length, ((CPUTF8[]) band)[n]);
333            }
334        }
335
336        public String getTag() {
337            return tag;
338        }
339
340        @Override
341        public void readBands(final InputStream in, final int count) throws IOException, Pack200Exception {
342            if (tag.startsWith("KI")) { // Integer
343                band = parseCPIntReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
344            } else if (tag.startsWith("KJ")) { // Long
345                band = parseCPLongReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
346            } else if (tag.startsWith("KF")) { // Float
347                band = parseCPFloatReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
348            } else if (tag.startsWith("KD")) { // Double
349                band = parseCPDoubleReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
350            } else if (tag.startsWith("KS")) { // String
351                band = parseCPStringReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
352            } else if (tag.startsWith("RC")) { // Class
353                band = parseCPClassReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
354            } else if (tag.startsWith("RS")) { // Signature
355                band = parseCPSignatureReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
356            } else if (tag.startsWith("RD")) { // Descriptor
357                band = parseCPDescriptorReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
358            } else if (tag.startsWith("RF")) { // Field Reference
359                band = parseCPFieldRefReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
360            } else if (tag.startsWith("RM")) { // Method Reference
361                band = parseCPMethodRefReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
362            } else if (tag.startsWith("RI")) { // Interface Method Reference
363                band = parseCPInterfaceMethodRefReferences(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
364            } else if (tag.startsWith("RU")) { // UTF8 String
365                band = parseCPUTF8References(attributeLayout.getName(), in, Codec.UNSIGNED5, count);
366            }
367        }
368
369    }
370
371    /**
372     * A replication is an array of layout elements, with an associated count
373     */
374    public class Replication extends LayoutElement {
375
376        private final Integral countElement;
377
378        private final List<LayoutElement> layoutElements = new ArrayList<>();
379
380        public Replication(final String tag, final String contents) throws IOException {
381            this.countElement = new Integral(tag);
382            final StringReader stream = new StringReader(contents);
383            LayoutElement e;
384            while ((e = readNextLayoutElement(stream)) != null) {
385                layoutElements.add(e);
386            }
387        }
388
389        @Override
390        public void addToAttribute(final int index, final NewAttribute attribute) {
391            // Add the count value
392            countElement.addToAttribute(index, attribute);
393
394            // Add the corresponding array values
395            int offset = 0;
396            for (int i = 0; i < index; i++) {
397                offset += countElement.getValue(i);
398            }
399            final long numElements = countElement.getValue(index);
400            for (int i = offset; i < offset + numElements; i++) {
401                for (final LayoutElement layoutElement : layoutElements) {
402                    layoutElement.addToAttribute(i, attribute);
403                }
404            }
405        }
406
407        public Integral getCountElement() {
408            return countElement;
409        }
410
411        public List<LayoutElement> getLayoutElements() {
412            return layoutElements;
413        }
414
415        @Override
416        public void readBands(final InputStream in, final int count) throws IOException, Pack200Exception {
417            countElement.readBands(in, count);
418            int arrayCount = 0;
419            for (int i = 0; i < count; i++) {
420                arrayCount += countElement.getValue(i);
421            }
422            for (final LayoutElement layoutElement : layoutElements) {
423                layoutElement.readBands(in, arrayCount);
424            }
425        }
426    }
427
428    /**
429     * A Union is a type of layout element where the tag value acts as a selector for one of the union cases
430     */
431    public class Union extends LayoutElement {
432
433        private final Integral unionTag;
434        private final List<UnionCase> unionCases;
435        private final List<LayoutElement> defaultCaseBody;
436        private int[] caseCounts;
437        private int defaultCount;
438
439        public Union(final String tag, final List<UnionCase> unionCases, final List<LayoutElement> body) {
440            this.unionTag = new Integral(tag);
441            this.unionCases = unionCases;
442            this.defaultCaseBody = body;
443        }
444
445        @Override
446        public void addToAttribute(final int n, final NewAttribute attribute) {
447            unionTag.addToAttribute(n, attribute);
448            int offset = 0;
449            final int[] tagBand = unionTag.band;
450            final int tag = unionTag.getValue(n);
451            boolean defaultCase = true;
452            for (final UnionCase unionCase : unionCases) {
453                if (unionCase.hasTag(tag)) {
454                    defaultCase = false;
455                    for (int j = 0; j < n; j++) {
456                        if (unionCase.hasTag(tagBand[j])) {
457                            offset++;
458                        }
459                    }
460                    unionCase.addToAttribute(offset, attribute);
461                }
462            }
463            if (defaultCase) {
464                // default case
465                int defaultOffset = 0;
466                for (int j = 0; j < n; j++) {
467                    boolean found = false;
468                    for (final UnionCase unionCase : unionCases) {
469                        if (unionCase.hasTag(tagBand[j])) {
470                            found = true;
471                        }
472                    }
473                    if (!found) {
474                        defaultOffset++;
475                    }
476                }
477                if (defaultCaseBody != null) {
478                    for (final LayoutElement element : defaultCaseBody) {
479                        element.addToAttribute(defaultOffset, attribute);
480                    }
481                }
482            }
483        }
484
485        public List<LayoutElement> getDefaultCaseBody() {
486            return defaultCaseBody;
487        }
488
489        public List<UnionCase> getUnionCases() {
490            return unionCases;
491        }
492
493        public Integral getUnionTag() {
494            return unionTag;
495        }
496
497        @Override
498        public void readBands(final InputStream in, final int count) throws IOException, Pack200Exception {
499            unionTag.readBands(in, count);
500            final int[] values = unionTag.band;
501            // Count the band size for each union case then read the bands
502            caseCounts = new int[unionCases.size()];
503            for (int i = 0; i < caseCounts.length; i++) {
504                final UnionCase unionCase = unionCases.get(i);
505                for (final int value : values) {
506                    if (unionCase.hasTag(value)) {
507                        caseCounts[i]++;
508                    }
509                }
510                unionCase.readBands(in, caseCounts[i]);
511            }
512            // Count number of default cases then read the default bands
513            for (final int value : values) {
514                boolean found = false;
515                for (final UnionCase unionCase : unionCases) {
516                    if (unionCase.hasTag(value)) {
517                        found = true;
518                    }
519                }
520                if (!found) {
521                    defaultCount++;
522                }
523            }
524            if (defaultCaseBody != null) {
525                for (final LayoutElement element : defaultCaseBody) {
526                    element.readBands(in, defaultCount);
527                }
528            }
529        }
530
531    }
532
533    /**
534     * A Union case
535     */
536    public class UnionCase extends LayoutElement {
537
538        private List<LayoutElement> body;
539
540        private final List<Integer> tags;
541
542        public UnionCase(final List<Integer> tags) {
543            this.tags = tags;
544        }
545
546        public UnionCase(final List<Integer> tags, final List<LayoutElement> body) {
547            this.tags = tags;
548            this.body = body;
549        }
550
551        @Override
552        public void addToAttribute(final int index, final NewAttribute attribute) {
553            if (body != null) {
554                for (final LayoutElement element : body) {
555                    element.addToAttribute(index, attribute);
556                }
557            }
558        }
559
560        public List<LayoutElement> getBody() {
561            return body == null ? Collections.EMPTY_LIST : body;
562        }
563
564        public boolean hasTag(final int i) {
565            return tags.contains(Integer.valueOf(i));
566        }
567
568        public boolean hasTag(final long l) {
569            return tags.contains(Integer.valueOf((int) l));
570        }
571
572        @Override
573        public void readBands(final InputStream in, final int count) throws IOException, Pack200Exception {
574            if (body != null) {
575                for (final LayoutElement element : body) {
576                    element.readBands(in, count);
577                }
578            }
579        }
580    }
581
582    private final AttributeLayout attributeLayout;
583
584    private int backwardsCallCount;
585
586    protected List<AttributeLayoutElement> attributeLayoutElements;
587
588    public NewAttributeBands(final Segment segment, final AttributeLayout attributeLayout) throws IOException {
589        super(segment);
590        this.attributeLayout = attributeLayout;
591        parseLayout();
592        attributeLayout.setBackwardsCallCount(backwardsCallCount);
593    }
594
595    public int getBackwardsCallCount() {
596        return backwardsCallCount;
597    }
598
599    /**
600     * Returns the {@link BHSDCodec} that should be used for the given layout element.
601     *
602     * @param layoutElement TODO
603     * @return the {@link BHSDCodec} that should be used for the given layout element.
604     */
605    public BHSDCodec getCodec(final String layoutElement) {
606        if (layoutElement.indexOf('O') >= 0) {
607            return Codec.BRANCH5;
608        }
609        if (layoutElement.indexOf('P') >= 0) {
610            return Codec.BCI5;
611        }
612        if (layoutElement.indexOf('S') >= 0 && !layoutElement.contains("KS") //$NON-NLS-1$
613                && !layoutElement.contains("RS")) { //$NON-NLS-1$
614            return Codec.SIGNED5;
615        }
616        if (layoutElement.indexOf('B') >= 0) {
617            return Codec.BYTE1;
618        }
619        return Codec.UNSIGNED5;
620    }
621
622    /**
623     * Gets one attribute at the given index from the various bands. The correct bands must have already been read in.
624     *
625     * @param index    TODO
626     * @param elements TODO
627     * @return attribute at the given index.
628     */
629    private Attribute getOneAttribute(final int index, final List<AttributeLayoutElement> elements) {
630        final NewAttribute attribute = new NewAttribute(segment.getCpBands().cpUTF8Value(attributeLayout.getName()), attributeLayout.getIndex());
631        for (final AttributeLayoutElement element : elements) {
632            element.addToAttribute(index, attribute);
633        }
634        return attribute;
635    }
636
637    /**
638     * Utility method to get the contents of the given stream, up to the next {@code ]}, (ignoring pairs of brackets {@code [} and {@code ]})
639     *
640     * @param stream
641     * @return
642     * @throws IOException If an I/O error occurs.
643     */
644    private StringReader getStreamUpToMatchingBracket(final StringReader stream) throws IOException {
645        final StringBuilder sb = new StringBuilder();
646        int foundBracket = -1;
647        while (foundBracket != 0) {
648            final int read = stream.read();
649            if (read == -1) {
650                break;
651            }
652            final char c = (char) read;
653            if (c == ']') {
654                foundBracket++;
655            }
656            if (c == '[') {
657                foundBracket--;
658            }
659            if (!(foundBracket == 0)) {
660                sb.append(c);
661            }
662        }
663        return new StringReader(sb.toString());
664    }
665
666    /**
667     * Parse the bands relating to this AttributeLayout and return the correct class file attributes as a List of {@link Attribute}.
668     *
669     * @param in              parse source.
670     * @param occurrenceCount TODO
671     * @return Class file attributes as a List of {@link Attribute}.
672     * @throws IOException      If an I/O error occurs.
673     * @throws Pack200Exception TODO
674     */
675    public List<Attribute> parseAttributes(final InputStream in, final int occurrenceCount) throws IOException, Pack200Exception {
676        for (final AttributeLayoutElement element : attributeLayoutElements) {
677            element.readBands(in, occurrenceCount);
678        }
679
680        final List<Attribute> attributes = new ArrayList<>(occurrenceCount);
681        for (int i = 0; i < occurrenceCount; i++) {
682            attributes.add(getOneAttribute(i, attributeLayoutElements));
683        }
684        return attributes;
685    }
686
687    /**
688     * Tokenize the layout into AttributeElements
689     *
690     * @throws IOException If an I/O error occurs.
691     */
692    private void parseLayout() throws IOException {
693        if (attributeLayoutElements == null) {
694            attributeLayoutElements = new ArrayList<>();
695            final StringReader stream = new StringReader(attributeLayout.getLayout());
696            AttributeLayoutElement e;
697            while ((e = readNextAttributeElement(stream)) != null) {
698                attributeLayoutElements.add(e);
699            }
700            resolveCalls();
701        }
702    }
703
704    /*
705     * (non-Javadoc)
706     *
707     * @see org.apache.commons.compress.harmony.unpack200.BandSet#unpack(java.io.InputStream)
708     */
709    @Override
710    public void read(final InputStream in) throws IOException, Pack200Exception {
711        // does nothing - use parseAttributes instead
712    }
713
714    /**
715     * Read a 'body' section of the layout from the given stream
716     *
717     * @param stream
718     * @return List of LayoutElements
719     * @throws IOException If an I/O error occurs.
720     */
721    private List<LayoutElement> readBody(final StringReader stream) throws IOException {
722        final List<LayoutElement> layoutElements = new ArrayList<>();
723        LayoutElement e;
724        while ((e = readNextLayoutElement(stream)) != null) {
725            layoutElements.add(e);
726        }
727        return layoutElements;
728    }
729
730    private AttributeLayoutElement readNextAttributeElement(final StringReader stream) throws IOException {
731        stream.mark(1);
732        final int next = stream.read();
733        if (next == -1) {
734            return null;
735        }
736        if (next == '[') {
737            return new Callable(readBody(getStreamUpToMatchingBracket(stream)));
738        }
739        stream.reset();
740        return readNextLayoutElement(stream);
741    }
742
743    private LayoutElement readNextLayoutElement(final StringReader stream) throws IOException {
744        final int nextChar = stream.read();
745        if (nextChar == -1) {
746            return null;
747        }
748        switch (nextChar) {
749        // Integrals
750        case 'B':
751        case 'H':
752        case 'I':
753        case 'V':
754            return new Integral(new String(new char[] { (char) nextChar }));
755        case 'S':
756        case 'F':
757            return new Integral(new String(new char[] { (char) nextChar, (char) stream.read() }));
758        case 'P':
759            stream.mark(1);
760            if (stream.read() != 'O') {
761                stream.reset();
762                return new Integral("P" + (char) stream.read());
763            }
764            return new Integral("PO" + (char) stream.read());
765        case 'O':
766            stream.mark(1);
767            if (stream.read() != 'S') {
768                stream.reset();
769                return new Integral("O" + (char) stream.read());
770            }
771            return new Integral("OS" + (char) stream.read());
772
773        // Replication
774        case 'N':
775            final char uintType = (char) stream.read();
776            stream.read(); // '['
777            final String str = readUpToMatchingBracket(stream);
778            return new Replication("" + uintType, str);
779
780        // Union
781        case 'T':
782            String intType = "" + (char) stream.read();
783            if (intType.equals("S")) {
784                intType += (char) stream.read();
785            }
786            final List<UnionCase> unionCases = new ArrayList<>();
787            UnionCase c;
788            while ((c = readNextUnionCase(stream)) != null) {
789                unionCases.add(c);
790            }
791            stream.read(); // '('
792            stream.read(); // ')'
793            stream.read(); // '['
794            List<LayoutElement> body = null;
795            stream.mark(1);
796            final char next = (char) stream.read();
797            if (next != ']') {
798                stream.reset();
799                body = readBody(getStreamUpToMatchingBracket(stream));
800            }
801            return new Union(intType, unionCases, body);
802
803        // Call
804        case '(':
805            final int number = readNumber(stream).intValue();
806            stream.read(); // ')'
807            return new Call(number);
808        // Reference
809        case 'K':
810        case 'R':
811            final StringBuilder string = new StringBuilder("").append((char) nextChar).append((char) stream.read());
812            final char nxt = (char) stream.read();
813            string.append(nxt);
814            if (nxt == 'N') {
815                string.append((char) stream.read());
816            }
817            return new Reference(string.toString());
818        }
819        return null;
820    }
821
822    /**
823     * Read a UnionCase from the stream.
824     *
825     * @param stream source stream.
826     * @return A UnionCase from the stream.
827     * @throws IOException If an I/O error occurs.
828     */
829    private UnionCase readNextUnionCase(final StringReader stream) throws IOException {
830        stream.mark(2);
831        stream.read(); // '('
832        final int next = stream.read();
833        char ch = (char) next;
834        if (ch == ')' || next == -1) {
835            stream.reset();
836            return null;
837        }
838        stream.reset();
839        stream.read(); // '('
840        final List<Integer> tags = new ArrayList<>();
841        Integer nextTag;
842        do {
843            nextTag = readNumber(stream);
844            if (nextTag != null) {
845                tags.add(nextTag);
846                stream.read(); // ',' or ')'
847            }
848        } while (nextTag != null);
849        stream.read(); // '['
850        stream.mark(1);
851        ch = (char) stream.read();
852        if (ch == ']') {
853            return new UnionCase(tags);
854        }
855        stream.reset();
856        return new UnionCase(tags, readBody(getStreamUpToMatchingBracket(stream)));
857    }
858
859    /**
860     * Read a number from the stream and return it
861     *
862     * @param stream
863     * @return
864     * @throws IOException If an I/O error occurs.
865     */
866    private Integer readNumber(final StringReader stream) throws IOException {
867        stream.mark(1);
868        final char first = (char) stream.read();
869        final boolean negative = first == '-';
870        if (!negative) {
871            stream.reset();
872        }
873        stream.mark(100);
874        int i;
875        int length = 0;
876        while ((i = stream.read()) != -1 && Character.isDigit((char) i)) {
877            length++;
878        }
879        stream.reset();
880        if (length == 0) {
881            return null;
882        }
883        final char[] digits = new char[length];
884        final int read = stream.read(digits);
885        if (read != digits.length) {
886            throw new IOException("Error reading from the input stream");
887        }
888        return ParsingUtils.parseIntValue((negative ? "-" : "") + new String(digits));
889    }
890
891    /**
892     * Gets the contents of the given stream, up to the next {@code ]}, (ignoring pairs of brackets {@code [} and {@code ]})
893     *
894     * @param stream input stream.
895     * @return the contents of the given stream.
896     * @throws IOException If an I/O error occurs.
897     */
898    private String readUpToMatchingBracket(final StringReader stream) throws IOException {
899        final StringBuilder sb = new StringBuilder();
900        int foundBracket = -1;
901        while (foundBracket != 0) {
902            final int read = stream.read();
903            if (read == -1) {
904                break;
905            }
906            final char c = (char) read;
907            if (c == ']') {
908                foundBracket++;
909            }
910            if (c == '[') {
911                foundBracket--;
912            }
913            if (!(foundBracket == 0)) {
914                sb.append(c);
915            }
916        }
917        return sb.toString();
918    }
919
920    /**
921     * Resolve calls in the attribute layout and returns the number of backwards calls
922     */
923    private void resolveCalls() {
924        int backwardsCalls = 0;
925        for (int i = 0; i < attributeLayoutElements.size(); i++) {
926            final AttributeLayoutElement element = attributeLayoutElements.get(i);
927            if (element instanceof Callable) {
928                final Callable callable = (Callable) element;
929                if (i == 0) {
930                    callable.setFirstCallable(true);
931                }
932                // Look for calls in the body
933                for (final LayoutElement layoutElement : callable.body) {
934                    // Set the callable for each call
935                    backwardsCalls += resolveCallsForElement(i, callable, layoutElement);
936                }
937            }
938        }
939        backwardsCallCount = backwardsCalls;
940    }
941
942    private int resolveCallsForElement(final int i, final Callable currentCallable, final LayoutElement layoutElement) {
943        int backwardsCalls = 0;
944        if (layoutElement instanceof Call) {
945            final Call call = (Call) layoutElement;
946            int index = call.callableIndex;
947            if (index == 0) { // Calls the parent callable
948                backwardsCalls++;
949                call.setCallable(currentCallable);
950            } else if (index > 0) { // Forwards call
951                for (int k = i + 1; k < attributeLayoutElements.size(); k++) {
952                    final AttributeLayoutElement el = attributeLayoutElements.get(k);
953                    if (el instanceof Callable) {
954                        index--;
955                        if (index == 0) {
956                            call.setCallable((Callable) el);
957                            break;
958                        }
959                    }
960                }
961            } else { // Backwards call
962                backwardsCalls++;
963                for (int k = i - 1; k >= 0; k--) {
964                    final AttributeLayoutElement el = attributeLayoutElements.get(k);
965                    if (el instanceof Callable) {
966                        index++;
967                        if (index == 0) {
968                            call.setCallable((Callable) el);
969                            break;
970                        }
971                    }
972                }
973            }
974        } else if (layoutElement instanceof Replication) {
975            final List<LayoutElement> children = ((Replication) layoutElement).layoutElements;
976            for (final LayoutElement child : children) {
977                backwardsCalls += resolveCallsForElement(i, currentCallable, child);
978            }
979        }
980        return backwardsCalls;
981    }
982
983    /**
984     * Once the attribute bands have been read the callables can be informed about the number of times each is subject to a backwards call. This method is used
985     * to set this information.
986     *
987     * @param backwardsCalls one int for each backwards callable, which contains the number of times that callable is subject to a backwards call.
988     * @throws IOException If an I/O error occurs.
989     */
990    public void setBackwardsCalls(final int[] backwardsCalls) throws IOException {
991        int index = 0;
992        parseLayout();
993        for (final AttributeLayoutElement element : attributeLayoutElements) {
994            if (element instanceof Callable && ((Callable) element).isBackwardsCallable()) {
995                ((Callable) element).addCount(backwardsCalls[index]);
996                index++;
997            }
998        }
999    }
1000
1001    @Override
1002    public void unpack() throws IOException, Pack200Exception {
1003
1004    }
1005
1006}