From cb1f00a96949ee97f313a085b1ce088d16ef4afc Mon Sep 17 00:00:00 2001 From: David Rose Date: Tue, 31 Oct 2000 03:19:40 +0000 Subject: [PATCH] *** empty log message *** --- dtool/Config.pp | 7 + dtool/pptempl/Global.gmsvc.pp | 99 ++++ dtool/pptempl/Template.gmsvc.pp | 823 ++++++++++++++++++++++++++++++++ dtool/pptempl/Template.msvc.pp | 2 +- 4 files changed, 930 insertions(+), 1 deletion(-) create mode 100644 dtool/pptempl/Global.gmsvc.pp create mode 100644 dtool/pptempl/Template.gmsvc.pp diff --git a/dtool/Config.pp b/dtool/Config.pp index 72f7563cd6..58bdb0e7a5 100644 --- a/dtool/Config.pp +++ b/dtool/Config.pp @@ -63,6 +63,13 @@ // msvc - Generate makefiles suitable for building on Windows platforms // (e.g. Windows NT, Windows 2000) using the Microsoft Visual C++ // command-line compiler and Microsoft nmake. +// gmsvc - Generate makefiles similar to the above, using Microsoft +// Visual C++, but uses the Cygwin-supplied GNU make +// instead of Microsoft nmake. This is potentially +// faster if you have multiple CPU's, since it supports +// distributed make. It's a tiny bit slower if you're +// not taking advantage of distributed make, because of +// the overhead associated with Cygwin fork() calls. // #define BUILD_TYPE unix diff --git a/dtool/pptempl/Global.gmsvc.pp b/dtool/pptempl/Global.gmsvc.pp new file mode 100644 index 0000000000..5eddd1ddfc --- /dev/null +++ b/dtool/pptempl/Global.gmsvc.pp @@ -0,0 +1,99 @@ +// +// Global.gmsvc.pp +// +// This file is read in before any of the individual Sources.pp files +// are read. It defines a few global variables to assist +// Template.gmsvc.pp. +// + +#if $[< $[PPREMAKE_VERSION],0.55] + #error You need at least ppremake version 0.56 to use BUILD_TYPE gmsvc. +#endif + +#defun get_metalibs target,complete_libs + // In Windows, we need to know the complete set of metalibs that + // encapsulates each of the libraries we'd be linking with normally. + // In the case where a particular library is not part of a metalib, + // we include the library itself. + + #define actual_libs + #foreach lib $[complete_libs] + // Only consider libraries that we're actually building. + #if $[all_libs $[and $[build_directory],$[build_target]],$[lib]] + #define modmeta $[module $[TARGET],$[lib]] + #if $[ne $[modmeta],] + #if $[ne $[modmeta],$[target]] // We don't link with ourselves. + #set actual_libs $[actual_libs] $[modmeta] + #endif + #else + #set actual_libs $[actual_libs] $[lib] + #endif + #endif + #end lib + #set actual_libs $[unique $[actual_libs]] $[patsubst %:m,%,$[filter %:m,$[OTHER_LIBS]]] + $[actual_libs] +#end get_metalibs + +#defun decygwin frompat,topat,path + #foreach file $[path] + #if $[isfullpath $[file]] + $[patsubstw $[frompat],$[topat],$[cygpath_w $[file]]] + #else + $[patsubstw $[frompat],$[topat],$[osfilename $[file]]] + #endif + #end file +#end decygwin + +#define install_lib_dir $[install_lib_dir] +#define install_bin_dir $[install_bin_dir] +#define install_headers_dir $[install_headers_dir] +#define install_data_dir $[install_data_dir] +#define install_igatedb_dir $[install_igatedb_dir] +#define install_config_dir $[install_config_dir] +#define install_parser_inc_dir $[install_parser_inc_dir] + +// Define this if we want to make .sbr files. +#defer BROWSEINFO_FLAG /Fr"$[osfilename $[target:%.obj=%.sbr]]" +#defer CFLAGS_SHARED + +#defer OPTFLAGS /O2 /Ob1 /Ogity /G6 + +#defer CDEFINES_OPT1 _DEBUG +#defer CDEFINES_OPT2 _DEBUG +#defer CDEFINES_OPT3 +#defer CDEFINES_OPT4 NDEBUG + +#defer CFLAGS_OPT1 $[CDEFINES_OPT1:%=/D%] /MDd /Gi- /GZ /Zi $[BROWSEINFO_FLAG] /Fd"$[osfilename $[target:%.obj=%.pdb]]" +#defer CFLAGS_OPT2 $[CDEFINES_OPT2:%=/D%] /MDd /Gi- /Zi $[BROWSEINFO_FLAG] /Fd"$[osfilename $[target:%.obj=%.pdb]]" +#defer CFLAGS_OPT3 $[CDEFINES_OPT3:%=/D%] /MD /Gi- +#defer CFLAGS_OPT4 $[CDEFINES_OPT4:%=/D%] /MD /Gi- + +#defer LDFLAGS_OPT1 /debug /incremental:no +#defer LDFLAGS_OPT2 /debug /incremental:no +#defer LDFLAGS_OPT3 /fixed:no +#defer LDFLAGS_OPT4 /fixed:no + +// $[dllext] will be "_d" for debug builds, and empty for non-debug +// builds. This is the extra bit of stuff we tack on to the end of a +// dll name. We name the debug dll's file_d.dll, partly to be +// consistent with Python's convention, and partly for our own benefit +// to differentiate debug-built from non-debug-built dll's (since the +// distinction is so important in Windows). +#define dllext $[if $[<= $[OPTIMIZE],2],_d] + +#defer interrogate_ipath $[decygwin %,-I"%",$[target_ipath]] +#defer interrogate_spath $[decygwin %,-S"%",$[install_parser_inc_dir]] + +#defer extra_cflags /W3 /EHsc /Zm250 /DWIN32_VC /DWIN32 + +#defer COMPILE_C cl /nologo /c /Fo"$[osfilename $[target]]" $[decygwin %,/I"%",$[ipath]] $[flags] $[extra_cflags] $[source] +#defer COMPILE_C++ $[COMPILE_C] + +#defer STATIC_LIB_C lib /nologo $[sources] /OUT:"$[osfilename $[target]]" +#defer STATIC_LIB_C++ $[STATIC_LIB_C] + +#defer SHARED_LIB_C link /nologo /dll $[LDFLAGS_OPT$[OPTIMIZE]] $[sources] $[decygwin %,/LIBPATH:"%",$[lpath]] $[patsubst %.lib,%.lib,%,lib%.lib,$[libs]] /OUT:"$[osfilename $[target]]" +#defer SHARED_LIB_C++ $[SHARED_LIB_C] + +#defer LINK_BIN_C link /nologo $[LDFLAGS_OPT$[OPTIMIZE]] $[sources] $[decygwin %,/LIBPATH:"%",$[lpath]] $[patsubst %.lib,%.lib,%,lib%.lib,$[libs]] /OUT:"$[osfilename $[target]]" +#defer LINK_BIN_C++ $[LINK_BIN_C] diff --git a/dtool/pptempl/Template.gmsvc.pp b/dtool/pptempl/Template.gmsvc.pp new file mode 100644 index 0000000000..9f166d5f7c --- /dev/null +++ b/dtool/pptempl/Template.gmsvc.pp @@ -0,0 +1,823 @@ +// +// Template.gmsvc.pp +// +// This file defines the set of output files that will be generated to +// support a makefile build system invoking Microsoft's Visual C++ +// command-line compiler, similar to Template.msvc.pp, but using +// Cygwin's GNU make instead of Microsoft's nmake. +// + +// Before this file is processed, the following files are read and +// processed (in order): + +// The Package.pp file in the root of the current source hierarchy +// (e.g. $PANDA/Package.pp) +// $DTOOL/Package.pp +// $DTOOL/Config.pp +// $DTOOL/Config.Platform.pp +// $DTOOL/pptempl/System.pp +// The user's PPREMAKE_CONFIG file. +// $DTOOL/pptempl/Global.pp +// $DTOOL/pptempl/Global.msvc.pp +// All of the Sources.pp files in the current source hierarchy +// $DTOOL/Depends.pp, once for each Sources.pp file +// Template.msvc.pp (this file), once for each Sources.pp file + + +////////////////////////////////////////////////////////////////////// +#if $[or $[eq $[DIR_TYPE], src],$[eq $[DIR_TYPE], metalib]] +////////////////////////////////////////////////////////////////////// +// For a source directory, build a single Makefile with rules to build +// each target. + +// This is the real set of lib_targets we'll be building. On Windows, +// we don't build the shared libraries which are included on metalibs. +#define real_lib_targets +#define deferred_objs +#forscopes lib_target + #if $[eq $[module $[TARGET],$[TARGET]],] + // This library is not on a metalib, so we can build it. + #set real_lib_targets $[real_lib_targets] $[TARGET] + #else + // This library is on a metalib, so we can't build it, but we + // should build all the obj's that go into it. + #set deferred_objs $[deferred_objs] \ + $[patsubst %.c %.cxx %.yxx %.lxx,$[so_dir]/%.obj,%,,$[get_sources] $[get_igateoutput]] + #endif +#end lib_target + +// We need to know the various targets we'll be building. +// $[lib_targets] will be the list of dynamic libraries, +// $[static_lib_targets] the list of static libraries, and +// $[bin_targets] the list of binaries. $[test_bin_targets] is the +// list of binaries that are to be built only when specifically asked +// for. +#define lib_targets $[patsubst %,$[so_dir]/lib%$[dllext].dll,$[active_target(metalib_target noinst_lib_target)] $[real_lib_targets]] +#define static_lib_targets $[active_target(static_lib_target ss_lib_target):%=$[st_dir]/lib%$[dllext].lib] +#define bin_targets \ + $[active_target(bin_target noinst_bin_target):%=$[st_dir]/%.exe] \ + $[active_target(sed_bin_target):%=$[st_dir]/%] +#define test_bin_targets $[active_target(test_bin_target):%=$[st_dir]/%.exe] + +// And these variables will define the various things we need to +// install. +#define install_lib $[active_target(metalib_target static_lib_target ss_lib_target)] $[real_lib_targets] +#define install_bin $[active_target(bin_target)] +#define install_scripts $[sort $[INSTALL_SCRIPTS(metalib_target lib_target static_lib_target ss_lib_target bin_target)] $[INSTALL_SCRIPTS]] +#define install_headers $[sort $[INSTALL_HEADERS(metalib_target lib_target static_lib_target ss_lib_target bin_target)] $[INSTALL_HEADERS]] +#define install_parser_inc $[sort $[INSTALL_PARSER_INC]] +#define install_data $[sort $[INSTALL_DATA(metalib_target lib_target static_lib_target ss_lib_target bin_target)] $[INSTALL_DATA]] +#define install_config $[sort $[INSTALL_CONFIG(metalib_target lib_target static_lib_target ss_lib_target bin_target)] $[INSTALL_CONFIG]] +#define install_igatedb $[sort $[get_igatedb(metalib_target lib_target)]] + +// $[so_sources] is the set of sources that belong on a shared object, +// and $[st_sources] is the set of sources that belong on a static +// object, like a static library or an executable. In Windows, we +// don't need to make this distinction, but we do anyway in case we +// might in the future for some nutty reason. +#define so_sources $[get_sources(metalib_target lib_target noinst_lib_target)] +#define st_sources $[get_sources(static_lib_target ss_lib_target bin_target noinst_bin_target test_bin_target)] + +// These are the source files that our dependency cache file will +// depend on. If it's an empty list, we won't bother writing rules to +// freshen the cache file. +#define dep_sources $[sort $[filter %.c %.cxx %.yxx %.lxx %.h %.I,$[so_sources] $[st_sources]]] + +#if $[eq $[so_dir],$[st_dir]] + // If the static and shared directories are the same, we have to use the + // same rules to build both shared and static targets. + #set st_sources $[so_sources] $[st_sources] + #set so_sources +#endif + +// And these are the various source files, extracted out by type. +#define cxx_so_sources $[filter %.cxx,$[so_sources]] +#define cxx_st_sources $[filter %.cxx,$[st_sources]] +#define c_so_sources $[filter %.c,$[so_sources]] +#define c_st_sources $[filter %.c,$[st_sources]] +#define yxx_so_sources $[filter %.yxx,$[so_sources]] +#define yxx_st_sources $[filter %.yxx,$[st_sources]] +#define lxx_so_sources $[filter %.lxx,$[so_sources]] +#define lxx_st_sources $[filter %.lxx,$[st_sources]] + +// This map variable gets us all the various source files from all the +// targets in this directory. We need it to look up the context in +// which to build a particular source file, since some targets may +// have different requirements (e.g. different local_libs, or +// different USE_this or USE_that) than other targets. +#map all_sources get_sources(metalib_target lib_target noinst_lib_target static_lib_target ss_lib_target bin_target noinst_bin_target test_bin_target) + +// We define $[complete_local_libs] as the full set of libraries (from +// within this tree) that we must link a particular target with. It +// is the transitive closure of our dependent libs: the libraries we +// depend on, plus the libraries *those* libraries depend on, and so +// on. +#defer complete_local_libs $[unique $[closure all_libs,$[active_libs]]] +#defer actual_local_libs $[get_metalibs $[TARGET],$[complete_local_libs]] + +// And $[complete_ipath] is the list of directories (from within this +// tree) we should add to our -I list. It's basically just one for +// each directory named in the $[complete_local_libs], above, plus +// whatever else the user might have explicitly named in +// $[LOCAL_INCS]. +#defer complete_ipath $[all_libs $[RELDIR],$[complete_local_libs]] $[RELDIR($[LOCAL_INCS:%=%/])] + +// $[target_ipath] is the proper ipath to put on the command line, +// from the context of a particular target. +#defer target_ipath $[TOPDIR] $[sort $[complete_ipath]] $[other_trees:%=%/include] $[get_ipath] + +// $[file_ipath] is the ipath from the context of a particular source +// file, given in $[file]. It uses the all_sources map to look up +// the target the source file belongs on, to get the proper context. +#defer file_ipath $[all_sources $[target_ipath],$[file]] + +// These are the complete set of extra flags the compiler requires, +// from the context of a particular file, given in $[file]. +#defer cflags $[all_sources $[get_cflags] $[CFLAGS],$[file]] $[CFLAGS_OPT$[OPTIMIZE]] $[if $[>= $[OPTIMIZE],2],$[OPTFLAGS]] +#defer c++flags $[all_sources $[get_cflags] $[C++FLAGS],$[file]] $[CFLAGS_OPT$[OPTIMIZE]] $[if $[>= $[OPTIMIZE],2],$[OPTFLAGS]] + +// These are the same flags, sans the compiler optimizations. +#defer noopt_c++flags $[all_sources $[get_cflags] $[C++FLAGS],$[file]] $[CFLAGS_OPT$[OPTIMIZE]] + +// $[complete_lpath] is rather like $[complete_ipath]: the list of +// directories (from within this tree) we should add to our -L list. +#defer complete_lpath $[static_libs $[RELDIR:%=%/$[st_dir]],$[actual_local_libs]] $[dynamic_libs $[RELDIR:%=%/$[so_dir]],$[actual_local_libs]] + +// $[lpath] is like $[target_ipath]: it's the list of directories we +// should add to our -L list, from the context of a particular target. +#defer lpath $[sort $[complete_lpath]] $[other_trees:%=%/lib] $[get_lpath] + +// And $[libs] is the set of libraries we will link with. +#defer libs $[unique $[actual_local_libs:%=%$[dllext]] $[patsubst %:c,,%:m %,%$[dllext],$[OTHER_LIBS]] $[get_libs]] + +// Okay, we're ready. Start outputting the Makefile now. +#output Makefile +#format makefile +#### Generated automatically by $[PPREMAKE] $[PPREMAKE_VERSION] from $[SOURCEFILE]. +################################# DO NOT EDIT ########################### + + +// The 'all' rule makes all the stuff in the directory except for the +// test_bin_targets. It doesn't do any installation, however. +#define all_targets \ + Makefile \ + $[if $[dep_sources],$[DEPENDENCY_CACHE_FILENAME]] \ + $[if $[so_sources],$[so_dir]] \ + $[if $[st_sources],$[st_dir]] \ + $[sort $[lib_targets] $[static_lib_targets] $[bin_targets]] \ + $[deferred_objs] +all : $[all_targets] + +// The 'test' rule makes all the test_bin_targets. +test : $[test_bin_targets] + +// We implement 'clean' simply by removing the odirs, since all of our +// generated output ends up in one or the other of these. Effective. +// It does assume that the odirs are not '.', however. +clean : +#if $[so_sources] + rm -rf $[so_dir] +#endif +#if $[st_sources] + rm -rf $[st_dir] +#endif + +// 'cleanall' is not much more thorough than 'clean': At the moment, +// it also cleans up the bison and flex output, as well as the +// dependency cache file. +cleanall : clean +#if $[yxx_so_sources] $[yxx_st_sources] $[lxx_so_sources] $[lxx_st_sources] + rm -f $[patsubst %.yxx %.lxx,%.cxx,$[yxx_so_sources] $[yxx_st_sources] $[lxx_so_sources] $[lxx_st_sources]] +#endif +#if $[ne $[DEPENDENCY_CACHE_FILENAME],] + rm -f $[DEPENDENCY_CACHE_FILENAME] +#endif + +// Now, 'install' and 'uninstall'. These simply copy files into the +// install directory (or remove them). The 'install' rule also makes +// the directories if necessary. +#define installed_files \ + $[INSTALL_SCRIPTS:%=$[install_bin_dir]/%] \ + $[INSTALL_HEADERS:%=$[install_headers_dir]/%] \ + $[INSTALL_PARSER_INC:%=$[install_parser_inc_dir]/%] \ + $[INSTALL_DATA:%=$[install_data_dir]/%] \ + $[INSTALL_CONFIG:%=$[install_config_dir]/%] + +#define install_targets \ + $[sort \ + $[if $[install_lib],$[install_lib_dir]] \ + $[if $[install_bin] $[install_scripts],$[install_bin_dir]] \ + $[if $[install_headers],$[install_headers_dir]] \ + $[if $[install_parser_inc],$[install_parser_inc_dir]] \ + $[if $[install_data],$[install_data_dir]] \ + $[if $[install_config],$[install_config_dir]] \ + $[if $[install_igatedb],$[install_igatedb_dir]] \ + ] \ + $[active_target(metalib_target lib_target static_lib_target ss_lib_target):%=install-lib%] \ + $[active_target(bin_target sed_bin_target):%=install-%] \ + $[installed_files] + +install : all $[install_targets] + +uninstall : $[active_target(metalib_target lib_target static_lib_target ss_lib_target):%=uninstall-lib%] $[active_target(bin_target):%=uninstall-%] +#if $[installed_files] + rm -f $[sort $[installed_files]] +#endif + + +// We need a rule for each directory we might need to make. This +// loops through the full set of directories and creates a rule to +// make each one, as needed. +#foreach directory $[sort \ + $[if $[so_sources],$[so_dir]] \ + $[if $[st_sources],$[st_dir]] \ + $[if $[install_lib],$[install_lib_dir]] \ + $[if $[install_bin] $[install_scripts],$[install_bin_dir]] \ + $[if $[install_headers],$[install_headers_dir]] \ + $[if $[install_parser_inc],$[install_parser_inc_dir]] \ + $[if $[install_data],$[install_data_dir]] \ + $[if $[install_config],$[install_config_dir]] \ + $[if $[install_igatedb],$[install_igatedb_dir]] \ + ] +$[directory] : + @test -d $[directory] || echo mkdir -p $[directory] + @test -d $[directory] || mkdir -p $[directory] +#end directory + + +// Now it's time to start generating the rules to make our actual +// targets. + + +///////////////////////////////////////////////////////////////////// +// First, the dynamic libraries. Each lib_target and metalib_target +// is a dynamic library. +///////////////////////////////////////////////////////////////////// + +#forscopes metalib_target lib_target + +// In Windows, we don't actually build all the libraries. In +// particular, we don't build any libraries that are listed on a +// metalib. Is this one such library? +#define build_it $[eq $[module $[TARGET],$[TARGET]],] + +// We might need to define a BUILDING_ symbol for win32. We use the +// BUILDING_DLL variable name, defined typically in the metalib, for +// this; but in some cases, where the library isn't part of a metalib, +// we define BUILDING_DLL directly for the target. +#define building_var $[or $[BUILDING_DLL],$[module $[BUILDING_DLL],$[TARGET]]] + +// $[igatescan] is the set of C++ headers and source files that we +// need to scan for interrogate. $[igateoutput] is the name of the +// generated .cxx file that interrogate will produce (and which we +// should compile into the library). $[igatedb] is the name of the +// generated .in file that interrogate will produce (and which should +// be installed into the /etc directory). +#define igatescan $[get_igatescan] +#define igateoutput $[get_igateoutput] +#define igatedb $[get_igatedb] + +// If this is a metalib, it may have a number of components that +// include interrogated interfaces. If so, we need to generate a +// 'module' file within this library. This is mainly necessary for +// Python; it contains a table of all of the interrogated functions, +// so we can load the library as a Python module and have access to +// the interrogated functions. + +// $[igatemscan] is the set of .in files generated by all of our +// component libraries. If it is nonempty, then we do need to +// generate a module, and $[igatemout] is the name of the .cxx file +// that interrogate will produce to make this module. +#define igatemscan $[components $[get_igatedb:%=$[RELDIR]/$[so_dir]/%],$[active_component_libs]] +#define igatemout $[if $[igatemscan],lib$[TARGET]_module.cxx] + +#if $[build_it] + // Now output the rule to actually link the library from all of its + // various .obj files. + #define sources \ + $[unique $[patsubst %.cxx %.c %.yxx %.lxx,$[so_dir]/%.obj,%,,$[get_sources] $[igateoutput] $[igatemout]]] \ + $[components $[unique $[patsubst %.cxx %.c %.yxx %.lxx,$[RELDIR]/$[so_dir]/%.obj,%,,$[get_sources] $[get_igateoutput]]],$[active_component_libs]] + #define varname $[subst -,_,lib$[TARGET]_so] +$[varname] = $[sources] + #define target $[so_dir]/lib$[TARGET]$[dllext].dll + #define sources $($[varname]) +$[target] : $[sources] + #if $[filter %.cxx %.yxx %.lxx,$[get_sources]] + $[SHARED_LIB_C++] + #else + $[SHARED_LIB_C] + #endif +#endif + +// Here are the rules to install and uninstall the library and +// everything that goes along with it. +#define installed_files \ + $[if $[build_it], \ + $[install_lib_dir]/lib$[TARGET]$[dllext].dll \ + $[install_lib_dir]/lib$[TARGET]$[dllext].lib \ + ] \ + $[INSTALL_SCRIPTS:%=$[install_bin_dir]/%] \ + $[INSTALL_HEADERS:%=$[install_headers_dir]/%] \ + $[INSTALL_DATA:%=$[install_data_dir]/%] \ + $[INSTALL_CONFIG:%=$[install_config_dir]/%] \ + $[igatedb:%=$[install_igatedb_dir]/%] + +install-lib$[TARGET] : $[installed_files] + +uninstall-lib$[TARGET] : +#if $[installed_files] + rm -f $[sort $[installed_files]] +#endif + +$[install_lib_dir]/lib$[TARGET]$[dllext].dll : $[so_dir]/lib$[TARGET]$[dllext].dll +#define local lib$[TARGET]$[dllext].dll +#define dest $[install_lib_dir] + cp $[so_dir]/$[local] $[dest] + +$[install_lib_dir]/lib$[TARGET]$[dllext].lib : $[so_dir]/lib$[TARGET]$[dllext].lib +#define local lib$[TARGET]$[dllext].lib +#define dest $[install_lib_dir] + cp $[so_dir]/$[local] $[dest] + +#if $[igatescan] +// Now, some additional rules to generate and compile the interrogate +// data, if needed. + +// The library name is based on this library. +#define igatelib lib$[TARGET] +// The module name comes from the metalib that includes this library. +#define igatemod $[module $[TARGET],$[TARGET]] +#if $[eq $[igatemod],] + // Unless no metalib includes this library. + #define igatemod $[TARGET] +#endif + +$[install_igatedb_dir]/$[igatedb] : $[so_dir]/$[igatedb] +#define local $[igatedb] +#define dest $[install_igatedb_dir] + cp $[so_dir]/$[local] $[dest] + +lib$[TARGET]_igatescan = $[igatescan] +$[so_dir]/$[igatedb] $[so_dir]/$[igateoutput] : $[filter-out %.c %.cxx,$[igatescan]] +// We use forward slash for interrogate because it prefers those. + interrogate -od $[so_dir]/$[igatedb] -oc $[so_dir]/$[igateoutput] $[interrogate_options] -module "$[igatemod]" -library "$[igatelib]" $(lib$[TARGET]_igatescan) + +#define target $[igateoutput:%.cxx=$[so_dir]/%.obj] +#define source $[so_dir]/$[igateoutput] +#define ipath . $[target_ipath] +#define flags $[get_cflags] $[C++FLAGS] $[CFLAGS_OPT$[OPTIMIZE]] $[CFLAGS_SHARED] $[building_var:%=/D%] +$[target] : $[source] + $[COMPILE_C++] +#endif // $[igatescan] + +#if $[igatemout] +// And finally, some additional rules to build the interrogate module +// file into the library, if this is a metalib that includes +// interrogated components. + +#define igatelib lib$[TARGET] +#define igatemod $[TARGET] + +lib$[TARGET]_igatemscan = $[igatemscan] +#define target $[so_dir]/$[igatemout] +#define sources $(lib$[TARGET]_igatemscan) +$[target] : $[sources] + interrogate_module -oc $[target] -module "$[igatemod]" -library "$[igatelib]" -python $[sources] + +#define target $[igatemout:%.cxx=$[so_dir]/%.obj] +#define source $[so_dir]/$[igatemout] +#define ipath . $[target_ipath] +#define flags $[get_cflags] $[C++FLAGS] $[CFLAGS_OPT$[OPTIMIZE]] $[CFLAGS_SHARED] $[building_var:%=/D%] +$[target] : $[source] + $[COMPILE_C++] +#endif // $[igatescan] + +#end metalib_target lib_target + + + + +///////////////////////////////////////////////////////////////////// +// Now, the noninstalled dynamic libraries. These are presumably used +// only within this directory, or at the most within this tree, and +// also presumably will never include interrogate data. That, plus +// the fact that we don't need to generate install rules, makes it a +// lot simpler. +///////////////////////////////////////////////////////////////////// + +#forscopes noinst_lib_target +#define varname $[subst -,_,lib$[TARGET]_so] +$[varname] = $[unique $[patsubst %.cxx %.c %.yxx %.lxx,$[so_dir]/%.obj,%,,$[get_sources]]] +#define target $[so_dir]/lib$[TARGET]$[dllext].dll +#define sources $($[varname]) +$[target] : $[sources] +#if $[filter %.cxx %.yxx %.lxx,$[get_sources]] + $[SHARED_LIB_C++] +#else + $[SHARED_LIB_C] +#endif + +#end noinst_lib_target + + + +///////////////////////////////////////////////////////////////////// +// Now the static libraries. Again, we assume there's no interrogate +// interfaces going on in here, and there's no question of this being +// a metalib, making the rules relatively simple. +///////////////////////////////////////////////////////////////////// + +#forscopes static_lib_target ss_lib_target +#define varname $[subst -,_,lib$[TARGET]_a] +$[varname] = $[unique $[patsubst %.cxx %.c %.yxx %.lxx,$[st_dir]/%.obj,%,,$[get_sources]]] +#define target $[st_dir]/lib$[TARGET]$[dllext].lib +#define sources $($[varname]) +$[target] : $[sources] +#if $[filter %.cxx %.yxx %.lxx,$[get_sources]] + $[STATIC_LIB_C++] +#else + $[STATIC_LIB_C] +#endif + +#define installed_files \ + $[install_lib_dir]/lib$[TARGET]$[dllext].lib \ + $[INSTALL_SCRIPTS:%=$[install_bin_dir]/%] \ + $[INSTALL_HEADERS:%=$[install_headers_dir]/%] \ + $[INSTALL_DATA:%=$[install_data_dir]/%] \ + $[INSTALL_CONFIG:%=$[install_config_dir]/%] + +install-lib$[TARGET] : $[installed_files] + +uninstall-lib$[TARGET] : +#if $[installed_files] + rm -f $[sort $[installed_files]] +#endif + +$[install_lib_dir]/lib$[TARGET]$[dllext].lib : $[st_dir]/lib$[TARGET]$[dllext].lib +#define local lib$[TARGET]$[dllext].lib +#define dest $[install_lib_dir] + cp $[st_dir]/$[local] $[dest] + +#end static_lib_target ss_lib_target + + + +///////////////////////////////////////////////////////////////////// +// The sed_bin_targets are a special bunch. These are scripts that +// are to be preprocessed with sed before being installed, for +// instance to insert a path or something in an appropriate place. +///////////////////////////////////////////////////////////////////// + +#forscopes sed_bin_target +$[TARGET] : $[st_dir]/$[TARGET] + +#define target $[st_dir]/$[TARGET] +#define source $[SOURCE] +#define script $[COMMAND] +$[target] : $[source] + $[SED] + chmod +x $[target] + +#define installed_files \ + $[install_bin_dir]/$[TARGET] + +install-$[TARGET] : $[installed_files] + +uninstall-$[TARGET] : +#if $[installed_files] + rm -f $[sort $[installed_files]] +#endif + +#define local $[TARGET] +#define dest $[install_bin_dir] +$[install_bin_dir]/$[TARGET] : $[st_dir]/$[TARGET] + cp $[st_dir]/$[local] $[dest] + +#end sed_bin_target + + +///////////////////////////////////////////////////////////////////// +// And now, the bin_targets. These are normal C++ executables. No +// interrogate, metalibs, or any such nonsense here. +///////////////////////////////////////////////////////////////////// + +#forscopes bin_target +$[TARGET] : $[st_dir]/$[TARGET].exe + +#define varname $[subst -,_,bin_$[TARGET]] +$[varname] = $[unique $[patsubst %.cxx %.c %.yxx %.lxx,$[st_dir]/%.obj,%,,$[get_sources]]] +#define target $[st_dir]/$[TARGET].exe +#define sources $($[varname]) +#define ld $[get_ld] +$[target] : $[sources] +#if $[ld] + // If there's a custom linker defined for the target, we have to use it. + $[ld] -o $[target] $[sources] $[lpath:%=-L%] $[libs:%=-l%] +#else + // Otherwise, we can use the normal linker. + #if $[filter %.cxx %.yxx %.lxx,$[get_sources]] + $[LINK_BIN_C++] + #else + $[LINK_BIN_C] + #endif +#endif + +#define installed_files \ + $[install_bin_dir]/$[TARGET].exe \ + $[INSTALL_SCRIPTS:%=$[install_bin_dir]/%] \ + $[INSTALL_HEADERS:%=$[install_headers_dir]/%] \ + $[INSTALL_DATA:%=$[install_data_dir]/%] \ + $[INSTALL_CONFIG:%=$[install_config_dir]/%] + +install-$[TARGET] : $[installed_files] + +uninstall-$[TARGET] : +#if $[installed_files] + rm -f $[sort $[installed_files]] +#endif + +$[install_bin_dir]/$[TARGET].exe : $[st_dir]/$[TARGET].exe +#define local $[TARGET].exe +#define dest $[install_bin_dir] + cp $[st_dir]/$[local] $[dest] + +#end bin_target + + + +///////////////////////////////////////////////////////////////////// +// The noinst_bin_targets and the test_bin_targets share the property +// of being built (when requested), but having no install rules. +///////////////////////////////////////////////////////////////////// + +#forscopes noinst_bin_target test_bin_target +$[TARGET] : $[st_dir]/$[TARGET].exe + +#define varname $[subst -,_,bin_$[TARGET]] +$[varname] = $[unique $[patsubst %.cxx %.c %.yxx %.lxx,$[st_dir]/%.obj,%,,$[get_sources]]] +#define target $[st_dir]/$[TARGET].exe +#define sources $($[varname]) +$[target] : $[sources] +#if $[filter %.cxx %.yxx %.lxx,$[get_sources]] + $[LINK_BIN_C++] +#else + $[LINK_BIN_C] +#endif + +#end noinst_bin_target test_bin_target + + + + +///////////////////////////////////////////////////////////////////// +// Finally, we put in the rules to compile each source file into a .obj +// file. +///////////////////////////////////////////////////////////////////// + +// Rules to generate a C++ file from a Bison input file. +#foreach file $[sort $[yxx_so_sources] $[yxx_st_sources]] +#define target $[patsubst %.yxx,%.cxx,$[file]] +#define source $[file] +$[target] : $[source] + $[BISON] $[YFLAGS] -y $[if $[YACC_PREFIX],-d --name-prefix=$[YACC_PREFIX]] $[source] + mv y.tab.c $[target] + mv y.tab.h $[patsubst %.yxx,%.h,$[source]] + +#end file + +// Rules to generate a C++ file from a Flex input file. +#foreach file $[sort $[lxx_so_sources] $[lxx_st_sources]] +#define target $[patsubst %.lxx,%.cxx,$[file]] +#define source $[file] +$[target] : $[source] + $[FLEX] $[LFLAGS] $[if $[YACC_PREFIX],-P$[YACC_PREFIX]] -olex.yy.c $[source] +#define source lex.yy.c +#define script /#include /d + $[SED] + rm $[source] + +#end file + +// Rules to compile ordinary C files that appear on a shared library. +#foreach file $[sort $[c_so_sources]] +#define target $[patsubst %.c,$[so_dir]/%.obj,$[file]] +#define source $[file] +#define ipath $[file_ipath] +#define flags $[cflags] $[CFLAGS_SHARED] $[all_sources $[building_var:%=/D%],$[file]] +$[target] : $[source] $[dependencies $[source]] + $[COMPILE_C] + +#end file + +// Rules to compile ordinary C files that appear on a static library +// or in an executable. +#foreach file $[sort $[c_st_sources]] +#define target $[patsubst %.c,$[st_dir]/%.obj,$[file]] +#define source $[file] +#define ipath $[file_ipath] +#define flags $[cflags] $[all_sources $[building_var:%=/D%],$[file]] +$[target] : $[source] $[dependencies $[source]] + $[COMPILE_C] + +#end file + +// Rules to compile C++ files that appear on a shared library. +#foreach file $[sort $[cxx_so_sources]] +#define target $[patsubst %.cxx,$[so_dir]/%.obj,$[file]] +#define source $[file] +#define ipath $[file_ipath] +#define flags $[c++flags] $[CFLAGS_SHARED] $[all_sources $[building_var:%=/D%],$[file]] +// Yacc must run before some files can be compiled, so all files +// depend on yacc having run. +$[target] : $[source] $[dependencies $[file]] $[yxx_so_sources:%.yxx=%.cxx] + $[COMPILE_C++] + +#end file + +// Rules to compile C++ files that appear on a static library or in an +// executable. +#foreach file $[sort $[cxx_st_sources]] +#define target $[patsubst %.cxx,$[st_dir]/%.obj,$[file]] +#define source $[file] +#define ipath $[file_ipath] +#define flags $[c++flags] $[all_sources $[building_var:%=/D%],$[file]] +$[target] : $[source] $[dependencies $[file]] $[yxx_st_sources:%.yxx=%.cxx] + $[COMPILE_C++] + +#end file + +// Rules to compile generated C++ files that appear on a shared library. +#foreach file $[sort $[yxx_so_sources] $[lxx_so_sources]] +#define target $[patsubst %.lxx %.yxx,$[so_dir]/%.obj,$[file]] +#define source $[patsubst %.lxx %.yxx,%.cxx,$[file]] +#define ipath $[file_ipath] +#define flags $[noopt_c++flags] $[CFLAGS_SHARED] $[all_sources $[building_var:%=/D%],$[file]] +// Yacc must run before some files can be compiled, so all files +// depend on yacc having run. +$[target] : $[source] $[dependencies $[file]] $[yxx_so_sources:%.yxx=%.cxx] + $[COMPILE_C++] + +#end file + +// Rules to compile generated C++ files that appear on a static +// library or in an executable. +#foreach file $[sort $[yxx_st_sources] $[lxx_st_sources]] +#define target $[patsubst %.lxx %.yxx,$[st_dir]/%.obj,$[file]] +#define source $[patsubst %.lxx %.yxx,%.cxx,$[file]] +#define ipath $[file_ipath] +#define flags $[noopt_c++flags] $[all_sources $[building_var:%=/D%],$[file]] +$[target] : $[source] $[dependencies $[file]] $[yxx_st_sources:%.yxx=%.cxx] + $[COMPILE_C++] + +#end file + +// And now the rules to install the auxiliary files, like headers and +// data files. +#foreach file $[install_scripts] +$[install_bin_dir]/$[file] : $[file] +#define local $[file] +#define dest $[install_bin_dir] + cp $[local] $[dest] +#end file + +#foreach file $[install_headers] +$[install_headers_dir]/$[file] : $[file] +#define local $[file] +#define dest $[install_headers_dir] + cp $[local] $[dest] +#end file + +#foreach file $[install_parser_inc] +$[install_parser_inc_dir]/$[file] : $[file] +#define local $[file] +#define dest $[install_parser_inc_dir] + cp $[local] $[dest] +#end file + +#foreach file $[install_data] +$[install_data_dir]/$[file] : $[file] +#define local $[file] +#define dest $[install_data_dir] + cp $[local] $[dest] +#end file + +#foreach file $[install_config] +$[install_config_dir]/$[file] : $[file] +#define local $[file] +#define dest $[install_config_dir] + cp $[local] $[dest] +#end file + + +// Finally, the rules to freshen the Makefile itself. +Makefile : $[SOURCE_FILENAME] + ppremake + +#if $[and $[DEPENDENCY_CACHE_FILENAME],$[dep_sources]] +$[DEPENDENCY_CACHE_FILENAME] : $[dep_sources] + @ppremake -D $[DEPENDENCY_CACHE_FILENAME] +#endif + + +#end Makefile + + +////////////////////////////////////////////////////////////////////// +#elif $[eq $[DIR_TYPE], group] +////////////////////////////////////////////////////////////////////// + +// This is a group directory: a directory above a collection of source +// directories, e.g. $DTOOL/src. We don't need to output anything in +// this directory. + + + +////////////////////////////////////////////////////////////////////// +#elif $[eq $[DIR_TYPE], toplevel] +////////////////////////////////////////////////////////////////////// + +// This is the toplevel directory, e.g. $DTOOL. Here we build the +// root makefile and also synthesize the dtool_config.h (or whichever +// file) we need. + +#map subdirs +// Iterate through all of our known source files. Each src and +// metalib type file gets its corresponding Makefile listed +// here. However, we test for $[DIR_TYPE] of toplevel, because the +// source directories typically don't define their own DIR_TYPE +// variable, and they end up inheriting this one dynamically. +#forscopes */ +#if $[or $[eq $[DIR_TYPE], src],$[eq $[DIR_TYPE], metalib],$[and $[eq $[DIR_TYPE], toplevel],$[ne $[DIRNAME],top]]] +#if $[build_directory] + #addmap subdirs $[DIRNAME] +#endif +#endif +#end */ + +#output Makefile +#format makefile +#### Generated automatically by $[PPREMAKE] $[PPREMAKE_VERSION] from $[SOURCEFILE]. +################################# DO NOT EDIT ########################### + +all : $[subdirs] +test : $[subdirs:%=test-%] +clean : $[subdirs:%=clean-%] +cleanall : $[subdirs:%=cleanall-%] +install : $[if $[CONFIG_HEADER],$[install_headers_dir] $[install_headers_dir]/$[CONFIG_HEADER]] $[subdirs:%=install-%] +uninstall : $[subdirs:%=uninstall-%] +#if $[CONFIG_HEADER] + rm -f $[install_headers_dir]/$[CONFIG_HEADER] +#endif + +#formap dirname subdirs +#define depends +$[dirname] : $[dirnames $[if $[build_directory],$[DIRNAME]],$[DEPEND_DIRS]] + cd ./$[PATH]; $(MAKE) all +#end dirname + +#formap dirname subdirs +test-$[dirname] : + cd ./$[PATH]; $(MAKE) test +#end dirname + +#formap dirname subdirs +clean-$[dirname] : + cd ./$[PATH]; $(MAKE) clean +#end dirname + +#formap dirname subdirs +cleanall-$[dirname] : + cd ./$[PATH]; $(MAKE) cleanall +#end dirname + +#formap dirname subdirs +install-$[dirname] : $[patsubst %,install-%,$[dirnames $[if $[build_directory],$[DIRNAME]],$[DEPEND_DIRS]]] + cd ./$[PATH]; $(MAKE) install +#end dirname + +#formap dirname subdirs +uninstall-$[dirname] : + cd ./$[PATH]; $(MAKE) uninstall +#end dirname + +#if $[ne $[CONFIG_HEADER],] +$[install_headers_dir] : + @test -d $[install_headers_dir] || echo mkdir -p $[install_headers_dir] + @test -d $[install_headers_dir] || mkdir -p $[install_headers_dir] + +$[install_headers_dir]/$[CONFIG_HEADER] : $[CONFIG_HEADER] +#define local $[CONFIG_HEADER] +#define dest $[install_headers_dir] + cp $[local] $[dest] +#endif + +#end Makefile + +// If there is a file called LocalSetup.pp in the package's top +// directory, then invoke that. It might contain some further setup +// instructions. +#sinclude $[TOPDIRPREFIX]LocalSetup.gmsvc.pp +#sinclude $[TOPDIRPREFIX]LocalSetup.pp + +////////////////////////////////////////////////////////////////////// +#endif // DIR_TYPE diff --git a/dtool/pptempl/Template.msvc.pp b/dtool/pptempl/Template.msvc.pp index 84586c352d..7f8dbed492 100644 --- a/dtool/pptempl/Template.msvc.pp +++ b/dtool/pptempl/Template.msvc.pp @@ -297,7 +297,7 @@ $[osfilename $[directory]] : #define sources \ $[unique $[patsubst %.cxx %.c %.yxx %.lxx,$[so_dir]\%.obj,%,,$[get_sources] $[igateoutput] $[igatemout]]] \ $[components $[unique $[patsubst %.cxx %.c %.yxx %.lxx,$[RELDIR]\$[so_dir]\%.obj,%,,$[get_sources] $[get_igateoutput]]],$[active_component_libs]] -#define varname $[subst -,_,lib$[TARGET]_so] + #define varname $[subst -,_,lib$[TARGET]_so] $[varname] = $[osfilename $[sources]] #define target $[so_dir]\lib$[TARGET]$[dllext].dll #define sources $($[varname])