pax_global_header 0000666 0000000 0000000 00000000064 12022156743 0014514 g ustar 00root root 0000000 0000000 52 comment=36a1fb07afa3e18efda5c4e317fda0eb4e5e1da6
plexus-compiler-plexus-compiler-1.9.2/ 0000775 0000000 0000000 00000000000 12022156743 0020003 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/.gitignore 0000664 0000000 0000000 00000000070 12022156743 0021770 0 ustar 00root root 0000000 0000000 target/
.project
.classpath
.settings/
bin
.idea
*.iml
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/ 0000775 0000000 0000000 00000000000 12022156743 0023702 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/pom.xml 0000664 0000000 0000000 00000001543 12022156743 0025222 0 ustar 00root root 0000000 0000000
4.0.0
org.codehaus.plexus
plexus-compiler
1.9.2
plexus-compiler-api
Plexus Compiler Api
Plexus Compilers component's API to manipulate compilers.
org.codehaus.plexus
plexus-utils
junit
junit
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/ 0000775 0000000 0000000 00000000000 12022156743 0024471 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/ 0000775 0000000 0000000 00000000000 12022156743 0025415 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/ 0000775 0000000 0000000 00000000000 12022156743 0026336 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0027125 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/ 0000775 0000000 0000000 00000000000 12022156743 0030720 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 12022156743 0032240 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0033773 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler AbstractCompiler.java 0000664 0000000 0000000 00000021065 12022156743 0040100 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler package org.codehaus.plexus.compiler;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.logging.AbstractLogEnabled;
import org.codehaus.plexus.util.DirectoryScanner;
import java.io.File;
import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* @author Jason van Zyl
* @author Michal Maczka
* @author Trygve Laugstøl
* @version $Id$
*/
public abstract class AbstractCompiler
extends AbstractLogEnabled
implements Compiler
{
protected static final String EOL = System.getProperty( "line.separator" );
protected static final String PS = System.getProperty( "path.separator" );
private CompilerOutputStyle compilerOutputStyle;
private String inputFileEnding;
private String outputFileEnding;
private String outputFile;
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
protected AbstractCompiler( CompilerOutputStyle compilerOutputStyle, String inputFileEnding,
String outputFileEnding, String outputFile )
{
this.compilerOutputStyle = compilerOutputStyle;
this.inputFileEnding = inputFileEnding;
this.outputFileEnding = outputFileEnding;
this.outputFile = outputFile;
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
public CompilerOutputStyle getCompilerOutputStyle()
{
return compilerOutputStyle;
}
public String getInputFileEnding( CompilerConfiguration configuration )
throws CompilerException
{
return inputFileEnding;
}
public String getOutputFileEnding( CompilerConfiguration configuration )
throws CompilerException
{
if ( compilerOutputStyle != CompilerOutputStyle.ONE_OUTPUT_FILE_PER_INPUT_FILE )
{
throw new RuntimeException( "This compiler implementation doesn't have one output file per input file." );
}
return outputFileEnding;
}
public String getOutputFile( CompilerConfiguration configuration )
throws CompilerException
{
if ( compilerOutputStyle != CompilerOutputStyle.ONE_OUTPUT_FILE_FOR_ALL_INPUT_FILES )
{
throw new RuntimeException( "This compiler implementation doesn't have one output file for all files." );
}
return outputFile;
}
public boolean canUpdateTarget( CompilerConfiguration configuration )
throws CompilerException
{
return true;
}
// ----------------------------------------------------------------------
// Utility Methods
// ----------------------------------------------------------------------
public static String getPathString( List pathElements )
{
StringBuilder sb = new StringBuilder();
for ( String pathElement : pathElements )
{
sb.append( pathElement ).append( File.pathSeparator );
}
return sb.toString();
}
protected static Set getSourceFilesForSourceRoot( CompilerConfiguration config, String sourceLocation )
{
DirectoryScanner scanner = new DirectoryScanner();
scanner.setBasedir( sourceLocation );
Set includes = config.getIncludes();
if ( includes != null && !includes.isEmpty() )
{
String[] inclStrs = includes.toArray( new String[includes.size()] );
scanner.setIncludes( inclStrs );
}
else
{
scanner.setIncludes( new String[]{ "**/*.java" } );
}
Set excludes = config.getExcludes();
if ( excludes != null && !excludes.isEmpty() )
{
String[] exclStrs = excludes.toArray( new String[excludes.size()] );
scanner.setIncludes( exclStrs );
}
scanner.scan();
String[] sourceDirectorySources = scanner.getIncludedFiles();
Set sources = new HashSet();
for ( int j = 0; j < sourceDirectorySources.length; j++ )
{
File f = new File( sourceLocation, sourceDirectorySources[j] );
sources.add( f.getPath() );
}
return sources;
}
protected static String[] getSourceFiles( CompilerConfiguration config )
{
Set sources = new HashSet();
Set sourceFiles = config.getSourceFiles();
if ( sourceFiles != null && !sourceFiles.isEmpty() )
{
for ( File sourceFile : sourceFiles )
{
sources.add( sourceFile.getAbsolutePath() );
}
}
else
{
for ( String sourceLocation : config.getSourceLocations() )
{
sources.addAll( getSourceFilesForSourceRoot( config, sourceLocation ) );
}
}
String[] result;
if ( sources.isEmpty() )
{
result = new String[0];
}
else
{
result = (String[]) sources.toArray( new String[sources.size()] );
}
return result;
}
protected static String makeClassName( String fileName, String sourceDir )
throws CompilerException
{
File origFile = new File( fileName );
String canonical = null;
if ( origFile.exists() )
{
canonical = getCanonicalPath( origFile ).replace( '\\', '/' );
}
if ( sourceDir != null )
{
String prefix = getCanonicalPath( new File( sourceDir ) ).replace( '\\', '/' );
if ( canonical != null )
{
if ( canonical.startsWith( prefix ) )
{
String result = canonical.substring( prefix.length() + 1, canonical.length() - 5 );
result = result.replace( '/', '.' );
return result;
}
}
else
{
File t = new File( sourceDir, fileName );
if ( t.exists() )
{
String str = getCanonicalPath( t ).replace( '\\', '/' );
return str.substring( prefix.length() + 1, str.length() - 5 ).replace( '/', '.' );
}
}
}
if ( fileName.endsWith( ".java" ) )
{
fileName = fileName.substring( 0, fileName.length() - 5 );
}
fileName = fileName.replace( '\\', '.' );
return fileName.replace( '/', '.' );
}
private static String getCanonicalPath( File origFile )
throws CompilerException
{
try
{
return origFile.getCanonicalPath();
}
catch ( IOException e )
{
throw new CompilerException(
"Error while getting the canonical path of '" + origFile.getAbsolutePath() + "'.", e );
}
}
/**
* @deprecated use (String[]) arguments.toArray( new String[ arguments.size() ] ); instead
*/
protected static String[] toStringArray( List arguments )
{
String[] args = new String[arguments.size()];
int argLength = arguments.size();
for ( int i = 0; i < argLength; i++ )
{
args[i] = arguments.get( i );
}
return args;
}
}
Compiler.java 0000664 0000000 0000000 00000005173 12022156743 0036416 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler package org.codehaus.plexus.compiler;
/**
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.util.List;
/**
* @author Jason van Zyl
* @author Trygve Laugstøl
* @author Matthew Pocock
* @version $Id$
*/
public interface Compiler
{
String ROLE = Compiler.class.getName();
CompilerOutputStyle getCompilerOutputStyle();
String getInputFileEnding( CompilerConfiguration configuration )
throws CompilerException;
String getOutputFileEnding( CompilerConfiguration configuration )
throws CompilerException;
String getOutputFile( CompilerConfiguration configuration )
throws CompilerException;
boolean canUpdateTarget( CompilerConfiguration configuration )
throws CompilerException;
List compile( CompilerConfiguration configuration )
throws CompilerException;
/**
* Create the command line that would be executed using this configuration.
* If this particular compiler has no concept of a command line then returns
* null.
*
* @param config the CompilerConfiguration describing the
* compilation
* @return an array of Strings that make up the command line, or null if
* this compiler has no concept of command line
* @throws CompilerException if there was an error generating the command
* line
*/
String[] createCommandLine(CompilerConfiguration config )
throws CompilerException;
}
CompilerConfiguration.java 0000664 0000000 0000000 00000031710 12022156743 0041142 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler package org.codehaus.plexus.compiler;
/**
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.io.File;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @author jdcasey
* @version $Id$
*/
public class CompilerConfiguration
{
private String outputLocation;
private List classpathEntries = new LinkedList();
// ----------------------------------------------------------------------
// Source Files
// ----------------------------------------------------------------------
private Set sourceFiles = new HashSet();
private List sourceLocations = new LinkedList();
private Set includes = new HashSet();
private Set excludes = new HashSet();
// ----------------------------------------------------------------------
// Compiler Settings
// ----------------------------------------------------------------------
private boolean debug;
private String debugLevel;
private boolean showWarnings = true;
private boolean showDeprecation;
private String sourceVersion;
private String targetVersion;
private String sourceEncoding;
private Map customCompilerArguments = new LinkedHashMap();
private boolean fork;
private boolean optimize;
private String meminitial;
private String maxmem;
private String executable;
private File workingDirectory;
private String compilerVersion;
private boolean verbose = false;
/**
* A build temporary directory, eg target/.
*
* Used by the compiler implementation to put temporary files.
*/
private File buildDirectory;
/**
* Used to control the name of the output file when compiling a set of
* sources to a single file.
*/
private String outputFileName;
/**
* in jdk 1.6+, used to hold value of the -s path parameter.
*/
private File generatedSourcesDirectory;
/**
* value of the -proc parameter in jdk 1.6+
*/
private String proc;
/**
* -processor parameters in jdk 1.6+
*/
private String[] annotationProcessors;
/**
* default value {@link CompilerReuseStrategy.ReuseCreated}
*
* @since 1.9
*/
private CompilerReuseStrategy compilerReuseStrategy = CompilerReuseStrategy.ReuseCreated;
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
public void setOutputLocation( String outputLocation )
{
this.outputLocation = outputLocation;
}
public String getOutputLocation()
{
return outputLocation;
}
// ----------------------------------------------------------------------
// Class path
// ----------------------------------------------------------------------
public void addClasspathEntry( String classpathEntry )
{
classpathEntries.add( classpathEntry );
}
public void setClasspathEntries( List classpathEntries )
{
if ( classpathEntries == null )
{
this.classpathEntries = Collections.emptyList();
}
else
{
this.classpathEntries = new LinkedList( classpathEntries );
}
}
public List getClasspathEntries()
{
return Collections.unmodifiableList( classpathEntries );
}
// ----------------------------------------------------------------------
// Source files
// ----------------------------------------------------------------------
public void setSourceFiles( Set sourceFiles )
{
if ( sourceFiles == null )
{
this.sourceFiles = Collections.emptySet();
}
else
{
this.sourceFiles = new HashSet( sourceFiles );
}
}
public Set getSourceFiles()
{
return sourceFiles;
}
public void addSourceLocation( String sourceLocation )
{
sourceLocations.add( sourceLocation );
}
public void setSourceLocations( List sourceLocations )
{
if ( sourceLocations == null )
{
this.sourceLocations = Collections.emptyList();
}
else
{
this.sourceLocations = new LinkedList( sourceLocations );
}
}
public List getSourceLocations()
{
return Collections.unmodifiableList( sourceLocations );
}
public void addInclude( String include )
{
includes.add( include );
}
public void setIncludes( Set includes )
{
if ( includes == null )
{
this.includes = Collections.emptySet();
}
else
{
this.includes = new HashSet( includes );
}
}
public Set getIncludes()
{
return Collections.unmodifiableSet( includes );
}
public void addExclude( String exclude )
{
excludes.add( exclude );
}
public void setExcludes( Set excludes )
{
if ( excludes == null )
{
this.excludes = Collections.emptySet();
}
else
{
this.excludes = new HashSet( excludes );
}
}
public Set getExcludes()
{
return Collections.unmodifiableSet( excludes );
}
// ----------------------------------------------------------------------
// Compiler Settings
// ----------------------------------------------------------------------
public void setDebug( boolean debug )
{
this.debug = debug;
}
public boolean isDebug()
{
return debug;
}
public void setDebugLevel( String debugLevel )
{
this.debugLevel = debugLevel;
}
public String getDebugLevel()
{
return debugLevel;
}
public void setShowWarnings( boolean showWarnings )
{
this.showWarnings = showWarnings;
}
public boolean isShowWarnings()
{
return showWarnings;
}
public boolean isShowDeprecation()
{
return showDeprecation;
}
public void setShowDeprecation( boolean showDeprecation )
{
this.showDeprecation = showDeprecation;
}
public String getSourceVersion()
{
return sourceVersion;
}
public void setSourceVersion( String sourceVersion )
{
this.sourceVersion = sourceVersion;
}
public String getTargetVersion()
{
return targetVersion;
}
public void setTargetVersion( String targetVersion )
{
this.targetVersion = targetVersion;
}
public String getSourceEncoding()
{
return sourceEncoding;
}
public void setSourceEncoding( String sourceEncoding )
{
this.sourceEncoding = sourceEncoding;
}
public void addCompilerCustomArgument( String customArgument, String value )
{
customCompilerArguments.put( customArgument, value );
}
/**
* @deprecated will be removed in 2.X use #getCustomCompilerArgumentsAsMap
* @return
*/
public LinkedHashMap getCustomCompilerArguments()
{
return new LinkedHashMap( customCompilerArguments );
}
/**
* @deprecated will be removed in 2.X use #setCustomCompilerArgumentsAsMap
* @param customCompilerArguments
*/
public void setCustomCompilerArguments( LinkedHashMap customCompilerArguments )
{
if ( customCompilerArguments == null )
{
this.customCompilerArguments = new LinkedHashMap();
}
else
{
this.customCompilerArguments = customCompilerArguments;
}
}
public Map getCustomCompilerArgumentsAsMap()
{
return new LinkedHashMap( customCompilerArguments );
}
public void setCustomCompilerArgumentsAsMap( Map customCompilerArguments )
{
if ( customCompilerArguments == null )
{
this.customCompilerArguments = new LinkedHashMap();
}
else
{
this.customCompilerArguments = customCompilerArguments;
}
}
public boolean isFork()
{
return fork;
}
public void setFork( boolean fork )
{
this.fork = fork;
}
public String getMeminitial()
{
return meminitial;
}
public void setMeminitial( String meminitial )
{
this.meminitial = meminitial;
}
public String getMaxmem()
{
return maxmem;
}
public void setMaxmem( String maxmem )
{
this.maxmem = maxmem;
}
public String getExecutable()
{
return executable;
}
public void setExecutable( String executable )
{
this.executable = executable;
}
public File getWorkingDirectory()
{
return workingDirectory;
}
public void setWorkingDirectory( File workingDirectory )
{
this.workingDirectory = workingDirectory;
}
public File getBuildDirectory()
{
return buildDirectory;
}
public void setBuildDirectory( File buildDirectory )
{
this.buildDirectory = buildDirectory;
}
public String getOutputFileName()
{
return outputFileName;
}
public void setOutputFileName( String outputFileName )
{
this.outputFileName = outputFileName;
}
public boolean isOptimize()
{
return optimize;
}
public void setOptimize( boolean optimize )
{
this.optimize = optimize;
}
public String getCompilerVersion()
{
return compilerVersion;
}
public void setCompilerVersion( String compilerVersion )
{
this.compilerVersion = compilerVersion;
}
public boolean isVerbose()
{
return verbose;
}
public void setVerbose( boolean verbose )
{
this.verbose = verbose;
}
public void setProc( String proc )
{
this.proc = proc;
}
public void setGeneratedSourcesDirectory( File generatedSourcesDirectory )
{
this.generatedSourcesDirectory = generatedSourcesDirectory;
}
public File getGeneratedSourcesDirectory()
{
return generatedSourcesDirectory;
}
public String getProc()
{
return proc;
}
public void setAnnotationProcessors( String[] annotationProcessors )
{
this.annotationProcessors = annotationProcessors;
}
public String[] getAnnotationProcessors()
{
return annotationProcessors;
}
public CompilerReuseStrategy getCompilerReuseStrategy()
{
return compilerReuseStrategy;
}
public void setCompilerReuseStrategy( CompilerReuseStrategy compilerReuseStrategy )
{
this.compilerReuseStrategy = compilerReuseStrategy;
}
/**
* re use strategy of the compiler (implement for java only)
*/
public enum CompilerReuseStrategy
{
/**
* always reuse the same
* default strategy
*/
ReuseSame( "reuseSame" ),
/**
* re create a new compiler for each use
*/
AlwaysNew( "alwaysNew" ),
/**
* re use already created compiler, create new one if non already exists
* Will mimic a kind of pool to prevent different threads use the same
*/
ReuseCreated( "reuseCreated" );
private String strategy;
CompilerReuseStrategy( String strategy )
{
this.strategy = strategy;
}
public String getStrategy()
{
return strategy;
}
@Override
public String toString()
{
return "CompilerReuseStrategy:" + this.strategy;
}
}
}
CompilerError.java 0000664 0000000 0000000 00000014340 12022156743 0037424 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler package org.codehaus.plexus.compiler;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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.
*/
/**
* This class encapsulates an error message produced by a programming language
* processor (whether interpreted or compiled)
* @author Stefano Mazzocchi
* @version $Id$
* @since 2.0
*/
public class CompilerError
{
/**
* Is this a severe error or a warning?
*/
private boolean error;
/**
* The start line number of the offending program text
*/
private int startline;
/**
* The start column number of the offending program text
*/
private int startcolumn;
/**
* The end line number of the offending program text
*/
private int endline;
/**
* The end column number of the offending program text
*/
private int endcolumn;
/**
* The name of the file containing the offending program text
*/
private String file;
/**
* The actual error text produced by the language processor
*/
private String message;
/**
* The error message constructor.
*
* @param file The name of the file containing the offending program text
* @param error Is this a severe error or a warning?
* @param startline The start line number of the offending program text
* @param startcolumn The start column number of the offending program text
* @param endline The end line number of the offending program text
* @param endcolumn The end column number of the offending program text
* @param message The actual error text produced by the language processor
*/
public CompilerError( String file,
boolean error,
int startline,
int startcolumn,
int endline,
int endcolumn,
String message )
{
this.file = file;
this.error = error;
this.startline = startline;
this.startcolumn = startcolumn;
this.endline = endline;
this.endcolumn = endcolumn;
this.message = message;
}
/**
* The warning message constructor.
*
* @param message The actual error text produced by the language processor
*/
public CompilerError( String message )
{
this.message = message;
}
/**
* The error message constructor.
*
* @param message The actual error text produced by the language processor
* @param error whether it was an error or informational
*/
public CompilerError( String message, boolean error )
{
this.message = message;
this.error = error;
}
/**
* Return the filename associated with this compiler error.
*
* @return The filename associated with this compiler error
*/
public String getFile()
{
return file;
}
/**
* Assert whether this is a severe error or a warning
*
* @return Whether the error is severe
*/
public boolean isError()
{
return error;
}
/**
* Return the starting line number of the program text originating this error
*
* @return The starting line number of the program text originating this error
*/
public int getStartLine()
{
return startline;
}
/**
* Return the starting column number of the program text originating this
* error
*
* @return The starting column number of the program text originating this
* error
*/
public int getStartColumn()
{
return startcolumn;
}
/**
* Return the ending line number of the program text originating this error
*
* @return The ending line number of the program text originating this error
*/
public int getEndLine()
{
return endline;
}
/**
* Return the ending column number of the program text originating this
* error
*
* @return The ending column number of the program text originating this
* error
*/
public int getEndColumn()
{
return endcolumn;
}
/**
* Return the message produced by the language processor
*
* @return The message produced by the language processor
*/
public String getMessage()
{
return message;
}
public String toString()
{
if ( file != null )
{
return file + ":" + "[" + startline + "," + startcolumn + "] " + message;
}
else
{
return message;
}
}
}
CompilerException.java 0000664 0000000 0000000 00000002772 12022156743 0040277 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler package org.codehaus.plexus.compiler;
/**
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public class CompilerException
extends Exception
{
public CompilerException( String message )
{
super( message );
}
public CompilerException( String message, Throwable cause )
{
super( message, cause );
}
}
CompilerOutputStyle.java 0000664 0000000 0000000 00000004522 12022156743 0040655 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler package org.codehaus.plexus.compiler;
/**
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public final class CompilerOutputStyle
{
public final static CompilerOutputStyle ONE_OUTPUT_FILE_PER_INPUT_FILE = new CompilerOutputStyle( "one-output-file-per-input-file" );
public final static CompilerOutputStyle ONE_OUTPUT_FILE_FOR_ALL_INPUT_FILES = new CompilerOutputStyle( "one-output-file" );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
private String id;
private CompilerOutputStyle( String id )
{
this.id = id;
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
public String toString()
{
return id;
}
public boolean equals( Object other )
{
if ( other == null || !(other instanceof CompilerOutputStyle) )
{
return false;
}
return id.equals( ((CompilerOutputStyle)other ).id );
}
public int hashCode()
{
return id.hashCode();
}
}
0000775 0000000 0000000 00000000000 12022156743 0034750 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util StreamPumper.java 0000664 0000000 0000000 00000004657 12022156743 0040253 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util package org.codehaus.plexus.compiler.util;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* @author Jason van Zyl
* @version $Id$
*/
public class StreamPumper
extends Thread
{
private static final int BUFFER_SIZE = 512;
private BufferedInputStream stream;
private boolean endOfStream = false;
private int SLEEP_TIME = 5;
private OutputStream out;
public StreamPumper( BufferedInputStream is, OutputStream out )
{
this.stream = is;
this.out = out;
}
public void pumpStream()
throws IOException
{
byte[] buf = new byte[BUFFER_SIZE];
if ( !endOfStream )
{
int bytesRead = stream.read( buf, 0, BUFFER_SIZE );
if ( bytesRead > 0 )
{
out.write( buf, 0, bytesRead );
}
else if ( bytesRead == -1 )
{
endOfStream = true;
}
}
}
public void run()
{
try
{
while ( !endOfStream )
{
pumpStream();
sleep( SLEEP_TIME );
}
}
catch ( Exception e )
{
// getLogger().warn("Jikes.run()", e);
}
}
}
0000775 0000000 0000000 00000000000 12022156743 0035674 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan AbstractSourceInclusionScanner.java 0000664 0000000 0000000 00000004407 12022156743 0044666 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan package org.codehaus.plexus.compiler.util.scan;
/*
* Copyright 2001-2005 The Apache Software Foundation.
*
* Licensed 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.
*/
import org.codehaus.plexus.compiler.util.scan.mapping.SourceMapping;
import org.codehaus.plexus.util.DirectoryScanner;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
/**
* @author jdcasey
* @version $Id$
*/
public abstract class AbstractSourceInclusionScanner
implements SourceInclusionScanner
{
private final List sourceMappings = new ArrayList();
public final void addSourceMapping( SourceMapping sourceMapping )
{
sourceMappings.add( sourceMapping );
}
protected final List getSourceMappings()
{
return Collections.unmodifiableList( sourceMappings );
}
protected String[] scanForSources( File sourceDir, Set sourceIncludes, Set sourceExcludes )
{
DirectoryScanner ds = new DirectoryScanner();
ds.setFollowSymlinks( true );
ds.setBasedir( sourceDir );
String[] includes;
if ( sourceIncludes.isEmpty() )
{
includes = new String[0];
}
else
{
includes = sourceIncludes.toArray( new String[sourceIncludes.size()] );
}
ds.setIncludes( includes );
String[] excludes;
if ( sourceExcludes.isEmpty() )
{
excludes = new String[0];
}
else
{
excludes = sourceExcludes.toArray( new String[sourceExcludes.size()] );
}
ds.setExcludes( excludes );
ds.addDefaultExcludes();
ds.scan();
return ds.getIncludedFiles();
}
}
InclusionScanException.java 0000664 0000000 0000000 00000001726 12022156743 0043174 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan package org.codehaus.plexus.compiler.util.scan;
/*
* Copyright 2001-2005 The Apache Software Foundation.
*
* Licensed 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.
*/
/**
* @author jdcasey
* @version $Id$
*/
public class InclusionScanException
extends Exception
{
public InclusionScanException( String message )
{
super( message );
}
public InclusionScanException( String message, Throwable cause )
{
super( message, cause );
}
}
SimpleSourceInclusionScanner.java 0000664 0000000 0000000 00000005073 12022156743 0044354 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan package org.codehaus.plexus.compiler.util.scan;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.compiler.util.scan.mapping.SourceMapping;
import java.io.File;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public class SimpleSourceInclusionScanner
extends AbstractSourceInclusionScanner
{
private Set sourceIncludes;
private Set sourceExcludes;
public SimpleSourceInclusionScanner( Set sourceIncludes, Set sourceExcludes )
{
this.sourceIncludes = sourceIncludes;
this.sourceExcludes = sourceExcludes;
}
public Set getIncludedSources( File sourceDir, File targetDir )
throws InclusionScanException
{
List srcMappings = getSourceMappings();
if ( srcMappings.isEmpty() )
{
return Collections.emptySet();
}
String[] potentialSources = scanForSources( sourceDir, sourceIncludes, sourceExcludes );
Set matchingSources = new HashSet( potentialSources != null ? potentialSources.length : 0 );
if ( potentialSources != null )
{
for ( String potentialSource : potentialSources )
{
matchingSources.add( new File( sourceDir, potentialSource ) );
}
}
return matchingSources;
}
}
SourceInclusionScanner.java 0000664 0000000 0000000 00000002256 12022156743 0043202 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan package org.codehaus.plexus.compiler.util.scan;
/*
* Copyright 2001-2005 The Apache Software Foundation.
*
* Licensed 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.
*/
import org.codehaus.plexus.compiler.util.scan.mapping.SourceMapping;
import java.io.File;
import java.util.Set;
/**
* @author jdcasey
* @version $Id$
*/
public interface SourceInclusionScanner
{
void addSourceMapping( SourceMapping sourceMapping );
/**
*
* @param sourceDir
* @param targetDir
* @return Set of File objects
* @throws InclusionScanException
*/
Set getIncludedSources( File sourceDir, File targetDir )
throws InclusionScanException;
}
StaleSourceScanner.java 0000664 0000000 0000000 00000006707 12022156743 0042314 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan package org.codehaus.plexus.compiler.util.scan;
/*
* Copyright 2001-2005 The Apache Software Foundation.
*
* Licensed 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.
*/
import org.codehaus.plexus.compiler.util.scan.mapping.SourceMapping;
import java.io.File;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* @author jdcasey
* @version $Id$
*/
public class StaleSourceScanner
extends AbstractSourceInclusionScanner
{
private final long lastUpdatedWithinMsecs;
private final Set sourceIncludes;
private final Set sourceExcludes;
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
public StaleSourceScanner()
{
this( 0, Collections.singleton( "**/*" ), Collections.emptySet() );
}
public StaleSourceScanner( long lastUpdatedWithinMsecs )
{
this( lastUpdatedWithinMsecs, Collections.singleton( "**/*" ), Collections.emptySet() );
}
public StaleSourceScanner( long lastUpdatedWithinMsecs, Set sourceIncludes, Set sourceExcludes )
{
this.lastUpdatedWithinMsecs = lastUpdatedWithinMsecs;
this.sourceIncludes = sourceIncludes;
this.sourceExcludes = sourceExcludes;
}
// ----------------------------------------------------------------------
// SourceInclusionScanner Implementation
// ----------------------------------------------------------------------
public Set getIncludedSources( File sourceDir, File targetDir )
throws InclusionScanException
{
List srcMappings = getSourceMappings();
if ( srcMappings.isEmpty() )
{
return Collections.emptySet();
}
String[] potentialIncludes = scanForSources( sourceDir, sourceIncludes, sourceExcludes );
Set matchingSources = new HashSet();
for ( String path : potentialIncludes )
{
File sourceFile = new File( sourceDir, path );
staleSourceFileTesting:
for ( SourceMapping mapping : srcMappings )
{
Set targetFiles = mapping.getTargetFiles( targetDir, path );
// never include files that don't have corresponding target mappings.
// the targets don't have to exist on the filesystem, but the
// mappers must tell us to look for them.
for ( File targetFile : targetFiles )
{
if ( !targetFile.exists()
|| ( targetFile.lastModified() + lastUpdatedWithinMsecs < sourceFile.lastModified() ) )
{
matchingSources.add( sourceFile );
break staleSourceFileTesting;
}
}
}
}
return matchingSources;
}
}
0000775 0000000 0000000 00000000000 12022156743 0037327 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan/mapping SingleTargetSourceMapping.java 0000664 0000000 0000000 00000004103 12022156743 0045255 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan/mapping package org.codehaus.plexus.compiler.util.scan.mapping;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.compiler.util.scan.InclusionScanException;
import java.util.Set;
import java.util.Collections;
import java.io.File;
/**
* Maps a set of input files to a single output file.
*
* @author Trygve Laugstøl
* @version $Id$
*/
public class SingleTargetSourceMapping
implements SourceMapping
{
private String sourceSuffix;
private String outputFile;
public SingleTargetSourceMapping( String sourceSuffix, String outputFile )
{
this.sourceSuffix = sourceSuffix;
this.outputFile = outputFile;
}
public Set getTargetFiles( File targetDir, String source )
throws InclusionScanException
{
if ( !source.endsWith( sourceSuffix ) )
{
return Collections.emptySet();
}
return Collections.singleton( new File( targetDir, outputFile ) );
}
}
SourceMapping.java 0000664 0000000 0000000 00000001716 12022156743 0042753 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan/mapping package org.codehaus.plexus.compiler.util.scan.mapping;
/*
* Copyright 2001-2005 The Apache Software Foundation.
*
* Licensed 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.
*/
import org.codehaus.plexus.compiler.util.scan.InclusionScanException;
import java.io.File;
import java.util.Set;
/**
* @author jdcasey
* @version $Id$
*/
public interface SourceMapping
{
Set getTargetFiles( File targetDir, String source )
throws InclusionScanException;
}
SuffixMapping.java 0000664 0000000 0000000 00000003475 12022156743 0042763 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/main/java/org/codehaus/plexus/compiler/util/scan/mapping package org.codehaus.plexus.compiler.util.scan.mapping;
/*
* Copyright 2001-2005 The Apache Software Foundation.
*
* Licensed 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.
*/
import java.io.File;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/**
* @author jdcasey
* @version $Id$
*/
public final class SuffixMapping
implements SourceMapping
{
private final String sourceSuffix;
private final Set targetSuffixes;
public SuffixMapping( String sourceSuffix, String targetSuffix )
{
this.sourceSuffix = sourceSuffix;
this.targetSuffixes = Collections.singleton( targetSuffix );
}
public SuffixMapping( String sourceSuffix, Set targetSuffixes )
{
this.sourceSuffix = sourceSuffix;
this.targetSuffixes = Collections.unmodifiableSet( targetSuffixes );
}
public Set getTargetFiles( File targetDir, String source )
{
Set targetFiles = new HashSet();
if ( source.endsWith( sourceSuffix ) )
{
String base = source.substring( 0, source.length() - sourceSuffix.length() );
for ( String suffix : targetSuffixes )
{
targetFiles.add( new File( targetDir, base + suffix ) );
}
}
return targetFiles;
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/site/ 0000775 0000000 0000000 00000000000 12022156743 0025435 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/site/site.xml 0000664 0000000 0000000 00000001126 12022156743 0027123 0 ustar 00root root 0000000 0000000
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/ 0000775 0000000 0000000 00000000000 12022156743 0025450 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/ 0000775 0000000 0000000 00000000000 12022156743 0026371 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0027160 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/ 0000775 0000000 0000000 00000000000 12022156743 0030753 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 12022156743 0032273 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034026 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0035003 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/plexus/compiler/util 0000775 0000000 0000000 00000000000 12022156743 0035727 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/plexus/compiler/util/scan AbstractSourceInclusionScannerTest.java 0000664 0000000 0000000 00000006653 12022156743 0045566 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/plexus/compiler/util/scan package org.codehaus.plexus.compiler.util.scan;
/*
* Copyright 2006 The Apache Software Foundation.
*
* Licensed 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.
*/
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
import java.util.Set;
import junit.framework.TestCase;
import org.codehaus.plexus.compiler.util.scan.mapping.SuffixMapping;
import org.codehaus.plexus.util.IOUtil;
/**
* Tests for all the implementations of SourceInclusionScanner
*
* @author Carlos Sanchez
* @version $Id$
*/
public abstract class AbstractSourceInclusionScannerTest
extends TestCase
{
private static final String TESTFILE_DEST_MARKER_FILE =
SourceInclusionScanner.class.getName().replace( '.', '/' ) + "-testMarker.txt";
protected SourceInclusionScanner scanner;
public void testGetIncludedSources() throws Exception
{
File base = new File( getTestBaseDir(), "testGetIncludedSources" );
File sourceFile = new File( base, "file.java" );
writeFile( sourceFile );
sourceFile.setLastModified( System.currentTimeMillis() );
SuffixMapping mapping = new SuffixMapping( ".java", ".xml" );
scanner.addSourceMapping( mapping );
SetincludedSources = scanner.getIncludedSources( base, base );
assertTrue( "no sources were included", !includedSources.isEmpty());
for ( File file : includedSources )
{
assertTrue( "file included does not exist", file.exists() );
}
}
// ----------------------------------------------------------------------
// Utilities
// ----------------------------------------------------------------------
protected File getTestBaseDir()
{
ClassLoader cl = Thread.currentThread().getContextClassLoader();
URL markerResource = cl.getResource( TESTFILE_DEST_MARKER_FILE );
File basedir;
if ( markerResource != null )
{
File marker = new File( markerResource.getPath() );
basedir = marker.getParentFile().getAbsoluteFile();
}
else
{
// punt.
System.out.println( "Cannot find marker file: \'" + TESTFILE_DEST_MARKER_FILE + "\' in classpath. " +
"Using '.' for basedir." );
basedir = new File( "." ).getAbsoluteFile();
}
return basedir;
}
protected void writeFile( File file )
throws IOException
{
FileWriter fWriter = null;
try
{
File parent = file.getParentFile();
if ( !parent.exists() )
{
parent.mkdirs();
}
file.deleteOnExit();
fWriter = new FileWriter( file );
fWriter.write( "This is just a test file." );
}
finally
{
IOUtil.close( fWriter );
}
}
}
SimpleSourceInclusionScannerTest.java 0000664 0000000 0000000 00000002362 12022156743 0045245 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/plexus/compiler/util/scan package org.codehaus.plexus.compiler.util.scan;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/*
* Copyright 2006 The Apache Software Foundation.
*
* Licensed 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.
*/
/**
* Test for
*
* @author Carlos Sanchez
* @version $Id$
*/
public class SimpleSourceInclusionScannerTest
extends AbstractSourceInclusionScannerTest
{
private Set includes, excludes;
protected void setUp()
throws Exception
{
super.setUp();
includes = Collections.singleton( "*.java" );
excludes = new HashSet();
scanner = new SimpleSourceInclusionScanner( includes, excludes );
}
}
StaleSourceScannerTest.java 0000664 0000000 0000000 00000034545 12022156743 0043210 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/plexus/compiler/util/scan package org.codehaus.plexus.compiler.util.scan;
/*
* Copyright 2001-2005 The Apache Software Foundation.
*
* Licensed 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.
*/
import java.io.File;
import java.util.Collections;
import java.util.Set;
import org.codehaus.plexus.compiler.util.scan.mapping.SingleTargetSourceMapping;
import org.codehaus.plexus.compiler.util.scan.mapping.SourceMapping;
import org.codehaus.plexus.compiler.util.scan.mapping.SuffixMapping;
/**
* @author jdcasey
* @author Trygve Laugstøl
* @version $Id$
*/
public class StaleSourceScannerTest
extends AbstractSourceInclusionScannerTest
{
protected void setUp()
throws Exception
{
super.setUp();
scanner = new StaleSourceScanner();
}
// test 1.
public void testWithDefaultConstructorShouldFindOneStaleSource()
throws Exception
{
File base = new File( getTestBaseDir(), "test1" );
long now = System.currentTimeMillis();
File targetFile = new File( base, "file.xml" );
writeFile( targetFile );
targetFile.setLastModified( now - 60000 );
File sourceFile = new File( base, "file.java" );
writeFile( sourceFile );
sourceFile.setLastModified( now );
SuffixMapping mapping = new SuffixMapping( ".java", ".xml" );
scanner.addSourceMapping( mapping );
Set result = scanner.getIncludedSources( base, base );
assertEquals( "wrong number of stale sources returned.", 1, result.size() );
assertTrue( "expected stale source file not found in result", result.contains( sourceFile ) );
}
// test 2.
public void testWithDefaultConstructorShouldNotFindStaleSources()
throws Exception
{
File base = new File( getTestBaseDir(), "test2" );
long now = System.currentTimeMillis();
File sourceFile = new File( base, "file.java" );
writeFile( sourceFile );
sourceFile.setLastModified( now - 60000 );
File targetFile = new File( base, "file.xml" );
writeFile( targetFile );
targetFile.setLastModified( now );
SuffixMapping mapping = new SuffixMapping( ".java", ".xml" );
scanner.addSourceMapping( mapping );
Set result = scanner.getIncludedSources( base, base );
assertEquals( "wrong number of stale sources returned.", 0, result.size() );
assertFalse( "expected stale source file not found in result", result.contains( sourceFile ) );
}
// test 3.
public void testWithDefaultConstructorShouldFindStaleSourcesBecauseOfMissingTargetFile()
throws Exception
{
File base = new File( getTestBaseDir(), "test3" );
File sourceFile = new File( base, "file.java" );
writeFile( sourceFile );
SuffixMapping mapping = new SuffixMapping( ".java", ".xml" );
scanner.addSourceMapping( mapping );
Set result = scanner.getIncludedSources( base, base );
assertEquals( "wrong number of stale sources returned.", 1, result.size() );
assertTrue( "expected stale source file not found in result", result.contains( sourceFile ) );
}
// test 4.
public void testWithDefaultConstructorShouldFindStaleSourcesOneBecauseOfMissingTargetAndOneBecauseOfStaleTarget()
throws Exception
{
File base = new File( getTestBaseDir(), "test4" );
long now = System.currentTimeMillis();
File targetFile = new File( base, "file2.xml" );
writeFile( targetFile );
targetFile.setLastModified( now - 60000 );
File sourceFile = new File( base, "file.java" );
writeFile( sourceFile );
File sourceFile2 = new File( base, "file2.java" );
writeFile( sourceFile2 );
sourceFile2.setLastModified( now );
SuffixMapping mapping = new SuffixMapping( ".java", ".xml" );
scanner.addSourceMapping( mapping );
Set result = scanner.getIncludedSources( base, base );
assertEquals( "wrong number of stale sources returned.", 2, result.size() );
assertTrue( "expected stale source file not found in result", result.contains( sourceFile ) );
assertTrue( "expected stale source file not found in result", result.contains( sourceFile2 ) );
}
// test 5.
public void testWithDefaultConstructorShouldFindOneStaleSourcesWithStaleTargetAndOmitUpToDateSource()
throws Exception
{
File base = new File( getTestBaseDir(), "test5" );
long now = System.currentTimeMillis();
// target/source (1) should result in source being included.
// write the target file first, and set the lastmod to some time in the
// past to ensure this.
File targetFile = new File( base, "file.xml" );
writeFile( targetFile );
targetFile.setLastModified( now - 60000 );
// now write the source file, and set the lastmod to now.
File sourceFile = new File( base, "file.java" );
writeFile( sourceFile );
sourceFile.setLastModified( now );
// target/source (2) should result in source being omitted.
// write the source file first, and set the lastmod to some time in the
// past to ensure this.
File sourceFile2 = new File( base, "file2.java" );
writeFile( sourceFile2 );
sourceFile2.setLastModified( now - 60000 );
// now write the target file, with lastmod of now.
File targetFile2 = new File( base, "file2.xml" );
writeFile( targetFile2 );
targetFile2.setLastModified( now );
SuffixMapping mapping = new SuffixMapping( ".java", ".xml" );
scanner.addSourceMapping( mapping );
Set result = scanner.getIncludedSources( base, base );
assertEquals( "wrong number of stale sources returned.", 1, result.size() );
assertTrue( "expected stale source file not found in result", result.contains( sourceFile ) );
}
// test 6.
public void testConstructedWithMsecsShouldReturnOneSourceFileOfTwoDueToLastMod()
throws Exception
{
File base = new File( getTestBaseDir(), "test6" );
long now = System.currentTimeMillis();
File targetFile = new File( base, "file.xml" );
writeFile( targetFile );
// should be within the threshold of lastMod for stale sources.
targetFile.setLastModified( now - 8000 );
File sourceFile = new File( base, "file.java" );
writeFile( sourceFile );
// modified 'now' for comparison with the above target file.
sourceFile.setLastModified( now );
File targetFile2 = new File( base, "file2.xml" );
writeFile( targetFile2 );
targetFile2.setLastModified( now - 12000 );
File sourceFile2 = new File( base, "file2.java" );
writeFile( sourceFile2 );
// modified 'now' for comparison to above target file.
sourceFile2.setLastModified( now );
SuffixMapping mapping = new SuffixMapping( ".java", ".xml" );
scanner = new StaleSourceScanner( 10000 );
scanner.addSourceMapping( mapping );
Set result = scanner.getIncludedSources( base, base );
assertEquals( "wrong number of stale sources returned.", 1, result.size() );
assertTrue( "expected stale source file not found in result", result.contains( sourceFile2 ) );
assertFalse( "expected stale source file not found in result", result.contains( sourceFile ) );
}
// test 7.
public void testConstructedWithMsecsIncludesAndExcludesShouldReturnOneSourceFileOfThreeDueToIncludePattern()
throws Exception
{
File base = new File( getTestBaseDir(), "test7" );
long now = System.currentTimeMillis();
File targetFile = new File( base, "file.xml" );
writeFile( targetFile );
// should be within the threshold of lastMod for stale sources.
targetFile.setLastModified( now - 12000 );
File sourceFile = new File( base, "file.java" );
writeFile( sourceFile );
// modified 'now' for comparison with the above target file.
sourceFile.setLastModified( now );
File targetFile2 = new File( base, "file2.xml" );
writeFile( targetFile2 );
targetFile2.setLastModified( now - 12000 );
File sourceFile2 = new File( base, "file2.java" );
writeFile( sourceFile2 );
// modified 'now' for comparison to above target file.
sourceFile2.setLastModified( now );
File targetFile3 = new File( base, "file3.xml" );
writeFile( targetFile3 );
targetFile3.setLastModified( now - 12000 );
File sourceFile3 = new File( base, "file3.java" );
writeFile( sourceFile3 );
// modified 'now' for comparison to above target file.
sourceFile3.setLastModified( now );
SuffixMapping mapping = new SuffixMapping( ".java", ".xml" );
scanner = new StaleSourceScanner( 0, Collections.singleton( "*3.java" ), Collections.emptySet() );
scanner.addSourceMapping( mapping );
Set result = scanner.getIncludedSources( base, base );
assertEquals( "wrong number of stale sources returned.", 1, result.size() );
assertFalse( "expected stale source file not found in result", result.contains( sourceFile ) );
assertFalse( "unexpected stale source file found in result", result.contains( sourceFile2 ) );
assertTrue( "unexpected stale source file found in result", result.contains( sourceFile3 ) );
}
// test 8.
public void testConstructedWithMsecsIncludesAndExcludesShouldReturnTwoSourceFilesOfThreeDueToExcludePattern()
throws Exception
{
File base = new File( getTestBaseDir(), "test8" );
long now = System.currentTimeMillis();
File targetFile = new File( base, "fileX.xml" );
writeFile( targetFile );
// should be within the threshold of lastMod for stale sources.
targetFile.setLastModified( now - 12000 );
File sourceFile = new File( base, "fileX.java" );
writeFile( sourceFile );
// modified 'now' for comparison with the above target file.
sourceFile.setLastModified( now );
File targetFile2 = new File( base, "file2.xml" );
writeFile( targetFile2 );
targetFile2.setLastModified( now - 12000 );
File sourceFile2 = new File( base, "file2.java" );
writeFile( sourceFile2 );
// modified 'now' for comparison to above target file.
sourceFile2.setLastModified( now );
File targetFile3 = new File( base, "file3.xml" );
writeFile( targetFile3 );
targetFile3.setLastModified( now - 12000 );
File sourceFile3 = new File( base, "file3.java" );
writeFile( sourceFile3 );
// modified 'now' for comparison to above target file.
sourceFile3.setLastModified( now );
SuffixMapping mapping = new SuffixMapping( ".java", ".xml" );
scanner = new StaleSourceScanner( 0, Collections.singleton( "**/*" ), Collections.singleton( "*X.*" ) );
scanner.addSourceMapping( mapping );
Set result = scanner.getIncludedSources( base, base );
assertEquals( "wrong number of stale sources returned.", 2, result.size() );
assertFalse( "unexpected stale source file found in result", result.contains( sourceFile ) );
assertTrue( "expected stale source not file found in result", result.contains( sourceFile2 ) );
assertTrue( "expected stale source not file found in result", result.contains( sourceFile3 ) );
}
// test 9.
public void testSingleFileSourceMapping()
throws Exception
{
File src = new File( getTestBaseDir(), "test9-src" );
File target = new File( getTestBaseDir(), "test9-target" );
long now = System.currentTimeMillis();
// ----------------------------------------------------------------------
// The output file is missing
// ----------------------------------------------------------------------
File fooCs = new File( src, "Foo.cs" );
writeFile( fooCs );
fooCs.setLastModified( now - 10000 );
SourceMapping mapping = new SingleTargetSourceMapping( ".cs", "Application.exe" );
scanner = new StaleSourceScanner( 0 );
scanner.addSourceMapping( mapping );
Set result = scanner.getIncludedSources( src, target );
assertEquals( 1, result.size() );
assertTrue( result.contains( fooCs ) );
// ----------------------------------------------------------------------
// Add another source file
// ----------------------------------------------------------------------
File barCs = new File( src, "Bar.cs" );
writeFile( barCs );
barCs.setLastModified( now - 20000 );
result = scanner.getIncludedSources( src, target );
assertEquals( 2, result.size() );
assertTrue( result.contains( fooCs ) );
assertTrue( result.contains( barCs ) );
// ----------------------------------------------------------------------
// Now add the result file
// ----------------------------------------------------------------------
File applicationExe = new File( target, "Application.exe" );
writeFile( applicationExe );
applicationExe.setLastModified( now );
result = scanner.getIncludedSources( src, target );
assertEquals( 0, result.size() );
// ----------------------------------------------------------------------
// Make Application.exe older than the Foo.cs
// ----------------------------------------------------------------------
applicationExe.setLastModified( now - 15000 );
result = scanner.getIncludedSources( src, target );
assertEquals( 1, result.size() );
assertTrue( result.contains( fooCs ) );
}
}
0000775 0000000 0000000 00000000000 12022156743 0037362 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/plexus/compiler/util/scan/mapping SuffixMappingTest.java 0000664 0000000 0000000 00000007320 12022156743 0043647 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/java/org/codehaus/plexus/compiler/util/scan/mapping package org.codehaus.plexus.compiler.util.scan.mapping;
/*
* Copyright 2001-2005 The Apache Software Foundation.
*
* Licensed 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.
*/
import junit.framework.TestCase;
import org.codehaus.plexus.compiler.util.scan.InclusionScanException;
import java.io.File;
import java.util.HashSet;
import java.util.Set;
/**
* @author jdcasey
*/
public class SuffixMappingTest
extends TestCase
{
public void testShouldReturnSingleClassFileForSingleJavaFile()
throws InclusionScanException
{
String base = "path/to/file";
File basedir = new File( "." );
SuffixMapping mapping = new SuffixMapping( ".java", ".class" );
Set results = mapping.getTargetFiles( basedir, base + ".java" );
assertEquals( "Returned wrong number of target files.", 1, results.size() );
assertEquals( "Target file is wrong.", new File( basedir, base + ".class" ), results.iterator().next() );
}
public void testShouldNotReturnClassFileWhenSourceFileHasWrongSuffix()
throws InclusionScanException
{
String base = "path/to/file";
File basedir = new File( "." );
SuffixMapping mapping = new SuffixMapping( ".java", ".class" );
Set results = mapping.getTargetFiles( basedir, base + ".xml" );
assertTrue( "Returned wrong number of target files.", results.isEmpty() );
}
public void testShouldReturnOneClassFileAndOneXmlFileForSingleJavaFile()
throws InclusionScanException
{
String base = "path/to/file";
File basedir = new File( "." );
Set targets = new HashSet();
targets.add( ".class" );
targets.add( ".xml" );
SuffixMapping mapping = new SuffixMapping( ".java", targets );
Set results = mapping.getTargetFiles( basedir, base + ".java" );
assertEquals( "Returned wrong number of target files.", 2, results.size() );
assertTrue( "Targets do not contain class target.", results.contains( new File( basedir, base + ".class" ) ) );
assertTrue( "Targets do not contain class target.", results.contains( new File( basedir, base + ".xml" ) ) );
}
public void testShouldReturnNoTargetFilesWhenSourceFileHasWrongSuffix()
throws InclusionScanException
{
String base = "path/to/file";
File basedir = new File( "." );
Set targets = new HashSet();
targets.add( ".class" );
targets.add( ".xml" );
SuffixMapping mapping = new SuffixMapping( ".java", targets );
Set results = mapping.getTargetFiles( basedir, base + ".apt" );
assertTrue( "Returned wrong number of target files.", results.isEmpty() );
}
public void testSingleTargetMapper()
throws InclusionScanException
{
String base = "path/to/file";
File basedir = new File( "target/" );
SingleTargetSourceMapping mapping = new SingleTargetSourceMapping( ".cs", "/foo" );
Set results = mapping.getTargetFiles( basedir, base + ".apt" );
assertTrue( results.isEmpty() );
results = mapping.getTargetFiles( basedir, base + ".cs" );
assertEquals( 1, results.size() );
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/resources/ 0000775 0000000 0000000 00000000000 12022156743 0027462 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/resources/org/ 0000775 0000000 0000000 00000000000 12022156743 0030251 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/resources/org/codehaus/ 0000775 0000000 0000000 00000000000 12022156743 0032044 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/resources/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 12022156743 0033364 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0035117 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/resources/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0036074 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/resources/org/codehaus/plexus/compiler/util 0000775 0000000 0000000 00000000000 12022156743 0037020 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/resources/org/codehaus/plexus/compiler/util/scan SourceInclusionScanner-testMarker.txt 0000664 0000000 0000000 00000000062 12022156743 0046334 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-api/src/test/resources/org/codehaus/plexus/compiler/util/scan marker for finding this location on the classpath. plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/ 0000775 0000000 0000000 00000000000 12022156743 0024543 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/pom.xml 0000664 0000000 0000000 00000001264 12022156743 0026063 0 ustar 00root root 0000000 0000000
4.0.0
org.codehaus.plexus
plexus-compiler
1.9.2
plexus-compiler-manager
Plexus Compiler Manager
org.codehaus.plexus
plexus-compiler-api
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/ 0000775 0000000 0000000 00000000000 12022156743 0025332 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/ 0000775 0000000 0000000 00000000000 12022156743 0026256 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/java/ 0000775 0000000 0000000 00000000000 12022156743 0027177 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0027766 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/java/org/codehaus/ 0000775 0000000 0000000 00000000000 12022156743 0031561 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/java/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 12022156743 0033101 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034634 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0036246 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/java/org/codehaus/plexus/compiler/manager CompilerManager.java 0000664 0000000 0000000 00000002744 12022156743 0042165 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/java/org/codehaus/plexus/compiler/manager package org.codehaus.plexus.compiler.manager;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.compiler.Compiler;
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public interface CompilerManager
{
String ROLE = CompilerManager.class.getName();
Compiler getCompiler( String compilerId )
throws NoSuchCompilerException;
}
DefaultCompilerManager.java 0000664 0000000 0000000 00000004167 12022156743 0043473 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/java/org/codehaus/plexus/compiler/manager package org.codehaus.plexus.compiler.manager;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.compiler.Compiler;
import org.codehaus.plexus.logging.AbstractLogEnabled;
import java.util.Map;
/**
* @plexus.component
*
* @author Trygve Laugstøl
* @version $Id$
*/
public class DefaultCompilerManager
extends AbstractLogEnabled
implements CompilerManager
{
/**
* @plexus.requirement role="org.codehaus.plexus.compiler.Compiler"
*/
private Map compilers;
// ----------------------------------------------------------------------
// CompilerManager Implementation
// ----------------------------------------------------------------------
public Compiler getCompiler( String compilerId )
throws NoSuchCompilerException
{
Compiler compiler = compilers.get( compilerId );
if ( compiler == null )
{
throw new NoSuchCompilerException( compilerId );
}
return compiler;
}
}
NoSuchCompilerException.java 0000664 0000000 0000000 00000003133 12022156743 0043662 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/main/java/org/codehaus/plexus/compiler/manager package org.codehaus.plexus.compiler.manager;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public class NoSuchCompilerException
extends Exception
{
private final String compilerId;
public NoSuchCompilerException( String compilerId )
{
super( "No such compiler '" + compilerId + "'." );
this.compilerId = compilerId;
}
public String getCompilerId()
{
return compilerId;
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/site/ 0000775 0000000 0000000 00000000000 12022156743 0026276 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/site/site.xml 0000664 0000000 0000000 00000001126 12022156743 0027764 0 ustar 00root root 0000000 0000000
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/test/ 0000775 0000000 0000000 00000000000 12022156743 0026311 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/test/java/ 0000775 0000000 0000000 00000000000 12022156743 0027232 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/test/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0030021 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/test/java/org/codehaus/ 0000775 0000000 0000000 00000000000 12022156743 0031614 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/test/java/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 12022156743 0033134 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034667 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/test/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0036301 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/test/java/org/codehaus/plexus/compiler/manager CompilerManagerTest.java 0000664 0000000 0000000 00000003362 12022156743 0043055 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-manager/src/test/java/org/codehaus/plexus/compiler/manager package org.codehaus.plexus.compiler.manager;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.PlexusTestCase;
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public class CompilerManagerTest
extends PlexusTestCase
{
public void testBasic()
throws Exception
{
CompilerManager compilerManager = (CompilerManager) lookup( CompilerManager.ROLE );
try
{
compilerManager.getCompiler( "foo" );
fail( "Expected NoSuchCompilerException" );
}
catch ( NoSuchCompilerException e )
{
// ignored
}
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/ 0000775 0000000 0000000 00000000000 12022156743 0024110 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/pom.xml 0000664 0000000 0000000 00000003547 12022156743 0025436 0 ustar 00root root 0000000 0000000
4.0.0
org.codehaus.plexus
plexus-compiler
1.9.2
plexus-compiler-test
Plexus Compiler Test Harness
org.codehaus.plexus
plexus-compiler-api
junit
junit
compile
org.apache.maven
maven-artifact-test
2.0.10
org.apache.maven
maven-artifact
2.0
org.apache.maven
maven-artifact-manager
2.0
org.apache.maven
maven-settings
2.0
org.codehaus.plexus
plexus-utils
commons-lang
commons-lang
2.0
runtime
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/ 0000775 0000000 0000000 00000000000 12022156743 0024677 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/main/ 0000775 0000000 0000000 00000000000 12022156743 0025623 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/main/java/ 0000775 0000000 0000000 00000000000 12022156743 0026544 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/main/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0027333 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/main/java/org/codehaus/ 0000775 0000000 0000000 00000000000 12022156743 0031126 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/main/java/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 12022156743 0032446 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034201 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/main/java/org/codehaus/plexus/compiler AbstractCompilerTckTest.java 0000664 0000000 0000000 00000015070 12022156743 0041607 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/main/java/org/codehaus/plexus/compiler package org.codehaus.plexus.compiler;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.PlexusTestCase;
import org.codehaus.plexus.util.FileUtils;
import java.io.File;
import java.io.IOException;
import java.util.List;
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public abstract class AbstractCompilerTckTest
extends PlexusTestCase
{
private static final String EOL = System.getProperty( "line.separator" );
private String roleHint;
protected AbstractCompilerTckTest( String roleHint )
{
this.roleHint = roleHint;
}
public void testDeprecation()
throws Exception
{
File foo = new File( getSrc(), "Foo.java" );
writeFileWithDeprecatedApi( foo, "Foo" );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
CompilerConfiguration configuration = new CompilerConfiguration();
configuration.setShowDeprecation( true );
configuration.addSourceLocation( getSrc().getAbsolutePath() );
List result = compile( configuration );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
assertEquals( 1, result.size() );
CompilerError error = result.get( 0 );
System.out.println( error.getMessage() );
assertFalse( error.isError() );
assertTrue( error.getMessage().indexOf( "Date" ) != -1 );
assertTrue( error.getMessage().indexOf( "deprecated" ) != -1 );
}
public void testWarning()
throws Exception
{
File foo = new File( getSrc(), "Foo.java" );
writeFileWithWarning( foo, "Foo" );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
CompilerConfiguration configuration = new CompilerConfiguration();
configuration.setShowWarnings( true );
configuration.addSourceLocation( getSrc().getAbsolutePath() );
List result = compile( configuration );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
assertEquals( 1, result.size() );
CompilerError error = result.get( 0 );
assertFalse( error.isError() );
assertTrue( error.getMessage().indexOf( "finally block does not complete normally" ) != -1 );
}
protected List compile( CompilerConfiguration configuration )
throws Exception
{
// ----------------------------------------------------------------------
// Set up configuration
// ----------------------------------------------------------------------
File compilerOutput = getCompilerOutput();
if ( compilerOutput.exists() )
{
FileUtils.deleteDirectory( compilerOutput );
}
configuration.setOutputLocation( compilerOutput.getAbsolutePath() );
// ----------------------------------------------------------------------
// Compile!
// ----------------------------------------------------------------------
Compiler compiler = (Compiler) lookup( Compiler.ROLE, roleHint );
List result = compiler.compile( configuration );
assertNotNull( result );
return result;
}
private File getCompilerOutput()
{
return getTestFile( "target/compiler-output/" + getName() );
}
private File getSrc()
{
return getTestFile( "target/compiler-src/" + getName() );
}
protected void writeFileWithDeprecatedApi( File path, String className )
throws IOException
{
File parent = path.getParentFile();
if ( !parent.exists() )
{
assertTrue( parent.mkdirs() );
}
String source = "import java.util.Date;" + EOL +
"" + EOL +
"public class " + className + "" + EOL +
"{" + EOL +
" private static Date date = new Date( \"foo\" );" + EOL +
" static " + EOL +
" { " + EOL +
" Date date = " + className + ".date; " + EOL +
" Date date2 = date; " + EOL +
" date = date2; " + EOL +
" }" + EOL +
"}";
FileUtils.fileWrite( path.getAbsolutePath(), source );
}
protected void writeFileWithWarning( File path, String className )
throws IOException
{
File parent = path.getParentFile();
if ( !parent.exists() )
{
assertTrue( parent.mkdirs() );
}
String source = "public class " + className + "" + EOL +
"{" + EOL +
" public void foo()" + EOL +
" {" + EOL +
" try{ throw new java.io.IOException(); }" + EOL +
" finally { return; }" + EOL +
" }" + EOL +
"}";
FileUtils.fileWrite( path.getAbsolutePath(), source );
}
}
AbstractCompilerTest.java 0000664 0000000 0000000 00000016564 12022156743 0041156 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/main/java/org/codehaus/plexus/compiler package org.codehaus.plexus.compiler;
/**
* The MIT License
*
* Copyright (c) 2004, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.DefaultArtifact;
import org.apache.maven.artifact.handler.DefaultArtifactHandler;
import org.apache.maven.artifact.test.ArtifactTestCase;
import org.apache.maven.artifact.versioning.VersionRange;
import org.codehaus.plexus.util.FileUtils;
import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;
/**
* @version $Id$
*/
public abstract class AbstractCompilerTest
extends ArtifactTestCase
{
private boolean compilerDebug = false;
private boolean compilerDeprecationWarnings = false;
protected abstract String getRoleHint();
protected void setCompilerDebug( boolean flag )
{
compilerDebug = flag;
}
protected void setCompilerDeprecationWarnings( boolean flag )
{
compilerDeprecationWarnings = flag;
}
protected List getClasspath()
throws Exception
{
List cp = new ArrayList();
File file = getLocalArtifactPath( "commons-lang", "commons-lang", "2.0", "jar" );
assertTrue( "test prerequisite: commons-lang library must be available in local repository, expected "
+ file.getAbsolutePath(), file.canRead() );
cp.add( file.getAbsolutePath() );
return cp;
}
@SuppressWarnings( "unchecked" )
public void testCompilingSources()
throws Exception
{
List messages = new ArrayList();
Collection files = new TreeSet();
for ( CompilerConfiguration compilerConfig : getCompilerConfigurations() )
{
File outputDir = new File( compilerConfig.getOutputLocation() );
Compiler compiler = (Compiler) lookup( Compiler.ROLE, getRoleHint() );
messages.addAll( compiler.compile( compilerConfig ) );
if ( outputDir.isDirectory() )
{
files.addAll( normalizePaths( FileUtils.getFileNames( outputDir, null, null, false ) ) );
}
}
int numCompilerErrors = compilerErrorCount( messages );
int numCompilerWarnings = messages.size() - numCompilerErrors;
if ( expectedErrors() != numCompilerErrors )
{
System.err.println( numCompilerErrors + " error(s) found:" );
for ( CompilerError error : messages )
{
if ( !error.isError() )
{
continue;
}
System.err.println( "----" );
System.err.println( error.getFile() );
System.err.println( error.getMessage() );
System.err.println( "----" );
}
assertEquals( "Wrong number of compilation errors.",
expectedErrors(),
numCompilerErrors );
}
if ( expectedWarnings() != numCompilerWarnings )
{
System.err.println( numCompilerWarnings + " warning(s) found:" );
for ( CompilerError error : messages )
{
if ( error.isError() )
{
continue;
}
System.err.println( "----" );
System.err.println( error.getFile() );
System.err.println( error.getMessage() );
System.err.println( "----" );
}
assertEquals( "Wrong number of compilation warnings.",
expectedWarnings(),
numCompilerWarnings );
}
assertEquals( new TreeSet( normalizePaths( expectedOutputFiles() ) ), files );
}
private List getCompilerConfigurations()
throws Exception
{
String sourceDir = getBasedir() + "/src/test-input/src/main";
@SuppressWarnings( "unchecked" )
List filenames = FileUtils.getFileNames( new File( sourceDir ), "**/*.java", null, false, true );
Collections.sort( filenames );
List compilerConfigurations = new ArrayList();
int index = 0;
for ( Iterator it = filenames.iterator(); it.hasNext(); index++ )
{
String filename = it.next();
CompilerConfiguration compilerConfig = new CompilerConfiguration();
compilerConfig.setDebug( compilerDebug );
compilerConfig.setShowDeprecation( compilerDeprecationWarnings );
compilerConfig.setClasspathEntries( getClasspath() );
compilerConfig.addSourceLocation( sourceDir );
compilerConfig.setOutputLocation( getBasedir() + "/target/" + getRoleHint() + "/classes-" + index );
compilerConfig.addInclude( filename );
compilerConfigurations.add( compilerConfig );
}
return compilerConfigurations;
}
private List normalizePaths( Collection relativePaths )
{
List normalizedPaths = new ArrayList();
for ( String relativePath : relativePaths )
{
normalizedPaths.add( relativePath.replace( File.separatorChar, '/' ) );
}
return normalizedPaths;
}
protected int compilerErrorCount( List messages )
{
int count = 0;
for ( CompilerError message : messages )
{
count += message.isError() ? 1 : 0;
}
return count;
}
protected int expectedErrors()
{
return 1;
}
protected int expectedWarnings()
{
return 0;
}
protected Collection expectedOutputFiles()
{
return Collections.emptyList();
}
protected File getLocalArtifactPath( String groupId, String artifactId, String version, String type )
{
VersionRange versionRange = VersionRange.createFromVersion( version );
Artifact artifact =
new DefaultArtifact( groupId, artifactId, versionRange, Artifact.SCOPE_COMPILE, type, null,
new DefaultArtifactHandler( type ) );
return getLocalArtifactPath( artifact );
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/site/ 0000775 0000000 0000000 00000000000 12022156743 0025643 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compiler-test/src/site/site.xml 0000664 0000000 0000000 00000001126 12022156743 0027331 0 ustar 00root root 0000000 0000000
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/ 0000775 0000000 0000000 00000000000 12022156743 0023316 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/ 0000775 0000000 0000000 00000000000 12022156743 0030075 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/pom.xml 0000664 0000000 0000000 00000001525 12022156743 0031415 0 ustar 00root root 0000000 0000000
4.0.0
org.codehaus.plexus
plexus-compilers
1.9.2
plexus-compiler-aspectj
Plexus AspectJ Compiler
org.aspectj
aspectjrt
1.6.0
org.aspectj
aspectjtools
1.6.0
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/ 0000775 0000000 0000000 00000000000 12022156743 0030664 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/main/ 0000775 0000000 0000000 00000000000 12022156743 0031610 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/main/java/ 0000775 0000000 0000000 00000000000 12022156743 0032531 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/main/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0033320 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0035034 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/main/java/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0036354 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/main/java/org/codehaus/plexus 0000775 0000000 0000000 00000000000 12022156743 0040166 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/main/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0040723 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/main/java/org/codehaus/plexus/compiler/ajc AspectJCompiler.java 0000664 0000000 0000000 00000044242 12022156743 0044620 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/main/java/org/codehaus/plexus/compiler/ajc package org.codehaus.plexus.compiler.ajc;
import org.aspectj.ajdt.internal.core.builder.AjBuildConfig;
import org.aspectj.ajdt.internal.core.builder.AjBuildManager;
import org.aspectj.bridge.AbortException;
import org.aspectj.bridge.IMessage;
import org.aspectj.bridge.ISourceLocation;
import org.aspectj.bridge.MessageHandler;
import org.aspectj.org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.codehaus.plexus.compiler.AbstractCompiler;
import org.codehaus.plexus.compiler.CompilerConfiguration;
import org.codehaus.plexus.compiler.CompilerError;
import org.codehaus.plexus.compiler.CompilerException;
import org.codehaus.plexus.compiler.CompilerOutputStyle;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* @plexus.component
* role="org.codehaus.plexus.compiler.Compiler"
* role-hint="aspectj"
*
* Options
*
* -injars JarList
*
* Accept as source bytecode any .class files inside the specified .jar files. The output will include these
* classes, possibly as woven with any applicable aspects. JarList, like classpath, is a single argument
* containing a list of paths to jar files, delimited by the platform- specific classpath delimiter.
*
* -aspectpath JarList
*
* Weave binary aspects from JarList zip files into all sources. The aspects should have been output by
* the same version of the compiler. To run the output classes requires putting all the aspectpath entries on
* the run classpath. JarList, like classpath, is a single argument containing a list of paths to jar files,
* delimited by the platform- specific classpath delimiter.
*
* -argfile File
*
* The file is a line-delimited list of arguments. These arguments are inserted into the argument list.
*
* -outjar output.jar
*
* Put output classes in zip file output.jar.
*
* -incremental
*
* Run the compiler continuously. After the initial compilation, the compiler will wait to recompile until it
* reads a newline from the standard input, and will quit when it reads a 'q'. It will only recompile necessary
* components, so a recompile should be much faster than doing a second compile. This requires -sourceroots.
*
* -sourceroots DirPaths
*
* Find and build all .java or .aj source files under any directory listed in DirPaths. DirPaths, like
* classpath, is a single argument containing a list of paths to directories, delimited by the platform-
* specific classpath delimiter. Required by -incremental.
*
* -emacssym
*
* Generate .ajesym symbol files for emacs support
*
* -Xlint
*
* Same as -Xlint:warning (enabled by default)
*
* -Xlint:{level}
*
* Set default level for messages about potential programming mistakes in crosscutting code. {level} may be
* ignore, warning, or error. This overrides entries in org/aspectj/weaver/XlintDefault.properties from
* aspectjtools.jar, but does not override levels set using the -Xlintfile option.
*
* -Xlintfile PropertyFile
*
* Specify properties file to set levels for specific crosscutting messages. PropertyFile is a path to a
* Java .properties file that takes the same property names and values as
* org/aspectj/weaver/XlintDefault.properties from aspectjtools.jar, which it also overrides.
* -help
*
* Emit information on compiler options and usage
*
* -version
*
* Emit the version of the AspectJ compiler
*
* -classpath Path
*
* Specify where to find user class files. Path is a single argument containing a list of paths to zip files
* or directories, delimited by the platform-specific path delimiter.
*
* -bootclasspath Path
*
* Override location of VM's bootclasspath for purposes of evaluating types when compiling. Path is a single
* argument containing a list of paths to zip files or directories, delimited by the platform-specific path
* delimiter.
*
* -extdirs Path
*
* Override location of VM's extension directories for purposes of evaluating types when compiling. Path is
* a single argument containing a list of paths to directories, delimited by the platform-specific path
* delimiter.
*
* -d Directory
*
* Specify where to place generated .class files. If not specified, Directory defaults to the current
* working dir.
*
* -target [1.1|1.2]
*
* Specify classfile target setting (1.1 or 1.2, default is 1.1)
*
* -1.3
*
* Set compliance level to 1.3 (default)
* -1.4
*
* Set compliance level to 1.4
* -source [1.3|1.4]
*
* Toggle assertions (1.3 or 1.4, default is 1.3 in -1.3 mode and 1.4 in -1.4 mode). When using -source 1.3,
* an assert() statement valid under Java 1.4 will result in a compiler error. When using -source 1.4, treat
* assert as a keyword and implement assertions according to the 1.4 language spec.
*
* -nowarn
*
* Emit no warnings (equivalent to '-warn:none') This does not suppress messages generated by declare warning
* or Xlint.
*
* -warn: items
*
* Emit warnings for any instances of the comma-delimited list of questionable code
* (eg '-warn:unusedLocals,deprecation'):
*
* constructorName method with constructor name
* packageDefaultMethod attempt to override package-default method
* deprecation usage of deprecated type or member
* maskedCatchBlocks hidden catch block
* unusedLocals local variable never read
* unusedArguments method argument never read
* unusedImports import statement not used by code in file
* none suppress all compiler warnings
*
*
* -warn:none does not suppress messages generated by declare warning or Xlint.
*
* -deprecation
*
* Same as -warn:deprecation
*
* -noImportError
*
* Emit no errors for unresolved imports
*
* -proceedOnError
*
* Keep compiling after error, dumping class files with problem methods
*
* -g:[lines,vars,source]
*
* debug attributes level, that may take three forms:
*
* -g all debug info ('-g:lines,vars,source')
* -g:none no debug info
* -g:{items} debug info for any/all of [lines, vars, source], e.g.,
* -g:lines,source
*
*
* -preserveAllLocals
*
* Preserve all local variables during code generation (to facilitate debugging).
*
* -referenceInfo
*
* Compute reference information.
*
* -encoding format
*
* Specify default source encoding format. Specify custom encoding on a per file basis by suffixing each
* input source file/folder name with '[encoding]'.
*
* -verbose
*
* Emit messages about accessed/processed compilation units
*
* -log file
*
* Specify a log file for compiler messages.
* -progress
*
* Show progress (requires -log mode).
* -time
*
* Display speed information.
* -noExit
*
* Do not call System.exit(n) at end of compilation (n=0 if no error)
* -repeat N
*
* Repeat compilation process N times (typically to do performance analysis).
* -Xnoweave
*
* (Experimental) produce unwoven class files for input using -injars.
* -Xnoinline
*
* (Experimental) do not inline around advice
* -XincrementalFile file
*
* (Experimental) This works like incremental mode, but using a file rather than standard input to control
* the compiler. It will recompile each time file is changed and and halt when file is deleted.
*
* -XserializableAspects
*
* (Experimental) Normally it is an error to declare aspects Serializable. This option removes that restriction.
*
* @author Jason van Zyl
* @version $Id$
*/
public class AspectJCompiler
extends AbstractCompiler
{
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
public AspectJCompiler()
{
super( CompilerOutputStyle.ONE_OUTPUT_FILE_PER_INPUT_FILE, ".java", ".class", null );
}
public List compile( CompilerConfiguration config )
throws CompilerException
{
File destinationDir = new File( config.getOutputLocation() );
if ( !destinationDir.exists() )
{
destinationDir.mkdirs();
}
String[] sourceFiles = getSourceFiles( config );
if ( sourceFiles.length == 0 )
{
return Collections.emptyList();
}
System.out.println( "Compiling " + sourceFiles.length + " " + "source file"
+ ( sourceFiles.length == 1 ? "" : "s" ) + " to " + destinationDir.getAbsolutePath() );
// String[] args = buildCompilerArguments( config, sourceFiles );
AjBuildConfig buildConfig = buildCompilerConfig( config );
return compileInProcess( buildConfig );
}
private AjBuildConfig buildCompilerConfig( CompilerConfiguration config )
throws CompilerException
{
AjBuildConfig buildConfig = new AjBuildConfig();
buildConfig.setIncrementalMode( false );
String[] files = getSourceFiles( config );
if ( files != null )
{
buildConfig.setFiles( buildFileList( Arrays.asList( files ) ) );
}
setSourceVersion( buildConfig, config.getSourceVersion() );
if ( config.isDebug() )
{
buildConfig.getOptions().produceDebugAttributes = ClassFileConstants.ATTR_SOURCE + ClassFileConstants.ATTR_LINES
+ ClassFileConstants.ATTR_VARS;
}
Map javaOpts = config.getCustomCompilerArguments();
if ( javaOpts != null && !javaOpts.isEmpty() )
{
// TODO support customCompilerArguments
// buildConfig.setJavaOptions( javaOpts );
}
List cp = new LinkedList( config.getClasspathEntries() );
File javaHomeDir = new File( System.getProperty( "java.home" ) );
File[] jars = new File( javaHomeDir, "lib" ).listFiles();
if ( jars != null )
{
for ( File jar : jars )
{
if ( jar.getName().endsWith( ".jar" ) || jar.getName().endsWith( ".zip" ) )
{
cp.add( 0, jar.getAbsolutePath() );
}
}
}
jars = new File( javaHomeDir, "../Classes" ).listFiles();
if ( jars != null )
{
for ( File jar : jars )
{
if ( jar.getName().endsWith( ".jar" ) || jar.getName().endsWith( ".zip" ) )
{
cp.add( 0, jar.getAbsolutePath() );
}
}
}
checkForAspectJRT( cp );
if ( cp != null && !cp.isEmpty() )
{
List elements = new ArrayList( cp.size() );
for ( String path : cp )
{
elements.add( ( new File( path ) ).getAbsolutePath() );
}
buildConfig.setClasspath( elements );
}
String outputLocation = config.getOutputLocation();
if ( outputLocation != null )
{
File outDir = new File( outputLocation );
if ( !outDir.exists() )
{
outDir.mkdirs();
}
buildConfig.setOutputDir( outDir );
}
if ( config instanceof AspectJCompilerConfiguration )
{
AspectJCompilerConfiguration ajCfg = (AspectJCompilerConfiguration) config;
Map sourcePathResources = ajCfg.getSourcePathResources();
if ( sourcePathResources != null && !sourcePathResources.isEmpty() )
{
buildConfig.setSourcePathResources( sourcePathResources );
}
Map ajOptions = ajCfg.getAJOptions();
if ( ajOptions != null && !ajOptions.isEmpty() )
{
// TODO not supported
//buildConfig.setAjOptions( ajCfg.getAJOptions() );
}
List aspectPath = buildFileList( ajCfg.getAspectPath() );
if ( aspectPath != null && !aspectPath.isEmpty() )
{
buildConfig.setAspectpath( buildFileList( ajCfg.getAspectPath() ) );
}
List inJars = buildFileList( ajCfg.getInJars() );
if ( inJars != null && !inJars.isEmpty() )
{
buildConfig.setInJars( buildFileList( ajCfg.getInJars() ) );
}
List inPaths = buildFileList( ajCfg.getInPath() );
if ( inPaths != null && !inPaths.isEmpty() )
{
buildConfig.setInPath( buildFileList( ajCfg.getInPath() ) );
}
String outJar = ajCfg.getOutputJar();
if ( outJar != null )
{
buildConfig.setOutputJar( new File( ajCfg.getOutputJar() ) );
}
}
return buildConfig;
}
private List compileInProcess( AjBuildConfig buildConfig )
throws CompilerException
{
MessageHandler messageHandler = new MessageHandler();
AjBuildManager manager = new AjBuildManager( messageHandler );
try
{
manager.batchBuild( buildConfig, messageHandler );
}
catch ( AbortException e )
{
throw new CompilerException( "Unknown error while compiling", e );
}
catch ( IOException e )
{
throw new CompilerException( "Unknown error while compiling", e );
}
// We need the location of the maven so we have a couple of options
// here.
//
// The aspectjrt jar is something this component needs to function so we
// can either
// bake it into the plugin and retrieve it somehow or use a system
// property or we
// could pass in a set of parameters in a Map.
boolean errors = messageHandler.hasAnyMessage( IMessage.ERROR, true );
List messages = new ArrayList();
if ( errors )
{
IMessage[] errorMessages = messageHandler.getMessages( IMessage.ERROR, true );
for ( IMessage m : errorMessages )
{
ISourceLocation sourceLocation = m.getSourceLocation();
CompilerError error;
if ( sourceLocation == null )
{
error = new CompilerError( m.getMessage(), true );
}
else
{
error = new CompilerError( sourceLocation.getSourceFile().getPath(), true,
sourceLocation.getLine(), sourceLocation.getColumn(), sourceLocation
.getEndLine(), sourceLocation.getColumn(), m.getMessage() );
}
messages.add( error );
}
}
return messages;
}
private void checkForAspectJRT( List cp )
{
if ( cp == null || cp.isEmpty() )
{
throw new IllegalStateException( "AspectJ Runtime not found in supplied classpath" );
}
else
{
try
{
URL[] urls = new URL[cp.size()];
for ( int i = 0; i < urls.length; i++ )
{
urls[i] = ( new File( cp.get( i ) ) ).toURL();
}
URLClassLoader cloader = new URLClassLoader( urls );
cloader.loadClass( "org.aspectj.lang.JoinPoint" );
}
catch ( MalformedURLException e )
{
throw new IllegalArgumentException( "Invalid classpath entry" );
}
catch ( ClassNotFoundException e )
{
throw new IllegalStateException( "AspectJ Runtime not found in supplied classpath" );
}
}
}
private List buildFileList( List locations )
{
List fileList = new LinkedList();
for ( String location : locations )
{
fileList.add( new File( location ) );
}
return fileList;
}
/**
* Set the source version in ajc compiler
*
* @param buildConfig
* @param sourceVersion
*/
private void setSourceVersion( AjBuildConfig buildConfig, String sourceVersion )
throws CompilerException
{
if ( "1.7".equals( sourceVersion ) )
{
buildConfig.getOptions().sourceLevel = ClassFileConstants.JDK1_7;
}
else if ( "1.6".equals( sourceVersion ) )
{
buildConfig.getOptions().sourceLevel = ClassFileConstants.JDK1_6;
}
else if ( "1.5".equals( sourceVersion ) )
{
buildConfig.getOptions().sourceLevel = ClassFileConstants.JDK1_5;
}
else if ( "5.0".equals( sourceVersion ) )
{
buildConfig.getOptions().sourceLevel = ClassFileConstants.JDK1_5;
}
else if ( "1.4".equals( sourceVersion ) )
{
buildConfig.getOptions().sourceLevel = ClassFileConstants.JDK1_4;
}
else if ( "1.3".equals( sourceVersion ) )
{
buildConfig.getOptions().sourceLevel = ClassFileConstants.JDK1_3;
}
else if ( "1.2".equals( sourceVersion ) )
{
buildConfig.getOptions().sourceLevel = ClassFileConstants.JDK1_2;
}
else if ( "1.1".equals( sourceVersion ) )
{
buildConfig.getOptions().sourceLevel = ClassFileConstants.JDK1_1;
}
else if ( sourceVersion == null || sourceVersion.length() <= 0 )
{
buildConfig.getOptions().sourceLevel = ClassFileConstants.JDK1_3;
}
else
{
throw new CompilerException( "The source version was not recognized: " + sourceVersion );
}
}
/**
* @return null
*/
public String[] createCommandLine( CompilerConfiguration config )
throws CompilerException
{
return null;
}
}
AspectJCompilerConfiguration.java 0000664 0000000 0000000 00000005225 12022156743 0047346 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/main/java/org/codehaus/plexus/compiler/ajc /* Created on Oct 4, 2004 */
package org.codehaus.plexus.compiler.ajc;
import java.io.File;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.codehaus.plexus.compiler.CompilerConfiguration;
/**
* @author jdcasey
*/
public class AspectJCompilerConfiguration
extends CompilerConfiguration
{
private List aspectPath = new LinkedList();
private List inJars = new LinkedList();
private List inPath = new LinkedList();
private String outputJar;
private Map ajOptions = new TreeMap();
private Map sourcePathResources;
public void setAspectPath( List aspectPath )
{
this.aspectPath = new LinkedList( aspectPath );
}
public void addAspectPath( String aspectPath )
{
this.aspectPath.add( aspectPath );
}
public List getAspectPath()
{
return Collections.unmodifiableList( aspectPath );
}
public void setInJars( List inJars )
{
this.inJars = new LinkedList( inJars );
}
public void addInJar( String inJar )
{
this.inJars.add( inJar );
}
public List getInJars()
{
return Collections.unmodifiableList( inJars );
}
public void setInPath( List inPath )
{
this.inPath = new LinkedList( inPath );
}
public void addInPath( String inPath )
{
this.inPath.add( inPath );
}
public List getInPath()
{
return Collections.unmodifiableList( inPath );
}
public void setOutputJar( String outputJar )
{
this.outputJar = outputJar;
}
public String getOutputJar()
{
return outputJar;
}
/**
* Ignored, not supported yet
* @param ajOptions
*/
public void setAJOptions( Map ajOptions )
{
//TODO
//this.ajOptions = new TreeMap( ajOptions );
}
public void setAJOption( String optionName, String optionValue )
{
this.ajOptions.put( optionName, optionValue );
}
/**
* Ignored, not supported yet
* @return empty Map
*/
public Map getAJOptions()
{
return Collections.unmodifiableMap( ajOptions );
}
public void setSourcePathResources( Map sourcePathResources )
{
this.sourcePathResources = new TreeMap( sourcePathResources );
}
public Map getSourcePathResources()
{
return sourcePathResources;
}
} plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/site/ 0000775 0000000 0000000 00000000000 12022156743 0031630 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/site/site.xml 0000664 0000000 0000000 00000001126 12022156743 0033316 0 ustar 00root root 0000000 0000000
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/ 0000775 0000000 0000000 00000000000 12022156743 0033000 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/ 0000775 0000000 0000000 00000000000 12022156743 0033567 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034434 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main 0000775 0000000 0000000 00000000000 12022156743 0035223 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main/org 0000775 0000000 0000000 00000000000 12022156743 0037016 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0037601 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main/org/codehaus/foo Bad.class 0000664 0000000 0000000 00000000742 12022156743 0041321 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main/org/codehaus/foo Ęţşľ . org/codehaus/foo/Bad java/lang/Object ()V Code java/lang/Error žUnresolved compilation problems:
pubic cannot be resolved (or is not a valid type) for the field Bad.String
Syntax error on token "pubic", public expected
(Ljava/lang/String;)V
LineNumberTable LocalVariableTable this Lorg/codehaus/foo/Bad;
SourceFile Bad.java ! 4
» Y · ż
Bad.java 0000664 0000000 0000000 00000000161 12022156743 0041130 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class Bad
{
// Intentionally misspelled modifier.
pubic String name;
}
ExternalDeps.class 0000664 0000000 0000000 00000001211 12022156743 0043221 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main/org/codehaus/foo Ęţşľ . org/codehaus/foo/ExternalDeps java/lang/Object ()V Code java/lang/Error tUnresolved compilation problems:
The import org.apache.commons cannot be resolved
StringUtils cannot be resolved
(Ljava/lang/String;)V
LineNumberTable LocalVariableTable this Lorg/codehaus/foo/ExternalDeps; hello AUnresolved compilation problem:
StringUtils cannot be resolved
str Ljava/lang/String;
SourceFile ExternalDeps.java ! 4
» Y · ż
>
» Y· ż
ExternalDeps.java 0000664 0000000 0000000 00000000310 12022156743 0043034 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
import org.apache.commons.lang.StringUtils;
public class ExternalDeps
{
public void hello( String str )
{
System.out.println( StringUtils.upperCase( str) );
}
}
Person.class 0000664 0000000 0000000 00000000425 12022156743 0042077 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main/org/codehaus/foo Ęţşľ . org/codehaus/foo/Person java/lang/Object ()V Code
LineNumberTable LocalVariableTable this Lorg/codehaus/foo/Person;
SourceFile Person.java ! / *· ±
Person.java 0000664 0000000 0000000 00000000063 12022156743 0041711 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class Person
{
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test/ 0000775 0000000 0000000 00000000000 12022156743 0031643 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test/java/ 0000775 0000000 0000000 00000000000 12022156743 0032564 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0033353 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0035067 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test/java/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0036407 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test/java/org/codehaus/plexus 0000775 0000000 0000000 00000000000 12022156743 0040221 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0040756 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test/java/org/codehaus/plexus/compiler/ajc AspectJCompilerTest.java 0000664 0000000 0000000 00000002040 12022156743 0045501 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-aspectj/src/test/java/org/codehaus/plexus/compiler/ajc package org.codehaus.plexus.compiler.ajc;
import java.io.File;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.codehaus.plexus.compiler.AbstractCompilerTest;
/**
* @author Jason van Zyl
* @version $Id$
*/
public class AspectJCompilerTest
extends AbstractCompilerTest
{
public AspectJCompilerTest()
{
super();
}
protected String getRoleHint()
{
return "aspectj";
}
protected int expectedErrors()
{
return 1;
}
protected Collection expectedOutputFiles()
{
return Arrays.asList( new String[] { "org/codehaus/foo/ExternalDeps.class", "org/codehaus/foo/Person.class" } );
}
protected List getClasspath()
throws Exception
{
List cp = super.getClasspath();
File localArtifactPath = getLocalArtifactPath( "org.aspectj", "aspectjrt", "1.6.0", "jar" );
cp.add( localArtifactPath.getAbsolutePath() );
return cp;
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/ 0000775 0000000 0000000 00000000000 12022156743 0027724 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/pom.xml 0000664 0000000 0000000 00000001250 12022156743 0031237 0 ustar 00root root 0000000 0000000
4.0.0
org.codehaus.plexus
plexus-compilers
1.9.2
plexus-compiler-csharp
Plexus C# Compiler
org.codehaus.plexus
plexus-utils
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/ 0000775 0000000 0000000 00000000000 12022156743 0030513 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/main/ 0000775 0000000 0000000 00000000000 12022156743 0031437 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/main/java/ 0000775 0000000 0000000 00000000000 12022156743 0032360 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/main/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0033147 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034663 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/main/java/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0036203 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/main/java/org/codehaus/plexus 0000775 0000000 0000000 00000000000 12022156743 0040015 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/main/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0041275 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/main/java/org/codehaus/plexus/compiler/csharp CSharpCompiler.java 0000664 0000000 0000000 00000050366 12022156743 0045025 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/main/java/org/codehaus/plexus/compiler/csharp package org.codehaus.plexus.compiler.csharp;
/*
* Copyright 2005 The Apache Software Foundation.
*
* Licensed 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.
*/
import org.codehaus.plexus.compiler.AbstractCompiler;
import org.codehaus.plexus.compiler.CompilerConfiguration;
import org.codehaus.plexus.compiler.CompilerError;
import org.codehaus.plexus.compiler.CompilerException;
import org.codehaus.plexus.compiler.CompilerOutputStyle;
import org.codehaus.plexus.util.DirectoryScanner;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.Os;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.cli.CommandLineException;
import org.codehaus.plexus.util.cli.CommandLineUtils;
import org.codehaus.plexus.util.cli.Commandline;
import org.codehaus.plexus.util.cli.StreamConsumer;
import org.codehaus.plexus.util.cli.WriterStreamConsumer;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @author Gilles Dodinet
* @author Trygve Laugstøl
* @author Matthew Pocock
* @author Chris Stevenson
* @version $Id$
* @plexus.component role="org.codehaus.plexus.compiler.Compiler"
* role-hint="csharp"
*/
public class CSharpCompiler
extends AbstractCompiler
{
private static final String ARGUMENTS_FILE_NAME = "csharp-arguments";
private static final String[] DEFAULT_INCLUDES = {"**/**"};
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
public CSharpCompiler()
{
super( CompilerOutputStyle.ONE_OUTPUT_FILE_FOR_ALL_INPUT_FILES, ".cs", null, null );
}
// ----------------------------------------------------------------------
// Compiler Implementation
// ----------------------------------------------------------------------
public boolean canUpdateTarget( CompilerConfiguration configuration )
throws CompilerException
{
return false;
}
public String getOutputFile( CompilerConfiguration configuration )
throws CompilerException
{
return configuration.getOutputFileName() + "." + getTypeExtension( configuration );
}
public List compile( CompilerConfiguration config )
throws CompilerException
{
File destinationDir = new File( config.getOutputLocation() );
if ( !destinationDir.exists() )
{
destinationDir.mkdirs();
}
config.setSourceFiles( null );
String[] sourceFiles = CSharpCompiler.getSourceFiles( config );
if ( sourceFiles.length == 0 )
{
return Collections.emptyList();
}
System.out.println( "Compiling " + sourceFiles.length + " " + "source file" +
( sourceFiles.length == 1 ? "" : "s" ) + " to " + destinationDir.getAbsolutePath() );
String[] args = buildCompilerArguments( config, sourceFiles );
List messages;
if ( config.isFork() )
{
messages = compileOutOfProcess( config.getWorkingDirectory(), config.getBuildDirectory(),
findExecutable( config ), args );
}
else
{
throw new CompilerException( "This compiler doesn't support in-process compilation." );
}
return messages;
}
public String[] createCommandLine( CompilerConfiguration config )
throws CompilerException
{
return buildCompilerArguments( config, CSharpCompiler.getSourceFiles( config ) );
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
private String findExecutable( CompilerConfiguration config )
{
String executable = config.getExecutable();
if ( !StringUtils.isEmpty( executable ) )
{
return executable;
}
if ( Os.isFamily( "windows" ) )
{
return "csc";
}
return "mcs";
}
/*
$ mcs --help
Mono C# compiler, (C) 2001 - 2003 Ximian, Inc.
mcs [options] source-files
--about About the Mono C# compiler
-addmodule:MODULE Adds the module to the generated assembly
-checked[+|-] Set default context to checked
-codepage:ID Sets code page to the one in ID (number, utf8, reset)
-clscheck[+|-] Disables CLS Compliance verifications
-define:S1[;S2] Defines one or more symbols (short: /d:)
-debug[+|-], -g Generate debugging information
-delaysign[+|-] Only insert the public key into the assembly (no signing)
-doc:FILE XML Documentation file to generate
-keycontainer:NAME The key pair container used to strongname the assembly
-keyfile:FILE The strongname key file used to strongname the assembly
-langversion:TEXT Specifies language version modes: ISO-1 or Default
-lib:PATH1,PATH2 Adds the paths to the assembly link path
-main:class Specified the class that contains the entry point
-noconfig[+|-] Disables implicit references to assemblies
-nostdlib[+|-] Does not load core libraries
-nowarn:W1[,W2] Disables one or more warnings
-optimize[+|-] Enables code optimalizations
-out:FNAME Specifies output file
-pkg:P1[,Pn] References packages P1..Pn
-recurse:SPEC Recursively compiles the files in SPEC ([dir]/file)
-reference:ASS References the specified assembly (-r:ASS)
-target:KIND Specifies the target (KIND is one of: exe, winexe,
library, module), (short: /t:)
-unsafe[+|-] Allows unsafe code
-warnaserror[+|-] Treat warnings as errors
-warn:LEVEL Sets warning level (the highest is 4, the default is 2)
-help2 Show other help flags
Resources:
-linkresource:FILE[,ID] Links FILE as a resource
-resource:FILE[,ID] Embed FILE as a resource
-win32res:FILE Specifies Win32 resource file (.res)
-win32icon:FILE Use this icon for the output
@file Read response file for more options
Options can be of the form -option or /option
*/
private String[] buildCompilerArguments( CompilerConfiguration config, String[] sourceFiles )
throws CompilerException
{
List args = new ArrayList();
if ( config.isDebug() )
{
args.add( "/debug+" );
}
else
{
args.add( "/debug-" );
}
// config.isShowWarnings()
// config.getSourceVersion()
// config.getTargetVersion()
// config.getSourceEncoding()
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
for ( String element : config.getClasspathEntries() )
{
File f = new File( element );
if ( !f.isFile() )
{
continue;
}
args.add( "/reference:\"" + element + "\"" );
}
// ----------------------------------------------------------------------
// Main class
// ----------------------------------------------------------------------
Map compilerArguments = config.getCustomCompilerArguments();
String mainClass = compilerArguments.get( "-main" );
if ( !StringUtils.isEmpty( mainClass ) )
{
args.add( "/main:" + mainClass );
}
// ----------------------------------------------------------------------
// Xml Doc output
// ----------------------------------------------------------------------
String doc = compilerArguments.get( "-doc" );
if ( !StringUtils.isEmpty( doc ) )
{
args.add( "/doc:" +
new File( config.getOutputLocation(), config.getOutputFileName() + ".xml" ).getAbsolutePath() );
}
// ----------------------------------------------------------------------
// Xml Doc output
// ----------------------------------------------------------------------
String nowarn = compilerArguments.get( "-nowarn" );
if ( !StringUtils.isEmpty( nowarn ) )
{
args.add( "/nowarn:" + nowarn );
}
// ----------------------------------------------------------------------
// Out - Override output name, this is required for generating the unit test dll
// ----------------------------------------------------------------------
String out = compilerArguments.get( "-out" );
if ( !StringUtils.isEmpty( out ) )
{
args.add( "/out:" + new File( config.getOutputLocation(), out ).getAbsolutePath() );
}
else
{
args.add( "/out:" + new File( config.getOutputLocation(), getOutputFile( config ) ).getAbsolutePath() );
}
// ----------------------------------------------------------------------
// Resource File - compile in a resource file into the assembly being created
// ----------------------------------------------------------------------
String resourcefile = compilerArguments.get( "-resourcefile" );
if ( !StringUtils.isEmpty( resourcefile ) )
{
String resourceTarget = (String) compilerArguments.get( "-resourcetarget" );
args.add( "/res:" + new File( resourcefile ).getAbsolutePath() + "," + resourceTarget );
}
// ----------------------------------------------------------------------
// Target - type of assembly to produce, lib,exe,winexe etc...
// ----------------------------------------------------------------------
String target = compilerArguments.get( "-target" );
if ( StringUtils.isEmpty( target ) )
{
args.add( "/target:library" );
}
else
{
args.add( "/target:" + target );
}
// ----------------------------------------------------------------------
// remove MS logo from output (not applicable for mono)
// ----------------------------------------------------------------------
String nologo = compilerArguments.get( "-nologo" );
if ( !StringUtils.isEmpty( nologo ) )
{
args.add( "/nologo" );
}
// ----------------------------------------------------------------------
// add any resource files
// ----------------------------------------------------------------------
this.addResourceArgs( config, args );
// ----------------------------------------------------------------------
// add source files
// ----------------------------------------------------------------------
for ( String sourceFile : sourceFiles )
{
args.add( sourceFile );
}
return args.toArray( new String[args.size()] );
}
private void addResourceArgs( CompilerConfiguration config, List args )
{
File filteredResourceDir = this.findResourceDir( config );
if ( ( filteredResourceDir != null ) && filteredResourceDir.exists() )
{
DirectoryScanner scanner = new DirectoryScanner();
scanner.setBasedir( filteredResourceDir );
scanner.setIncludes( DEFAULT_INCLUDES );
scanner.addDefaultExcludes();
scanner.scan();
List includedFiles = Arrays.asList( scanner.getIncludedFiles() );
for ( String name : includedFiles )
{
File filteredResource = new File( filteredResourceDir, name );
String assemblyResourceName = this.convertNameToAssemblyResourceName( name );
String argLine = "/resource:\"" + filteredResource + "\",\"" + assemblyResourceName + "\"";
if ( config.isDebug() )
{
System.out.println( "adding resource arg line:" + argLine );
}
args.add( argLine );
}
}
}
private File findResourceDir( CompilerConfiguration config )
{
if ( config.isDebug() )
{
System.out.println( "Looking for resourcesDir" );
}
Map compilerArguments = config.getCustomCompilerArguments();
String tempResourcesDirAsString = (String) compilerArguments.get( "-resourceDir" );
File filteredResourceDir = null;
if ( tempResourcesDirAsString != null )
{
filteredResourceDir = new File( tempResourcesDirAsString );
if ( config.isDebug() )
{
System.out.println( "Found resourceDir at: " + filteredResourceDir.toString() );
}
}
else
{
if ( config.isDebug() )
{
System.out.println( "No resourceDir was available." );
}
}
return filteredResourceDir;
}
private String convertNameToAssemblyResourceName( String name )
{
return name.replace( File.separatorChar, '.' );
}
@SuppressWarnings( "deprecation" )
private List compileOutOfProcess( File workingDirectory, File target, String executable,
String[] args )
throws CompilerException
{
// ----------------------------------------------------------------------
// Build the @arguments file
// ----------------------------------------------------------------------
File file;
PrintWriter output = null;
try
{
file = new File( target, ARGUMENTS_FILE_NAME );
output = new PrintWriter( new FileWriter( file ) );
for ( String arg : args )
{
output.println( arg );
}
}
catch ( IOException e )
{
throw new CompilerException( "Error writing arguments file.", e );
}
finally
{
IOUtil.close( output );
}
// ----------------------------------------------------------------------
// Execute!
// ----------------------------------------------------------------------
Commandline cli = new Commandline();
cli.setWorkingDirectory( workingDirectory.getAbsolutePath() );
cli.setExecutable( executable );
cli.createArgument().setValue( "@" + file.getAbsolutePath() );
Writer stringWriter = new StringWriter();
StreamConsumer out = new WriterStreamConsumer( stringWriter );
StreamConsumer err = new WriterStreamConsumer( stringWriter );
int returnCode;
List messages;
try
{
returnCode = CommandLineUtils.executeCommandLine( cli, out, err );
messages = parseCompilerOutput( new BufferedReader( new StringReader( stringWriter.toString() ) ) );
}
catch ( CommandLineException e )
{
throw new CompilerException( "Error while executing the external compiler.", e );
}
catch ( IOException e )
{
throw new CompilerException( "Error while executing the external compiler.", e );
}
if ( returnCode != 0 && messages.isEmpty() )
{
// TODO: exception?
messages.add( new CompilerError(
"Failure executing the compiler, but could not parse the error:" + EOL + stringWriter.toString(),
true ) );
}
return messages;
}
public static List parseCompilerOutput( BufferedReader bufferedReader )
throws IOException
{
List messages = new ArrayList();
String line = bufferedReader.readLine();
while ( line != null )
{
CompilerError compilerError = DefaultCSharpCompilerParser.parseLine( line );
if ( compilerError != null )
{
messages.add( compilerError );
}
line = bufferedReader.readLine();
}
return messages;
}
private String getType( Map compilerArguments )
{
String type = compilerArguments.get( "-target" );
if ( StringUtils.isEmpty( type ) )
{
return "library";
}
return type;
}
private String getTypeExtension( CompilerConfiguration configuration )
throws CompilerException
{
String type = getType( configuration.getCustomCompilerArguments() );
if ( "exe".equals( type ) || "winexe".equals( type ) )
{
return "exe";
}
if ( "library".equals( type ) || "module".equals( type ) )
{
return "dll";
}
throw new CompilerException( "Unrecognized type '" + type + "'." );
}
// added for debug purposes....
protected static String[] getSourceFiles( CompilerConfiguration config )
{
Set sources = new HashSet();
//Set sourceFiles = null;
//was:
Set sourceFiles = config.getSourceFiles();
if ( sourceFiles != null && !sourceFiles.isEmpty() )
{
for ( File sourceFile : sourceFiles )
{
sources.add( sourceFile.getAbsolutePath() );
}
}
else
{
for ( String sourceLocation : config.getSourceLocations() )
{
sources.addAll( getSourceFilesForSourceRoot( config, sourceLocation ) );
}
}
String[] result;
if ( sources.isEmpty() )
{
result = new String[0];
}
else
{
result = (String[]) sources.toArray( new String[sources.size()] );
}
return result;
}
/**
* This method is just here to maintain the public api. This is now handled in the parse
* compiler output function.
*
* @author Chris Stevenson
* @deprecated
*/
public static CompilerError parseLine( String line )
{
return DefaultCSharpCompilerParser.parseLine( line );
}
protected static Set getSourceFilesForSourceRoot( CompilerConfiguration config, String sourceLocation )
{
DirectoryScanner scanner = new DirectoryScanner();
scanner.setBasedir( sourceLocation );
Set includes = config.getIncludes();
if ( includes != null && !includes.isEmpty() )
{
String[] inclStrs = includes.toArray( new String[includes.size()] );
scanner.setIncludes( inclStrs );
}
else
{
scanner.setIncludes( new String[]{"**/*.cs"} );
}
Set excludes = config.getExcludes();
if ( excludes != null && !excludes.isEmpty() )
{
String[] exclStrs = excludes.toArray( new String[excludes.size()] );
scanner.setIncludes( exclStrs );
}
scanner.scan();
String[] sourceDirectorySources = scanner.getIncludedFiles();
Set sources = new HashSet();
for ( String source : sourceDirectorySources )
{
File f = new File( sourceLocation, source );
sources.add( f.getPath() );
}
return sources;
}
}
DefaultCSharpCompilerParser.java 0000664 0000000 0000000 00000012177 12022156743 0047505 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/main/java/org/codehaus/plexus/compiler/csharp package org.codehaus.plexus.compiler.csharp;
import org.codehaus.plexus.compiler.CompilerError;
import org.codehaus.plexus.util.StringUtils;
/**
* Handles output from both mono with only the line number
*
* ex error = "/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./TestRunnerThread.cs(29) error CS0246: Cannot find type 'NameValueCollection'"
*
* and errors from mono & csc on windows which has column num also
*
* ex error = "src\\test\\csharp\\Hierarchy\\Logger.cs(98,4): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'";
*
* @author Gilles Dodinet
* @author Trygve Laugstøl
* @author Matthew Pocock
* @author Chris Stevenson
*/
public class DefaultCSharpCompilerParser
{
private static String ERROR_PREFIX = "error ";
private static String COMPILATION_PREFIX = "Compilation ";
private static String MAGIC_LINE_MARKER = ".cs(";
private static String MAGIC_LINE_MARKER_2 = ")";
public static CompilerError parseLine( String line )
{
CompilerError ce = null;
if ( isOutputWithNoColumnNumber( line ) )
{
ce = parseLineWithNoColumnNumber( line );
}
else
{
ce = parseLineWithColumnNumberAndLineNumber( line );
}
return ce;
}
private static boolean isOutputWithNoColumnNumber( String line )
{
int i = line.indexOf( MAGIC_LINE_MARKER );
if ( i == -1 )
{
return true;
}
String chunk1 = line.substring( i + MAGIC_LINE_MARKER.length() );
int j = chunk1.indexOf( MAGIC_LINE_MARKER_2 );
String chunk2 = chunk1.substring( 0, j );
return ( chunk2.indexOf( "," ) == -1 );
}
private static CompilerError parseLineWithNoColumnNumber( String line )
{
String file = null;
boolean error = true;
int startline = -1;
int startcolumn = -1;
int endline = -1;
int endcolumn = -1;
String message;
if ( line.startsWith( ERROR_PREFIX ) )
{
message = line.substring( ERROR_PREFIX.length() );
}
else if ( line.startsWith( COMPILATION_PREFIX ) )
{
// ignore
return null;
}
else if ( line.indexOf( MAGIC_LINE_MARKER ) != -1 )
{
int i = line.indexOf( MAGIC_LINE_MARKER );
int j = line.indexOf( ' ', i );
file = line.substring( 0, i + 3 );
String num = line.substring( i + MAGIC_LINE_MARKER.length(), j - 1 );
startline = Integer.parseInt( num );
endline = startline;
message = line.substring( j + 1 + ERROR_PREFIX.length() );
error = line.indexOf( ") error" ) != -1;
}
else
{
System.err.println( "Unknown output: " + line );
return null;
}
return new CompilerError( file, error, startline, startcolumn, endline, endcolumn, message );
}
private static CompilerError parseLineWithColumnNumberAndLineNumber( String line )
{
String file = null;
boolean error = true;
int startline = -1;
int startcolumn = -1;
int endline = -1;
int endcolumn = -1;
String message;
if ( line.startsWith( ERROR_PREFIX ) )
{
message = line.substring( ERROR_PREFIX.length() );
}
else if ( line.startsWith( COMPILATION_PREFIX ) )
{
return null;
}
else if ( line.indexOf( MAGIC_LINE_MARKER ) != -1 )
{
int i = line.indexOf( MAGIC_LINE_MARKER );
int j = line.indexOf( ' ', i );
file = line.substring( 0, i + 3 );
String linecol = line.substring( i + MAGIC_LINE_MARKER.length(), j - 2 );
String linenum = null;
String colnum = null;
if ( linecol.indexOf( "," ) > -1 && linecol.split( "," ).length == 2 )
{
linenum = linecol.split( "," )[0];
colnum = linecol.split( "," )[1];
}
else if ( linecol.split( "," ).length == 1 )
{
linenum = linecol.split( "," )[0];
colnum = "-1";
}
else
{
linenum = linecol.trim();
colnum = "-1";
}
startline = StringUtils.isEmpty( linenum ) ? -1 : Integer.parseInt( linenum );
startcolumn = StringUtils.isEmpty( colnum ) ? -1 : Integer.parseInt( colnum );
endline = startline;
endcolumn = startcolumn;
message = line.substring( j + 1 + ERROR_PREFIX.length() );
error = line.indexOf( "): error" ) != -1;
}
else
{
System.err.println( "Unknown output: " + line );
return null;
}
return new CompilerError( file, error, startline, startcolumn, endline, endcolumn, message );
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/site/ 0000775 0000000 0000000 00000000000 12022156743 0031457 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/site/site.xml 0000664 0000000 0000000 00000001126 12022156743 0033145 0 ustar 00root root 0000000 0000000
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/test/ 0000775 0000000 0000000 00000000000 12022156743 0031472 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/test/java/ 0000775 0000000 0000000 00000000000 12022156743 0032413 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/test/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0033202 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034716 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/test/java/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0036236 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/test/java/org/codehaus/plexus 0000775 0000000 0000000 00000000000 12022156743 0040050 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/test/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0041330 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/test/java/org/codehaus/plexus/compiler/csharp CSharpCompilerTest.java 0000664 0000000 0000000 00000031710 12022156743 0045710 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-csharp/src/test/java/org/codehaus/plexus/compiler/csharp package org.codehaus.plexus.compiler.csharp;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import junit.framework.TestCase;
import org.codehaus.plexus.compiler.CompilerError;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.List;
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public class CSharpCompilerTest
extends TestCase
{
public void testParser()
throws IOException
{
CompilerError error;
// ----------------------------------------------------------------------
// Test a few concrete lines
// ----------------------------------------------------------------------
error = DefaultCSharpCompilerParser.parseLine( "error CS2008: No files to compile were specified" );
assertNotNull( error );
assertEquals( "CS2008: No files to compile were specified", error.getMessage() );
error = DefaultCSharpCompilerParser.parseLine( "Compilation failed: 1 error(s), 0 warnings" );
assertNull( error );
error = DefaultCSharpCompilerParser.parseLine( "Compilation succeeded - 2 warning(s)" );
assertNull( error );
error = DefaultCSharpCompilerParser.parseLine(
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./TestRunnerThread.cs(29) error CS0246: Cannot find type 'NameValueCollection'" );
assertNotNull( error );
assertEquals( 29, error.getStartLine() );
assertEquals( -1, error.getStartColumn() );
assertEquals( 29, error.getEndLine() );
assertEquals( -1, error.getEndColumn() );
assertEquals( "CS0246: Cannot find type 'NameValueCollection'", error.getMessage() );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
String input =
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./TestRunnerThread.cs(5) error CS0234: The type or namespace name `Specialized' could not be found in namespace `System.Collections'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./TestRunnerThread.cs(29) error CS0246: Cannot find type 'NameValueCollection'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./Reflect.cs(4) error CS0234: The type or namespace name `Framework' could not be found in namespace `NUnit'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./Reflect.cs(123) error CS0246: Cannot find type 'TestFixtureAttribute'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./Reflect.cs(129) error CS0246: Cannot find type 'TestAttribute'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./Reflect.cs(135) error CS0246: Cannot find type 'IgnoreAttribute'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./Reflect.cs(141) error CS0246: Cannot find type 'ExpectedExceptionAttribute'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./WarningSuite.cs(49) error CS0506: `NUnit.Core.WarningSuite.Add': cannot override inherited member `TestSuite.Add' because it is not virtual, abstract or override\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./WarningSuite.cs(49) error CS0507: `NUnit.Core.WarningSuite.Add': can't change the access modifiers when overriding inherited member `TestSuite.Add'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./WarningSuite.cs(56) error CS0115: 'NUnit.Core.WarningSuite.CreateNewSuite(System.Type)': no suitable methods found to override\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./TestRunnerThread.cs(5) error CS0234: The type or namespace name `Specialized' could not be found in namespace `System.Collections'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./TestRunnerThread.cs(5) error CS0246: The namespace `System.Collections.Specialized' can not be found (missing assembly reference?)\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./Reflect.cs(4) error CS0234: The type or namespace name `Framework' could not be found in namespace `NUnit'\n" +
"/home/trygvis/dev/com.myrealbox/trunk/mcs/nunit20/core/./Reflect.cs(4) error CS0246: The namespace `NUnit.Framework' can not be found (missing assembly reference?)\n" +
"Compilation failed: 14 error(s), 0 warnings";
List messages =
CSharpCompiler.parseCompilerOutput( new BufferedReader( new StringReader( input ) ) );
assertNotNull( messages );
assertEquals( 14, messages.size() );
}
public void testParserCscWin()
throws Exception
{
String cscWin =
"src\\test\\csharp\\Hierarchy\\Logger.cs(77,4): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'\n" +
"src\\test\\csharp\\Hierarchy\\Logger.cs(98,4): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'\n" +
"src\\test\\csharp\\Hierarchy\\Logger.cs(126,4): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'\n" +
"src\\test\\csharp\\Hierarchy\\Logger.cs(151,4): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'\n" +
"src\\test\\csharp\\Hierarchy\\Logger.cs(187,4): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'\n" +
"src\\test\\csharp\\Hierarchy\\Logger.cs(222,4): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'\n" +
"src\\test\\csharp\\Hierarchy\\Logger.cs(255,33): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'\n" +
"src\\test\\csharp\\Hierarchy\\Logger.cs(270,4): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'\n" +
"src\\test\\csharp\\Util\\PropertiesDictionaryTest.cs(56,4): warning CS0618: 'NUnit.Framework.Assertion' is obsolete: 'Use Assert class instead'\n" +
"src\\main\\csharp\\Flow\\Loader.cs(62,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly reference?)\n" +
"src\\main\\csharp\\Ctl\\Aspx\\AspxController.cs(18,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly\n" +
"src\\main\\csharp\\Transform\\XsltTransform.cs(78,11): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly\n" +
"src\\main\\csharp\\View\\DispatchedViewFactory.cs(20,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assemb\n" +
"src\\main\\csharp\\Flow\\ViewRegistry.cs(31,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly refere\n" +
"src\\main\\csharp\\Flow\\MasterFactory.cs(50,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly refer\n" +
"src\\main\\csharp\\Dispatcher.cs(152,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly reference?)\n" +
"src\\main\\csharp\\Flow\\MaverickContext.cs(43,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly ref\n" +
"src\\main\\csharp\\Transform\\DocumentTransform.cs(38,12): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assem\n" +
"src\\main\\csharp\\Flow\\CommandBase.cs(11,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly referen\n" +
"src\\main\\csharp\\Shunt\\LanguageShuntFactory.cs(47,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assemb\n" +
"src\\main\\csharp\\Shunt\\LanguageShuntFactory.cs(67,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assemb\n" +
"src\\main\\csharp\\Util\\PropertyPopulator.cs(19,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly r\n" +
"src\\main\\csharp\\Ctl\\ThrowawayForm.cs(30,27): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly refere\n" +
"src\\main\\csharp\\AssemblyInfo.cs(68,12): error CS0246: The type or namespace name 'log4net' could not be found (are you missing a using directive or an assembly reference?)\n";
List messagesWinCsc =
CSharpCompiler.parseCompilerOutput( new BufferedReader( new StringReader( cscWin ) ) );
assertNotNull( messagesWinCsc );
assertEquals( 24, messagesWinCsc.size() );
assertTrue( "Check that the line number is not -1",
( (CompilerError) messagesWinCsc.get( 0 ) ).getStartLine() != -1 );
assertTrue( "Check that the column number is not -1",
( (CompilerError) messagesWinCsc.get( 0 ) ).getStartColumn() != -1 );
}
public void testParserMonoWin()
throws Exception
{
String monoWin =
"C:\\Work\\SCM\\SVN\\javaforge\\maven-csharp\\trunk\\maverick-net\\src\\main\\csharp\\Ctl\\ThrowawayForm.cs(30,27): error CS0246: The type or namespace name `log4net' could not be found. Are you missing a using directive or an assembly reference? error CS0234: No such name or typespace log4net\n" +
"C:\\Work\\SCM\\SVN\\javaforge\\maven-csharp\\trunk\\maverick-net\\src\\main\\csharp\\Util\\PropertyPopulator.cs(19,27): error CS0246: The type or namespace name `log4net' could not be found. Are you missing a using directive or an assembly reference? error CS0234: No such name or typespace log4net\n" +
"C:\\Work\\SCM\\SVN\\javaforge\\maven-csharp\\trunk\\maverick-net\\src\\main\\csharp\\Flow\\ViewRegistry.cs(31,27): error CS0246: The type or namespace name `log4net' could not be found. Are you missing a using directive or an assembly reference? error CS0234: No such name or typespace log4net\n" +
"C:\\Work\\SCM\\SVN\\javaforge\\maven-csharp\\trunk\\maverick-net\\src\\main\\csharp\\Shunt\\LanguageShuntFactory.cs(47,27): error CS0246: The type or namespace name `log4net' could not be found. Are you missing a using directive or an assembly reference? error CS0234: No such name or typespace log4net\n" +
"C:\\Work\\SCM\\SVN\\javaforge\\maven-csharp\\trunk\\maverick-net\\src\\main\\csharp\\Shunt\\LanguageShuntFactory.cs(67,27): error CS0246: The type or namespace name `log4net' could not be found. Are you missing a using directive or an assembly reference? error CS0234: No such name or typespace log4net\n" +
"Compilation failed: 28 error(s), 0 warnings";
List messagesMonoWin = CSharpCompiler.parseCompilerOutput( new BufferedReader( new StringReader( monoWin ) ) );
assertNotNull( messagesMonoWin );
assertEquals( 5, messagesMonoWin.size() );
assertTrue( "Check that the line number is not -1",
( (CompilerError) messagesMonoWin.get( 0 ) ).getStartLine() != -1 );
assertTrue( "Check that the column number is not -1",
( (CompilerError) messagesMonoWin.get( 0 ) ).getStartColumn() != -1 );
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/ 0000775 0000000 0000000 00000000000 12022156743 0030070 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/pom.xml 0000664 0000000 0000000 00000002554 12022156743 0031413 0 ustar 00root root 0000000 0000000
4.0.0
org.codehaus.plexus
plexus-compilers
1.9.2
plexus-compiler-eclipse
Plexus Eclipse Compiler
org.codehaus.plexus
plexus-utils
org.eclipse.jdt
core
3.3.0-v_771
org.eclipse.core
resources
org.eclipse.core
runtime
org.eclipse.core
filesystem
org.eclipse
text
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/ 0000775 0000000 0000000 00000000000 12022156743 0030657 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/main/ 0000775 0000000 0000000 00000000000 12022156743 0031603 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/main/java/ 0000775 0000000 0000000 00000000000 12022156743 0032524 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/main/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0033313 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0035027 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/main/java/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0036347 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/main/java/org/codehaus/plexus 0000775 0000000 0000000 00000000000 12022156743 0040161 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/main/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0041605 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/main/java/org/codehaus/plexus/compiler/eclipse EclipseJavaCompiler.java 0000664 0000000 0000000 00000052077 12022156743 0046344 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/main/java/org/codehaus/plexus/compiler/eclipse package org.codehaus.plexus.compiler.eclipse;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import org.codehaus.plexus.compiler.AbstractCompiler;
import org.codehaus.plexus.compiler.CompilerConfiguration;
import org.codehaus.plexus.compiler.CompilerError;
import org.codehaus.plexus.compiler.CompilerException;
import org.codehaus.plexus.compiler.CompilerOutputStyle;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.StringUtils;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.internal.compiler.ClassFile;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.Compiler;
import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
import org.eclipse.jdt.internal.compiler.IProblemFactory;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
/**
* @plexus.component
* role="org.codehaus.plexus.compiler.Compiler"
* role-hint="eclipse"
*/
public class EclipseJavaCompiler
extends AbstractCompiler
{
public EclipseJavaCompiler()
{
super( CompilerOutputStyle.ONE_OUTPUT_FILE_PER_INPUT_FILE,
".java",
".class",
null );
}
// ----------------------------------------------------------------------
// Compiler Implementation
// ----------------------------------------------------------------------
public List compile( CompilerConfiguration config )
throws CompilerException
{
List errors = new LinkedList();
List classpathEntries = config.getClasspathEntries();
URL[] urls = new URL[ 1 + classpathEntries.size() ];
int i = 0;
try
{
urls[ i++ ] = new File( config.getOutputLocation() ).toURL();
for ( String entry : classpathEntries )
{
urls[ i++ ] = new File( entry ).toURL();
}
}
catch ( MalformedURLException e )
{
throw new CompilerException( "Error while converting the classpath entries to URLs.", e );
}
ClassLoader classLoader = new URLClassLoader( urls );
SourceCodeLocator sourceCodeLocator = new SourceCodeLocator( config.getSourceLocations() );
INameEnvironment env = new EclipseCompilerINameEnvironment( sourceCodeLocator,
classLoader,
errors );
IErrorHandlingPolicy policy = DefaultErrorHandlingPolicies.proceedWithAllProblems();
// ----------------------------------------------------------------------
// Build settings from configuration
// ----------------------------------------------------------------------
Map settings = new HashMap();
if ( config.isDebug() )
{
settings.put( CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.GENERATE );
settings.put( CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.GENERATE );
settings.put( CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.GENERATE );
}
if ( !config.isShowWarnings() )
{
// TODO: Implement. I'm not sure what value to pass - trygve
// settings.put( CompilerOptions.OPTION_SuppressWarnings, );
settings.put( CompilerOptions.OPTION_SuppressWarnings, CompilerOptions.ENABLED );
}
String sourceVersion = decodeVersion( config.getSourceVersion() );
if ( sourceVersion != null )
{
settings.put( CompilerOptions.OPTION_Source, sourceVersion );
}
String targetVersion = decodeVersion( config.getTargetVersion() );
if ( targetVersion != null )
{
settings.put( CompilerOptions.OPTION_TargetPlatform, targetVersion );
if ( config.isOptimize() )
{
settings.put( CompilerOptions.OPTION_Compliance, targetVersion );
}
}
if ( StringUtils.isNotEmpty( config.getSourceEncoding() ) )
{
settings.put( CompilerOptions.OPTION_Encoding, config.getSourceEncoding() );
}
if ( config.isShowDeprecation() )
{
settings.put( CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.WARNING );
}
else
{
settings.put( CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.IGNORE );
}
// ----------------------------------------------------------------------
// Set Eclipse-specific options
// ----------------------------------------------------------------------
settings.put( CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.GENERATE );
settings.put( CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.GENERATE );
// compiler-specific extra options override anything else in the config object...
Map extras = config.getCustomCompilerArguments();
if ( extras != null && !extras.isEmpty() )
{
settings.putAll( extras );
}
IProblemFactory problemFactory = new DefaultProblemFactory( Locale.getDefault() );
ICompilerRequestor requestor = new EclipseCompilerICompilerRequestor( config.getOutputLocation(),
errors );
List compilationUnits = new ArrayList();
for ( String sourceRoot : config.getSourceLocations() )
{
Set sources = getSourceFilesForSourceRoot( config, sourceRoot );
for ( String source : sources )
{
CompilationUnit unit = new CompilationUnit( source,
makeClassName( source, sourceRoot ),
errors, config.getSourceEncoding() );
compilationUnits.add( unit );
}
}
// ----------------------------------------------------------------------
// Compile!
// ----------------------------------------------------------------------
CompilerOptions options = new CompilerOptions( settings );
Compiler compiler = new Compiler( env, policy, options, requestor, problemFactory );
ICompilationUnit[] units = (ICompilationUnit[])
compilationUnits.toArray( new ICompilationUnit[ compilationUnits.size() ] );
compiler.compile( units );
return errors;
}
public String[] createCommandLine( CompilerConfiguration config )
throws CompilerException
{
return null;
}
private CompilerError handleError( String className, int line, int column, Object errorMessage )
{
if ( className.endsWith( ".java" ) )
{
className = className.substring( 0, className.lastIndexOf( '.' ) );
}
String fileName = className.replace( '.', File.separatorChar ) + ".java";
if ( column < 0 )
{
column = 0;
}
String message;
if ( errorMessage != null )
{
message = errorMessage.toString();
}
else
{
message = "No message";
}
return new CompilerError( fileName,
true,
line,
column,
line,
column,
message );
}
private CompilerError handleWarning( IProblem warning )
{
return new CompilerError( new String( warning.getOriginatingFileName() ),
false,
warning.getSourceLineNumber(),
warning.getSourceStart(),
warning.getSourceLineNumber(),
warning.getSourceEnd(),
warning.getMessage() );
}
private String decodeVersion( String versionSpec )
{
if ( StringUtils.isEmpty( versionSpec ) )
{
return null;
}
else if ( "1.1".equals( versionSpec ) )
{
return CompilerOptions.VERSION_1_1;
}
else if ( "1.2".equals( versionSpec ) )
{
return CompilerOptions.VERSION_1_2;
}
else if ( "1.3".equals( versionSpec ) )
{
return CompilerOptions.VERSION_1_3;
}
else if ( "1.4".equals( versionSpec ) )
{
return CompilerOptions.VERSION_1_4;
}
else if ( "1.5".equals( versionSpec ) )
{
return CompilerOptions.VERSION_1_5;
}
else if ( "1.6" .equals( versionSpec ) )
{
return CompilerOptions.VERSION_1_6;
}
else if ( "1.7".equals( versionSpec ) )
{
return CompilerOptions.VERSION_1_7;
}
else
{
getLogger().warn( "Unknown version '" + versionSpec + "', no version setting will be given to the compiler." );
return null;
}
}
// ----------------------------------------------------------------------
// Classes
// ----------------------------------------------------------------------
private class CompilationUnit
implements ICompilationUnit
{
private final String className;
private final String sourceFile;
private final String sourceEncoding;
private final List errors;
CompilationUnit( String sourceFile, String className, List errors )
{
this( sourceFile, className, errors, null );
}
CompilationUnit( String sourceFile, String className, List errors, String sourceEncoding )
{
this.className = className;
this.sourceFile = sourceFile;
this.errors = errors;
this.sourceEncoding = sourceEncoding;
}
public char[] getFileName()
{
String fileName = sourceFile;
int lastSeparator = fileName.lastIndexOf( File.separatorChar );
if ( lastSeparator > 0 )
{
fileName = fileName.substring( lastSeparator + 1 );
}
return fileName.toCharArray();
}
public char[] getContents()
{
try
{
return FileUtils.fileRead( sourceFile, sourceEncoding ).toCharArray();
}
catch ( FileNotFoundException e )
{
errors.add( handleError( className, -1, -1, e.getMessage() ) );
return null;
}
catch ( IOException e )
{
errors.add( handleError( className, -1, -1, e.getMessage() ) );
return null;
}
}
public char[] getMainTypeName()
{
int dot = className.lastIndexOf( '.' );
if ( dot > 0 )
{
return className.substring( dot + 1 ).toCharArray();
}
return className.toCharArray();
}
public char[][] getPackageName()
{
StringTokenizer izer = new StringTokenizer( className, "." );
char[][] result = new char[izer.countTokens() - 1][];
for ( int i = 0; i < result.length; i++ )
{
String tok = izer.nextToken();
result[ i ] = tok.toCharArray();
}
return result;
}
}
private class EclipseCompilerINameEnvironment
implements INameEnvironment
{
private SourceCodeLocator sourceCodeLocator;
private ClassLoader classLoader;
private List errors;
public EclipseCompilerINameEnvironment( SourceCodeLocator sourceCodeLocator,
ClassLoader classLoader,
List errors )
{
this.sourceCodeLocator = sourceCodeLocator;
this.classLoader = classLoader;
this.errors = errors;
}
public NameEnvironmentAnswer findType( char[][] compoundTypeName )
{
String result = "";
String sep = "";
for ( int i = 0; i < compoundTypeName.length; i++ )
{
result += sep;
result += new String( compoundTypeName[ i ] );
sep = ".";
}
return findType( result );
}
public NameEnvironmentAnswer findType( char[] typeName, char[][] packageName )
{
String result = "";
String sep = "";
for ( int i = 0; i < packageName.length; i++ )
{
result += sep;
result += new String( packageName[ i ] );
sep = ".";
}
result += sep;
result += new String( typeName );
return findType( result );
}
private NameEnvironmentAnswer findType( String className )
{
try
{
File f = sourceCodeLocator.findSourceCodeForClass( className );
if ( f != null )
{
ICompilationUnit compilationUnit = new CompilationUnit( f.getAbsolutePath(),
className,
errors);
return new NameEnvironmentAnswer( compilationUnit, null );
}
String resourceName = className.replace( '.', '/' ) + ".class";
InputStream is = classLoader.getResourceAsStream( resourceName );
if ( is == null )
{
return null;
}
byte[] classBytes = IOUtil.toByteArray( is );
char[] fileName = className.toCharArray();
ClassFileReader classFileReader = new ClassFileReader( classBytes, fileName, true );
return new NameEnvironmentAnswer( classFileReader, null );
}
catch ( IOException e )
{
errors.add( handleError( className, -1, -1, e.getMessage() ) );
return null;
}
catch ( ClassFormatException e )
{
errors.add( handleError( className, -1, -1, e.getMessage() ) );
return null;
}
}
private boolean isPackage( String result )
{
if ( sourceCodeLocator.findSourceCodeForClass( result ) != null )
{
return false;
}
String resourceName = "/" + result.replace( '.', '/' ) + ".class";
InputStream is = classLoader.getResourceAsStream( resourceName );
return is == null;
}
public boolean isPackage( char[][] parentPackageName,
char[] packageName )
{
String result = "";
String sep = "";
if ( parentPackageName != null )
{
for ( int i = 0; i < parentPackageName.length; i++ )
{
result += sep;
result += new String( parentPackageName[ i ] );
sep = ".";
}
}
if ( Character.isUpperCase( packageName[ 0 ] ) )
{
return false;
}
String str = new String( packageName );
result += sep;
result += str;
return isPackage( result );
}
public void cleanup()
{
// nothing to do
}
}
private class EclipseCompilerICompilerRequestor
implements ICompilerRequestor
{
private String destinationDirectory;
private List errors;
public EclipseCompilerICompilerRequestor( String destinationDirectory,
List errors )
{
this.destinationDirectory = destinationDirectory;
this.errors = errors;
}
public void acceptResult( CompilationResult result )
{
boolean hasErrors = false;
if ( result.hasProblems() )
{
IProblem[] problems = result.getProblems();
for ( IProblem problem : problems )
{
String name = new String( problem.getOriginatingFileName() );
if ( problem.isWarning() )
{
errors.add( handleWarning( problem ) );
}
else
{
hasErrors = true;
errors.add( handleError( name,
problem.getSourceLineNumber(),
-1,
problem.getMessage() ) );
}
}
}
if ( !hasErrors )
{
ClassFile[] classFiles = result.getClassFiles();
for ( ClassFile classFile : classFiles )
{
char[][] compoundName = classFile.getCompoundName();
String className = "";
String sep = "";
for ( int j = 0; j < compoundName.length; j++ )
{
className += sep;
className += new String( compoundName[ j ] );
sep = ".";
}
byte[] bytes = classFile.getBytes();
File outFile = new File( destinationDirectory, className.replace( '.', '/' ) + ".class" );
if ( !outFile.getParentFile().exists() )
{
outFile.getParentFile().mkdirs();
}
FileOutputStream fout = null;
try
{
fout = new FileOutputStream( outFile );
fout.write( bytes );
}
catch ( FileNotFoundException e )
{
errors.add( handleError( className, -1, -1, e.getMessage() ) );
}
catch ( IOException e )
{
errors.add( handleError( className, -1, -1, e.getMessage() ) );
}
finally
{
IOUtil.close( fout );
}
}
}
}
}
}
SourceCodeLocator.java 0000664 0000000 0000000 00000004426 12022156743 0046035 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/main/java/org/codehaus/plexus/compiler/eclipse package org.codehaus.plexus.compiler.eclipse;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.io.File;
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public class SourceCodeLocator
{
private List sourceRoots;
private Map cache;
public SourceCodeLocator( List sourceRoots )
{
this.sourceRoots = sourceRoots;
cache = new HashMap();
}
public File findSourceCodeForClass( String className )
{
File f = cache.get( className );
if ( f != null )
{
return f;
}
String sourceName = className.replace( '.', System.getProperty( "file.separator" ).charAt( 0 ) );
sourceName += ".java";
f = findInRoots( sourceName );
cache.put( className, f );
return f;
}
private File findInRoots( String s )
{
for ( String root : sourceRoots )
{
File f = new File( root, s );
if ( f.exists() )
{
return f;
}
}
return null;
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/site/ 0000775 0000000 0000000 00000000000 12022156743 0031623 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/site/site.xml 0000664 0000000 0000000 00000001126 12022156743 0033311 0 ustar 00root root 0000000 0000000
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/ 0000775 0000000 0000000 00000000000 12022156743 0032773 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/ 0000775 0000000 0000000 00000000000 12022156743 0033562 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034427 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main 0000775 0000000 0000000 00000000000 12022156743 0035216 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org 0000775 0000000 0000000 00000000000 12022156743 0037011 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0037574 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org/codehaus/foo Bad.java 0000664 0000000 0000000 00000000161 12022156743 0041123 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class Bad
{
// Intentionally misspelled modifier.
pubic String name;
}
Deprecation.java 0000664 0000000 0000000 00000000177 12022156743 0042701 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class Deprecation
{
public Deprecation()
{
new java.util.Date("testDate");
}
}
ExternalDeps.java 0000664 0000000 0000000 00000000310 12022156743 0043027 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
import org.apache.commons.lang.StringUtils;
public class ExternalDeps
{
public void hello( String str )
{
System.out.println( StringUtils.upperCase( str) );
}
}
Person.java 0000664 0000000 0000000 00000000063 12022156743 0041704 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class Person
{
}
ReservedWord.java 0000664 0000000 0000000 00000000111 12022156743 0043043 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class ReservedWord
{
String assert;
}
UnknownSymbol.java 0000664 0000000 0000000 00000000160 12022156743 0043261 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class UnknownSymbol
{
public UnknownSymbol()
{
foo();
}
}
WrongClassname.java 0000664 0000000 0000000 00000000073 12022156743 0043362 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class RightClassname
{
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test/ 0000775 0000000 0000000 00000000000 12022156743 0031636 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test/java/ 0000775 0000000 0000000 00000000000 12022156743 0032557 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0033346 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0035062 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test/java/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0036402 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test/java/org/codehaus/plexus 0000775 0000000 0000000 00000000000 12022156743 0040214 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0041640 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test/java/org/codehaus/plexus/compiler/eclipse EclipseCompilerTckTest.java 0000664 0000000 0000000 00000002734 12022156743 0047072 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test/java/org/codehaus/plexus/compiler/eclipse package org.codehaus.plexus.compiler.eclipse;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.compiler.AbstractCompilerTckTest;
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public class EclipseCompilerTckTest
extends AbstractCompilerTckTest
{
public EclipseCompilerTckTest()
{
super( "eclipse" );
}
}
EclipseCompilerTest.java 0000664 0000000 0000000 00000004120 12022156743 0046417 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-eclipse/src/test/java/org/codehaus/plexus/compiler/eclipse package org.codehaus.plexus.compiler.eclipse;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.util.Arrays;
import java.util.Collection;
import org.codehaus.plexus.compiler.AbstractCompilerTest;
/**
* @author Jason van Zyl
* @version $Id$
*/
public class EclipseCompilerTest
extends AbstractCompilerTest
{
public void setUp()
throws Exception
{
super.setUp();
setCompilerDebug( true );
setCompilerDeprecationWarnings( true );
}
protected String getRoleHint()
{
return "eclipse";
}
protected int expectedErrors()
{
return 4;
}
protected int expectedWarnings()
{
return 2;
}
protected Collection expectedOutputFiles()
{
return Arrays.asList( new String[] { "org/codehaus/foo/Deprecation.class",
"org/codehaus/foo/ExternalDeps.class", "org/codehaus/foo/Person.class",
"org/codehaus/foo/ReservedWord.class" } );
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/ 0000775 0000000 0000000 00000000000 12022156743 0027530 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/pom.xml 0000664 0000000 0000000 00000001260 12022156743 0031044 0 ustar 00root root 0000000 0000000
4.0.0
org.codehaus.plexus
plexus-compilers
1.9.2
plexus-compiler-javac
Plexus Javac Component
org.codehaus.plexus
plexus-utils
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/ 0000775 0000000 0000000 00000000000 12022156743 0030317 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/main/ 0000775 0000000 0000000 00000000000 12022156743 0031243 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/main/java/ 0000775 0000000 0000000 00000000000 12022156743 0032164 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/main/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0032753 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034467 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0036007 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus 0000775 0000000 0000000 00000000000 12022156743 0037621 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0040705 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler/javac IsolatedClassLoader.java 0000664 0000000 0000000 00000004256 12022156743 0045440 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler/javac package org.codehaus.plexus.compiler.javac;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.net.URLClassLoader;
import java.net.URL;
public class IsolatedClassLoader
extends URLClassLoader
{
private ClassLoader parentClassLoader = ClassLoader.getSystemClassLoader();
public IsolatedClassLoader()
{
super( new URL[0], null );
}
public void addURL( URL url )
{
super.addURL( url );
}
public synchronized Class loadClass( String className )
throws ClassNotFoundException
{
Class c = findLoadedClass( className );
ClassNotFoundException ex = null;
if ( c == null )
{
try
{
c = findClass( className );
}
catch ( ClassNotFoundException e )
{
ex = e;
if ( parentClassLoader != null )
{
c = parentClassLoader.loadClass( className );
}
}
}
if ( c == null )
{
throw ex;
}
return c;
}
}
JavacCompiler.java 0000664 0000000 0000000 00000102653 12022156743 0044276 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/main/java/org/codehaus/plexus/compiler/javac package org.codehaus.plexus.compiler.javac;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/**
*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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.
*/
import org.codehaus.plexus.compiler.AbstractCompiler;
import org.codehaus.plexus.compiler.CompilerConfiguration;
import org.codehaus.plexus.compiler.CompilerError;
import org.codehaus.plexus.compiler.CompilerException;
import org.codehaus.plexus.compiler.CompilerOutputStyle;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.Os;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.cli.CommandLineException;
import org.codehaus.plexus.util.cli.CommandLineUtils;
import org.codehaus.plexus.util.cli.Commandline;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* @author Trygve Laugstøl
* @author Matthew Pocock
* @author Jörg Waßmer
* @author Others
* @version $Id$
* @plexus.component role="org.codehaus.plexus.compiler.Compiler"
* role-hint="javac"
*/
public class JavacCompiler
extends AbstractCompiler
{
// see compiler.warn.warning in compiler.properties of javac sources
private static final String[] WARNING_PREFIXES = { "warning: ", "\u8b66\u544a: ", "\u8b66\u544a\uff1a " };
// see compiler.note.note in compiler.properties of javac sources
private static final String[] NOTE_PREFIXES = { "Note: ", "\u6ce8: ", "\u6ce8\u610f\uff1a " };
private static final Object LOCK = new Object();
private static final String JAVAC_CLASSNAME = "com.sun.tools.javac.Main";
private static volatile Class JAVAC_CLASS;
private List> javaccClasses = new CopyOnWriteArrayList>();
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
public JavacCompiler()
{
super( CompilerOutputStyle.ONE_OUTPUT_FILE_PER_INPUT_FILE, ".java", ".class", null );
}
// ----------------------------------------------------------------------
// Compiler Implementation
// ----------------------------------------------------------------------
public List compile( CompilerConfiguration config )
throws CompilerException
{
File destinationDir = new File( config.getOutputLocation() );
if ( !destinationDir.exists() )
{
destinationDir.mkdirs();
}
String[] sourceFiles = getSourceFiles( config );
if ( ( sourceFiles == null ) || ( sourceFiles.length == 0 ) )
{
return Collections.emptyList();
}
if ( ( getLogger() != null ) && getLogger().isInfoEnabled() )
{
getLogger().info( "Compiling " + sourceFiles.length + " " +
"source file" + ( sourceFiles.length == 1 ? "" : "s" ) +
" to " + destinationDir.getAbsolutePath() );
}
String[] args = buildCompilerArguments( config, sourceFiles );
List messages;
if ( config.isFork() )
{
String executable = config.getExecutable();
if ( StringUtils.isEmpty( executable ) )
{
try
{
executable = getJavacExecutable();
}
catch ( IOException e )
{
getLogger().warn( "Unable to autodetect 'javac' path, using 'javac' from the environment." );
executable = "javac";
}
}
messages = compileOutOfProcess( config, executable, args );
}
else
{
messages = compileInProcess( args, config );
}
return messages;
}
public String[] createCommandLine( CompilerConfiguration config )
throws CompilerException
{
return buildCompilerArguments( config, getSourceFiles( config ) );
}
public static String[] buildCompilerArguments( CompilerConfiguration config, String[] sourceFiles )
{
List args = new ArrayList();
// ----------------------------------------------------------------------
// Set output
// ----------------------------------------------------------------------
File destinationDir = new File( config.getOutputLocation() );
args.add( "-d" );
args.add( destinationDir.getAbsolutePath() );
// ----------------------------------------------------------------------
// Set the class and source paths
// ----------------------------------------------------------------------
List classpathEntries = config.getClasspathEntries();
if ( classpathEntries != null && !classpathEntries.isEmpty() )
{
args.add( "-classpath" );
args.add( getPathString( classpathEntries ) );
}
List sourceLocations = config.getSourceLocations();
if ( sourceLocations != null && !sourceLocations.isEmpty() )
{
//always pass source path, even if sourceFiles are declared,
//needed for jsr269 annotation processing, see MCOMPILER-98
args.add( "-sourcepath" );
args.add( getPathString( sourceLocations ) );
}
args.addAll( Arrays.asList( sourceFiles ) );
if ( !isPreJava16( config ) )
{
//now add jdk 1.6 annotation processing related parameters
if ( config.getGeneratedSourcesDirectory() != null )
{
config.getGeneratedSourcesDirectory().mkdirs();
args.add( "-s" );
args.add( config.getGeneratedSourcesDirectory().getAbsolutePath() );
}
if ( config.getProc() != null )
{
args.add( "-proc:" + config.getProc() );
}
if ( config.getAnnotationProcessors() != null )
{
args.add( "-processor" );
String[] procs = config.getAnnotationProcessors();
StringBuilder buffer = new StringBuilder();
for ( int i = 0; i < procs.length; i++ )
{
if ( i > 0 )
{
buffer.append( "," );
}
buffer.append( procs[i] );
}
args.add( buffer.toString() );
}
}
if ( config.isOptimize() )
{
args.add( "-O" );
}
if ( config.isDebug() )
{
if ( StringUtils.isNotEmpty( config.getDebugLevel() ) )
{
args.add( "-g:" + config.getDebugLevel() );
}
else
{
args.add( "-g" );
}
}
if ( config.isVerbose() )
{
args.add( "-verbose" );
}
if ( config.isShowDeprecation() )
{
args.add( "-deprecation" );
// This is required to actually display the deprecation messages
config.setShowWarnings( true );
}
if ( !config.isShowWarnings() )
{
args.add( "-nowarn" );
}
// TODO: this could be much improved
if ( StringUtils.isEmpty( config.getTargetVersion() ) )
{
// Required, or it defaults to the target of your JDK (eg 1.5)
args.add( "-target" );
args.add( "1.1" );
}
else
{
args.add( "-target" );
args.add( config.getTargetVersion() );
}
if ( !suppressSource( config ) && StringUtils.isEmpty( config.getSourceVersion() ) )
{
// If omitted, later JDKs complain about a 1.1 target
args.add( "-source" );
args.add( "1.3" );
}
else if ( !suppressSource( config ) )
{
args.add( "-source" );
args.add( config.getSourceVersion() );
}
if ( !suppressEncoding( config ) && !StringUtils.isEmpty( config.getSourceEncoding() ) )
{
args.add( "-encoding" );
args.add( config.getSourceEncoding() );
}
for ( Map.Entry entry : config.getCustomCompilerArgumentsAsMap().entrySet() )
{
String key = entry.getKey();
if ( StringUtils.isEmpty( key ) || key.startsWith( "-J" ) )
{
continue;
}
args.add( key );
String value = entry.getValue();
if ( StringUtils.isEmpty( value ) )
{
continue;
}
args.add( value );
}
return (String[]) args.toArray( new String[args.size()] );
}
/**
* Determine if the compiler is a version prior to 1.4.
* This is needed as 1.3 and earlier did not support -source or -encoding parameters
*
* @param config The compiler configuration to test.
* @return true if the compiler configuration represents a Java 1.4 compiler or later, false otherwise
*/
private static boolean isPreJava14( CompilerConfiguration config )
{
String v = config.getCompilerVersion();
if ( v == null )
{
return false;
}
return v.startsWith( "1.3" ) || v.startsWith( "1.2" ) || v.startsWith( "1.1" ) || v.startsWith( "1.0" );
}
/**
* Determine if the compiler is a version prior to 1.6.
* This is needed for annotation processing parameters.
*
* @param config The compiler configuration to test.
* @return true if the compiler configuration represents a Java 1.6 compiler or later, false otherwise
*/
private static boolean isPreJava16( CompilerConfiguration config )
{
String v = config.getCompilerVersion();
if ( v == null )
{
//mkleint: i haven't completely understood the reason for the
//compiler version parameter, checking source as well, as most projects will have this one set, not the compiler
String s = config.getSourceVersion();
if ( s == null )
{
//now return true, as the 1.6 version is not the default - 1.4 is.
return true;
}
return s.startsWith( "1.5" ) || s.startsWith( "1.4" ) || s.startsWith( "1.3" ) || s.startsWith( "1.2" )
|| s.startsWith( "1.1" ) || s.startsWith( "1.0" );
}
return v.startsWith( "1.5" ) || v.startsWith( "1.4" ) || v.startsWith( "1.3" ) || v.startsWith( "1.2" )
|| v.startsWith( "1.1" ) || v.startsWith( "1.0" );
}
private static boolean suppressSource( CompilerConfiguration config )
{
return isPreJava14( config );
}
private static boolean suppressEncoding( CompilerConfiguration config )
{
return isPreJava14( config );
}
/**
* Compile the java sources in a external process, calling an external executable,
* like javac.
*
* @param config compiler configuration
* @param executable name of the executable to launch
* @param args arguments for the executable launched
* @return List of CompilerError objects with the errors encountered.
* @throws CompilerException
*/
List compileOutOfProcess( CompilerConfiguration config, String executable, String[] args )
throws CompilerException
{
Commandline cli = new Commandline();
cli.setWorkingDirectory( config.getWorkingDirectory().getAbsolutePath() );
cli.setExecutable( executable );
try
{
File argumentsFile = createFileWithArguments( args, config.getOutputLocation() );
cli.addArguments(
new String[]{ "@" + argumentsFile.getCanonicalPath().replace( File.separatorChar, '/' ) } );
if ( !StringUtils.isEmpty( config.getMaxmem() ) )
{
cli.addArguments( new String[]{ "-J-Xmx" + config.getMaxmem() } );
}
if ( !StringUtils.isEmpty( config.getMeminitial() ) )
{
cli.addArguments( new String[]{ "-J-Xms" + config.getMeminitial() } );
}
for ( String key : config.getCustomCompilerArgumentsAsMap().keySet() )
{
if ( StringUtils.isNotEmpty( key ) && key.startsWith( "-J" ) )
{
cli.addArguments( new String[]{ key } );
}
}
}
catch ( IOException e )
{
throw new CompilerException( "Error creating file with javac arguments", e );
}
CommandLineUtils.StringStreamConsumer out = new CommandLineUtils.StringStreamConsumer();
CommandLineUtils.StringStreamConsumer err = new CommandLineUtils.StringStreamConsumer();
int returnCode;
List messages;
if ( ( getLogger() != null ) && getLogger().isDebugEnabled() )
{
File commandLineFile =
new File( config.getOutputLocation(), "javac." + ( Os.isFamily( Os.FAMILY_WINDOWS ) ? "bat" : "sh" ) );
try
{
FileUtils.fileWrite( commandLineFile.getAbsolutePath(), cli.toString().replaceAll( "'", "" ) );
if ( !Os.isFamily( Os.FAMILY_WINDOWS ) )
{
Runtime.getRuntime().exec( new String[]{ "chmod", "a+x", commandLineFile.getAbsolutePath() } );
}
}
catch ( IOException e )
{
if ( ( getLogger() != null ) && getLogger().isWarnEnabled() )
{
getLogger().warn( "Unable to write '" + commandLineFile.getName() + "' debug script file", e );
}
}
}
try
{
returnCode = CommandLineUtils.executeCommandLine( cli, out, err );
messages = parseModernStream( returnCode, new BufferedReader( new StringReader( err.getOutput() ) ) );
}
catch ( CommandLineException e )
{
throw new CompilerException( "Error while executing the external compiler.", e );
}
catch ( IOException e )
{
throw new CompilerException( "Error while executing the external compiler.", e );
}
if ( ( returnCode != 0 ) && messages.isEmpty() )
{
if ( err.getOutput().length() == 0 )
{
throw new CompilerException(
"Unknown error trying to execute the external compiler: " + EOL + cli.toString() );
}
else
{
messages.add( new CompilerError(
"Failure executing javac, but could not parse the error:" + EOL + err.getOutput(), true ) );
}
}
return messages;
}
/**
* Compile the java sources in the current JVM, without calling an external executable,
* using com.sun.tools.javac.Main class
*
* @param args arguments for the compiler as they would be used in the command line javac
* @return List of CompilerError objects with the errors encountered.
* @throws CompilerException
*/
List compileInProcess( String[] args, CompilerConfiguration config )
throws CompilerException
{
final Class javacClass = getJavacClass( config );
final Thread thread = Thread.currentThread();
final ClassLoader contextClassLoader = thread.getContextClassLoader();
thread.setContextClassLoader( javacClass.getClassLoader() );
try
{
return compileInProcess0( javacClass, args );
}
finally
{
releaseJavaccClass( javacClass, config );
thread.setContextClassLoader( contextClassLoader );
}
}
/**
* Helper method for compileInProcess()
*/
private static List compileInProcess0( Class javacClass, String[] args )
throws CompilerException
{
StringWriter out = new StringWriter();
Integer ok;
List messages;
try
{
Method compile = javacClass.getMethod( "compile", new Class[]{ String[].class, PrintWriter.class } );
ok = (Integer) compile.invoke( null, new Object[]{ args, new PrintWriter( out ) } );
messages = parseModernStream( ok.intValue(), new BufferedReader( new StringReader( out.toString() ) ) );
}
catch ( NoSuchMethodException e )
{
throw new CompilerException( "Error while executing the compiler.", e );
}
catch ( IllegalAccessException e )
{
throw new CompilerException( "Error while executing the compiler.", e );
}
catch ( InvocationTargetException e )
{
throw new CompilerException( "Error while executing the compiler.", e );
}
catch ( IOException e )
{
throw new CompilerException( "Error while executing the compiler.", e );
}
if ( ( ok.intValue() != 0 ) && messages.isEmpty() )
{
// TODO: exception?
messages.add( new CompilerError( "Failure executing javac, but could not parse the error:" + EOL +
out.toString(), true ) );
}
return messages;
}
/**
* Parse the output from the compiler into a list of CompilerError objects
*
* @param exitCode The exit code of javac.
* @param input The output of the compiler
* @return List of CompilerError objects
* @throws IOException
*/
static List parseModernStream( int exitCode, BufferedReader input )
throws IOException
{
List errors = new ArrayList();
String line;
StringBuilder buffer;
while ( true )
{
// cleanup the buffer
buffer = new StringBuilder(); // this is quicker than clearing it
// most errors terminate with the '^' char
do
{
line = input.readLine();
if ( line == null )
{
return errors;
}
// TODO: there should be a better way to parse these
if ( ( buffer.length() == 0 ) && line.startsWith( "error: " ) )
{
errors.add( new CompilerError( line, true ) );
}
else if ( ( buffer.length() == 0 ) && isNote( line ) )
{
// skip, JDK 1.5 telling us deprecated APIs are used but -Xlint:deprecation isn't set
}
else
{
buffer.append( line );
buffer.append( EOL );
}
}
while ( !line.endsWith( "^" ) );
// add the error bean
errors.add( parseModernError( exitCode, buffer.toString() ) );
}
}
private static boolean isNote( String line )
{
for ( int i = 0; i < NOTE_PREFIXES.length; i++ )
{
if ( line.startsWith( NOTE_PREFIXES[i] ) )
{
return true;
}
}
return false;
}
/**
* Construct a CompilerError object from a line of the compiler output
*
* @param exitCode The exit code from javac.
* @param error output line from the compiler
* @return the CompilerError object
*/
static CompilerError parseModernError( int exitCode, String error )
{
StringTokenizer tokens = new StringTokenizer( error, ":" );
boolean isError = exitCode != 0;
StringBuilder msgBuffer;
try
{
// With Java 6 error output lines from the compiler got longer. For backward compatibility
// .. and the time being, we eat up all (if any) tokens up to the erroneous file and source
// .. line indicator tokens.
boolean tokenIsAnInteger;
String file = null;
String currentToken = null;
do
{
if ( currentToken != null )
{
if ( file == null )
{
file = currentToken;
}
else
{
file = file + ':' + currentToken;
}
}
currentToken = tokens.nextToken();
// Probably the only backward compatible means of checking if a string is an integer.
tokenIsAnInteger = true;
try
{
Integer.parseInt( currentToken );
}
catch ( NumberFormatException e )
{
tokenIsAnInteger = false;
}
}
while ( !tokenIsAnInteger );
String lineIndicator = currentToken;
int startOfFileName = file.lastIndexOf( ']' );
if ( startOfFileName > -1 )
{
file = file.substring( startOfFileName + 2 );
}
int line = Integer.parseInt( lineIndicator );
msgBuffer = new StringBuilder();
String msg = tokens.nextToken( EOL ).substring( 2 );
// Remove the 'warning: ' prefix
String warnPrefix = getWarnPrefix( msg );
if ( warnPrefix != null )
{
isError = false;
msg = msg.substring( warnPrefix.length() );
}
else
{
isError = exitCode != 0;
}
msgBuffer.append( msg );
msgBuffer.append( EOL );
String context = tokens.nextToken( EOL );
String pointer = tokens.nextToken( EOL );
if ( tokens.hasMoreTokens() )
{
msgBuffer.append( context ); // 'symbol' line
msgBuffer.append( EOL );
msgBuffer.append( pointer ); // 'location' line
msgBuffer.append( EOL );
context = tokens.nextToken( EOL );
try
{
pointer = tokens.nextToken( EOL );
}
catch ( NoSuchElementException e )
{
pointer = context;
context = null;
}
}
String message = msgBuffer.toString();
int startcolumn = pointer.indexOf( "^" );
int endcolumn = context == null ? startcolumn : context.indexOf( " ", startcolumn );
if ( endcolumn == -1 )
{
endcolumn = context.length();
}
return new CompilerError( file, isError, line, startcolumn, line, endcolumn, message.trim() );
}
catch ( NoSuchElementException e )
{
return new CompilerError( "no more tokens - could not parse error message: " + error, isError );
}
catch ( NumberFormatException e )
{
return new CompilerError( "could not parse error message: " + error, isError );
}
catch ( Exception e )
{
return new CompilerError( "could not parse error message: " + error, isError );
}
}
private static String getWarnPrefix( String msg )
{
for ( int i = 0; i < WARNING_PREFIXES.length; i++ )
{
if ( msg.startsWith( WARNING_PREFIXES[i] ) )
{
return WARNING_PREFIXES[i];
}
}
return null;
}
/**
* put args into a temp file to be referenced using the @ option in javac command line
*
* @param args
* @return the temporary file wth the arguments
* @throws IOException
*/
private File createFileWithArguments( String[] args, String outputDirectory )
throws IOException
{
PrintWriter writer = null;
try
{
File tempFile;
if ( ( getLogger() != null ) && getLogger().isDebugEnabled() )
{
tempFile =
File.createTempFile( JavacCompiler.class.getName(), "arguments", new File( outputDirectory ) );
}
else
{
tempFile = File.createTempFile( JavacCompiler.class.getName(), "arguments" );
tempFile.deleteOnExit();
}
writer = new PrintWriter( new FileWriter( tempFile ) );
for ( int i = 0; i < args.length; i++ )
{
String argValue = args[i].replace( File.separatorChar, '/' );
writer.write( "\"" + argValue + "\"" );
writer.println();
}
writer.flush();
return tempFile;
}
finally
{
if ( writer != null )
{
writer.close();
}
}
}
/**
* Get the path of the javac tool executable: try to find it depending the OS or the java.home
* system property or the JAVA_HOME environment variable.
*
* @return the path of the Javadoc tool
* @throws IOException if not found
*/
private static String getJavacExecutable()
throws IOException
{
String javacCommand = "javac" + ( Os.isFamily( Os.FAMILY_WINDOWS ) ? ".exe" : "" );
String javaHome = System.getProperty( "java.home" );
File javacExe;
if ( Os.isName( "AIX" ) )
{
javacExe = new File( javaHome + File.separator + ".." + File.separator + "sh", javacCommand );
}
else if ( Os.isName( "Mac OS X" ) )
{
javacExe = new File( javaHome + File.separator + "bin", javacCommand );
}
else
{
javacExe = new File( javaHome + File.separator + ".." + File.separator + "bin", javacCommand );
}
// ----------------------------------------------------------------------
// Try to find javacExe from JAVA_HOME environment variable
// ----------------------------------------------------------------------
if ( !javacExe.isFile() )
{
Properties env = CommandLineUtils.getSystemEnvVars();
javaHome = env.getProperty( "JAVA_HOME" );
if ( StringUtils.isEmpty( javaHome ) )
{
throw new IOException( "The environment variable JAVA_HOME is not correctly set." );
}
if ( !new File( javaHome ).isDirectory() )
{
throw new IOException(
"The environment variable JAVA_HOME=" + javaHome + " doesn't exist or is not a valid directory." );
}
javacExe = new File( env.getProperty( "JAVA_HOME" ) + File.separator + "bin", javacCommand );
}
if ( !javacExe.isFile() )
{
throw new IOException( "The javadoc executable '" + javacExe
+ "' doesn't exist or is not a file. Verify the JAVA_HOME environment variable." );
}
return javacExe.getAbsolutePath();
}
private void releaseJavaccClass( Class javaccClass, CompilerConfiguration compilerConfiguration )
{
if ( compilerConfiguration.getCompilerReuseStrategy()
== CompilerConfiguration.CompilerReuseStrategy.ReuseCreated )
{
javaccClasses.add( javaccClass );
}
}
/**
* Find the main class of JavaC. Return the same class for subsequent calls.
*
* @return the non-null class.
* @throws CompilerException if the class has not been found.
*/
private Class getJavacClass( CompilerConfiguration compilerConfiguration )
throws CompilerException
{
Class c = null;
switch ( compilerConfiguration.getCompilerReuseStrategy() )
{
case AlwaysNew:
return createJavacClass();
case ReuseCreated:
synchronized ( javaccClasses )
{
if ( javaccClasses.size() > 0 )
{
c = javaccClasses.get( 0 );
javaccClasses.remove( c );
return c;
}
}
c = createJavacClass();
return c;
case ReuseSame:
default:
c = JavacCompiler.JAVAC_CLASS;
if ( c != null )
{
return c;
}
synchronized ( JavacCompiler.LOCK )
{
if ( c == null )
{
JavacCompiler.JAVAC_CLASS = c = createJavacClass();
}
return c;
}
}
}
/**
* Helper method for create Javac class
*/
private Class createJavacClass()
throws CompilerException
{
try
{
// look whether JavaC is on Maven's classpath
//return Class.forName( JavacCompiler.JAVAC_CLASSNAME, true, JavacCompiler.class.getClassLoader() );
return JavacCompiler.class.getClassLoader().loadClass( JavacCompiler.JAVAC_CLASSNAME );
}
catch ( ClassNotFoundException ex )
{
// ok
}
final File toolsJar = new File( System.getProperty( "java.home" ), "../lib/tools.jar" );
if ( !toolsJar.exists() )
{
throw new CompilerException( "tools.jar not found: " + toolsJar );
}
try
{
final ClassLoader javacClassLoader =
new URLClassLoader( new URL[]{ toolsJar.toURI().toURL() }, JavacCompiler.class.getClassLoader() );
final Thread thread = Thread.currentThread();
final ClassLoader contextClassLoader = thread.getContextClassLoader();
thread.setContextClassLoader( javacClassLoader );
try
{
//return Class.forName( JavacCompiler.JAVAC_CLASSNAME, true, javacClassLoader );
return javacClassLoader.loadClass( JavacCompiler.JAVAC_CLASSNAME );
}
finally
{
thread.setContextClassLoader( contextClassLoader );
}
}
catch ( MalformedURLException ex )
{
throw new CompilerException(
"Could not convert the file reference to tools.jar to a URL, path to tools.jar: '"
+ toolsJar.getAbsolutePath() + "'.", ex );
}
catch ( ClassNotFoundException ex )
{
throw new CompilerException( "Unable to locate the Javac Compiler in:" + EOL + " " + toolsJar + EOL
+ "Please ensure you are using JDK 1.4 or above and" + EOL
+ "not a JRE (the com.sun.tools.javac.Main class is required)." + EOL
+ "In most cases you can change the location of your Java" + EOL
+ "installation by setting the JAVA_HOME environment variable.", ex );
}
}
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/site/ 0000775 0000000 0000000 00000000000 12022156743 0031263 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/site/site.xml 0000664 0000000 0000000 00000001126 12022156743 0032751 0 ustar 00root root 0000000 0000000
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/ 0000775 0000000 0000000 00000000000 12022156743 0032433 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/ 0000775 0000000 0000000 00000000000 12022156743 0033222 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034067 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main 0000775 0000000 0000000 00000000000 12022156743 0034656 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org 0000775 0000000 0000000 00000000000 12022156743 0036451 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0037234 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org/codehaus/foo Bad.java 0000664 0000000 0000000 00000000161 12022156743 0040563 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class Bad
{
// Intentionally misspelled modifier.
pubic String name;
}
Deprecation.java 0000664 0000000 0000000 00000000177 12022156743 0042341 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class Deprecation
{
public Deprecation()
{
new java.util.Date("testDate");
}
}
ExternalDeps.java 0000664 0000000 0000000 00000000311 12022156743 0042470 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
import org.apache.commons.lang.StringUtils;
public class ExternalDeps
{
public void hello( String str )
{
System.out.println( StringUtils.upperCase( str) );
}
}
Person.java 0000664 0000000 0000000 00000000063 12022156743 0041344 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class Person
{
}
ReservedWord.java 0000664 0000000 0000000 00000000111 12022156743 0042503 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class ReservedWord
{
String assert;
}
UnknownSymbol.java 0000664 0000000 0000000 00000000160 12022156743 0042721 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class UnknownSymbol
{
public UnknownSymbol()
{
foo();
}
}
WrongClassname.java 0000664 0000000 0000000 00000000073 12022156743 0043022 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test-input/src/main/org/codehaus/foo package org.codehaus.foo;
public class RightClassname
{
}
plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test/ 0000775 0000000 0000000 00000000000 12022156743 0031276 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test/java/ 0000775 0000000 0000000 00000000000 12022156743 0032217 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test/java/org/ 0000775 0000000 0000000 00000000000 12022156743 0033006 5 ustar 00root root 0000000 0000000 0000775 0000000 0000000 00000000000 12022156743 0034522 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test/java/org/codehaus 0000775 0000000 0000000 00000000000 12022156743 0036042 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test/java/org/codehaus/plexus 0000775 0000000 0000000 00000000000 12022156743 0037654 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test/java/org/codehaus/plexus/compiler 0000775 0000000 0000000 00000000000 12022156743 0040740 5 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test/java/org/codehaus/plexus/compiler/javac ErrorMessageParserTest.java 0000664 0000000 0000000 00000022421 12022156743 0046217 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test/java/org/codehaus/plexus/compiler/javac package org.codehaus.plexus.compiler.javac;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.List;
import junit.framework.TestCase;
import org.codehaus.plexus.compiler.CompilerError;
/**
* @author Trygve Laugstøl
* @version $Id$
*/
public class ErrorMessageParserTest
extends TestCase
{
private static final String EOL = System.getProperty( "line.separator" );
public void testDeprecationMessage()
throws Exception
{
String error = "target/compiler-src/testDeprecation/Foo.java:1: warning: Date(java.lang.String) in java.util.Date has been deprecated" + EOL +
"import java.util.Date;public class Foo{ private Date date = new Date( \"foo\");}" + EOL +
" ^" + EOL;
CompilerError compilerError = JavacCompiler.parseModernError( 0, error );
assertNotNull( compilerError );
assertFalse( compilerError.isError() );
assertEquals( "Date(java.lang.String) in java.util.Date has been deprecated", compilerError.getMessage() );
assertEquals( 63, compilerError.getStartColumn() );
assertEquals( 66, compilerError.getEndColumn() );
assertEquals( 1, compilerError.getStartLine() );
assertEquals( 1, compilerError.getEndLine() );
}
public void testWarningMessage()
{
String error = "target/compiler-src/testWarning/Foo.java:8: warning: finally clause cannot complete normally" + EOL +
" finally { return; }" + EOL +
" ^" + EOL;
CompilerError compilerError = JavacCompiler.parseModernError( 0, error );
assertNotNull( compilerError );
assertFalse( compilerError.isError() );
assertEquals( "finally clause cannot complete normally", compilerError.getMessage() );
assertEquals( 26, compilerError.getStartColumn() );
assertEquals( 27, compilerError.getEndColumn() );
assertEquals( 8, compilerError.getStartLine() );
assertEquals( 8, compilerError.getEndLine() );
}
public void testErrorMessage()
{
String error = "Foo.java:7: not a statement" + EOL +
" i;" + EOL +
" ^" + EOL;
CompilerError compilerError = JavacCompiler.parseModernError( 1, error );
assertNotNull( compilerError );
assertTrue( compilerError.isError() );
assertEquals( "not a statement", compilerError.getMessage() );
assertEquals( 9, compilerError.getStartColumn() );
assertEquals( 11, compilerError.getEndColumn() );
assertEquals( 7, compilerError.getStartLine() );
assertEquals( 7, compilerError.getEndLine() );
}
public void testUnknownSymbolError()
{
String error = "./org/codehaus/foo/UnknownSymbol.java:7: cannot find symbol" + EOL +
"symbol : method foo()" + EOL +
"location: class org.codehaus.foo.UnknownSymbol" + EOL +
" foo();" + EOL +
" ^" + EOL;
CompilerError compilerError = JavacCompiler.parseModernError( 1, error );
assertNotNull( compilerError );
assertTrue( compilerError.isError() );
assertEquals( "cannot find symbol" + EOL +
"symbol : method foo()" + EOL +
"location: class org.codehaus.foo.UnknownSymbol",
compilerError.getMessage()
);
assertEquals( 8, compilerError.getStartColumn() );
assertEquals( 14, compilerError.getEndColumn() );
assertEquals( 7, compilerError.getStartLine() );
assertEquals( 7, compilerError.getEndLine() );
}
public void testTwoErrors()
throws IOException
{
String errors = "./org/codehaus/foo/ExternalDeps.java:4: package org.apache.commons.lang does not exist" + EOL +
"import org.apache.commons.lang.StringUtils;" + EOL +
" ^" + EOL +
"./org/codehaus/foo/ExternalDeps.java:12: cannot find symbol" + EOL +
"symbol : variable StringUtils" + EOL +
"location: class org.codehaus.foo.ExternalDeps" + EOL +
" System.out.println( StringUtils.upperCase( str) );" + EOL +
" ^" + EOL +
"2 errors" + EOL;
List messages =
JavacCompiler.parseModernStream( 1, new BufferedReader( new StringReader( errors ) ) );
assertEquals( 2, messages.size() );
}
public void testAnotherTwoErrors()
throws IOException
{
String errors = "./org/codehaus/foo/ExternalDeps.java:4: package org.apache.commons.lang does not exist" + EOL +
"import org.apache.commons.lang.StringUtils;" + EOL +
" ^" + EOL +
"./org/codehaus/foo/ExternalDeps.java:12: cannot find symbol" + EOL +
"symbol : variable StringUtils" + EOL +
"location: class org.codehaus.foo.ExternalDeps" + EOL +
" System.out.println( StringUtils.upperCase( str) );" + EOL +
" ^" + EOL +
"2 errors" + EOL;
List messages =
JavacCompiler.parseModernStream( 1, new BufferedReader( new StringReader( errors ) ) );
assertEquals( 2, messages.size() );
}
public void testAssertError()
throws IOException
{
String errors = "./org/codehaus/foo/ReservedWord.java:5: as of release 1.4, 'assert' is a keyword, and may not be used as an identifier" + EOL +
"(try -source 1.3 or lower to use 'assert' as an identifier)" + EOL +
" String assert;" + EOL +
" ^" + EOL +
"1 error" + EOL;
List messages =
JavacCompiler.parseModernStream( 1, new BufferedReader( new StringReader( errors ) ) );
assertEquals( 1, messages.size() );
}
public void testLocalizedWarningNotTreatedAsError()
throws IOException
{
String errors = "./src/main/java/Main.java:9: \u8b66\u544a:[deprecation] java.io.File \u306e toURL() \u306f\u63a8\u5968\u3055\u308c\u307e\u305b\u3093\u3002" + EOL +
" new File( path ).toURL()" + EOL +
" ^" + EOL +
"\u8b66\u544a 1 \u500b" + EOL;
List messages =
JavacCompiler.parseModernStream( 0, new BufferedReader( new StringReader( errors ) ) );
assertEquals( 1, messages.size() );
assertFalse( ( (CompilerError) messages.get( 0 ) ).isError() );
}
public void testUnixFileNames()
{
String error = "/my/prj/src/main/java/test/prj/App.java:11: not a statement" + EOL +
" System.out.println( \"Hello World!\" );x" + EOL +
" ^" + EOL;
CompilerError compilerError = JavacCompiler.parseModernError( 1, error );
assertEquals( "/my/prj/src/main/java/test/prj/App.java:[11,45] not a statement", String.valueOf( compilerError ) );
}
public void testWindowsDriveLettersMCOMPILER140()
{
String error = "c:\\Documents and Settings\\My Self\\Documents\\prj\\src\\main\\java\\test\\prj\\App.java:11: not a statement" + EOL +
" System.out.println( \"Hello World!\" );x" + EOL +
" ^" + EOL;
CompilerError compilerError = JavacCompiler.parseModernError( 1, error );
assertEquals( "c:\\Documents and Settings\\My Self\\Documents\\prj\\src\\main\\java\\test\\prj\\App.java:[11,45] not a statement", String.valueOf( compilerError ) );
}
}
JavacCompilerTest.java 0000664 0000000 0000000 00000026200 12022156743 0045162 0 ustar 00root root 0000000 0000000 plexus-compiler-plexus-compiler-1.9.2/plexus-compilers/plexus-compiler-javac/src/test/java/org/codehaus/plexus/compiler/javac package org.codehaus.plexus.compiler.javac;
/**
* The MIT License
*
* Copyright (c) 2005, The Codehaus
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
import org.codehaus.plexus.compiler.AbstractCompilerTest;
import org.codehaus.plexus.compiler.CompilerConfiguration;
import org.codehaus.plexus.util.StringUtils;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
* @author Jason van Zyl
* @version $Id$
*/
public class JavacCompilerTest
extends AbstractCompilerTest
{
private static final String PS = File.pathSeparator;
public void setUp()
throws Exception
{
super.setUp();
setCompilerDebug( true );
setCompilerDeprecationWarnings( true );
}
protected String getRoleHint()
{
return "javac";
}
protected int expectedErrors()
{
String javaVersion = System.getProperty( "java.version" );
String realJavaVersion = javaVersion;
int dotIdx = javaVersion.indexOf( "." );
if ( dotIdx > -1 )
{
int lastDot = dotIdx;
// find the next dot, so we can trim up to this point.
dotIdx = javaVersion.indexOf( ".", lastDot + 1 );
if ( dotIdx > lastDot )
{
javaVersion = javaVersion.substring( 0, dotIdx );
}
}
System.out.println( "java.version is: " + realJavaVersion + "\ntrimmed java version is: "
+ javaVersion
+ "\ncomparison: \"1.5\".compareTo( \"" + javaVersion + "\" ) == "
+ ( "1.5".compareTo( javaVersion ) ) + "\n" );
// javac output changed for misspelled modifiers starting in 1.6...they now generate 2 errors per occurrence, not one.
if ( "1.5".compareTo( javaVersion ) < 0 )
{
return 4;
}
else
{
return 3;
}
}
protected int expectedWarnings()
{
return 2;
}
protected Collection expectedOutputFiles()
{
return Arrays.asList( new String[] { "org/codehaus/foo/Deprecation.class",
"org/codehaus/foo/ExternalDeps.class", "org/codehaus/foo/Person.class",
"org/codehaus/foo/ReservedWord.class" } );
}
public void internalTest( CompilerConfiguration compilerConfiguration, List expectedArguments )
{
String[] actualArguments = JavacCompiler.buildCompilerArguments( compilerConfiguration, new String[0] );
assertEquals( "The expected and actual argument list sizes differ.",
expectedArguments.size(),
actualArguments.length );
for ( int i = 0; i < actualArguments.length; i++ )
{
assertEquals( "Unexpected argument", expectedArguments.get(i), actualArguments[i] );
}
}
public void testBuildCompilerArgs13()
{
List expectedArguments = new ArrayList();
CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
compilerConfiguration.setCompilerVersion( "1.3" );
populateArguments( compilerConfiguration, expectedArguments, true, true );
internalTest( compilerConfiguration, expectedArguments );
}
public void testBuildCompilerArgs14()
{
List expectedArguments = new ArrayList();
CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
compilerConfiguration.setCompilerVersion( "1.4" );
populateArguments( compilerConfiguration, expectedArguments, false, false );
internalTest( compilerConfiguration, expectedArguments );
}
public void testBuildCompilerArgs15()
{
List expectedArguments = new ArrayList();
CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
compilerConfiguration.setCompilerVersion( "1.5" );
populateArguments( compilerConfiguration, expectedArguments, false, false );
internalTest( compilerConfiguration, expectedArguments );
}
public void testBuildCompilerArgsUnspecifiedVersion()
{
List expectedArguments = new ArrayList();
CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
populateArguments( compilerConfiguration, expectedArguments, false, false );
internalTest( compilerConfiguration, expectedArguments );
}
public void testBuildCompilerDebugLevel()
{
List expectedArguments = new ArrayList();
CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
compilerConfiguration.setDebug( true );
compilerConfiguration.setDebugLevel( "none" );
populateArguments( compilerConfiguration, expectedArguments, false, false );
internalTest( compilerConfiguration, expectedArguments );
}
// PLXCOMP-190
public void testJRuntimeArguments()
{
List expectedArguments = new ArrayList