Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
MMAKE(1)			 User Commands			      MMAKE(1)

NAME
	mmake -	generate a Java	Makefile

SYNOPSIS
	mmake [	-d | -v	]

DESCRIPTION
       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,  bun-
       dle,  install, uninstall, tags and depend Where 'make doc' runs javadoc
       on the source files, it will only work for files	in a package. The com-
       mand '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 com-
       mand 'make bundle' creates a Mac	OS X Application Bundle	with  all  the
       jar  file. The command 'make install' will install a jar	file, app bun-
       dle, 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
       makefile.dep, 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	 pack-
       age.  In	that case, you must either run mmake again or update the PACK-
       AGE variable in the Makefile. This is because the  Makefile  uses  this
       variable	to find	directories with java files.

       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
       http://www.ibm.com/developerworks/oss/jikes/.You	would probably be more
       content with jikes anyhow, since	it is much faster than javac. To  cre-
       ate a dependencies graph, do a make clean before	running	make depend.

A NOTE ON INSTALLATION
       The  Makefile created with mmake	will do	a fair job installing the dif-
       ferent files that makes up your system. It uses the following  Makefile
       variables when it conducts the install routine:

       •   PREFIX

       •   CLASS_DIR

       •   JAR_DIR

       •   BUNDLE_DIR

       •   DOC_DIR

       •   SCRIPT_DIR

       PREFIX

       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 in-
       stallation like:	make PREFIX=/local/myproject/ install

       CLASS_DIR

       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
       value. Note: 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 us-
       ing  e.g.  ResourceBundles  to  Localize	your application and have your
       property	files in it's own directory in the package structure.

       JAR_DIR

       This variable tells the Makefile	where to install the jar file. The de-
       fault value is lib, which is also a good	default	value.

       BUNDLE_DIR

       This variable tells the Makefile	where to install the app  bundle.  The
       default value is	lib, which is also a good default value.

       DOC_DIR

       When  you  run javadoc, all the html files will be put into this	direc-
       tory. Its default value is doc/api-docs.	You should probably keep  that
       name, but then again, you may change it as you like.

       SCRIPT_DIR

       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 applica-
       tion. Its default value is bin. (The Makefile will only install	shell-
       scripts	that  has  the	extension  .sh.	The mmake script will tell the
       Makefile	where to look for shell-scripts)

       INSTALLATION SUMMARY

       If you keep the default values you will get an installation  tree  that
       looks like this:

	`-- PREFIX
	    |--	bin
	    |--	classes
	    |	`-- package <--- Example of a sub-directory
	    |	    |--	sub-package1
	    |	    |--	sub-package2
	    |	    `--	sub-package3
	    |--	doc
	    |	`-- api-docs
	    `--	lib

USING THE C-PREPROCESSOR
       This  is	 a excellent tool for managing projects	with several different
       versions. The idea behind using the C preprocessor with Java is to bet-
       ter 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
       .xjava files.

       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 be removed.)

       You can now use cpp Conditionals	in Your	 Java-code,  for  example,  as
       follows:

	   #ifdef JAVA1_1
	      [code1]
	   #else
	      [code2]
	   #endif

       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 VER-
       SION is something else than JAVA1_1, then [code2] would be compiled and
       [code1] left out	of the resulting .class	file.

NOTES
       mmake will give you one Makefile	for managing  your  Java  files.   Al-
       though  it's  easy  to setup and	use mmake in a recursive makefile con-
       text, you don't want to do that.	To see why, read the  excellent	 arti-
       cle:	  Recursive	  Make	     Considered	      Harmful	    at
       http://www.canb.auug.org.au/~millerp/rmch/recu-make-cons-harm.html

DEPENDENCIES
       mmake will need the following:

       •   Perl	5.x

       •   Gnu make

       •   Gnu xargs (recommended)

AUTHOR
       Jan-Henrik Haukeland <hauk@tildeslash.com>

April 2. 2004		      www.tildeslash.com		      MMAKE(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=mmake&sektion=1&manpath=FreeBSD+Ports+15.0.quarterly>

home | help