1 /*
2 * Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.tools.javah;
27
28 import java.io.ByteArrayOutputStream;
29 import java.io.FileNotFoundException;
30 import java.io.IOException;
31 import java.io.InputStream;
32 import java.io.OutputStream;
33 import java.io.OutputStreamWriter;
34 import java.io.PrintWriter;
35 import java.io.UnsupportedEncodingException;
36 import java.nio.file.NoSuchFileException;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.List;
40 import java.util.Set;
41 import java.util.Stack;
42
43 import javax.annotation.processing.ProcessingEnvironment;
44 import javax.lang.model.element.ExecutableElement;
45 import javax.lang.model.element.Modifier;
46 import javax.lang.model.element.TypeElement;
47 import javax.lang.model.element.VariableElement;
48 import javax.lang.model.util.ElementFilter;
49 import javax.lang.model.util.Elements;
50 import javax.lang.model.util.Types;
51 import javax.tools.FileObject;
52 import javax.tools.JavaFileManager;
53 import javax.tools.JavaFileObject;
54 import javax.tools.StandardLocation;
55
56 /**
57 * An abstraction for generating support files required by native methods.
58 * Subclasses are for specific native interfaces. At the time of its
59 * original writing, this interface is rich enough to support JNI and the
60 * old 1.0-style native method interface.
61 *
62 * <p><b>This is NOT part of any supported API.
63 * If you write code that depends on this, you do so at your own
64 * risk. This code and its internal interfaces are subject to change
65 * or deletion without notice.</b></p>
66 *
67 * @author Sucheta Dambalkar(Revised)
68 */
69 public abstract class Gen {
70 protected String lineSep = System.getProperty("line.separator");
71
72 protected ProcessingEnvironment processingEnvironment;
73 protected Types types;
74 protected Elements elems;
75 protected Mangle mangler;
76 protected Util util;
77
78 protected Gen(Util util) {
79 this.util = util;
80 }
81
82 /*
83 * List of classes for which we must generate output.
84 */
85 protected Set<TypeElement> classes;
86 static private final boolean isWindows =
87 System.getProperty("os.name").startsWith("Windows");
88
89
90 /**
91 * Override this abstract method, generating content for the named
92 * class into the outputstream.
93 */
94 protected abstract void write(OutputStream o, TypeElement clazz) throws Util.Exit;
95
96 /**
97 * Override this method to provide a list of #include statements
98 * required by the native interface.
99 */
100 protected abstract String getIncludes();
101
102 /*
103 * Output location.
104 */
105 protected JavaFileManager fileManager;
106 protected JavaFileObject outFile;
107
108 public void setFileManager(JavaFileManager fm) {
109 fileManager = fm;
110 }
111
112 public void setOutFile(JavaFileObject outFile) {
113 this.outFile = outFile;
114 }
115
116
117 public void setClasses(Set<TypeElement> classes) {
118 this.classes = classes;
119 }
120
121 void setProcessingEnvironment(ProcessingEnvironment pEnv) {
122 processingEnvironment = pEnv;
123 elems = pEnv.getElementUtils();
124 types = pEnv.getTypeUtils();
125 mangler = new Mangle(elems, types);
126 }
127
128 /*
129 * Smartness with generated files.
130 */
131 protected boolean force = false;
132
133 public void setForce(boolean state) {
134 force = state;
135 }
136
137 /**
138 * We explicitly need to write ASCII files because that is what C
139 * compilers understand.
140 */
141 protected PrintWriter wrapWriter(OutputStream o) throws Util.Exit {
142 try {
143 return new PrintWriter(new OutputStreamWriter(o, "ISO8859_1"), true);
144 } catch (UnsupportedEncodingException use) {
145 util.bug("encoding.iso8859_1.not.found");
146 return null; /* dead code */
147 }
148 }
149
150 /**
151 * After initializing state of an instance, use this method to start
152 * processing.
153 *
154 * Buffer size chosen as an approximation from a single sampling of:
155 * expr `du -sk` / `ls *.h | wc -l`
156 */
157 public void run() throws IOException, ClassNotFoundException, Util.Exit {
158 int i = 0;
159 if (outFile != null) {
160 /* Everything goes to one big file... */
161 ByteArrayOutputStream bout = new ByteArrayOutputStream(8192);
162 writeFileTop(bout); /* only once */
163
164 for (TypeElement t: classes) {
165 write(bout, t);
166 }
167
168 writeIfChanged(bout.toByteArray(), outFile);
169 } else {
170 /* Each class goes to its own file... */
171 for (TypeElement t: classes) {
172 ByteArrayOutputStream bout = new ByteArrayOutputStream(8192);
173 writeFileTop(bout);
174 write(bout, t);
175 writeIfChanged(bout.toByteArray(), getFileObject(t.getQualifiedName()));
176 }
177 }
178 }
179
180 /*
181 * Write the contents of byte[] b to a file named file. Writing
182 * is done if either the file doesn't exist or if the contents are
183 * different.
184 */
185 private void writeIfChanged(byte[] b, FileObject file) throws IOException {
186 boolean mustWrite = false;
187 String event = "[No need to update file ";
188
189 if (force) {
190 mustWrite = true;
191 event = "[Forcefully writing file ";
192 } else {
193 InputStream in;
194 byte[] a;
195 try {
196 // regrettably, there's no API to get the length in bytes
197 // for a FileObject, so we can't short-circuit reading the
198 // file here
199 in = file.openInputStream();
200 a = readBytes(in);
201 if (!Arrays.equals(a, b)) {
202 mustWrite = true;
203 event = "[Overwriting file ";
204
205 }
206 } catch (FileNotFoundException | NoSuchFileException e) {
207 mustWrite = true;
208 event = "[Creating file ";
209 }
210 }
211
212 if (util.verbose)
213 util.log(event + file + "]");
214
215 if (mustWrite) {
216 OutputStream out = file.openOutputStream();
217 out.write(b); /* No buffering, just one big write! */
218 out.close();
219 }
220 }
221
222 protected byte[] readBytes(InputStream in) throws IOException {
223 try {
224 byte[] array = new byte[in.available() + 1];
225 int offset = 0;
226 int n;
227 while ((n = in.read(array, offset, array.length - offset)) != -1) {
228 offset += n;
229 if (offset == array.length)
230 array = Arrays.copyOf(array, array.length * 2);
231 }
232
233 return Arrays.copyOf(array, offset);
234 } finally {
235 in.close();
236 }
237 }
238
239 protected String defineForStatic(TypeElement c, VariableElement f)
240 throws Util.Exit {
241 CharSequence cnamedoc = c.getQualifiedName();
242 CharSequence fnamedoc = f.getSimpleName();
243
244 String cname = mangler.mangle(cnamedoc, Mangle.Type.CLASS);
245 String fname = mangler.mangle(fnamedoc, Mangle.Type.FIELDSTUB);
246
247 if (!f.getModifiers().contains(Modifier.STATIC))
248 util.bug("tried.to.define.non.static");
249
250 if (f.getModifiers().contains(Modifier.FINAL)) {
251 Object value = null;
252
253 value = f.getConstantValue();
254
255 if (value != null) { /* so it is a ConstantExpression */
256 String constString = null;
257 if ((value instanceof Integer)
258 || (value instanceof Byte)
259 || (value instanceof Short)) {
260 /* covers byte, short, int */
261 constString = value.toString() + "L";
262 } else if (value instanceof Boolean) {
263 constString = ((Boolean) value) ? "1L" : "0L";
264 } else if (value instanceof Character) {
265 Character ch = (Character) value;
266 constString = String.valueOf(((int) ch) & 0xffff) + "L";
267 } else if (value instanceof Long) {
268 // Visual C++ supports the i64 suffix, not LL.
269 if (isWindows)
270 constString = value.toString() + "i64";
271 else
272 constString = value.toString() + "LL";
273 } else if (value instanceof Float) {
274 /* bug for bug */
275 float fv = ((Float)value).floatValue();
276 if (Float.isInfinite(fv))
277 constString = ((fv < 0) ? "-" : "") + "Inff";
278 else
279 constString = value.toString() + "f";
280 } else if (value instanceof Double) {
281 /* bug for bug */
282 double d = ((Double)value).doubleValue();
283 if (Double.isInfinite(d))
284 constString = ((d < 0) ? "-" : "") + "InfD";
285 else
286 constString = value.toString();
287 }
288 if (constString != null) {
289 StringBuilder s = new StringBuilder("#undef ");
290 s.append(cname); s.append("_"); s.append(fname); s.append(lineSep);
291 s.append("#define "); s.append(cname); s.append("_");
292 s.append(fname); s.append(" "); s.append(constString);
293 return s.toString();
294 }
295
296 }
297 }
298 return null;
299 }
300
301 /*
302 * Deal with the C pre-processor.
303 */
304 protected String cppGuardBegin() {
305 return "#ifdef __cplusplus" + lineSep + "extern \"C\" {" + lineSep + "#endif";
306 }
307
308 protected String cppGuardEnd() {
309 return "#ifdef __cplusplus" + lineSep + "}" + lineSep + "#endif";
310 }
311
312 protected String guardBegin(String cname) {
313 return "/* Header for class " + cname + " */" + lineSep + lineSep +
314 "#ifndef _Included_" + cname + lineSep +
315 "#define _Included_" + cname;
316 }
317
318 protected String guardEnd(String cname) {
319 return "#endif";
320 }
321
322 /*
323 * File name and file preamble related operations.
324 */
325 protected void writeFileTop(OutputStream o) throws Util.Exit {
326 PrintWriter pw = wrapWriter(o);
327 pw.println("/* DO NOT EDIT THIS FILE - it is machine generated */" + lineSep +
328 getIncludes());
329 }
330
331 protected String baseFileName(CharSequence className) {
332 return mangler.mangle(className, Mangle.Type.CLASS);
333 }
334
335 protected FileObject getFileObject(CharSequence className) throws IOException {
336 String name = baseFileName(className) + getFileSuffix();
337 return fileManager.getFileForOutput(StandardLocation.SOURCE_OUTPUT, "", name, null);
338 }
339
340 protected String getFileSuffix() {
341 return ".h";
342 }
343
344 /**
345 * Including super classes' fields.
346 */
347
348 List<VariableElement> getAllFields(TypeElement subclazz) {
349 List<VariableElement> fields = new ArrayList<>();
350 TypeElement cd = null;
351 Stack<TypeElement> s = new Stack<>();
352
353 cd = subclazz;
354 while (true) {
355 s.push(cd);
356 TypeElement c = (TypeElement) (types.asElement(cd.getSuperclass()));
357 if (c == null)
358 break;
359 cd = c;
360 }
361
362 while (!s.empty()) {
363 cd = s.pop();
364 fields.addAll(ElementFilter.fieldsIn(cd.getEnclosedElements()));
365 }
366
367 return fields;
368 }
369
370 // c.f. MethodDoc.signature
371 String signature(ExecutableElement e) {
372 StringBuilder sb = new StringBuilder("(");
373 String sep = "";
374 for (VariableElement p: e.getParameters()) {
375 sb.append(sep);
376 sb.append(types.erasure(p.asType()).toString());
377 sep = ",";
378 }
379 sb.append(")");
380 return sb.toString();
381 }
382 }
383