285 lines
9.8 KiB
Java
285 lines
9.8 KiB
Java
/*
|
|
* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
package com.sun.tools.internal.jxc;
|
|
|
|
import com.sun.tools.internal.jxc.ap.Options;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
|
|
import javax.xml.bind.SchemaOutputResolver;
|
|
import javax.xml.parsers.ParserConfigurationException;
|
|
import javax.xml.parsers.SAXParserFactory;
|
|
import javax.xml.transform.Result;
|
|
import javax.xml.transform.stream.StreamResult;
|
|
import javax.xml.validation.ValidatorHandler;
|
|
|
|
import javax.annotation.processing.ProcessingEnvironment;
|
|
import javax.lang.model.element.TypeElement;
|
|
import com.sun.tools.internal.jxc.gen.config.Config;
|
|
import com.sun.tools.internal.jxc.gen.config.Schema;
|
|
import com.sun.tools.internal.xjc.SchemaCache;
|
|
import com.sun.tools.internal.xjc.api.Reference;
|
|
import com.sun.tools.internal.xjc.util.ForkContentHandler;
|
|
|
|
import com.sun.xml.internal.bind.v2.util.XmlFactory;
|
|
import org.xml.sax.ErrorHandler;
|
|
import org.xml.sax.InputSource;
|
|
import org.xml.sax.SAXException;
|
|
import org.xml.sax.XMLReader;
|
|
|
|
|
|
/**
|
|
* This reads the config files passed by the user to annotation processing
|
|
* and obtains a list of classes that need to be included
|
|
* for a particular config from the set of classes passed
|
|
* by the user to annotation processing.
|
|
*
|
|
* @author Bhakti Mehta (bhakti.mehta@sun.com)
|
|
*/
|
|
public final class ConfigReader {
|
|
|
|
/**
|
|
* The set of classes to be passed to XJC
|
|
*
|
|
*/
|
|
private final Set<Reference> classesToBeIncluded = new HashSet<Reference>();
|
|
|
|
|
|
/**
|
|
* The SchemaOutputResolver used to generate the schemas
|
|
*/
|
|
private final SchemaOutputResolver schemaOutputResolver;
|
|
|
|
private final ProcessingEnvironment env;
|
|
|
|
/**
|
|
*
|
|
* @param classes
|
|
* The set of classes passed to the AnnotationProcessor
|
|
* @param xmlFile
|
|
* The configuration file.
|
|
* @throws SAXException
|
|
* If this is thrown, the error has already been reported.
|
|
* @throws IOException
|
|
* If any IO errors occur.
|
|
*/
|
|
public ConfigReader(ProcessingEnvironment env, Collection<? extends TypeElement> classes, File xmlFile, ErrorHandler errorHandler) throws SAXException, IOException {
|
|
this.env = env;
|
|
Config config = parseAndGetConfig(xmlFile, errorHandler, env.getOptions().containsKey(Options.DISABLE_XML_SECURITY));
|
|
checkAllClasses(config,classes);
|
|
String path = xmlFile.getAbsolutePath();
|
|
String xmlPath = path.substring(0,path.lastIndexOf(File.separatorChar));
|
|
schemaOutputResolver = createSchemaOutputResolver(config,xmlPath);
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* This creates a regular expression
|
|
* for the user pattern , matches the input classes
|
|
* passed by the user and returns the final
|
|
* list of classes that need to be included for a config file
|
|
* after applying those patterns
|
|
*
|
|
*/
|
|
public Collection<Reference> getClassesToBeIncluded() {
|
|
return classesToBeIncluded;
|
|
}
|
|
|
|
private void checkAllClasses(Config config, Collection<? extends TypeElement> rootClasses) {
|
|
|
|
List<Pattern> includeRegexList = config.getClasses().getIncludes();
|
|
List<Pattern> excludeRegexList = config.getClasses().getExcludes();
|
|
|
|
OUTER:
|
|
for (TypeElement typeDecl : rootClasses) {
|
|
|
|
String qualifiedName = typeDecl.getQualifiedName().toString();
|
|
|
|
for (Pattern pattern : excludeRegexList) {
|
|
boolean match = checkPatternMatch(qualifiedName, pattern);
|
|
if (match)
|
|
continue OUTER; // excluded
|
|
}
|
|
|
|
for (Pattern pattern : includeRegexList) {
|
|
boolean match = checkPatternMatch(qualifiedName, pattern);
|
|
if (match) {
|
|
classesToBeIncluded.add(new Reference(typeDecl,env));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This returns the SchemaOutputResolver to generate the schemas
|
|
*/
|
|
public SchemaOutputResolver getSchemaOutputResolver(){
|
|
return schemaOutputResolver;
|
|
}
|
|
|
|
private SchemaOutputResolver createSchemaOutputResolver(Config config, String xmlpath) {
|
|
File baseDir = new File(xmlpath, config.getBaseDir().getPath());
|
|
SchemaOutputResolverImpl outResolver = new SchemaOutputResolverImpl (baseDir);
|
|
|
|
for( Schema schema : (List<Schema>)config.getSchema() ) {
|
|
String namespace = schema.getNamespace();
|
|
File location = schema.getLocation();
|
|
outResolver.addSchemaInfo(namespace,location);
|
|
}
|
|
return outResolver;
|
|
}
|
|
|
|
/**
|
|
* This will check if the qualified name matches the pattern
|
|
*
|
|
* @param qualifiedName
|
|
* The qualified name of the TypeDeclaration
|
|
* @param pattern
|
|
* The pattern obtained from the users input
|
|
*
|
|
*/
|
|
private boolean checkPatternMatch(String qualifiedName, Pattern pattern) {
|
|
Matcher matcher = pattern.matcher(qualifiedName);
|
|
return matcher.matches();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Lazily parsed schema for the binding file.
|
|
*/
|
|
private static SchemaCache configSchema = new SchemaCache(Config.class.getResource("config.xsd"));
|
|
|
|
|
|
/**
|
|
* Parses an xml config file and returns a Config object.
|
|
*
|
|
* @param xmlFile
|
|
* The xml config file which is passed by the user to annotation processing
|
|
* @return
|
|
* A non null Config object
|
|
*/
|
|
private Config parseAndGetConfig (File xmlFile, ErrorHandler errorHandler, boolean disableSecureProcessing) throws SAXException, IOException {
|
|
XMLReader reader;
|
|
try {
|
|
SAXParserFactory factory = XmlFactory.createParserFactory(disableSecureProcessing);
|
|
reader = factory.newSAXParser().getXMLReader();
|
|
} catch (ParserConfigurationException e) {
|
|
// in practice this will never happen
|
|
throw new Error(e);
|
|
}
|
|
NGCCRuntimeEx runtime = new NGCCRuntimeEx(errorHandler);
|
|
|
|
// set up validator
|
|
ValidatorHandler validator = configSchema.newValidator();
|
|
validator.setErrorHandler(errorHandler);
|
|
|
|
// the validator will receive events first, then the parser.
|
|
reader.setContentHandler(new ForkContentHandler(validator,runtime));
|
|
|
|
reader.setErrorHandler(errorHandler);
|
|
Config config = new Config(runtime);
|
|
runtime.setRootHandler(config);
|
|
reader.parse(new InputSource(xmlFile.toURL().toExternalForm()));
|
|
runtime.reset();
|
|
|
|
return config;
|
|
}
|
|
/**
|
|
* Controls where the JAXB RI puts the generates
|
|
* schema files.
|
|
* @author
|
|
* Bhakti Mehta (bhakti.mehta@sun.com)
|
|
*/
|
|
private static final class SchemaOutputResolverImpl extends SchemaOutputResolver{
|
|
|
|
/**
|
|
* Directory to which we put the rest of the files.
|
|
* Never be null.
|
|
*/
|
|
private final File baseDir;
|
|
|
|
/**
|
|
* Namespace URI to the location of the schema.
|
|
* This captures what the user specifies.
|
|
*/
|
|
private final Map<String,File> schemas = new HashMap<String,File>();
|
|
|
|
|
|
/**
|
|
* Decides where the schema file (of the given namespace URI)
|
|
* will be written, and return it as a {@link Result} object.
|
|
*
|
|
*/
|
|
public Result createOutput( String namespaceUri, String suggestedFileName ) {
|
|
|
|
// the user's preference takes a precedence
|
|
if(schemas.containsKey(namespaceUri)) {
|
|
File loc = schemas.get(namespaceUri);
|
|
if(loc==null) return null; // specifically not to generate a schema
|
|
|
|
// create directories if necessary. we've already checked that the baseDir
|
|
// exists, so this should be no surprise to users.
|
|
loc.getParentFile().mkdirs();
|
|
|
|
return new StreamResult(loc); // generate into a file the user specified.
|
|
}
|
|
|
|
// if the user didn't say anything about this namespace,
|
|
// generate it into the default directory with a default name.
|
|
|
|
File schemaFile = new File (baseDir, suggestedFileName);
|
|
// The systemId for the result will be schemaFile
|
|
return new StreamResult(schemaFile);
|
|
}
|
|
|
|
|
|
public SchemaOutputResolverImpl(File baseDir) {
|
|
assert baseDir!=null;
|
|
this.baseDir = baseDir;
|
|
}
|
|
|
|
public void addSchemaInfo(String namespaceUri, File location) {
|
|
if (namespaceUri == null )
|
|
//generate elements in no namespace
|
|
namespaceUri = "";
|
|
schemas.put(namespaceUri, location);
|
|
|
|
}
|
|
|
|
}
|
|
}
|