コード例 #1
0
def checkCppUnit(env):
    try:
        cppunit_inc_path,cppunit_lib_path=findLibWithHeader(env, env['cppunit_libs'], 'cppunit/TestFixture.h', env['cppunit_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [cppunit_inc_path])
        env.AppendUnique(LIBPATH = [cppunit_lib_path])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], cppunit_lib_path)
        env['cppunit']=True
    except:
        env['cppunit']=False
    return env
コード例 #2
0
def checkCUDA(env):
    try:
        cuda_inc_path,cuda_lib_path=findLibWithHeader(env, 'cudart', 'thrust/version.h', env['cuda_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [cuda_inc_path])
        env.AppendUnique(LIBPATH = [cuda_lib_path])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], cuda_lib_path)
        env.Append(CPPDEFINES = ['ESYS_HAVE_CUDA'])
        env['cuda']=True
    except:
        env['cuda']=False
    return env
コード例 #3
0
def checkForTrilinos(env):
    trilinos_inc_path=''
    trilinos_lib_path=''
    if env['trilinos']:
        havelibs = (len(env['trilinos_libs']) > 0)
        trilinos_inc_path,trilinos_lib_path=findLibWithHeader(env,
                env['trilinos_libs'], 'Tpetra_CrsMatrix.hpp',
                env['trilinos_prefix'], lang='c++', try_link=havelibs)
        if not havelibs:
            packages=['Tpetra','Kokkos','Belos','Amesos2','Ifpack2','MueLu']
            libs = []
            for pk in packages:
                # find out what libraries to link with...
                makefile = os.path.join(trilinos_inc_path, 'Makefile.export.%s'%pk)
                try:
                    for l in open(makefile, 'r').readlines():
                        if l.startswith("%s_LIBRARIES"%pk): # or l.startswith("Trilinos_TPL_LIBRARIES"):
                            lst = l.split('=')[1].strip().split()
                            lst = [e.replace('-l','',1) for e in lst]
                            libs += lst
                        elif l.startswith("%s_TPL_INCLUDE_DIRS"%pk):
                            lst = l.split('=')[1].strip().split()
                            lst = [e.replace('-I','',1) for e in lst]
                            env.AppendUnique(CPPPATH = lst)

                except Exception as e:
                    raise RuntimeError('Error reading Trilinos export Makefile\n%s'%(e))
            env['trilinos_libs'] = libs

        env.AppendUnique(CPPPATH = [trilinos_inc_path])
        env.AppendUnique(LIBPATH = [trilinos_lib_path])
        env.Append(CPPDEFINES = ['ESYS_HAVE_TRILINOS'])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], trilinos_lib_path)
        env['buildvars']['trilinos_inc_path']=trilinos_inc_path
        env['buildvars']['trilinos_lib_path']=trilinos_lib_path
    env['buildvars']['trilinos']=int(env['trilinos'])
    return env
コード例 #4
0
def checkBoost(env):
    boost_inc_path,boost_lib_path=findLibWithHeader(env, env['boost_libs'], 'boost/python.hpp', env['boost_prefix'], lang='c++')
    if env['sysheaderopt'] == '':
        env.AppendUnique(CPPPATH = [boost_inc_path])
    else:
        # This is required because we can't -isystem /usr/include since it
        # breaks std includes
        if os.path.normpath(boost_inc_path) == '/usr/include':
            env.Append(CCFLAGS=[env['sysheaderopt'], os.path.join(boost_inc_path,'boost')])
        else:
            env.Append(CCFLAGS=[env['sysheaderopt'], boost_inc_path])

    env.AppendUnique(LIBPATH = [boost_lib_path])
    env.AppendUnique(LIBS = env['boost_libs'])
    env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], boost_lib_path)

    # Try to extract the boost version from version.hpp
    boosthpp=open(os.path.join(boost_inc_path, 'boost', 'version.hpp'))
    boostversion='unknown'
    for line in boosthpp:
        ver=re.match(r'#define BOOST_VERSION (\d+)',line)
        if ver:
            boostversion=ver.group(1)
            boostversion = int(boostversion)
            maj = boostversion/100000
            minor = (boostversion/100)%1000
            sub = boostversion % 100
            env['boost_version'] = "%d.%d.%d"%(maj,minor,sub)
            if maj <= REQUIRED_BOOST[0] and minor < REQUIRED_BOOST[1]:
                print("The boost version referenced must be at least version %d.%d "%REQUIRED_BOOST + "(have %d.%d.%d)"%(maj,minor,sub))
                env.Exit(1)
    boosthpp.close()
    env['buildvars']['boost_inc_path']=boost_inc_path
    env['buildvars']['boost_lib_path']=boost_lib_path
    env['buildvars']['boostversion']=boostversion
    return env
