dist/Index

   1 [This Index is automatically generated from Jmake.rules file. Do not
   2 edit this file or your changes will be lost. Edit Jmake.rules instead.]
   3
   4 This file contains a listing of all the macros that can be used in a
   5 Jmakefile. Only a few of these should be used in the Jmakefile (they
   6 are the top-level macros). However, some low-level ones may be useful,
   7 but it is up to you to make that decision. This explains why this file
   8 holds all the available macros for jmake.
   9
  10 In the following listing, the macros are separated by a line of dashes.
  11 The signature of the macro is given, then a small comment of what it
  12 does precedes the actual definition.
  13
  14 Lines preceded by '->' show the set of symbols defined when the macro is
  15 used. Initialization lines are shown as-is, i.e. have the form SYM = val
  16 while concatenation is shown by SYM += val (which means val is added to
  17 the value of SYM).
  18
  19 Conditional lines are preceded by tests like (if SYM). This means the line
  20 is to be kept if and only if the symbol SYM is defined. Other internal
  21 requests are not formatted yet.
  22
  23 ------------------------------------------------------------------------
  24 AddSuffix(ext):
  25     Adds a sufix to the .SUFFIXES: list.
  26
  27     .SUFFIXES: ext
  28
  29 ------------------------------------------------------------------------
  30 AddedByConfigure(files):
  31     Gives name of the files generated by Configure that can safely
  32     be removed when a "make clobber" is issued. Not that it is useless
  33     to name config.h or config.sh because these are already taken care
  34     of by jmake.
  35
  36     local_clobber::
  37         $(RM) files
  38
  39 ------------------------------------------------------------------------
  40 AliasedLibraryTarget(libname,alias):
  41     Generate rules to link one library to another.
  42
  43     AllTarget(lib/**/alias.a)
  44
  45     lib/**/alias.a: lib^^libname.a
  46         $(RM) $@
  47         $(LN) lib/**/libname.a $@
  48
  49 ------------------------------------------------------------------------
  50 AllTarget(depends):
  51     Generate rules to build necessary things during make all.
  52
  53     all:: depends
  54
  55     local_realclean::
  56         $(RM) depends
  57
  58 ------------------------------------------------------------------------
  59 BuildMakefile():
  60     Generate rules to build a Makefile from a Makefile.SH.
  61
  62     Makefile: Makefile.SH
  63         /bin/sh Makefile.SH
  64
  65 ------------------------------------------------------------------------
  66 BuildMakefileSH(jmakeflags):
  67     Generate rules to build a Makefile.SH from an Jmakefile and any
  68     special jmake flags.  This is generally done automatically by the
  69     template or by any special Jmakefiles.
  70     This function will simply touch Makefile.SH if no $(TOP)/.package
  71     exists, assuming the Jmakefile is not in a production environment.
  72
  73     Makefile.SH: Jmakefile
  74         -@if test -f $(TOP)/.package; then \
  75             if test -f Makefile.SH; then \
  76                 echo "    $(RM) Makefile.SH~; $(MV) Makefile.SH Makefile.SH~"; \
  77                 $(RM) Makefile.SH~; $(MV) Makefile.SH Makefile.SH~; \
  78             fi; \
  79             echo "    $(JMAKE) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT)" jmakeflags; \
  80             $(JMAKE) -DTOPDIR=$(TOP) -DCURDIR=$(CURRENT) jmakeflags; \
  81         else touch $@; fi
  82
  83 ------------------------------------------------------------------------
  84 CleanSubdirs():
  85     Generate rules to recursively clean out garbage files.
  86
  87     NamedDepthTargetSubdirs(clean,"Cleaning",/**/)
  88     NamedDepthTargetSubdirs(realclean,"Real cleaning",/**/)
  89     NamedDepthTargetSubdirs(clobber,"Clobbering",/**/)
  90
  91 ------------------------------------------------------------------------
  92 CleanTarget():
  93     Generate rules to remove any garbage files.
  94
  95     (if SUBDIRS) clean: sub_clean local_clean
  96     (not SUBDIRS) clean: local_clean
  97     (if SUBDIRS) realclean: sub_realclean local_realclean
  98     (not SUBDIRS) realclean: local_realclean
  99     (if SUBDIRS) clobber: sub_clobber local_clobber
 100     (not SUBDIRS) clobber: local_clobber
 101
 102     local_clean::
 103         if test -f core; then $(RM) core; fi
 104         $(RM) *~ *.o
 105
 106     local_realclean:: local_clean
 107     (if TOP)  $(RM) -r UU
 108
 109     local_clobber:: local_realclean
 110     (not TOP)  $(RM) Makefile config.sh
 111     (if TOP)  $(RM) config.sh config.h
 112     (if TOP)  $(RM) -r .config
 113     (if TOP)  $(RM) Makefile
 114
 115 ------------------------------------------------------------------------
 116 CommonSubdirsRule(dirs):
 117     Rule for making $(TARGET) in every subdirectory, with $(VERB) as
 118     verbose message and $(FLAGS) as additional flags.
 119
 120     subdirs:
 121         @case '${MFLAGS}' in *[ik]*) set +e;; esac; \
 122         for i in dirs ;\
 123         do \
 124             (cd $$i ; echo $(VERB) "in $(DIR)$$i..."; \
 125                 $(MAKE) $(MFLAGS) $(FLAGS) $(TARGET)) || exit 1; \
 126         done
 127
 128 ------------------------------------------------------------------------
 129 ComplexProgramTarget(program):
 130     Generate rules for compiling and linking the program specified by
 131     $(OBJS) and $(SRCS), installing the program and its man page, and
 132     generating dependencies.  It should only be used in Jmakefiles
 133     that describe a single program.
 134
 135         OBJECTS += $(OBJS)
 136         SOURCES += $(SRCS)
 137
 138     NormalObjectRule()
 139     AllTarget(program)
 140
 141     program: $(OBJS)
 142         RemoveTargetProgram($@)
 143         $(CC) -o $@ $(OBJS) $(JLDFLAGS) $(LIBS)
 144
 145     InstallProgram(program,$(BINDIR))
 146     InstallManPage(program,$(MANSRC))
 147     DependTarget()
 148     LintTarget()
 149
 150 ------------------------------------------------------------------------
 151 ComplexProgramTarget_1(program):
 152     Generate rules for compiling and linking the program specified by
 153     $(OBJS1) and $(SRCS1), installing the program and its man page,
 154     and generating dependencies for it and any programs described by
 155     $(SRCS2) and $(SRCS3).  It should be used to build the primary
 156     program in Jmakefiles that describe multiple programs.
 157
 158         OBJECTS += $(OBJS1)
 159         SOURCES += $(SRCS1)
 160
 161     NormalObjectRule()
 162     AllTarget(program)
 163
 164     program: $(OBJS1)
 165         RemoveTargetProgram($@)
 166         $(CC) -o $@ $(OBJS1) $(JLDFLAGS) $(LIBS)
 167
 168     InstallProgram(program,$(BINDIR))
 169     InstallManPage(program,$(MANSRC))
 170
 171     DependTarget()
 172     LintTarget()
 173
 174 ------------------------------------------------------------------------
 175 ComplexProgramTarget_2(program):
 176     Generate rules for compiling and linking the program specified by
 177     $(OBJS2) and $(SRCS2) and installing the program and man page.
 178     It should be used to build the second program in Jmakefiles
 179     describing more than one program.
 180
 181         OBJECTS += $(OBJS2)
 182         SOURCES += $(SRCS2)
 183
 184     NormalObjectRule()
 185     AllTarget(program)
 186
 187     program: $(OBJS2)
 188         RemoveTargetProgram($@)
 189         $(CC) -o $@ $(OBJS2) $(JLDFLAGS) $(LIBS)
 190
 191     InstallProgram(program,$(BINDIR))
 192     InstallManPage(program,$(MANSRC))
 193
 194 ------------------------------------------------------------------------
 195 ComplexProgramTarget_3(program):
 196     Generate rules for compiling and linking the program specified by
 197     $(OBJS3) and $(SRCS3) and installing the program and man page.  It
 198     should be used to build the third program in Jmakefiles describing
 199     more than one program.
 200
 201         OBJECTS += $(OBJS3)
 202         SOURCES += $(SRCS3)
 203
 204     NormalObjectRule()
 205     AllTarget(program)
 206
 207     program: $(OBJS3)
 208         RemoveTargetProgram($@)
 209         $(CC) -o $@ $(OBJS3) $(JLDFLAGS) $(LIBS)
 210
 211     InstallProgram(program,$(BINDIR))
 212     InstallManPage(program,$(MANSRC))
 213
 214 ------------------------------------------------------------------------
 215 ComplexShellManualTarget(manpages):
 216     Builds manual pages that are to be extracted from .SH files into
 217     .$manext files.
 218
 219         MANPAGE += manpages
 220
 221     |once _ShellManualRule_
 222     .SH.$manext:
 223         /bin/sh $<
 224
 225     -once
 226     AddSuffix(.SH)
 227     AddSuffix(.$manext)
 228     AllTarget(manpages)
 229
 230     local_install.man::
 231         _MakeInstallDirIgnore($(MANSRC)) \
 232         for file in manpages; do \
 233             (set -x; $(INSTALL) -c -m 444 $$file \
 234                 $(INSTALL_PREFIX)$(MANSRC)) || exit 1; \
 235         done
 236
 237     local_deinstall.man::
 238         @case '${MFLAGS}' in *[i]*) set +e;; esac; \
 239         for file in manpages; do \
 240             (set -x; $(RM) $(INSTALL_PREFIX)$(MANSRC)/$$file); \
 241         done
 242
 243 ------------------------------------------------------------------------
 244 ComplexYaccInclude(base,prefix):
 245     Declare that program will need an include file produced by
 246     the output of yacc on base.y, which typically produces a file
 247     named y.tab.h, which will be renamed as base.h.
 248     The difference with SimpleYaccInclude is the identifying process
 249     of the y.tab.h file where all 'yy' are renamed to prefix.
 250     The only problem is that the dependencies towards base.h have
 251     to be manually given in the Jmakefile.
 252
 253     base.h: base.c
 254         @if test -f y.tab.h; then \
 255             echo "    $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.h > base.h"; \
 256             $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.h > base.h; \
 257             echo "    $(RM) y.tab.h"; \
 258             $(RM) y.tab.h; \
 259         elif test -f base.h; then \
 260             echo "    $(CP) base.h base.ht"; \
 261             $(CP) base.h base.ht; \
 262             echo "    $(SED) -e 's/yy\(.\)/prefix\1/g' < base.ht > base.h"; \
 263             $(SED) -e 's/yy\(.\)/prefix\1/g' < base.ht > base.h; \
 264             echo "    $(RM) base.ht"; \
 265             $(RM) base.ht; \
 266         fi
 267
 268     local_realclean::
 269         $(RM) base.h
 270
 271 ------------------------------------------------------------------------
 272 ComplexYaccTarget(program,base,prefix):
 273     Declare a yacc base.y file to be used in the building of the
 274     specified target program. The source file must be given without
 275     its final .y extension. The name of the .c and .o will be
 276     derived from the source file basename provided.
 277     The difference with SimpleYaccTarget is the identifying process
 278     where all the 'yy' are replaced by the specified prefix.
 279
 280         SOURCES += base.y
 281         OBJECTS += base.o
 282
 283     program: base.c
 284
 285     base.c: base.y
 286         $(YACC) $(JYFLAGS) base.y
 287         $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.c > base.c
 288         $(SED) -e 's/yy\(.\)/prefix\1/g' < y.tab.h > base.h
 289         $(RM) y.tab.c y.tab.h
 290
 291     local_realclean::
 292         $(RM) base.c
 293
 294 ------------------------------------------------------------------------
 295 CppScriptTarget(dst,src,defs,deplist):
 296     Generate rules to create a shell script by running the input
 297     through cpp.
 298
 299     dst::  src deplist
 300         $(RM) $@
 301         $(CPP) defs <src | \
 302             sed -e '/^#  *[0-9][0-9]*  *.*$$/d' >$@
 303         chmod a+x $@
 304
 305 ------------------------------------------------------------------------
 306 DebuggedAndProfiledLibraryObjectRule():
 307     Generate make rules to build debuggable, profiled, and "normal"
 308     objects.
 309
 310     all::
 311         @if [ ! -d profiled ]; then mkdir profiled; fi
 312         @if [ ! -d debugger ]; then mkdir debugger; fi
 313
 314     .c.o:
 315         $(RM) $@ profiled/$@ debugger/$@
 316         $(CC) -pg -c $(JCFLAGS) $*.c
 317         $(MV) $*.o profiled/$*.o
 318         $(CC) -g -c $(JCFLAGS) $*.c
 319         $(MV) $*.o debugger/$*.o
 320         $(CC) -c $(JCFLAGS) $*.c
 321
 322     local_clean::
 323         -@if [ -d profiled ]; then echo "    $(RM) profiled/?*.o"; \
 324             $(RM) profiled/?*.o; fi
 325         -@if [ -d debugger ]; then echo "    $(RM) debugger/?*.o"; \
 326             $(RM) debugger/?*.o; fi
 327
 328 ------------------------------------------------------------------------
 329 DebuggedLibraryObjectRule():
 330     Generate make rules to build both debuggable and "normal"
 331     objects.
 332
 333     all::
 334         @if [ ! -d debugger ]; then mkdir debugger; fi
 335
 336     .c.o:
 337         $(RM) $@ debugger/$@
 338         $(CC) -g -c $(JCFLAGS) $*.c
 339         $(MV) $*.o debugger/$*.o
 340         $(CC) -c $(JCFLAGS) $*.c
 341
 342     local_clean::
 343         -@if [ -d debugger ]; then echo "    $(RM) debugger/?*.o"; \
 344             $(RM) debugger/?*.o; fi
 345
 346 ------------------------------------------------------------------------
 347 DebuggedLibraryTarget(libname,srclist,objlist):
 348     Generate rules to create a debuggable library.
 349
 350         SOURCES += srclist
 351         OBJECTS += objlist
 352
 353     AllTarget(lib/**/libname^^_d.a)
 354
 355     lib/**/libname^^_d.a: objlist
 356         $(RM) $@
 357         cd debugger; $(AR) ../$@ objlist
 358         $(RANLIB) $@
 359
 360 ------------------------------------------------------------------------
 361 DebuggedRelocatableTarget(objname,objlist):
 362     Generate rules to produce a debuggable relocatable object file
 363     instead of a library.
 364
 365     AllTarget(objname/**/_d.o)
 366
 367     objname/**/_d.o: objlist
 368         $(RM) $@
 369         $(LD) -X -r objlist -o $@
 370
 371 ------------------------------------------------------------------------
 372 DeinstallMultipleDest(step,list,dest):
 373     Generate rules to deinstall multiple files at once during a particular
 374     step in the build.
 375
 376     step::
 377         @case '${MFLAGS}' in *[i]*) set +e;; esac; \
 378         for i in list; do \
 379             (set -x; $(RM) $(INSTALL_PREFIX)/***/dest/$$i); \
 380         done
 381
 382 ------------------------------------------------------------------------
 383 DependDependency():
 384     Generate rules to build the makedepend program.
 385
 386     depend:: TOPDIR/mkdep
 387
 388     TOPDIR/mkdep:
 389     (if TOP)  @echo "You have to run Configure first."; exit 1
 390     (not TOP)  @echo "You have to run Configure in $(TOP) first."; exit 1
 391
 392 ------------------------------------------------------------------------
 393 DependDirs(dirs):
 394     Generate rules to recursively compute dependencies as part of the
 395     make depend step.
 396
 397     NamedTargetSubdirsRule(dirs,depend,"Depending",/**/)
 398
 399 ------------------------------------------------------------------------
 400 DependSubdirs():
 401     Generate rules to recursively compute dependencies as part of the
 402     make depend step.
 403
 404     DependDirs($(SUBDIRS))
 405
 406 ------------------------------------------------------------------------
 407 DependTarget():
 408     Generate rules to compute dependencies for all files listed
 409     in $(SOURCES) (automatically generated macro).
 410
 411         USRINC = $usrinc
 412
 413     |once _DependTarget_
 414     DependDependency()
 415
 416     depend::
 417         ($(SED) '/^# DO NOT DELETE/q' Makefile && \
 418         $(MKDEP) $(SOURCES) | \
 419         $(SED) -e 's:/usr/lib[^ ]*::g; s:$(USRINC)[^ ]*::g; ' \
 420             -e '/: / b print' -e '$$ b print' -e 'H; d; n; : print' \
 421             -e 'x; s/\\$$//; s/\\\n//g; s/ /**/ */ /g; s/ :/:/;' -e '/: *$$/d' \
 422         ) > Makefile.new
 423         cp Makefile Makefile.bak
 424         cp Makefile.new Makefile
 425         $(RM) Makefile.new
 426
 427     -once
 428
 429 ------------------------------------------------------------------------
 430 Expand(rule, pattern):
 431     This powerful macro expands the `rule' given a `pattern'. It
 432     relies on a built-in command in jmake. The expansion is
 433     documented in the short notes file that comes with jmake and
 434     gives some insights on the internal syntax.
 435
 436     |expand pattern
 437     rule
 438     -expand
 439
 440 ------------------------------------------------------------------------
 441 ForceTarget():
 442     The force target will force reconstruction of all the other
 443     targets which include .FORCE in their own dependencies.
 444
 445     |once _force_
 446     .FORCE:
 447
 448     -once
 449
 450 ------------------------------------------------------------------------
 451 IdentifiedLexDependTarget(program,base,parser,prefix):
 452     Declare that program will need an include file produced by
 453     the output of lex on base.l, which typically produces a file
 454     named lex.yy.c which will be renamed as base.c. Besides, the
 455     lexical analyzer needs the file parser.h produced by running
 456     parser.y through yacc and renaming y.tab.h as parser.h.
 457     The lexical analyzer is identified with the supplied prefix,
 458     which replaces the regular 'yy' prefix in the symbol names.
 459
 460     base.o: parser.h
 461
 462     IdentifiedLexTarget(program,base,prefix)
 463
 464 ------------------------------------------------------------------------
 465 IdentifiedLexTarget(program,base,prefix):
 466     This declares a lex base.l file which is to be ran through
 467     lex to produce a base.c file. The prefix is used to replace
 468     the 'yy', so that the lexical analyzer may be identified.
 469
 470         SOURCES += base.l
 471         OBJECTS += base.o
 472
 473     program: base.c
 474
 475     base.c: base.l
 476         $(LEX) $(JLFLAGS) base.l
 477         $(SED) -e 's/yy\(.\)/prefix\1/g' < lex.yy.c > base.c
 478         $(RM) lex.yy.c
 479
 480     local_realclean::
 481         $(RM) base.c
 482
 483 ------------------------------------------------------------------------
 484 IdentifiedParserTarget(program,lexic,parser,prefix):
 485     Specify that program is using the lex/yacc combination to
 486     produce a parser. The lexic and parser parameters are the
 487     base name of the .l and .y file, respectively. The parser
 488     produced is identified via its prefix, which replaces all
 489     the normally supplied 'yy' prefix, hence making it possible
 490     to have multiple parsers in a single executable.
 491
 492     IdentifiedLexDependTarget(program,lexic,parser,prefix)
 493     IdentifiedYaccTarget(program,parser,prefix)
 494
 495 ------------------------------------------------------------------------
 496 IdentifiedYaccTarget(program,base,prefix):
 497     Declare a yacc base.y file which should produce a base.c and
 498     base.h file as derived from the output of yacc, to be used by
 499     the specified program. The specified prefix is used to remplace
 500     all the 'yy' in the generated file, for use when more than a
 501     single parser is needed in one executable.
 502
 503     ComplexYaccTarget(program,base,prefix)
 504     ComplexYaccInclude(base,prefix)
 505
 506 ------------------------------------------------------------------------
 507 IncludesSubdirs():
 508     Generate rules to recursively put include files in build
 509
 510     NamedTargetSubdirs(includes,including,/**/)
 511
 512 ------------------------------------------------------------------------
 513 Initialize(symbol,value):
 514     Puts the line symbol = value in the initialization section of
 515     Makefile.SH (the one that is subject to parameter substitutions).
 516
 517         symbol = value
 518
 519 ------------------------------------------------------------------------
 520 InstallLibrary(libname,dest):
 521     Generate rules to install the indicated library.
 522
 523     local_install:: lib/**/libname.a
 524         _MakeInstallDirIgnore(dest) \
 525         $(INSTALL) -c -m 644 lib/**/libname.a $(INSTALL_PREFIX)/***/dest
 526         $(RANLIB) dest/lib/**/libname.a
 527         chmod 444 dest/lib/**/libnane.a
 528
 529     local_deinstall::
 530         $(RM) $(INSTALL_PREFIX)/***/dest/lib/**/libname.a
 531
 532 ------------------------------------------------------------------------
 533 InstallLibraryAlias(libname,alias,dest):
 534     Generate rules to create a link from one library name to another
 535     for the purposes of aliasing.
 536
 537     local_install:: lib/**/libname.a
 538         $(RM) lib/**/alias.a
 539         -(cd dest; $(LN) lib/**/libname.a lib^^alias.a)
 540
 541     local_deinstall::
 542         $(RM) dest/lib/**/alias.a
 543
 544 ------------------------------------------------------------------------
 545 InstallLintLibrary(libname,dest):
 546     Generate rules to install the indicated lint library.
 547
 548     install.ln:: llib-l/**/libname.ln
 549         _MakeInstallDirIgnore(dest) \
 550         $(INSTALL) -c -m 444 llib-l/**/libname.ln $(INSTALL_PREFIX)/***/dest
 551
 552     deinstall.ln::
 553         $(RM) $(INSTALL_PREFIX)/***/dest/llib-l/**/libname.ln
 554
 555 ------------------------------------------------------------------------
 556 InstallManPage(file,dest):
 557     Generate rules to install the indicated manual page.
 558
 559     InstallManPageLong(file,dest,file)
 560
 561 ------------------------------------------------------------------------
 562 InstallManPageLong(file,destdir,dest):
 563     Generate rules to install the indicated manual page, giving it an
 564     alternate name.  This is used for installing man pages whose base
 565     name without the .man suffix would normally be longer than 8
 566     characters (the limit for using source code control systems on
 567     files systems with short file names).
 568
 569     local_install.man:: file.man
 570         _MakeInstallDirIgnore(destdir) \
 571         $(INSTALL) -c -m 444 file.man $(INSTALL_PREFIX)/***/destdir/dest.$(L)
 572
 573     local_deinstall.man::
 574         $(RM) $(INSTALL_PREFIX)/***/destdir/dest.$(L)
 575
 576 ------------------------------------------------------------------------
 577 InstallManScripts():
 578     Generate rule to install/deinstall manual pages for scripts listed
 579     in the automatically generated $(SCRIPTS) macro.
 580
 581     |once _InstallManScripts_
 582     #ifndef NOMAN
 583     local_install.man::
 584         _MakeInstallDirIgnore($(MANSRC)) \
 585         for file in $(SCRIPTS); do \
 586             if test -f $$file.man; then \
 587                 (set -x; \
 588                 $(INSTALL) -c -m 444 $$file.man \
 589                     $(INSTALL_PREFIX)$(MANSRC)/$$file.$(L)) || \
 590                     exit 1; \
 591             fi; \
 592         done
 593
 594     local_deinstall.man::
 595         case '${MFLAGS}' in *[i]*) set +e;; esac; \
 596         for file in $(SCRIPTS); do \
 597             (set -x; $(RM) $(INSTALL_PREFIX)$(MANSRC)/$$file.$(L)); \
 598         done
 599
 600     #endif
 601     -once
 602
 603 ------------------------------------------------------------------------
 604 InstallManSubdirs():
 605     Generate rules to recursively install and deinstall manual pages.
 606
 607     NamedSubTargetSubdirs(install.man,"Installing man pages",/**/)
 608     NamedDepthTargetSubdirs(deinstall.man,"Deinstalling man pages",/**/)
 609
 610 ------------------------------------------------------------------------
 611 InstallMultiple(list,dest):
 612     Generate rules to install multiple files at once during the install
 613     step of the build using any install flags set in $(INSTALLFLAGS)
 614     and deinstall them.
 615
 616     InstallMultipleDestFlags(local_install,list,dest,$(INSTALLFLAGS))
 617     DeinstallMultipleDest(local_deinstall,list,dest)
 618
 619 ------------------------------------------------------------------------
 620 InstallMultipleDestFlags(step,list,dest,flags):
 621     Generate rules to install multiple files at once during a particular
 622     step in the build using a specific set of install flags.
 623
 624     step:: list
 625         _MakeInstallDirIgnore(dest) \
 626         for i in list; do \
 627             (set -x; $(INSTALL) -c flags \
 628                 $$i $(INSTALL_PREFIX)/***/dest) || exit 1;\
 629         done
 630
 631 ------------------------------------------------------------------------
 632 InstallMultipleFlags(list,dest,flags):
 633     Generate rules to install multiple files at once during the
 634     install step of the build using the given install flags.
 635
 636     InstallMultipleDestFlags(local_install,list,dest,flags)
 637     DeinstallMultipleDest(local_deinstall,list,dest)
 638
 639 ------------------------------------------------------------------------
 640 InstallMultipleMan(list,dest):
 641     Generate rules to install a variety of manual pages
 642     during the install.man step of the build.
 643
 644     InstallMultipleDestFlags(local_install.man,list,dest,$(INSTALLFLAGS))
 645     DeinstallMultipleDest(local_deinstall.man,list,dest)
 646
 647 ------------------------------------------------------------------------
 648 InstallNonExec(file,dest):
 649     Generate rules to install a data file using any special
 650     install flags.
 651
 652     local_install:: file
 653         _MakeInstallDirIgnore(dest) \
 654         $(INSTALL) -c -m 444 file $(INSTALL_PREFIX)/***/dest
 655
 656     local_deinstall::
 657         $(RM) $(INSTALL_PREFIX)/***/dest/file
 658
 659 ------------------------------------------------------------------------
 660 InstallProgram(program,dest):
 661     Generate rules to install an executable program using any special
 662     install flags set in $(INSTALLFLAGS).
 663
 664     InstallProgramWithFlags(program,dest,/**/)
 665
 666 ------------------------------------------------------------------------
 667 InstallProgramNoStrip(program,dest):
 668     Generate rules to install an executable program using any special
 669     install flags set in $(INSTALLFLAGS), but without stripping the
 670     executable from debugging symbols.
 671
 672     InstallProgramNoStripWithFlags(program,dest,/**/)
 673
 674 ------------------------------------------------------------------------
 675 InstallProgramNoStripWithFlags(program,dest,flags):
 676     Generate rules to install an executable program using given
 677     install flags.
 678
 679     local_install:: program
 680         _MakeInstallDirIgnore(dest) \
 681         $(INSTALL) -c -m 555 flags program/***/$(_EXE) $(INSTALL_PREFIX)/**/^dest
 682
 683     local_deinstall::
 684         $(RM) $(INSTALL_PREFIX)/***/dest/program/**/^$(_EXE)
 685
 686 ------------------------------------------------------------------------
 687 InstallProgramWithFlags(program,dest,flags):
 688     Generate rules to install an executable program using given
 689     install flags.
 690
 691     local_install:: program
 692         _MakeInstallDirIgnore(dest) \
 693         $(INSTALL) -c -s -m 555 flags program/***/$(_EXE) $(INSTALL_PREFIX)/**/^dest
 694
 695     local_deinstall::
 696         $(RM) $(INSTALL_PREFIX)/***/dest/program/**/^$(_EXE)
 697
 698 ------------------------------------------------------------------------
 699 InstallScript(script,dest):
 700     Generate rules to install an executable script using any special
 701     install flags set in $(INSTALLFLAGS).
 702
 703     InstallScriptWithFlags(script,dest,/**/)
 704
 705 ------------------------------------------------------------------------
 706 InstallScriptWithFlags(script,dest,flags):
 707     Generate rules to install an executable script using given
 708     install flags.
 709
 710     local_install:: script
 711         _MakeInstallDirIgnore(dest) \
 712         $(INSTALL) -c -m 555 flags script $(INSTALL_PREFIX)/***/dest
 713
 714     local_deinstall::
 715         $(RM) $(INSTALL_PREFIX)/***/dest/script
 716
 717 ------------------------------------------------------------------------
 718 InstallScripts():
 719     Generate rules to install all the scripts listed in the generated
 720     $(SCRIPTS) and $(LSCRIPTS) macros.
 721
 722     |once _InstallScripts_
 723     local_install:: $(SCRIPTS) $(LSCRIPTS)
 724         _MakeInstallDirIgnore($(SCRIPTDIR)) \
 725         for file in $(SCRIPTS) $(LSCRIPTS); do \
 726             (set -x; \
 727             $(INSTALL) -c -m 555 $$file $(INSTALL_PREFIX)$(SCRIPTDIR)) || \
 728             exit 1; \
 729         done
 730
 731     local_deinstall::
 732         @for file in $(SCRIPTS) $(LSCRIPTS); do \
 733             case '${MFLAGS}' in *[i]*) set +e;; esac; \
 734             (set -x; $(RM) $(INSTALL_PREFIX)$(SCRIPTDIR)/$$file); \
 735         done
 736     -once
 737
 738 ------------------------------------------------------------------------
 739 InstallSharedLibrary(libname,rev,dest):
 740     Generate rules to install the shared library.
 741
 742     local_install:: lib/**/libname.so.rev
 743         _MakeInstallDirIgnore(dest) \
 744         $(INSTALL) -c -m 444 lib/**/libname.so.rev $(INSTALL_PREFIX)/***/dest
 745
 746     local_deinstall::
 747         $(RM) $(INSTALL_PREFIX)/***/dest/lib/**/libname.so.rev
 748
 749 ------------------------------------------------------------------------
 750 InstallSharedLibraryData(libname,rev,dest):
 751     Generate rules to install the shared library data
 752
 753     local_install:: lib/**/libname.sa.rev
 754         _MakeInstallDirIgnore(dest) \
 755         $(INSTALL) -c -m 444 lib/**/libname.sa.rev $(INSTALL_PREFIX)/***/dest
 756
 757     local_deinstall::
 758         $(RM) $(INSTALL_PREFIX)/***/dest/lib/**/libname.sa.rev
 759
 760 ------------------------------------------------------------------------
 761 InstallSubdirs():
 762     Generate rules to recursively install and deinstall programs and
 763     files.
 764
 765     NamedSubTargetSubdirs(install,"Installing",/**/)
 766     NamedDepthTargetSubdirs(deinstall,"Deinstalling",/**/)
 767
 768 ------------------------------------------------------------------------
 769 InstallTarget():
 770     Generate rules to recursively install files
 771
 772     (if SUBDIRS) install:: local_install sub_install
 773     (not SUBDIRS) install:: local_install
 774     (if SUBDIRS) install.man:: maybe_install.man sub_install.man
 775     (not SUBDIRS) install.man:: maybe_install.man
 776     (if SUBDIRS) deinstall:: sub_deinstall local_deinstall
 777     (not SUBDIRS) deinstall:: local_deinstall
 778     (if SUBDIRS) deinstall.man:: sub_deinstall.man maybe_deinstall.man
 779     (not SUBDIRS) deinstall.man:: maybe_deinstall.man
 780
 781     (if MANSRC) install.man-yes: local_install.man
 782     install.man-no:
 783     (if MANSRC) deinstall.man-yes: local_deinstall.man
 784     deinstall.man-no:
 785
 786 ------------------------------------------------------------------------
 787 LinkFileList(step,list,dir,sub):
 788     Link a list of list of files from one place to another
 789
 790     step:: list
 791         @case '${MFLAGS}' in *[i]*) set +e;; esac; \
 792         echo "    cd" dir; cd dir; for i in list; do (set -x; $(LN) sub/$$i .); done
 793
 794 ------------------------------------------------------------------------
 795 LinkSourceFile(src,dir):
 796     Snag source file from some other directory
 797
 798     src:  dir/src
 799         $(RM) $@
 800         $(LN) $? $@
 801
 802 ------------------------------------------------------------------------
 803 LintDirs(dirs):
 804     Generate rules to recursively lint directories as part of the
 805     make lint step.
 806
 807     MakeLintSubdirs(dirs,lint)
 808
 809 ------------------------------------------------------------------------
 810 LintLibraryTarget(libname,srclist):
 811     Generate rules to create a lint library.  Note that the lint
 812     library is always forced to be newer than the library itself.
 813
 814     lintlib:: llib-l/**/libname.ln
 815
 816     llib-l/**/libname.ln: srclist
 817         $(RM) $@
 818         $(LINT) $(LINTLIBFLAG)/**/libname $(LINTFLAGS) srclist
 819
 820 ------------------------------------------------------------------------
 821 LintSubdirs():
 822     Generate rules to recursively lint directories as part of the
 823     make lint step.
 824
 825     LintDirs($(SUBDIRS))
 826
 827 ------------------------------------------------------------------------
 828 LintTarget():
 829     Generate rules to lint $(SOURCES) (automatically generated)
 830
 831     |once _LintTarget_
 832     NormalLintTarget($(SOURCES))
 833     -once
 834
 835 ------------------------------------------------------------------------
 836 MakeDirectories(step,dirs):
 837     Generate rules to create a hierarchy of directories.
 838
 839     step::
 840         MakeDirs(dirs)
 841
 842 ------------------------------------------------------------------------
 843 MakeDirs(dirs):
 844     Creates a set of directories, even if some directories in the path
 845     do not already exist. There should be no '@!' at the end of the
 846     '#define' line, because this macro is used *inside* building rules.
 847
 848         @case '${MFLAGS}' in *[i]*) set +e;; esac; \
 849         for dir in dirs; do \
 850             (set -x; test -d $$dir || $(INSTALLDIR) $$dir) || \
 851             exit 1; \
 852         done
 853
 854 ------------------------------------------------------------------------
 855 MakeInstallDirectories(dirs):
 856     Generate a rule to create a set of directories at installation
 857     time (removed by deinstall).
 858
 859     local_install::
 860         _MakeInstallDirs(dirs)
 861
 862     local_deinstall::
 863         _RmInstallDirs(dirs)
 864
 865 ------------------------------------------------------------------------
 866 MakeLintLibSubdirs(dirs):
 867     Generate rules to recursively create lint libraries.
 868
 869     MakeLintSubdirs(dirs,lintlib)
 870
 871 ------------------------------------------------------------------------
 872 MakeLintSubdirs(dirs,target):
 873     Generate rules to recursively lint directories as part of the
 874     named step.
 875
 876     NamedTargetSubdirsRule(dirs,target,"Linting",/**/)
 877
 878 ------------------------------------------------------------------------
 879 MakeMakeSubdirs(target):
 880     Generate rules to recursively recreate target as part of the
 881     specified step in the build.  This assumes Makefile.SH has
 882     already been built (which is the case for a delivery), but does
 883     not rely on the existence of a Makefile.
 884
 885     target::
 886         @case '${MFLAGS}' in *[ik]*) set +e;; esac; \
 887         for i in $(SUBDIRS);\
 888         do \
 889             echo "Making "target" in $(DIR)$$i..."; \
 890             (cd $$i || exit 1; \
 891             if test ! -f Makefile; then /bin/sh Makefile.SH; fi; \
 892             $(MAKE) $(MFLAGS) target) || exit 1;\
 893         done
 894
 895 ------------------------------------------------------------------------
 896 MakeMakefilesSH():
 897     Generate rules to recursively recreate target as part of the
 898     specified step in the build.  If $(TOP) is set to an absolute
 899     path, don't prepend the ../ prefix.  This makes running things
 900     outside of the source tree to be much easier.
 901
 902     Makefiles.SH:: Makefile.SH
 903         @case '${MFLAGS}' in *[ik]*) set +e;; esac; \
 904         for i in $(SUBDIRS);\
 905         do \
 906             case "$(DIR)$$i/" in \
 907             /**/*^^/^^*^^/^^*^^/^^*^^/) newtop=../../../..;; \
 908             /**/*^^/^^*^^/^^*^^/) newtop=../../..;; \
 909             /**/*^^/^^*^^/) newtop=../..;; \
 910             */**//) newtop=..;; \
 911             esac; \
 912             case "$(TOP)" in \
 913             //**/*) newtop="$(TOP)" ;; \
 914             esac; \
 915             echo "Making Makefiles.SH in $(DIR)$$i..."; \
 916             (cd $$i || exit 1; \
 917                 if test -f Jmakefile; then \
 918                     $(MAKE) $(MFLAGS) -f ../Makefile \
 919                         Makefile TOP=$$newtop CURRENT=$(DIR)$$i && \
 920                     $(MAKE) $(MFLAGS) Makefiles.SH; \
 921                 fi; \
 922             ) || exit 1; \
 923         done
 924
 925 ------------------------------------------------------------------------
 926 MakeScriptFromCpp(name,defs):
 927     Generate rules to create a script from a file with a
 928     .cpp suffix.
 929
 930     CppScriptTarget(name,name.cpp,defs,/**/)
 931
 932 ------------------------------------------------------------------------
 933 MakeSubdirs():
 934     Generate rules to do makes in the given subdirectories.
 935
 936     NamedTargetSubdirs(all,"Making all",/**/)
 937
 938 ------------------------------------------------------------------------
 939 MakeSubincludesForBuild(step,dir,srclist):
 940     Make includes in sub directories.
 941
 942     step::  dir srclist
 943         @-(list=`echo srclist | sed -e 's/[^ ]*\///g'`; \
 944             set -x; cd dir; $(RM) $$list)
 945         @for i in srclist; do \
 946             (set -x; cd dir; $(LN) ../$$i .) || exit 1; \
 947         done
 948
 949     MakeDirectories(dir,dir)
 950
 951     local_realclean::
 952         @-(if [ -d dir ]; then \
 953             list=`echo srclist | sed -e 's/[^ ]*\///g'`; \
 954             set -x; cd dir; $(RM) $$list; fi)
 955
 956 ------------------------------------------------------------------------
 957 MakefileSubdirs():
 958     Generate rules to create Makefiles.
 959
 960     MakeMakeSubdirs(Makefiles)
 961     MakeMakefilesSH()
 962
 963 ------------------------------------------------------------------------
 964 MakefileTarget():
 965     Generate rules to build a normal Makefile.
 966
 967     BuildMakefileSH(/**/)
 968     BuildMakefile()
 969
 970 ------------------------------------------------------------------------
 971 NamedDepthTargetSubdirs(name,verb,flags):
 972     Recursively make a series of steps. We first enter the
 973     subdirectories, then perform the local entries.
 974     The supplied "name" has "sub_" prefixed to it.
 975
 976     sub_/***/name::
 977         @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags
 978         @echo "Back to $(CURRENT) for "name/**/...
 979
 980 ------------------------------------------------------------------------
 981 NamedSubTargetSubdirs(name,verb,flags):
 982     Recursively make a series of steps, like NamedTargetSubdirs.
 983     However, the supplied "name" has "sub_" prefixed to it.
 984
 985     sub_/***/name::
 986         @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags
 987
 988 ------------------------------------------------------------------------
 989 NamedTargetSubdirs(name,verb,flags):
 990     Recursively make a series of steps.
 991
 992     name::
 993         @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags
 994
 995 ------------------------------------------------------------------------
 996 NamedTargetSubdirsRule(dirs,name,verb,flags):
 997     Recursively make a series of steps in the specified directories.
 998
 999     name::
