Class Rmic

  • All Implemented Interfaces:
    java.lang.Cloneable, SelectorContainer

    public class Rmic
    extends MatchingTask

    Runs the rmic compiler against classes.

    Rmic can be run on a single class (as specified with the classname attribute) or a number of classes at once (all classes below base that are neither _Stub nor _Skel classes). If you want to rmic a single class and this class is a class nested into another class, you have to specify the classname in the form Outer$$Inner instead of Outer.Inner.

    It is possible to refine the set of files that are being rmiced. This can be done with the includes, includesfile, excludes, excludesfile and defaultexcludes attributes. With the includes or includesfile attribute you specify the files you want to have included by using patterns. The exclude or excludesfile attribute is used to specify the files you want to have excluded. This is also done with patterns. And finally with the defaultexcludes attribute, you can specify whether you want to use default exclusions or not. See the section on directory based tasks, on how the inclusion/exclusion of files works, and how to write patterns.

    This task forms an implicit FileSet and supports all attributes of <fileset> (dir becomes base) as well as the nested <include>, <exclude> and <patternset> elements.

    It is possible to use different compilers. This can be selected with the "build.rmic" property or the compiler attribute. There are three choices:

    • sun (the standard compiler of the JDK)
    • kaffe (the standard compiler of Kaffe)
    • weblogic

    The miniRMI project contains a compiler implementation for this task as well, please consult miniRMI's documentation to learn how to use it.

    Since:
    Ant 1.1
    • Field Detail

      • ERROR_RMIC_FAILED

        public static final java.lang.String ERROR_RMIC_FAILED
        rmic failed message
        See Also:
        Constant Field Values
      • ERROR_UNABLE_TO_VERIFY_CLASS

        public static final java.lang.String ERROR_UNABLE_TO_VERIFY_CLASS
        unable to verify message
        See Also:
        Constant Field Values
      • ERROR_NOT_FOUND

        public static final java.lang.String ERROR_NOT_FOUND
        could not be found message
        See Also:
        Constant Field Values
      • ERROR_NOT_DEFINED

        public static final java.lang.String ERROR_NOT_DEFINED
        not defined message
        See Also:
        Constant Field Values
      • ERROR_LOADING_CAUSED_EXCEPTION

        public static final java.lang.String ERROR_LOADING_CAUSED_EXCEPTION
        loaded error message
        See Also:
        Constant Field Values
      • ERROR_NO_BASE_EXISTS

        public static final java.lang.String ERROR_NO_BASE_EXISTS
        base not exists message
        See Also:
        Constant Field Values
      • ERROR_NOT_A_DIR

        public static final java.lang.String ERROR_NOT_A_DIR
        base not a directory message
        See Also:
        Constant Field Values
      • ERROR_BASE_NOT_SET

        public static final java.lang.String ERROR_BASE_NOT_SET
        base attribute not set message
        See Also:
        Constant Field Values
    • Constructor Detail

      • Rmic

        public Rmic()
        Constructor for Rmic.
    • Method Detail

      • setBase

        public void setBase​(java.io.File base)
        Sets the location to store the compiled files; required
        Parameters:
        base - the location to store the compiled files
      • setDestdir

        public void setDestdir​(java.io.File destdir)
        Sets the base directory to output the generated files.
        Parameters:
        destdir - the base directory to output the generated files.
        Since:
        Ant 1.8.0
      • getDestdir

        public java.io.File getDestdir()
        Gets the base directory to output the generated files.
        Returns:
        the base directory to output the generated files.
        Since:
        Ant 1.8.0
      • getOutputDir

        public java.io.File getOutputDir()
        Gets the base directory to output the generated files, favoring destdir if set, otherwise defaulting to basedir.
        Returns:
        the actual directory to output to (either destdir or basedir)
        Since:
        Ant 1.8.0
      • getBase

        public java.io.File getBase()
        Gets the base directory to output generated class.
        Returns:
        the location of the compiled files
      • setClassname

        public void setClassname​(java.lang.String classname)
        Sets the class to run rmic against; optional
        Parameters:
        classname - the name of the class for rmic to create code for
      • getClassname

        public java.lang.String getClassname()
        Gets the class name to compile.
        Returns:
        the name of the class to compile
      • setSourceBase

        public void setSourceBase​(java.io.File sourceBase)
        optional directory to save generated source files to.
        Parameters:
        sourceBase - the directory to save source files to.
      • getSourceBase

        public java.io.File getSourceBase()
        Gets the source dirs to find the source java files.
        Returns:
        sourceBase the directory containing the source files.
      • setStubVersion

        public void setStubVersion​(java.lang.String stubVersion)
        Specify the JDK version for the generated stub code. Specify "1.1" to pass the "-v1.1" option to rmic.
        Parameters:
        stubVersion - the JDK version
      • getStubVersion

        public java.lang.String getStubVersion()
        Gets the JDK version for the generated stub code.
        Returns:
        stubVersion
      • setFiltering

        public void setFiltering​(boolean filter)
        Sets token filtering [optional], default=false
        Parameters:
        filter - turn on token filtering
      • getFiltering

        public boolean getFiltering()
        Gets whether token filtering is set
        Returns:
        filtering
      • setDebug

        public void setDebug​(boolean debug)
        Generate debug info (passes -g to rmic); optional, defaults to false
        Parameters:
        debug - turn on debug info
      • getDebug

        public boolean getDebug()
        Gets the debug flag.
        Returns:
        debug
      • setClasspath

        public void setClasspath​(Path classpath)
        Set the classpath to be used for this compilation.
        Parameters:
        classpath - the classpath used for this compilation
      • createClasspath

        public Path createClasspath()
        Creates a nested classpath element.
        Returns:
        classpath
      • setClasspathRef

        public void setClasspathRef​(Reference pathRef)
        Adds to the classpath a reference to a <path> defined elsewhere.
        Parameters:
        pathRef - the reference to add to the classpath
      • getClasspath

        public Path getClasspath()
        Gets the classpath.
        Returns:
        the classpath
      • setVerify

        public void setVerify​(boolean verify)
        Flag to enable verification so that the classes found by the directory match are checked to see if they implement java.rmi.Remote. optional; This defaults to false if not set.
        Parameters:
        verify - turn on verification for classes
      • getVerify

        public boolean getVerify()
        Get verify flag.
        Returns:
        verify
      • setIiop

        public void setIiop​(boolean iiop)
        Indicates that IIOP compatible stubs should be generated; optional, defaults to false if not set.
        Parameters:
        iiop - generate IIOP compatible stubs
      • getIiop

        public boolean getIiop()
        Gets iiop flags.
        Returns:
        iiop
      • setIiopopts

        public void setIiopopts​(java.lang.String iiopOpts)
        Set additional arguments for iiop
        Parameters:
        iiopOpts - additional arguments for iiop
      • getIiopopts

        public java.lang.String getIiopopts()
        Gets additional arguments for iiop.
        Returns:
        iiopOpts
      • setIdl

        public void setIdl​(boolean idl)
        Indicates that IDL output should be generated. This defaults to false if not set.
        Parameters:
        idl - generate IDL output
      • getIdl

        public boolean getIdl()
        Gets IDL flags.
        Returns:
        the idl flag
      • setIdlopts

        public void setIdlopts​(java.lang.String idlOpts)
        pass additional arguments for IDL compile
        Parameters:
        idlOpts - additional IDL arguments
      • getIdlopts

        public java.lang.String getIdlopts()
        Gets additional arguments for idl compile.
        Returns:
        the idl options
      • getFileList

        public java.util.Vector<java.lang.String> getFileList()
        Gets file list to compile.
        Returns:
        the list of files to compile.
      • setIncludeantruntime

        public void setIncludeantruntime​(boolean include)
        Sets whether or not to include ant's own classpath in this task's classpath. Optional; default is true.
        Parameters:
        include - if true include ant's classpath
      • getIncludeantruntime

        public boolean getIncludeantruntime()
        Gets whether or not the ant classpath is to be included in the task's classpath.
        Returns:
        true if ant's classpath is to be included
      • setIncludejavaruntime

        public void setIncludejavaruntime​(boolean include)
        task's classpath. Enables or disables including the default run-time libraries from the executing VM; optional, defaults to false
        Parameters:
        include - if true include default run-time libraries
      • getIncludejavaruntime

        public boolean getIncludejavaruntime()
        Gets whether or not the java runtime should be included in this task's classpath.
        Returns:
        true if default run-time libraries are included
      • setExtdirs

        public void setExtdirs​(Path extDirs)
        Sets the extension directories that will be used during the compilation; optional.
        Parameters:
        extDirs - the extension directories to be used
      • createExtdirs

        public Path createExtdirs()
        Maybe creates a nested extdirs element.
        Returns:
        path object to be configured with the extension directories
      • getExtdirs

        public Path getExtdirs()
        Gets the extension directories that will be used during the compilation.
        Returns:
        the extension directories to be used
      • getCompileList

        public java.util.Vector<java.lang.String> getCompileList()
        Returns:
        the compile list.
      • setCompiler

        public void setCompiler​(java.lang.String compiler)
        Sets the compiler implementation to use; optional, defaults to the value of the build.rmic property, or failing that, default compiler for the current VM
        Parameters:
        compiler - the compiler implementation to use
        Since:
        Ant 1.5
      • getCompiler

        public java.lang.String getCompiler()
        get the name of the current compiler
        Returns:
        the name of the compiler
        Since:
        Ant 1.5
      • createCompilerArg

        public Rmic.ImplementationSpecificArgument createCompilerArg()
        Adds an implementation specific command line argument.
        Returns:
        an object to be configured with a command line argument
        Since:
        Ant 1.5
      • getCurrentCompilerArgs

        public java.lang.String[] getCurrentCompilerArgs()
        Get the additional implementation specific command line arguments.
        Returns:
        array of command line arguments, guaranteed to be non-null.
        Since:
        Ant 1.5
      • setExecutable

        public void setExecutable​(java.lang.String ex)
        Name of the executable to use when forking.
        Parameters:
        ex - String
        Since:
        Ant 1.8.0
      • getExecutable

        public java.lang.String getExecutable()
        Explicitly specified name of the executable to use when forking - if any.
        Returns:
        String
        Since:
        Ant 1.8.0
      • createCompilerClasspath

        public Path createCompilerClasspath()
        The classpath to use when loading the compiler implementation if it is not a built-in one.
        Returns:
        Path
        Since:
        Ant 1.8.0
      • setListfiles

        public void setListfiles​(boolean list)
        If true, list the source files being handed off to the compiler.
        Parameters:
        list - if true list the source files
        Since:
        Ant 1.8.0
      • add

        public void add​(RmicAdapter adapter)
        Set the compiler adapter explicitly.
        Parameters:
        adapter - RmicAdapter
        Since:
        Ant 1.8.0
      • execute

        public void execute()
                     throws BuildException
        execute by creating an instance of an implementation class and getting to do the work
        Overrides:
        execute in class Task
        Throws:
        BuildException - if there's a problem with baseDir or RMIC
      • cleanup

        protected void cleanup()
        Cleans up resources.
        Since:
        Ant 1.8.0
      • scanDir

        protected void scanDir​(java.io.File baseDir,
                               java.lang.String[] files,
                               FileNameMapper mapper)
        Scans the directory looking for class files to be compiled. The result is returned in the class variable compileList.
        Parameters:
        baseDir - the base direction
        files - the list of files to scan
        mapper - the mapper of files to target files
      • isValidRmiRemote

        public boolean isValidRmiRemote​(java.lang.String classname)
        Load named class and test whether it can be rmic'ed
        Parameters:
        classname - the name of the class to be tested
        Returns:
        true if the class can be rmic'ed
      • getRemoteInterface

        public java.lang.Class<?> getRemoteInterface​(java.lang.Class<?> testClass)
        Returns the topmost interface that extends Remote for a given class - if one exists.
        Parameters:
        testClass - the class to be tested
        Returns:
        the topmost interface that extends Remote, or null if there is none.
      • getLoader

        public java.lang.ClassLoader getLoader()
        Classloader for the user-specified classpath.
        Returns:
        the classloader