コード例 #5
0
def checkOptionalLibraries(env):
    ######## netCDF
    netcdf_inc_path=''
    netcdf_lib_path=''
    if env['netcdf']:
        if env['netcdf']==4:
            env.Append(CPPDEFINES = ['NETCDF4'])
            netcdf_inc_path,netcdf_lib_path=findLibWithHeader(env, env['netcdf_libs'], 'ncVar.h', env['netcdf_prefix'], lang='c++')
        else:
            netcdf_inc_path,netcdf_lib_path=findLibWithHeader(env, env['netcdf_libs'], 'netcdfcpp.h', env['netcdf_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [netcdf_inc_path])
        env.AppendUnique(LIBPATH = [netcdf_lib_path])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], netcdf_lib_path)
        env.Append(CPPDEFINES = ['ESYS_HAVE_NETCDF'])
        env['buildvars']['netcdf_inc_path']=netcdf_inc_path
        env['buildvars']['netcdf_lib_path']=netcdf_lib_path
    env['buildvars']['netcdf']=int(env['netcdf'])

    ######## PAPI
    papi_inc_path=''
    papi_lib_path=''
    if env['papi']:
        papi_inc_path,papi_lib_path=findLibWithHeader(env, env['papi_libs'], 'papi.h', env['papi_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [papi_inc_path])
        env.AppendUnique(LIBPATH = [papi_lib_path])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], papi_lib_path)
        env.Append(CPPDEFINES = ['ESYS_HAVE_PAPI'])
        env['buildvars']['papi_inc_path']=papi_inc_path
        env['buildvars']['papi_lib_path']=papi_lib_path
    env['buildvars']['papi']=int(env['papi'])

    ######## MKL
    mkl_inc_path=''
    mkl_lib_path=''
    if env['mkl']:
        mkl_inc_path,mkl_lib_path=findLibWithHeader(env, env['mkl_libs'], 'mkl_pardiso.h', env['mkl_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [mkl_inc_path])
        env.AppendUnique(LIBPATH = [mkl_lib_path])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], mkl_lib_path)
        env.Append(CPPDEFINES = ['ESYS_HAVE_MKL'])
        env['buildvars']['mkl_inc_path']=mkl_inc_path
        env['buildvars']['mkl_lib_path']=mkl_lib_path
    env['buildvars']['mkl']=int(env['mkl'])

    ######## UMFPACK
    umfpack_inc_path=''
    umfpack_lib_path=''
    if env['umfpack']:
        umfpack_inc_path,umfpack_lib_path=findLibWithHeader(env, env['umfpack_libs'], 'umfpack.h', env['umfpack_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [umfpack_inc_path])
        env.AppendUnique(LIBPATH = [umfpack_lib_path])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], umfpack_lib_path)
        env.Append(CPPDEFINES = ['ESYS_HAVE_UMFPACK'])
        env['buildvars']['umfpack_inc_path']=umfpack_inc_path
        env['buildvars']['umfpack_lib_path']=umfpack_lib_path
    env['buildvars']['umfpack']=int(env['umfpack'])

    ######## LAPACK
    lapack_inc_path=''
    lapack_lib_path=''
    flavour = 'none'
    env['uselapack'] = False
    if env['lapack'] != 0:
        # not explicitly disabled so run the checks
        if env['longindices']:
            # you want longindices + lapack? sorry.
            if env['lapack'] == 1:
                print("LAPACK requires index type = int. Set longindices to False or disable LAPACK.")
                env.Exit(1)
        else:
            if env['mkl']:
                # we detected MKL so try the MKL header+libs
                flavour = 'mkl'
                header = 'mkl_lapack.h'
                prefix = env['mkl_prefix']
                if len(env['lapack_libs']) == 0:
                    libs = env['mkl_libs']
                else:
                    libs = env['lapack_libs']
            else:
                # try for clapack
                flavour = 'clapack'
                header = 'clapack.h'
                prefix = env['lapack_prefix']
                if len(env['lapack_libs']) == 0:
                    libs = ['lapack_atlas']
                else:
                    libs = env['lapack_libs']

            try:
                lapack_inc_path,lapack_lib_path=findLibWithHeader(env, libs, header, prefix, lang='c++')
                env['lapack_libs'] = libs
                env['uselapack'] = True
                env.AppendUnique(CPPPATH = [lapack_inc_path])
                env.AppendUnique(LIBPATH = [lapack_lib_path])
                env.Append(CPPDEFINES = ['ESYS_HAVE_LAPACK'])
                if flavour == 'mkl':
                    env.AppendUnique(CPPDEFINES = ['ESYS_MKL_LAPACK'])
                env['buildvars']['lapack_inc_path']=lapack_inc_path
                env['buildvars']['lapack_lib_path']=lapack_lib_path
            except:
                if env['lapack'] == 1:
                    raise
                # lapack was set to auto-detect so not a fatal error
                flavour = 'none'

    env['lapack'] = flavour
    env['buildvars']['lapack'] = flavour

    ######## Silo
    silo_inc_path=''
    silo_lib_path=''
    if env['silo']:
        silo_inc_path,silo_lib_path=findLibWithHeader(env, env['silo_libs'], 'silo.h', env['silo_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [silo_inc_path])
        env.AppendUnique(LIBPATH = [silo_lib_path])
        env.Append(CPPDEFINES = ['ESYS_HAVE_SILO'])
        env['buildvars']['silo_inc_path']=silo_inc_path
        env['buildvars']['silo_lib_path']=silo_lib_path
    env['buildvars']['silo']=int(env['silo'])

    ######## VisIt
    visit_inc_path=''
    visit_lib_path=''
    if env['visit']:
        visit_inc_path,visit_lib_path=findLibWithHeader(env, env['visit_libs'], 'VisItControlInterface_V2.h', env['visit_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [visit_inc_path])
        env.AppendUnique(LIBPATH = [visit_lib_path])
        env['buildvars']['visit_inc_path']=visit_inc_path
        env['buildvars']['visit_lib_path']=visit_lib_path
    env['buildvars']['visit']=int(env['visit'])

    ######## MPI
    if env['mpi']=='no':
        env['mpi']='none'

    env['usempi'] = env['mpi']!='none'
    mpi_inc_path=''
    mpi_lib_path=''
    if env['usempi']:
        mpi_inc_path,mpi_lib_path=findLibWithHeader(env, env['mpi_libs'], 'mpi.h', env['mpi_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [mpi_inc_path])
        env.AppendUnique(LIBPATH = [mpi_lib_path])
        env.AppendUnique(LIBS = env['mpi_libs'])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], mpi_lib_path)
        env.Append(CPPDEFINES = ['ESYS_MPI', 'MPI_NO_CPPBIND', 'MPICH_IGNORE_CXX_SEEK'])
        # NetCDF 4.1 defines MPI_Comm et al. if MPI_INCLUDED is not defined!
        # On the other hand MPT and OpenMPI don't define the latter so we have
        # to do that here
        if env['netcdf'] and env['mpi'] in ['MPT','OPENMPI']:
            env.Append(CPPDEFINES = ['MPI_INCLUDED'])

        if env['mpi'] == 'OPENMPI':
            # try to get version for correct launcher arguments
            try:
                p = Popen(['orterun', '-V'], stdout=PIPE, stderr=PIPE)
                o,e = p.communicate()
                try:
                    ver = e.split('\n')[0].split()[-1]
                except IndexError:
                    ver = o.split('\n')[0].split()[-1]
                if len(ver) > 0:
                    env['orte_version'] = ver
            except OSError:
                pass

        env['buildvars']['mpi_inc_path']=mpi_inc_path
        env['buildvars']['mpi_lib_path']=mpi_lib_path
    env['buildvars']['mpi']=env['mpi']

    ######## BOOMERAMG
    if env['mpi'] == 'none': env['boomeramg'] = False
    boomeramg_inc_path=''
    boomeramg_lib_path=''
    if env['boomeramg']:
        boomeramg_inc_path,boomeramg_lib_path=findLibWithHeader(env, env['boomeramg_libs'], 'HYPRE.h', env['boomeramg_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [boomeramg_inc_path])
        env.AppendUnique(LIBPATH = [boomeramg_lib_path])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], boomeramg_lib_path)
        env.Append(CPPDEFINES = ['ESYS_HAVE_BOOMERAMG'])
        env['buildvars']['boomeramg_inc_path']=boomeramg_inc_path
        env['buildvars']['boomeramg_lib_path']=boomeramg_lib_path
    env['buildvars']['boomeramg']=int(env['boomeramg'])

    ######## ParMETIS
    if not env['usempi']: env['parmetis'] = False
    parmetis_inc_path=''
    parmetis_lib_path=''
    if env['parmetis']:
        parmetis_inc_path,parmetis_lib_path=findLibWithHeader(env, env['parmetis_libs'], 'parmetis.h', env['parmetis_prefix'], lang='c++')
        env.AppendUnique(CPPPATH = [parmetis_inc_path])
        env.AppendUnique(LIBPATH = [parmetis_lib_path])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], parmetis_lib_path)

        # Try to extract the parmetis version from parmetis.h
        header=open(os.path.join(parmetis_inc_path, 'parmetis.h')).readlines()
        major,minor,sub = None,None,None
        for line in header:
            ver=re.match(r'#define PARMETIS_MAJOR_VERSION\s*(\d+)',line)
            if ver:
                major = int(ver.group(1))
                continue
            ver=re.match(r'#define PARMETIS_MINOR_VERSION\s*(\d+)',line)
            if ver:
                minor = int(ver.group(1))
                continue
            ver=re.match(r'#define PARMETIS_SUBMINOR_VERSION\s*(\d+)',line)
            if ver:
                sub = int(ver.group(1))
                continue
        if major is not None:
            env['parmetis_version'] = "%d.%d.%d"%(major,minor,0 if sub is None else sub)
            if env['longindices']:
                # ParMETIS version 3.x does not support 64-bit indices
                if major < 4:
                    print("Sorry, cannot use ParMETIS version < 4.0 with 64-bit index types. Set longindices to False or disable ParMETIS.")
                    env.Exit(1)
                else:
                    # check if ParMETIS was built with 64-bit indices
                    conf = Configure(env.Clone())
                    idxsize=conf.CheckTypeSize('idx_t', '#include <parmetis.h>', 'C++')
                    if idxsize != 8:
                        print("Sorry, ParMETIS was not compiled with 64-bit indices. Set longindices to False or disable/rebuild ParMETIS.")
                        env.Exit(1)
        else:
            env['parmetis_version'] = "unknown"

        env.Append(CPPDEFINES = ['ESYS_HAVE_PARMETIS'])
        env['buildvars']['parmetis_inc_path']=parmetis_inc_path
        env['buildvars']['parmetis_lib_path']=parmetis_lib_path
    env['buildvars']['parmetis']=int(env['parmetis'])

    ######## gmsh (for tests)
    env['gmsh'] = False
    if env['IS_WINDOWS']:
        try:
            p=Popen(['gmsh', '-info'], stderr=PIPE)
            _,e=p.communicate()
            if e.split().count("MPI"):
                env['gmsh']='m'
            else:
                env['gmsh']='s'
        except OSError:
            pass
    else:
        which = Popen(['which', 'gmsh'], stdout=PIPE)
        path,_ = which.communicate()
        if which.wait() == 0:
            cmd = ['ldd', path[:-1]]
            if env['IS_OSX']:
                cmd = ['otool','-L', path[:-1]]
            try:
                p=Popen(cmd, stdout=PIPE)
                gmshlibs,_ = p.communicate()
                env.Append(CPPDEFINES=['ESYS_HAVE_GMSH'])
                if p.returncode == 0 and 'libmpi' in gmshlibs:
                    env['gmsh'] = 'm'
                    env.Append(CPPDEFINES=['ESYS_GMSH_MPI'])
                else:
                    env['gmsh'] = 's'
            except OSError:
                pass
    
    ######## boost::iostreams
    if env['compressed_files']:
        try:
            boost_inc_path, boost_lib_path = findLibWithHeader(env, env['compression_libs'], 'boost/iostreams/filter/gzip.hpp', env['boost_prefix'], lang='c++')
            env.Append(CPPDEFINES = ['ESYS_HAVE_BOOST_IO'])
        except RuntimeError as e:
            env['compressed_files'] = False
    env['buildvars']['compressed_files']=int(env['compressed_files'])

    ######## Trilinos
    env = checkForTrilinos(env)
    return env
コード例 #6
0
def checkForTrilinos(env):
    trilinos_inc_path = ''
    trilinos_lib_path = ''
    if env['trilinos']:
        havelibs = (len(env['trilinos_libs']) > 0)
        trilinos_inc_path, trilinos_lib_path = findLibWithHeader(
            env,
            env['trilinos_libs'],
            'Amesos2.hpp',
            env['trilinos_prefix'],
            lang='c++',
            try_link=havelibs)
        env.AppendUnique(CPPPATH=[trilinos_inc_path])
        env.AppendUnique(LIBPATH=[trilinos_lib_path])
        env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], trilinos_lib_path)
        env['buildvars']['trilinos_inc_path'] = trilinos_inc_path
        env['buildvars']['trilinos_lib_path'] = trilinos_lib_path
        conf = Configure(env.Clone())

        dependencies=['Amesos2.hpp','Amesos2_Solver_decl.hpp','BelosSolverFactory.hpp','BelosSolverManager.hpp',\
        'BelosTFQMRIter.hpp','BelosTFQMRSolMgr.hpp','BelosTpetraAdapter.hpp','BelosTypes.hpp',\
        'Ifpack2_Factory.hpp','Kokkos_DefaultNode.hpp',\
        'MatrixMarket_Tpetra.hpp','MueLu_CreateTpetraPreconditioner.hpp',\
        'Teuchos_DefaultComm.hpp','Teuchos_ParameterList.hpp',\
        'Tpetra_CrsGraph.hpp','Tpetra_CrsMatrix.hpp', 'Tpetra_RowMatrix.hpp',\
        'Tpetra_Vector.hpp','Trilinos_version.h']

        print("Looking for the Trilinos headers...")
        for check in dependencies:
            print("Checking for %s... %s" % (check, "yes" if os.path.isfile(
                os.path.join(trilinos_inc_path, check)) else "no"))
            if not os.path.isfile(os.path.join(trilinos_inc_path, check)):
                print(
                    "Could not find a Trilinos header file (tried looking in directory %s)"
                    % (trilinos_inc_path))
                env.Exit(1)

        if os.path.isfile(
                os.path.join(trilinos_inc_path, 'Tpetra_DefaultPlatform.hpp')):
            print("Checking for %s... %s" %
                  ('Tpetra_DefaultPlatform.hpp', "yes" if os.path.isfile(
                      os.path.join(trilinos_inc_path,
                                   'Tpetra_DefaultPlatform.hpp')) else "no"))
            env.Append(CPPDEFINES=['ESYS_HAVE_TPETRA_DP'])

        if os.path.isfile(
                os.path.join(trilinos_inc_path, 'Tpetra_BlockCrsMatrix.hpp')):
            print("Checking for %s... %s" %
                  ('Tpetra_BlockCrsMatrix.hpp', "yes" if os.path.isfile(
                      os.path.join(trilinos_inc_path,
                                   'Tpetra_DefaultPlatform.hpp')) else "no"))
        elif os.path.isfile(
                os.path.join(trilinos_inc_path,
                             'Tpetra_Experimental_BlockCrsMatrix.hpp')):
            print("Checking for %s... %s" %
                  ('Tpetra_Experimental_BlockCrsMatrix.hpp',
                   "yes" if os.path.isfile(
                       os.path.join(trilinos_inc_path,
                                    'Tpetra_DefaultPlatform.hpp')) else "no"))
            env.Append(CPPDEFINES=['ESYS_HAVE_TPETRA_EXPERIMENTAL_BLOCKCRS'])
        else:
            raise RuntimeError(
                'Could not locate the Trilinos Block CRS Matrix header')

        if os.path.isfile(
                os.path.join(trilinos_inc_path,
                             'Tpetra_BlockCrsMatrix_Helpers.hpp')):
            print(
                "Checking for %s... %s" %
                ('Tpetra_BlockCrsMatrix_Helpers.hpp', "yes" if os.path.isfile(
                    os.path.join(trilinos_inc_path,
                                 'Tpetra_DefaultPlatform.hpp')) else "no"))
        elif os.path.isfile(
                os.path.join(
                    trilinos_inc_path,
                    'Tpetra_Experimental_BlockCrsMatrix_Helpers.hpp')):
            print("Checking for %s... %s" %
                  ('Tpetra_Experimental_BlockCrsMatrix_Helpers.hpp',
                   "yes" if os.path.isfile(
                       os.path.join(trilinos_inc_path,
                                    'Tpetra_DefaultPlatform.hpp')) else "no"))
            env.Append(CPPDEFINES=['ESYS_HAVE_TPETRA_EXPERIMENTAL_BLOCKCRSH'])
        else:
            raise RuntimeError(
                'Could not locate the Trilinos Block CRS Matrix Helpers header'
            )

        if os.path.isfile(
                os.path.join(trilinos_inc_path, 'Tpetra_BlockVector.hpp')):
            print("Checking for %s... %s" %
                  ('Tpetra_BlockVector.hpp', "yes" if os.path.isfile(
                      os.path.join(trilinos_inc_path,
                                   'Tpetra_DefaultPlatform.hpp')) else "no"))
        elif os.path.isfile(
                os.path.join(trilinos_inc_path,
                             'Tpetra_Experimental_BlockVector.hpp')):
            print("Checking for %s... %s" %
                  ('Tpetra_Experimental_BlockVector.hpp',
                   "yes" if os.path.isfile(
                       os.path.join(trilinos_inc_path,
                                    'Tpetra_DefaultPlatform.hpp')) else "no"))
            env.Append(CPPDEFINES=['ESYS_HAVE_TPETRA_EXPERIMENTAL_BLOCKV'])
        else:
            raise RuntimeError(
                'Could not locate the Trilinos BlockVector header')

        # Try to extract the trilinos version from Trilinos_version.h
        versionh = open(os.path.join(trilinos_inc_path, 'Trilinos_version.h'))
        trilinos_version = 'unknown'
        env['trilinos_version'] = 'unknown'
        for line in versionh:
            ver = re.match(r'#define TRILINOS_MAJOR_MINOR_VERSION (\d+)', line)
            if ver:
                trilinos_version = ver.group(1)
                trilinos_version = int(trilinos_version)
                major = int(str(trilinos_version)[:2])
                minor = int(str(trilinos_version)[2:4])
                tmp = int(str(trilinos_version)[4:6])
                env['trilinos_version'] = str(major) + "." + str(
                    minor) + "." + str(tmp)

        if not havelibs:
            packages = [
                'Tpetra', 'Kokkos', 'Belos', 'Amesos2', 'Ifpack2', 'MueLu'
            ]
            libs = []
            for pk in packages:
                # find out what libraries to link with...
                makefile = os.path.join(trilinos_inc_path,
                                        'Makefile.export.%s' % pk)
                try:
                    for l in open(makefile, 'r').readlines():
                        if l.startswith(
                                "%s_LIBRARIES" % pk
                        ):  # or l.startswith("Trilinos_TPL_LIBRARIES"):
                            lst = l.split('=')[1].strip().split()
                            lst = [e.replace('-l', '', 1) for e in lst]
                            libs += lst
                        elif l.startswith("%s_TPL_INCLUDE_DIRS" % pk):
                            lst = l.split('=')[1].strip().split()
                            lst = [e.replace('-I', '', 1) for e in lst]
                            env.AppendUnique(CPPPATH=lst)

                except Exception as e:
                    raise RuntimeError(
                        'Error reading Trilinos export Makefile\n%s' % (e))
            env['trilinos_libs'] = libs

        env.Append(CPPDEFINES=['ESYS_HAVE_TRILINOS'])
        # env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], trilinos_lib_path)
        # env['buildvars']['trilinos_inc_path']=trilinos_inc_path
        # env['buildvars']['trilinos_lib_path']=trilinos_lib_path
    env['buildvars']['trilinos'] = int(env['trilinos'])
    return env
