1 /*
2 * Copyright (c) 2018, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 package com.sun.tools.jextract;
25
26 import java.nio.file.Files;
27 import java.nio.file.Path;
28 import java.util.ArrayList;
29 import java.util.LinkedHashMap;
30 import java.util.List;
31 import java.util.Map;
32 import java.util.logging.Level;
33
34 public class HeaderResolver {
35
36 // The folder path mapping to package name
37 private final Map<Path, String> pkgMap = new LinkedHashMap<>();
38 // The header file parsed
39 private final Map<Path, HeaderFile> headerMap = new LinkedHashMap<>();
40 private final Log log;
41 private final Path builtinHeader;
42
43 public HeaderResolver(Context ctx) {
44 this.log = ctx.log;
45 usePackageForFolder(Context.getBuiltinHeadersDir(), "clang_support");
46 this.builtinHeader = Context.getBuiltinHeaderFile();
47 ctx.sources.stream()
48 .map(Path::getParent)
49 .forEach(p -> usePackageForFolder(p, ctx.options.targetPackage));
50 ctx.options.pkgMappings.forEach(this::usePackageForFolder);
51 }
52
53 public String headerInterfaceName(String filename) {
54 int ext = filename.lastIndexOf('.');
55 String name = ext != -1 ? filename.substring(0, ext) : filename;
56 return Utils.toClassName(name);
57 }
58
59 public String staticForwarderName(String filename) {
60 return headerInterfaceName(filename) + "_h";
61 }
62
63 private void usePackageForFolder(Path folder, String pkg) {
64 folder = folder.normalize().toAbsolutePath();
65 String existing = pkgMap.putIfAbsent(folder, pkg);
66 final String finalFolder = (null == folder) ? "all folders not configured" : folder.toString();
67 if (existing == null) {
68 log.print(Level.CONFIG, () -> "Package " + pkg + " is selected for " + finalFolder);
69 } else {
70 String pkgName = pkg.isEmpty() ? "<default-package>" : pkg;
71 log.print(Level.WARNING, () -> "Package " + existing + " had been selected for " + finalFolder + ", request to use " + pkgName + " is ignored.");
72 }
73 }
74
75 // start of header file resolution logic
76
77 static class HeaderPath {
78 final String pkg;
79 final String headerCls;
80 final String forwarderCls;
81
82 HeaderPath(String pkg, String headerCls, String forwarderCls) {
83 this.pkg = pkg;
84 this.headerCls = headerCls;
85 this.forwarderCls = forwarderCls;
86 }
87 }
88
89 /**
90 * Determine package and interface name given a path. If the path is
91 * a folder, then only package name is determined. The package name is
92 * determined with the longest path matching the setup. If the path is not
93 * setup for any package, the default package name is returned.
94 *
95 * @param origin The source path
96 * @return The HeaderPath
97 * @see Context::usePackageForFolder(Path, String)
98 */
99 private HeaderPath resolveHeaderPath(Path origin) {
100 // normalize to absolute path
101 origin = origin.normalize().toAbsolutePath();
102 if (Files.isDirectory(origin)) {
103 throw new IllegalStateException("Not an header file: " + origin);
104 }
105 String filename = origin.getFileName().toString();
106 origin = origin.getParent();
107 Path path = origin;
108
109 // search the map for a hit with longest path
110 while (path != null && !pkgMap.containsKey(path)) {
111 path = path.getParent();
112 }
113
114 String pkg;
115 if (path != null) {
116 pkg = pkgMap.get(path);
117 if (path.getNameCount() != origin.getNameCount()) {
118 String sep = pkg.isEmpty() ? "" : ".";
119 for (int i = path.getNameCount() ; i < origin.getNameCount() ; i++) {
120 pkg += sep + Utils.toJavaIdentifier(origin.getName(i).toString());
121 sep = ".";
122 }
123 usePackageForFolder(origin, pkg);
124 }
125 } else {
126 //infer a package name from path
127 List<String> parts = new ArrayList<>();
128 for (Path p : origin) {
129 parts.add(Utils.toJavaIdentifier(p.toString()));
130 }
131 pkg = String.join(".", parts);
132 usePackageForFolder(origin, pkg);
133 }
134
135 return new HeaderPath(pkg, headerInterfaceName(filename), staticForwarderName(filename));
136 }
137
138 private HeaderFile getHeaderFile(Path header) {
139 if (!Files.isRegularFile(header)) {
140 log.print(Level.WARNING, () -> "Not a regular file: " + header.toString());
141 throw new IllegalArgumentException(header.toString());
142 }
143
144 final HeaderPath hp = resolveHeaderPath(header);
145 return new HeaderFile(this, header, hp.pkg, hp.headerCls, hp.forwarderCls);
146 }
147
148 public HeaderFile headerFor(Path path) {
149 if (path == null) {
150 path = builtinHeader;
151 }
152
153 return headerMap.computeIfAbsent(path.normalize().toAbsolutePath(), this::getHeaderFile);
154 }
155 }