Package org.apache.tools.ant.taskdefs

Examples of org.apache.tools.ant.taskdefs.Javac


            if (success && !srconly) {
                long start = System.currentTimeMillis();

                // compile the source
                Javac javac = new Javac();
                javac.setProject(project);
                javac.setTaskName(getTaskName());
                javac.setClasspath(classpath);
                if (compiler != null) javac.setCompiler(compiler);
                javac.setDebug(debug);
                if (debugLevel != null) javac.setDebugLevel(debugLevel);
                javac.setDestdir(classgendir);
                javac.setExecutable(forkedExecutable);
                javac.setFailonerror(failonerror);
                javac.setFork(fork);
                javac.setIncludeantruntime(includeAntRuntime);
                javac.setIncludejavaruntime(includeJavaRuntime);
                javac.setSrcdir(new Path(project, srcgendir.getAbsolutePath()));
                if (memoryInitialSize != null) javac.setMemoryInitialSize(memoryInitialSize);
                if (memoryMaximumSize != null) javac.setMemoryMaximumSize(memoryMaximumSize);
                javac.setOptimize(optimize);
                javac.setVerbose(verbose);
                javac.execute();

                long finish = System.currentTimeMillis();
                if (!quiet)
                    log("Time to compile code: " + ((double)(finish - start) / 1000.0) + " seconds");
View Full Code Here


            for (int i = 0; i < count; ++i) {
                generate(generateList[i], loader);
            }

            Javac javac = new Javac();
            javac.setProject(project);
            javac.createSrc().setLocation(_sourceBase);
            javac.setDestdir(_base);
            javac.setDebug(_debug);
            javac.setClasspath(classpath);
            javac.execute();
        }
    }
View Full Code Here

    private Javac makeCompiler(final File srcDir, final File destDir) {
        Project project = new Project();
        project.init();
        project.setBasedir(srcDir.getAbsolutePath());

        Javac compiler = new Javac();
        compiler.setProject(project);
        compiler.setDestdir(destDir.getAbsoluteFile());
        compiler.setOptimize(false);
        compiler.setDebug(true);
        compiler.setDebugLevel("lines,vars,source");
        compiler.setIncludejavaruntime(true);
        if (XMLTestCase._verbose) {
            compiler.setListfiles(true);
            compiler.setVerbose(true);
        } else {
            compiler.setNowarn(true);
        }
        if (_javaVersion != null) {
            compiler.setSource(_javaVersion);
        }
        Path classpath = compiler.createClasspath();
        classpath.setPath(System.getProperty("java.class.path"));
        classpath.add(new Path(project, destDir.getAbsolutePath()));
        compiler.setClasspath(classpath);
        return compiler;
    }
View Full Code Here

        return d;
    }

    public MatchingTask createJavac() {
        if(scp.javac == null) {
      scp.javac = new Javac();
          scp.javac.setProject(getProject());
    }
        return scp.javac;
    }
