Example #1
0
  private void runCompiler(String[] commandLine) {
    // hand crank it so we can add our own compiler configuration
    try {
      Options options = FileSystemCompiler.createCompilationOptions();

      CommandLineParser cliParser = new DefaultParser();

      CommandLine cli;
      cli = cliParser.parse(options, commandLine);

      configuration = FileSystemCompiler.generateCompilerConfigurationFromOptions(cli);
      configuration.setScriptExtensions(getScriptExtensions());
      String tmpExtension = getScriptExtension();
      if (tmpExtension.startsWith("*.")) tmpExtension = tmpExtension.substring(1);
      configuration.setDefaultScriptExtension(tmpExtension);

      // Load the file name list
      String[] filenames = FileSystemCompiler.generateFileNamesFromOptions(cli);
      boolean fileNameErrors = filenames == null;

      fileNameErrors = fileNameErrors || !FileSystemCompiler.validateFiles(filenames);

      if (targetBytecode != null) {
        configuration.setTargetBytecode(targetBytecode);
      }

      if (!fileNameErrors) {
        FileSystemCompiler.doCompilation(
            configuration, makeCompileUnit(), filenames, forceLookupUnnamedFiles);
      }

    } catch (Exception re) {
      Throwable t = re;
      if ((re.getClass() == RuntimeException.class) && (re.getCause() != null)) {
        // unwrap to the real exception
        t = re.getCause();
      }
      StringWriter writer = new StringWriter();
      new ErrorReporter(t, false).write(new PrintWriter(writer));
      String message = writer.toString();

      taskSuccess = false;
      if (errorProperty != null) {
        getProject().setNewProperty(errorProperty, "true");
      }

      if (failOnError) {
        log.error(message);
        throw new BuildException("Compilation Failed", t, getLocation());
      } else {
        log.error(message);
      }
    }
  }
  /** Sets the Flags to defaults. */
  public CompilerConfiguration() {
    //
    // Set in safe defaults

    setWarningLevel(WarningMessage.LIKELY_ERRORS);
    setOutput(null);
    setTargetDirectory((File) null);
    setClasspath("");
    setVerbose(false);
    setDebug(false);
    setTolerance(10);
    setScriptBaseClass(null);
    setRecompileGroovySource(false);
    setMinimumRecompilationInterval(100);
    setTargetBytecode(getVMVersion());
    setDefaultScriptExtension(".groovy");

    //
    // Source file encoding
    String encoding = null;
    try {
      encoding = System.getProperty("file.encoding", "US-ASCII");
    } catch (Exception e) {
      // IGNORE
    }
    try {
      encoding = System.getProperty("groovy.source.encoding", encoding);
    } catch (Exception e) {
      // IGNORE
    }
    setSourceEncoding(encoding);

    try {
      setOutput(new PrintWriter(System.err));
    } catch (Exception e) {
      // IGNORE
    }

    try {
      String target = System.getProperty("groovy.target.directory");
      if (target != null) {
        setTargetDirectory(target);
      }
    } catch (Exception e) {
      // IGNORE
    }
  }
 /**
  * Copy constructor. Use this if you have a mostly correct configuration for your compilation but
  * you want to make a some changes programmatically. An important reason to prefer this approach
  * is that your code will most likely be forward compatible with future changes to this
  * configuration API.<br>
  * An example of this copy constructor at work:<br>
  *
  * <pre>
  *    // In all likelihood there is already a configuration in your code's context
  *    // for you to copy, but for the sake of this example we'll use the global default.
  *    CompilerConfiguration myConfiguration = new CompilerConfiguration(CompilerConfiguration.DEFAULT);
  *    myConfiguration.setDebug(true);
  * </pre>
  *
  * @param configuration The configuration to copy.
  */
 public CompilerConfiguration(CompilerConfiguration configuration) {
   setWarningLevel(configuration.getWarningLevel());
   setOutput(configuration.getOutput());
   setTargetDirectory(configuration.getTargetDirectory());
   setClasspathList(new LinkedList(configuration.getClasspath()));
   setVerbose(configuration.getVerbose());
   setDebug(configuration.getDebug());
   setTolerance(configuration.getTolerance());
   setScriptBaseClass(configuration.getScriptBaseClass());
   setRecompileGroovySource(configuration.getRecompileGroovySource());
   setMinimumRecompilationInterval(configuration.getMinimumRecompilationInterval());
   setTargetBytecode(configuration.getTargetBytecode());
   setDefaultScriptExtension(configuration.getDefaultScriptExtension());
   setSourceEncoding(configuration.getSourceEncoding());
   setOutput(configuration.getOutput());
   setTargetDirectory(configuration.getTargetDirectory());
   Map jointCompilationOptions = configuration.getJointCompilationOptions();
   if (jointCompilationOptions != null) {
     jointCompilationOptions = new HashMap(jointCompilationOptions);
   }
   setJointCompilationOptions(jointCompilationOptions);
   setPluginFactory(configuration.getPluginFactory());
 }
  /**
   * Method to configure a this CompilerConfiguration by using Properties. For a list of available
   * properties look at {link {@link #CompilerConfiguration(Properties)}.
   *
   * @param configuration The properties to get flag values from.
   */
  public void configure(Properties configuration) throws ConfigurationException {
    String text = null;
    int numeric = 0;

    //
    // Warning level

    numeric = getWarningLevel();
    try {
      text = configuration.getProperty("groovy.warnings", "likely errors");
      numeric = Integer.parseInt(text);
    } catch (NumberFormatException e) {
      text = text.toLowerCase();
      if (text.equals("none")) {
        numeric = WarningMessage.NONE;
      } else if (text.startsWith("likely")) {
        numeric = WarningMessage.LIKELY_ERRORS;
      } else if (text.startsWith("possible")) {
        numeric = WarningMessage.POSSIBLE_ERRORS;
      } else if (text.startsWith("paranoia")) {
        numeric = WarningMessage.PARANOIA;
      } else {
        throw new ConfigurationException("unrecogized groovy.warnings: " + text);
      }
    }
    setWarningLevel(numeric);

    //
    // Source file encoding
    //
    text = configuration.getProperty("groovy.source.encoding");
    if (text != null) setSourceEncoding(text);

    //
    // Target directory for classes
    //
    text = configuration.getProperty("groovy.target.directory");
    if (text != null) setTargetDirectory(text);

    text = configuration.getProperty("groovy.target.bytecode");
    if (text != null) setTargetBytecode(text);

    //
    // Classpath
    //
    text = configuration.getProperty("groovy.classpath");
    if (text != null) setClasspath(text);

    //
    // Verbosity
    //
    text = configuration.getProperty("groovy.output.verbose");
    if (text != null && text.equalsIgnoreCase("true")) setVerbose(true);

    //
    // Debugging
    //
    text = configuration.getProperty("groovy.output.debug");
    if (text != null && text.equalsIgnoreCase("true")) setDebug(true);

    //
    // Tolerance
    //
    numeric = 10;
    try {
      text = configuration.getProperty("groovy.errors.tolerance", "10");
      numeric = Integer.parseInt(text);
    } catch (NumberFormatException e) {
      throw new ConfigurationException(e);
    }
    setTolerance(numeric);

    //
    // Script Base Class
    //
    text = configuration.getProperty("groovy.script.base");
    if (text != null) setScriptBaseClass(text);

    //
    // recompilation options
    //
    text = configuration.getProperty("groovy.recompile");
    if (text != null) {
      setRecompileGroovySource(text.equalsIgnoreCase("true"));
    }

    numeric = 100;
    try {
      text = configuration.getProperty("groovy.recompile.minimumIntervall");
      if (text == null) text = configuration.getProperty("groovy.recompile.minimumInterval");
      if (text != null) {
        numeric = Integer.parseInt(text);
      } else {
        numeric = 100;
      }
    } catch (NumberFormatException e) {
      throw new ConfigurationException(e);
    }
    setMinimumRecompilationInterval(numeric);
  }