[This Index is automatically generated from Jmake.rules file. Do not edit this file or your changes will be lost. Edit Jmake.rules instead.] This file contains a listing of all the macros that can be used in a Jmakefile. Only a few of these should be used in the Jmakefile (they are the top-level macros). However, some low-level ones may be useful, but it is up to you to make that decision. This explains why this file holds all the available macros for jmake. In the following listing, the macros are separated by a line of dashes. The signature of the macro is given, then a small comment of what it does precedes the actual definition. Lines preceded by '->' show the set of symbols defined when the macro is used. Initialization lines are shown as-is, i.e. have the form SYM = val while concatenation is shown by SYM += val (which means val is added to the value of SYM). Conditional lines are preceded by tests like (if SYM). This means the line is to be kept if and only if the symbol SYM is defined. Other internal requests are not formatted yet. ------------------------------------------------------------------------ AddSuffix(ext): Adds a sufix to the .SUFFIXES: list. .SUFFIXES: ext ------------------------------------------------------------------------ AddedByConfigure(files): Gives name of the files generated by Configure that can safely be removed when a "make clobber" is issued. Not that it is useless to name config.h or config.sh because these are already taken care of by jmake. local_clobber:: $(RM) files ------------------------------------------------------------------------ AliasedLibraryTarget(libname,alias): Generate rules to link one library to another. AllTarget(lib/**/alias.a) lib/**/alias.a: lib^^libname.a $(RM) $@ $(LN) lib/**/libname.a $@ ------------------------------------------------------------------------ AllTarget(depends): Generate rules to build necessary things during make all. all:: depends local_realclean:: $(RM) depends ------------------------------------------------------------------------ BuildMakefile(): Generate rules to build a Makefile from a Makefile.SH. Makefile: Makefile.SH /bin/sh Makefile.SH ------------------------------------------------------------------------ BuildMakefileSH(jmakeflags): Generate rules to build a Makefile.SH from an Jmakefile and any special jmake flags. This is generally done automatically by the template or by any special Jmakefiles. This function will simply touch Makefile.SH if no $(TOP)/.package exists, assuming the Jmakefile is not in a production environment. Makefile.SH: Jmakefile -@if test -f $(TOP)/.package; then \ if test -f Makefile.SH; then \ echo " $(RM) Makefile.SH~; $(MV) Makefile.SH Makefile.SH~"; \ $(RM) Makefile.SH~; $(MV) Makefile.SH Makefile.SH~; \ fi; \ echo " $(JMAKE) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT)" jmakeflags; \ $(JMAKE) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT) jmakeflags; \ else touch $@; fi ------------------------------------------------------------------------ CleanSubdirs(): Generate rules to recursively clean out garbage files. NamedDepthTargetSubdirs(clean,"Cleaning",/**/) NamedDepthTargetSubdirs(realclean,"Real cleaning",/**/) NamedDepthTargetSubdirs(clobber,"Clobbering",/**/) ------------------------------------------------------------------------ CleanTarget(): Generate rules to remove any garbage files. (if SUBDIRS) clean: sub_clean local_clean (not SUBDIRS) clean: local_clean (if SUBDIRS) realclean: sub_realclean local_realclean (not SUBDIRS) realclean: local_realclean (if SUBDIRS) clobber: sub_clobber local_clobber (not SUBDIRS) clobber: local_clobber local_clean:: if test -f core; then $(RM) core; fi $(RM) *~ *.o local_realclean:: local_clean (if TOP) $(RM) -r UU local_clobber:: local_realclean (not TOP) $(RM) Makefile config.sh (if TOP) $(RM) config.sh config.h (if TOP) $(RM) -r .config (if TOP) $(RM) Makefile ------------------------------------------------------------------------ CommonSubdirsRule(dirs): Rule for making $(TARGET) in every subdirectory, with $(VERB) as verbose message and $(FLAGS) as additional flags. subdirs: @case '${MFLAGS}' in *[ik]*) set +e;; esac; \ for i in dirs ;\ do \ (cd $$i ; echo $(VERB) "in $(DIR)$$i..."; \ $(MAKE) $(MFLAGS) $(FLAGS) $(TARGET)) || exit 1; \ done ------------------------------------------------------------------------ ComplexProgramTarget(program): Generate rules for compiling and linking the program specified by $(OBJS) and $(SRCS), installing the program and its man page, and generating dependencies. It should only be used in Jmakefiles that describe a single program. OBJECTS += $(OBJS) SOURCES += $(SRCS) NormalObjectRule() AllTarget(program) program: $(OBJS) RemoveTargetProgram($@) $(CC) -o $@ $(OBJS) $(JLDFLAGS) $(LIBS) InstallProgram(program,$(BINDIR)) InstallManPage(program,$(MANSRC)) DependTarget() LintTarget() ------------------------------------------------------------------------ ComplexProgramTarget_1(program): Generate rules for compiling and linking the program specified by $(OBJS1) and $(SRCS1), installing the program and its man page, and generating dependencies for it and any programs described by $(SRCS2) and $(SRCS3). It should be used to build the primary program in Jmakefiles that describe multiple programs. OBJECTS += $(OBJS1) SOURCES += $(SRCS1) NormalObjectRule() AllTarget(program) program: $(OBJS1) RemoveTargetProgram($@) $(CC) -o $@ $(OBJS1) $(JLDFLAGS) $(LIBS) InstallProgram(program,$(BINDIR)) InstallManPage(program,$(MANSRC)) DependTarget() LintTarget() ------------------------------------------------------------------------ ComplexProgramTarget_2(program): Generate rules for compiling and linking the program specified by $(OBJS2) and $(SRCS2) and installing the program and man page. It should be used to build the second program in Jmakefiles describing more than one program. OBJECTS += $(OBJS2) SOURCES += $(SRCS2) NormalObjectRule() AllTarget(program) program: $(OBJS2) RemoveTargetProgram($@) $(CC) -o $@ $(OBJS2) $(JLDFLAGS) $(LIBS) InstallProgram(program,$(BINDIR)) InstallManPage(program,$(MANSRC)) ------------------------------------------------------------------------ ComplexProgramTarget_3(program): Generate rules for compiling and linking the program specified by $(OBJS3) and $(SRCS3) and installing the program and man page. It should be used to build the third program in Jmakefiles describing more than one program. OBJECTS += $(OBJS3) SOURCES += $(SRCS3) NormalObjectRule() AllTarget(program) program: $(OBJS3) RemoveTargetProgram($@) $(CC) -o $@ $(OBJS3) $(JLDFLAGS) $(LIBS) InstallProgram(program,$(BINDIR)) InstallManPage(program,$(MANSRC)) ------------------------------------------------------------------------ ComplexShellManualTarget(manpages): Builds manual pages that are to be extracted from .SH files into .$manext files. MANPAGE += manpages |once _ShellManualRule_ .SH.$manext: /bin/sh $< -once AddSuffix(.SH) AddSuffix(.$manext) AllTarget(manpages) local_install.man:: _MakeInstallDirIgnore($(MANSRC)) \ for file in manpages; do \ (set -x; $(INSTALL) -c -m 444 $$file \ $(INSTALL_PREFIX)$(MANSRC)) || exit 1; \ done local_deinstall.man:: @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for file in manpages; do \ (set -x; $(RM) $(INSTALL_PREFIX)$(MANSRC)/$$file); \ done ------------------------------------------------------------------------ ComplexYaccInclude(base,prefix): Declare that program will need an include file produced by the output of yacc on base.y, which typically produces a file named y.tab.h, which will be renamed as base.h. The difference with SimpleYaccInclude is the identifying process of the y.tab.h file where all 'yy' are renamed to prefix. The only problem is that the dependencies towards base.h have to be manually given in the Jmakefile. base.h: base.c @if test -f y.tab.h; then \ echo " $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.h > base.h"; \ $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.h > base.h; \ echo " $(RM) y.tab.h"; \ $(RM) y.tab.h; \ elif test -f base.h; then \ echo " $(CP) base.h base.ht"; \ $(CP) base.h base.ht; \ echo " $(SED) -e 's/yy\(.\)/prefix\1/g' < base.ht > base.h"; \ $(SED) -e 's/yy\(.\)/prefix\1/g' < base.ht > base.h; \ echo " $(RM) base.ht"; \ $(RM) base.ht; \ fi local_realclean:: $(RM) base.h ------------------------------------------------------------------------ ComplexYaccTarget(program,base,prefix): Declare a yacc base.y file to be used in the building of the specified target program. The source file must be given without its final .y extension. The name of the .c and .o will be derived from the source file basename provided. The difference with SimpleYaccTarget is the identifying process where all the 'yy' are replaced by the specified prefix. SOURCES += base.y OBJECTS += base.o program: base.c base.c: base.y $(YACC) $(JYFLAGS) base.y $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.c > base.c $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.h > base.h $(RM) y.tab.c y.tab.h local_realclean:: $(RM) base.c ------------------------------------------------------------------------ CppScriptTarget(dst,src,defs,deplist): Generate rules to create a shell script by running the input through cpp. dst:: src deplist $(RM) $@ $(CPP) defs $@ chmod a+x $@ ------------------------------------------------------------------------ DebuggedAndProfiledLibraryObjectRule(): Generate make rules to build debuggable, profiled, and "normal" objects. all:: @if [ ! -d profiled ]; then mkdir profiled; fi @if [ ! -d debugger ]; then mkdir debugger; fi .c.o: $(RM) $@ profiled/$@ debugger/$@ $(CC) -pg -c $(JCFLAGS) $*.c $(MV) $*.o profiled/$*.o $(CC) -g -c $(JCFLAGS) $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(JCFLAGS) $*.c local_clean:: -@if [ -d profiled ]; then echo " $(RM) profiled/?*.o"; \ $(RM) profiled/?*.o; fi -@if [ -d debugger ]; then echo " $(RM) debugger/?*.o"; \ $(RM) debugger/?*.o; fi ------------------------------------------------------------------------ DebuggedLibraryObjectRule(): Generate make rules to build both debuggable and "normal" objects. all:: @if [ ! -d debugger ]; then mkdir debugger; fi .c.o: $(RM) $@ debugger/$@ $(CC) -g -c $(JCFLAGS) $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(JCFLAGS) $*.c local_clean:: -@if [ -d debugger ]; then echo " $(RM) debugger/?*.o"; \ $(RM) debugger/?*.o; fi ------------------------------------------------------------------------ DebuggedLibraryTarget(libname,srclist,objlist): Generate rules to create a debuggable library. SOURCES += srclist OBJECTS += objlist AllTarget(lib/**/libname^^_d.a) lib/**/libname^^_d.a: objlist $(RM) $@ cd debugger; $(AR) ../$@ objlist $(RANLIB) $@ ------------------------------------------------------------------------ DebuggedRelocatableTarget(objname,objlist): Generate rules to produce a debuggable relocatable object file instead of a library. AllTarget(objname/**/_d.o) objname/**/_d.o: objlist $(RM) $@ $(LD) -X -r objlist -o $@ ------------------------------------------------------------------------ DeinstallMultipleDest(step,list,dest): Generate rules to deinstall multiple files at once during a particular step in the build. step:: @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for i in list; do \ (set -x; $(RM) $(INSTALL_PREFIX)/***/dest/$$i); \ done ------------------------------------------------------------------------ DependDependency(): Generate rules to build the makedepend program. depend:: TOPDIR/mkdep TOPDIR/mkdep: (if TOP) @echo "You have to run Configure first."; exit 1 (not TOP) @echo "You have to run Configure in $(TOP) first."; exit 1 ------------------------------------------------------------------------ DependDirs(dirs): Generate rules to recursively compute dependencies as part of the make depend step. NamedTargetSubdirsRule(dirs,depend,"Depending",/**/) ------------------------------------------------------------------------ DependSubdirs(): Generate rules to recursively compute dependencies as part of the make depend step. DependDirs($(SUBDIRS)) ------------------------------------------------------------------------ DependTarget(): Generate rules to compute dependencies for all files listed in $(SOURCES) (automatically generated macro). USRINC = $usrinc |once _DependTarget_ DependDependency() depend:: ($(SED) '/^# DO NOT DELETE/q' Makefile && \ $(MKDEP) $(SOURCES) | \ $(SED) -e 's:/usr/lib[^ ]*::g; s:$(USRINC)[^ ]*::g; ' \ -e '/: / b print' -e '$$ b print' -e 'H; d; n; : print' \ -e 'x; s/\\$$//; s/\\\n//g; s/ /**/ */ /g; s/ :/:/;' -e '/: *$$/d' \ ) > Makefile.new cp Makefile Makefile.bak cp Makefile.new Makefile $(RM) Makefile.new -once ------------------------------------------------------------------------ Expand(rule, pattern): This powerful macro expands the `rule' given a `pattern'. It relies on a built-in command in jmake. The expansion is documented in the short notes file that comes with jmake and gives some insights on the internal syntax. |expand pattern rule -expand ------------------------------------------------------------------------ ForceTarget(): The force target will force reconstruction of all the other targets which include .FORCE in their own dependencies. |once _force_ .FORCE: -once ------------------------------------------------------------------------ IdentifiedLexDependTarget(program,base,parser,prefix): Declare that program will need an include file produced by the output of lex on base.l, which typically produces a file named lex.yy.c which will be renamed as base.c. Besides, the lexical analyzer needs the file parser.h produced by running parser.y through yacc and renaming y.tab.h as parser.h. The lexical analyzer is identified with the supplied prefix, which replaces the regular 'yy' prefix in the symbol names. base.o: parser.h IdentifiedLexTarget(program,base,prefix) ------------------------------------------------------------------------ IdentifiedLexTarget(program,base,prefix): This declares a lex base.l file which is to be ran through lex to produce a base.c file. The prefix is used to replace the 'yy', so that the lexical analyzer may be identified. SOURCES += base.l OBJECTS += base.o program: base.c base.c: base.l $(LEX) $(JLFLAGS) base.l $(SED) -e 's/yy\(.\)/prefix\1/g' < lex.yy.c > base.c $(RM) lex.yy.c local_realclean:: $(RM) base.c ------------------------------------------------------------------------ IdentifiedParserTarget(program,lexic,parser,prefix): Specify that program is using the lex/yacc combination to produce a parser. The lexic and parser parameters are the base name of the .l and .y file, respectively. The parser produced is identified via its prefix, which replaces all the normally supplied 'yy' prefix, hence making it possible to have multiple parsers in a single executable. IdentifiedLexDependTarget(program,lexic,parser,prefix) IdentifiedYaccTarget(program,parser,prefix) ------------------------------------------------------------------------ IdentifiedYaccTarget(program,base,prefix): Declare a yacc base.y file which should produce a base.c and base.h file as derived from the output of yacc, to be used by the specified program. The specified prefix is used to remplace all the 'yy' in the generated file, for use when more than a single parser is needed in one executable. ComplexYaccTarget(program,base,prefix) ComplexYaccInclude(base,prefix) ------------------------------------------------------------------------ IncludesSubdirs(): Generate rules to recursively put include files in build NamedTargetSubdirs(includes,including,/**/) ------------------------------------------------------------------------ Initialize(symbol,value): Puts the line symbol = value in the initialization section of Makefile.SH (the one that is subject to parameter substitutions). symbol = value ------------------------------------------------------------------------ InstallLibrary(libname,dest): Generate rules to install the indicated library. local_install:: lib/**/libname.a _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 644 lib/**/libname.a $(INSTALL_PREFIX)/***/dest $(RANLIB) dest/lib/**/libname.a chmod 444 dest/lib/**/libnane.a local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/lib/**/libname.a ------------------------------------------------------------------------ InstallLibraryAlias(libname,alias,dest): Generate rules to create a link from one library name to another for the purposes of aliasing. local_install:: lib/**/libname.a $(RM) lib/**/alias.a -(cd dest; $(LN) lib/**/libname.a lib^^alias.a) local_deinstall:: $(RM) dest/lib/**/alias.a ------------------------------------------------------------------------ InstallLintLibrary(libname,dest): Generate rules to install the indicated lint library. install.ln:: llib-l/**/libname.ln _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 444 llib-l/**/libname.ln $(INSTALL_PREFIX)/***/dest deinstall.ln:: $(RM) $(INSTALL_PREFIX)/***/dest/llib-l/**/libname.ln ------------------------------------------------------------------------ InstallManPage(file,dest): Generate rules to install the indicated manual page. InstallManPageLong(file,dest,file) ------------------------------------------------------------------------ InstallManPageLong(file,destdir,dest): Generate rules to install the indicated manual page, giving it an alternate name. This is used for installing man pages whose base name without the .man suffix would normally be longer than 8 characters (the limit for using source code control systems on files systems with short file names). local_install.man:: file.man _MakeInstallDirIgnore(destdir) \ $(INSTALL) -c -m 444 file.man $(INSTALL_PREFIX)/***/destdir/dest.$(L) local_deinstall.man:: $(RM) $(INSTALL_PREFIX)/***/destdir/dest.$(L) ------------------------------------------------------------------------ InstallManScripts(): Generate rule to install/deinstall manual pages for scripts listed in the automatically generated $(SCRIPTS) macro. |once _InstallManScripts_ #ifndef NOMAN local_install.man:: _MakeInstallDirIgnore($(MANSRC)) \ for file in $(SCRIPTS); do \ if test -f $$file.man; then \ (set -x; \ $(INSTALL) -c -m 444 $$file.man \ $(INSTALL_PREFIX)$(MANSRC)/$$file.$(L)) || \ exit 1; \ fi; \ done local_deinstall.man:: case '${MFLAGS}' in *[i]*) set +e;; esac; \ for file in $(SCRIPTS); do \ (set -x; $(RM) $(INSTALL_PREFIX)$(MANSRC)/$$file.$(L)); \ done #endif -once ------------------------------------------------------------------------ InstallManSubdirs(): Generate rules to recursively install and deinstall manual pages. NamedSubTargetSubdirs(install.man,"Installing man pages",/**/) NamedDepthTargetSubdirs(deinstall.man,"Deinstalling man pages",/**/) ------------------------------------------------------------------------ InstallMultiple(list,dest): Generate rules to install multiple files at once during the install step of the build using any install flags set in $(INSTALLFLAGS) and deinstall them. InstallMultipleDestFlags(local_install,list,dest,$(INSTALLFLAGS)) DeinstallMultipleDest(local_deinstall,list,dest) ------------------------------------------------------------------------ InstallMultipleDestFlags(step,list,dest,flags): Generate rules to install multiple files at once during a particular step in the build using a specific set of install flags. step:: list _MakeInstallDirIgnore(dest) \ for i in list; do \ (set -x; $(INSTALL) -c flags \ $$i $(INSTALL_PREFIX)/***/dest) || exit 1;\ done ------------------------------------------------------------------------ InstallMultipleFlags(list,dest,flags): Generate rules to install multiple files at once during the install step of the build using the given install flags. InstallMultipleDestFlags(local_install,list,dest,flags) DeinstallMultipleDest(local_deinstall,list,dest) ------------------------------------------------------------------------ InstallMultipleMan(list,dest): Generate rules to install a variety of manual pages during the install.man step of the build. InstallMultipleDestFlags(local_install.man,list,dest,$(INSTALLFLAGS)) DeinstallMultipleDest(local_deinstall.man,list,dest) ------------------------------------------------------------------------ InstallNonExec(file,dest): Generate rules to install a data file using any special install flags. local_install:: file _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 444 file $(INSTALL_PREFIX)/***/dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/file ------------------------------------------------------------------------ InstallProgram(program,dest): Generate rules to install an executable program using any special install flags set in $(INSTALLFLAGS). InstallProgramWithFlags(program,dest,/**/) ------------------------------------------------------------------------ InstallProgramNoStrip(program,dest): Generate rules to install an executable program using any special install flags set in $(INSTALLFLAGS), but without stripping the executable from debugging symbols. InstallProgramNoStripWithFlags(program,dest,/**/) ------------------------------------------------------------------------ InstallProgramNoStripWithFlags(program,dest,flags): Generate rules to install an executable program using given install flags. local_install:: program _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 555 flags program/***/$(_EXE) $(INSTALL_PREFIX)/**/^dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/program/**/^$(_EXE) ------------------------------------------------------------------------ InstallProgramWithFlags(program,dest,flags): Generate rules to install an executable program using given install flags. local_install:: program _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -s -m 555 flags program/***/$(_EXE) $(INSTALL_PREFIX)/**/^dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/program/**/^$(_EXE) ------------------------------------------------------------------------ InstallScript(script,dest): Generate rules to install an executable script using any special install flags set in $(INSTALLFLAGS). InstallScriptWithFlags(script,dest,/**/) ------------------------------------------------------------------------ InstallScriptWithFlags(script,dest,flags): Generate rules to install an executable script using given install flags. local_install:: script _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 555 flags script $(INSTALL_PREFIX)/***/dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/script ------------------------------------------------------------------------ InstallScripts(): Generate rules to install all the scripts listed in the generated $(SCRIPTS) and $(LSCRIPTS) macros. |once _InstallScripts_ local_install:: $(SCRIPTS) $(LSCRIPTS) _MakeInstallDirIgnore($(SCRIPTDIR)) \ for file in $(SCRIPTS) $(LSCRIPTS); do \ (set -x; \ $(INSTALL) -c -m 555 $$file $(INSTALL_PREFIX)$(SCRIPTDIR)) || \ exit 1; \ done local_deinstall:: @for file in $(SCRIPTS) $(LSCRIPTS); do \ case '${MFLAGS}' in *[i]*) set +e;; esac; \ (set -x; $(RM) $(INSTALL_PREFIX)$(SCRIPTDIR)/$$file); \ done -once ------------------------------------------------------------------------ InstallSharedLibrary(libname,rev,dest): Generate rules to install the shared library. local_install:: lib/**/libname.so.rev _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 444 lib/**/libname.so.rev $(INSTALL_PREFIX)/***/dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/lib/**/libname.so.rev ------------------------------------------------------------------------ InstallSharedLibraryData(libname,rev,dest): Generate rules to install the shared library data local_install:: lib/**/libname.sa.rev _MakeInstallDirIgnore(dest) \ $(INSTALL) -c -m 444 lib/**/libname.sa.rev $(INSTALL_PREFIX)/***/dest local_deinstall:: $(RM) $(INSTALL_PREFIX)/***/dest/lib/**/libname.sa.rev ------------------------------------------------------------------------ InstallSubdirs(): Generate rules to recursively install and deinstall programs and files. NamedSubTargetSubdirs(install,"Installing",/**/) NamedDepthTargetSubdirs(deinstall,"Deinstalling",/**/) ------------------------------------------------------------------------ InstallTarget(): Generate rules to recursively install files (if SUBDIRS) install:: local_install sub_install (not SUBDIRS) install:: local_install (if SUBDIRS) install.man:: maybe_install.man sub_install.man (not SUBDIRS) install.man:: maybe_install.man (if SUBDIRS) deinstall:: sub_deinstall local_deinstall (not SUBDIRS) deinstall:: local_deinstall (if SUBDIRS) deinstall.man:: sub_deinstall.man maybe_deinstall.man (not SUBDIRS) deinstall.man:: maybe_deinstall.man (if MANSRC) install.man-yes: local_install.man install.man-no: (if MANSRC) deinstall.man-yes: local_deinstall.man deinstall.man-no: ------------------------------------------------------------------------ LinkFileList(step,list,dir,sub): Link a list of list of files from one place to another step:: list @case '${MFLAGS}' in *[i]*) set +e;; esac; \ echo " cd" dir; cd dir; for i in list; do (set -x; $(LN) sub/$$i .); done ------------------------------------------------------------------------ LinkSourceFile(src,dir): Snag source file from some other directory src: dir/src $(RM) $@ $(LN) $? $@ ------------------------------------------------------------------------ LintDirs(dirs): Generate rules to recursively lint directories as part of the make lint step. MakeLintSubdirs(dirs,lint) ------------------------------------------------------------------------ LintLibraryTarget(libname,srclist): Generate rules to create a lint library. Note that the lint library is always forced to be newer than the library itself. lintlib:: llib-l/**/libname.ln llib-l/**/libname.ln: srclist $(RM) $@ $(LINT) $(LINTLIBFLAG)/**/libname $(LINTFLAGS) srclist ------------------------------------------------------------------------ LintSubdirs(): Generate rules to recursively lint directories as part of the make lint step. LintDirs($(SUBDIRS)) ------------------------------------------------------------------------ LintTarget(): Generate rules to lint $(SOURCES) (automatically generated) |once _LintTarget_ NormalLintTarget($(SOURCES)) -once ------------------------------------------------------------------------ MakeDirectories(step,dirs): Generate rules to create a hierarchy of directories. step:: MakeDirs(dirs) ------------------------------------------------------------------------ MakeDirs(dirs): Creates a set of directories, even if some directories in the path do not already exist. There should be no '@!' at the end of the '#define' line, because this macro is used *inside* building rules. @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for dir in dirs; do \ (set -x; test -d $$dir || $(INSTALLDIR) $$dir) || \ exit 1; \ done ------------------------------------------------------------------------ MakeInstallDirectories(dirs): Generate a rule to create a set of directories at installation time (removed by deinstall). local_install:: _MakeInstallDirs(dirs) local_deinstall:: _RmInstallDirs(dirs) ------------------------------------------------------------------------ MakeLintLibSubdirs(dirs): Generate rules to recursively create lint libraries. MakeLintSubdirs(dirs,lintlib) ------------------------------------------------------------------------ MakeLintSubdirs(dirs,target): Generate rules to recursively lint directories as part of the named step. NamedTargetSubdirsRule(dirs,target,"Linting",/**/) ------------------------------------------------------------------------ MakeMakeSubdirs(target): Generate rules to recursively recreate target as part of the specified step in the build. This assumes Makefile.SH has already been built (which is the case for a delivery), but does not rely on the existence of a Makefile. target:: @case '${MFLAGS}' in *[ik]*) set +e;; esac; \ for i in $(SUBDIRS);\ do \ echo "Making "target" in $(DIR)$$i..."; \ (cd $$i || exit 1; \ if test ! -f Makefile; then /bin/sh Makefile.SH; fi; \ $(MAKE) $(MFLAGS) target) || exit 1;\ done ------------------------------------------------------------------------ MakeMakefilesSH(): Generate rules to recursively recreate target as part of the specified step in the build. If $(TOP) is set to an absolute path, don't prepend the ../ prefix. This makes running things outside of the source tree to be much easier. Makefiles.SH:: Makefile.SH @case '${MFLAGS}' in *[ik]*) set +e;; esac; \ for i in $(SUBDIRS);\ do \ case "$(DIR)$$i/" in \ /**/*^^/^^*^^/^^*^^/^^*^^/) newtop=../../../..;; \ /**/*^^/^^*^^/^^*^^/) newtop=../../..;; \ /**/*^^/^^*^^/) newtop=../..;; \ */**//) newtop=..;; \ esac; \ case "$(TOP)" in \ //**/*) newtop="$(TOP)" ;; \ esac; \ echo "Making Makefiles.SH in $(DIR)$$i..."; \ (cd $$i || exit 1; \ if test -f Jmakefile; then \ $(MAKE) $(MFLAGS) -f ../Makefile \ Makefile TOP=$$newtop CURRENT=$(DIR)$$i && \ $(MAKE) $(MFLAGS) Makefiles.SH; \ fi; \ ) || exit 1; \ done ------------------------------------------------------------------------ MakeScriptFromCpp(name,defs): Generate rules to create a script from a file with a .cpp suffix. CppScriptTarget(name,name.cpp,defs,/**/) ------------------------------------------------------------------------ MakeSubdirs(): Generate rules to do makes in the given subdirectories. NamedTargetSubdirs(all,"Making all",/**/) ------------------------------------------------------------------------ MakeSubincludesForBuild(step,dir,srclist): Make includes in sub directories. step:: dir srclist @-(list=`echo srclist | sed -e 's/[^ ]*\///g'`; \ set -x; cd dir; $(RM) $$list) @for i in srclist; do \ (set -x; cd dir; $(LN) ../$$i .) || exit 1; \ done MakeDirectories(dir,dir) local_realclean:: @-(if [ -d dir ]; then \ list=`echo srclist | sed -e 's/[^ ]*\///g'`; \ set -x; cd dir; $(RM) $$list; fi) ------------------------------------------------------------------------ MakefileSubdirs(): Generate rules to create Makefiles. MakeMakeSubdirs(Makefiles) MakeMakefilesSH() ------------------------------------------------------------------------ MakefileTarget(): Generate rules to build a normal Makefile. BuildMakefileSH(/**/) BuildMakefile() ------------------------------------------------------------------------ NamedDepthTargetSubdirs(name,verb,flags): Recursively make a series of steps. We first enter the subdirectories, then perform the local entries. The supplied "name" has "sub_" prefixed to it. sub_/***/name:: @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags @echo "Back to $(CURRENT) for "name/**/... ------------------------------------------------------------------------ NamedSubTargetSubdirs(name,verb,flags): Recursively make a series of steps, like NamedTargetSubdirs. However, the supplied "name" has "sub_" prefixed to it. sub_/***/name:: @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags ------------------------------------------------------------------------ NamedTargetSubdirs(name,verb,flags): Recursively make a series of steps. name:: @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags ------------------------------------------------------------------------ NamedTargetSubdirsRule(dirs,name,verb,flags): Recursively make a series of steps in the specified directories. name:: @case '${MFLAGS}' in *[ik]*) set +e;; esac; \ for i in dirs ;\ do \ (cd $$i ; echo verb "in $(DIR)$$i..."; \ $(MAKE) $(MFLAGS) flags name) || exit 1; \ done ------------------------------------------------------------------------ NoManPages(): Actually forces the definition of NOMAN, which tells the jmake program to not generate rules for installing manual pages. -> NOMAN. ------------------------------------------------------------------------ NormalLexDependTarget(program,base,parser): Declare that program will need an include file produced by the output of lex on base.l, which typically produces a file named lex.yy.c which will be renamed as base.c. Besides, the lexical analyzer needs the file parser.h produced by running parser.y through yacc and renaming y.tab.h as parser.h. base.o: parser.h SimpleLexTarget(program,base) ------------------------------------------------------------------------ NormalLibraryObjectRule(): Generate make rules to build "normal" objects. |once _ObjectRule_ .c.o: $(RM) $@ $(CC) -c $(JCFLAGS) $< -once ------------------------------------------------------------------------ NormalLibraryTarget(libname,srclist,objlist): Generate rules to create a library. The 'srclist' and 'objlist' parameters are added to SOURCES and OBJECTS macros. The 'srclist' is not otherwise used by this rule, but is necessary for make depend. OBJECTS += objlist SOURCES += srclist NormalLibraryObjectRule() AllTarget(lib/**/libname.a) lib/**/libname.a: objlist $(RM) $@ $(AR) $@ objlist $(RANLIB) $@ ------------------------------------------------------------------------ NormalLibraryTarget2(libname,srclist,objlist1,objlist2): Generate rules to create a library in two steps. This is used to create libraries with large numbers of files. SOURCES += srclist OBJECTS += objlist1 OBJECTS += objlist2 NormalLibraryObjectRule() AllTarget(lib/**/libname.a) lib/**/libname.a: objlist1 objlist2 $(RM) $@ $(AR) $@ objlist1 $(AR) $@ objlist2 $(RANLIB) $@ ------------------------------------------------------------------------ NormalLintTarget(srclist): Generate rules to lint a set of sources. lint: $(LINT) $(LINTFLAGS) srclist $(LINTLIBS) ------------------------------------------------------------------------ NormalObjectRule(): Generate make rule to build usual object files. |once _ObjectRule_ .c.o: $(CC) -c $(JCFLAGS) $< -once ------------------------------------------------------------------------ NormalObjectTarget(file): Generate rules to produce a single object file.o from a file.c. SOURCES += file/**/.c AllTarget(file/**/.o) NormalObjectRule() ------------------------------------------------------------------------ NormalParserTarget(program,lexic,parser): Specify that program is using the lex/yacc combination to produce a parser. The lexic and parser parameters are the base name of the .l and .y file, respectively. NormalLexDependTarget(program,lexic,parser) NormalYaccTarget(program,parser) ------------------------------------------------------------------------ NormalProgramTarget(program,sources,objects): Generate rules to compile and link the indicated program; since it does not use any default object files, it may be used for multiple programs in the same Jmakefile. OBJECTS += objects SOURCES += sources NormalObjectRule() AllTarget(program) program: objects RemoveTargetProgram($@) $(CC) -o $@ objects $(JLDFLAGS) $(LIBS) ------------------------------------------------------------------------ NormalRelocatableTarget(objname,objlist): Generate rules to produce a relocatable object file instead of a library. AllTarget(objname.o) objname.o: objlist $(RM) $@ $(LD) $(JLDFLAGS) -r objlist -o $@ ------------------------------------------------------------------------ NormalSharedLibraryDataTarget(libname,rev,salist): Generate rules to create shlib data file; build it into a different name so that the we don't hose people by having the library gone for long periods. AllTarget(lib/**/libname.sa.rev) lib/**/libname.sa.rev: salist $(RM) $@ $(AR) $@ salist $(RANLIB) $@ ------------------------------------------------------------------------ NormalSharedLibraryTarget(libname,rev,solist): Generate rules to create a shared library; build it into a different name so that the we don't hose people by having the library gone for long periods. AllTarget(lib/**/libname.so.rev) lib/**/libname.so.rev: solist $(RM) $@~ (cd shared; $(LD) -o ../$@~ -assert pure-text solist) $(RM) $@ $(MV) $@~ $@ ------------------------------------------------------------------------ NormalYaccTarget(program,base): Declare a yacc base.y file which should produce a base.c and base.h file as derived from the output of yacc, to be used by the specified program. SimpleYaccTarget(program,base) SimpleYaccInclude(base) ------------------------------------------------------------------------ PrelinkedRelocatableTarget(objname,objlist,libs): Generate rules to produce a relocatable object file instead of a library. AllTarget(objname.o) objname.o: objlist $(RM) $@ $(LD) $(JLDFLAGS) -r objlist -o $@ libs ------------------------------------------------------------------------ ProfiledLibraryObjectRule(): Generate make rules to build both profiled and "normal" objects. all:: @if [ ! -d profiled ]; then mkdir profiled; fi .c.o: $(RM) $@ profiled/$@ $(CC) -pg -c $(JCFLAGS) $*.c $(MV) $*.o profiled/$*.o $(CC) -c $(JCFLAGS) $*.c local_clean:: -@if [ -d profiled ]; then echo " $(RM) profiled/?*.o"; \ $(RM) profiled/?*.o; fi ------------------------------------------------------------------------ ProfiledLibraryTarget(libname,srclist,objlist): Generate rules to create a profiled library. SOURCES += srclist OBJECTS += objlist AllTarget(lib/**/libname^^_p.a) lib/**/libname^^_p.a: objlist $(RM) $@ cd profiled; $(AR) ../$@ objlist $(RANLIB) $@ ------------------------------------------------------------------------ ProfiledRelocatableTarget(objname,objlist): Generate rules to produce a profiled relocatable object file instead of a library. AllTarget(objname/**/_p.o) objname/**/_p.o: objlist $(RM) $@ $(LD) -X -r objlist -o $@ ------------------------------------------------------------------------ RemoteDependency(directory,dependency): Specify rules for making a remote dependency. ForceTarget() |once =directory//***/dependency= directory//***/dependency: .FORCE @echo "Checking "/***/dependency" in "/**/^directory"..." cd /***/directory; $(MAKE) /**/^dependency @echo "Continuing in $(CURRENT)..." -once ------------------------------------------------------------------------ RemoteTargetDependency(target,directory,dependency): A local target may rely on a remote dependency (e.g. a library) made in a separate directory. This rule explicits the dependency and forces a make of that dependency in the remote directory. RemoteDependency(directory,dependency) target: directory//***/dependency ------------------------------------------------------------------------ RemoveTargetProgram(program): This is used in some other macros in order to remove the target before starting its building (saves disk space). There should be no '@!' at the end of the '#define' line, because this macro is used *inside* building rules. $(RM) program if test -f program/***/$(_EXE); then \ $(MV) program/***/$(_EXE) program/**/~^^^$(_EXE); fi ------------------------------------------------------------------------ SetSubdirs(subdirs): Actually forces the definition of SUBDIRS, and lets the user specify what the sub-directories are. This will be added to the customization part. -> SUBDIRS. SUBDIRS = subdirs ------------------------------------------------------------------------ SharedAndDebuggedLibraryObjectRule(): Generate make rules to build shared, debuggable, and "normal" object files. all:: @if [ ! -d shared ]; then mkdir shared; fi @if [ ! -d debugger ]; then mkdir debugger; fi .c.o: $(RM) $@ shared/$@ debugger/$@ $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) $*.c $(MV) $*.o shared/$*.o $(CC) -g -c $(SHLIBDEF) $(JCFLAGS) $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(SHLIBDEF) $(JCFLAGS) $*.c local_clean:: -@if [ -d shared ]; then echo " $(RM) shared/?*.o"; \ $(RM) shared/?*.o; fi -@if [ -d debugger ]; then echo " $(RM) debugger/?*.o"; \ $(RM) debugger/?*.o; fi ------------------------------------------------------------------------ SharedLibraryObjectRule(): Generate make rules to build shared and "normal" object files. all:: @if [ ! -d shared ]; then mkdir shared; fi .c.o: $(RM) $@ shared/$@ $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) $*.c $(MV) $*.o shared/$*.o $(CC) -c $(SHLIBDEF) $(JCFLAGS) $*.c local_clean:: -@if [ -d shared ]; then echo " $(RM) shared/?*.o"; \ $(RM) shared/?*.o; fi ------------------------------------------------------------------------ ShellScriptLongTarget(basename,scriptname): Generate rules to create a set of scripts from .SH files where the name of the generated file is different from the basename of the .SH file (when, for instance, the total length with the .SH extension would not leave enough space for RCS ,v extension). LSCRIPTS += scriptname AllTarget(scriptname) scriptname: basename/**/.SH /bin/sh basename/**/.SH InstallScripts() #ifndef NOMAN InstallManPageLong(basename,$(MANSRC),scriptname) #endif ------------------------------------------------------------------------ ShellScriptTarget(scripts): Generate rules to create and install a set of scripts from .SH files. Man pages derived from the name of the scripts are also installed unless NoManPages() is specified. ShellScriptTargetExt(scripts,.SH) ------------------------------------------------------------------------ ShellScriptTargetExt(scripts,ext): Generate rules to create and install a set of scripts from ext files (.sh and .SH are the most common examples). Man pages derived from the name of the scripts are also installed unless NoManPages() is specified. SCRIPTS += scripts SimpleShellScriptTargetExt(scripts,ext) InstallScripts() InstallManScripts() ------------------------------------------------------------------------ SimpleLexTarget(program,base): This declares a lex base.l file which is to be ran through lex to produce a base.c file. SOURCES += base.l OBJECTS += base.o |once _LexRule_ .l.c: $(LEX) $(JLFLAGS) $< $(MV) lex.yy.c $@ -once AddSuffix(.l) program: base.c local_realclean:: $(RM) base.c ------------------------------------------------------------------------ SimpleProgramTarget(program): Generate rules for compiling and linking programs that only have one C source file. It should only be used in Jmakefiles that describe a single program. NormalProgramTarget(program,program.c,program.o) ------------------------------------------------------------------------ SimpleShellScriptTarget(scripts): Generate rules to create a set of scripts from .SH files. SimpleShellScriptTargetExt(scripts,.SH) ------------------------------------------------------------------------ SimpleShellScriptTargetExt(scripts,ext): Generate rules to create a set of scripts from ext files where ext is usually something like .sh or .SH, or whatever file extension you like.. AllTarget(scripts) |expand s!scripts! !s: !s/**/ext /bin/sh !s/**/ext -expand ------------------------------------------------------------------------ SimpleYaccInclude(base): Declare that program will need an include file produced by the output of yacc on base.y, which typically produces a file named y.tab.h, which will be renamed as base.h. The only problem is that the dependencies towards base.h have to be manually given in the Jmakefile. base.h: base.c @if test -f y.tab.h; then \ echo " $(MV) y.tab.h $@"; \ $(MV) y.tab.h $@; \ fi local_realclean:: $(RM) base.h ------------------------------------------------------------------------ SimpleYaccTarget(program,base): Declare a yacc base.y file to be used in the building of the specified target program. The source file must be given without its final .y extension. The name of the .c and .o will be derived from the source file basename provided. SOURCES += base.y OBJECTS += base.o YaccRule() program: base.c local_realclean:: $(RM) base.c ------------------------------------------------------------------------ SingleProgramTarget(program,objects,libs): Obsolete version of NormalProgramTarget that doesn't have deplibs. NormalProgramTarget(program,objects,libs) ------------------------------------------------------------------------ SpecialDebuggedAndProfiledObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make debuggable and profiled versions. all:: @if [ ! -d profiled ]; then mkdir profiled; fi @if [ ! -d debugger ]; then mkdir debugger; fi objs: depends $(RM) $@ profiled/$@ debugger/$@ $(CC) -pg -c $(JCFLAGS) options $*.c $(MV) $*.o profiled/$*.o $(CC) -g -c $(JCFLAGS) options $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialDebuggedObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make a debuggable version. all:: @if [ ! -d debugger ]; then mkdir debugger; fi objs: depends $(RM) $@ debugger/$@ $(CC) -g -c $(JCFLAGS) options $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialObjectRule(objs,depends,options): Generate rules to compile a file with special flags. objs: depends $(RM) $@ $(CC) -c $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialProfiledObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make a profiled version. all:: @if [ ! -d profiled ]; then mkdir profiled; fi objs: depends $(RM) $@ profiled/$@ $(CC) -pg -c $(JCFLAGS) options $*.c $(MV) $*.o profiled/$*.o $(CC) -c $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialSharedAndDebuggedObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make shared and debuggable versions. all:: @if [ ! -d shared ]; then mkdir shared; fi @if [ ! -d debugger ]; then mkdir debugger; fi objs: depends $(RM) $@ shared/$@ debugger/$@ $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) options $*.c $(MV) $*.o shared/$*.o $(CC) -g -c $(SHLIBDEF) $(JCFLAGS) options $*.c $(MV) $*.o debugger/$*.o $(CC) -c $(SHLIBDEF) $(JCFLAGS) options $*.c ------------------------------------------------------------------------ SpecialSharedObjectRule(objs,depends,options): Generate rules to compile a file with special flags and to make shared and debuggable versions. all:: @if [ ! -d shared ]; then mkdir shared; fi objs: depends $(RM) $@ shared/$@ $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) options $*.c $(MV) $*.o shared/$*.o $(CC) -c $(SHLIBDEF) $(JCFLAGS) options $*.c ------------------------------------------------------------------------ TagSubdirs(dirs): Generate rules to recursively create tags files. NamedTargetSubdirsRule(dirs,tag,"Tagging",/**/) ------------------------------------------------------------------------ TagsTarget(): Generate rules to compute tags files for C source code. tags:: $(CTAGS) -w *.[ch] $(CTAGS) -xw *.[ch] > tags local_clobber:: $(RM) tags ------------------------------------------------------------------------ YaccRule(): This is the rule which is used to build a .c file from a .y file. AddSuffix(.y) |once _YaccRule_ .y.c: $(YACC) $(JYFLAGS) $< $(MV) y.tab.c $@ -once ------------------------------------------------------------------------ _MakeInstallDir(dir): Internal macro to create a missing install directory. (set -x; test -d $(INSTALL_PREFIX)/***/dir || \ $(INSTALLDIR) $(INSTALL_PREFIX)/***/dir); ------------------------------------------------------------------------ _MakeInstallDirIgnore(dir): Same as _MakeInstallDir but handles "make -i" as well. @case '${MFLAGS}' in *[i]*) set +e;; esac; \ _MakeInstallDir(dir) ------------------------------------------------------------------------ _MakeInstallDirs(dirs): Creates a set of intall directories, even if some directories in the path do not already exist. There should be no '@!' at the end of the '#define' line, because this macro is used *inside* building rules. @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for dir in dirs; do \ _MakeInstallDir($$dir) \ done ------------------------------------------------------------------------ _RmInstallDirs(dirs): Removes a set of intall directories. There should be no '@!' at the end of the '#define' line, because this macro is used *inside* building rules. @case '${MFLAGS}' in *[i]*) set +e;; esac; \ for dir in dirs; do \ (set -x; test -d $$dir && $(RM) -r $(INSTALL_PREFIX)$$dir); \ done ------------------------------------------------------------------------