/[ascend]/trunk/jam/Jambase
ViewVC logotype

Annotation of /trunk/jam/Jambase

Parent Directory Parent Directory | Revision Log Revision Log


Revision 47 - (hide annotations) (download)
Thu Apr 7 23:59:22 2005 UTC (15 years, 9 months ago) by jds
File size: 51845 byte(s)
Updated jam build files:
-Added support for -DTIMESTAMP builder credit.
- Renamed Tcl/Tk/TkTable libs for MinGW to match common gcc names.
- Corrected Linux ref in tcltk98 Jamfile.
- Added ascPrintTcl.c to list of interface sources.
- Fixed default CP definition in Jambase.
- Reworked gcc warning options in Jamrules_general.

utilities/ascConfig.h
- Added UNREFERENCED_PARAMETER() macro to standardize handling of unreferenced parameters.
-__WIN32__ macros for isnan(), isinf(), finite() not redefined if the plain versions exist (underscore not added in all __WIN32__ compiler systems, e.g. MinGW)

interface/ascPrintTcl.[ch]
- Added return value to Asc_PrintInit_TclVtable().
- Modified doxygen comments to describe function return values.

interface/Driver.c
- Added #include "interface/tkConsole.h" for __WIN32__ to pull in console functions.
- Added UNREFERENCED_PARAMETER() for WinMain() parameters.
1 jds 40 #
2     # /+\
3     # +\ Copyright 1993, 2000 Christopher Seiwald.
4     # \+/
5     #
6     # This file is part of Jam - see jam.c for Copyright information.
7     #
8    
9     #
10     # JAMBASE - jam 2.3 ruleset providing make(1)-like functionality
11     #
12     # Supports UNIX, NT, and VMS.
13     #
14     # 12/27/93 (seiwald) - purturb library sources with SOURCE_GRIST
15     # 04/18/94 (seiwald) - use '?=' when setting OS specific vars
16     # 04/21/94 (seiwald) - do RmTemps together
17     # 05/05/94 (seiwald) - all supported C compilers support -o: relegate
18     # RELOCATE as an option; set Ranlib to "" to disable it
19     # 06/01/94 (seiwald) - new 'actions existing' to do existing sources
20     # 08/25/94 (seiwald) - new ObjectCcFlags rule to append to per-target CCFLAGS
21     # 08/29/94 (seiwald) - new ObjectHdrs rule to append to per-target HDRS
22     # 09/19/94 (seiwald) - LinkLibraries and Undefs now append
23     # - Rule names downshifted.
24     # 10/06/94 (seiwald) - Dumb yyacc stuff moved into Jamfile.
25     # 10/14/94 (seiwald) - (Crude) support for .s, .C, .cc, .cpp, and .f files.
26     # 01/08/95 (seiwald) - Shell now handled with awk, not sed
27     # 01/09/95 (seiwald) - Install* now take dest directory as target
28     # 01/10/95 (seiwald) - All entries sorted.
29     # 01/10/95 (seiwald) - NT support moved in, with LauraW's help.
30     # 01/10/95 (seiwald) - VMS support moved in.
31     # 02/06/95 (seiwald) - ObjectC++Flags and SubDirC++Flags added.
32     # 02/07/95 (seiwald) - Iron out when HDRSEARCH uses "" or SEARCH_SOURCE.
33     # 02/08/95 (seiwald) - SubDir works on VMS.
34     # 02/14/95 (seiwald) - MkDir and entourage.
35     # 04/30/95 (seiwald) - Use install -c flag so that it copies, not moves.
36     # 07/10/95 (taylor) - Support for Microsoft C++.
37     # 11/21/96 (peterk) - Support for BeOS
38     # 07/19/99 (sickel) - Support for Mac OS X Server (and maybe client)
39     # 02/18/00 (belmonte)- Support for Cygwin.
40     # 11/05/04 (st.clair)- Modified MinGW variables and actions
41    
42     # Special targets defined in this file:
43     #
44     # all - parent of first, shell, files, lib, exe
45     # first - first dependent of 'all', for potential initialization
46     # shell - parent of all Shell targets
47     # files - parent of all File targets
48     # lib - parent of all Library targets
49     # exe - parent of all Main targets
50     # dirs - parent of all MkDir targets
51     # clean - removes all Shell, File, Library, and Main targets
52     # uninstall - removes all Install targets
53     #
54    
55     # Rules defined by this file:
56     #
57     # as obj.o : source.s ; .s -> .o
58     # Bulk dir : files ; populate directory with many files
59     # Cc obj.o : source.c ; .c -> .o
60     # C++ obj.o : source.cc ; .cc -> .o
61     # Clean clean : sources ; remove sources with 'jam clean'
62     # File dest : source ; copy file
63     # Fortran obj.o : source.f ; .f -> .o
64     # GenFile source.c : program args ; make custom file
65     # Hardlink target : source ; make link from source to target
66     # HdrRule source : headers ; handle #includes
67     # InstallInto dir : sources ; install any files
68     # InstallBin dir : sources ; install binaries
69     # InstallLib dir : sources ; install files
70     # InstallFile dir : sources ; install files
71     # InstallMan dir : sources ; install man pages
72     # InstallShell dir : sources ; install shell scripts
73     # Lex source.c : source.l ; .l -> .c
74     # Library lib : source ; archive library from compiled sources
75     # LibraryFromObjects lib : objects ; archive library from objects
76     # LinkLibraries images : libraries ; bag libraries onto Mains
77     # Main image : source ; link executable from compiled sources
78     # MainFromObjects image : objects ; link executable from objects
79     # MkDir dir ; make a directory, if not there
80     # Object object : source ; compile object from source
81     # ObjectCcFlags source : flags ; add compiler flags for object
82     # ObjectC++Flags source : flags ; add compiler flags for object
83     # ObjectHdrs source : dirs ; add include directories for object
84     # Objects sources ; compile sources
85     # RmTemps target : sources ; remove temp sources after target made
86     # Setuid images ; mark executables Setuid
87     # SubDir TOP d1 d2 ... ; start a subdirectory Jamfile
88     # SubDirCcFlags flags ; add compiler flags until next SubDir
89     # SubDirC++Flags flags ; add compiler flags until next SubDir
90     # SubDirHdrs dirs ; add include dirs until next SubDir
91     # SubInclude TOP d1 d2 ... ; include a subdirectory Jamfile
92     # Shell exe : source ; make a shell executable
93     # Undefines images : symbols ; save undef's for linking
94     # UserObject object : source ; handle unknown suffixes for Object
95     # Yacc source.c : source.y ; .y -> .c
96     #
97     # Utility rules that have no side effects (not supported):
98     #
99     # FAppendSuffix f1 f2 ... : $(SUF) ; return $(<) with suffixes
100     # FConcat value ... ; return contatenated values
101     # FDirName d1 d2 ... ; return path from root to dir
102     # FGrist d1 d2 ... ; return d1!d2!...
103     # FGristFiles value ; return $(value:G=$(SOURCE_GRIST))
104     # FGristSourceFiles value ; return $(value:G=$(SOURCE_GRIST))
105     # FRelPath d1 : d2 ; return rel path from d1 to d2
106     # FSubDir d1 d2 ... ; return path to root
107     #
108    
109    
110     # Brief review of the jam language:
111     #
112     # Statements:
113     # rule RULE - statements to process a rule
114     # actions RULE - system commands to carry out target update
115     #
116     # Modifiers on actions:
117     # together - multiple instances of same rule on target get executed
118     # once with their sources ($(>)) concatenated
119     # updated - refers to updated sources ($(>)) only
120     # ignore - ignore return status of command
121     # quietly - don't trace its execution unless verbose
122     # piecemeal - iterate command each time with a small subset of $(>)
123     # existing - refers to currently existing sources ($(>)) only
124     # bind vars - subject to binding before expanding in actions
125     #
126     # Special rules:
127     # ALWAYS - always build a target
128     # DEPENDS - builds the dependency graph
129     # ECHO - blurt out targets on stdout
130     # EXIT - blurt out targets and exit
131     # INCLUDES - marks sources as headers for target (a codependency)
132     # NOCARE - don't panic if the target can't be built
133     # NOUPDATE - create the target if needed but never update it
134     # NOTFILE - ignore the timestamp of the target (it's not a file)
135     # TEMPORARY - target need not be present if sources haven't changed
136     #
137     # Special variables set by jam:
138     # $(<) - targets of a rule (to the left of the :)
139     # $(>) - sources of a rule (to the right of the :)
140     # $(xxx) - true on xxx (UNIX, VMS, NT, OS2, MAC)
141     # $(OS) - name of OS - varies wildly
142     # $(JAMVERSION) - version number (2.3)
143     #
144     # Special variables used by jam:
145     # SEARCH - where to find something (used during binding and actions)
146     # LOCATE - where to plop something not found with SEARCH
147     # HDRRULE - rule to call to handle include files
148     # HDRSCAN - egrep regex to extract include files
149     #
150     # Special targets:
151     # all - default if none given on command line
152     #
153    
154     # Initialize variables
155     #
156    
157     #
158     # OS specific variable settings
159     #
160    
161     if $(NT)
162     {
163     # the list of supported toolsets on Windows NT and Windows 95/98
164     #
165     local SUPPORTED_TOOLSETS =
166     "BORLANDC"
167     "VISUALC"
168     "VISUALC16"
169     "INTELC"
170     "WATCOM"
171     "MINGW"
172     "LCC"
173     ;
174    
175     # this variable holds the current toolset
176     #
177     TOOLSET = "" ;
178    
179     # if the JAM_TOOLSET environment variable is defined, check that it is
180     # one of our supported values
181     #
182     if $(JAM_TOOLSET)
183     {
184     local t ;
185    
186     for t in $(SUPPORTED_TOOLSETS)
187     {
188     if $(t) = $(JAM_TOOLSET) { TOOLSET = $(t) ; }
189     }
190    
191     if ! $(TOOLSET)
192     {
193     ECHO "The JAM_TOOLSET environment variable is defined but its value" ;
194     ECHO "is invalid, please use one of the following:" ;
195     ECHO ;
196    
197     for t in $(SUPPORTED_TOOLSETS) { ECHO " " $(t) ; }
198     EXIT ;
199     }
200     }
201    
202     # if TOOLSET is empty, we'll try to detect the toolset from other
203     # environment variables to remain backwards compatible with Jam 2.3
204     #
205     if ! $(TOOLSET)
206     {
207     if $(BCCROOT)
208     {
209     TOOLSET = BORLANDC ;
210     BORLANDC = $(BCCROOT) ;
211     }
212     else if $(MSVC)
213     {
214     TOOLSET = VISUALC16 ;
215     VISUALC16 = $(MSVC) ;
216     }
217     else if $(MSVCNT)
218     {
219     TOOLSET = VISUALC ;
220     VISUALC = $(MSVCNT) ;
221     }
222     else if $(MINGW)
223     {
224     TOOLSET = MINGW ;
225     }
226     else
227     {
228     ECHO "Jam cannot be run because you didn't indicate which compilation toolset" ;
229     ECHO "to use. To do so, follow these simple instructions:" ;
230     ECHO ;
231     ECHO " - define one of the following environment variable, with the" ;
232     ECHO " appropriate value according to this list:" ;
233     ECHO ;
234     ECHO " Variable Toolset Description" ;
235     ECHO ;
236     ECHO " BORLANDC Borland C++ BC++ install path" ;
237     ECHO " VISUALC Microsoft Visual C++ VC++ install path" ;
238     ECHO " VISUALC16 Microsoft Visual C++ 16 bit VC++ 16 bit install" ;
239     ECHO " INTELC Intel C/C++ IC++ install path" ;
240     ECHO " WATCOM Watcom C/C++ Watcom install path" ;
241     ECHO " MINGW MinGW (gcc) MinGW install path" ;
242     ECHO " LCC Win32-LCC LCC-Win32 install path" ;
243     ECHO ;
244     ECHO " - define the JAM_TOOLSET environment variable with the *name*" ;
245     ECHO " of the toolset variable you want to use." ;
246     ECHO ;
247     ECHO " e.g.: set VISUALC=C:\Visual6" ;
248     ECHO " set JAM_TOOLSET=VISUALC" ;
249     ECHO ;
250     EXIT ;
251     }
252     }
253    
254     CP ?= copy ;
255     RM ?= del ;
256     MV ?= move /Y ;
257     SLASH ?= \\ ;
258     SUFLIB ?= .lib ;
259     SUFOBJ ?= .obj ;
260     SUFEXE ?= .exe ;
261    
262     if $(TOOLSET) = BORLANDC
263     {
264     ECHO "Compiler is Borland C++" ;
265    
266     AR ?= tlib /C /P64 ;
267     CC ?= bcc32 ;
268     CCFLAGS ?= -q -y -d -v -w-par -w-ccc -w-rch -w-pro -w-aus ;
269     C++ ?= bcc32 ;
270     C++FLAGS ?= -q -y -d -v -w-par -w-ccc -w-rch -w-pro -w-aus -P ;
271     STDLIBPATH ?= $(BORLANDC)\\lib ;
272     STDHDRS ?= $(BORLANDC)\\include ;
273     LINK ?= $(CC) ;
274     LINKFLAGS ?= $(CCFLAGS) -L$(STDLIBPATH) ;
275     NOARSCAN ?= true ;
276     }
277     else if $(TOOLSET) = VISUALC16
278     {
279     ECHO "Compiler is Microsoft Visual C++ 16 bit" ;
280    
281     AR ?= lib /nologo ;
282     CC ?= cl /nologo ;
283     CCFLAGS ?= /D \"WIN\" ;
284     C++ ?= $(CC) ;
285     C++FLAGS ?= $(CCFLAGS) ;
286     LINK ?= $(CC) ;
287     LINKFLAGS ?= $(CCFLAGS) ;
288     LINKLIBS ?=
289     #$(VISUALC16)\\lib\\advapi32.lib
290     #$(VISUALC16)\\lib\\libcmt.lib
291     $(VISUALC16)\\lib\\mlibce.lib
292     #$(VISUALC16)\\lib\\slibce.lib
293     $(VISUALC16)\\lib\\oldnames.lib
294     #$(VISUALC16)\\lib\\kernel32.lib
295     ;
296     LINKLIBS ?= ;
297     NOARSCAN ?= true ;
298     OPTIM ?= "" ;
299     STDHDRS ?= $(VISUALC16)\\include ;
300     UNDEFFLAG ?= "/u _" ;
301     }
302     else if $(TOOLSET) = VISUALC
303     {
304     ECHO "Compiler is Microsoft Visual C++" ;
305    
306     AR ?= lib ;
307     AS ?= masm386 ;
308     CC ?= cl /nologo ;
309     CCFLAGS ?= "" ;
310     C++ ?= $(CC) ;
311     C++FLAGS ?= $(CCFLAGS) ;
312     LINK ?= link /nologo ;
313     LINKFLAGS ?= "" ;
314     LINKLIBS ?= $(VISUALC)\\lib\\advapi32.lib
315     $(VISUALC)\\lib\\libc.lib
316     $(VISUALC)\\lib\\oldnames.lib
317     $(VISUALC)\\lib\\gdi32.lib
318     $(VISUALC)\\lib\\user32.lib
319     $(VISUALC)\\lib\\kernel32.lib ;
320     OPTIM ?= "" ;
321     STDHDRS ?= $(VISUALC)\\include ;
322     UNDEFFLAG ?= "/u _" ;
323     }
324     else if $(TOOLSET) = INTELC
325     {
326     ECHO "Compiler is Intel C/C++" ;
327    
328     if ! $(VISUALC)
329     {
330     ECHO "As a special exception, when using the Intel C++ compiler, you need" ;
331     ECHO "to define the VISUALC environment variable to indicate the location" ;
332     ECHO "of your Visual C++ installation. Aborting.." ;
333     EXIT ;
334     }
335    
336     AR ?= lib ;
337     AS ?= masm386 ;
338     CC ?= icl /nologo ;
339     CCFLAGS ?= "" ;
340     C++ ?= $(CC) ;
341     C++FLAGS ?= $(CCFLAGS) ;
342     LINK ?= link /nologo ;
343     LINKFLAGS ?= "" ;
344     LINKLIBS ?= $(VISUALC)\\lib\\advapi32.lib
345     $(VISUALC)\\lib\\libc.lib
346     $(VISUALC)\\lib\\oldnames.lib
347     $(VISUALC)\\lib\\kernel32.lib ;
348     OPTIM ?= "" ;
349     STDHDRS ?= $(INTELC)\include $(VISUALC)\\include ;
350     UNDEFFLAG ?= "/u _" ;
351     }
352     else if $(TOOLSET) = WATCOM
353     {
354     ECHO "Compiler is Watcom C/C++" ;
355    
356     AR ?= wlib ;
357     CC ?= wcc386 ;
358     CCFLAGS ?= /zq /DWIN32 /I$(WATCOM)\\h ; # zq=quiet
359     C++ ?= wpp386 ;
360     C++FLAGS ?= $(CCFLAGS) ;
361     DOT ?= . ;
362     DOTDOT ?= .. ;
363     FORTRAN ?= wfc386 ;
364     LINK ?= wcl386 ;
365     LINKFLAGS ?= /zq ; # zq=quiet
366     LINKLIBS ?= ;
367     NOARSCAN ?= true ;
368     OPTIM ?= ;
369     STDHDRS ?= $(WATCOM)\\h $(WATCOM)\\h\\nt ;
370     UNDEFFLAG ?= "/u _" ;
371     }
372     else if $(TOOLSET) = MINGW
373     {
374     ECHO "Compiler is GCC with Mingw" ;
375    
376     AR ?= ar -ru ;
377     CC ?= gcc ;
378     CCFLAGS ?= "" ;
379     C++ ?= $(CC) ;
380     C++FLAGS ?= $(CCFLAGS) ;
381     FORTRAN ?= g77 ;
382     LINK ?= $(CC) ;
383     LINKFLAGS ?= "" ;
384     LINKLIBS ?= "" ;
385     OPTIM ?= ;
386     SUFOBJ = .o ;
387     SUFLIB = .a ;
388     # NOARSCAN ?= true ;
389     }
390     else if $(TOOLSET) = LCC
391     {
392     ECHO "Compiler is Win32-LCC" ;
393    
394     AR ?= lcclib ;
395     CC ?= lcc ;
396     CCFLAGS ?= "" ;
397     C++ ?= $(CC) ;
398     C++FLAGS ?= $(CCFLAGS) ;
399     LINK ?= lcclnk ;
400     LINKFLAGS ?= "" ;
401     LINKLIBS ?= "" ;
402     OPTIM ?= ;
403     NOARSCAN = true ;
404     }
405     else
406     {
407     EXIT On NT, did not recognize compiler type. ;
408     }
409     }
410    
411     else if $(OS2)
412     {
413     # the list of supported toolsets on Windows NT and Windows 95/98
414     #
415     local SUPPORTED_TOOLSETS = "EMX" "WATCOM" ;
416    
417     # this variable holds the current toolset
418     #
419     TOOLSET = "" ;
420    
421     # if the JAM_TOOLSET environment variable is defined, check that it is
422     # one of our supported values
423     #
424     if $(JAM_TOOLSET)
425     {
426     local t ;
427    
428     for t in $(SUPPORTED_TOOLSETS)
429     {
430     if $(t) = $(JAM_TOOLSET) { TOOLSET = $(t) ; }
431     }
432    
433     if ! $(TOOLSET)
434     {
435     ECHO "The JAM_TOOLSET environment variable is defined but its value" ;
436     ECHO "is invalid, please use one of the following:" ;
437     ECHO ;
438    
439     for t in $(SUPPORTED_TOOLSETS) { ECHO " " $(t) ; }
440     EXIT ;
441     }
442     }
443    
444     # if TOOLSET is empty, we'll try to detect the toolset from other
445     # environment variables to remain backwards compatible with Jam 2.3
446     #
447     if ! $(TOOLSET)
448     {
449     if $(watcom)
450     {
451     WATCOM = $(watcom) ;
452     TOOLSET = WATCOM ;
453     }
454     else
455     {
456     ECHO "Jam cannot be run because you didn't indicate which compilation toolset" ;
457     ECHO "to use. To do so, follow these simple instructions:" ;
458     ECHO ;
459     ECHO " - define one of the following environment variable, with the" ;
460     ECHO " appropriate value according to this list:" ;
461     ECHO ;
462     ECHO " Variable Toolset Description" ;
463     ECHO ;
464     ECHO " WATCOM Watcom C/C++ Watcom install path" ;
465     ECHO " EMX EMX (gcc) EMX install path" ;
466     ECHO " VISUALAGE IBM Visual Age C/C++ VisualAge install path" ;
467     ECHO ;
468     ECHO " - define the JAM_TOOLSET environment variable with the *name*" ;
469     ECHO " of the toolset variable you want to use." ;
470     ECHO ;
471     ECHO " e.g.: set WATCOM=C:\WATCOM" ;
472     ECHO " set JAM_TOOLSET=WATCOM" ;
473     ECHO ;
474     EXIT ;
475     }
476     }
477    
478     RM = del /f ;
479     CP = copy ;
480     MV ?= move ;
481     DOT ?= . ;
482     DOTDOT ?= .. ;
483     SUFLIB ?= .lib ;
484     SUFOBJ ?= .obj ;
485     SUFEXE ?= .exe ;
486    
487     if $(TOOLSET) = WATCOM
488     {
489     AR ?= wlib ;
490     BINDIR ?= \\os2\\apps ;
491     CC ?= wcc386 ;
492     CCFLAGS ?= /zq /DOS2 /I$(WATCOM)\\h ; # zq=quiet
493     C++ ?= wpp386 ;
494     C++FLAGS ?= $(CCFLAGS) ;
495     LINK ?= wcl386 ;
496     LINKFLAGS ?= /zq ; # zq=quiet
497     LINKLIBS ?= ;
498     NOARSCAN ?= true ;
499     OPTIM ?= ;
500     SLASH ?= \\ ;
501     STDHDRS ?= $(WATCOM)\\h ;
502     UNDEFFLAG ?= "/u _" ;
503     }
504     else if $(TOOLSET) = EMX
505     {
506     ECHO "Compiler is GCC-EMX" ;
507     AR ?= ar -ru ;
508     CC ?= gcc ;
509     CCFLAGS ?= "" ;
510     C++ ?= $(CC) ;
511     C++FLAGS ?= $(CCFLAGS) ;
512     LINK ?= $(CC) ;
513     LINKFLAGS ?= "" ;
514     LINKLIBS ?= "" ;
515     OPTIM ?= ;
516     SUFOBJ = .o ;
517     SUFLIB = .a ;
518     UNDEFFLAG ?= "-U" ;
519     SLASH = / ;
520     # NOARSCAN ?= true ;
521     }
522     else
523     {
524     # should never happen
525     EXIT "Sorry, but the $(JAM_TOOLSET) toolset isn't supported for now" ;
526     }
527     }
528     else if $(VMS)
529     {
530     C++ ?= cxx ;
531     C++FLAGS ?= ;
532     CC ?= cc ;
533     CCFLAGS ?= ;
534     CHMOD ?= set file/prot= ;
535     CP ?= copy/replace ;
536     CRELIB ?= true ;
537     DOT ?= [] ;
538     DOTDOT ?= [-] ;
539     EXEMODE ?= (w:e) ;
540     FILEMODE ?= (w:r) ;
541     HDRS ?= ;
542     LINK ?= link ;
543     LINKFLAGS ?= "" ;
544     LINKLIBS ?= ;
545     MKDIR ?= create/dir ;
546     MV ?= rename ;
547     OPTIM ?= "" ;
548     RM ?= delete ;
549     RUNVMS ?= mcr ;
550     SHELLMODE ?= (w:er) ;
551     SLASH ?= . ;
552     STDHDRS ?= decc$library_include ;
553     SUFEXE ?= .exe ;
554     SUFLIB ?= .olb ;
555     SUFOBJ ?= .obj ;
556    
557     switch $(OS)
558     {
559     case OPENVMS : CCFLAGS ?= /stand=vaxc ;
560     case VMS : LINKLIBS ?= sys$library:vaxcrtl.olb/lib ;
561     }
562     }
563     else if $(MAC)
564     {
565     local OPT ;
566    
567     CW ?= "{CW}" ;
568    
569     MACHDRS ?=
570     "$(UMACHDRS):Universal:Interfaces:CIncludes"
571     "$(CW):MSL:MSL_C:MSL_Common:Include"
572     "$(CW):MSL:MSL_C:MSL_MacOS:Include" ;
573    
574     MACLIBS ?=
575     "$(CW):MacOS Support:Universal:Libraries:StubLibraries:Interfacelib"
576     "$(CW):MacOS Support:Universal:Libraries:StubLibraries:Mathlib" ;
577    
578     MPWLIBS ?=
579     "$(CW):MacOS Support:Libraries:Runtime:Runtime PPC:MSL MPWCRuntime.lib"
580     "$(CW):MSL:MSL_C:MSL_MacOS:Lib:PPC:MSL C.PPC MPW.Lib" ;
581    
582     MPWNLLIBS ?=
583     "$(CW):MacOS Support:Libraries:Runtime:Runtime PPC:MSL MPWCRuntime.lib"
584     "$(CW):MSL:MSL_C:MSL_MacOS:Lib:PPC:MSL C.PPC MPW(NL).Lib" ;
585    
586     SIOUXHDRS ?= ;
587    
588     SIOUXLIBS ?=
589     "$(CW):MacOS Support:Libraries:Runtime:Runtime PPC:MSL RuntimePPC.lib"
590     "$(CW):MSL:MSL_C:MSL_MacOS:Lib:PPC:MSL SIOUX.PPC.Lib"
591     "$(CW):MSL:MSL_C:MSL_MacOS:Lib:PPC:MSL C.PPC.Lib" ;
592    
593     C++ ?= mwcppc ;
594     C++FLAGS ?= -w off -nomapcr ;
595     CC ?= mwcppc ;
596     CCFLAGS ?= -w off -nomapcr ;
597     CP ?= duplicate -y ;
598     DOT ?= ":" ;
599     DOTDOT ?= "::" ;
600     HDRS ?= $(MACHDRS) $(MPWHDRS) ;
601     LINK ?= mwlinkppc ;
602     LINKFLAGS ?= -mpwtool -warn ;
603     LINKLIBS ?= $(MACLIBS) $(MPWLIBS) ;
604     MKDIR ?= newfolder ;
605     MV ?= rename -y ;
606     NOARSCAN ?= true ;
607     OPTIM ?= ;
608     RM ?= delete -y ;
609     SLASH ?= ":" ;
610     STDHDRS ?= ;
611     SUFLIB ?= .lib ;
612     SUFOBJ ?= .o ;
613     }
614     else if $(OS) = BEOS && $(METROWERKS)
615     {
616     AR ?= mwld -xml -o ;
617     BINDIR ?= /boot/apps ;
618     CC ?= mwcc ;
619     CCFLAGS ?= -nosyspath ;
620     C++ ?= $(CC) ;
621     C++FLAGS ?= -nosyspath ;
622     FORTRAN ?= "" ;
623     LIBDIR ?= /boot/develop/libraries ;
624     LINK ?= mwld ;
625     LINKFLAGS ?= "" ;
626     MANDIR ?= /boot/documentation/"Shell Tools"/HTML ;
627     NOARSCAN ?= true ;
628     STDHDRS ?= /boot/develop/headers/posix ;
629     }
630     else if $(OS) = BEOS
631     {
632     BINDIR ?= /boot/apps ;
633     CC ?= gcc ;
634     C++ ?= $(CC) ;
635     FORTRAN ?= "" ;
636     LIBDIR ?= /boot/develop/libraries ;
637     LINK ?= gcc ;
638     LINKLIBS ?= -lnet ;
639     NOARSCAN ?= true ;
640     STDHDRS ?= /boot/develop/headers/posix ;
641     }
642     else if $(UNIX)
643     {
644     switch $(OS)
645     {
646     case AIX :
647     LINKLIBS ?= -lbsd ;
648    
649     case AMIGA :
650     CC ?= gcc ;
651     YACC ?= bison ;
652    
653     case CYGWIN :
654     CC ?= gcc ;
655     CCFLAGS += -D__cygwin__ ;
656     LEX ?= flex ;
657     JAMSHELL ?= sh -c ;
658     RANLIB ?= "" ;
659     SUFEXE ?= .exe ;
660     YACC ?= bison ;
661    
662     case DGUX :
663     RANLIB ?= "" ;
664     RELOCATE ?= true ;
665    
666     case HPUX :
667     RANLIB ?= "" ;
668    
669     case INTERIX :
670     CC ?= gcc ;
671     JAMSHELL ?= sh -c ;
672     RANLIB ?= "" ;
673    
674     case IRIX :
675     RANLIB ?= "" ;
676    
677     case MPEIX :
678     CC ?= gcc ;
679     C++ ?= gcc ;
680     CCFLAGS += -D_POSIX_SOURCE ;
681     HDRS += /usr/include ;
682     RANLIB ?= "" ;
683     NOARSCAN ?= true ;
684     NOARUPDATE ?= true ;
685    
686     case MVS :
687     RANLIB ?= "" ;
688    
689     case NEXT :
690     AR ?= libtool -o ;
691     RANLIB ?= "" ;
692    
693     case MACOSX :
694     AR ?= libtool -o ;
695     C++ ?= c++ ;
696     MANDIR ?= /usr/local/share/man ;
697     RANLIB ?= "" ;
698    
699     case NCR :
700     RANLIB ?= "" ;
701    
702     case PTX :
703     RANLIB ?= "" ;
704    
705     case QNX :
706     AR ?= wlib ;
707     CC ?= cc ;
708     CCFLAGS ?= -Q ; # quiet
709     C++ ?= $(CC) ;
710     C++FLAGS ?= -Q ; # quiet
711     LINK ?= $(CC) ;
712     LINKFLAGS ?= -Q ; # quiet
713     NOARSCAN ?= true ;
714     RANLIB ?= "" ;
715    
716     case SCO :
717     RANLIB ?= "" ;
718     RELOCATE ?= true ;
719    
720     case SINIX :
721     RANLIB ?= "" ;
722    
723     case SOLARIS :
724     RANLIB ?= "" ;
725     AR ?= "/usr/ccs/bin/ar ru" ;
726    
727     case UNICOS :
728     NOARSCAN ?= true ;
729     OPTIM ?= -O0 ;
730    
731     case UNIXWARE :
732     RANLIB ?= "" ;
733     RELOCATE ?= true ;
734     }
735    
736     # UNIX defaults
737    
738     CCFLAGS ?= ;
739     C++FLAGS ?= $(CCFLAGS) ;
740     CHMOD ?= chmod ;
741     LEX ?= lex ;
742     LINKFLAGS ?= $(CCFLAGS) ;
743     LINKLIBS ?= ;
744     OPTIM ?= -O ;
745     RANLIB ?= ranlib ;
746     YACC ?= yacc ;
747     YACCFILES ?= y.tab ;
748     YACCFLAGS ?= -d ;
749     }
750    
751     #
752     # General defaults; a lot like UNIX
753     #
754    
755     AR ?= ar ru ;
756     AS ?= as ;
757     ASFLAGS ?= ;
758     AWK ?= awk ;
759     BINDIR ?= /usr/local/bin ;
760     C++ ?= gcc ;
761     C++FLAGS ?= ;
762     CC ?= gcc ;
763     CCFLAGS ?= ;
764 jds 47 CP ?= cp -f ;
765 jds 40 CRELIB ?= ;
766     DOT ?= . ;
767     DOTDOT ?= .. ;
768     EXEMODE ?= 711 ;
769     FILEMODE ?= 644 ;
770     FORTRAN ?= g77 ;
771     FORTRANFLAGS ?= ;
772     HDRS ?= ;
773     JAMFILE ?= Jamfile ;
774     JAMRULES ?= Jamrules ;
775     LEX ?= lex ;
776     LIBDIR ?= /usr/local/lib ;
777     LINK ?= $(CC) ;
778     LINKFLAGS ?= ;
779     LINKLIBS ?= ;
780     LN ?= ln ;
781     MANDIR ?= /usr/local/man ;
782     MKDIR ?= mkdir ;
783     MV ?= mv -f ;
784     OPTIM ?= ;
785     RCP ?= rcp ;
786     RM ?= rm -f ;
787     RSH ?= rsh ;
788     SED ?= sed ;
789     SHELLHEADER ?= "#!/bin/sh" ;
790     SHELLMODE ?= 755 ;
791     SLASH ?= / ;
792     STDHDRS ?= /usr/include ;
793     SUFEXE ?= "" ;
794     SUFLIB ?= .a ;
795     SUFOBJ ?= .o ;
796     UNDEFFLAG ?= "-u _" ;
797     YACC ?= ;
798     YACCFILES ?= ;
799     YACCFLAGS ?= ;
800    
801 jds 47 HDRPATTERN =
802 jds 40 "^[ ]*#[ ]*include[ ]*[<\"]([^\">]*)[\">].*$" ;
803    
804     OSFULL = $(OS)$(OSVER)$(OSPLAT) $(OS)$(OSPLAT) $(OS)$(OSVER) $(OS) ;
805    
806    
807     #
808     # Base dependencies - first for "bootstrap" kinds of rules
809     #
810    
811     DEPENDS all : shell files lib exe obj ;
812     DEPENDS all shell files lib exe obj : first ;
813     NOTFILE all first shell files lib exe obj dirs clean uninstall ;
814     ALWAYS clean uninstall ;
815    
816     #
817     # Rules
818     #
819    
820     rule As
821     {
822     DEPENDS $(<) : $(>) ;
823     ASFLAGS on $(<) += $(ASFLAGS) $(SUBDIRASFLAGS) ;
824     }
825    
826     rule Bulk
827     {
828     local i ;
829    
830     for i in $(>)
831     {
832     File $(i:D=$(<)) : $(i) ;
833     }
834     }
835    
836     rule Cc
837     {
838     local _h ;
839    
840     DEPENDS $(<) : $(>) ;
841    
842     # Just to clarify here: this sets the per-target CCFLAGS to
843     # be the current value of (global) CCFLAGS and SUBDIRCCFLAGS.
844    
845     CCFLAGS on $(<) += $(CCFLAGS) $(SUBDIRCCFLAGS) ;
846    
847     # If the compiler's -o flag doesn't work, relocate the .o
848    
849     if $(RELOCATE)
850     {
851     CcMv $(<) : $(>) ;
852     }
853    
854     _h = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;
855    
856     if $(VMS) && $(_h)
857     {
858     SLASHINC on $(<) = "/inc=(" $(_h[1]) ,$(_h[2-]) ")" ;
859     }
860     else if $(MAC) && $(_h)
861     {
862     local _i _j ;
863     _j = $(_h[1]) ;
864     for _i in $(_h[2-])
865     {
866     _j = $(_j),$(_i) ;
867     }
868     MACINC on $(<) = \"$(_j)\" ;
869     }
870     }
871    
872     rule C++
873     {
874     local _h ;
875    
876     DEPENDS $(<) : $(>) ;
877     C++FLAGS on $(<) += $(C++FLAGS) $(SUBDIRC++FLAGS) ;
878    
879     if $(RELOCATE)
880     {
881     CcMv $(<) : $(>) ;
882     }
883    
884     _h = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;
885    
886     if $(VMS) && $(_h)
887     {
888     SLASHINC on $(<) = "/inc=(" $(_h[1]) ,$(_h[2-]) ")" ;
889     }
890     else if $(MAC) && $(_h)
891     {
892     local _i _j ;
893     _j = $(_h[1]) ;
894     for _i in $(_h[2-])
895     {
896     _j = $(_j),$(_i) ;
897     }
898     MACINC on $(<) = \"$(_j)\" ;
899     }
900     }
901    
902     rule Chmod
903     {
904     if $(CHMOD) { Chmod1 $(<) ; }
905     }
906    
907     rule File
908     {
909     DEPENDS files : $(<) ;
910     DEPENDS $(<) : $(>) ;
911     SEARCH on $(>) = $(SEARCH_SOURCE) ;
912     MODE on $(<) = $(FILEMODE) ;
913     Chmod $(<) ;
914     }
915    
916     rule Fortran
917     {
918     DEPENDS $(<) : $(>) ;
919     }
920    
921     rule GenFile
922     {
923     local _t = [ FGristSourceFiles $(<) ] ;
924     local _s = [ FAppendSuffix $(>[1]) : $(SUFEXE) ] ;
925     Depends $(_t) : $(_s) $(>[2-]) ;
926     GenFile1 $(_t) : $(_s) $(>[2-]) ;
927     Clean clean : $(_t) ;
928     }
929    
930     rule GenFile1
931     {
932     MakeLocate $(<) : $(LOCATE_SOURCE) ;
933     SEARCH on $(>) = $(SEARCH_SOURCE) ;
934     }
935    
936     rule HardLink
937     {
938     DEPENDS files : $(<) ;
939     DEPENDS $(<) : $(>) ;
940     SEARCH on $(>) = $(SEARCH_SOURCE) ;
941     }
942    
943     rule HdrMacroFile
944     {
945     # HdrMacroFile file ;
946     #
947     # this rule is used to indicate that a given file contains definitions
948     # for filename macros (e.g. "#define MYFILE_H <myfile.h>") that can
949     # later be used in #include statements in the rest of the source
950     #
951     # theses files must be parsed before any make is tried..
952     #
953     HDRMACRO $(<) ;
954     }
955    
956     rule HdrRule
957     {
958     # HdrRule source : headers ;
959    
960     # N.B. This rule is called during binding, potentially after
961     # the fate of many targets has been determined, and must be
962     # used with caution: don't add dependencies to unrelated
963     # targets, and don't set variables on $(<).
964    
965     # Tell Jam that anything depending on $(<) also depends on $(>),
966     # set SEARCH so Jam can find the headers, but then say we don't
967     # care if we can't actually find the headers (they may have been
968     # within ifdefs),
969    
970     local s ;
971    
972     if $(HDRGRIST)
973     {
974     s = $(>:G=$(HDRGRIST)) ;
975     } else {
976     s = $(>) ;
977     }
978    
979     INCLUDES $(<) : $(s) ;
980     SEARCH on $(s) = $(HDRSEARCH) ;
981     NOCARE $(s) ;
982    
983     # Propagate on $(<) to $(>)
984    
985     HDRSEARCH on $(s) = $(HDRSEARCH) ;
986     HDRSCAN on $(s) = $(HDRSCAN) ;
987     HDRRULE on $(s) = $(HDRRULE) ;
988     HDRGRIST on $(s) = $(HDRGRIST) ;
989     }
990    
991     rule InstallInto
992     {
993     local i t ;
994    
995     t = $(>:G=installed) ;
996    
997     DEPENDS install : $(t) ;
998     DEPENDS $(t) : $(>) ;
999     SEARCH on $(>) = $(SEARCH_SOURCE) ;
1000     MakeLocate $(t) : $(<) ;
1001    
1002     # Arrange for jam uninstall
1003    
1004     Clean uninstall : $(t) ;
1005    
1006     for i in $(>)
1007     {
1008     Install $(i:G=installed) : $(i) ;
1009     }
1010    
1011     Chmod $(t) ;
1012    
1013     if $(UNIX)
1014     {
1015     if $(OWNER) { Chown $(t) ; OWNER on $(t) = $(OWNER) ; }
1016     if $(GROUP) { Chgrp $(t) ; GROUP on $(t) = $(GROUP) ; }
1017     }
1018     }
1019    
1020     rule InstallBin
1021     {
1022     local _t = [ FAppendSuffix $(>) : $(SUFEXE) ] ;
1023    
1024     InstallInto $(<) : $(_t) ;
1025     MODE on $(_t:G=installed) = $(EXEMODE) ;
1026     }
1027    
1028     rule InstallFile
1029     {
1030     InstallInto $(<) : $(>) ;
1031     MODE on $(>:G=installed) = $(FILEMODE) ;
1032     }
1033    
1034     rule InstallLib
1035     {
1036     InstallInto $(<) : $(>) ;
1037     MODE on $(>:G=installed) = $(FILEMODE) ;
1038     }
1039    
1040     rule InstallMan
1041     {
1042     # Really this just strips the . from the suffix
1043    
1044     local i s d ;
1045    
1046     for i in $(>)
1047     {
1048     switch $(i:S)
1049     {
1050     case .1 : s = 1 ; case .2 : s = 2 ; case .3 : s = 3 ;
1051     case .4 : s = 4 ; case .5 : s = 5 ; case .6 : s = 6 ;
1052     case .7 : s = 7 ; case .8 : s = 8 ; case .l : s = l ;
1053     case .n : s = n ; case .man : s = 1 ;
1054     }
1055    
1056     d = man$(s) ;
1057    
1058     InstallInto $(d:R=$(<)) : $(i) ;
1059     }
1060    
1061     MODE on $(>:G=installed) = $(FILEMODE) ;
1062     }
1063    
1064     rule InstallShell
1065     {
1066     InstallInto $(<) : $(>) ;
1067     MODE on $(>:G=installed) = $(SHELLMODE) ;
1068     }
1069    
1070     rule Lex
1071     {
1072     LexMv $(<) : $(>) ;
1073     DEPENDS $(<) : $(>) ;
1074     MakeLocate $(<) : $(LOCATE_SOURCE) ;
1075     Clean clean : $(<) ;
1076     }
1077    
1078     rule Library
1079     {
1080     LibraryFromObjects $(<) : $(>:S=$(SUFOBJ)) ;
1081     Objects $(>) ;
1082     }
1083    
1084     rule LibraryFromObjects
1085     {
1086     local _i _l _s ;
1087    
1088     # Add grist to file names
1089    
1090     _s = [ FGristFiles $(>) ] ;
1091     _l = $(<:S=$(SUFLIB)) ;
1092    
1093     # library depends on its member objects
1094    
1095     if $(KEEPOBJS)
1096     {
1097     DEPENDS obj : $(_s) ;
1098     }
1099     else
1100     {
1101     DEPENDS lib : $(_l) ;
1102     }
1103    
1104     # Set LOCATE for the library and its contents. The bound
1105     # value shows up as $(NEEDLIBS) on the Link actions.
1106     # For compatibility, we only do this if the library doesn't
1107     # already have a path.
1108    
1109     if ! $(_l:D)
1110     {
1111     MakeLocate $(_l) $(_l)($(_s:BS)) : $(LOCATE_TARGET) ;
1112     }
1113    
1114     if $(NOARSCAN)
1115     {
1116     # If we can't scan the library to timestamp its contents,
1117     # we have to just make the library depend directly on the
1118     # on-disk object files.
1119    
1120     DEPENDS $(_l) : $(_s) ;
1121     }
1122     else
1123     {
1124     # If we can scan the library, we make the library depend
1125     # on its members and each member depend on the on-disk
1126     # object file.
1127    
1128     DEPENDS $(_l) : $(_l)($(_s:BS)) ;
1129    
1130     for _i in $(_s)
1131     {
1132     DEPENDS $(_l)($(_i:BS)) : $(_i) ;
1133     }
1134     }
1135    
1136     Clean clean : $(_l) ;
1137    
1138     if $(CRELIB) { CreLib $(_l) : $(_s[1]) ; }
1139    
1140     Archive $(_l) : $(_s) ;
1141    
1142     if $(RANLIB) { Ranlib $(_l) ; }
1143    
1144     # If we can't scan the library, we have to leave the .o's around.
1145    
1146     if ! ( $(NOARSCAN) || $(KEEPOBJS) ) { RmTemps $(_l) : $(_s) ; }
1147     }
1148    
1149     rule Link
1150     {
1151     MODE on $(<) = $(EXEMODE) ;
1152     Chmod $(<) ;
1153     }
1154    
1155     rule LinkLibraries
1156     {
1157     # make library dependencies of target
1158     # set NEEDLIBS variable used by 'actions Main'
1159    
1160     local _t = [ FAppendSuffix $(<) : $(SUFEXE) ] ;
1161    
1162     DEPENDS $(_t) : $(>:S=$(SUFLIB)) ;
1163     NEEDLIBS on $(_t) += $(>:S=$(SUFLIB)) ;
1164     }
1165    
1166     rule Main
1167     {
1168     MainFromObjects $(<) : $(>:S=$(SUFOBJ)) ;
1169     Objects $(>) ;
1170     }
1171    
1172     rule MainFromObjects
1173     {
1174     local _s _t ;
1175    
1176     # Add grist to file names
1177     # Add suffix to exe
1178    
1179     _s = [ FGristFiles $(>) ] ;
1180     _t = [ FAppendSuffix $(<) : $(SUFEXE) ] ;
1181    
1182     if $(_t) != $(<)
1183     {
1184     DEPENDS $(<) : $(_t) ;
1185     NOTFILE $(<) ;
1186     }
1187    
1188     # make compiled sources a dependency of target
1189    
1190     DEPENDS exe : $(_t) ;
1191     DEPENDS $(_t) : $(_s) ;
1192     MakeLocate $(_t) : $(LOCATE_TARGET) ;
1193    
1194     Clean clean : $(_t) ;
1195    
1196     Link $(_t) : $(_s) ;
1197     }
1198    
1199     rule MakeLocate
1200     {
1201     if $(>)
1202     {
1203     LOCATE on $(<) = $(>) ;
1204     Depends $(<) : $(>[1]) ;
1205     MkDir $(>[1]) ;
1206     }
1207     }
1208    
1209     rule MkDir
1210     {
1211     # If dir exists, don't update it
1212     # Do this even for $(DOT).
1213    
1214     NOUPDATE $(<) ;
1215    
1216     if $(<) != $(DOT) && ! $($(<)-mkdir)
1217     {
1218     local s ;
1219    
1220     # Cheesy gate to prevent multiple invocations on same dir
1221     # MkDir1 has the actions
1222     # Arrange for jam dirs
1223    
1224     $(<)-mkdir = true ;
1225     MkDir1 $(<) ;
1226     Depends dirs : $(<) ;
1227    
1228     # Recursively make parent directories.
1229     # $(<:P) = $(<)'s parent, & we recurse until root
1230    
1231     s = $(<:P) ;
1232    
1233     if $(NT)
1234     {
1235     switch $(s)
1236     {
1237     case *: : s = ;
1238     case *:\\ : s = ;
1239     }
1240     }
1241    
1242     if $(s) && $(s) != $(<)
1243     {
1244     Depends $(<) : $(s) ;
1245     MkDir $(s) ;
1246     }
1247     else if $(s)
1248     {
1249     NOTFILE $(s) ;
1250     }
1251    
1252     }
1253     }
1254    
1255     rule Object
1256     {
1257     local h ;
1258    
1259     # locate object and search for source, if wanted
1260    
1261     Clean clean : $(<) ;
1262    
1263     MakeLocate $(<) : $(LOCATE_TARGET) ;
1264     SEARCH on $(>) = $(SEARCH_SOURCE) ;
1265    
1266     # Save HDRS for -I$(HDRS) on compile.
1267     # We shouldn't need -I$(SEARCH_SOURCE) as cc can find headers
1268     # in the .c file's directory, but generated .c files (from
1269     # yacc, lex, etc) are located in $(LOCATE_TARGET), possibly
1270     # different from $(SEARCH_SOURCE).
1271    
1272     HDRS on $(<) = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;
1273    
1274     # handle #includes for source: Jam scans for headers with
1275     # the regexp pattern $(HDRSCAN) and then invokes $(HDRRULE)
1276     # with the scanned file as the target and the found headers
1277     # as the sources. HDRSEARCH is the value of SEARCH used for
1278     # the found header files. Finally, if jam must deal with
1279     # header files of the same name in different directories,
1280     # they can be distinguished with HDRGRIST.
1281    
1282     # $(h) is where cc first looks for #include "foo.h" files.
1283     # If the source file is in a distant directory, look there.
1284     # Else, look in "" (the current directory).
1285    
1286     if $(SEARCH_SOURCE)
1287     {
1288     h = $(SEARCH_SOURCE) ;
1289     }
1290     else
1291     {
1292     h = "" ;
1293     }
1294    
1295     HDRRULE on $(>) = HdrRule ;
1296     HDRSCAN on $(>) = $(HDRPATTERN) ;
1297     HDRSEARCH on $(>) = $(HDRS) $(SUBDIRHDRS) $(h) $(STDHDRS) ;
1298     HDRGRIST on $(>) = $(HDRGRIST) ;
1299    
1300     # if source is not .c, generate .c with specific rule
1301    
1302     switch $(>:S)
1303     {
1304     case .asm : As $(<) : $(>) ;
1305     case .c : Cc $(<) : $(>) ;
1306     case .C : C++ $(<) : $(>) ;
1307     case .cc : C++ $(<) : $(>) ;
1308     case .cpp : C++ $(<) : $(>) ;
1309     case .f : Fortran $(<) : $(>) ;
1310     case .l : Cc $(<) : $(<:S=.c) ;
1311     Lex $(<:S=.c) : $(>) ;
1312     case .s : As $(<) : $(>) ;
1313     case .y : Cc $(<) : $(<:S=.c) ;
1314     Yacc $(<:S=.c) : $(>) ;
1315     case * : UserObject $(<) : $(>) ;
1316     }
1317     }
1318    
1319    
1320     rule ObjectCcFlags
1321     {
1322     CCFLAGS on [ FGristFiles $(<:S=$(SUFOBJ)) ] += $(>) ;
1323     }
1324    
1325     rule ObjectC++Flags
1326     {
1327     C++FLAGS on [ FGristFiles $(<:S=$(SUFOBJ)) ] += $(>) ;
1328     }
1329    
1330     rule ObjectHdrs
1331     {
1332     HDRS on [ FGristFiles $(<:S=$(SUFOBJ)) ] += $(>) ;
1333     }
1334    
1335     rule Objects
1336     {
1337     local _i ;
1338    
1339     for _i in [ FGristFiles $(<) ]
1340     {
1341     Object $(_i:S=$(SUFOBJ)) : $(_i) ;
1342     DEPENDS obj : $(_i:S=$(SUFOBJ)) ;
1343     }
1344     }
1345    
1346     rule RmTemps
1347     {
1348     TEMPORARY $(>) ;
1349     }
1350    
1351     rule Setuid
1352     {
1353     MODE on [ FAppendSuffix $(<) : $(SUFEXE) ] = 4711 ;
1354     }
1355    
1356     rule Shell
1357     {
1358     DEPENDS shell : $(<) ;
1359     DEPENDS $(<) : $(>) ;
1360     SEARCH on $(>) = $(SEARCH_SOURCE) ;
1361     MODE on $(<) = $(SHELLMODE) ;
1362     Clean clean : $(<) ;
1363     Chmod $(<) ;
1364     }
1365    
1366     rule SubDir
1367     {
1368     local _r _s ;
1369    
1370     #
1371     # SubDir TOP d1 [ ... ]
1372     #
1373     # This introduces a Jamfile that is part of a project tree
1374     # rooted at $(TOP). It (only once) includes the project-specific
1375     # rules file $(TOP)/Jamrules and then sets search & locate stuff.
1376     #
1377     # If the variable $(TOPRULES) is set (where TOP is the first arg
1378     # to SubDir), that file is included instead of $(TOP)/Jamrules.
1379     #
1380     # d1 ... are the directory elements that lead to this directory
1381     # from $(TOP). We construct the system dependent path from these
1382     # directory elements in order to set search&locate stuff.
1383     #
1384    
1385     if ! $($(<[1]))
1386     {
1387     if ! $(<[1])
1388     {
1389     EXIT SubDir syntax error ;
1390     }
1391    
1392     $(<[1]) = [ FSubDir $(<[2-]) ] ;
1393     }
1394    
1395     #
1396     # If $(TOP)/Jamrules hasn't been included, do so.
1397     #
1398    
1399     if ! $($(<[1])-included)
1400     {
1401     # Gated entry.
1402    
1403     $(<[1])-included = TRUE ;
1404    
1405     # File is $(TOPRULES) or $(TOP)/Jamrules.
1406    
1407     _r = $($(<[1])RULES) ;
1408    
1409     if ! $(_r)
1410     {
1411     _r = $(JAMRULES:R=$($(<[1]))) ;
1412     }
1413    
1414     # Include it.
1415    
1416     include $(_r) ;
1417     }
1418    
1419     # Get path to current directory from root using SubDir.
1420     # Save dir tokens for other potential uses.
1421    
1422     _s = [ FDirName $(<[2-]) ] ;
1423     SUBDIR = $(_s:R=$($(<[1]))) ;
1424     SUBDIR_TOKENS = $(<[2-]) ;
1425    
1426     # Now set up SEARCH_SOURCE, LOCATE_TARGET, SOURCE_GRIST
1427     # These can be reset if needed. For example, if the source
1428     # directory should not hold object files, LOCATE_TARGET can
1429     # subsequently be redefined.
1430    
1431     SEARCH_SOURCE = $(SUBDIR) ;
1432     LOCATE_SOURCE = $(ALL_LOCATE_TARGET) $(SUBDIR) ;
1433     LOCATE_TARGET = $(ALL_LOCATE_TARGET) $(SUBDIR) ;
1434     SOURCE_GRIST = [ FGrist $(<[2-]) ] ;
1435    
1436     # Reset per-directory ccflags, hdrs
1437    
1438     SUBDIRCCFLAGS = ;
1439     SUBDIRC++FLAGS = ;
1440     SUBDIRHDRS = ;
1441     }
1442    
1443     rule SubDirCcFlags
1444     {
1445     SUBDIRCCFLAGS += $(<) ;
1446     }
1447    
1448     rule SubDirC++Flags
1449     {
1450     SUBDIRC++FLAGS += $(<) ;
1451     }
1452    
1453     rule SubDirHdrs
1454     {
1455     SUBDIRHDRS += $(<) ;
1456     }
1457    
1458     rule SubInclude
1459     {
1460     local _s ;
1461    
1462     # That's
1463     # SubInclude TOP d1 [ d2 [ d3 [ d4 ] ] ]
1464     #
1465     # to include a subdirectory's Jamfile.
1466    
1467     if ! $($(<[1]))
1468     {
1469     EXIT Top level of source tree has not been set with $(<[1]) ;
1470     }
1471    
1472     _s = [ FDirName $(<[2-]) ] ;
1473    
1474     include $(JAMFILE:D=$(_s):R=$($(<[1]))) ;
1475     }
1476    
1477     rule Undefines
1478     {
1479     UNDEFS on [ FAppendSuffix $(<) : $(SUFEXE) ] += $(UNDEFFLAG)$(>) ;
1480     }
1481    
1482     rule UserObject
1483     {
1484     EXIT "Unknown suffix on" $(>) "- see UserObject rule in Jamfile(5)." ;
1485     }
1486    
1487     rule Yacc
1488     {
1489     local _h ;
1490    
1491     _h = $(<:BS=.h) ;
1492    
1493     # Some places don't have a yacc.
1494    
1495     MakeLocate $(<) $(_h) : $(LOCATE_SOURCE) ;
1496    
1497     if $(YACC)
1498     {
1499     DEPENDS $(<) $(_h) : $(>) ;
1500     Yacc1 $(<) $(_h) : $(>) ;
1501     YaccMv $(<) $(_h) : $(>) ;
1502     Clean clean : $(<) $(_h) ;
1503     }
1504    
1505     # make sure someone includes $(_h) else it will be
1506     # a deadly independent target
1507    
1508     INCLUDES $(<) : $(_h) ;
1509     }
1510    
1511     #
1512     # Utility rules; no side effects on these
1513     #
1514    
1515     rule FGrist
1516     {
1517     # Turn individual elements in $(<) into grist.
1518    
1519     local _g _i ;
1520    
1521     _g = $(<[1]) ;
1522    
1523     for _i in $(<[2-])
1524     {
1525     _g = $(_g)!$(_i) ;
1526     }
1527    
1528     return $(_g) ;
1529     }
1530    
1531     rule FGristFiles
1532     {
1533     if ! $(SOURCE_GRIST)
1534     {
1535     return $(<) ;
1536     }
1537     else
1538     {
1539     return $(<:G=$(SOURCE_GRIST)) ;
1540     }
1541     }
1542    
1543     rule FGristSourceFiles
1544     {
1545     # Produce source file name name with grist in it,
1546     # if SOURCE_GRIST is set.
1547    
1548     # Leave header files alone, because they have a global
1549     # visibility.
1550    
1551     if ! $(SOURCE_GRIST)
1552     {
1553     return $(<) ;
1554     }
1555     else
1556     {
1557     local _i _o ;
1558    
1559     for _i in $(<)
1560     {
1561     switch $(_i)
1562     {
1563     case *.h : _o += $(_i) ;
1564     case * : _o += $(_i:G=$(SOURCE_GRIST)) ;
1565     }
1566     }
1567    
1568     return $(_o) ;
1569     }
1570     }
1571    
1572     rule FConcat
1573     {
1574     # Puts the variables together, removing spaces.
1575    
1576     local _t _r ;
1577    
1578     $(_r) = $(<[1]) ;
1579    
1580     for _t in $(<[2-])
1581     {
1582     $(_r) = $(_r)$(_t) ;
1583     }
1584    
1585     return $(_r) ;
1586     }
1587    
1588     rule FSubDir
1589     {
1590     local _i _d ;
1591    
1592     # If $(>) is the path to the current directory, compute the
1593     # path (using ../../ etc) back to that root directory.
1594     # Sets result in $(<)
1595    
1596     if ! $(<[1])
1597     {
1598     _d = $(DOT) ;
1599     }
1600     else
1601     {
1602     _d = $(DOTDOT) ;
1603    
1604     for _i in $(<[2-])
1605     {
1606     _d = $(_d:R=$(DOTDOT)) ;
1607     }
1608     }
1609    
1610     return $(_d) ;
1611     }
1612    
1613     rule FDirName
1614     {
1615     local _s _i ;
1616    
1617     # Turn individual elements in $(<) into a usable path.
1618    
1619     if ! $(<)
1620     {
1621     _s = $(DOT) ;
1622     }
1623     else if $(VMS)
1624     {
1625     # This handles the following cases:
1626     # a -> [.a]
1627     # a b c -> [.a.b.c]
1628     # x: -> x:
1629     # x: a -> x:[a]
1630     # x:[a] b -> x:[a.b]
1631    
1632     switch $(<[1])
1633     {
1634     case *:* : _s = $(<[1]) ;
1635     case \\[*\\] : _s = $(<[1]) ;
1636     case * : _s = [.$(<[1])] ;
1637     }
1638    
1639     for _i in [.$(<[2-])]
1640     {
1641     _s = $(_i:R=$(_s)) ;
1642     }
1643     }
1644     else if $(MAC)
1645     {
1646     _s = $(DOT) ;
1647    
1648     for _i in $(<)
1649     {
1650     _s = $(_i:R=$(_s)) ;
1651     }
1652     }
1653     else
1654     {
1655     _s = $(<[1]) ;
1656    
1657     for _i in $(<[2-])
1658     {
1659     _s = $(_i:R=$(_s)) ;
1660     }
1661     }
1662    
1663     return $(_s) ;
1664     }
1665    
1666    
1667     rule _makeCommon
1668     {
1669     # strip common initial elements
1670    
1671     if $($(<)[1]) && $($(<)[1]) = $($(>)[1])
1672     {
1673     $(<) = $($(<)[2-]) ;
1674     $(>) = $($(>)[2-]) ;
1675     _makeCommon $(<) : $(>) ;
1676     }
1677     }
1678    
1679    
1680     rule FRelPath
1681     {
1682     local _l _r ;
1683    
1684     # first strip off common parts
1685    
1686     _l = $(<) ;
1687     _r = $(>) ;
1688    
1689     _makeCommon _l : _r ;
1690    
1691     # now make path to root and path down
1692    
1693     _l = [ FSubDir $(_l) ] ;
1694     _r = [ FDirName $(_r) ] ;
1695    
1696     # Concatenate and save
1697    
1698     # XXX This should be better
1699    
1700     if $(_r) = $(DOT) {
1701     return $(_l) ;
1702     } else {
1703     return $(_r:R=$(_l)) ;
1704     }
1705     }
1706    
1707     rule FAppendSuffix
1708     {
1709     # E.g., "FAppendSuffix yacc lex foo.bat : $(SUFEXE) ;"
1710     # returns (yacc,lex,foo.bat) on Unix and
1711     # (yacc.exe,lex.exe,foo.bat) on NT.
1712    
1713     if $(>)
1714     {
1715     local _i _o ;
1716    
1717     for _i in $(<)
1718     {
1719     if $(_i:S)
1720     {
1721     _o += $(_i) ;
1722     }
1723     else
1724     {
1725     _o += $(_i:S=$(>)) ;
1726     }
1727     }
1728     return $(_o) ;
1729     }
1730     else
1731     {
1732     return $(<) ;
1733     }
1734     }
1735    
1736     rule unmakeDir
1737     {
1738     if $(>[1]:D) && $(>[1]:D) != $(>[1]) && $(>[1]:D) != \\\\
1739     {
1740     unmakeDir $(<) : $(>[1]:D) $(>[1]:BS) $(>[2-]) ;
1741     }
1742     else
1743     {
1744     $(<) = $(>) ;
1745     }
1746     }
1747    
1748    
1749     rule FConvertToSlashes
1750     {
1751     local _d, _s, _i ;
1752    
1753     unmakeDir _d : $(<) ;
1754    
1755     _s = $(_d[1]) ;
1756     for _i in $(_d[2-])
1757     {
1758     _s = $(_s)/$(_i) ;
1759     }
1760     return $(_s) ;
1761     }
1762    
1763    
1764     #
1765     # Actions
1766     #
1767    
1768     #
1769     # First the defaults
1770     #
1771    
1772     actions updated together piecemeal Archive
1773     {
1774     $(AR) $(<) $(>)
1775     }
1776    
1777     actions As
1778     {
1779     $(AS) $(ASFLAGS) -I$(HDRS) -o $(<) $(>)
1780     }
1781    
1782     actions C++
1783     {
1784     $(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)
1785     }
1786    
1787     actions Cc
1788     {
1789     $(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)
1790     }
1791    
1792     actions Chgrp
1793     {
1794     chgrp $(GROUP) $(<)
1795     }
1796    
1797     actions Chmod1
1798     {
1799     $(CHMOD) $(MODE) $(<)
1800     }
1801    
1802     actions Chown
1803     {
1804     chown $(OWNER) $(<)
1805     }
1806    
1807     actions piecemeal together existing Clean
1808     {
1809     $(RM) $(>)
1810     }
1811    
1812     actions File
1813     {
1814     $(CP) $(>) $(<)
1815     }
1816    
1817     actions GenFile1
1818     {
1819     $(>[1]) $(<) $(>[2-])
1820     }
1821    
1822     actions Fortran
1823     {
1824     $(FORTRAN) $(FORTRANFLAGS) -o $(<) $(>)
1825     }
1826    
1827     actions HardLink
1828     {
1829     $(RM) $(<) && $(LN) $(>) $(<)
1830     }
1831    
1832     actions Install
1833     {
1834     $(CP) $(>) $(<)
1835     }
1836    
1837     actions Lex
1838     {
1839     $(LEX) $(>)
1840     }
1841    
1842     actions LexMv
1843     {
1844     $(MV) lex.yy.c $(<)
1845     }
1846    
1847     actions Link bind NEEDLIBS
1848     {
1849     $(LINK) $(LINKFLAGS) -o $(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
1850     }
1851    
1852     actions MkDir1
1853     {
1854     $(MKDIR) $(<)
1855     }
1856    
1857     actions together Ranlib
1858     {
1859     $(RANLIB) $(<)
1860     }
1861    
1862     actions quietly updated piecemeal together RmTemps
1863     {
1864     $(RM) $(>)
1865     }
1866    
1867     actions Shell
1868     {
1869     $(AWK) '
1870     NR == 1 { print "$(SHELLHEADER)" }
1871     NR == 1 && /^[#:]/ { next }
1872     /^##/ { next }
1873     { print }
1874     ' < $(>) > $(<)
1875     }
1876    
1877     actions Yacc1
1878     {
1879     $(YACC) $(YACCFLAGS) $(>)
1880     }
1881    
1882     actions YaccMv
1883     {
1884     $(MV) $(YACCFILES).c $(<[1])
1885     $(MV) $(YACCFILES).h $(<[2])
1886     }
1887    
1888     #
1889     # RELOCATE - for compilers with broken -o flags
1890     #
1891    
1892     if $(RELOCATE)
1893     {
1894     actions C++
1895     {
1896     $(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) $(>)
1897     }
1898    
1899     actions Cc
1900     {
1901     $(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) $(>)
1902     }
1903    
1904     actions ignore CcMv
1905     {
1906     [ $(<) != $(>:BS=$(SUFOBJ)) ] && $(MV) $(>:BS=$(SUFOBJ)) $(<)
1907     }
1908     }
1909    
1910     #
1911     # NOARUPDATE - can't update an archive
1912     #
1913    
1914     if $(NOARUPDATE)
1915     {
1916     actions Archive
1917     {
1918     $(AR) $(<) $(>)
1919     }
1920     }
1921    
1922     #
1923     # NT specific actions
1924     #
1925    
1926     if $(NT)
1927     {
1928     if $(TOOLSET) = VISUALC || $(TOOLSET) = INTELC
1929     {
1930     actions updated together piecemeal Archive
1931     {
1932     if exist $(<) set _$(<:B)_=$(<)
1933     $(AR) /out:$(<) %_$(<:B)_% $(>)
1934     }
1935    
1936     actions As
1937     {
1938     $(AS) /Ml /p /v /w2 $(>) $(<) ,nul,nul;
1939     }
1940    
1941     actions Cc
1942     {
1943     $(CC) /c $(CCFLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /I$(STDHDRS) $(>)
1944     }
1945    
1946     actions C++
1947     {
1948     $(C++) /c $(C++FLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /I$(STDHDRS) /Tp$(>)
1949     }
1950    
1951     actions Link bind NEEDLIBS
1952     {
1953     $(LINK) $(LINKFLAGS) /out:$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
1954     }
1955     }
1956     else if $(TOOLSET) = VISUALC16
1957     {
1958     actions updated together piecemeal Archive
1959     {
1960     $(AR) $(<) -+$(>)
1961     }
1962    
1963     actions Cc
1964     {
1965     $(CC) /c $(CCFLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) $(>)
1966     }
1967    
1968     actions C++
1969     {
1970     $(C++) /c $(C++FLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /Tp$(>)
1971     }
1972    
1973     actions Link bind NEEDLIBS
1974     {
1975     $(LINK) $(LINKFLAGS) /out:$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
1976     }
1977     }
1978     else if $(TOOLSET) = BORLANDC
1979     {
1980     actions updated together piecemeal Archive
1981     {
1982     $(AR) $(<) -+$(>)
1983     }
1984    
1985     actions Link bind NEEDLIBS
1986     {
1987     $(LINK) -e$(<) $(LINKFLAGS) $(UNDEFS) -L$(LINKLIBS) $(NEEDLIBS) $(>)
1988     }
1989    
1990     actions C++
1991     {
1992     $(C++) -c $(C++FLAGS) $(OPTIM) -I$(STDHDRS) -I$(HDRS) -o$(<) $(>)
1993     }
1994    
1995     actions Cc
1996     {
1997     $(CC) -c $(CCFLAGS) $(OPTIM) -I$(STDHDRS) -I$(HDRS) -o$(<) $(>)
1998     }
1999    
2000     }
2001     else if $(TOOLSET) = MINGW
2002     {
2003     # actions together piecemeal Archive
2004     # {
2005     # $(AR) $(<) $(>:T)
2006     # }
2007    
2008     # actions Cc
2009     # {
2010     # $(CC) $(CCFLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
2011     # }
2012    
2013     # actions C++
2014     # {
2015     # $(C++) $(C++FLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
2016     # }
2017     }
2018     else if $(TOOLSET) = WATCOM
2019     {
2020     actions together piecemeal Archive
2021     {
2022     $(AR) $(<) +-$(>)
2023     }
2024    
2025     actions Cc
2026     {
2027     $(CC) $(CCFLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
2028     }
2029    
2030     actions C++
2031     {
2032     $(C++) $(C++FLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
2033     }
2034    
2035     actions Fortran
2036     {
2037     $(FORTRAN) $(FORTRANFLAGS) /FO=$(<) $(>)
2038     }
2039    
2040     actions Link bind NEEDLIBS
2041     {
2042     $(LINK) $(LINKFLAGS) /Fe=$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
2043     }
2044    
2045     actions Shell
2046     {
2047     $(CP) $(>) $(<)
2048     }
2049     }
2050     else if $(TOOLSET) = LCC
2051     {
2052     actions together piecemeal Archive
2053     {
2054     $(AR) /out:$(<) $(>)
2055     }
2056    
2057     actions Cc
2058     {
2059     $(CC) $(CCFLAGS) $(OPTIM) -Fo$(<) -I$(HDRS) $(>)
2060     }
2061    
2062     actions Link bind NEEDLIBS
2063     {
2064     $(LINK) $(LINKFLAGS) -o $(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
2065     }
2066    
2067     actions Shell
2068     {
2069     $(CP) $(>) $(<)
2070     }
2071     }
2072     }
2073    
2074     #
2075     # OS2 specific actions
2076     #
2077    
2078     else if $(OS2)
2079     {
2080     if $(TOOLSET) = WATCOM
2081     {
2082     actions together piecemeal Archive
2083     {
2084     $(AR) $(<) +-$(>)
2085     }
2086    
2087     actions Cc
2088     {
2089     $(CC) $(CCFLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
2090     }
2091    
2092     actions C++
2093     {
2094     $(C++) $(C++FLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
2095     }
2096    
2097     actions Link bind NEEDLIBS
2098     {
2099     $(LINK) $(LINKFLAGS) /Fe=$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
2100     }
2101    
2102     actions Shell
2103     {
2104     $(CP) $(>) $(<)
2105     }
2106     }
2107     else if $(TOOLSET) = EMX
2108     {
2109     actions together piecemeal Archive
2110     {
2111     $(AR) $(<) $(>:T)
2112     }
2113    
2114     actions Cc
2115     {
2116     $(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
2117     }
2118    
2119     actions C++
2120     {
2121     $(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
2122     }
2123     }
2124     }
2125    
2126     #
2127     # VMS specific actions
2128     #
2129    
2130     else if $(VMS)
2131     {
2132     actions updated together piecemeal Archive
2133     {
2134     lib/replace $(<) $(>[1]) ,$(>[2-])
2135     }
2136    
2137     actions Cc
2138     {
2139     $(CC)/obj=$(<) $(CCFLAGS) $(OPTIM) $(SLASHINC) $(>)
2140     }
2141    
2142     actions C++
2143     {
2144     $(C++)/obj=$(<) $(C++FLAGS) $(OPTIM) $(SLASHINC) $(>)
2145     }
2146    
2147     actions piecemeal together existing Clean
2148     {
2149     $(RM) $(>[1]);* ,$(>[2-]);*
2150     }
2151    
2152     actions together quietly CreLib
2153     {
2154     if f$search("$(<)") .eqs. "" then lib/create $(<)
2155     }
2156    
2157     actions GenFile1
2158     {
2159     mcr $(>[1]) $(<) $(>[2-])
2160     }
2161    
2162     actions Link bind NEEDLIBS
2163     {
2164     $(LINK)/exe=$(<) $(LINKFLAGS) $(>[1]) ,$(>[2-]) ,$(NEEDLIBS)/lib ,$(LINKLIBS)
2165     }
2166    
2167     actions quietly updated piecemeal together RmTemps
2168     {
2169     $(RM) $(>[1]);* ,$(>[2-]);*
2170     }
2171    
2172     actions Shell
2173     {
2174     $(CP) $(>) $(<)
2175     }
2176     }
2177    
2178     #
2179     # Mac specific actions
2180     #
2181    
2182     else if $(MAC)
2183     {
2184     actions together Archive
2185     {
2186     $(LINK) -library -o $(<) $(>)
2187     }
2188    
2189     actions Cc
2190     {
2191     set -e MWCincludes $(MACINC)
2192     $(CC) -o $(<) $(CCFLAGS) $(OPTIM) $(>)
2193     }
2194    
2195     actions C++
2196     {
2197     set -e MWCincludes $(MACINC)
2198     $(CC) -o $(<) $(C++FLAGS) $(OPTIM) $(>)
2199     }
2200    
2201     actions Link bind NEEDLIBS
2202     {
2203     $(LINK) -o $(<) $(LINKFLAGS) $(>) $(NEEDLIBS) "$(LINKLIBS)"
2204     }
2205     }
2206    
2207     #
2208     # Backwards compatibility with jam 1, where rules were uppercased.
2209     #
2210    
2211     rule BULK { Bulk $(<) : $(>) ; }
2212     rule FILE { File $(<) : $(>) ; }
2213     rule HDRRULE { HdrRule $(<) : $(>) ; }
2214     rule INSTALL { Install $(<) : $(>) ; }
2215     rule LIBRARY { Library $(<) : $(>) ; }
2216     rule LIBS { LinkLibraries $(<) : $(>) ; }
2217     rule LINK { Link $(<) : $(>) ; }
2218     rule MAIN { Main $(<) : $(>) ; }
2219     rule SETUID { Setuid $(<) ; }
2220     rule SHELL { Shell $(<) : $(>) ; }
2221     rule UNDEFINES { Undefines $(<) : $(>) ; }
2222    
2223     # Old INSTALL* didn't take dest directory.
2224    
2225     rule INSTALLBIN { InstallBin $(BINDIR) : $(<) ; }
2226     rule INSTALLLIB { InstallLib $(LIBDIR) : $(<) ; }
2227     rule INSTALLMAN { InstallMan $(MANDIR) : $(<) ; }
2228    
2229     # Compatibility with jam 2.2.
2230    
2231     rule addDirName { $(<) += [ FDirName $(>) ] ; }
2232     rule makeDirName { $(<) = [ FDirName $(>) ] ; }
2233     rule makeGristedName { $(<) = [ FGristSourceFiles $(>) ] ; }
2234     rule makeRelPath { $(<[1]) = [ FRelPath $(<[2-]) : $(>) ] ; }
2235     rule makeSuffixed { $(<[1]) = [ FAppendSuffix $(>) : $(<[2]) ] ; }
2236    
2237     #
2238     # Now include the user's Jamfile.
2239     #
2240    
2241     {
2242     if $(JAMFILE) { include $(JAMFILE) ; }
2243     }

john.pye@anu.edu.au
ViewVC Help
Powered by ViewVC 1.1.22