View Full Code Here


  public void visitCompilerParameter(SpeedoCompilerParameter scp) throws SpeedoException {
    compiler = scp.javac;
    if (compiler == null) {
      compiler = new Javac();
      Project project = new Project();
      project.init();
      compiler.setProject(project);
    }
    compiler.setDestdir(new File(scp.output));
View Full Code Here

        logger = scp.loggerFactory.getLogger(LOGGER_NAME);
        if (scp.getXmldescriptor().isEmpty())
            return false;

        // Sets the owning Project
        compiler = new Javac();
        Project projectCompiler = new Project();
        if (scp.javac != null) {
            String c = scp.javac.getProject().getProperty("build.compiler");
            if (c != null && c.length() >0) {
                projectCompiler.setProperty("build.compiler", c);
View Full Code Here

            if (success && !srconly) {
                long start = System.currentTimeMillis();

                // compile the source
                Javac javac = new Javac();
                javac.setProject(project);
                javac.setTaskName(getTaskName());
                javac.setClasspath(classpath);
                if (compiler != null) javac.setCompiler(compiler);
                javac.setDebug(debug);
                if (debugLevel != null) javac.setDebugLevel(debugLevel);
                javac.setDestdir(classgendir);
                javac.setExecutable(forkedExecutable);
                javac.setFailonerror(failonerror);
                javac.setFork(fork);
                javac.setIncludeantruntime(includeAntRuntime);
                javac.setIncludejavaruntime(includeJavaRuntime);
                javac.setSrcdir(new Path(project, srcgendir.getAbsolutePath()));
                if (memoryInitialSize != null) javac.setMemoryInitialSize(memoryInitialSize);
                if (memoryMaximumSize != null) javac.setMemoryMaximumSize(memoryMaximumSize);
                javac.setOptimize(optimize);
                javac.setVerbose(verbose);
                javac.execute();

                long finish = System.currentTimeMillis();
                if (!quiet)
                    log("Time to compile code: " + ((double)(finish - start) / 1000.0) + " seconds");
View Full Code Here

        // Start capturing the System.err output for this thread
        SystemLogHandler.setThread();

        // Initializing javac task
        getProject();
        Javac javac = (Javac) project.createTask("javac");

        // Initializing classpath
        Path path = new Path(project);
        path.setPath(System.getProperty("java.class.path") + sep
                     + classpath);

        // Initializing sourcepath
        Path srcPath = new Path(project);
        srcPath.setPath(options.getScratchDir().getAbsolutePath());

        // Configure the compiler object
        javac.setEncoding(javaEncoding);
        javac.setClasspath(path);
        //javac.setDestdir(new File(options.getScratchDir().getAbsolutePath()));
        javac.setDebug(ctxt.getOptions().getClassDebugInfo());
        javac.setSrcdir(srcPath);
        javac.setOptimize(! ctxt.getOptions().getClassDebugInfo() );

        // Set the Java compiler to use
        if (options.getCompiler() != null) {
            javac.setCompiler(options.getCompiler());
        }

        // Build includes path
        javac.setIncludes(ctxt.getJspPath());

        try {
            javac.execute();
        } catch (BuildException e) {
            //   System.out.println("Javac execption ");
            //   e.printStackTrace(System.out);
            success = false;
        }
View Full Code Here

     *
     * @param outputLocation
     */
    private void compile(String outputLocation){
        //using the ant javac task for compilation
        Javac javaCompiler = new Javac();
        Project codeGenProject = new Project();
        Target compileTarget = new Target();

        compileTarget.setName(COMPILE_TARGET_NAME);
        compileTarget.addTask(javaCompiler);
        codeGenProject.addTarget(compileTarget);
        codeGenProject.setSystemProperties();
        javaCompiler.setProject(codeGenProject);
        javaCompiler.setIncludejavaruntime(true);
        javaCompiler.setIncludeantruntime(true);

        /*
          This harmless looking setFork is actually very important. unless the compiler is
          forked it wont work!
        */
        javaCompiler.setFork(true);

        //Create classpath - The generated output directories also become part of the classpath
        //reason for this is that some codegenerators(XMLBeans) produce compiled classes as part of
        //generated artifacts
        File outputLocationFile = new File(outputLocation);
        Path classPath = new Path(codeGenProject,outputLocation) ;
        classPath.addExisting(classPath.concatSystemClasspath(),false);
        for (int i = 0; i < moduleNames.length; i++) {
            classPath.add(new Path(codeGenProject,MODULE_PATH_PREFIX +moduleNames[i]+CLASSES_DIR));
        }
        javaCompiler.setClasspath(classPath);

        //set sourcePath - The generated output directories also become part of the sourcepath
        Path sourcePath = new Path(codeGenProject,outputLocation) ;
        sourcePath.setLocation(outputLocationFile);
        javaCompiler.setSrcdir(sourcePath);

        //output the classes into the output dir as well
        javaCompiler.setDestdir(outputLocationFile);
        javaCompiler.setVerbose(true);
        try {
            codeGenProject.executeTarget(COMPILE_TARGET_NAME);
        } catch (BuildException e) {
            fail();
        }
View Full Code Here

    commonsAttributesCompiler.execute();

    System.out.println("Compiling Java sources generated by Commons Attributes using Javac: requires tools.jar on Eclipse project classpath");
    // We now have the generated Java source: compile it.
    // This requires Javac on the source path
    Javac javac = new Javac();
    javac.setProject(project);
    //project.setCoreLoader(Thread.currentThread().getContextClassLoader());
    Path path = new Path(project, tempPath);
    javac.setSrcdir(path);

    // Couldn't get this to work: trying to use Eclipse
    //javac.setCompiler("org.eclipse.jdt.core.JDTCompilerAdapter");
    File destDir = new File(root.getPath() + File.separator + "target/test-classes");
    if(!destDir.exists()) {
      destDir.mkdir();
    }

    javac.setDestdir(destDir);
    javac.setIncludes(attributeClasses);
    javac.execute();
  }
View Full Code Here

TOP

Related Classes of org.apache.tools.ant.taskdefs.Javac

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.