def configure(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
with local.cwd(self.src_dir):
configure = local["./configure"]
with local.env(CC=str(clang)):
run(configure["--disable-dependency-tracking",
"--disable-silent-rules", "--with-gnu-ld"])
def configure(self):
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
from plumbum.cmd import autoreconf, make
rasdaman_dir = path.join(self.builddir, self.src_dir)
gdal_dir = path.join(self.builddir, self.gdal_dir, self.gdal_dir)
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(gdal_dir):
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run(configure["--with-pic", "--enable-static",
"--disable-debug", "--with-gnu-ld",
"--without-ld-shared", "--without-libtool"])
run(make["-j", CFG["jobs"]])
with local.cwd(rasdaman_dir):
autoreconf("-i")
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run(configure["--without-debug-symbols", "--enable-benchmark",
"--with-static-libs", "--disable-java",
"--with-pic", "--disable-debug",
"--without-docs"])
def build(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
with local.cwd(self.src_dir):
target_opts = ["-DCPUS=1", "-DSYZYGY", "-DTEST"]
crafty_make = make["target=UNIX", "CC=" + str(clang),
"opt=" + " ".join(target_opts), "crafty-make"]
run(crafty_make)
def configure(self):
rasdaman_dir = path.join(self.SRC_FILE)
gdal_dir = path.join(self.gdal_dir, self.gdal_dir)
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(gdal_dir):
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run(configure["--with-pic", "--enable-static",
"--disable-debug", "--with-gnu-ld",
"--without-ld-shared", "--without-libtool"])
run(make["-j", CFG["jobs"]])
with local.cwd(rasdaman_dir):
autoreconf("-i")
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run(configure["--without-debug-symbols", "--enable-benchmark",
"--with-static-libs", "--disable-java",
"--with-pic", "--disable-debug",
"--without-docs"])
def configure(self):
from benchbuild.utils.run import run
# First we have to prepare boost for lady povray...
boost_dir = path.join(self.builddir, self.boost_src_dir)
boost_prefix = path.join(self.builddir, "boost-install")
with local.cwd(boost_dir):
from plumbum.cmd import mkdir
mkdir(boost_prefix)
bootstrap = local["./bootstrap.sh"]
run(bootstrap["--with-toolset=clang", "--prefix=\"{0}\"".format(
boost_prefix)])
b2 = local["./b2"]
run(b2["--ignore-site-config", "variant=release", "link=static",
"threading=multi", "optimization=speed", "install"])
povray_dir = path.join(self.builddir, self.src_dir)
with local.cwd(path.join(povray_dir, "unix")):
from plumbum.cmd import sh
sh("prebuild.sh")
with local.cwd(povray_dir):
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
configure = local["./configure"]
with local.env(COMPILED_BY="BB <*****@*****.**>",
CC=str(clang),
CXX=str(clang_cxx)):
run(configure["--with-boost=" + boost_prefix])
def configure(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
with local.cwd(self.src_dir):
configure = local["./configure"]
run(configure["--disable-shared", "--cc=" + str(clang),
"--extra-ldflags=" + " ".join(self.ldflags),
"--samples=" + self.fate_dir])
def configure(self):
lapack_dir = path.join(self.builddir, self.src_dir)
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(lapack_dir):
with open("make.inc", 'w') as makefile:
content = [
"SHELL = /bin/sh\n", "PLAT = _LINUX\n",
"CC = " + str(clang) + "\n",
"CXX = " + str(clang_cxx) + "\n",
"CFLAGS = -I$(TOPDIR)/INCLUDE\n",
"LOADER = " + str(clang) + "\n", "LOADOPTS = \n",
"NOOPT = -O0 -I$(TOPDIR)/INCLUDE\n",
"DRVCFLAGS = $(CFLAGS)\n", "F2CCFLAGS = $(CFLAGS)\n",
"TIMER = INT_CPU_TIME\n", "ARCH = ar\n",
"ARCHFLAGS = cr\n", "RANLIB = ranlib\n",
"BLASLIB = ../../blas$(PLAT).a\n", "XBLASLIB = \n",
"LAPACKLIB = lapack$(PLAT).a\n",
"F2CLIB = ../../F2CLIBS/libf2c.a\n",
"TMGLIB = tmglib$(PLAT).a\n",
"EIGSRCLIB = eigsrc$(PLAT).a\n",
"LINSRCLIB = linsrc$(PLAT).a\n",
"F2CLIB = ../../F2CLIBS/libf2c.a\n"
]
makefile.writelines(content)
def build(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(self.src_dir):
run(make["CC=" + str(clang), "CXX=" + str(clang_cxx), "clean",
"all"])
def configure(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(self.src_dir):
with local.env(CC=str(clang), CXX=str(clang_cxx)):
configure = local["./configure"]
run(configure["--with-static-linked-ext", "--disable-shared"])
def build(self):
with local.cwd(self.SRC_FILE):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
run(make["CC=" + str(clang), "CXX=" + str(clang_cxx), "clean",
"lsh", "sh"])
def build(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
with local.cwd(self.src_dir):
run(clang["-fPIC", "-I.", "-c", "sqlite3.c"])
run(clang["-shared", "-o", "libsqlite3.so", "sqlite3.o", "-ldl"])
self.build_leveldb()
def build(self):
src_file = path.join(self.name + ".dir", self.name + ".c")
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
run(clang["-I", "utilities", "-I", self.name,
"-DPOLYBENCH_USE_C99_PROTO",
"-DEXTRALARGE_DATASET",
"-DPOLYBENCH_USE_RESTRICT",
"utilities/polybench.c", src_file, "-lm", "-o", self.run_f])
def build(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(self.SRC_FILE):
with local.env(CXX=str(clang_cxx), CC=str(clang)):
make("clean")
run(make["all", "-i"])
def configure(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
with local.cwd(self.SRC_FILE):
configure = local["./configure"]
with local.env(CC=str(clang)):
run(configure["--disable-thread", "--disable-opencl",
"--enable-pic"])
def configure(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(self.SRC_FILE):
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run(configure["--without-ccache", "--disable-pic14-port",
"--disable-pic16-port"])
def configure(self):
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
from plumbum.cmd import make
mcrypt_dir = path.join(self.builddir, self.src_dir)
mhash_dir = path.join(self.builddir, self.mhash_dir)
libmcrypt_dir = path.join(self.builddir, self.libmcrypt_dir)
# Build mhash dependency
with local.cwd(mhash_dir):
configure = local["./configure"]
with local.env(CC=lt_clang(self.cflags, self.ldflags,
self.compiler_extension),
CXX=lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)):
run(configure["--prefix=" + self.builddir])
run(make["-j", CFG["jobs"], "install"])
# Builder libmcrypt dependency
with local.cwd(libmcrypt_dir):
configure = local["./configure"]
with local.env(CC=lt_clang(self.cflags, self.ldflags,
self.compiler_extension),
CXX=lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)):
run(configure["--prefix=" + self.builddir])
run(make["-j", CFG["jobs"], "install"])
with local.cwd(mcrypt_dir):
configure = local["./configure"]
with local.env(CC=lt_clang(self.cflags, self.ldflags,
self.compiler_extension),
CXX=lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension),
LD_LIBRARY_PATH=path.join(self.builddir, "lib") +
":" + CFG["ld_library_path"],
LDFLAGS="-L" + path.join(self.builddir, "lib"),
CFLAGS="-I" + path.join(self.builddir, "include")):
run(configure["--disable-dependency-tracking",
"--enable-static", "--disable-shared",
"--with-libmcrypt=" + self.builddir,
"--with-libmhash=" + self.builddir])
def build(self):
from benchbuild.utils.compiler import lt_clang
from benchbuild.utils.run import run
cflags = self.cflags
ldflags = self.ldflags + ["-lm"]
with local.cwd(self.builddir):
clang = lt_clang(cflags, ldflags, self.compiler_extension)
run(clang["-o", self.run_f, "linpack.c"])
def configure(self):
self.cflags += ["-fPIC"]
clang = lt_clang(self.cflags, self.ldflags)
configure = local[path.join(self.src_dir, "configure")]
with local.cwd(self.src_dir):
with local.env(CC=str(clang)):
run(configure["--disable-asm", "--disable-shared",
"--enable-static",
"--disable-dependency-tracking",
"--with-pic=yes"])
def build(self):
from plumbum.cmd import make
from benchbuild.utils.compiler import lt_clang
from benchbuild.utils.run import run
blas_dir = path.join(self.builddir, self.src_dir)
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(blas_dir):
run(make["CC=" + str(clang)])
def configure(self):
clang = lt_clang(self.cflags, self.ldflags)
with local.cwd(self.src_dir):
configure = local["./configure"]
with local.env(CC=str(clang)):
run(configure["--enable-threads=no", "--with-gnu-ld=yes",
"--disable-shared",
"--disable-dependency-tracking",
"--disable-xzdec", "--disable-lzmadec",
"--disable-lzmainfo", "--disable-lzma-links",
"--disable-scripts", "--disable-doc"])
def configure(self):
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
ruby_dir = path.join(self.builddir, self.src_dir)
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(ruby_dir):
with local.env(CC=str(clang), CXX=str(clang_cxx)):
configure = local["./configure"]
run(configure["--with-static-linked-ext", "--disable-shared"])
def build(self):
from benchbuild.utils.compiler import lt_clang
from benchbuild.utils.run import run
src_file = path.join(self.name + ".dir", self.name + ".c")
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
run(clang["-I", "utilities", "-I", self.name,
"-DPOLYBENCH_USE_C99_PROTO", "-DEXTRALARGE_DATASET",
"utilities/polybench.c", src_file, "-lm", "-o",
self.run_f])
def build(self):
from plumbum.cmd import make
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
minisat_dir = path.join(self.builddir, self.src_dir)
with local.cwd(minisat_dir):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
run(make["CC=" + str(clang), "CXX=" + str(clang_cxx), "clean",
"lsh", "sh"])
def configure(self):
from benchbuild.utils.compiler import lt_clang
from benchbuild.utils.run import run
openssl_dir = path.join(self.builddir, self.src_dir)
configure = local[path.join(openssl_dir, "configure")]
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags)
with local.cwd(openssl_dir):
with local.env(CC=str(clang)):
run(configure["--disable-asm"])
def configure(self):
mcrypt_dir = self.src_dir
mhash_dir = self.mhash_dir
libmcrypt_dir = self.libmcrypt_dir
# Build mhash dependency
with local.cwd(mhash_dir):
configure = local["./configure"]
with local.env(CC=lt_clang(self.cflags, self.ldflags,
self.compiler_extension),
CXX=lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)):
run(configure["--prefix=" + self.builddir])
run(make["-j", CFG["jobs"], "install"])
# Builder libmcrypt dependency
with local.cwd(libmcrypt_dir):
configure = local["./configure"]
with local.env(CC=lt_clang(self.cflags, self.ldflags,
self.compiler_extension),
CXX=lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)):
run(configure["--prefix=" + self.builddir])
run(make["-j", CFG["jobs"], "install"])
with local.cwd(mcrypt_dir):
configure = local["./configure"]
with local.env(CC=lt_clang(self.cflags, self.ldflags,
self.compiler_extension),
CXX=lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension),
LD_LIBRARY_PATH=path.join(self.builddir, "lib") +
":" + CFG["ld_library_path"],
LDFLAGS="-L" + path.join(self.builddir, "lib"),
CFLAGS="-I" + path.join(self.builddir, "include")):
run(configure["--disable-dependency-tracking",
"--enable-static", "--disable-shared",
"--with-libmcrypt=" + self.builddir,
"--with-libmhash=" + self.builddir])
def configure(self):
from benchbuild.utils.compiler import lt_clang
from benchbuild.utils.run import run
from plumbum.cmd import mkdir
tcc_dir = path.join(self.builddir, self.src_dir)
with local.cwd(self.builddir):
mkdir("build")
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(path.join(self.builddir, "build")):
configure = local[path.join(tcc_dir, "configure")]
run(configure["--cc=" + str(clang), "--libdir=/usr/lib64"])
def build_leveldb(self):
sqlite_dir = self.src_dir
leveldb_dir = "leveldb.src"
# We need to place sqlite3 in front of all other flags.
self.ldflags += ["-L{0}".format(path.abspath(sqlite_dir))]
self.cflags += ["-I{0}".format(path.abspath(sqlite_dir))]
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags)
clang = lt_clang(self.cflags, self.ldflags)
with local.cwd(leveldb_dir):
with local.env(CXX=str(clang_cxx), CC=str(clang)):
run(make["clean", "out-static/db_bench_sqlite3"])
def configure(self):
from benchbuild.utils.compiler import lt_clang
x264_dir = path.join(self.builddir, self.src_dir)
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(x264_dir):
configure = local["./configure"]
with local.env(CC=str(clang)):
run(configure["--enable-static",
"--disable-asm", "--disable-thread",
"--disable-opencl", "--enable-pic"])
def configure(self):
from benchbuild.utils.compiler import lt_clang
from benchbuild.utils.run import run
gzip_dir = path.join(self.builddir, self.src_dir)
with local.cwd(gzip_dir):
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
configure = local["./configure"]
with local.env(CC=str(clang)):
run(configure["--disable-dependency-tracking",
"--disable-silent-rules", "--with-gnu-ld"])
def configure(self):
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
python_dir = path.join(self.builddir, self.src_dir)
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(python_dir):
configure = local["./configure"]
with local.env(CC=str(clang), CXX=str(clang_cxx)):
run(configure["--disable-shared", "--without-gcc"])
def run_tests(self, experiment, run):
exp = wrap_dynamic(self, "lnt_runner", experiment)
lnt = local[path.join("local", "bin", "lnt")]
sandbox_dir = path.join(self.builddir, "run")
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
run(lnt["runtest", "nt", "-v", "-j1", "--sandbox", sandbox_dir, "--cc",
str(clang), "--cxx",
str(clang_cxx), "--test-suite",
path.join(self.builddir, self.test_suite_dir), "--test-style",
"simple", "--make-param=RUNUNDER=" + str(exp),
"--only-test=" + path.join("MultiSource", "Applications")])
def build(self):
from plumbum.cmd import make
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
leveldb_dir = path.join(self.builddir, "leveldb.src")
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(leveldb_dir):
with local.env(CXX=str(clang_cxx), CC=str(clang)):
run(make["clean", "out-static/db_bench"])
def build(self):
from benchbuild.utils.compiler import lt_clang
from benchbuild.utils.run import run
with local.cwd(self.builddir):
sqlite_dir = path.join(self.builddir, self.src_dir)
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(sqlite_dir):
run(clang["-fPIC", "-I.", "-c", "sqlite3.c"])
run(clang["-shared", "-Wl,-soname,libsqlite3.so.0", "-o",
"libsqlite3.so", "sqlite3.o", "-ldl"])
with local.cwd(self.builddir):
self.build_leveldb()
def configure(self):
from benchbuild.utils.compiler import lt_clang
from benchbuild.utils.run import run
xz_dir = path.join(self.builddir, self.src_dir)
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags)
with local.cwd(xz_dir):
configure = local["./configure"]
with local.env(CC=str(clang)):
run(configure["--enable-threads=no", "--with-gnu-ld=yes",
"--disable-shared",
"--disable-dependency-tracking",
"--disable-xzdec", "--disable-lzmadec",
"--disable-lzmainfo", "--disable-lzma-links",
"--disable-scripts", "--disable-doc"])
def configure(self):
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
ccrypt_dir = path.join(self.builddir, self.src_dir)
with local.cwd(ccrypt_dir):
configure = local["./configure"]
with local.env(CC=str(clang),
CXX=str(clang_cxx),
LDFLAGS=" ".join(self.ldflags)):
run(configure)
def build_leveldb(self):
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
from plumbum.cmd import make
sqlite_dir = path.join(self.builddir, self.src_dir)
leveldb_dir = path.join(self.builddir, "leveldb.src")
# We need to place sqlite3 in front of all other flags.
self.ldflags = ["-L", sqlite_dir] + self.ldflags
self.cflags = ["-I", sqlite_dir] + self.cflags
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags)
clang = lt_clang(self.cflags, self.ldflags)
with local.cwd(leveldb_dir):
with local.env(CXX=str(clang_cxx), CC=str(clang)):
run(make["clean", "out-static/db_bench_sqlite3"])
def build(self):
from plumbum.cmd import make
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
crafty_dir = path.join(self.builddir, self.src_dir)
with local.cwd(crafty_dir):
target_opts = ["-DINLINE64", "-DCPUS=1"]
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
run(make["target=LINUX", "CC=" + str(clang), "CXX=" + str(
clang_cxx), "opt=" + " ".join(target_opts), "crafty-make"])
def configure(self):
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
from plumbum.cmd import mkdir
js_dir = path.join(self.builddir, self.src_dir, "js", "src")
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(js_dir):
autoconf = local["autoconf"]
autoconf()
mkdir("build_OPT.OBJ")
with local.cwd("build_OPT.OBJ"):
with local.env(CC=str(clang), CXX=str(clang_cxx)):
configure = local["../configure"]
run(configure)
def run_tests(self, experiment):
from benchbuild.utils.compiler import lt_clang, lt_clang_cxx
from benchbuild.utils.run import run
exp = self.wrap_dynamic("lnt_runner", experiment)
lnt = local[path.join("local", "bin", "lnt")]
sandbox_dir = path.join(self.builddir, "run")
with local.cwd(self.builddir):
clang = lt_clang(self.cflags, self.ldflags,
self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
run(lnt["runtest", "nt", "-v", "-j1", "--sandbox", sandbox_dir, "--cc",
str(clang), "--cxx", str(clang_cxx), "--test-suite", path.join(
self.builddir, self.test_suite_dir), "--test-style",
"simple", "--make-param=RUNUNDER=" + str(exp), "--only-test=" +
path.join("MultiSource", "Applications")])
def configure(self):
js_dir = path.join(self.src_dir, "js", "src")
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(js_dir):
make_src_pkg = local["./make-source-package.sh"]
with local.env(DIST=self.builddir,
MOZJS_MAJOR_VERSION=0,
MOZJS_MINOR_VERSION=0,
MOZJS_PATCH_VERSION=0):
make_src_pkg()
mozjs_dir = "mozjs-0.0.0"
tar("xfj", mozjs_dir + ".tar.bz2")
with local.cwd(path.join(mozjs_dir, "js", "src")):
mkdir("obj")
autoconf = local["autoconf-2.13"]
autoconf()
with local.cwd("obj"):
with local.env(CC=str(clang), CXX=str(clang_cxx)):
configure = local["../configure"]
run(configure)
def configure(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
with local.cwd(self.src_dir):
with open("make.inc", 'w') as makefile:
content = [
"SHELL = /bin/sh\n", "PLAT = _LINUX\n",
"CC = " + str(clang) + "\n", "CXX = " +
str(clang_cxx) + "\n", "CFLAGS = -I$(TOPDIR)/INCLUDE\n",
"LOADER = " + str(clang) + "\n", "LOADOPTS = \n",
"NOOPT = -O0 -I$(TOPDIR)/INCLUDE\n",
"DRVCFLAGS = $(CFLAGS)\n", "F2CCFLAGS = $(CFLAGS)\n",
"TIMER = INT_CPU_TIME\n", "ARCH = ar\n",
"ARCHFLAGS = cr\n", "RANLIB = ranlib\n",
"BLASLIB = ../../blas$(PLAT).a\n", "XBLASLIB = \n",
"LAPACKLIB = lapack$(PLAT).a\n",
"F2CLIB = ../../F2CLIBS/libf2c.a\n",
"TMGLIB = tmglib$(PLAT).a\n",
"EIGSRCLIB = eigsrc$(PLAT).a\n",
"LINSRCLIB = linsrc$(PLAT).a\n",
"F2CLIB = ../../F2CLIBS/libf2c.a\n"
]
makefile.writelines(content)
def configure(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
clang_cxx = lt_clang_cxx(self.cflags, self.ldflags,
self.compiler_extension)
# First we have to prepare boost for lady povray...
boost_prefix = "boost-install"
with local.cwd(self.boost_src_dir):
mkdir(boost_prefix)
bootstrap = local["./bootstrap.sh"]
run(bootstrap["--with-toolset=clang",
"--prefix=\"{0}\"".format(boost_prefix)])
b2 = local["./b2"]
run(b2["--ignore-site-config", "variant=release", "link=static",
"threading=multi", "optimization=speed", "install"])
with local.cwd(path.join(self.SRC_FILE, "unix")):
sh("prebuild.sh")
with local.cwd(self.SRC_FILE):
configure = local["./configure"]
with local.env(COMPILED_BY="BB <*****@*****.**>",
CC=str(clang),
CXX=str(clang_cxx)):
run(configure["--with-boost=" + boost_prefix])
def build(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
with local.cwd(self.SRC_FILE):
run(make["CC=" + str(clang)])
def build(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
run(make["CC=" + str(clang), "scimark2"])
def build(self):
clang = lt_clang(self.cflags, self.ldflags, self.compiler_extension)
with local.cwd(self.src_dir):
run(make["CFLAGS=-O3", "CC=" + str(clang), "clean", "bzip2"])
