mirror of
https://github.com/bulletphysics/bullet3
synced 2024-12-16 14:40:05 +00:00
354 lines
10 KiB
Plaintext
354 lines
10 KiB
Plaintext
#============================================================================
|
|
# Utility rules for static builds without plugins
|
|
# Copyright (C)2003 by Matze Braun <matzebraun@users.sourceforge.net>
|
|
#
|
|
# This library is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU Library General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or (at your
|
|
# option) any later version.
|
|
#
|
|
# This library is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
|
|
# License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Library General Public License
|
|
# along with this library; if not, write to the Free Software Foundation,
|
|
# Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
#
|
|
#============================================================================
|
|
# all private
|
|
|
|
rule GenerateStaticPluginBoilerplate
|
|
{
|
|
ResponseFile $(<) :
|
|
"// This file is automatically generated."
|
|
"#include \"cssysdef.h\""
|
|
"#include \"csutil/scf.h\""
|
|
""
|
|
"// Put static linking stuff into own section."
|
|
"// The idea is that this allows the section to be swapped out but not"
|
|
"// swapped in again b/c something else in it was needed."
|
|
"#if !defined(CS_DEBUG) && defined(CS_COMPILER_MSVC)"
|
|
"#pragma const_seg(\".CSmetai\")"
|
|
"#pragma comment(linker, \"/section:.CSmetai,r\")"
|
|
"#pragma code_seg(\".CSmeta\")"
|
|
"#pragma comment(linker, \"/section:.CSmeta,er\")"
|
|
"#pragma comment(linker, \"/merge:.CSmetai=.CSmeta\")"
|
|
"#endif"
|
|
: notfile ;
|
|
}
|
|
|
|
rule GenerateStaticPluginInstantiation
|
|
{
|
|
GenerateStaticPluginBoilerplate $(<) ;
|
|
ResponseFile $(<) : "SCF_USE_STATIC_PLUGIN($(>:B))" : notfile ;
|
|
}
|
|
|
|
rule GenerateStaticPluginRegistration
|
|
{
|
|
GenerateStaticPluginBoilerplate $(<) ;
|
|
GenerateStaticPluginRegistration1 $(<) : $(>) ;
|
|
}
|
|
|
|
rule BuildStaticRegFile
|
|
{
|
|
local statictarget = $(>) ;
|
|
# prepare source files
|
|
local sources = [ DoObjectGrist _$(<)_static_reg.cpp ] ;
|
|
local object = [ CompileObject $(sources) ] ;
|
|
|
|
MakeLocate $(sources) : $(LOCATE_TARGET) ;
|
|
MakeLocate $(object) : $(LOCATE_TARGET) ;
|
|
|
|
local metalist metafile i ;
|
|
for i in $(<)
|
|
{
|
|
metafile = $($(i)_METAFILE) ;
|
|
metalist += $(metafile) ;
|
|
Depends $(sources) : $(metafile) ;
|
|
}
|
|
|
|
GenerateStaticPluginRegistration $(sources) : $(metalist) ;
|
|
Clean $(statictarget)clean : $(sources) ;
|
|
Clean $(statictarget)clean : $(object) ;
|
|
return $(object) ;
|
|
}
|
|
|
|
rule BuildStaticUseFile
|
|
{
|
|
local statictarget = $(2) ;
|
|
local package = $(3) ;
|
|
# prepare source files
|
|
local sources ;
|
|
if $(3)
|
|
{
|
|
sources = [ DoObjectGrist _cs_static_use_$(package).cpp ] ;
|
|
}
|
|
else
|
|
{
|
|
sources = [ DoObjectGrist _cs_static_use.cpp ] ;
|
|
}
|
|
local object = [ CompileObject $(sources) ] ;
|
|
|
|
MakeLocate $(sources) : $(LOCATE_TARGET) ;
|
|
SEARCH on $(sources) = $(LOCATE_TARGET) ;
|
|
MakeLocate $(object) : $(LOCATE_TARGET) ;
|
|
|
|
C++FLAGS on $(object) += $($($(>).EXTERNALLIBS).CFLAGS) ;
|
|
|
|
GenerateStaticPluginInstantiation $(sources) : $(<) ;
|
|
Clean $(statictarget)clean : $(sources) ;
|
|
Clean $(statictarget)clean : $(object) ;
|
|
return $(object) ;
|
|
}
|
|
|
|
## LinkStaticPlugins target : plugins [: optionalplugins] [: package]
|
|
## Builds the plugins in 'plugins' (and 'optionalplugins') statically into
|
|
## 'target'. Can be used both for static plugins from the local project or
|
|
## an external project. In the latter case, the project's static plugin
|
|
## library has to have been built, also, the "<package>.STATICDEPS"
|
|
## variable must contain a path to a specially generated Jamfile that
|
|
## contains information about the plugins provided by as well as external
|
|
## dependencies. The static plugins library for both local and external
|
|
## package must be explicitly linked into 'target'.
|
|
rule LinkStaticPlugins
|
|
{
|
|
local package target plugins optplugins ;
|
|
# Fetch the parameters
|
|
target = $(1) ;
|
|
plugins = $(2) ;
|
|
optplugins = $(3) ;
|
|
package = $(4) ;
|
|
|
|
if $(package)
|
|
{
|
|
# External static plugins.
|
|
# First include static plugin info
|
|
if ! $(HAVE_STATICDEPS.$(package))
|
|
{
|
|
include $($(package).STATICDEPS) ;
|
|
HAVE_STATICDEPS.$(package) = yes ;
|
|
}
|
|
local lflags p ;
|
|
# Collect optional plugins
|
|
for p in $(optplugins)
|
|
{
|
|
if [ IsElem $(p) : $(STATICPLUGINS.AVAILABLE) ]
|
|
{
|
|
plugins += $(p) ;
|
|
}
|
|
}
|
|
# Grab flags
|
|
for p in $(plugins)
|
|
{
|
|
NotFile $(p) ;
|
|
CFlags $(target) : $(STATICPLUGIN.$(p).CFLAGS) ;
|
|
lflags = [ MergeLFlags $(lflags) : $(STATICPLUGIN.$(p).LFLAGS) ] ;
|
|
}
|
|
LFlags $(target) : $(lflags) ;
|
|
}
|
|
else
|
|
{
|
|
# Local static plugins
|
|
local lflags libs p ;
|
|
# Collect optional plugins
|
|
for p in $(optplugins)
|
|
{
|
|
if $($(p)_TARGET)
|
|
{
|
|
plugins += $(p) ;
|
|
}
|
|
}
|
|
# Grab flags
|
|
for p in $(plugins)
|
|
{
|
|
lflags += [ Filter $($(p).LFLAGS) : $(LINKLIBS) $(PLUGIN.LFLAGS) ] ;
|
|
libs += $($(p).NEEDLIBS) ;
|
|
}
|
|
LFlags $(target) : [ Reverse [ RemoveDups [ Reverse $(lflags) ] ] ] ;
|
|
LinkWith $(target) : [ Reverse [ RemoveDups [ Reverse $(libs) ] ] ] ;
|
|
}
|
|
|
|
# construct initialization sourcefile
|
|
local staticobject = [ BuildStaticUseFile $(plugins) : $(target) : $(package) ] ;
|
|
ExtraObjects $(target) : $(staticobject) : inheritcflags ;
|
|
}
|
|
|
|
## StaticPluginLibrary name [: rejects]
|
|
## Create a library that monolithically contains statically linkable
|
|
## versions of all plugins, and also provides a target to install this
|
|
## library ("install_staticplugins") as well as resources to facilitate the
|
|
## use of that library from external projects. Also, most plugins will
|
|
## probably themselves depend on other libraries; while those are correctly
|
|
## linked in with the static plugins, they are not built or installed when
|
|
## the static plugin library is.
|
|
## This library is intended to be used together with the
|
|
## "LinkStaticPlugins" rule.
|
|
rule StaticPluginLibrary
|
|
{
|
|
local name = $(<) ;
|
|
local rejects = $(>) ;
|
|
local t ;
|
|
|
|
local targets = $(STATICPLUGINS.SUBTARGETS) ;
|
|
if $(rejects)
|
|
{
|
|
targets = [ Filter $(targets) : $(rejects) ] ;
|
|
}
|
|
local objects ;
|
|
for t in $(targets)
|
|
{
|
|
objects += $(STATICPLUGINS.OBJECTS.$(t)) ;
|
|
}
|
|
|
|
# Set up library
|
|
Library $(name) : $(objects) : noinstall notest independent nohelp ;
|
|
SEARCH on $(name) += $(LOCATE_TARGET) ;
|
|
MsvcDefine $(name) : $(STATICPLUGINS.MSVC_DEFINES) ;
|
|
CFlags $(name) :
|
|
[ FDefines CS_STATIC_LINKED ]
|
|
: nostatic ;
|
|
|
|
# Copy a variety of flags
|
|
local o ;
|
|
for o in $(objects)
|
|
{
|
|
local sourceobj = $(STATICPLUGINS.OBJECTS.$(o)) ;
|
|
if $(sourceobj)
|
|
{
|
|
CCFLAGS on $(o) += [ on $(sourceobj) GetVar CCFLAGS ] ;
|
|
C++FLAGS on $(o) += [ on $(sourceobj) GetVar C++FLAGS ] ;
|
|
}
|
|
}
|
|
|
|
# Write out needed CFLAGS, LFLAGS
|
|
STATICPLUGINS.DEPENDENCIES = $(name).jam ;
|
|
MakeLocate $(STATICPLUGINS.DEPENDENCIES) : $(LOCATE.OBJECTS)/libs ;
|
|
for t in $(targets)
|
|
{
|
|
WriteDependencies $(STATICPLUGINS.DEPENDENCIES) : $(t) : $(name) ;
|
|
}
|
|
Depends $(name) : $(STATICPLUGINS.DEPENDENCIES) ;
|
|
Clean $(name)clean : $(STATICPLUGINS.DEPENDENCIES) ;
|
|
|
|
# Install targets
|
|
Depends install_staticplugins :
|
|
[ DoInstall [ ConstructLibraryTarget $(name) ] : $(libdir) ] ;
|
|
Depends install_staticplugins : $(STATICPLUGINS.DEPENDENCIES) ;
|
|
Depends install_staticplugins :
|
|
[ DoInstall $(STATICPLUGINS.DEPENDENCIES) : $(libdir) ] ;
|
|
Depends install_staticplugins : install_libs ;
|
|
|
|
INSTALLEDLIBS_OPTIONAL += $(name) ;
|
|
|
|
# Collect library dependencies. The idea is to built all libs needed by the
|
|
# static plugins when "jam staticplugins" is invoked.
|
|
for t in $(targets)
|
|
{
|
|
local deplibs ;
|
|
if $($(t).NEEDLIBS)
|
|
{
|
|
deplibs += $($(t).NEEDLIBS) ;
|
|
}
|
|
deplibs = [ RemoveDups $(deplibs) ] ;
|
|
Depends staticplugins : $(deplibs) ;
|
|
}
|
|
Help staticplugins :
|
|
"Build the library with static versions of all plugins" ;
|
|
Depends staticplugins : libs $(name) ;
|
|
}
|
|
|
|
#----------------------------------------------------------------------------
|
|
|
|
# Write out CFLAGS, LFLAGS needed by a plugin
|
|
rule WriteDependencies
|
|
{
|
|
local cflags ;
|
|
local lflags ;
|
|
local depfile = $(<) ;
|
|
local plugin = $(>) ;
|
|
local name = $(3) ;
|
|
local depfile_gristed = $(depfile:G=$(plugin)) ;
|
|
MakeLocate $(depfile_gristed) : [ on $(depfile) GetVar LOCATE ] ;
|
|
|
|
# Collect flags
|
|
lflags += -l$(name) ;
|
|
local libs = [ ResolveLibs $($(plugin).NEEDLIBS) ] ;
|
|
lflags += -l$(libs) ;
|
|
|
|
local l ;
|
|
for l in $($(plugin).EXTERNALLIBS)
|
|
{
|
|
cflags += $($(l).CFLAGS) ;
|
|
lflags += [ Filter $($(l).LFLAGS) : $(LINKLIBS) $(PLUGIN.LFLAGS) ] ;
|
|
}
|
|
lflags += [ Filter $($(plugin).LFLAGS) : $(LINKLIBS) $(PLUGIN.LFLAGS) ] ;
|
|
CFLAGS on $(depfile_gristed) = "$(cflags)" ;
|
|
LFLAGS on $(depfile_gristed) = "$(lflags)" ;
|
|
|
|
if $($(depfile).FIRSTTIME) != "yes"
|
|
{
|
|
WriteDepFlags1 $(depfile_gristed) : $(plugin) ;
|
|
$(depfile).FIRSTTIME = "yes" ;
|
|
}
|
|
else
|
|
{
|
|
WriteDepFlags2 $(depfile_gristed) : $(plugin) ;
|
|
}
|
|
Depends $(depfile) : $(depfile_gristed) ;
|
|
}
|
|
|
|
actions WriteDepFlags1
|
|
{
|
|
cat << EOT > $(<)
|
|
STATICPLUGINS.AVAILABLE += $(>) ;
|
|
STATICPLUGIN.$(>).CFLAGS = $(CFLAGS) ;
|
|
STATICPLUGIN.$(>).LFLAGS = $(LFLAGS) ;
|
|
EOT
|
|
}
|
|
|
|
actions WriteDepFlags2
|
|
{
|
|
cat << EOT >> $(<)
|
|
STATICPLUGINS.AVAILABLE += $(>) ;
|
|
STATICPLUGIN.$(>).CFLAGS = $(CFLAGS) ;
|
|
STATICPLUGIN.$(>).LFLAGS = $(LFLAGS) ;
|
|
EOT
|
|
}
|
|
|
|
actions piecemeal GenerateStaticPluginRegistration1
|
|
{
|
|
echo 'namespace csStaticPluginInit' >> $(<)
|
|
echo '{' >> $(<)
|
|
for x in $(>)
|
|
do
|
|
n=`basename $x $(SUFMETA)`
|
|
echo "static char const metainfo_${n}[] =" >> $(<)
|
|
$(SED) 's:\\:\\\\:g;s:":\\":g;s:\(.*\):"\1":' < $x >>$(<)
|
|
echo ";" >> $(<)
|
|
$(SED) '/<implementation>/!d;s:[ ]*<implementation>\(..*\)</implementation>: #ifndef \1_FACTORY_REGISTER_DEFINED \
|
|
#define \1_FACTORY_REGISTER_DEFINED \
|
|
SCF_DEFINE_FACTORY_FUNC_REGISTRATION(\1) \
|
|
#endif:g' < $x >> $(<)
|
|
done
|
|
echo '' >> $(<)
|
|
for x in $(>)
|
|
do
|
|
n=`basename $x $(SUFMETA)`
|
|
echo "class ${n}" >> $(<)
|
|
echo "{" >> $(<)
|
|
echo "SCF_REGISTER_STATIC_LIBRARY($n,metainfo_${n})" >>$(<)
|
|
$(SED) '/<implementation>/!d;s:[ ]*<implementation>\(..*\)</implementation>: #ifndef \1_FACTORY_REGISTERED \
|
|
#define \1_FACTORY_REGISTERED \
|
|
\1_StaticInit \1_static_init__; \
|
|
#endif:g' < $x >> $(<)
|
|
echo "public:" >> $(<)
|
|
echo " ${n}();" >> $(<)
|
|
echo "};" >> $(<)
|
|
echo "$n::$n() {}" >> $(<)
|
|
echo "" >> $(<)
|
|
done
|
|
echo '}' >> $(<)
|
|
}
|