compiler/src/main/java/org/apache/etch/compiler/EtchMain.java - etch - Git at Google

 /* $Id$
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements. See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership. The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License. You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package org.apache.etch.compiler;

 import java.io.File;
 import java.util.StringTokenizer;

 import org.apache.etch.util.cmd.CommandParser;
 import org.apache.etch.util.cmd.Option;
 import org.apache.etch.util.cmd.Parameter;
 import org.apache.etch.util.cmd.Program;


 /**
  * The main command line interface for the etch compiler.
  */
 public class EtchMain extends Program
 {
 	/**
      * @param args
      * @throws Exception
      */
     public static void main( String[] args ) throws Exception
     {
     	new EtchMain().doMain( args );
     }

     /**
      * Runs the main program, parsing command line arguments and performing
      * the action.
      * @param args
      * @throws Exception
      */
     public void doMain( String[] args ) throws Exception
     {
     	try
     	{
     		main( this, args );
     	}
         catch ( Throwable e )
         {
         	e.printStackTrace();
             exit( 3, toString(), e.toString(), true );
             return;
         }
     }

     /**
      * Constructs the etch parser / compiler driver.
      */
     public EtchMain()
     {
         // nothing to do.
     }

     @Override
     public String toString()
     {
         return "etch";
     }

     @Override
     protected void defineOptionsAndParameters( CommandParser cp )
         throws Exception
     {
         cp.defineFileOption( "-d|--output-dir", "outputDir", "setOutputDir",
             "output directory for compiler generated files",
             Option.SINGLETON, null, null );

         cp.defineFileOption( "-m|--mixin-output-dir", "outputDir", "setMixinOutputDir",
             "output directory for compiler generated files for mixins",
             Option.SINGLETON, null, null );

         cp.defineFileOption( "-t|--template-output-dir", "outputDir", "setTemplateOutputDir",
             "output directory for compiler generated user editable template files",
             Option.SINGLETON, null, null );

         cp.defineStringOption( "-b|--binding", "binding", "setBinding",
             "specifies a target language binding to generate",
             Option.REQUIRED|Option.SINGLETON, null, null );

         cp.defineStringOption( "-w|--what", "what", "addWhat",
             "specifies what files to generate (depends upon binding, try -w help for more info; separate with '"+CmdLineOptions.WHAT_DELIMETER+"')",
             Option.NONE, null, null );

         cp.defineNullOption( "-g|--ignore-global-words-list", "ignoreGlobalWordsList",
             "ignore the global reserved words list",
             Option.SINGLETON );

         cp.defineNullOption( "-l|--ignore-local-words-list", "ignoreLocalWordsList",
             "ignore the local (binding-specific) reserved words list",
             Option.SINGLETON );

         cp.defineFileOption( "-W|--user-words-list", "wordList", "setUserWordsList",
             "file name of a user-specified reserved words list",
             Option.SINGLETON, null, null );

         cp.defineStringOption( "-I|--include-path", "includePath", "addIncludePath",
             "adds search directories for included or mixed in etch files (separate elements with system path separator '"+File.pathSeparator+"')",
             Option.NONE, null, null );

         cp.defineNullOption( "-i|--ignore-include-path", "ignoreIncludePath",
             "ignore the "+CmdLineOptions.ETCH_INCLUDE_PATH+" environment variable",
             Option.SINGLETON );

         cp.defineNullOption( "-n|--no-mixin-artifacts", "noMixinArtifacts",
             "mixin artifacts should not be generated",
             Option.SINGLETON );

         cp.defineNullOption( "-q|--quiet", "quiet",
             "only report problems",
             Option.SINGLETON );

         cp.defineNullOption( "-v|--version", "doVersion",
             "show the version and exit",
             Option.SINGLETON );

         cp.defineNullOption( "-f|--no-flatten-packages", "noFlattenPackages",
             "namespace directory tree should not be flattened",
             Option.SINGLETON );

         cp.defineNullOption( "--testing", "setTesting",
         	"",
         	Option.HIDDEN );

         cp.defineFileParameter( "sourceFile", "setSourceFile",
             "etch source file to compile", true, false, null );
     }

     private final CmdLineOptions clo = new CmdLineOptions();

     /**
      * Sets the output directory of compiler generated files.
      * @param cp
      * @param option
      * @param token
      * @param value the output directory
      */
     public void setOutputDir( CommandParser cp, Option option, String token,
         File value )
     {
         clo.outputDir = value;
     }

     /**
      * Sets the output directory for user editable template files.
      * @param cp
      * @param option
      * @param token
      * @param value the template output directory
      */
     public void setTemplateOutputDir( CommandParser cp, Option option, String token,
         File value )
     {
     	clo.templateOutputDir = value;
     }

     /**
      * Sets the binding.
      * @param cp
      * @param option
      * @param token
      * @param value the binding
      */
     public void setBinding( CommandParser cp, Option option, String token,
         String value )
     {
     	clo.binding = value;
     }

     /**
      * Adds to the set of what needs to be generated.
      * @param cp
      * @param option
      * @param token
      * @param value the list of what needs to be generated.
      */
     public void addWhat( CommandParser cp, Option option, String token,
         String value )
     {
         StringTokenizer st = new StringTokenizer( value, CmdLineOptions.WHAT_DELIMETER );
         while (st.hasMoreElements())
         	clo.what.add(st.nextToken().toUpperCase());
     }

     /**
      * Sets the ignore the globally reserved words list flag.
      * @param cp
      * @param option
      * @param token
      */
     public void ignoreGlobalWordsList(CommandParser cp, Option option, String token)
     {
     	clo.ignoreGlobalWordsList = true;
     }

     /**
      * Sets the ignore the locally reserved words list flag.
      * @param cp
      * @param option
      * @param token
      */
     public void ignoreLocalWordsList(CommandParser cp, Option option, String token)
     {
     	clo.ignoreLocalWordsList = true;
     }

     /**
      * Sets the file name of the user-defined reserved words list.
      * @param cp
      * @param option
      * @param token
      * @param value the file name of the user-defined reserved words list
      */
     public void setUserWordsList(CommandParser cp, Option option, String token,
         File value)
     {
     	clo.userWordsList = value;
     }

     /**
      * Adds to the include path.
      * @param cp
      * @param option
      * @param token
      * @param value path list to append to the current include path.
      */
     public void addIncludePath( CommandParser cp, Option option, String token,
         String value )
     {
         StringTokenizer includeTokens = new StringTokenizer(value,
             File.pathSeparator);

         while(includeTokens.hasMoreTokens())
         {
             File temp = new File(includeTokens.nextToken());
             clo.includePath.add(temp);
         }
     }

     /**
      * Sets the ignore the include path from the environment flag.
      * @param cp
      * @param option
      * @param token
      */
     public void ignoreIncludePath(CommandParser cp, Option option,
         String token)
     {
     	clo.ignoreIncludePath = true;
     }

     /**
      * Sets the quiet flag.
      * @param cp
      * @param option
      * @param token
      */
     public void quiet( CommandParser cp, Option option, String token )
     {
     	clo.quiet = true;
     }

     /**
      * Shows the version and exits.
      * @param cp
      * @param option
      * @param token
      * @return false so that we stop.
      */
     public boolean doVersion( CommandParser cp, Option option, String token )
     {
         System.out.println(String.format("Etch version is %s", Version.VERSION));
         return false;
     }

     /**
      * Sets the suppress mixin artifacts flag.
      * @param cp
      * @param option
      * @param token
      */
     public void noMixinArtifacts( CommandParser cp, Option option, String token )
     {
     	clo.noMixinArtifacts = true;
     }

     /**
      * Sets the output directory for mixins.
      * @param cp
      * @param option
      * @param token
      * @param value the output directory for mixin
      */
     public void setMixinOutputDir( CommandParser cp, Option option, String token,
         File value )
     {
     	clo.mixinOutputDir = value;
     }

     /**
      * Sets the no flatten packages flag.
      * @param cp
      * @param option
      * @param token
      */
     public void noFlattenPackages( CommandParser cp, Option option, String token )
     {
     	clo.noFlattenPackages = true;
     }

     /**
      * Sets the hidden testing flag.
      * @param cp
      * @param option
      * @param token
      */
     public void setTesting( CommandParser cp, Option option, String token )
     {
     	clo.testing = true;
     	clo.lh = new ListLogHandler();
     	testingClo = clo;
     }

     /**
      * If --testing is on the command line, the CmdLineOptions is saved
      * here for reference by unit testing programs.
      */
     public CmdLineOptions testingClo;

     /**
      * Sets the etch source file to compile.
      * @param cp the command parser
      * @param param
      * @param value path of etch file to compile
      */
     public void setSourceFile( CommandParser cp, Parameter param, File value )
     {
     	clo.sourceFile = value;
     }

     @Override
     protected void run() throws Exception
     {
         // Instantiate a new compiler instance and run it.
     	ClassLoader cl = EtchCompiler.setupClassLoader( null );
         EtchCompiler etchCompiler = new EtchCompiler( cl );

         etchCompiler.run( clo );

         if (clo.lh.hasError())
         	exit( 3, "EtchMain", "errors during compile", false );
     }
 }
	/* $Id$
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package org.apache.etch.compiler;

	import java.io.File;
	import java.util.StringTokenizer;

	import org.apache.etch.util.cmd.CommandParser;
	import org.apache.etch.util.cmd.Option;
	import org.apache.etch.util.cmd.Parameter;
	import org.apache.etch.util.cmd.Program;


	/**
	* The main command line interface for the etch compiler.
	*/
	public class EtchMain extends Program
	{
	/**
	* @param args
	* @throws Exception
	*/
	public static void main( String[] args ) throws Exception
	{
	new EtchMain().doMain( args );
	}

	/**
	* Runs the main program, parsing command line arguments and performing
	* the action.
	* @param args
	* @throws Exception
	*/
	public void doMain( String[] args ) throws Exception
	{
	try
	{
	main( this, args );
	}
	catch ( Throwable e )
	{
	e.printStackTrace();
	exit( 3, toString(), e.toString(), true );
	return;
	}
	}

	/**
	* Constructs the etch parser / compiler driver.
	*/
	public EtchMain()
	{
	// nothing to do.
	}

	@Override
	public String toString()
	{
	return "etch";
	}

	@Override
	protected void defineOptionsAndParameters( CommandParser cp )
	throws Exception
	{
	cp.defineFileOption( "-d\|--output-dir", "outputDir", "setOutputDir",
	"output directory for compiler generated files",
	Option.SINGLETON, null, null );

	cp.defineFileOption( "-m\|--mixin-output-dir", "outputDir", "setMixinOutputDir",
	"output directory for compiler generated files for mixins",
	Option.SINGLETON, null, null );

	cp.defineFileOption( "-t\|--template-output-dir", "outputDir", "setTemplateOutputDir",
	"output directory for compiler generated user editable template files",
	Option.SINGLETON, null, null );

	cp.defineStringOption( "-b\|--binding", "binding", "setBinding",
	"specifies a target language binding to generate",
	Option.REQUIRED\|Option.SINGLETON, null, null );

	cp.defineStringOption( "-w\|--what", "what", "addWhat",
	"specifies what files to generate (depends upon binding, try -w help for more info; separate with '"+CmdLineOptions.WHAT_DELIMETER+"')",
	Option.NONE, null, null );

	cp.defineNullOption( "-g\|--ignore-global-words-list", "ignoreGlobalWordsList",
	"ignore the global reserved words list",
	Option.SINGLETON );

	cp.defineNullOption( "-l\|--ignore-local-words-list", "ignoreLocalWordsList",
	"ignore the local (binding-specific) reserved words list",
	Option.SINGLETON );

	cp.defineFileOption( "-W\|--user-words-list", "wordList", "setUserWordsList",
	"file name of a user-specified reserved words list",
	Option.SINGLETON, null, null );

	cp.defineStringOption( "-I\|--include-path", "includePath", "addIncludePath",
	"adds search directories for included or mixed in etch files (separate elements with system path separator '"+File.pathSeparator+"')",
	Option.NONE, null, null );

	cp.defineNullOption( "-i\|--ignore-include-path", "ignoreIncludePath",
	"ignore the "+CmdLineOptions.ETCH_INCLUDE_PATH+" environment variable",
	Option.SINGLETON );

	cp.defineNullOption( "-n\|--no-mixin-artifacts", "noMixinArtifacts",
	"mixin artifacts should not be generated",
	Option.SINGLETON );

	cp.defineNullOption( "-q\|--quiet", "quiet",
	"only report problems",
	Option.SINGLETON );

	cp.defineNullOption( "-v\|--version", "doVersion",
	"show the version and exit",
	Option.SINGLETON );

	cp.defineNullOption( "-f\|--no-flatten-packages", "noFlattenPackages",
	"namespace directory tree should not be flattened",
	Option.SINGLETON );

	cp.defineNullOption( "--testing", "setTesting",
	"",
	Option.HIDDEN );

	cp.defineFileParameter( "sourceFile", "setSourceFile",
	"etch source file to compile", true, false, null );
	}

	private final CmdLineOptions clo = new CmdLineOptions();

	/**
	* Sets the output directory of compiler generated files.
	* @param cp
	* @param option
	* @param token
	* @param value the output directory
	*/
	public void setOutputDir( CommandParser cp, Option option, String token,
	File value )
	{
	clo.outputDir = value;
	}

	/**
	* Sets the output directory for user editable template files.
	* @param cp
	* @param option
	* @param token
	* @param value the template output directory
	*/
	public void setTemplateOutputDir( CommandParser cp, Option option, String token,
	File value )
	{
	clo.templateOutputDir = value;
	}

	/**
	* Sets the binding.
	* @param cp
	* @param option
	* @param token
	* @param value the binding
	*/
	public void setBinding( CommandParser cp, Option option, String token,
	String value )
	{
	clo.binding = value;
	}

	/**
	* Adds to the set of what needs to be generated.
	* @param cp
	* @param option
	* @param token
	* @param value the list of what needs to be generated.
	*/
	public void addWhat( CommandParser cp, Option option, String token,
	String value )
	{
	StringTokenizer st = new StringTokenizer( value, CmdLineOptions.WHAT_DELIMETER );
	while (st.hasMoreElements())
	clo.what.add(st.nextToken().toUpperCase());
	}

	/**
	* Sets the ignore the globally reserved words list flag.
	* @param cp
	* @param option
	* @param token
	*/
	public void ignoreGlobalWordsList(CommandParser cp, Option option, String token)
	{
	clo.ignoreGlobalWordsList = true;
	}

	/**
	* Sets the ignore the locally reserved words list flag.
	* @param cp
	* @param option
	* @param token
	*/
	public void ignoreLocalWordsList(CommandParser cp, Option option, String token)
	{
	clo.ignoreLocalWordsList = true;
	}

	/**
	* Sets the file name of the user-defined reserved words list.
	* @param cp
	* @param option
	* @param token
	* @param value the file name of the user-defined reserved words list
	*/
	public void setUserWordsList(CommandParser cp, Option option, String token,
	File value)
	{
	clo.userWordsList = value;
	}

	/**
	* Adds to the include path.
	* @param cp
	* @param option
	* @param token
	* @param value path list to append to the current include path.
	*/
	public void addIncludePath( CommandParser cp, Option option, String token,
	String value )
	{
	StringTokenizer includeTokens = new StringTokenizer(value,
	File.pathSeparator);

	while(includeTokens.hasMoreTokens())
	{
	File temp = new File(includeTokens.nextToken());
	clo.includePath.add(temp);
	}
	}

	/**
	* Sets the ignore the include path from the environment flag.
	* @param cp
	* @param option
	* @param token
	*/
	public void ignoreIncludePath(CommandParser cp, Option option,
	String token)
	{
	clo.ignoreIncludePath = true;
	}

	/**
	* Sets the quiet flag.
	* @param cp
	* @param option
	* @param token
	*/
	public void quiet( CommandParser cp, Option option, String token )
	{
	clo.quiet = true;
	}

	/**
	* Shows the version and exits.
	* @param cp
	* @param option
	* @param token
	* @return false so that we stop.
	*/
	public boolean doVersion( CommandParser cp, Option option, String token )
	{
	System.out.println(String.format("Etch version is %s", Version.VERSION));
	return false;
	}

	/**
	* Sets the suppress mixin artifacts flag.
	* @param cp
	* @param option
	* @param token
	*/
	public void noMixinArtifacts( CommandParser cp, Option option, String token )
	{
	clo.noMixinArtifacts = true;
	}

	/**
	* Sets the output directory for mixins.
	* @param cp
	* @param option
	* @param token
	* @param value the output directory for mixin
	*/
	public void setMixinOutputDir( CommandParser cp, Option option, String token,
	File value )
	{
	clo.mixinOutputDir = value;
	}

	/**
	* Sets the no flatten packages flag.
	* @param cp
	* @param option
	* @param token
	*/
	public void noFlattenPackages( CommandParser cp, Option option, String token )
	{
	clo.noFlattenPackages = true;
	}

	/**
	* Sets the hidden testing flag.
	* @param cp
	* @param option
	* @param token
	*/
	public void setTesting( CommandParser cp, Option option, String token )
	{
	clo.testing = true;
	clo.lh = new ListLogHandler();
	testingClo = clo;
	}

	/**
	* If --testing is on the command line, the CmdLineOptions is saved
	* here for reference by unit testing programs.
	*/
	public CmdLineOptions testingClo;

	/**
	* Sets the etch source file to compile.
	* @param cp the command parser
	* @param param
	* @param value path of etch file to compile
	*/
	public void setSourceFile( CommandParser cp, Parameter param, File value )
	{
	clo.sourceFile = value;
	}

	@Override
	protected void run() throws Exception
	{
	// Instantiate a new compiler instance and run it.
	ClassLoader cl = EtchCompiler.setupClassLoader( null );
	EtchCompiler etchCompiler = new EtchCompiler( cl );

	etchCompiler.run( clo );

	if (clo.lh.hasError())
	exit( 3, "EtchMain", "errors during compile", false );
	}
	}