コード例 #7
0
def checkBoost(env):
    boost_inc_path, boost_lib_path = findLibWithHeader(env,
                                                       env['boost_libs'],
                                                       'boost/python.hpp',
                                                       env['boost_prefix'],
                                                       lang='c++')
    if env['sysheaderopt'] == '':
        env.AppendUnique(CPPPATH=[boost_inc_path])
    else:
        # This is required because we can't -isystem /usr/include since it
        # breaks std includes
        if os.path.normpath(boost_inc_path) == '/usr/include':
            env.Append(CCFLAGS=[
                env['sysheaderopt'],
                os.path.join(boost_inc_path, 'boost')
            ])
        else:
            env.Append(CCFLAGS=[env['sysheaderopt'], boost_inc_path])

    env.AppendUnique(LIBPATH=[boost_lib_path])
    env.AppendUnique(LIBS=env['boost_libs'])
    env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'], boost_lib_path)

    # Try to extract the boost version from version.hpp
    boosthpp = open(os.path.join(boost_inc_path, 'boost', 'version.hpp'))
    boostversion = 'unknown'
    for line in boosthpp:
        ver = re.match(r'#define BOOST_VERSION (\d+)', line)
        if ver:
            boostversion = ver.group(1)
            boostversion = int(boostversion)
            maj = boostversion / 100000
            minor = (boostversion / 100) % 1000
            sub = boostversion % 100
            env['boost_version'] = "%d.%d.%d" % (maj, minor, sub)
            if maj <= REQUIRED_BOOST[0] and minor < REQUIRED_BOOST[1]:
                print(
                    "The boost version referenced must be at least version %d.%d "
                    % REQUIRED_BOOST + "(have %d.%d.%d)" % (maj, minor, sub))
                env.Exit(1)
    boosthpp.close()
    env['buildvars']['boost_inc_path'] = boost_inc_path
    env['buildvars']['boost_lib_path'] = boost_lib_path
    env['buildvars']['boostversion'] = boostversion

    # Check for the boost numpy library
    env['have_boost_numpy'] = False
    if boostversion >= 106300 and env['disable_boost_numpy'] is False:
        try:
            boost_numpy_inc_path, boost_numpy_lib_path = findLibWithHeader(
                env,
                env['boost_libs'],
                'boost/python/numpy.hpp',
                env['boost_prefix'],
                lang='c++')

            # Locate the boost numpy files
            if env['IS_WINDOWS']:
                raise Exception  # TODO: fix boost numpy dll ex/import compile errors
                import sys
                for l in os.listdir(env['boost_prefix'] + '\\lib'):
                    if l.startswith('boost_numpy{}{}'.format(
                            sys.version_info.major, sys.version_info.minor)):
                        libname = os.path.splitext(l)[0]
            else:
                p = subprocess.Popen(["ld", "--verbose"],
                                     stdout=subprocess.PIPE)
                out, err = p.communicate()
                spath = [x[13:-3] for x in out.split() if b'SEARCH_DIR' in x]
                spath.append(boost_lib_path)
                p2name = ''
                p3name = ''
                for name in spath:
                    try:
                        l = os.listdir(name)

                        import sys
                        if sys.version_info[0] == 3:
                            string_type = str
                        else:
                            string_type = basestring

                        p2res = ''
                        p3res = ''
                        for x in l:
                            if isinstance(x, string_type):
                                if x.startswith('libboost_numpy-py'
                                                ) and x.endswith('.so'):
                                    p2res = x
                                if x.startswith('libboost_numpy-py3'
                                                ) and x.endswith('.so'):
                                    p3res = x
                            else:
                                if x.startswith(b'libboost_numpy-py'
                                                ) and x.endswith(b'.so'):
                                    p2res = x
                                if x.startswith(b'libboost_numpy-py3'
                                                ) and x.endswith(b'.so'):
                                    p3res = x

                        if len(p2name) == 0 and len(p2res) > 0:
                            p2name = p2res[-1]
                        if len(p3name) == 0 and len(p3res) > 0:
                            p3name = p3res[-1]
                    except OSError:
                        pass

                # Pick the right one
                if int(env['python_version'][0]) == 2:
                    libname = p2name[3:-3]
                else:
                    libname = p3name[3:-3]

            # If found, add the necessary information to env
            if len(libname) > 0:
                env.AppendUnique(LIBS=libname)
                tmp = env['boost_libs']
                env['boost_libs'] = [tmp, libname]
                env.AppendUnique(CPPPATH=[boost_numpy_inc_path])
                env.AppendUnique(LIBPATH=[boost_numpy_lib_path])
                env.PrependENVPath(env['LD_LIBRARY_PATH_KEY'],
                                   boost_numpy_lib_path)
                env.Append(CPPDEFINES=['ESYS_HAVE_BOOST_NUMPY'])
                env['have_boost_numpy'] = True

            print(
                "Found boost/python/numpy.hpp. Building with boost numpy support."
            )
        except:
            print(
                "Warning: Could not find boost/python/numpy.hpp. Building without numpy support."
            )

    # Check if the version of boost we are using is missing BOOST_BYTE_ORDER
    if boostversion >= 107000:
        env.Append(CPPDEFINES=['ESYS_DEPRECATED_BOOST_ENDIAN'])
    if boostversion >= 107200:
        env.Append(CPPDEFINES=['ESYS_MOVED_BOOST_ENDIAN'])

    return env