| /* |
| * Copyright (c) 1997, 2013, 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.xjc; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.OutputStreamWriter; |
| import java.io.PrintStream; |
| import java.util.Iterator; |
| |
| import com.sun.codemodel.internal.CodeWriter; |
| import com.sun.codemodel.internal.JCodeModel; |
| import com.sun.codemodel.internal.writer.ZipCodeWriter; |
| import com.sun.istack.internal.NotNull; |
| import com.sun.istack.internal.Nullable; |
| import com.sun.istack.internal.tools.DefaultAuthenticator; |
| import com.sun.tools.internal.xjc.generator.bean.BeanGenerator; |
| import com.sun.tools.internal.xjc.model.Model; |
| import com.sun.tools.internal.xjc.outline.Outline; |
| import com.sun.tools.internal.xjc.reader.gbind.Expression; |
| import com.sun.tools.internal.xjc.reader.gbind.Graph; |
| import com.sun.tools.internal.xjc.reader.internalizer.DOMForest; |
| import com.sun.tools.internal.xjc.reader.xmlschema.ExpressionBuilder; |
| import com.sun.tools.internal.xjc.reader.xmlschema.parser.XMLSchemaInternalizationLogic; |
| import com.sun.tools.internal.xjc.util.ErrorReceiverFilter; |
| import com.sun.tools.internal.xjc.util.NullStream; |
| import com.sun.tools.internal.xjc.util.Util; |
| import com.sun.tools.internal.xjc.writer.SignatureWriter; |
| import com.sun.xml.internal.xsom.XSComplexType; |
| import com.sun.xml.internal.xsom.XSParticle; |
| import com.sun.xml.internal.xsom.XSSchemaSet; |
| |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXParseException; |
| |
| |
| /** |
| * Command Line Interface of XJC. |
| */ |
| public class Driver { |
| |
| public static void main(final String[] args) throws Exception { |
| // use the platform default proxy if available. |
| // see sun.net.spi.DefaultProxySelector for details. |
| try { |
| System.setProperty("java.net.useSystemProxies","true"); |
| } catch (SecurityException e) { |
| // failing to set this property isn't fatal |
| } |
| |
| if( Util.getSystemProperty(Driver.class,"noThreadSwap")!=null ) |
| _main(args); // for the ease of debugging |
| |
| // run all the work in another thread so that the -Xss option |
| // will take effect when compiling a large schema. See |
| // http://developer.java.sun.com/developer/bugParade/bugs/4362291.html |
| final Throwable[] ex = new Throwable[1]; |
| |
| Thread th = new Thread() { |
| @Override |
| public void run() { |
| try { |
| _main(args); |
| } catch( Throwable e ) { |
| ex[0]=e; |
| } |
| } |
| }; |
| th.start(); |
| th.join(); |
| |
| if(ex[0]!=null) { |
| // re-throw |
| if( ex[0] instanceof Exception ) |
| throw (Exception)ex[0]; |
| else |
| throw (Error)ex[0]; |
| } |
| } |
| |
| private static void _main( String[] args ) throws Exception { |
| try { |
| System.exit(run( args, System.out, System.out )); |
| } catch (BadCommandLineException e) { |
| // there was an error in the command line. |
| // print usage and abort. |
| if(e.getMessage()!=null) { |
| System.out.println(e.getMessage()); |
| System.out.println(); |
| } |
| |
| usage(e.getOptions(),false); |
| System.exit(-1); |
| } |
| } |
| |
| |
| |
| /** |
| * Performs schema compilation and prints the status/error into the |
| * specified PrintStream. |
| * |
| * <p> |
| * This method could be used to trigger XJC from other tools, |
| * such as Ant or IDE. |
| * |
| * @param args |
| * specified command line parameters. If there is an error |
| * in the parameters, {@link BadCommandLineException} will |
| * be thrown. |
| * @param status |
| * Status report of the compilation will be sent to this object. |
| * Useful to update users so that they will know something is happening. |
| * Only ignorable messages should be sent to this stream. |
| * |
| * This parameter can be null to suppress messages. |
| * |
| * @param out |
| * Various non-ignorable output (error messages, etc) |
| * will go to this stream. |
| * |
| * @return |
| * If the compiler runs successfully, this method returns 0. |
| * All non-zero values indicate an error. The error message |
| * will be sent to the specified PrintStream. |
| */ |
| public static int run(String[] args, final PrintStream status, final PrintStream out) |
| throws Exception { |
| |
| class Listener extends XJCListener { |
| ConsoleErrorReporter cer = new ConsoleErrorReporter(out==null?new PrintStream(new NullStream()):out); |
| |
| @Override |
| public void generatedFile(String fileName, int count, int total) { |
| message(fileName); |
| } |
| @Override |
| public void message(String msg) { |
| if(status!=null) |
| status.println(msg); |
| } |
| |
| public void error(SAXParseException exception) { |
| cer.error(exception); |
| } |
| |
| public void fatalError(SAXParseException exception) { |
| cer.fatalError(exception); |
| } |
| |
| public void warning(SAXParseException exception) { |
| cer.warning(exception); |
| } |
| |
| public void info(SAXParseException exception) { |
| cer.info(exception); |
| } |
| } |
| |
| return run(args,new Listener()); |
| } |
| |
| /** |
| * Performs schema compilation and prints the status/error into the |
| * specified PrintStream. |
| * |
| * <p> |
| * This method could be used to trigger XJC from other tools, |
| * such as Ant or IDE. |
| * |
| * @param args |
| * specified command line parameters. If there is an error |
| * in the parameters, {@link BadCommandLineException} will |
| * be thrown. |
| * @param listener |
| * Receives messages from XJC reporting progress/errors. |
| * |
| * @return |
| * If the compiler runs successfully, this method returns 0. |
| * All non-zero values indicate an error. The error message |
| * will be sent to the specified PrintStream. |
| */ |
| public static int run(String[] args, @NotNull final XJCListener listener) throws BadCommandLineException { |
| |
| // recognize those special options before we start parsing options. |
| for (String arg : args) { |
| if (arg.equals("-version")) { |
| listener.message(Messages.format(Messages.VERSION)); |
| return -1; |
| } |
| if (arg.equals("-fullversion")) { |
| listener.message(Messages.format(Messages.FULLVERSION)); |
| return -1; |
| } |
| } |
| |
| final OptionsEx opt = new OptionsEx(); |
| opt.setSchemaLanguage(Language.XMLSCHEMA); // disable auto-guessing |
| try { |
| opt.parseArguments(args); |
| } catch (WeAreDone e) { |
| if (opt.proxyAuth != null) { |
| DefaultAuthenticator.reset(); |
| } |
| return -1; |
| } catch(BadCommandLineException e) { |
| if (opt.proxyAuth != null) { |
| DefaultAuthenticator.reset(); |
| } |
| e.initOptions(opt); |
| throw e; |
| } |
| |
| // display a warning if the user specified the default package |
| // this should work, but is generally a bad idea |
| if(opt.defaultPackage != null && opt.defaultPackage.length()==0) { |
| listener.message(Messages.format(Messages.WARNING_MSG, Messages.format(Messages.DEFAULT_PACKAGE_WARNING))); |
| } |
| |
| |
| // set up the context class loader so that the user-specified classes |
| // can be loaded from there |
| final ClassLoader contextClassLoader = SecureLoader.getContextClassLoader(); |
| SecureLoader.setContextClassLoader(opt.getUserClassLoader(contextClassLoader)); |
| |
| // parse a grammar file |
| //----------------------------------------- |
| try { |
| if( !opt.quiet ) { |
| listener.message(Messages.format(Messages.PARSING_SCHEMA)); |
| } |
| |
| final boolean[] hadWarning = new boolean[1]; |
| |
| ErrorReceiver receiver = new ErrorReceiverFilter(listener) { |
| @Override |
| public void info(SAXParseException exception) { |
| if(opt.verbose) |
| super.info(exception); |
| } |
| @Override |
| public void warning(SAXParseException exception) { |
| hadWarning[0] = true; |
| if(!opt.quiet) |
| super.warning(exception); |
| } |
| @Override |
| public void pollAbort() throws AbortException { |
| if(listener.isCanceled()) |
| throw new AbortException(); |
| } |
| }; |
| |
| if( opt.mode==Mode.FOREST ) { |
| // dump DOM forest and quit |
| ModelLoader loader = new ModelLoader( opt, new JCodeModel(), receiver ); |
| try { |
| DOMForest forest = loader.buildDOMForest(new XMLSchemaInternalizationLogic()); |
| forest.dump(System.out); |
| return 0; |
| } catch (SAXException e) { |
| // the error should have already been reported |
| } catch (IOException e) { |
| receiver.error(e); |
| } |
| |
| return -1; |
| } |
| |
| if( opt.mode==Mode.GBIND ) { |
| try { |
| XSSchemaSet xss = new ModelLoader(opt, new JCodeModel(), receiver).loadXMLSchema(); |
| Iterator<XSComplexType> it = xss.iterateComplexTypes(); |
| while (it.hasNext()) { |
| XSComplexType ct = it.next(); |
| XSParticle p = ct.getContentType().asParticle(); |
| if(p==null) continue; |
| |
| Expression tree = ExpressionBuilder.createTree(p); |
| System.out.println("Graph for "+ct.getName()); |
| System.out.println(tree.toString()); |
| Graph g = new Graph(tree); |
| System.out.println(g.toString()); |
| System.out.println(); |
| } |
| return 0; |
| } catch (SAXException e) { |
| // the error should have already been reported |
| } |
| return -1; |
| } |
| |
| Model model = ModelLoader.load( opt, new JCodeModel(), receiver ); |
| |
| if (model == null) { |
| listener.message(Messages.format(Messages.PARSE_FAILED)); |
| return -1; |
| } |
| |
| if( !opt.quiet ) { |
| listener.message(Messages.format(Messages.COMPILING_SCHEMA)); |
| } |
| |
| switch (opt.mode) { |
| case SIGNATURE : |
| try { |
| SignatureWriter.write( |
| BeanGenerator.generate(model,receiver), |
| new OutputStreamWriter(System.out)); |
| return 0; |
| } catch (IOException e) { |
| receiver.error(e); |
| return -1; |
| } |
| |
| case CODE : |
| case DRYRUN : |
| case ZIP : |
| { |
| // generate actual code |
| receiver.debug("generating code"); |
| {// don't want to hold outline in memory for too long. |
| Outline outline = model.generateCode(opt,receiver); |
| if(outline==null) { |
| listener.message( |
| Messages.format(Messages.FAILED_TO_GENERATE_CODE)); |
| return -1; |
| } |
| |
| listener.compiled(outline); |
| } |
| |
| if( opt.mode == Mode.DRYRUN ) |
| break; // enough |
| |
| // then print them out |
| try { |
| CodeWriter cw; |
| if( opt.mode==Mode.ZIP ) { |
| OutputStream os; |
| if(opt.targetDir.getPath().equals(".")) |
| os = System.out; |
| else |
| os = new FileOutputStream(opt.targetDir); |
| |
| cw = opt.createCodeWriter(new ZipCodeWriter(os)); |
| } else |
| cw = opt.createCodeWriter(); |
| |
| if( !opt.quiet ) { |
| cw = new ProgressCodeWriter(cw,listener, model.codeModel.countArtifacts()); |
| } |
| model.codeModel.build(cw); |
| } catch (IOException e) { |
| receiver.error(e); |
| return -1; |
| } |
| |
| break; |
| } |
| default : |
| assert false; |
| } |
| |
| if(opt.debugMode) { |
| try { |
| new FileOutputStream(new File(opt.targetDir,hadWarning[0]?"hadWarning":"noWarning")).close(); |
| } catch (IOException e) { |
| receiver.error(e); |
| return -1; |
| } |
| } |
| |
| return 0; |
| } catch( StackOverflowError e ) { |
| if(opt.verbose) |
| // in the debug mode, propagate the error so that |
| // the full stack trace will be dumped to the screen. |
| throw e; |
| else { |
| // otherwise just print a suggested workaround and |
| // quit without filling the user's screen |
| listener.message(Messages.format(Messages.STACK_OVERFLOW)); |
| return -1; |
| } |
| } finally { |
| if (opt.proxyAuth != null) { |
| DefaultAuthenticator.reset(); |
| } |
| } |
| } |
| |
| public static String getBuildID() { |
| return Messages.format(Messages.BUILD_ID); |
| } |
| |
| |
| /** |
| * Operation mode. |
| */ |
| private static enum Mode { |
| // normal mode. compile the code |
| CODE, |
| |
| // dump the signature of the generated code |
| SIGNATURE, |
| |
| // dump DOMForest |
| FOREST, |
| |
| // same as CODE but don't produce any Java source code |
| DRYRUN, |
| |
| // same as CODE but pack all the outputs into a zip and dumps to stdout |
| ZIP, |
| |
| // testing a new binding mode |
| GBIND |
| } |
| |
| |
| /** |
| * Command-line arguments processor. |
| * |
| * <p> |
| * This class contains options that only make sense |
| * for the command line interface. |
| */ |
| static class OptionsEx extends Options |
| { |
| /** Operation mode. */ |
| protected Mode mode = Mode.CODE; |
| |
| /** A switch that determines the behavior in the BGM mode. */ |
| public boolean noNS = false; |
| |
| /** Parse XJC-specific options. */ |
| @Override |
| public int parseArgument(String[] args, int i) throws BadCommandLineException { |
| if (args[i].equals("-noNS")) { |
| noNS = true; |
| return 1; |
| } |
| if (args[i].equals("-mode")) { |
| i++; |
| if (i == args.length) |
| throw new BadCommandLineException( |
| Messages.format(Messages.MISSING_MODE_OPERAND)); |
| |
| String mstr = args[i].toLowerCase(); |
| |
| for( Mode m : Mode.values() ) { |
| if(m.name().toLowerCase().startsWith(mstr) && mstr.length()>2) { |
| mode = m; |
| return 2; |
| } |
| } |
| |
| throw new BadCommandLineException( |
| Messages.format(Messages.UNRECOGNIZED_MODE, args[i])); |
| } |
| if (args[i].equals("-help")) { |
| usage(this,false); |
| throw new WeAreDone(); |
| } |
| if (args[i].equals("-private")) { |
| usage(this,true); |
| throw new WeAreDone(); |
| } |
| |
| return super.parseArgument(args, i); |
| } |
| } |
| |
| /** |
| * Used to signal that we've finished processing. |
| */ |
| private static final class WeAreDone extends BadCommandLineException {} |
| |
| |
| /** |
| * Prints the usage screen and exits the process. |
| * |
| * @param opts |
| * If the parsing of options have started, set a partly populated |
| * {@link Options} object. |
| */ |
| public static void usage( @Nullable Options opts, boolean privateUsage ) { |
| System.out.println(Messages.format(Messages.DRIVER_PUBLIC_USAGE)); |
| if (privateUsage) { |
| System.out.println(Messages.format(Messages.DRIVER_PRIVATE_USAGE)); |
| } |
| |
| if( opts!=null && !opts.getAllPlugins().isEmpty()) { |
| System.out.println(Messages.format(Messages.ADDON_USAGE)); |
| for (Plugin p : opts.getAllPlugins()) { |
| System.out.println(p.getUsage()); |
| } |
| } |
| } |
| } |
