1/*
2 * Copyright (c) 1999, 2016, 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 */
25package com.sun.tools.javac.jvm;
26
27import java.io.IOException;
28import java.io.InputStream;
29import java.nio.file.Files;
30import java.nio.file.Path;
31
32import javax.tools.JavaFileObject;
33
34import static com.sun.tools.javac.jvm.ClassFile.*;
35
36
37/**
38 * Stripped down ClassReader, just sufficient to read module names from module-info.class files
39 * while analyzing the module path.
40 *
41 * <p>
42 * <b>This is NOT part of any supported API. If you write code that depends on this, you do so at
43 * your own risk. This code and its internal interfaces are subject to change or deletion without
44 * notice.</b>
45 */
46public class ModuleNameReader {
47    public static class BadClassFile extends Exception {
48        private static final long serialVersionUID = 0;
49        BadClassFile(String msg) {
50            super(msg);
51        }
52    }
53
54    private static final int INITIAL_BUFFER_SIZE = 0x0fff0;
55
56    /** The buffer containing the currently read class file.
57     */
58    private byte[] buf = new byte[INITIAL_BUFFER_SIZE];
59
60    /** The current input pointer.
61     */
62    private int bp;
63
64    /** For every constant pool entry, an index into buf where the
65     *  defining section of the entry is found.
66     */
67    private int[] poolIdx;
68
69    public ModuleNameReader() {
70    }
71
72    public String readModuleName(Path p) throws IOException, BadClassFile {
73        try (InputStream in = Files.newInputStream(p)) {
74            return readModuleName(in);
75        }
76    }
77
78    public String readModuleName(JavaFileObject jfo) throws IOException, BadClassFile {
79        try (InputStream in = jfo.openInputStream()) {
80            return readModuleName(in);
81        }
82    }
83
84    public String readModuleName(InputStream in) throws IOException, BadClassFile {
85        bp = 0;
86        buf = readInputStream(buf, in);
87
88        int magic = nextInt();
89        if (magic != JAVA_MAGIC)
90            throw new BadClassFile("illegal.start.of.class.file");
91
92        int minorVersion = nextChar();
93        int majorVersion = nextChar();
94        if (majorVersion < 53)
95            throw new BadClassFile("bad major version number for module: " + majorVersion);
96
97        indexPool();
98
99        int access_flags = nextChar();
100        if (access_flags != 0x8000)
101            throw new BadClassFile("invalid access flags for module: 0x" + Integer.toHexString(access_flags));
102
103        int this_class = nextChar();
104        // could, should, check this_class == CONSTANT_Class("mdoule-info")
105        checkZero(nextChar(), "super_class");
106        checkZero(nextChar(), "interface_count");
107        checkZero(nextChar(), "fields_count");
108        checkZero(nextChar(), "methods_count");
109        int attributes_count = nextChar();
110        for (int i = 0; i < attributes_count; i++) {
111            int attr_name = nextChar();
112            int attr_length = nextInt();
113            if (getUtf8Value(attr_name, false).equals("Module") && attr_length > 2) {
114                return getModuleName(nextChar());
115            } else {
116                // skip over unknown attributes
117                bp += attr_length;
118            }
119        }
120        throw new BadClassFile("no Module attribute");
121    }
122
123    void checkZero(int count, String name) throws BadClassFile {
124        if (count != 0)
125            throw new BadClassFile("invalid " + name + " for module: " + count);
126    }
127
128    /** Extract a character at position bp from buf.
129     */
130    char getChar(int bp) {
131        return
132            (char)(((buf[bp] & 0xFF) << 8) + (buf[bp+1] & 0xFF));
133    }
134
135    /** Read a character.
136     */
137    char nextChar() {
138        return (char)(((buf[bp++] & 0xFF) << 8) + (buf[bp++] & 0xFF));
139    }
140
141    /** Read an integer.
142     */
143    int nextInt() {
144        return
145            ((buf[bp++] & 0xFF) << 24) +
146            ((buf[bp++] & 0xFF) << 16) +
147            ((buf[bp++] & 0xFF) << 8) +
148            (buf[bp++] & 0xFF);
149    }
150
151    /** Index all constant pool entries, writing their start addresses into
152     *  poolIdx.
153     */
154    void indexPool() throws BadClassFile {
155        poolIdx = new int[nextChar()];
156        int i = 1;
157        while (i < poolIdx.length) {
158            poolIdx[i++] = bp;
159            byte tag = buf[bp++];
160            switch (tag) {
161            case CONSTANT_Utf8: case CONSTANT_Unicode: {
162                int len = nextChar();
163                bp = bp + len;
164                break;
165            }
166            case CONSTANT_Class:
167            case CONSTANT_String:
168            case CONSTANT_MethodType:
169            case CONSTANT_Module:
170            case CONSTANT_Package:
171                bp = bp + 2;
172                break;
173            case CONSTANT_MethodHandle:
174                bp = bp + 3;
175                break;
176            case CONSTANT_Fieldref:
177            case CONSTANT_Methodref:
178            case CONSTANT_InterfaceMethodref:
179            case CONSTANT_NameandType:
180            case CONSTANT_Integer:
181            case CONSTANT_Float:
182            case CONSTANT_InvokeDynamic:
183                bp = bp + 4;
184                break;
185            case CONSTANT_Long:
186            case CONSTANT_Double:
187                bp = bp + 8;
188                i++;
189                break;
190            default:
191                throw new BadClassFile("malformed constant pool");
192            }
193        }
194    }
195
196    String getUtf8Value(int index, boolean internalize) throws BadClassFile {
197        int utf8Index = poolIdx[index];
198        if (buf[utf8Index] == CONSTANT_Utf8) {
199            int len = getChar(utf8Index + 1);
200            int start = utf8Index + 3;
201            if (internalize) {
202                return new String(ClassFile.internalize(buf, start, len));
203            } else {
204                return new String(buf, start, len);
205            }
206        }
207        throw new BadClassFile("bad name at index " + index);
208    }
209
210    String getModuleName(int index) throws BadClassFile {
211        int infoIndex = poolIdx[index];
212        if (buf[infoIndex] == CONSTANT_Module) {
213            return getUtf8Value(getChar(infoIndex + 1), true);
214        } else {
215            throw new BadClassFile("bad module name at index " + index);
216        }
217    }
218
219    private static byte[] readInputStream(byte[] buf, InputStream s) throws IOException {
220        try {
221            buf = ensureCapacity(buf, s.available());
222            int r = s.read(buf);
223            int bp = 0;
224            while (r != -1) {
225                bp += r;
226                buf = ensureCapacity(buf, bp);
227                r = s.read(buf, bp, buf.length - bp);
228            }
229            return buf;
230        } finally {
231            try {
232                s.close();
233            } catch (IOException e) {
234                /* Ignore any errors, as this stream may have already
235                 * thrown a related exception which is the one that
236                 * should be reported.
237                 */
238            }
239        }
240    }
241
242    /*
243     * ensureCapacity will increase the buffer as needed, taking note that
244     * the new buffer will always be greater than the needed and never
245     * exactly equal to the needed size or bp. If equal then the read (above)
246     * will infinitely loop as buf.length - bp == 0.
247     */
248    private static byte[] ensureCapacity(byte[] buf, int needed) {
249        if (buf.length <= needed) {
250            byte[] old = buf;
251            buf = new byte[Integer.highestOneBit(needed) << 1];
252            System.arraycopy(old, 0, buf, 0, old.length);
253        }
254        return buf;
255    }
256}
257