# BhbJambase
# Copyright (c) 2001 MBruce, all rights reserved
# $Id: //guest/matt_bruce/sampleProject/BhbJambase#1 $
# This is the basic Jambase for use in your projects.
################################################################################
# Note: This is an architectural difference between "jam" from perforce and #
# this highly modified version of "jam". This version of "jam" will only #
# know how to do very few things in it's Jambase. Everything else in included #
# at runtime from this file. #
# #
################################################################################
# -----------
# Local stuff.
# -----------
include $(TOP)$(SLASH)Jamvars ;
# ----------------
# Basic Common variables
# ----------------
# Customize for your project
BHBVERSION = "10" ;
# TOP refers to the top of the source tree - in our case this is the
# branch directory (e.g. ~/dev/bhb10).
HDRS = $(TOP)$(SLASH)inc ; # Where our standard headers are.
LIBPATH = $(TOP)$(SLASH)lib ; # Where our libraries go.
BINPATH = $(TOP)$(SLASH)bin ; # Where our executables go.
# we keep 3rdparty libs elsewhere
CFLIBDIR = $(CF) ;
if $(CF) = rbug
{
CFLIBDIR = release ;
}
3RDPARTYLIB =
$(TOP)$(SLASH)3rdparty$(SLASH)lib
$(TOP)$(SLASH)3rdparty$(SLASH)lib$(SLASH)$(CFLIBDIR)
;
# Where the base of the java tree is, in grist and dirs:
JAVAGRIST = <java> ;
JAVAROOT = $(TOP:R=$(PWD))$(SLASH)java ;
JAVA3RDPARTYROOT = $(TOP:R=$(PWD))$(SLASH)3rdparty$(SLASH)java ;
# Java classpath
CLASSPATH = $(JAVA3RDPARTYROOT) ;
# Variable Meaning
# -------- -------
# ARCH Letters to append to lib/exe names to indicate configuration.
# ARCHDIR Subdirectory where intermediate files go.
# DEBUGGING Are we debugging at all?
ARCHDIR = $(CF) ;
# ------------------------------------------
# Environmental configuration settings
# These must come before the "if $(NT)" and "if $(UNIX)" sections.
# ------------------------------------------
if ! $(TOP)
{
ECHO We depend on TOP being the name of the top directory ;
EXIT As in SubDir TOP foo bar ";" ;
}
if ! $(CF) || ( $(CF) != debug && $(CF) != release && $(CF) != rbug )
{
ECHO Please define a configuration (ie: if you are building debug or release) ;
ECHO The possible configurations are debug and release. ;
EXIT The configuration needs to be set in the environment variable 'CF'. ;
}
if ! $(TEMP)
{
ECHO Please set the environment variable "TEMP" to somewhere safe. ;
ECHO DO NOT set it to /tmp unless you are the only one who uses this machine. ;
EXIT TYPE: export TEMP=$(HOME)/tmp; mkdir $(HOME)/tmp ;
}
# uncomment this if you need object store persistable classes
# if ! $(OSJI_HOME)
# {
# ECHO Please set OSJI_HOME to the root path of ObjectStore. ;
# EXIT You can probably do this by running /opt/release/bhb/bin ;
# }
if $(FAST)
{
ECHO Fast build specified; skipping header dependency analysis. ;
ECHO C and C++ only ;
}
if $(PROFILE)
{
LINKPROFILE = $(PROFILE) ;
}
if $(LINKPROFILE)
{
ECHO Profiling is enabled. ;
ECHO Windows NT only at the moment. ;
}
if $(CF) = rbug
{
ECHO Generating debug info in release mode! ;
# more crappy trunkated debug info in this mode...
ALLOWWARN = true ;
ECHO Windows NT only. This stuff works on UNIX. ;
}
if $(MAPFILE)
{
ECHO Generating Mapfile. ;
ECHO Windows NT only at the moment. ;
}
# Unit testing is enabled by default...
if $(NOUNITTEST)
{
ECHO Unit testing disabled. ;
}
if $(VERBOSELINK)
{
ECHO Verbose link. ;
}
if $(ALLOWWARN)
{
ECHO Allowing warnings... beware ;
}
if $(UPDATEINSTALLEXE) && ! $(DEBUGGING)
{
if $(INSTALL_DIR)
{
ECHO Updating the executables in the bhbInstall directory. ;
DEPENDS all : install ;
}
else
{
ECHO Update your $(INSTALL_DIR) ;
}
}
if $(NOLINK)
{
ECHO Not linking... ;
}
if ! $(BHBJAM)
{
EXIT This Bhbrules needs to be run with bhbjam ;
}
if $(BROWSE)
{
ECHO Building file-by-file browse info. ;
ECHO To build the .bsc file run \"jam browse\". ;
}
# ------------------------------------------
# Start decision making.
# ------------------------------------------
switch $(CF)
{
case debug :
DEBUGGING = true ;
ARCH = g ;
case release :
DEBUGGING = ;
ARCH = r ;
case rbug :
DEBUGGING = true ;
ARCH = ag ;
}
if $(DEBUGGING)
{
JAVAFLAGS = -g ;
}
else
{
JAVAFLAGS = -O ;
}
LCURLY = "{" ;
RCURLY = "}" ;
if $(UNIX)
{
LINKEXECUTABLE += -lstdc++ ;
LINKDLL = $(LINKEXECUTABLE) ;
LINKMAIN = $(LINKEXECUTABLE) ;
LINKAPPLICATION = $(LINKEXECUTABLE) ;
LINKLIBRARY = ;
SPLITPATH = ":" ;
JAMSHELL = "/bin/ksh" ;
}
if $(NT)
{
SPLITPATH = ";" ;
# /Zi = Generate debug info in a pdb file (used for exes).
# /Od = Disable optimizations.
# /GZ = Enable runtime stack checks.
OPTIMDEBUG = -D"_DEBUG" /Zi /Od /GZ ;
# Inlining:
# /Ob0 = Disabled.
# /Ob1 = Only when specified with 'inline'. (/Ob1 also enables the Force.)
# /Ob2 = Any suitable function.
# Optimization:
# /O2 = optimize for speed
OPTIMRELEASE = -D"NDEBUG" -D"BHB_RELEASE_ASSERT" /Ob1 /O2 ;
switch $(CF)
{
case debug :
OBJECTPDBFILE = $(LIBPATH)$(SLASH)objects$(ARCH).pdb ;
DEBUGLINKFLAGS = /debug /incremental:yes ;
OPTIM = $(OPTIMDEBUG) ;
case release :
DEBUGLINKFLAGS = ;
OPTIM = $(OPTIMRELEASE) ;
case rbug :
OPTIMRELEASE += /Zi ;
OPTIMDEBUG = $(OPTIMRELEASE) ;
OBJECTPDBFILE = $(LIBPATH)$(SLASH)objects$(ARCH).pdb ;
DEBUGLINKFLAGS = /debug ;
OPTIM = $(OPTIMDEBUG) ;
}
# Unit testing is on unless explicitly turned off.
if $(NOUNITTEST)
{
UNITTESTFLAGS = ;
}
else
{
UNITTESTFLAGS = /D"_UNITTEST" ;
}
switch $(CF)
{
case debug :
# Link with MSVCRTD.LIB (meaning AFXDLL),
# Link with stingray as dlls
CFCFLAGS default =
/MDd /D"_AFXDLL"
/D_CMNDLL /D_SECDLL /D_GXDLL
/D_BHB_CF_DEBUG
;
case release :
# Link with MSVCRT.LIB (meaning AFXDLL),
# Link with stingray as dlls
CFCFLAGS default =
/MD /D"_AFXDLL"
/D_CMNDLL /D_SECDLL /D_GXDLL
/D_BHB_CF_RELEASE
;
case rbug :
# Link with MSVCRT.LIB (meaning AFXDLL),
# Link with stingray as dlls
CFCFLAGS default =
/MD /D"_AFXDLL"
/D_CMNDLL /D_SECDLL /D_GXDLL
/D_BHB_CF_RELEASE
;
}
# Standard Link flags
# flags for any EXE (dll, main, app)
LINKEXECUTABLE =
/nologo
$(DEBUGLINKFLAGS)
/machine:I386
;
if $(LINKPROFILE)
{
LINKEXECUTABLE += /profile ;
}
if $(MAPFILE)
{
LINKEXECUTABLE += /map /mapinfo:lines ;
}
if $(VERBOSELINK)
{
LINKEXECUTABLE += /verbose ;
}
LINKDLL = /dll $(LINKEXECUTABLE) ;
LINKMAIN = /subsystem:console $(LINKEXECUTABLE) ;
LINKAPPLICATION = /subsystem:windows $(LINKEXECUTABLE) ;
LINKLIBRARY = /lib /nologo ;
if $(ALLOWWARN)
{
NOWARNINGS = ;
}
else
{
NOWARNINGS = /WX ; # Warnings are errors
}
STANDARDCFLAGS =
/nologo
/Zp8 # 8-byte struct alignment.
/W3 # Warning level 3.
/GX # Enable C++ exception handling.
/GR # Enable RTTI
$(NOWARNINGS)
/D"NOMINMAX"
/D"WIN32"
/D"_WINDOWS"
/D"_MBCS"
/D_SECNOMSG
$(UNITTESTFLAGS)
"/I$(TOP:R=$(PWD))/3rdparty/inc"
"/I$(TOP:R=$(PWD))/3rdparty/inc/stingray"
"/I$(TOP:R=$(PWD))/3rdparty/inc/versant"
/D"_WIN32_IE=0x0400" # Ensures compatibility with comctl32.dll & shell32.dll v4.71 and later
/c # Compile only (no link).
/D"_GXNOMSG" # No MSG please! (Objective Grid pragma messages, that is)
/DODBCXXX_DLL # We're using odbc++.dll
$(CFCFLAGS)
;
}
# ----------------------------
# End Basic Configuration
# ----------------------------
# You probably don't need to mess with anything below this point.
# ----------------
# Base dependencies
# ----------------
DEPENDS all : shell lib exe obj java jar ;
DEPENDS all shell files lib exe obj java : first ;
DEPENDS veryclean : clean ;
NOTFILE all first shell files lib exe obj dirs clean uninstall java veryclean ;
NOTFILE
all first shell files lib exe obj dirs clean uninstall java veryclean jar ;
ALWAYS veryclean clean uninstall ;
# Not yet installed grist (to distinguish from the installed file
PREINSTALL = <preinstall> ;
# Allow a space or tab befor the '#include' when searching
# for headers.
HDRPATTERN = "^[ ]*#[ ]*include[ ]*[<\"](.*)[\">].*$" ;
# Names of standard Jam files
JAMFILE default = Jamfile ;
JAMRULES default = Bhbrules ;
# since we're using sh for NT, these are general
AWK default = awk ;
CHMOD default = chmod ;
CP default = cp ;
DOT default = . ;
DOTDOT default = .. ;
EXEMODE default = 711 ;
FILEMODE default = 644 ;
MKDIR default = mkdir -p ;
MV default = mv -f ;
RCP default = rcp ;
RSH default = rsh ;
RM default = rm -rf ;
SED default = sed ;
SLASH default = / ;
# ---------------------------
# Platform-specific variables
# ---------------------------
# Variables such as NT were set when we built jam itself.
# Variable Meaning
# -------- -------
# CFCFLAGS Configuration-specific compiler flags (NT only).
# PRELIB Prefix for library names.
# PREDLL Prefix for dll names.
# SUFDLL Suffix for dll names.
# SUFRES Suffix for compiled resources.
if $(UNIX)
{
PRELIB default = lib ;
PREDLL default = lib ;
SUFDLL default = .so ;
SUFLIB default = .a ;
SUFOBJ default = .o ;
SUFEXE default = "" ;
SUFRES default = .res ;
AR default = ar ru ;
AS default = as ;
CC default = gcc ;
C++ default = $(CC) ;
LINK default = $(CC) ;
if $(OS) = SOLARIS
{
# Solaris build are currently working. Allow this.
}
else if $(OS) = LINUX
{
EXIT Linux build isn't ready yet. ;
}
else
{
EXIT What unix are you building on? ;
}
}
else if $(NT)
{
OS = NT ; # replace Windows_NT
PRELIB default = "" ;
PREDLL default = $(PRELIB) ;
SUFDLL default = .dll ;
SUFLIB default = .lib ;
SUFOBJ default = .obj ;
SUFEXE default = .exe ;
SUFRES default = .res ;
AR default = link /nologo ;
AS default = masm386 ;
CC default = cl /nologo ;
C++ default = $(CC) ;
LINK default = link ;
RC = rc ; # Resource compiler.
AR = lib -nologo ; # Archive command.
}
else
{
EXIT We don't support this platform. ;
}
# -------------------
# BhbJam' Markup
# -------------------
# Markup an exe, lib or dll with our weird markup scheme. E.g.
#
# MakeName targ : BhbJam : exe : locate ;
# targ -> "BhbJam84lg.exe" in $(TOP)/bin
#
# MakeName targ : og : dll : nomarkup ;
#
# targ -> "og.dll" wherever it's already supposed to be
#
# etc.
rule MakeName
{
local _f_result = $(1) ;
local _f_target = $(2) ;
local _f_type = $(3) ;
local _f_flags = $(4) ;
if ! $($(_f_result))
{
local _f_path, _f_cfMark, _f_versionMark, _f_suffix, _f_prefix;
local _f_locate = ;
local _f_depend = ;
local _f_grist = ;
local _f_search = ;
_f_suffix = "" ;
_f_prefix = "" ;
_f_cfMark = $(ARCH) ;
_f_versionMark = $(BHBVERSION) ;
switch $(_f_type)
{
case exe :
_f_path = $(BINPATH) ;
_f_suffix = $(SUFEXE) ;
# if $(CF) = release { _f_flags += nomarkup ; }
case dll :
_f_path = $(LIBPATH) ;
_f_suffix = $(SUFDLL) ;
_f_prefix = $(PREDLL) ;
case lib :
_f_path = $(LIBPATH) ;
_f_suffix = $(SUFLIB) ;
_f_search = true ;
case obj :
_f_grist = true ;
_f_path = $(LOCATE_TARGET) ;
_f_suffix = $(SUFOBJ) ;
_f_flags += nomarkup ;
case pch :
_f_grist = true ;
_f_path = $(LOCATE_TARGET) ;
_f_suffix = $(SUFPCH) ;
_f_flags += nomarkup ;
case res :
_f_grist = true ;
_f_path = $(LOCATE_TARGET) ;
_f_suffix = $(SUFRES) ;
_f_flags += nomarkup ;
case jar :
_f_path = $(JAVAROOT) ;
_f_suffix = ".jar" ;
_f_flags += nomarkup ;
case * :
_f_suffix = "."$(_f_type) ;
_f_flags += nomarkup ;
_f_path = $(LOCATE_TARGET) ;
_f_grist = true ;
_f_path = $(SUBDIR) ;
_f_locate = true ;
}
for _f in $(_f_flags)
{
switch $(_f)
{
case 3rdparty :
_f_path = $(3RDPARTYLIB) ;
_f_versionMark = "" ;
_f_cfMark = "" ;
case nomarkup :
_f_versionMark = "" ;
_f_cfMark = "" ;
case locate :
_f_locate = true ;
case depend :
_f_depend = true ;
case declare :
_f_locate = true ;
_f_depend = true ;
}
}
local _f_base = $(_f_prefix)$(_f_target)$(_f_versionMark)$(_f_cfMark) ;
local _f_name ;
if $(_f_grist)
{
makeGristedName _f_name : $(_f_base:S=$(_f_suffix)) ;
}
else
{
_f_name = $(_f_base:S=$(_f_suffix)) ;
}
if $(_f_locate)
{
MakeLocate $(_f_name) : $(_f_path) ;
}
else if $(_f_search)
{
SEARCH on $(_f_name) = $(_f_path) ;
}
if $(_f_depend)
{
NOTFILE $(_f_target) ;
DEPENDS $(_f_target) : $(_f_name) ;
}
$(_f_result) = $(_f_name) ;
}
}
# Append to a flag for some stage of the compilation process. e.g.:
#
# SetFlag foo.c : obj : CCFLAGS : -Dfoo ;
#
# SetFlag bozo : dll : LINKFLAGS : -R /usr/local/lib ;
#
rule SetFlag
{
local s t ;
# flags for anylib are both lib & dll
if $(2) = anylib
{
MakeName s : $(1) : dll ;
MakeName t : $(2) : lib ;
s += t ;
}
else
{
MakeName s : $(1) : $(2) ;
}
$(3) on $(s) += $(4) ;
}
# ------------------
# Global rules
# ------------------
# Build an application, e.g. BhbJam:
#
# Application myFancyProgram : sourcefile.cpp fancyprog.cpp ;
rule Application
{
MainFromObjects $(<) : $(>) : app ;
Objects $(>) ;
}
# BuildPch pchfile : cppfileusedtobuild : headerupto ;
# e.g.
# BuildPch bhbafx.pch : bhbafx.cpp : bhbafx.h ;
# or
# BuildPch cellsafx.pch : cellsafx.cpp : stdafx.h ;
#
# the third paramater is optional, but otherwise you need that
# hdrstop pragma. You should use a cppfile tailored to this purpose;
# the pchfile will depend on anything it depends on.
rule BuildPch
{
if $(NT)
{
local o p h ;
makeGristedName s : $(>) ;
makeGristedName o : $(>:S=$(SUFOBJ)) ;
makeGristedName p : $(<:S=.pch) ;
MakeLocate $(p) : $(LOCATE_TARGET) ;
BuiltByBuildOf $(p) : $(o) ;
if $(3)
{
endh = $(3) ;
}
else
{
endh = "" ;
}
# /Yc = create precompiled header up to endheader
C++FLAGS on $(o) = /Yc$(endh) ;
CCFLAGS on $(o) = /Yc$(endh) ;
PCHFILE on $(o) = $(p) ;
$(o)-builds-$(p) = true ;
}
}
# This is done on a file-for-file basis at the moment, since it's not
# normally safe to use it for all files in the dir.
# Syntax :
# UsePch file : pchfile : endhdr ;
# endhdr is optional, but requires #pragma hdrstop
rule UsePch
{
if $(NT)
{
local o ;
local p ;
makeGristedName o : $(<:S=$(SUFOBJ)) ;
makeGristedName p : $(>:S=.pch) ;
if $(3)
{
endh = $(3) ;
}
else
{
endh = "" ;
}
for i in $(o)
{
if ! $($(i)-builds-$(p))
{
DEPENDS $(i) : $(p) ;
# /Yu = use pch
C++FLAGS on $(i) += /Yu$(endh) ;
CCFLAGS on $(i) += /Yu$(endh) ;
PCHFILE on $(i) = $(p) ;
}
}
}
}
# Syntax:
# SubDirUsePch pchfile : endhdr ;
# Uses the pch file for all C and C++ files in the directory
rule SubDirUsePch
{
SUBDIR_PCH_FILE = $(<) ;
SUBDIR_PCH_END = $(>) ;
}
# Build a browse info file (.bsc) from the sbrs.
#
# We will build the .sbr files if $(BROWSE) is set.
rule BrowseInfo
{
NOTFILE browse ;
DEPENDS browse : $(<) ;
ALWAYS $(<) ;
Clean clean : $(<) ;
Clean clean : $(TOP)$(SLASH)browse ;
}
# Tells jam that $(<) was built when we built $(>)
rule BuiltByBuildOf
{
DEPENDS $(<) : $(>) ;
}
rule Cc
{
DEPENDS $(<) : $(>) ;
CCFLAGS on $(<) += $(STANDARDCFLAGS) $(CCFLAGS) $(SUBDIRCCFLAGS) ;
CcCommonFlags $(<) : $(>) ;
}
rule C++
{
DEPENDS $(<) : $(>) ;
C++FLAGS on $(<) += $(STANDARDCFLAGS) $(C++FLAGS) $(SUBDIRC++FLAGS) ;
CcCommonFlags $(<) : $(>) ;
}
rule CcCommonFlags
{
if $(NT)
{
# precompiled headers
if $(SUBDIR_PCH_FILE)
{
UsePch $(<) : $(SUBDIR_PCH_FILE) : $(SUBDIR_PCH_END) ;
}
if $(DEBUGGING)
{
# all .obj's share a .pdb file -- this is much cleaner and
# faster than the alternatives. The debugging info will
# get copied from this .pdb file to the pdb file of the exe's
# by the linker.
PDBFILE on $(<) = $(OBJECTPDBFILE) ;
DEPENDS $(<) : $(OBJECTPDBFILE:D) ;
MkDir $(OBJECTPDBFILE:D) ;
Clean veryclean : $(OBJECTPDBFILE) ;
}
if $(BROWSE) && $(DEBUGGING)
{
# build browse info for Visual C++
C++FLAGS on $(<) += /FR$(TOP)$(SLASH)browse$(SLASH) ;
CCFLAGS on $(<) += /FR$(TOP)$(SLASH)browse$(SLASH) ;
DEPENDS $(<) : $(TOP)$(SLASH)browse ;
MkDir $(TOP)$(SLASH)browse ;
}
}
}
# Add entry(ies) to the classpath
rule ClassPath
{
local path ;
for path in $(<)
{
if $(NT)
{
CLASSPATH = $(CLASSPATH)";"$(path:R=$(PWD)) ;
}
else
{
CLASSPATH = $(CLASSPATH)":"$(path:R=$(PWD)) ;
}
}
}
# Clean files from a pattern. This can be useful if you
# don't quite know what silly files got created.
# e.g.
# CleanMany clean : *.class ;
rule CleanMany
{
DEPENDS $(<) : $(>) ;
NOTFILE $(>) ;
}
# compile the versant .imp file to an .obj by way of schcomp
rule DBSchemaCompile
{
local _schema _cxx ;
makeGristedName _schema : $(>:S=.sch) ;
makeGristedName _cxx : $(>:S=.cxx) ;
MakeLocate $(_cxx) : $(LOCATE_TARGET) ;
SchComp $(_schema) $(_cxx) : $(>) ;
Objects $(_cxx) ;
}
# Build the .sch and the .cxx from the versant Schema .imp file
# must call with $(schemaName) $(cxxName) as targets in that order!
rule SchComp
{
C++FLAGS on $(<) += $(SUBDIRC++FLAGS) $(C++FLAGS) $(STANDARDCFLAGS) ;
LOCATE_TARGET on $(<) = $(LOCATE_TARGET) ;
LOCATE on $(<) = $(LOCATE_TARGET) ;
CcCommonFlags $(<) : $(>) ;
HDRS on $(<) = $(HDRS) $(SUBDIRHDRS) ;
if ! $(FAST)
{
HDRRULE on $(>) = HdrRule ;
HDRSCAN on $(>) = $(HDRPATTERN) ;
HDRSEARCH on $(>) = $(HDRS) $(SUBDIRHDRS) $(STDHDRS) ;
HDRGRIST on $(>) = $(HDRGRIST) ;
}
SEARCH on $(>) = $(SEARCH_SOURCE) ;
NOTFILE schema ;
DEPENDS schema : $(<) ;
DEPENDS $(<) : $(>) ;
Clean clean : $(<) ;
}
# This is used for a define that should be set up if you're compling
# the file as a DLL. Usually this is guarding some kind of dllexport/
# dllimport define.
# e.g.
# DefineForDLL _INV_FTL_INTERNAL ;
rule DefineForDLL
{
SUBDIRC++FLAGS += "-D"$(<) ;
SUBDIRCCFLAGS += "-D"$(<) ;
}
# Use the export library from an executable (and copy it to the lib dir.)
rule ExportLibrary
{
if $(NT) && ! $(NOLINK)
{
local exeName libName ;
MakeName exeName : $(<) : exe ;
MakeName libName : $(<) : lib : locate ;
DEPENDS lib : $(libName) ;
local libWithExe = $(exeName:G=$(PREINSTALL):S=$(SUFLIB)) ;
BuiltByBuildOf $(libWithExe) : $(exeName) ;
LOCATE on $(libWithExe) = $(BINPATH) ;
File $(libName) : $(libWithExe) ;
NOPROPAGATE $(libName) ;
Clean clean : $(libName) ;
}
}
# Define some preprocessor macro for compliation
rule Define
{
SubDirC++Flags -D$(<) ;
SubDirCcFlags -D$(<) ;
}
# Copy a file.
rule File
{
DEPENDS files : $(<) ;
DEPENDS $(<) : $(>) ;
SEARCH on $(>) = $(SEARCH_SOURCE) ;
}
# Files a1 b1 c1 : a b c ;
#
# copies a to a1, b to b1, etc.
rule Files
{
if $(<) && $(>)
{
RmFile $(<[1]) ;
File $(<[1]) : $(>[1]) ;
if $(<[2-]) && $(>[2-])
{
Files $(<[2-]) : $(>[2-]) ;
}
}
}
rule HdrRule
{
# HdrRule source : headers : boundNameOfSource ;
# N.B. This rule is called during binding, potentially after
# the fate of many targets has been determined, and must be
# used with caution: don't add dependencies to unrelated
# targets, and don't set variables on $(<).
# Tell Jam that anything depending on $(<) also depends on $(>),
# set SEARCH so Jam can find the headers, but then say we don't
# care if we can't actually find the headers (they may have been
# within ifdefs),
local s ;
if $(HDRGRIST)
{
s = $(>:G=$(HDRGRIST)) ;
} else {
s = $(>) ;
}
# we can use the boundNameOfSource to add the current directory
# of the source into the search so #includes with quotes can search
# there (the standard on NT).
local headerDir = $(3:D) ;
INCLUDES $(<) : $(s) ;
SEARCH on $(s) = $(headerDir) $(HDRSEARCH) ;
NOCARE $(s) ;
# Propagate on $(<) to $(>)
HDRSEARCH on $(s) = $(HDRSEARCH) ;
HDRSCAN on $(s) = $(HDRSCAN) ;
HDRRULE on $(s) = $(HDRRULE) ;
HDRGRIST on $(s) = $(HDRGRIST) ;
}
# install everything... The syntax looks like
#
# InstallTarget from : ToDir : ToName ;
#
# This is really a utility rule for Install
rule InstallTarget
{
local installTarget ;
if $(3)
{
installTarget = $(3:G="<install>") ;
}
else
{
installTarget = $(<:G="<install>") ;
}
MakeLocate $(installTarget) : $(>:R=$(INSTALL_DIR)) ;
Files $(installTarget) : $(<) ;
DEPENDS install : $(installTarget) ;
}
# Install a decorated name. For example
#
# Install BhbJam : exe : bin ;
# installs BhbJam84lg.exe (or whatever) into $(INSTALL_DIR)/bin
# Install BhbJam : lib : sdk : sdk.lib ;
# installs BhbJam84lg.lib (from $(TOP)/lib) into $(INSTALL_DIR)/sdk/sdk.lib
# Install fdkfuncs.h : installFile : sdk ;
# isntalls fdkfuncs.h into $(INSTALL_DIR)/sdk
rule Install
{
local file ;
if $(2) = installFile
{
makeGristedName file : $(1) ;
SEARCH on $(file) = $(SEARCH_SOURCE) ;
}
else
{
MakeName file : $(1) : $(2) ;
}
InstallTarget $(file) : $(3) : $(4) ;
}
# Compiling the package all-in-one, by making a new class that merely
# includes all of the classes in the package. The point is to reduce
# the number of costly calls to javac, and to avoid having jam deal
# with dependencies
rule JavaPackage
{
local s ;
makeGristedName s : $(>) ;
LOCATE on $(s) = $(SUBDIR) ;
local jp jc ;
makeGristedName jp : JamPackage.java ;
jc = $(jp:S=.class) ;
LOCATE on $(jp) $(jc) = $(SUBDIR) ;
local pkj ;
if $(<) != ""
{
pkj = $(<).JamPackage ;
}
else
{
pkj = JamPackage ;
}
PACKAGENAME on $(jp) = $(pkj) ;
JamPackage $(jp) : $(>:S="") ;
INCLUDES $(jp) : $(s) ;
DEPENDS $(jp) : $(SUBDIR)$(SLASH)Jamfile ;
DEPENDS $(jp) : $(SUBDIR)$(SLASH)$(>) ;
RootJamPackage $(jp) : $(pkj) ;
Clean clean : $(jc) $(jp) ;
CleanMany clean : $(SUBDIR)$(SLASH)*.class ;
}
# build the JamPackage.java file
rule JamPackage
{
NOTFILE $(>) ;
}
# build the RootJamPackage.java file (only once) and compile it.
rule RootJamPackage
{
local rjp = $(JAVAGRIST)RootJamPackage.java ;
local rjc = $(rjp:S=.class) ;
LOCATE on $(rjp) $(rjc) = $(JAVAROOT) ;
PACKAGENAME on $(rjp) = RootJamPackage ;
INCLUDES $(rjp) : $(<) ;
DEPENDS $(rjp) : $(<) ;
JamPackage $(rjp) : $(>) ;
Clean clean : $(rjp) $(rjc) ;
if ! $(root-jam-package-initted)
{
root-jam-package-initted = true ;
JavaC $(rjc) : $(rjp) ;
SUBDIR on $(rjc) = $(JAVAROOT) ;
}
}
# compile a java file.
rule JavaC
{
DEPENDS $(<) : $(>) ;
DEPENDS java : $(<) ;
# ensure that RootJamPackage is built every time any java
# file needs to be built. This does two things - 1. get around
# a bug in 1.2.2's javac 2. creates minimal builds from subdirs
DEPENDS RootJamPackage : java ;
}
# build a jar file from various packages.
# $(2) is from packages that we build
# $(3) is third party packages.
# includes subpackages in package
#
# so, this looks like:
# Jar poserver :
# com.mbruce.poserver
# com.mbruce.util
# com.mbruce.db
# :
# com.javtech.coppelia
# org.xml.sax
# ;
#
# optional 4th argument is patterns for files to include.
# default:
# *.class *.properties
rule Jar
{
local jarFile ;
MakeName jarFile : $(<) : jar : declare ;
DEPENDS $(jarFile) : java ;
NOTFILE $(2) $(3) ;
DEPENDS jar : $(<) ;
if $(3)
{
JAR3RDPARTY on $(<) = $(3) ;
JARHAS3RDPARTY on $(<) = true ;
}
else
{
JAR3RDPARTY on $(<) = foo ;
JARHAS3RDPARTY on $(<) = false ;
}
if $(4)
{
# -type b == type block-special -- effectively -false
# for the null condition at the end of the ors
# so it looks like : -name "*.class" -type b -- effectively
# -name "*.class"
JARPATTERNS on $(<) = -type f | egrep '$(4)' ;
}
else
{
JARPATTERNS on $(<) = -type f | egrep '.*(class|properties|fmt)$' | grep -v JamPackage.class ;
}
Clean clean : $(jarFile) ;
}
# much like Jar, but runs the persistable object store stuff on
# the classes first
rule JarPersistable
{
local jarFile ;
MakeName jarFile : $(<) : jar : declare ;
DEPENDS $(jarFile) : java ;
NOTFILE $(2) $(3) ;
DEPENDS jar : $(<) ;
if $(3)
{
JAR3RDPARTY on $(<) = $(3) ;
JARHAS3RDPARTY on $(<) = true ;
}
else
{
JAR3RDPARTY on $(<) = foo ;
JARHAS3RDPARTY on $(<) = false ;
}
if $(4)
{
# -type b == type block-special -- effectively -false
# for the null condition at the end of the ors
# so it looks like : -name "*.class" -type b -- effectively
# -name "*.class"
JARPATTERNS on $(<) = -type f | egrep '$(4)' ;
}
else
{
JARPATTERNS on $(<) = -type f | egrep '.*(class)$' | grep -v JamPackage.class ;
}
Clean clean : $(jarFile) ;
}
# like jar, but obfuscates.
#
# Jode pricing :
# pricing.jos
# :
# *.properties resources/*
# ;
#
# i.e. obfuscate with file pricing.jos as a spec. After obfuscation
# include anything that matches the find pattern.
rule Jode
{
local jarFile ;
MakeName jarFile : $(<) : jar : declare ;
DEPENDS $(jarFile) : java ;
DEPENDS jar : $(<) ;
MakeLocate $(>) : $(JAVAROOT) ;
DEPENDS $(jarFile) : $(>) ;
if $(3)
{
JARHASEXTRAS on $(<) = true ;
JAREXTRAS on $(<) = -name" "\"$(3)\"" "-o -type b ;
}
Clean clean : $(jarFile) $(jarFile:S=".tbl") ;
}
#
# like jar but makes tar files:
#
# Tar wpserver :
# apacheBhbJam
# :
# apache*s.dll
# ftl*s.dll
# ;
#
rule Tar
{
local tarFile ;
MakeName tarFile : $(<) : tar.gz : declare ;
DEPENDS $(tarFile) : $(2) ;
NOTFILE $(2) ;
TARPATTERNS on $(<) = -name" "\"$(3)\"" "-o -type b ;
Clean clean : $(tarFile) ;
}
# Build a standard BhbJam library (a dll on nt)
# Syntax is like application
# Library mfctool : regkey.cpp font.cpp ... ;
rule Library
{
LibraryOfType $(<) : $(>) : dll ;
}
# A library that's always static.
rule StaticLibrary
{
LibraryOfType $(<) : $(>) : lib ;
}
# A library that's always a dll
rule DynamicLibrary
{
LibraryOfType $(<) : $(>) : dll ;
}
# A library that might be a DLL or a static lib. If it's a DLL, then
# the export symbols should be defined by a def file that's generated
# from the objects. (Sparing the code writer some __declspec(dllexport)
# nonsense). Note that static variables cannot be exported in this
# fashion.
rule DefLibrary
{
DefDynamicLibrary $(<) : $(>) ;
}
# a library that's a dll and always uses a generated .def file
rule DefDynamicLibrary
{
if $(NT)
{
local libName dllName ;
MakeName libName : $(<) : lib ;
MakeName dllName : $(<) : dll ;
local def ;
makeGristedName def : $(<:S=.def) ;
MakeLocate $(def) : $(LOCATE_TARGET) ;
DefFile $(def) : $(>) ;
DEFFILE on $(libName) $(dllName) = $(def) ;
DEPENDS $(libName) $(dllName) : $(def) ;
}
LibraryOfType $(<) : $(>) : dll ;
}
if $(NT)
{
# Generate .def file for a library from the .objs
rule DefFile
{
local s ;
makeGristedName s : $(>:S=$(SUFOBJ)) ;
DEPENDS $(<) : $(s) ;
DEPENDS $(<) : $(SUBDIR)$(SLASH)Jamfile ;
SUBDIR on $(<) = $(SUBDIR) ;
DefHeader $(<) ;
DefSymbols $(<) : $(s) ;
Clean clean : $(<) ;
}
}
# utility rule for building some form of library
rule LibraryOfType
{
LibraryFromObjects $(<) : $(>) : $(3) ;
Objects $(>) ;
}
# Build a .lib or a .dll from the objects. There's a lot to clean
# up. Note the use of the export library -- it depends on the .dll.
rule LibraryFromObjects
{
local name objName ;
MakeName name : $(<) : $(3) : declare ;
MakeName objName : $(>) : obj ;
DEPENDS obj : $(objName) ;
DEPENDS lib : $(name) ;
DEPENDS $(name) : $(objName) ;
if $(3) = dll && $(NT)
{
local exportName ;
MakeName exportName : $(<) : lib : declare ;
# building the lib makes the exportName -- tell jam this
BuiltByBuildOf $(exportName) : $(name) ;
Clean clean : $(exportName) ;
NOPROPAGATE $(exportName) ;
}
if $(3) = dll
{
SetFlag $(<) : dll : LINKFLAGS : $(LINKDLL) ;
SetFlag $(>) : obj : C++FLAGS : $(DLLCOMPILEFLAG) ;
SetFlag $(>) : obj : CCFLAGS : $(DLLCOMPILEFLAG) ;
if $(DEBUGGING) && $(NT)
{
SetFlag $(<) : lib : PDBFILE : $(LIBPATH)$(SLASH)$(name:S=.pdb) ;
Clean clean : $(LIBPATH)$(SLASH)$(name:S=.pdb) ;
}
if $(NT)
{
Clean clean : $(LIBPATH)$(SLASH)$(name:S=.map) ;
Clean clean : $(LIBPATH)$(SLASH)$(name:S=.pdb) ;
Clean clean : $(LIBPATH)$(SLASH)$(name:S=.ilk) ;
Clean clean : $(LIBPATH)$(SLASH)$(name:S=.exp) ;
Clean clean : $(LIBPATH)$(SLASH)$(name:S=.lib) ;
Clean clean : $(LIBPATH)$(SLASH)$(name:S=._ll) ;
Clean clean : $(LIBPATH)$(SLASH)$(name:S=.pbi) ;
Clean clean : $(LIBPATH)$(SLASH)$(name:S=.pbo) ;
Clean clean : $(LIBPATH)$(SLASH)$(name:S=.pbt) ;
}
if ! $(NOLINK)
{
Link $(name) : $(objName) ;
}
}
else
{
SetFlag $(<) : lib : LINKFLAGS : $(LINKLIBRARY) ;
SetFlag $(>) : obj : C++FLAGS : $(LIBCOMPILEFLAG) ;
SetFlag $(>) : obj : CCFLAGS : $(LIBCOMPILEFLAG) ;
if ! $(NOLINK)
{
LinkStaticLibrary $(name) : $(objName) ;
}
}
Clean clean : $(name) ;
}
# Link an executable.
rule Link
{
# so we can change directories
SUBDIR on $(<) = $(SUBDIR) ;
LOCATE_TARGET on $(<) = $(LOCATE_TARGET) ;
}
# set some linkflags on an executable or dll
rule LinkFlags
{
SetFlag $(<) : exe : LINKFLAGS : $(>) ;
SetFlag $(<) : dll : LINKFLAGS : $(>) ;
}
# Tell the linker which libraries to link an executable too. Note
# that we need to link for .dll's and .exe's but not for .lib's.
#
# LinkLibraries BhbJam : mfctool mdi ... ;
rule LinkLibraries
{
local exeName dllName libraries ;
MakeName exeName : $(<) : exe ;
MakeName dllName : $(<) : dll ;
if $(NT)
{
MakeName libraries : $(>) : lib : $(3) ;
DEPENDS $(exeName) $(dllName) : $(libraries) ;
NEEDLIBS on $(exeName) $(dllName) += $(libraries) ;
}
else
{
# depend on the abstract name of the libraries so we don't have
# to figure out if the're .so or .a
NOTFILE $(>) ;
DEPENDS $(exeName) $(dllName) : $(>) ;
LINKLIBS on $(exeName) $(dllName) +=
-L$(LIBPATH) -l$(>)$(BHBVERSION)$(ARCH) ;
}
}
# Build a command-line program (rather than a gui-based mess)
#
# Main putreg : putreg.cpp ;
rule Main
{
MainFromObjects $(<) : $(>) : main ;
Objects $(>) ;
}
rule MainFromObjects
{
local name objName ;
MakeName name : $(<) : exe : declare ;
MakeName objName : $(>) : obj ;
DEPENDS exe : $(name) ;
DEPENDS $(name) : $(objName) ;
Clean clean : $(name) ;
if $(3) = main
{
SetFlag $(<) : exe : LINKFLAGS : $(LINKMAIN) ;
SetFlag $(>) : obj : C++FLAGS : $(MAINCOMPILEFLAG) ;
SetFlag $(>) : obj : CCFLAGS : $(MAINCOMPILEFLAG) ;
}
else
{
SetFlag $(<) : exe : LINKFLAGS : $(LINKAPPLICATION) ;
SetFlag $(>) : obj : C++FLAGS : $(APPLICATIONCOMPILEFLAG) ;
SetFlag $(>) : obj : CCFLAGS : $(APPLICATIOCOMPILEFLAG) ;
}
if $(DEBUGGING)
{
SetFlag $(<) : exe : PDBFILE : $(BINPATH)$(SLASH)$(name:S=.pdb) ;
Clean clean : $(BINPATH)$(SLASH)$(name:S=.pdb) ;
}
Clean clean : $(BINPATH)$(SLASH)$(name:S=.map) ;
Clean clean : $(BINPATH)$(SLASH)$(name:S=.pdb) ;
Clean clean : $(BINPATH)$(SLASH)$(name:S=.ilk) ;
Clean clean : $(BINPATH)$(SLASH)$(name:S=.exp) ;
Clean clean : $(BINPATH)$(SLASH)$(name:S=.lib) ;
if ! $(NOLINK)
{
Link $(name) : $(objName) ;
}
}
# Tell jam where a file goes, and make sure the directory exists.
rule MakeLocate
{
if $(>)
{
LOCATE on $(<) = $(>) ;
Depends $(<) : $(>[1]) ;
MkDir $(>[1]) ;
}
}
# Make sure a directory exists. Note that this is gated, so you
# can safely call it more than once on the same directory.
rule MkDir
{
if $(<) != $(DOT) && ! $($(<)-mkdir)
{
local s ;
# Cheesy gate to prevent multiple invocations on same dir
# MkDir1 has the actions
# If dir exists, don't update it
# Arrange for jam dirs
$(<)-mkdir = true ;
MkDir1 $(<) ;
NOUPDATE $(<) ;
Depends dirs : $(<) ;
# Recursively make parent directories.
# $(<:P) = $(<)'s parent, & we recurse until root
s = $(<:P) ;
if $(NT)
{
switch $(s)
{
case *: : s = ;
case *:\\ : s = ;
}
}
if $(s) && $(s) != $(<)
{
Depends $(<) : $(s) ;
MkDir $(s) ;
}
else if $(s)
{
NOTFILE $(s) ;
}
}
else if $(<) = $(DOT)
{
NOUPDATE $(<) ;
}
}
# Compile some file into a .obj
#
# This assigns the standard $(LOCATE_TARGET), $(SEARCH_SOURCE) stuff
rule Object
{
local h ;
# locate object and search for source, if wanted
Clean clean : $(<) ;
MakeLocate $(<) : $(LOCATE_TARGET) ;
SEARCH on $(>) = $(SEARCH_SOURCE) ;
# Save HDRS for -I$(HDRS) on compile.
HDRS on $(<) = $(HDRS) $(SUBDIRHDRS) ;
# handle #includes for source: Jam scans for headers with
# the regexp pattern $(HDRSCAN) and then invokes $(HDRRULE)
# with the scanned file as the target and the found headers
# as the sources. HDRSEARCH is the value of SEARCH used for
# the found header files. Finally, if jam must deal with
# header files of the same name in different directories,
# they can be distinguished with HDRGRIST.
if ! $(FAST)
{
HDRRULE on $(>) = HdrRule ;
HDRSCAN on $(>) = $(HDRPATTERN) ;
HDRSEARCH on $(>) = $(HDRS) $(SUBDIRHDRS) $(STDHDRS) ;
HDRGRIST on $(>) = $(HDRGRIST) ;
}
# if source is not .c, generate .c with specific rule
switch $(>:S)
{
case .c : Cc $(<) : $(>) ;
case .C : C++ $(<) : $(>) ;
case .cc : C++ $(<) : $(>) ;
case .cpp : C++ $(<) : $(>) ;
case .cxx : C++ $(<) : $(>) ;
case .imp : DBSchemaCompile $(<) : $(>) ;
case * : EXIT "Unknown suffix" $(>:S) "in Object!" ;
}
}
# Set flags. Even easier wrappers to SetFlag
rule ObjectCcFlags { SetFlag $(<) : obj : CCFLAGS : $(>) ; }
rule ObjectC++Flags { SetFlag $(<) : obj : C++FLAGS : $(>) ; }
rule ObjectHdrs { SetFlag $(<) : obj : HDRS : $(>) ; }
# This rule loops through the objects and builds them.
# We build objects only once for a given
# grist; note that one source file compiled with multiple
# different flags (for example) should give two gristed names.
rule Objects
{
local i s ;
# Add grist to file names
makeGristedName s : $(<) ;
for i in $(s)
{
if ! $($(i)-object)
{
Object $(i:S=$(SUFOBJ)) : $(i) ;
DEPENDS obj : $(i:S=$(SUFOBJ)) ;
$(i)-object = true ;
}
}
}
# Say that an application depends on some compiled resources:
#
# Resources BhbJam : BhbJam.rc ;
rule Resources
{
# Fully qualify the source and target names according to our convention.
makeGristedName s : $(>) ;
local te td ;
MakeName te : $(<) : exe ;
MakeName td : $(<) : dll ;
local t = $(te) $(td) ;
# Invoke the ResourceCompiler rule on each .rc file.
for i in $(s)
{
local res = $(i:S=$(SUFRES)) ;
ResourceCompiler $(res) : $(i) ;
}
# Specify the link-time dependency of the exe on the compiled resources.
NEEDRES on $(t) += $(s:S=$(SUFRES)) ;
DEPENDS $(t) : $(s:S=$(SUFRES)) ;
}
# This rule is to .rc files what the C++ rule is to .cpp files.
rule ResourceCompiler
{
MakeLocate $(<) : $(LOCATE_TARGET) ;
SEARCH on $(>) = $(SEARCH_SOURCE) ;
if ! $(FAST)
{
HDRRULE on $(>) = HdrRule ;
HDRSCAN on $(>) = $(HDRPATTERN) ;
HDRSEARCH on $(>) = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) $(STDHDRS) ;
HDRGRIST on $(>) = $(HDRGRIST) ;
}
RCFLAGS on $(<) += $(RCFLAGS) ;
SUBDIRRCFLAGS on $(<) += $(SUBDIRRCFLAGS) ;
Clean clean : $(<) ;
DEPENDS $(<) : $(>) ;
}
# Set some resource compilation flags
#
# ResourceFlags BhbJam.rc : -I../mfctool ;
rule ResourceFlags
{
SetFlag $(<) : res : RCFLAGS : $(>) ;
}
rule RmTemps
{
TEMPORARY $(>) ;
}
# Add to the subdirectories of the current directory where jam
# will go looking for your source files.
rule Search
{
SEARCH_SOURCE += $(SUBDIR)$(SLASH)$(<) ;
}
rule SubDirCcFlags
{
SUBDIRCCFLAGS += $(<) ;
}
rule SubDirC++Flags
{
SUBDIRC++FLAGS += $(<) ;
}
rule SubDirHdrs
{
SUBDIRHDRS += $(<) ;
}
rule SubInclude
{
local s ;
# That's
# SubInclude TOP d1 [ d2 [ d3 [ d4 ] ] ]
#
# to include a subdirectory's Jamfile.
if ! $($(<[1]))
{
EXIT Top level of source tree has not been set with $(<[1]) ;
}
makeDirName s : $(<[2-]) ;
include $(JAMFILE:D=$(s):R=$($(<[1]))) ;
}
rule UserSubDir
{
#
# d1 ... are the directory elements that lead to this directory
# from $(TOP). We construct the system dependent path from these
# directory elements in order to set search&locate stuff.
#
# Get path to current directory from root using makeSubDir.
# Save dir tokens for other potential uses.
makeDirName s : $(<[2-]) ;
SUBDIR = $(s:R=$($(<[1]))) ;
SUBDIR_TOKENS = $(<[2-]) ;
# Now set up SEARCH_SOURCE, LOCATE_TARGET, SOURCE_GRIST
# These can be reset if needed. For example, if the source
# directory should not hold object files, LOCATE_TARGET can
# subsequently be redefined.
SEARCH_SOURCE = $(SUBDIR) ;
LOCATE_SOURCE = $(ALL_LOCATE_TARGET) $(SUBDIR) ;
LOCATE_TARGET = $(SUBDIR)$(SLASH)$(ARCHDIR) ;
makeGrist SOURCE_GRIST : $(<[2-]) ;
# Reset per-directory ccflags, hdrs
SUBDIRCCFLAGS = ;
SUBDIRC++FLAGS = ;
SUBDIRHDRS = ;
SUBDIR_PCH_FILE = ;
SUBDIR_PCH_END = ;
SUBDIR_RCFLAGS = ;
}
# ----------
# Actions
# ----------
# We should make sure the timestamp of the the target is the same as the
# the timestamp of the dependency, so we don't rebuild it by mistake
actions quietly BuiltByBuildOf
{
touch -cf $(>) $(<)
}
actions together JamPackage
{
sh $(TOP)/tools/makepackage.sh $(PACKAGENAME) $(>) > $(<)
}
if ! $(JIKESPATH)
{
actions JavaC
{
cd $(SUBDIR)
javac $(JAVAFLAGS) -classpath "$(CLASSPATH)" -sourcepath "$(JAVAROOT:R=$(PWD))" -J-Xmx256m $(>:BS)
}
}
else
{
# note the use of the shell's JIKESPATH, not ours -- because otherwise
# jam would split it.
JIKESPATHQUOTE = "$JIKESPATH" ;
actions together JavaC
{
cd $(JAVAROOT)
if jikes $(JAVAFLAGS) -classpath "$(JAVAROOT:R=$(PWD))$(SPLITPATH)$(CLASSPATH)$(SPLITPATH)$(JIKESPATHQUOTE)" -Xdepend $(>:R=$(PWD))
then
exit 0
else
rm -f $(<)
fi
}
}
actions Jar
{
rm -f $(<:R=$(JAVAROOT):S=.jar)
touch $(<:R=$(JAVAROOT):S=.jar)
function doPackage
$(LCURLY)
package=$1
path=$2
dir=`echo $package | sed s,\\\\.,/,g`
(
cd $path
find $dir $(JARPATTERNS) | xargs jar uf $(<:R=$(JAVAROOT):S=.jar)
)
$(RCURLY)
for pkg in $(2)
do
doPackage $pkg $(JAVAROOT)
done
if [ " $(JARHAS3RDPARTY) " = " true " ]
then
for pkg in $(JAR3RDPARTY)
do
doPackage $pkg $(JAVA3RDPARTYROOT)
done
fi
}
actions JarPersistable
{
rm -f $(<:R=$(JAVAROOT):S=.jar)
touch $(<:R=$(JAVAROOT):S=.jar)
rm -f $(<:R=$(JAVAROOT):S=.temp.jar)
touch $(<:R=$(JAVAROOT):S=.temp.jar)
rm -rf $(<:R=$(JAVAROOT):S=.osjitemp)
mkdir $(<:R=$(JAVAROOT):S=.osjitemp)
function doPackage
$(LCURLY)
package=$1
path=$2
dir=`echo $package | sed s,\\\\.,/,g`
class=`echo $dir.class`
(
cd $path
jar uf $(<:R=$(JAVAROOT):S=.temp.jar) $class
)
$(RCURLY)
for pkg in $(2)
do
doPackage $pkg $(JAVAROOT)
done
if [ " $(JARHAS3RDPARTY) " = " true " ]
then
for pkg in $(JAR3RDPARTY)
do
doPackage $pkg $(JAVA3RDPARTYROOT)
done
fi
# must set the classpath for OSJI to run properly. This next line sux and should go.
# if anyone thinks of a good way to get rid of it, go for it.
export CLASSPATH=$(CLASSPATH)
$(OSJI_HOME)/bin/osjcfp -dest $(<:R=$(JAVAROOT):S=.osjitemp) -classpath $(CLASSPATH) -quiet $(<:R=$(JAVAROOT):S=.temp.jar)
# now take osji's results and put them in the actual jar file, then clean up.
cd $(<:R=$(JAVAROOT):S=.osjitemp)
find . -name "*.class" -print | xargs jar uf $(<:R=$(JAVAROOT):S=.jar)
cd $(JAVAROOT)
rm -rf $(<:R=$(JAVAROOT):S=.osjitemp)
rm -f $(<:R=$(JAVAROOT):S=.temp.jar)
}
actions Jode
{
cd $(JAVAROOT)
java -cp ".$(SPLITPATH)$(CLASSPATH)$(SPLITPATH)$(TOP:R=$(PWD))/tools/jode.jar" jode.obfuscator.Main $(>)
if [ $? = 0 ] && ! [ " $(JARHASEXTRAS) " = " true " ]
then
find . $(JAREXTRAS) | xargs jar uf $(<:R=$(JAVAROOT):S=.jar)
fi
exit $?
}
actions Tar
{
find $(TOP) $(TARPATTERNS) | xargs tar czf $(<:R=$(TOP):S=.tar.gz)
}
actions piecemeal together existing Clean
{
$(RM) $(>)
}
actions piecemeal together CleanMany
{
$(RM) $(>)
}
actions File
{
$(RM) $(<)
$(CP) $(>) $(<)
}
actions GenFile1
{
$(>[1]) $(<) $(>[2-])
}
actions MkDir1
{
$(MKDIR) $(<)
}
actions quietly RmFile
{
$(RM) $(<)
}
actions quietly updated piecemeal together RmTemps
{
$(RM) $(>)
}
actions SchComp
{
# cd to where the target files go (we know that's writable)
cd $(LOCATE_TARGET)
# run schcomp
if schcomp $(OPTIM) $(C++FLAGS) -I$(HDRS:R=$(PWD)) $(>:R=$(PWD))
then
# that just made .sch and .cxx in locate-target. hopefully they go there.
# OK, the schema compiler erased some all important stuff from xstring.
# put it back
sed \
-e '/^#line 603 .*xstring"$/ {' \
-e ' n' \
-e ' /^#pragma warning(disable:4231)$/ {' \
-e ' r $(TOP:R=$(PWD))/tools/stringexport.h' \
-e ' }' \
-e '}' \
< $(>:B).cxx > $(>:B).tmp
# remove #line directives, which seem to choke the compiler...
sed 's:^#line://#line:' < $(>:B).tmp > $(>:B).cxx
rm -f $(>:B).tmp
else
exit 1
fi
}
# ----------
# Platform Actions
# ----------
if $(NT)
{
actions Cc bind PCHFILE
{
$(CC) /c $(OPTIM) /I$(HDRS) $(CCFLAGS) /Fo$(<[1]) /Fp$(PCHFILE) /Tc$(>[1) /Fd$(PDBFILE)
}
actions C++ bind PCHFILE
{
$(C++) /c $(OPTIM) /I$(HDRS) $(C++FLAGS) /Fo$(<[1]) /Fp$(PCHFILE) /Tp$(>[1]) /Fd$(PDBFILE)
}
# we need to CD to where the object files are so we don't have to give the
# full path names of the objects (notice the $(>:BS)) -- otherwise
# the linker internally runs out of room and dies...
actions Link bind NEEDLIBS NEEDRES DEFFILE
{
cd $(LOCATE_TARGET)
$(LINK) $(LINKFLAGS) /def:$(DEFFILE:R=$(PWD)) /out:$(<:R=$(PWD)) $(NEEDRES:R=$(PWD)) /pdb:$(PDBFILE:R=$(PWD)) $(UNDEFS) $(>:BS) $(LINKLIBS) $(NEEDLIBS:R=$(PWD)) /LIBPATH:$(3RDPARTYLIB:R=$(PWD))
}
# nt links libraries in the same way as dlls and exes
rule LinkStaticLibrary
{
Link $(<) : $(>) ;
}
actions DefHeader
{
echo LIBRARY $(<:B)$(BHBVERSION)$(ARCH) > $(<)
echo >> $(<)
echo EXPORTS >> $(<)
}
actions piecemeal DefSymbols
{
cd $(SUBDIR)$(SLASH)$(ARCHDIR)
sh $(TOP:R=$(PWD))/tools/exportsymbols.sh $(>:BS) >> $(<:R=$(PWD))
}
actions ResourceCompiler
{
$(RC) /fo $(<) $(RCFLAGS) $(UNITTESTFLAGS) $(SUBDIRRCFLAGS) $(>)
}
actions BrowseInfo
{
bscmake /nologo /n /o$(<) $(TOP)/browse/*.sbr
}
if $(BROWSE)
{
BrowseInfo $(TOP)$(SLASH)bin$(SLASH)browse.bsc ;
}
}
else
{
actions Cc
{
$(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)
}
actions C++
{
$(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)
}
actions Link
{
$(LINK) $(LINKFLAGS) -o $(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKIBS)
}
actions together LinkStaticLibrary
{
$(C++) $(ARCHIVEFLAGS) -o $(<) $(>) ;
}
actions BrowseInfo
{
bscmake /nologo /n /o$(<) $(TOP)/browse/*.sbr
}
if $(BROWSE)
{
BrowseInfo $(TOP)$(SLASH)bin$(SLASH)browse.bsc ;
}
}
#
# Compatibility
#
rule BhbLibrary { Library $(<) : $(>) ; }
rule BhbDefLibrary { Library $(<) : $(>) ; }
rule BhbDefLibrary { Library $(<) : $(>) ; }
rule BhbDLLDebugLibraries { LinkLibraries $(<) : $(>) : $(3) ; }
rule BhbDLLDebugDefine { DefineForDLL $(<) : $(>) ; }
rule BhbDLLLibraries { LinkLibraries $(<) : $(>) : $(3) ; }
rule BhbDefine { Define $(<) : $(>) ; }
rule BhbLinkFlags
{
SetFlag $(<) : exe : LINKFLAGS : $(>) ;
SetFlag $(<) : dll : LINKFLAGS : $(>) ;
}
rule BhbDLLLinkFlags { SetFlag $(<) : dll : LINKFLAGS : $(>) ; }
rule NTSucks_ReorderLibraries
{
if $(NT)
{
if $(CF) = debug
{
BhbLinkFlags $(<) :
/nodefaultlib:msvcrtd
/nodefaultlib:libcmtd
msvcrtd.lib
libcmtd.lib
;
}
else if $(CF) = release
{
BhbLinkFlags $(<) :
/nodefaultlib:msvcrt
/nodefaultlib:libcmt
msvcrt.lib
libcmt.lib
;
}
else if $(CF) = rbug
{
BhbLinkFlags $(<) :
/nodefaultlib:msvcrt
/nodefaultlib:libcmt
msvcrt.lib
libcmt.lib
;
}
}
}
rule BhbMain { Main $(<) : $(>) ; }
rule BhbApplication { Application $(<) : $(>) ; }
rule BhbLinkLibraries { LinkLibraries $(<) : $(>) : $(3) ; }
rule BhbDynamicLibrary { DynamicLibrary $(<) : $(>) ; }
rule BhbStaticLibrary { StaticLibrary $(<) : $(>) ; }
rule BhbExeExportLibrary { ExportLibrary $(<) : $(>) ; }
rule InstallProgram { Install $(<) : exe : $(2) : $(3) ; }
rule InstallDLL { Install $(<) : dll : $(2) : $(3) ; }
rule InstallFiles { Install $(<) : installFile : $(2) : $(3) ; }
rule BhbResources { Resources $(<) : $(>) ; }
rule BhbSearch { Search $(<) ; }