This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
As in bin/mlint, use Getopt::Std::getopts() instead of Perl 4 getopts.pl.
[metaconfig.git] / dist / Index
CommitLineData
d8875586
MBT
1[This Index is automatically generated from Jmake.rules file. Do not
2edit this file or your changes will be lost. Edit Jmake.rules instead.]
3
4This file contains a listing of all the macros that can be used in a
5Jmakefile. Only a few of these should be used in the Jmakefile (they
6are the top-level macros). However, some low-level ones may be useful,
7but it is up to you to make that decision. This explains why this file
8holds all the available macros for jmake.
9
10In the following listing, the macros are separated by a line of dashes.
11The signature of the macro is given, then a small comment of what it
12does precedes the actual definition.
13
14Lines preceded by '->' show the set of symbols defined when the macro is
15used. Initialization lines are shown as-is, i.e. have the form SYM = val
16while concatenation is shown by SYM += val (which means val is added to
17the value of SYM).
18
19Conditional lines are preceded by tests like (if SYM). This means the line
20is to be kept if and only if the symbol SYM is defined. Other internal
21requests are not formatted yet.
22
23------------------------------------------------------------------------
24AddSuffix(ext):
25 Adds a sufix to the .SUFFIXES: list.
26
27 .SUFFIXES: ext
28
29------------------------------------------------------------------------
30AddedByConfigure(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------------------------------------------------------------------------
40AliasedLibraryTarget(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------------------------------------------------------------------------
50AllTarget(depends):
51 Generate rules to build necessary things during make all.
52
53 all:: depends
54
55 local_realclean::
56 $(RM) depends
57
58------------------------------------------------------------------------
59BuildMakefile():
60 Generate rules to build a Makefile from a Makefile.SH.
61
62 Makefile: Makefile.SH
63 /bin/sh Makefile.SH
64
65------------------------------------------------------------------------
66BuildMakefileSH(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------------------------------------------------------------------------
84CleanSubdirs():
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------------------------------------------------------------------------
92CleanTarget():
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------------------------------------------------------------------------
116CommonSubdirsRule(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------------------------------------------------------------------------
129ComplexProgramTarget(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------------------------------------------------------------------------
151ComplexProgramTarget_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------------------------------------------------------------------------
175ComplexProgramTarget_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------------------------------------------------------------------------
195ComplexProgramTarget_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------------------------------------------------------------------------
215ComplexShellManualTarget(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------------------------------------------------------------------------
244ComplexYaccInclude(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------------------------------------------------------------------------
272ComplexYaccTarget(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------------------------------------------------------------------------
295CppScriptTarget(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------------------------------------------------------------------------
306DebuggedAndProfiledLibraryObjectRule():
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------------------------------------------------------------------------
329DebuggedLibraryObjectRule():
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------------------------------------------------------------------------
347DebuggedLibraryTarget(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------------------------------------------------------------------------
361DebuggedRelocatableTarget(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------------------------------------------------------------------------
372DeinstallMultipleDest(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------------------------------------------------------------------------
383DependDependency():
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------------------------------------------------------------------------
393DependDirs(dirs):
394 Generate rules to recursively compute dependencies as part of the
395 make depend step.
396
397 NamedTargetSubdirsRule(dirs,depend,"Depending",/**/)
398
399------------------------------------------------------------------------
400DependSubdirs():
401 Generate rules to recursively compute dependencies as part of the
402 make depend step.
403
404 DependDirs($(SUBDIRS))
405
406------------------------------------------------------------------------
407DependTarget():
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------------------------------------------------------------------------
430Expand(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------------------------------------------------------------------------
441ForceTarget():
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------------------------------------------------------------------------
451IdentifiedLexDependTarget(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------------------------------------------------------------------------
465IdentifiedLexTarget(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------------------------------------------------------------------------
484IdentifiedParserTarget(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------------------------------------------------------------------------
496IdentifiedYaccTarget(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------------------------------------------------------------------------
507IncludesSubdirs():
508 Generate rules to recursively put include files in build
509
510 NamedTargetSubdirs(includes,including,/**/)
511
512------------------------------------------------------------------------
513Initialize(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------------------------------------------------------------------------
520InstallLibrary(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------------------------------------------------------------------------
533InstallLibraryAlias(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------------------------------------------------------------------------
545InstallLintLibrary(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------------------------------------------------------------------------
556InstallManPage(file,dest):
557 Generate rules to install the indicated manual page.
558
559 InstallManPageLong(file,dest,file)
560
561------------------------------------------------------------------------
562InstallManPageLong(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------------------------------------------------------------------------
577InstallManScripts():
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------------------------------------------------------------------------
604InstallManSubdirs():
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------------------------------------------------------------------------
611InstallMultiple(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------------------------------------------------------------------------
620InstallMultipleDestFlags(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------------------------------------------------------------------------
632InstallMultipleFlags(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------------------------------------------------------------------------
640InstallMultipleMan(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------------------------------------------------------------------------
648InstallNonExec(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------------------------------------------------------------------------
660InstallProgram(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------------------------------------------------------------------------
667InstallProgramNoStrip(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------------------------------------------------------------------------
675InstallProgramNoStripWithFlags(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------------------------------------------------------------------------
687InstallProgramWithFlags(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------------------------------------------------------------------------
699InstallScript(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------------------------------------------------------------------------
706InstallScriptWithFlags(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------------------------------------------------------------------------
718InstallScripts():
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------------------------------------------------------------------------
739InstallSharedLibrary(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------------------------------------------------------------------------
750InstallSharedLibraryData(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------------------------------------------------------------------------
761InstallSubdirs():
762 Generate rules to recursively install and deinstall programs and
763 files.
764
765 NamedSubTargetSubdirs(install,"Installing",/**/)
766 NamedDepthTargetSubdirs(deinstall,"Deinstalling",/**/)
767
768------------------------------------------------------------------------
769InstallTarget():
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------------------------------------------------------------------------
787LinkFileList(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------------------------------------------------------------------------
795LinkSourceFile(src,dir):
796 Snag source file from some other directory
797
798 src: dir/src
799 $(RM) $@
800 $(LN) $? $@
801
802------------------------------------------------------------------------
803LintDirs(dirs):
804 Generate rules to recursively lint directories as part of the
805 make lint step.
806
807 MakeLintSubdirs(dirs,lint)
808
809------------------------------------------------------------------------
810LintLibraryTarget(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------------------------------------------------------------------------
821LintSubdirs():
822 Generate rules to recursively lint directories as part of the
823 make lint step.
824
825 LintDirs($(SUBDIRS))
826
827------------------------------------------------------------------------
828LintTarget():
829 Generate rules to lint $(SOURCES) (automatically generated)
830
831 |once _LintTarget_
832 NormalLintTarget($(SOURCES))
833 -once
834
835------------------------------------------------------------------------
836MakeDirectories(step,dirs):
837 Generate rules to create a hierarchy of directories.
838
839 step::
840 MakeDirs(dirs)
841
842------------------------------------------------------------------------
843MakeDirs(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------------------------------------------------------------------------
855MakeInstallDirectories(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------------------------------------------------------------------------
866MakeLintLibSubdirs(dirs):
867 Generate rules to recursively create lint libraries.
868
869 MakeLintSubdirs(dirs,lintlib)
870
871------------------------------------------------------------------------
872MakeLintSubdirs(dirs,target):
873 Generate rules to recursively lint directories as part of the
874 named step.
875
876 NamedTargetSubdirsRule(dirs,target,"Linting",/**/)
877
878------------------------------------------------------------------------
879MakeMakeSubdirs(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------------------------------------------------------------------------
896MakeMakefilesSH():
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------------------------------------------------------------------------
926MakeScriptFromCpp(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------------------------------------------------------------------------
933MakeSubdirs():
934 Generate rules to do makes in the given subdirectories.
935
936 NamedTargetSubdirs(all,"Making all",/**/)
937
938------------------------------------------------------------------------
939MakeSubincludesForBuild(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------------------------------------------------------------------------
957MakefileSubdirs():
958 Generate rules to create Makefiles.
959
960 MakeMakeSubdirs(Makefiles)
961 MakeMakefilesSH()
962
963------------------------------------------------------------------------
964MakefileTarget():
965 Generate rules to build a normal Makefile.
966
967 BuildMakefileSH(/**/)
968 BuildMakefile()
969
970------------------------------------------------------------------------
971NamedDepthTargetSubdirs(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------------------------------------------------------------------------
981NamedSubTargetSubdirs(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------------------------------------------------------------------------
989NamedTargetSubdirs(name,verb,flags):
990 Recursively make a series of steps.
991
992 name::
993 @$(MAKE) subdirs TARGET=name VERB=verb FLAGS=flags
994
995------------------------------------------------------------------------
996NamedTargetSubdirsRule(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------------------------------------------------------------------------
1008NoManPages():
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------------------------------------------------------------------------
1015NormalLexDependTarget(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------------------------------------------------------------------------
1027NormalLibraryObjectRule():
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------------------------------------------------------------------------
1038NormalLibraryTarget(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------------------------------------------------------------------------
1055NormalLibraryTarget2(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------------------------------------------------------------------------
1073NormalLintTarget(srclist):
1074 Generate rules to lint a set of sources.
1075
1076 lint:
1077 $(LINT) $(LINTFLAGS) srclist $(LINTLIBS)
1078
1079------------------------------------------------------------------------
1080NormalObjectRule():
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------------------------------------------------------------------------
1090NormalObjectTarget(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------------------------------------------------------------------------
1099NormalParserTarget(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------------------------------------------------------------------------
1108NormalProgramTarget(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------------------------------------------------------------------------
1124NormalRelocatableTarget(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------------------------------------------------------------------------
1135NormalSharedLibraryDataTarget(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------------------------------------------------------------------------
1148NormalSharedLibraryTarget(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------------------------------------------------------------------------
1162NormalYaccTarget(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------------------------------------------------------------------------
1171PrelinkedRelocatableTarget(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------------------------------------------------------------------------
1182ProfiledLibraryObjectRule():
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------------------------------------------------------------------------
1199ProfiledLibraryTarget(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------------------------------------------------------------------------
1213ProfiledRelocatableTarget(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------------------------------------------------------------------------
1224RemoteDependency(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------------------------------------------------------------------------
1237RemoteTargetDependency(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------------------------------------------------------------------------
1246RemoveTargetProgram(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------------------------------------------------------------------------
1257SetSubdirs(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------------------------------------------------------------------------
1267SharedAndDebuggedLibraryObjectRule():
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------------------------------------------------------------------------
1290SharedLibraryObjectRule():
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------------------------------------------------------------------------
1307ShellScriptLongTarget(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------------------------------------------------------------------------
1326ShellScriptTarget(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------------------------------------------------------------------------
1334ShellScriptTargetExt(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------------------------------------------------------------------------
1347SimpleLexTarget(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------------------------------------------------------------------------
1367SimpleProgramTarget(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------------------------------------------------------------------------
1375SimpleShellScriptTarget(scripts):
1376 Generate rules to create a set of scripts from .SH files.
1377
1378 SimpleShellScriptTargetExt(scripts,.SH)
1379
1380------------------------------------------------------------------------
1381SimpleShellScriptTargetExt(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------------------------------------------------------------------------
1395SimpleYaccInclude(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------------------------------------------------------------------------
1412SimpleYaccTarget(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------------------------------------------------------------------------
1428SingleProgramTarget(program,objects,libs):
1429 Obsolete version of NormalProgramTarget that doesn't have
1430 deplibs.
1431
1432 NormalProgramTarget(program,objects,libs)
1433
1434------------------------------------------------------------------------
1435SpecialDebuggedAndProfiledObjectRule(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------------------------------------------------------------------------
1452SpecialDebuggedObjectRule(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------------------------------------------------------------------------
1466SpecialObjectRule(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------------------------------------------------------------------------
1474SpecialProfiledObjectRule(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------------------------------------------------------------------------
1488SpecialSharedAndDebuggedObjectRule(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------------------------------------------------------------------------
1505SpecialSharedObjectRule(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------------------------------------------------------------------------
1519TagSubdirs(dirs):
1520 Generate rules to recursively create tags files.
1521
1522 NamedTargetSubdirsRule(dirs,tag,"Tagging",/**/)
1523
1524------------------------------------------------------------------------
1525TagsTarget():
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------------------------------------------------------------------------
1536YaccRule():
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------------------------------------------------------------------------