def Require(env): arnoldinc, arnoldlib = excons.GetDirs( "arnold", libdirname=("bin" if sys.platform != "win32" else "lib")) if arnoldinc: env.Append(CPPPATH=[arnoldinc]) if arnoldlib: env.Append(LIBPATH=[arnoldlib]) aver = Version(asString=False) if aver[0] >= 5: if sys.platform == "win32": if float(excons.mscver) < 14: excons.WarnOnce( "Arnold 5 and above require Visual Studio 2015 or newer (mscver 14.0)" ) if aver[0] >= 6: if sys.platform != "win32": if not excons.GetArgument("use-c++11", 0, int): excons.SetArgument("use-c++11", 1) if not "-std=c++11" in " ".join(env["CXXFLAGS"]): env.Append(CXXFLAGS=" -std=c++11") env.Append(LIBS=["ai"]) excons.AddHelpOptions(arnold=GetOptionsString())
def Require(env): zlibinc, zliblib = excons.GetDirs("zlib") if zlibinc: env.Append(CPPPATH=[zlibinc]) if zliblib: env.Append(LIBPATH=[zliblib]) static = (excons.GetArgument("zlib-static", 0, int) != 0) if str(Platform()) != "win32": zlib_name = excons.GetArgument("zlib-name", None) if not zlib_name: zlib_name = "%sz%s" % (excons.GetArgument( "zlib-prefix", ""), excons.GetArgument("zlib-suffix", "")) else: if static: zlib_name = excons.GetArgument("zlib-name", None) if not zlib_name: zlib_name = "zlib%s" % excons.GetArgument("zlib-suffix", "") else: zlib_name = excons.GetArgument("zlib-name", None) if not zlib_name: zlib_name = "zdll%s" % excons.GetArgument("zlib-suffix", "") env.Append(CPPDEFINES=["ZLIB_DLL"]) excons.Link(env, zlib_name, static=static, force=True, silent=True) excons.AddHelpOptions(zlib=GetOptionsString())
def Require(ilmbase=False, zlib=False): openexr_libprefix = excons.GetArgument("openexr-prefix", "") openexr_libsuffix = excons.GetArgument("openexr-suffix", "") openexr_libname = excons.GetArgument("openexr-name", "%sIlmImf%s" % (openexr_libprefix, openexr_libsuffix)) openexr_inc, openexr_lib = excons.GetDirs("openexr") if openexr_inc and not openexr_inc.endswith("OpenEXR"): openexr_inc += "/OpenEXR" openexr_static = (excons.GetArgument("openexr-static", 0, int) != 0) excons.AddHelpOptions(openexr=GetOptionsString()) def _RequireOpenEXR(env): if sys.platform == "win32" and not openexr_static: env.Append(CPPDEFINES=["OPENEXR_DLL"]) if openexr_inc: env.Append(CPPPATH=[openexr_inc, os.path.dirname(openexr_inc)]) if openexr_lib: env.Append(LIBPATH=[openexr_lib]) excons.Link(env, openexr_libname, static=openexr_static, force=True, silent=True) if ilmbase: excons.tools.ilmbase.Require()(env) if zlib: excons.tools.zlib.Require(env) return _RequireOpenEXR
def Require(env): glutinc, glutlib = excons.GetDirs("glut") if glutinc: env.Append(CPPPATH=[glutinc]) if glutlib: env.Append(LIBPATH=[glutlib]) static = (excons.GetArgument("glut-static", 0, int) != 0) libname = excons.GetArgument("glut-name", "") if not libname: libprefix = excons.GetArgument("glut-prefix", "") libsuffix = excons.GetArgument("glut-suffix", "") if sys.platform == "win32": libname = ("glut64" if excons.Build64() else "glut32") + libsuffix else: libname = "%sglut%s" % (libprefix, libsuffix) if sys.platform == "win32": env.Append(CPPDEFINES=["GLUT_NO_LIB_PRAGMA"]) env.Append(LIBS=[libname]) elif sys.platform == "darwin": env.Append(LINKFLAGS=" -framework GLUT") else: excons.Link(env, libname, static=static, force=True, silent=True) excons.AddHelpOptions(glut=GetOptionsString())
def Require(env): szip_inc, szip_lib = excons.GetDirs("szip") if szip_inc: env.Append(CPPPATH=[szip_inc]) if szip_lib: env.Append(LIBPATH=[szip_lib]) szip_static = (excons.GetArgument("szip-static", 0, int) != 0) if not szip_static: env.Append(CPPDEFINES=["SZ_BUILT_AS_DYNAMIC_LIB"]) szip_libname = excons.GetArgument("szip-name", None) if not szip_libname: szip_libprefix = excons.GetArgument("szip-prefix", "") szip_libsuffix = excons.GetArgument("szip-suffix", "") szip_libname = "%s%s%s" % (szip_libprefix, ("sz" if sys.platform != "win32" else "libszip"), szip_libsuffix) excons.Link(env, szip_libname, static=szip_static, force=True, silent=True) excons.AddHelpOptions(szip=GetOptionsString())
def Require(env): excons.AddHelpOptions(houdini=GetOptionsString()) ver, hfs = GetVersionAndDirectory(noexc=True) if not ver or not hfs: return # Call hcustom -c, hcustom -m to setup compile and link flags hcustomenv = os.environ.copy() hcustomenv["HFS"] = hfs if sys.platform == "win32": # Oldver version of hcustom on windows require MSVCDir to be set cmntools = "VS%sCOMNTOOLS" % env["MSVC_VERSION"].replace(".", "") if cmntools in hcustomenv: cmntools = hcustomenv[cmntools] if cmntools.endswith("\\") or cmntools.endswith("/"): cmntools = cmntools[:-1] cmntools = excons.joinpath(os.path.split(os.path.split(cmntools)[0])[0], "VC") hcustomenv["MSVCDir"] = cmntools hcustom = "%s/bin/hcustom" % hfs cmd = "\"%s\" -c" % hcustom p = subprocess.Popen(cmd, shell=True, env=hcustomenv, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, _ = p.communicate() ccflags = out.strip() if not "DLLEXPORT" in ccflags: if sys.platform == "win32": ccflags += ' /DDLLEXPORT="__declspec(dllexport)"' else: ccflags += ' -DDLLEXPORT=' if sys.platform != "win32": if int(ver.split(".")[0]) >= 14: if not "-std=c++11" in ccflags: ccflags += ' -DBOOST_NO_DEFAULTED_FUNCTIONS -DBOOST_NO_DELETED_FUNCTIONS' cmd = "\"%s\" -m" % hcustom p = subprocess.Popen(cmd, shell=True, env=hcustomenv, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, _ = p.communicate() linkflags = out.strip() if sys.platform == "win32": linkflags = re.sub(r"-link\s+", "", linkflags) elif sys.platform != "darwin": # On linux, $HFS/dsolib doesn't seem appear in linkflags linkflags += " -L %s/dsolib" % hfs else: # On OSX, linkflags does not provide frameworks or libraries to link libs = ["HoudiniUI", "HoudiniOPZ", "HoudiniOP3", "HoudiniOP2", "HoudiniOP1", "HoudiniSIM", "HoudiniGEO", "HoudiniPRM", "HoudiniUT"] libdir = "%s/Libraries" % "/".join(hfs.split("/")[:-1]) linkflags += " -flat_namespace -L %s -l%s" % (libdir, " -l".join(libs)) env.Append(CXXFLAGS=" %s" % ccflags) env.Append(LINKFLAGS=" %s" % linkflags)
def Require(e, ignoreLinkFlags=False): po = excons.GetArgument("with-python") if po is not None: rv = _GetPythonSpec(po) if rv is not None: ver, incdir, libdir, lib = rv plat = str(SCons.Script.Platform()) e.Append(CCFLAGS=" -DPY_VER=%s" % ver) e.Append(CPPPATH=[incdir]) if not ignoreLinkFlags: if plat == "darwin": if libdir: e.Append(LINKFLAGS=" -F%s -framework %s" % (libdir, lib)) else: e.Append(LINKFLAGS=" %s" % lib) else: e.Append(LIBPATH=[libdir]) e.Append(LIBS=[lib]) return # Default settings: use the python that this script runs on pyver = distutils.sysconfig.get_python_version() e.Append(CCFLAGS=" -DPY_VER=%s" % pyver) e.Append(CPPPATH=[distutils.sysconfig.get_python_inc()]) if distutils.sysconfig.get_config_var("PYTHONFRAMEWORK"): if not ignoreLinkFlags: fwdir = distutils.sysconfig.get_config_var("PYTHONFRAMEWORKPREFIX") fwname = distutils.sysconfig.get_config_var("PYTHONFRAMEWORK") if _GetPythonVersionOSX("%s/%s.framework" % (fwdir, fwname)) != pyver: e.Append(LINKFLAGS=" %s/%s.framework/Versions/%s/%s" % (fwdir, fwname, pyver, fwname)) else: e.Append(LINKFLAGS=" -F%s -framework %s" % (fwdir, fwname)) else: if str(SCons.Script.Platform()) == "win32": e.Append(LIBPATH=[distutils.sysconfig.PREFIX + '\\libs']) e.Append(LIBS=["python%s" % pyver.replace(".", "")]) else: e.Append(CCFLAGS=" %s" % distutils.sysconfig.get_config_var("CFLAGS")) if not ignoreLinkFlags: e.Append(LINKFLAGS=" %s" % distutils.sysconfig.get_config_var("LINKFORSHARED")) e.Append(LIBS=["python%s" % pyver]) excons.AddHelpOptions(python=GetOptionsString())
def _RequireLLVM(env): env.Append(CPPFLAGS=cfg["cppflags"]) if "incdir" in cfg: env.Append(CPPPATH=[cfg["incdir"]]) if "libdir" in cfg: env.Append(LIBPATH=[cfg["libdir"]]) for lib in cfg["libs"]: excons.Link(env, lib, static=True, force=True, silent=False) env.Append(LIBS=cfg["syslibs"]) excons.AddHelpOptions(llvm=GetOptionsString())
def Require(env): mtoa_inc, mtoa_lib = excons.GetDirs("mtoa", libdirname=("lib" if sys.platform == "win32" else "bin")) if sys.platform == "darwin": env.Append(CPPDEFINES=["_DARWIN"]) elif sys.platform == "win32": env.Append(CPPDEFINES=["_WIN32"]) else: env.Append(CPPDEFINES=["_LINUX"]) env.Append(CPPPATH=[mtoa_inc]) env.Append(LIBPATH=[mtoa_lib]) excons.Link(env, "mtoa_api", static=False, force=True, silent=True) excons.AddHelpOptions(mtoa=GetOptionsString())
def Require(env): arnoldinc, arnoldlib = excons.GetDirs("arnold", libdirname=("bin" if sys.platform != "win32" else "lib")) if arnoldinc: env.Append(CPPPATH=[arnoldinc]) if arnoldlib: env.Append(LIBPATH=[arnoldlib]) env.Append(LIBS=["ai"]) excons.AddHelpOptions(arnold=GetOptionsString())
def Require(env): excons.AddHelpOptions(maya=GetOptionsString()) mayadir = GetMayaRoot() if not mayadir: return env.Append(CPPPATH=[GetMayaInc(mayadir)]) env.Append(CPPDEFINES=["REQUIRE_IOSTREAM", "_BOOL"]) if sys.platform == "darwin": env.Append(CPPDEFINES=["OSMac_"]) env.Append(CPPFLAGS=" -Wno-unused-private-field") env.Append(LIBPATH=["%s/Maya.app/Contents/MacOS" % mayadir]) mach = "%s/maya/OpenMayaMac.h" % GetMayaInc(mayadir) if os.path.isfile(mach): env.Append(CCFLAGS=" -include \"%s\" -fno-gnu-keywords" % mach) maya_ver = Version(asString=False, nice=True) if maya_ver: # Starting Maya 2017, on osx libc++ is used instead of libstdc++ # Before this version, and unless explicitely overridden by 'use-c++11=' command line flag, use c++0x and libstdc++ if maya_ver < 2017: excons.WarnOnce( "Maya below 2017 requires linking against libstdc++.\nThis can be done using by using the command line flag 'use-stdc++=1'.", tool="maya") # Starting Maya 2018, Maya API is using C++11 standard if maya_ver >= 2018: env.Append(CPPFLAGS=" -std=c++11") else: env.Append(LIBPATH=["%s/lib" % mayadir]) if sys.platform == "win32": env.Append(CPPDEFINES=["NT_PLUGIN"]) else: maya_ver = Version(asString=False, nice=True) # Starting Maya 2018, Maya API is using C++11 standard if maya_ver and maya_ver >= 2018: env.Append(CPPFLAGS=" -std=c++11") env.Append(CPPDEFINES=["LINUX"]) env.Append( CPPFLAGS= " -fno-strict-aliasing -Wno-comment -Wno-sign-compare -funsigned-char -Wno-reorder -fno-gnu-keywords -pthread" ) env.Append(LIBS=[ "OpenMaya", "OpenMayaAnim", "OpenMayaFX", "OpenMayaRender", "OpenMayaUI", "Foundation" ])
def Require(env): glew_inc, glew_lib = excons.GetDirs("glew") glew_static = (excons.GetArgument("glew-static", 1, int) != 0) glew_no_glu = (excons.GetArgument("glew-noglu", 1, int) != 0) glew_mx = (excons.GetArgument("glew-mx", 0, int) != 0) if glew_inc: env.Append(CPPPATH=[glew_inc]) if glew_lib: env.Append(LIBPATH=[glew_lib]) defs = [] if glew_no_glu: defs.append("GLEW_NO_GLU") if glew_static: defs.append("GLEW_STATIC") if glew_mx: defs.append("GLEW_MX") env.Append(CPPDEFINES=defs) glew_libname = excons.GetArgument("glew-name", None) if not glew_libname: glew_libprefix = excons.GetArgument("glew-prefix", "") glew_libsuffix = excons.GetArgument("glew-suffix", "") glew_libname = glew_libprefix + ("glew32" if sys.platform == "win32" else "GLEW") + glew_libsuffix if glew_mx: glew_libname += "mx" if sys.platform == "win32" and glew_static: glew_libname += "s" excons.Link(env, glew_libname, static=glew_static, force=True, silent=True) excons.AddHelpOptions(glew=GetOptionsString())
def Require(env): tbbinc, tbblib = excons.GetDirs("tbb") if tbbinc: env.Append(CPPPATH=[tbbinc]) if tbblib: env.Append(LIBPATH=[tbblib]) static = (excons.GetArgument("tbb-static", 0, int) != 0) # Any specific defines? #env.Append(CPPDEFINES=[]) tbblibname = excons.GetArgument("tbb-name", None) if not tbblibname: tbblibname = "%stbb%s" % (excons.GetArgument("tbb-prefix", ""), excons.GetArgument("tbb-suffix", "")) excons.Link(env, tbblibname, static=static, force=True, silent=True) excons.AddHelpOptions(tbb=GetOptionsString())
def Require(env): fiinc, filib = excons.GetDirs("freeimage") if fiinc: env.Append(CPPPATH=[fiinc]) if filib: env.Append(LIBPATH=[filib]) static = (excons.GetArgument("freeimage-static", 0, int) != 0) if static: env.Append(CPPDEFINES=["FREEIMAGE_LIB"]) filibname = excons.GetArgument("freeimage-name", None) if not filibname: filibprefix = excons.GetArgument("freeimage-prefix", "") filibsuffix = excons.GetArgument("freeimage-suffix", "") filibname = "%sfreeimage%s" % (filibprefix, filibsuffix) excons.Link(env, filibname, static=static, force=True, silent=True) excons.AddHelpOptions(freeimage=GetOptionsString())
def Require(env): excons.AddHelpOptions(nuke=GetOptionsString()) nukespec = excons.GetArgument("with-nuke") if nukespec is None: excons.WarnOnce( "Please set Nuke version or directory using with-nuke=", tool="nuke") return idn = ("Contents/MacOS/include" if sys.platform == "darwin" else "include") ldn = ("Contents/MacOS" if sys.platform == "darwin" else "") if os.path.isdir(nukespec): if sys.platform == "darwin": bn = os.path.basename(nukespec) _, ext = os.path.splitext(bn) if ext != ".app": nukespec += "/%s.app" % bn excons.SetArgument("with-nuke", nukespec) ndkinc, ndklib = excons.GetDirs("nuke", incdirname=idn, libdirname=ldn, libdirarch="none") else: if not re.match(r"\d+\.\d+v\d+", nukespec): excons.WarnOnce("Invalid Nuke version format: \"%s\"" % nukespec, tool="nuke") return if sys.platform == "win32": ndkbase = "C:/Program Files/Nuke%s" % nukespec elif sys.platform == "darwin": ndkbase = "/Applications/Nuke%s/Nuke%s.app" % (nukespec, nukespec) else: ndkbase = "/usr/local/Nuke%s" % nukespec ndkinc = "%s/%s" % (ndkbase, idn) ndklib = "%s/%s" % (ndkbase, ldn) if ldn else ndkbase if ndkinc: env.Append(CPPPATH=[ndkinc]) if ndklib: env.Append(LIBPATH=[ndklib]) if sys.platform == "darwin": #env.Append(CCFLAGS=" -isysroot /Developer/SDKs/MacOSX10.4u.sdk") #env.Append(LINKFLAGS=" -Wl,-syslibroot,/Developer/SDKs/MacOSX10.4u.sdk") #env.Append(LINKFLAGS=" -framework QuartzCore -framework IOKit -framework CoreFoundation -framework Carbon -framework ApplicationServices -framework OpenGL -framework AGL -framework Quicktime") pass env.Append(DEFINES=["USE_GLEW"]) if sys.platform != "win32": env.Append(CCFLAGS=" -Wno-unused-variable -Wno-unused-parameter") env.Append(LIBS=["DDImage", "GLEW"]) else: env.Append(LIBS=["DDImage", "glew32"])
def _RealRequire(env): if boost_inc_dir: env.Append(CPPPATH=boost_inc_dir) if boost_lib_dir: env.Append(LIBPATH=boost_lib_dir) autolinkcount = 0 defs = [] # All libs but Boost.Python are statically linked by default # => use BOOST_PYTHON_STATIC_LIB to enable static linking # Libraries are auto-linked on windows by default # => disable for all libraries using BOOST_ALL_NO_LIB # => disable for a specific lib using BOOST_[libraryname]_NO_LIB for lib in libs: incdir = libargs[lib]["incdir"] libdir = libargs[lib]["libdir"] libname = libargs[lib]["name"] libstatic = libargs[lib]["static"] autolinklib = libargs[lib]["autolink"] if incdir: env.Append(CPPPATH=[incdir]) if libdir: env.Append(LIBPATH=[libdir]) if sys.platform == "win32": if not autolinklib: defs.append("BOOST_%s_NO_LIB" % lib.upper()) else: autolinkcount += 1 if libstatic: if lib == "thread": # Not to confure with the 'LIB' meaning of BOOST_xxx_NO_LIB defs.append("BOOST_THREAD_USE_LIB") elif lib == "python": # Boost.Python is dynamically linked by 'default' defs.append("BOOST_PYTHON_STATIC_LIB") else: # Should not have to make a special case of Boost.Thread anymore, but # for backward compatibility sake if lib == "thread": defs.append("BOOST_THREAD_USE_DLL") elif lib != "python": defs.append("BOOST_%s_DYN_LINK" % lib.upper()) if not autolinklib: excons.Link(env, libname, static=libstatic, force=True, silent=True) if sys.platform == "win32" and autolinkcount == 0: defs.append("BOOST_ALL_NO_LIB") env.Append(CPPDEFINES=defs) excons.AddHelpOptions(boost=GetOptionsString())
def Require(ilmthread=None, iexmath=None, python=None, halfonly=False): if not halfonly: if ilmthread is None: ilmthread = (excons.GetArgument("ilmbase-thread", 1, int) != 0) if iexmath is None: iexmath = (excons.GetArgument("ilmbase-iexmath", 1, int) != 0) if python is None: python = (excons.GetArgument("ilmbase-python", 0, int) != 0) else: ilmthread = False iexmath = False python = False ilmbase_libsuffix = excons.GetArgument("ilmbase-suffix", "") ilmbase_libprefix = excons.GetArgument("ilmbase-prefix", "") pyilmbase_inc, pyilmbase_lib, pyilmbase_libprefix, pyilmbase_libsuffix = "", "", "", "" if python: pyilmbase_inc, pyilmbase_lib = excons.GetDirs("ilmbase-python") if pyilmbase_inc and not pyilmbase_inc.endswith("OpenEXR"): pyilmbase_inc += "/OpenEXR" pyilmbase_libprefix = excons.GetArgument("ilmbase-python-prefix", ilmbase_libprefix) pyilmbase_libsuffix = excons.GetArgument("ilmbase-python-suffix", ilmbase_libsuffix) ilmbase_inc, ilmbase_lib = excons.GetDirs("ilmbase") if ilmbase_inc and not ilmbase_inc.endswith("OpenEXR"): ilmbase_inc += "/OpenEXR" static = (excons.GetArgument("ilmbase-static", 0, int) != 0) pystatic = static if python: pystatic = (excons.GetArgument("ilmbase-python-static", (1 if static else 0), int) != 0) excons.AddHelpOptions(ilmbase=GetOptionsString()) def _RealRequire(env): # Add python bindings first if python: if pystatic: env.Append(CPPDEFINES=["PLATFORM_BUILD_STATIC"]) if sys.platform != "win32": env.Append(CPPDEFINES=["PLATFORM_VISIBILITY_AVAILABLE"]) if pyilmbase_inc: env.Append(CPPPATH=[pyilmbase_inc, os.path.dirname(pyilmbase_inc)]) if pyilmbase_lib: env.Append(LIBPATH=[pyilmbase_lib]) excons.Link(env, "%sPyImath%s" % (pyilmbase_libprefix, pyilmbase_libsuffix), static=pystatic, silent=True) excons.Link(env, "%sPyIex%s" % (pyilmbase_libprefix, pyilmbase_libsuffix), static=pystatic, silent=True) if ilmbase_inc: env.Append(CPPPATH=[ilmbase_inc, os.path.dirname(ilmbase_inc)]) if ilmbase_lib: env.Append(LIBPATH=[ilmbase_lib]) if sys.platform == "win32" and not static: env.Append(CPPDEFINES=["OPENEXR_DLL"]) if ilmthread: # ilmthread will be False if halfonly is True libname = "%sIlmThread%s" % (ilmbase_libprefix, ilmbase_libsuffix) excons.Link(env, libname, static=static, force=True, silent=True) if not halfonly: libname = "%sImath%s" % (ilmbase_libprefix, ilmbase_libsuffix) excons.Link(env, libname, static=static, force=True, silent=True) if iexmath: # iexmath will be False if halfonly is True libname = "%sIexMath%s" % (ilmbase_libprefix, ilmbase_libsuffix) excons.Link(env, libname, static=static, force=True, silent=True) if not halfonly: libname = "%sIex%s" % (ilmbase_libprefix, ilmbase_libsuffix) excons.Link(env, libname, static=static, force=True, silent=True) libname = "%sHalf%s" % (ilmbase_libprefix, ilmbase_libsuffix) excons.Link(env, libname, static=static, force=True, silent=True) return _RealRequire
def Require(hl=False, verbose=False): global ThreadSafe_exp, Szlib_exp, Zlib_exp, hdf5_confs hdf5_inc, hdf5_lib = excons.GetDirs("hdf5") hdf5_static = (excons.GetArgument("hdf5-static", 0, int) != 0) hdf5_libname = excons.GetArgument("hdf5-name", None) if not hdf5_libname: hdf5_libprefix = excons.GetArgument("hdf5-prefix", "") hdf5_libsuffix = excons.GetArgument("hdf5-suffix", "") hdf5_basename = ("hdf5" if sys.platform != "win32" else "libhdf5") hdf5_libname = hdf5_basename + hdf5_libsuffix hdf5hl_libname = hdf5_libprefix + hdf5_basename + "_hl" + hdf5_libsuffix else: hdf5hl_libname = hdf5_libname + "_hl" def GetConf(env, incdir): h5conf = None cfg = {"threadsafe": False, "zlib": False, "szip": False} quiet = not verbose if incdir: # Note: On Fedora 14, H5pubconf.h has been renamed to H5pubconf-64.h # -> be slightly more flexible when looking up this file lst = filter(lambda x: os.path.basename(x).startswith("H5pubconf"), excons.glob(incdir + "/*.h")) if len(lst) > 0: h5conf = lst[0].replace("\\", "/") else: # Look in current include paths for d in env["CPPPATH"]: lst = filter( lambda x: os.path.basename(x).startswith("H5pubconf"), excons.glob(d + "/*.h")) if len(lst) > 0: h5conf = lst[0].replace("\\", "/") break if h5conf: if h5conf in hdf5_confs: quiet = True cfg = hdf5_confs[h5conf] else: if verbose: excons.PrintOnce("Reading configuration header '%s'..." % h5conf, tool="hdf5") f = open(h5conf, "r") for l in f.readlines(): l = l.strip() if ThreadSafe_exp.match(l): cfg["threadsafe"] = True elif Szip_exp.match(l): cfg["szip"] = True elif Zlib_exp.match(l): cfg["zlib"] = True hdf5_confs[h5conf] = cfg f.close() if not quiet: if cfg["threadsafe"]: excons.PrintOnce("Thread safe", tool="hdf5") if cfg["zlib"]: excons.PrintOnce("Using zlib", tool="hdf5") if cfg["szip"]: excons.PrintOnce("Using szip", tool="hdf5") else: excons.WarnOnce("Could not find configuration header", tool="hdf5") return (False, cfg) def _RealRequire(env): quiet, cfg = GetConf(env, hdf5_inc) if hdf5_inc: env.Append(CPPPATH=[hdf5_inc]) if hdf5_lib: env.Append(LIBPATH=[hdf5_lib]) if hl: excons.Link(env, hdf5hl_libname, static=hdf5_static, force=True, silent=True) excons.Link(env, hdf5_libname, static=hdf5_static, force=True, silent=True) if hdf5_static: if not quiet: excons.PrintOnce("Static build", tool="hdf5") if cfg["threadsafe"]: threads.Require(env) if cfg["zlib"]: if excons.GetArgument("zlib-static", None) is None: if not quiet: excons.PrintOnce("Force static zlib", tool="hdf5") excons.SetArgument("zlib-static", 1) zlib.Require(env) if cfg["szip"]: if excons.GetArgument("szip-static", None) is None: if not quiet: excons.PrintOnce("Force static szip", tool="hdf5") excons.SetArgument("szip-static", 1) szip.Require(env) excons.AddHelpOptions(hdf5=GetOptionsString()) return _RealRequire