1000         @case '${MFLAGS}' in *[ik]*) set +e;; esac; \
1001         for i in dirs ;\
1002         do \
1003             (cd $$i ; echo verb "in $(DIR)$$i..."; \
1004                 $(MAKE) $(MFLAGS) flags name) || exit 1; \
1005         done
1006
1007 ------------------------------------------------------------------------
1008 NoManPages():
1009     Actually forces the definition of NOMAN, which tells the jmake
1010     program to not generate rules for installing manual pages.
1011
1012         -> NOMAN.
1013
1014 ------------------------------------------------------------------------
1015 NormalLexDependTarget(program,base,parser):
1016     Declare that program will need an include file produced by
1017     the output of lex on base.l, which typically produces a file
1018     named lex.yy.c which will be renamed as base.c. Besides, the
1019     lexical analyzer needs the file parser.h produced by running
1020     parser.y through yacc and renaming y.tab.h as parser.h.
1021
1022     base.o: parser.h
1023
1024     SimpleLexTarget(program,base)
1025
1026 ------------------------------------------------------------------------
1027 NormalLibraryObjectRule():
1028     Generate make rules to build "normal" objects.
1029
1030     |once _ObjectRule_
1031     .c.o:
1032         $(RM) $@
1033         $(CC) -c $(JCFLAGS) $<
1034
1035     -once
1036
1037 ------------------------------------------------------------------------
1038 NormalLibraryTarget(libname,srclist,objlist):
1039     Generate rules to create a library. The 'srclist' and 'objlist'
1040     parameters are added to SOURCES and OBJECTS macros. The 'srclist'
1041     is not otherwise used by this rule, but is necessary for make depend.
1042
1043         OBJECTS += objlist
1044         SOURCES += srclist
1045
1046     NormalLibraryObjectRule()
1047     AllTarget(lib/**/libname.a)
1048
1049     lib/**/libname.a: objlist
1050         $(RM) $@
1051         $(AR) $@ objlist
1052         $(RANLIB) $@
1053
1054 ------------------------------------------------------------------------
1055 NormalLibraryTarget2(libname,srclist,objlist1,objlist2):
1056     Generate rules to create a library in two steps.  This is used to
1057     create libraries with large numbers of files.
1058
1059         SOURCES += srclist
1060         OBJECTS += objlist1
1061         OBJECTS += objlist2
1062
1063     NormalLibraryObjectRule()
1064     AllTarget(lib/**/libname.a)
1065
1066     lib/**/libname.a: objlist1 objlist2
1067         $(RM) $@
1068         $(AR) $@ objlist1
1069         $(AR) $@ objlist2
1070         $(RANLIB) $@
1071
1072 ------------------------------------------------------------------------
1073 NormalLintTarget(srclist):
1074     Generate rules to lint a set of sources.
1075
1076     lint:
1077         $(LINT) $(LINTFLAGS) srclist $(LINTLIBS)
1078
1079 ------------------------------------------------------------------------
1080 NormalObjectRule():
1081     Generate make rule to build usual object files.
1082
1083     |once _ObjectRule_
1084     .c.o:
1085         $(CC) -c $(JCFLAGS) $<
1086
1087     -once
1088
1089 ------------------------------------------------------------------------
1090 NormalObjectTarget(file):
1091     Generate rules to produce a single object file.o from a file.c.
1092
1093         SOURCES += file/**/.c
1094
1095     AllTarget(file/**/.o)
1096     NormalObjectRule()
1097
1098 ------------------------------------------------------------------------
1099 NormalParserTarget(program,lexic,parser):
1100     Specify that program is using the lex/yacc combination to
1101     produce a parser. The lexic and parser parameters are the
1102     base name of the .l and .y file, respectively.
1103
1104     NormalLexDependTarget(program,lexic,parser)
1105     NormalYaccTarget(program,parser)
1106
1107 ------------------------------------------------------------------------
1108 NormalProgramTarget(program,sources,objects):
1109     Generate rules to compile and link the indicated program; since
1110     it does not use any default object files, it may be used for
1111     multiple programs in the same Jmakefile.
1112
1113         OBJECTS += objects
1114         SOURCES += sources
1115
1116     NormalObjectRule()
1117     AllTarget(program)
1118
1119     program: objects
1120         RemoveTargetProgram($@)
1121         $(CC) -o $@ objects $(JLDFLAGS) $(LIBS)
1122
1123 ------------------------------------------------------------------------
1124 NormalRelocatableTarget(objname,objlist):
1125     Generate rules to produce a relocatable object file instead of a
1126     library.
1127
1128     AllTarget(objname.o)
1129
1130     objname.o: objlist
1131         $(RM) $@
1132         $(LD) $(JLDFLAGS) -r objlist -o $@
1133
1134 ------------------------------------------------------------------------
1135 NormalSharedLibraryDataTarget(libname,rev,salist):
1136     Generate rules to create shlib data file; build it into a
1137     different name so that the we don't hose people by having the
1138     library gone for long periods.
1139
1140     AllTarget(lib/**/libname.sa.rev)
1141
1142     lib/**/libname.sa.rev:  salist
1143         $(RM) $@
1144         $(AR) $@ salist
1145         $(RANLIB) $@
1146
1147 ------------------------------------------------------------------------
1148 NormalSharedLibraryTarget(libname,rev,solist):
1149     Generate rules to create a shared library; build it into a
1150     different name so that the we don't hose people by having the
1151     library gone for long periods.
1152
1153     AllTarget(lib/**/libname.so.rev)
1154
1155     lib/**/libname.so.rev:  solist
1156         $(RM) $@~
1157         (cd shared; $(LD) -o ../$@~ -assert pure-text solist)
1158         $(RM) $@
1159         $(MV) $@~ $@
1160
1161 ------------------------------------------------------------------------
1162 NormalYaccTarget(program,base):
1163     Declare a yacc base.y file which should produce a base.c and
1164     base.h file as derived from the output of yacc, to be used by
1165     the specified program.
1166
1167     SimpleYaccTarget(program,base)
1168     SimpleYaccInclude(base)
1169
1170 ------------------------------------------------------------------------
1171 PrelinkedRelocatableTarget(objname,objlist,libs):
1172     Generate rules to produce a relocatable object file instead of a
1173     library.
1174
1175     AllTarget(objname.o)
1176
1177     objname.o: objlist
1178         $(RM) $@
1179         $(LD) $(JLDFLAGS) -r objlist -o $@ libs
1180
1181 ------------------------------------------------------------------------
1182 ProfiledLibraryObjectRule():
1183     Generate make rules to build both profiled and "normal" objects.
1184
1185     all::
1186         @if [ ! -d profiled ]; then mkdir profiled; fi
1187
1188     .c.o:
1189         $(RM) $@ profiled/$@
1190         $(CC) -pg -c $(JCFLAGS) $*.c
1191         $(MV) $*.o profiled/$*.o
1192         $(CC) -c $(JCFLAGS) $*.c
1193
1194     local_clean::
1195         -@if [ -d profiled ]; then echo "    $(RM) profiled/?*.o"; \
1196             $(RM) profiled/?*.o; fi
1197
1198 ------------------------------------------------------------------------
1199 ProfiledLibraryTarget(libname,srclist,objlist):
1200     Generate rules to create a profiled library.
1201
1202         SOURCES += srclist
1203         OBJECTS += objlist
1204
1205     AllTarget(lib/**/libname^^_p.a)
1206
1207     lib/**/libname^^_p.a: objlist
1208         $(RM) $@
1209         cd profiled; $(AR) ../$@ objlist
1210         $(RANLIB) $@
1211
1212 ------------------------------------------------------------------------
1213 ProfiledRelocatableTarget(objname,objlist):
1214     Generate rules to produce a profiled relocatable object file
1215     instead of a library.
1216
1217     AllTarget(objname/**/_p.o)
1218
1219     objname/**/_p.o: objlist
1220         $(RM) $@
1221         $(LD) -X -r objlist -o $@
1222
1223 ------------------------------------------------------------------------
1224 RemoteDependency(directory,dependency):
1225     Specify rules for making a remote dependency.
1226
1227     ForceTarget()
1228     |once =directory//***/dependency=
1229     directory//***/dependency: .FORCE
1230         @echo "Checking "/***/dependency" in "/**/^directory"..."
1231         cd /***/directory; $(MAKE) /**/^dependency
1232         @echo "Continuing in $(CURRENT)..."
1233
1234     -once
1235
1236 ------------------------------------------------------------------------
1237 RemoteTargetDependency(target,directory,dependency):
1238     A local target may rely on a remote dependency (e.g. a library)
1239     made in a separate directory. This rule explicits the dependency
1240     and forces a make of that dependency in the remote directory.
1241
1242     RemoteDependency(directory,dependency)
1243     target: directory//***/dependency
1244
1245 ------------------------------------------------------------------------
1246 RemoveTargetProgram(program):
1247     This is used in some other macros in order to remove the target
1248     before starting its building (saves disk space).  There should be
1249     no '@!' at the end of the '#define' line, because this macro is
1250     used *inside* building rules.
1251
1252         $(RM) program
1253         if test -f program/***/$(_EXE); then \
1254             $(MV) program/***/$(_EXE) program/**/~^^^$(_EXE); fi
1255
1256 ------------------------------------------------------------------------
1257 SetSubdirs(subdirs):
1258     Actually forces the definition of SUBDIRS, and lets the user
1259     specify what the sub-directories are.  This will be added to the
1260     customization part.
1261
1262         -> SUBDIRS.
1263
1264         SUBDIRS = subdirs
1265
1266 ------------------------------------------------------------------------
1267 SharedAndDebuggedLibraryObjectRule():
1268     Generate make rules to build shared, debuggable, and "normal"
1269     object files.
1270
1271     all::
1272         @if [ ! -d shared ]; then mkdir shared; fi
1273         @if [ ! -d debugger ]; then mkdir debugger; fi
1274
1275     .c.o:
1276         $(RM) $@ shared/$@ debugger/$@
1277         $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) $*.c
1278         $(MV) $*.o shared/$*.o
1279         $(CC) -g -c $(SHLIBDEF) $(JCFLAGS) $*.c
1280         $(MV) $*.o debugger/$*.o
1281         $(CC) -c $(SHLIBDEF) $(JCFLAGS) $*.c
1282
1283     local_clean::
1284         -@if [ -d shared ]; then echo "    $(RM) shared/?*.o"; \
1285             $(RM) shared/?*.o; fi
1286         -@if [ -d debugger ]; then echo "    $(RM) debugger/?*.o"; \
1287             $(RM) debugger/?*.o; fi
1288
1289 ------------------------------------------------------------------------
1290 SharedLibraryObjectRule():
1291     Generate make rules to build shared and "normal" object files.
1292
1293     all::
1294         @if [ ! -d shared ]; then mkdir shared; fi
1295
1296     .c.o:
1297         $(RM) $@ shared/$@
1298         $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) $*.c
1299         $(MV) $*.o shared/$*.o
1300         $(CC) -c $(SHLIBDEF) $(JCFLAGS) $*.c
1301
1302     local_clean::
1303         -@if [ -d shared ]; then echo "    $(RM) shared/?*.o"; \
1304             $(RM) shared/?*.o; fi
1305
1306 ------------------------------------------------------------------------
1307 ShellScriptLongTarget(basename,scriptname):
1308     Generate rules to create a set of scripts from .SH files where
1309     the name of the generated file is different from the basename of
1310     the .SH file (when, for instance, the total length with the .SH
1311     extension would not leave enough space for RCS ,v extension).
1312
1313         LSCRIPTS += scriptname
1314
1315     AllTarget(scriptname)
1316
1317     scriptname: basename/**/.SH
1318         /bin/sh basename/**/.SH
1319
1320     InstallScripts()
1321     #ifndef NOMAN
1322     InstallManPageLong(basename,$(MANSRC),scriptname)
1323     #endif
1324
1325 ------------------------------------------------------------------------
1326 ShellScriptTarget(scripts):
1327     Generate rules to create and install a set of scripts from
1328     .SH files. Man pages derived from the name of the scripts are
1329     also installed unless NoManPages() is specified.
1330
1331     ShellScriptTargetExt(scripts,.SH)
1332
1333 ------------------------------------------------------------------------
1334 ShellScriptTargetExt(scripts,ext):
1335     Generate rules to create and install a set of scripts from
1336     ext files (.sh and .SH are the most common examples). Man pages
1337     derived from the name of the scripts are also installed unless
1338     NoManPages() is specified.
1339
1340         SCRIPTS += scripts
1341
1342     SimpleShellScriptTargetExt(scripts,ext)
1343     InstallScripts()
1344     InstallManScripts()
1345
1346 ------------------------------------------------------------------------
1347 SimpleLexTarget(program,base):
1348     This declares a lex base.l file which is to be ran through
1349     lex to produce a base.c file.
1350
1351         SOURCES += base.l
1352         OBJECTS += base.o
1353
1354     |once _LexRule_
1355     .l.c:
1356         $(LEX) $(JLFLAGS) $<
1357         $(MV) lex.yy.c $@
1358
1359     -once
1360     AddSuffix(.l)
1361     program: base.c
1362
1363     local_realclean::
1364         $(RM) base.c
1365
1366 ------------------------------------------------------------------------
1367 SimpleProgramTarget(program):
1368     Generate rules for compiling and linking programs that only have
1369     one C source file.  It should only be used in Jmakefiles that
1370     describe a single program.
1371
1372     NormalProgramTarget(program,program.c,program.o)
1373
1374 ------------------------------------------------------------------------
1375 SimpleShellScriptTarget(scripts):
1376     Generate rules to create a set of scripts from .SH files.
1377
1378     SimpleShellScriptTargetExt(scripts,.SH)
1379
1380 ------------------------------------------------------------------------
1381 SimpleShellScriptTargetExt(scripts,ext):
1382     Generate rules to create a set of scripts from ext files where
1383     ext is usually something like .sh or .SH, or whatever file
1384     extension you like..
1385
1386     AllTarget(scripts)
1387
1388     |expand s!scripts!
1389     !s: !s/**/ext
1390         /bin/sh !s/**/ext
1391
1392     -expand
1393
1394 ------------------------------------------------------------------------
1395 SimpleYaccInclude(base):
1396     Declare that program will need an include file produced by
1397     the output of yacc on base.y, which typically produces a file
1398     named y.tab.h, which will be renamed as base.h.
1399     The only problem is that the dependencies towards base.h have
1400     to be manually given in the Jmakefile.
1401
1402     base.h: base.c
1403         @if test -f y.tab.h; then \
1404             echo "    $(MV) y.tab.h $@"; \
1405             $(MV) y.tab.h $@; \
1406         fi
1407
1408     local_realclean::
1409         $(RM) base.h
1410
1411 ------------------------------------------------------------------------
1412 SimpleYaccTarget(program,base):
1413     Declare a yacc base.y file to be used in the building of the
1414     specified target program. The source file must be given without
1415     its final .y extension. The name of the .c and .o will be
1416     derived from the source file basename provided.
1417
1418         SOURCES += base.y
1419         OBJECTS += base.o
1420
1421     YaccRule()
1422     program: base.c
1423
1424     local_realclean::
1425         $(RM) base.c
1426
1427 ------------------------------------------------------------------------
1428 SingleProgramTarget(program,objects,libs):
1429     Obsolete version of NormalProgramTarget that doesn't have
1430     deplibs.
1431
1432     NormalProgramTarget(program,objects,libs)
1433
1434 ------------------------------------------------------------------------
1435 SpecialDebuggedAndProfiledObjectRule(objs,depends,options):
1436     Generate rules to compile a file with special flags and to make
1437     debuggable and profiled versions.
1438
1439     all::
1440         @if [ ! -d profiled ]; then mkdir profiled; fi
1441         @if [ ! -d debugger ]; then mkdir debugger; fi
1442
1443     objs:    depends
1444         $(RM) $@ profiled/$@ debugger/$@
1445         $(CC) -pg -c $(JCFLAGS) options $*.c
1446         $(MV) $*.o profiled/$*.o
1447         $(CC) -g -c $(JCFLAGS) options $*.c
1448         $(MV) $*.o debugger/$*.o
1449         $(CC) -c $(JCFLAGS) options $*.c
1450
1451 ------------------------------------------------------------------------
1452 SpecialDebuggedObjectRule(objs,depends,options):
1453     Generate rules to compile a file with special flags and to make a
1454     debuggable version.
1455
1456     all::
1457         @if [ ! -d debugger ]; then mkdir debugger; fi
1458
1459     objs:    depends
1460         $(RM) $@ debugger/$@
1461         $(CC) -g -c $(JCFLAGS) options $*.c
1462         $(MV) $*.o debugger/$*.o
1463         $(CC) -c $(JCFLAGS) options $*.c
1464
1465 ------------------------------------------------------------------------
1466 SpecialObjectRule(objs,depends,options):
1467     Generate rules to compile a file with special flags.
1468
1469     objs:    depends
1470         $(RM) $@
1471         $(CC) -c $(JCFLAGS) options $*.c
1472
1473 ------------------------------------------------------------------------
1474 SpecialProfiledObjectRule(objs,depends,options):
1475     Generate rules to compile a file with special flags and to make a
1476     profiled version.
1477
1478     all::
1479         @if [ ! -d profiled ]; then mkdir profiled; fi
1480
1481     objs:    depends
1482         $(RM) $@ profiled/$@
1483         $(CC) -pg -c $(JCFLAGS) options $*.c
1484         $(MV) $*.o profiled/$*.o
1485         $(CC) -c $(JCFLAGS) options $*.c
1486
1487 ------------------------------------------------------------------------
1488 SpecialSharedAndDebuggedObjectRule(objs,depends,options):
1489     Generate rules to compile a file with special flags and to make
1490     shared and debuggable versions.
1491
1492     all::
1493         @if [ ! -d shared ]; then mkdir shared; fi
1494         @if [ ! -d debugger ]; then mkdir debugger; fi
1495
1496     objs:    depends
1497         $(RM) $@ shared/$@ debugger/$@
1498         $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) options $*.c
1499         $(MV) $*.o shared/$*.o
1500         $(CC) -g -c $(SHLIBDEF) $(JCFLAGS) options $*.c
1501         $(MV) $*.o debugger/$*.o
1502         $(CC) -c $(SHLIBDEF) $(JCFLAGS) options $*.c
1503
1504 ------------------------------------------------------------------------
1505 SpecialSharedObjectRule(objs,depends,options):
1506     Generate rules to compile a file with special flags and to make
1507     shared and debuggable versions.
1508
1509     all::
1510         @if [ ! -d shared ]; then mkdir shared; fi
1511
1512     objs:    depends
1513         $(RM) $@ shared/$@
1514         $(CC) -pic -c $(SHAREDCODEDEF) $(SHLIBDEF) $(JCFLAGS) options $*.c
1515         $(MV) $*.o shared/$*.o
1516         $(CC) -c $(SHLIBDEF) $(JCFLAGS) options $*.c
1517
1518 ------------------------------------------------------------------------
1519 TagSubdirs(dirs):
1520     Generate rules to recursively create tags files.
1521
1522     NamedTargetSubdirsRule(dirs,tag,"Tagging",/**/)
1523
1524 ------------------------------------------------------------------------
1525 TagsTarget():
1526     Generate rules to compute tags files for C source code.
1527
1528     tags::
1529         $(CTAGS) -w *.[ch]
1530         $(CTAGS) -xw *.[ch] > tags
1531
1532     local_clobber::
1533         $(RM) tags
1534
1535 ------------------------------------------------------------------------
1536 YaccRule():
1537     This is the rule which is used to build a .c file from a .y file.
1538
1539     AddSuffix(.y)
1540     |once _YaccRule_
1541     .y.c:
1542         $(YACC) $(JYFLAGS) $<
1543         $(MV) y.tab.c $@
1544
1545     -once
1546
1547 ------------------------------------------------------------------------
1548 _MakeInstallDir(dir):
1549     Internal macro to create a missing install directory.
1550
1551         (set -x; test -d $(INSTALL_PREFIX)/***/dir || \
1552             $(INSTALLDIR) $(INSTALL_PREFIX)/***/dir);
1553
1554 ------------------------------------------------------------------------
1555 _MakeInstallDirIgnore(dir):
1556     Same as _MakeInstallDir but handles "make -i" as well.
1557
1558         @case '${MFLAGS}' in *[i]*) set +e;; esac;        \
1559         _MakeInstallDir(dir)
1560
1561 ------------------------------------------------------------------------
1562 _MakeInstallDirs(dirs):
1563     Creates a set of intall directories, even if some directories in the path
1564     do not already exist. There should be no '@!' at the end of the
1565     '#define' line, because this macro is used *inside* building rules.
1566
1567         @case '${MFLAGS}' in *[i]*) set +e;; esac; \
1568         for dir in dirs; do    \
1569             _MakeInstallDir($$dir)    \
1570         done
1571
1572 ------------------------------------------------------------------------
1573 _RmInstallDirs(dirs):
1574     Removes a set of intall directories.
1575     There should be no '@!' at the end of the '#define' line, because this
1576     macro is used *inside* building rules.
1577
1578         @case '${MFLAGS}' in *[i]*) set +e;; esac; \
1579         for dir in dirs; do \
1580             (set -x; test -d $$dir && $(RM) -r $(INSTALL_PREFIX)$$dir); \
1581         done
1582
1583 ------------------------------------------------------------------------