mmake - generate a Java Makefile
mmake [ -d ⎪ -v ]
This program will generate a Makefile for Java source files. Use the -d
option to accept all defaults.
After running mmake, you will obtain a Makefile in the directory from where you
started the program. The Makefile will handle java files in the current
directory and in any sub-directories.
Use the generated Makefile with mmake as follows:
To compile Java files just type make
. It's also possible to run make with
one of the following targets: doc, clean, help, jar, srcjar, bundle,
install, uninstall, tags and depend
Where 'make doc' runs javadoc on the
source files, it will only work for files in a package. The command 'make
clean' removes class files and other temporary files. The command 'make jar'
creates a jar file with all class files (and other files of your choice, see
the JAR_OBJS variable in the Makefile). The command 'make srcjar' creates a
jar file with all java files. The command 'make bundle' creates a Mac OS X
Application Bundle with all the jar file. The command 'make install' will
install a jar file, app bundle, class files and any shell wrappers you have
made. (A shell script must have the extension .sh to be installed). Use 'make
uninstall' to remove installed files. The command 'make help', shows a help
text with available targets. The command 'make tags' will generate a tag file
for Emacs. And finally the command 'make depend' creates a dependency graph
for the class files. (The dependency graph will be put in a file called
, which is included in the Makefile)
You don't have to run mmake each time you add a new java file to your project.
You can add as many new java files as you like, the Makefile will find them.
This is the case as long as you don't add a new package. In that case, you
must either run mmake again or update the PACKAGE variable in the Makefile.
This is because the Makefile uses this variable to find directories with java
The program mmake is able to create a dependency graph for your java files. To
do this, it needs the jikes
compiler from IBM. Get jikes from
.You would probably be more
content with jikes anyhow, since it is much faster than javac. To create a
dependencies graph, do a make clean
before running make depend
The Makefile created with mmake will do a fair job installing the different
files that makes up your system. It uses the following Makefile variables when
it conducts the install routine:
This variable will be prepended to all other directory variables above. It is
used for grouping the other directories into one root directory. If you don't
want that, you may simply set the variable to an empty string in the Makefile.
If the variable is empty you could still use it on the command line when you
run make, for instance for a one-shoot installation like: make
This variable denotes the top directory from where all class files will be
installed. Its default value is classes
, which I believe is a good
If you don't
want to install any class files
(because you are, for example, only going to use a jar file), set this
variable to an empty string and no class files will be installed.
Resource files will also be installed below this directory if such files are
present in a package structure. This is useful if you are using e.g.
ResourceBundles to Localize your application and have your property files in
it's own directory in the package structure.
This variable tells the Makefile where to install the jar file. The default
value is lib
, which is also a good default value.
This variable tells the Makefile where to install the app bundle. The default
value is lib
, which is also a good default value.
When you run javadoc, all the html files will be put into this directory. Its
default value is doc/api-docs
. You should probably keep that name, but
then again, you may change it as you like.
The Makefile uses this variable to install any shell wrapper-scripts that you
have created. If you write an application, it is always nice for the user that
you provide a wrapper script to start the application. Its default value is
. (The Makefile will only install shell-scripts that has the
extension .sh. The mmake script will tell the Makefile where to look for
If you keep the default values you will get an installation tree that looks like
⎪ `-- package <--- Example of a sub-directory
⎪ ⎪-- sub-package1
⎪ ⎪-- sub-package2
⎪ `-- sub-package3
⎪ `-- api-docs
This is a excellent tool for managing projects with several different versions.
The idea behind using the C preprocessor with Java is to better manage
different versions more easily. This is done by using CPP conditional
statements in the source files. I would strongly advise you not to use CPP to
redefine the Java language itself.
To use the C preprocessor together with Java, you can change the name of the
source files that you want to preprocess -- from <filename>.java to
<filename>.xjava. The Makefile has a rule to build .class files from
It is not
necesarry to change every file from .java to .xjava. The
Makefile will work well and consistently in an environment of both .java and
.xjava files. (E.g. 'make clean' will only remove .java files that were
created from a .xjava file. Other java files will, of course, not
You can now use cpp Conditionals in Your Java-code, for example, as follows:
The JAVA1_1 label in the above example is tested against the VERSION variable in
the Makefile. That is, if the VERSION variable is JAVA1_1, then [code1] would
be compiled and [code2] left out. Likewise, if VERSION is something else than
JAVA1_1, then [code2] would be compiled and [code1] left out of the resulting
mmake will give you one
Makefile for managing your Java files. Although
it's easy to setup and use mmake in a recursive makefile context, you don't
want to do that. To see why, read the excellent article: Recursive Make
mmake will need the following:
- Perl 5.x
- Gnu make
- Gnu xargs (recommended)
Jan-Henrik Haukeland <firstname.lastname@example.org>