| Attribute | + *Description | + *Required | + *
| srcdir | + *Location of the java files | + *Yes | + *
| instrumentdir | + *Indicates where the instrumented java and class files + * should go | + *Yes | + *
| repositorydir | + *Indicates where the repository java and class files should + * go | + *Yes | + *
| pre | + *Indicates whether or not to instrument for preconditions.
+ * Defaults to true |
+ * No | + *
| post | + *Indicates whether or not to instrument for postconditions.
+ * Defaults to true |
+ * No | + *
| invariant | + *Indicates whether or not to instrument for invariants.
+ * Defaults to true |
+ * No | + *
| failthrowable | + *The full name of the Throwable (Exception) that should be
+ * thrown when an assertion is violated. Defaults to java.lang.Error |
+ * No | + *
| controlfile | + *The name of the control file to pass to iContract. Default + * is to not pass a file | + *No | + *
| verbosity | + *Indicates the verbosity level of iContract. Any combination
+ * of error*,warning*,note*,info*,progress*,debug* (comma separated) can be
+ * used. Defaults to error*,warning* |
+ * No | + *
build.compiler property. See documentation for the Javac task for
+ * more information.
+ *
+ * Example:
+ * + *
+ * <!-- =================================================================== -->
+ * <!-- Instruments source codes with iContract -->
+ * <!-- =================================================================== -->
+ * <target name="instrument" depends="compile">
+ * <icontract
+ * srcdir="${build.src}"
+ * instrumentdir="${instrumented.dir}"
+ * repositorydir="${repository.dir}"
+ * >
+ * <classpath>
+ * <fileset dir="./lib">
+ * <include name="*.jar"/>
+ * </fileset>
+ * </classpath>
+ * </icontract>
+ * </target>
+ *
+ *
+ */
+public class IContract extends Task {
+
+ /** \ on windows, / on linux/unix */
+ private static final String ps = System.getProperty( "path.separator" );
+
+ /** compiler to use for instrumenation */
+ private String icCompiler = "javac";
+
+ /** temporary file with file names of all java files to be instrumented */
+ private File targets = null;
+
+ /** will be set to true if any of the sourca files are newer than the instrumented files */
+ private boolean dirty = false;
+
+ /** set to true if the iContract jar is missing */
+ private boolean iContractMissing = false;
+
+ /** source file root */
+ private File srcDir = null;
+
+ /** instrumentation root */
+ private File instrumentDir = null;
+
+ /** repository root */
+ private File repositoryDir = null;
+
+ /** classpath */
+ private Path classpath = null;
+
+ /** The class of the Throwable to be thrown on failed assertions */
+ private String failThrowable = "java.lang.Error";
+
+ /** The -v option */
+ private String verbosity = "error*,warning*";
+
+ /** Indicates whether or not to use internal compilation */
+ private boolean internalcompilation = false;
+
+ /** The -m option */
+ private File controlFile = null;
+
+ /** Indicates whether or not to instrument for preconditions */
+ private boolean pre = true;
+
+ /** Indicates whether or not to instrument for postconditions */
+ private boolean post = true;
+
+ /** Indicates whether or not to instrument for invariants */
+ private boolean invariant = true;
+
+ /** Indicates whether or not to instrument all files regardless of timestamp */
+ // can't be explicitly set, is set if control file exists and is newer than any source file
+ private boolean instrumentall = true;
+
+ /**
+ * Sets the source directory
+ *
+ * @param srcDir the source directory
+ */
+ public void setSrcdir( File srcDir ) {
+ this.srcDir = srcDir;
+ }
+
+ /**
+ * Sets the instrumentation directory
+ *
+ * @param instrumentDir the source directory
+ */
+ public void setInstrumentdir( File instrumentDir ) {
+ this.instrumentDir = instrumentDir;
+ }
+
+ /**
+ * Sets the repository directory
+ *
+ * @param repositoryDir the source directory
+ */
+ public void setRepositorydir( File repositoryDir ) {
+ this.repositoryDir = repositoryDir;
+ }
+
+ /**
+ * Turns on/off precondition instrumentation
+ *
+ * @param pre true turns it on
+ */
+ public void setPre( boolean pre ) {
+ this.pre = pre;
+ }
+
+ /**
+ * Turns on/off postcondition instrumentation
+ *
+ * @param post true turns it on
+ */
+ public void setPost( boolean post ) {
+ this.post = post;
+ }
+
+ /**
+ * Turns on/off invariant instrumentation
+ *
+ * @param invariant true turns it on
+ */
+ public void setInvariant( boolean invariant ) {
+ this.invariant = invariant;
+ }
+
+ /**
+ * Sets the Throwable (Exception) to be thrown on assertion violation
+ *
+ * @param clazz the Throwable class
+ */
+ public void setFailthrowable( Class clazz ) {
+ this.failThrowable = clazz.getName();
+ }
+
+ /**
+ * Sets the verbosity level of iContract. Any combination of
+ * error*,warning*,note*,info*,progress*,debug* (comma separated)
+ * can be used. Defaults to error*,warning*
+ *
+ * @param clazz the Throwable class
+ */
+ public void setVerbosity( String verbosity ) {
+ this.verbosity = verbosity;
+ }
+
+ /**
+ * Turns on/off internal compilation.
+ * build.compiler will be used, defaulting to javac,
+ * and run in a separate VM.
+ *
+ * @param internalcompilation set to true for internal compilation
+ */
+ /* FIXME: Doesn't work
+ public void setInternalcompilation( boolean internalcompilation ) {
+ this.internalcompilation = internalcompilation;
+ }
+ */
+
+ /**
+ * Sets the control file to pass to iContract.
+ *
+ * @param clazz the Throwable class
+ */
+ public void setControlfile( File controlFile ) {
+ this.controlFile = controlFile;
+ }
+
+ /**
+ * Sets the classpath to be used for invocation of iContract.
+ *
+ * @path the classpath
+ */
+ public void setClasspath( Path path ) {
+ createClasspath().append( path );
+ }
+
+ /**
+ * Creates a nested classpath element
+ *
+ * @return the nested classpath element
+ */
+ public Path createClasspath() {
+ if (classpath == null) {
+ classpath = new Path( getProject() );
+ }
+ return classpath;
+ }
+
+ /**
+ * Adds a reference to a classpath defined elsewhere.
+ *
+ * @param reference referenced classpath
+ */
+ public void setClasspathRef( Reference reference ) {
+ createClasspath().setRefid( reference );
+ }
+
+ /**
+ * Executes the task
+ *
+ * @exception BuildException if the instrumentation fails
+ */
+ public void execute() throws BuildException {
+ preconditions();
+ scan();
+ if( dirty ) {
+ // We want to be notified if iContract jar is missing. This makes life easier for the user
+ // who didn't understand that iContract is a separate library (duh!)
+ getProject().addBuildListener( new IContractPresenceDetector() );
+
+ // Prepare the directories for iContract. iContract will make them if they
+ // don't exist, but for some reason I don't know, it will complain about the REP files
+ // afterwards
+ Mkdir mkdir = (Mkdir) project.createTask( "mkdir" );
+ mkdir.setDir( instrumentDir );
+ mkdir.execute();
+ mkdir.setDir( repositoryDir );
+ mkdir.execute();
+
+ // Set the compiler
+ setCompiler();
+
+ // Set the classpath that is needed for regular Javac compilation
+ Path baseClasspath = createClasspath();
+
+ // Create the classpath required to compile the sourcefiles BEFORE instrumentation
+ Path beforeInstrumentationClasspath = ((Path) baseClasspath.clone());
+ beforeInstrumentationClasspath.append( new Path( getProject(), srcDir.getAbsolutePath() ) );
+
+ // Create the classpath required to compile the sourcefiles AFTER instrumentation
+ Path afterInstrumentationClasspath = ((Path) baseClasspath.clone());
+ afterInstrumentationClasspath.append( new Path( getProject(), instrumentDir.getAbsolutePath() ) );
+ afterInstrumentationClasspath.append( new Path( getProject(), repositoryDir.getAbsolutePath() ) );
+ afterInstrumentationClasspath.append( new Path( getProject(), srcDir.getAbsolutePath() ) );
+
+ // Create the classpath required to automatically compile the repository files
+ Path repositoryClasspath = ((Path) baseClasspath.clone());
+ repositoryClasspath.append( new Path( getProject(), instrumentDir.getAbsolutePath() ) );
+ repositoryClasspath.append( new Path( getProject(), srcDir.getAbsolutePath() ) );
+ repositoryClasspath.append( new Path( getProject(), repositoryDir.getAbsolutePath() ) );
+
+ // Create the classpath required for iContract itself
+ Path iContractClasspath = ((Path) baseClasspath.clone());
+ iContractClasspath.append( new Path( getProject(), System.getProperty( "java.home" ) + File.separator + ".." + File.separator + "lib" + File.separator + "tools.jar" ) );
+ iContractClasspath.append( new Path( getProject(), srcDir.getAbsolutePath() ) );
+ iContractClasspath.append( new Path( getProject(), repositoryDir.getAbsolutePath() ) );
+ iContractClasspath.append( new Path( getProject(), instrumentDir.getAbsolutePath() ) );
+
+ // Create a forked java process
+ Java iContract = (Java) project.createTask( "java" );
+ iContract.setTaskName( getTaskName() );
+ iContract.setFork( true );
+ iContract.setClassname( "com.reliablesystems.iContract.Tool" );
+ iContract.setClasspath( iContractClasspath );
+
+ // Build the arguments to iContract
+ StringBuffer args = new StringBuffer();
+ args.append( directiveString() );
+ args.append( "-v" ).append( verbosity ).append( " " );
+ args.append( "-b" ).append( icCompiler ).append( "\"" ).append( " -classpath " ).append( beforeInstrumentationClasspath ).append( "\" " );
+ args.append( "-c" ).append( icCompiler ).append( "\"" ).append( " -classpath " ).append( afterInstrumentationClasspath ).append( "\" " );
+ args.append( "-n" ).append( icCompiler ).append( "\"" ).append( " -classpath " ).append( repositoryClasspath ).append( "\" " );
+ args.append( "-d" ).append( failThrowable ).append( " " );
+ args.append( "-o" ).append( instrumentDir ).append( File.separator ).append( "@p" ).append( File.separator ).append( "@f.@e " );
+ args.append( "-k" ).append( repositoryDir ).append( File.separator ).append( "@p " );
+ args.append( instrumentall ? "-a " : "" ); // reinstrument everything if controlFile exists and is newer than source
+ args.append( "@" ).append( targets.getName() );
+ iContract.createArg().setLine( args.toString() );
+
+// System.out.println( "JAVA -classpath " + iContractClasspath + " com.reliablesystems.iContract.Tool " + args.toString() );
+
+ int result = iContract.executeJava();
+ if( result != 0 ) {
+ if( iContractMissing ) {
+ log( "iContract can't be found on your classpath. Your classpath is:" );
+ log( classpath.toString() );
+ log( "If you don't have the iContract jar, go get it at http://www.reliable-systems.com/tools/" );
+ }
+ throw new BuildException( "iContract instrumentation failed. Code=" + result );
+ }
+ } else {
+ //log( "Nothing to do. Everything up to date." );
+ }
+ }
+
+ /**
+ * Checks that the required attributes are set.
+ */
+ private void preconditions() throws BuildException {
+ if (srcDir == null) {
+ throw new BuildException( "srcdir attribute must be set!", location );
+ }
+ if (!srcDir.exists()) {
+ throw new BuildException( "srcdir \"" + srcDir.getPath() + "\" does not exist!", location );
+ }
+ if (instrumentDir == null) {
+ throw new BuildException( "instrumentdir attribute must be set!", location );
+ }
+ if (repositoryDir == null) {
+ throw new BuildException( "repositorydir attribute must be set!", location );
+ }
+ }
+
+ /**
+ * Verifies whether any of the source files have changed. Done by comparing date of source/class files.
+ * The whole lot is "dirty" if at least one source file is newer than the instrumented files. If not dirty,
+ * iContract will not be executed.
+ *