def build(arch, build):
path = None
if "wind" in arch.lower():
path = os.path.join(getRootPath(), "win", "NvFBC")
if "linux" in arch.lower():
path = os.path.join(getRootPath(), "linux", "NvFBC")
if path == None:
print "grid sdk is not supported on this platform"
return
toPath = devtools.getInstallPath(arch)
devtools.copyWindowsFiles(path, os.path.abspath(os.path.join(toPath, "include", "NvFBC")), ".h")
devtools.copyWindowsFiles(os.path.join(path, "..", "NvEncodeAPI"), os.path.abspath(os.path.join(toPath, "include", "NvEncodeAPI")), ".h")
print "copied"
def build(arch, build):
angleDir = getExtactedFolderPath()
toPath = devtools.getInstallPath(arch)
target_arch = "32" if "32" in arch.lower() else "64"
target_cpu = "x86" if target_arch == "32" else "x64"
is_debug = "false" if "rel" in build.lower() else "true"
if target_arch == "64":
print "We can build x64, but findAngle.cmake don't support it, update it and remove this line"
return
if not os.path.exists(angleDir) or not os.listdir(angleDir):
try:
os.mkdir(getRootPath())
except os.error:
pass
subprocess.check_call(
"git clone https://chromium.googlesource.com/angle/angle",
cwd=getRootPath(),
shell=True)
subprocess.check_call("git fetch", cwd=angleDir, shell=True)
subprocess.check_call(
"git reset --hard 59b1ed4a60fc9cf57c3914eb4851ec94c8df21a9",
cwd=angleDir,
shell=True)
subprocess.check_call("python scripts/bootstrap.py",
cwd=angleDir,
shell=True)
subprocess.check_call("gclient sync", cwd=angleDir, shell=True)
if "lin" in arch:
subprocess.check_call("./build/install-build-deps.sh",
cwd=angleDir,
shell=True)
try:
os.makedirs(os.path.dirname(getArgsPath(build, target_cpu)))
except os.error:
pass
GN_CONFIG = ""
if "wind" in arch:
GN_CONFIG = GN_WINDOWS_CONFIG
else:
GN_CONFIG = GN_LINUX_MAC_OS_CONFIG
with open(getArgsPath(build, target_cpu), "w") as argsFile:
argsFile.write(GN_CONFIG.format(target_cpu, is_debug))
build_path = build + "/" + target_cpu
subprocess.check_call("gn gen out/" + build_path, cwd=angleDir, shell=True)
subprocess.check_call("ninja -C out/" + build_path,
cwd=angleDir,
shell=True)
distutils.dir_util.copy_tree(
os.path.join(angleDir, "include"),
os.path.abspath(os.path.join(toPath, "include", "angle")))
distutils.dir_util.copy_tree(
os.path.join(angleDir, "src", "common"),
os.path.abspath(os.path.join(toPath, "include", "angle", "common")))
distutils.dir_util.copy_tree(
os.path.join(angleDir, "util"),
os.path.abspath(os.path.join(toPath, "include", "angle", "util")))
try:
os.makedirs(os.path.join(toPath, "pdb", "angle", build))
except os.error as error:
pass
try:
os.makedirs(os.path.join(toPath, "lib", "angle", build))
except os.error as error:
pass
try:
os.makedirs(os.path.join(toPath, "bin", "angle", build))
except os.error as error:
pass
dll_path = os.path.join(toPath, "bin", "angle", build)
pdb_path = os.path.join(toPath, "pdb", "angle", build)
lib_path = os.path.join(toPath, "lib", "angle", build)
for libs in LIB_LIST:
if "wind" in arch:
shutil.copy(
os.path.join(getOutPath(build, target_cpu), libs + ".dll"),
dll_path)
shutil.copy(
os.path.join(getOutPath(build, target_cpu), libs + ".dll.pdb"),
pdb_path)
shutil.copy(
os.path.join(getOutPath(build, target_cpu), libs + ".dll.lib"),
os.path.join(toPath, "lib"))
elif "lin" in arch:
shutil.copy(
os.path.join(getOutPath(build, target_cpu), libs + ".TOC"),
pdb_path)
shutil.copy(
os.path.join(getOutPath(build, target_cpu), libs + ".so"),
lib_path)
elif "darwin" in arch:
shutil.copy(
os.path.join(getOutPath(build, target_cpu), libs + ".TOC"),
pdb_path)
shutil.copy(
os.path.join(getOutPath(build, target_cpu), libs + ".dylib"),
dll_path)
if "wind" in arch:
shutil.copy(
os.path.join(getOutPath(build, target_cpu), WINDOWS_LIB + ".dll"),
dll_path)
shutil.copy(
os.path.join(getOutPath(build, target_cpu),
WINDOWS_LIB + ".dll.pdb"), pdb_path)
shutil.copy(
os.path.join(getOutPath(build,
target_cpu), WINDOWS_LIB + ".dll.lib"),
os.path.join(toPath, "lib"))
else:
shutil.copy(
os.path.join(getOutPath(build, target_cpu),
LINUX_MACOS_LIB + ".TOC"), pdb_path)
shutil.copy(
os.path.join(getOutPath(build, target_cpu),
LINUX_MACOS_LIB + ".so"), lib_path)
def prepareResources():
print "Start prepare resources"
prepareArgs()
if len(archs) > 1:
print "Invalid arch"
exit(-1)
arch = archs[0]
installPath3rdparty = devtools.getInstallPath(arch)
outdir = os.path.abspath(os.path.join(module_path(), g_outdirname))
linuxsharedlib = os.path.join(outdir, "shared", "usr", "lib", "LiquidSky")
winplayerlib = os.path.join(outdir, "player", "lib")
winstreamer = os.path.join(outdir, "streamer")
cfiles = [
{
'name': "avcodec",
'ext': ".dll",
'path': winstreamer
},
{
'name': "avcodec",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "avformat",
'ext': ".dll",
'path': winstreamer
},
{
'name': "avformat",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "avutil",
'ext': ".dll",
'path': winstreamer
},
{
'name': "avutil",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "swscale",
'ext': ".dll",
'path': winstreamer
},
{
'name': "swscale",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "u2ec",
'ext': ".dll",
'path': winstreamer
},
{
'name': "CrashSender.",
'ext': ".exe",
'path': winstreamer
},
{
'name': "crashrpt_lang",
'ext': ".ini",
'path': winstreamer
},
{
'name': "app-sender",
'ext': ".exe",
'path': winstreamer
},
{
'name': "process-monitor",
'ext': ".exe",
'path': winstreamer
},
{
'name': "usb-service",
'ext': ".exe",
'path': winstreamer
},
{
'name': "pdb",
'ext': ".pdb",
'path': os.path.join(outdir, "pdb")
},
]
devtools.findAndCopy(installPath3rdparty, cfiles)
if arch == "windows-x86_32":
cefReleaseDir = os.path.join(module_path(), "3rdparty", "cef",
"windows32", "Release")
cfiles = [
{
'name': "chrome_elf",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "d3dcompiler_43",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "d3dcompiler_47",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "libcef",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "widevinecdmadapter",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "bin",
'ext': ".bin",
'path': winplayerlib
},
]
devtools.findAndCopy(cefReleaseDir, cfiles)
angleReleaseDir = os.path.join(installPath3rdparty, "bin", "angle",
"Release")
cfiles = [
{
'name': "angle_util",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "libEGL",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "libGLESv1_CM",
'ext': ".dll",
'path': winplayerlib
},
{
'name': "libGLESv2",
'ext': ".dll",
'path': winplayerlib
},
]
devtools.findAndCopy(angleReleaseDir, cfiles)
cefResourcesDir = os.path.join(module_path(), "3rdparty", "cef",
"windows32", "Resources")
cfiles = [
{
'name': "",
'ext': "",
'path': winplayerlib,
'save_folders': True
},
]
devtools.findAndCopy(cefResourcesDir, cfiles)
imagesDir = os.path.join(module_path(), "testdata", "images")
cfiles = [
{
'name': "",
'ext': "png",
'path': os.path.join(winplayerlib, "images"),
'save_folders': True
},
]
devtools.findAndCopy(imagesDir, cfiles)
usbDriverDir = os.path.join(module_path(), "3rdparty", "u2ec")
cfiles = [
{
'name': "usb_driver",
'ext': "msi",
'path': winplayerlib
},
]
devtools.findAndCopy(usbDriverDir, cfiles)
#+ copytree(os.path.join(module_path(), "testdata", "localhost"), os.path.join(outdir, "player", "localhost"))
if "wind" in pfm:
cfiles = [
{
'name': "pdb",
'ext': ".pdb",
'path': os.path.join(outdir, "pdb")
},
]
buildtype = "Release"
buildPath = devtools.getTmpPath(devtools.rootDir, arch, buildtype)
devtools.findAndCopy(buildPath, cfiles)
devtools.findAndCopy(buildPath + "-8", cfiles)
print "Resources were successfully copied"
# print "not include pack for now TODO: build bot option"
if "wind" in pfm:
outputResourceFile = os.path.join(winplayerlib, "localhost.pack")
if "dar" in pfm:
outputResourceFile = os.path.join(outdir, "LiquidSky.app", "Contents",
"Resources", "localhost.pack")
respack.packFolder(
outputResourceFile,
os.path.join(module_path(), "testdata", "localhost_devel",
"localhost"), "localhost")
print "Pack file created"
def build(arch, build):
if "wind" in arch:
print "Extract ffmpeg"
unzipcmd = [
sevenz.cmd, "x", "-y", "-o" + getExtactedFolderPath(),
findGridSdkZip(getRootPath())
]
proc = subprocess.call(unzipcmd)
ffmpegDir = getExtactedFolderPath()
toPath = devtools.getInstallPath(arch)
distutils.dir_util.copy_tree(
os.path.join(ffmpegDir, "include"),
os.path.abspath(os.path.join(toPath, "include")))
devtools.copyWindowsFiles(os.path.join(ffmpegDir, "bin"),
os.path.abspath(os.path.join(toPath, "bin")),
".dll")
devtools.copyWindowsFiles(os.path.join(ffmpegDir, "bin"),
os.path.abspath(os.path.join(toPath, "lib")),
".lib")
devtools.copyWindowsFiles(
os.path.join(ffmpegDir),
os.path.abspath(os.path.join(toPath, "pdb", "ffmpeg")), ".pdb")
elif "lin" in arch or "dar" in arch:
workingDir = getWorkingFolderPath()
if not os.path.isdir(workingDir):
print "Extract ffmpeg"
bz = findbz(getRootPath())
unzipcmd = ["tar", "jxvf", bz, "-C", getRootPath()]
proc = subprocess.call(unzipcmd)
devtools.failIfReturnCodeNotZero(proc)
shutil.copytree(workingDir, os.path.join(workingDir, "..", arch))
workingDir = os.path.join(workingDir, "..", arch)
print "configure"
perlcmd = [
"./configure", "--disable-bzlib", "--disable-iconv",
"--disable-lzma", "--disable-sdl", "--disable-xlib",
"--disable-zlib", "--disable-yasm", "--disable-avfilter",
"--disable-avdevice", "--disable-swresample", "--disable-ffmpeg",
"--disable-ffprobe", "--disable-ffserver", "--disable-ffplay",
"--disable-static", "--enable-shared", "--disable-everything",
"--enable-hwaccels", "--enable-decoder=h264",
"--enable-decoder=h264_vdpau", "--enable-vaapi",
"--enable-muxer=matroska", "--enable-demuxer=matroska",
"--enable-demuxer=mpegts", "--enable-parser=h264",
"--enable-protocol=file",
"--prefix=" + devtools.getInstallPath(arch)
]
extra = []
if "darwin" in arch and "x86_32" in arch:
extra = [
"--sysroot=" + devtools.getMacosSDK(),
"--extra-cflags=\"-arch\ i386\ -DDMACOSX_DEPLOYMENT_TARGET=" +
devtools.getMacosSDKVersion() + "\ -mmacosx-version-min=" +
devtools.getMacosSDKVersion() + "\"",
"--extra-ldflags=\"-arch\ i386\ -isysroot\ " +
devtools.getMacosSDK() + "\ -mmacosx-version-min=" +
devtools.getMacosSDKVersion() + "\"", "--arch=x86_32",
"--target-os=darwin", "--enable-cross-compile"
]
if "darwin" in arch and "x86_64" in arch:
extra = [
"--sysroot=" + devtools.getMacosSDK(),
"--extra-cflags=\"-arch\ x86_64\ -DDMACOSX_DEPLOYMENT_TARGET="
+ devtools.getMacosSDKVersion() + "\ -mmacosx-version-min=" +
devtools.getMacosSDKVersion() + "\"",
"--extra-ldflags=\"-arch\ x86_64\ -isysroot\ " +
devtools.getMacosSDK() + "\ -mmacosx-version-min=" +
devtools.getMacosSDKVersion() + "\"", "--arch=x86_64",
"--target-os=darwin", "--enable-cross-compile"
]
for e in extra:
perlcmd.append(e)
print perlcmd
proc = subprocess.call(perlcmd, cwd=workingDir, env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
print "building " + name
devenvcmd = ["make"]
proc = subprocess.call(devenvcmd,
cwd=workingDir,
env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
devenvcmd = ["make", "install"]
proc = subprocess.call(devenvcmd,
cwd=workingDir,
env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
if "darwin" in arch:
folderPath = os.path.join(devtools.getInstallPath(arch), "lib")
names = [
"libavutil.dylib", "libavcodec.dylib", "libavformat.dylib",
"libswscale.dylib"
]
lnames = [
"libavutil.55.dylib", "libavcodec.57.dylib",
"libavformat.57.dylib", "libswscale.4.dylib"
]
prefixNewId = "@rpath/"
newRPath = "@loader_path/"
newDep = "@loader_path/"
for n in names:
print "----------------------- preparing... " + n
path = os.path.join(folderPath, n)
devtools.changeIdMacOsDLyb(folderPath, path, prefixNewId + n)
devtools.changeRpathMacOsDLyb(folderPath, path, newRPath)
index = 0
for lname in lnames:
newname = names[index]
index = index + 1
print "-------- find change: " + lname + " to " + newname
devtools.changeDepsMacOsDLyb(
folderPath, os.path.join(folderPath, lname),
os.path.join(newDep, newname), path)
def build(arch, build):
workingDir = getWorkingFolderPath()
if not os.path.isdir(workingDir):
print "Extract openssl"
gz = findZip(getRootPath())
tar = gz[:-3]
unzipcmd = [sevenz.cmd, "x", "-y", "-o" + getRootPath(), gz]
proc = subprocess.call(unzipcmd)
unzipcmd = [sevenz.cmd, "x", "-y", "-o" + getRootPath(), tar]
proc = subprocess.call(unzipcmd)
fixFileStruct(getRootPath(), workingDir)
newwd = os.path.join(workingDir, "..", arch)
devtools.rmtree(newwd)
shutil.copytree(workingDir, newwd)
workingDir = newwd
if "wind" in arch:
if "Debug" in build:
print "no debug build for openssl"
return
print "perl"
buildtype = "VC-WIN32"
asmcommand = "do_nasm.bat"
if "64" in arch:
buildtype = "VC-WIN64A"
asmcommand = "do_win64a.bat"
perlcmd = [
"perl.exe", "Configure", buildtype,
"--prefix=" + devtools.getInstallPath(arch),
"--openssldir=" + devtools.getInstallPath(arch),
"enable-static-engine", "no-shared", "enable-hw"
]
proc = subprocess.call(perlcmd, cwd=workingDir, env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
# print "do nasm"
# domscmd = [os.path.abspath(os.path.join(workingDir, "ms", asmcommand))]
# proc = subprocess.call(domscmd, cwd=workingDir, env=os.environ.copy())
# devtools.failIfReturnCodeNotZero(proc)
print "building " + name
devenvcmd = [
"nmake.exe", "-f",
os.path.abspath(os.path.join(workingDir, "makefile"))
]
proc = subprocess.call(devenvcmd,
cwd=workingDir,
env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
devenvcmd = [
"nmake.exe", "-f",
os.path.abspath(os.path.join(workingDir, "makefile")),
"install_sw", "install_ssldirs"
]
proc = subprocess.call(devenvcmd,
cwd=workingDir,
env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
elif "lin" in arch:
print "perl"
perlcmd = [os.path.abspath(os.path.join(workingDir, "config"))]
perlcmd.append("--prefix=" + devtools.getInstallPath(arch))
print perlcmd
proc = subprocess.call(perlcmd, cwd=workingDir, env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
print "building " + name
devenvcmd = ["make"]
proc = subprocess.call(devenvcmd,
cwd=workingDir,
env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
devenvcmd = ["make", "install"]
proc = subprocess.call(devenvcmd,
cwd=workingDir,
env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
elif "darwin" in arch:
print "perl"
perlcmd = [
"perl",
os.path.abspath(os.path.join(workingDir, "Configure"))
]
if "x86_32" in arch:
perlcmd.append("darwin-i386-cc")
archname = "i386"
if "x86_64" in arch:
perlcmd.append("darwin64-x86_64-cc")
archname = "x86_64"
perlcmd.append("--prefix=" + devtools.getInstallPath(arch))
print perlcmd
proc = subprocess.call(perlcmd, cwd=workingDir, env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
sedcmd = [
"sed", "-ie", 's!^CFLAG=!CFLAG=-isysroot ' +
devtools.getMacosSDK() + ' -arch ' + archname +
' -mmacosx-version-min=' + devtools.getMacosSDKVersion() + ' !',
os.path.abspath(os.path.join(workingDir, "Makefile"))
]
print sedcmd
proc = subprocess.call(sedcmd, cwd=workingDir, env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
print "building " + name
devenvcmd = ["make"]
proc = subprocess.call(devenvcmd,
cwd=workingDir,
env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
devenvcmd = ["make", "install"]
proc = subprocess.call(devenvcmd,
cwd=workingDir,
env=os.environ.copy())
devtools.failIfReturnCodeNotZero(proc)
return True
def build(arch, build):
archl = arch.lower()
installPath = devtools.getInstallPath(arch)
if "ios" in archl:
buildscript = os.path.join(getRootPath(), "ios-build",
"build-libstdc++.sh")
print buildscript
proc = subprocess.call(
[os.path.abspath(buildscript),
os.path.abspath(installPath)])
else:
if not os.path.isdir(getExtactedFolderPath()):
print "Extract boost"
try:
findBoostZip(getRootPath())
except:
url = 'https://dl.bintray.com/boostorg/release/1.70.0/source/boost_1_70_0.7z'
fname = os.path.join(getRootPath(), url.rsplit('/', 1)[1])
devtools.downloadFile(url, fname)
unzipcmd = [
sevenz.cmd, "x", "-y", "-o" + getRootPath(),
findBoostZip(getRootPath())
]
proc = subprocess.call(unzipcmd)
fixBoostFileStruct(getRootPath(), getRootPath())
if "wind" in archl:
bjam_name = "bjam.exe"
if "2013" in devtools.g_msvsVersion:
toolset_name = "--toolset=msvc-12.0"
elif "2015" in devtools.g_msvsVersion:
toolset_name = "--toolset=msvc-14.0"
elif "2017" in devtools.g_msvsVersion:
toolset_name = "--toolset=msvc-14.1"
else:
raise Exception("unknown msvs version")
bootstrap_name = "bootstrap.bat"
elif "lin" in archl or "dar" in archl:
bjam_name = "bjam"
toolset_name = ""
bootstrap_name = "bootstrap.sh"
if "dar" in archl:
toolset_name = "--toolset=clang"
sdk = devtools.getMacosSDKVersion()
sdkPath = "/Developer/SDKs/MacOSX" + sdk + ".sdk"
if os.path.isdir(sdkPath):
print "mac os x " + sdk + " sdk exists"
else:
print "please place mac os x " + sdk + " sdk to /Deveveloper"
bjam = os.path.join(getExtactedFolderPath(), bjam_name)
if not os.path.isfile(bjam):
proc = subprocess.call([
os.path.abspath(
os.path.join(getExtactedFolderPath(), bootstrap_name))
],
cwd=getExtactedFolderPath(),
env=os.environ.copy())
libdir = os.path.join(getExtactedFolderPath(), "stage", "lib")
boostlibs = [
"thread", "system", "atomic", "date_time", "filesystem", "chrono",
"coroutine", "context"
]
buildBoost = [os.path.abspath(bjam), "-q"]
buildBoost.append(toolset_name)
buildBoost.append("variant=" + build.lower())
buildBoost.append("link=static")
buildBoost.append("runtime-link=static")
buildBoost.append("define=BOOST_NO_RTTI")
buildBoost.append("define=BOOST_EXCEPTION_DISABLE")
buildBoost.append("define=BOOST_REGEX_NO_LIB")
if "x86" in archl:
buildBoost.append("architecture=x86")
elif "arm" in archl:
buildBoost.append("architecture=arm")
if "64" in archl:
buildBoost.append("address-model=64")
elif "32" in archl or "386" in archl:
buildBoost.append("address-model=32")
if "dar" in archl:
sdk = devtools.getMacosSDKVersion()
buildBoost.append("macosx-version=" + sdk)
buildBoost.append("macosx-version-min=" + sdk)
if "lin" in archl:
buildBoost.append("cxxflags=-fPIC")
if "dar" in archl:
buildBoost.append("cflags=-mmacosx-version-min=" + sdk)
# buildBoost.append("mflags=-mmacosx-version-min=" + sdk)
# buildBoost.append("mmflags=-mmacosx-version-min=" + sdk)
buildBoost.append(
"cxxflags=-fvisibility=hidden -std=c++11 -stdlib=libc++ -mmacosx-version-min="
+ sdk)
buildBoost.append(
"linkflags=-stdlib=libc++ -mmacosx-version-min=" + sdk)
buildBoost.append("-j" + str(multiprocessing.cpu_count()))
for lib in boostlibs:
buildBoost.append("--with-" + lib)
buildBoost.append("--prefix=" + installPath)
buildBoost.append(
"--build-dir=" +
os.path.abspath(os.path.join(devtools.rootDir, "3rdparty", "tmp")))
buildBoost.append("install")
print buildBoost
proc = subprocess.call(buildBoost,
cwd=getExtactedFolderPath(),
env=os.environ.copy())
def build(arch, build):
archl = arch.lower()
target_arch = "32" if "32" in archl else "64"
target_cpu = "x86" if target_arch == "32" else "x64"
installPath = devtools.getInstallPath(arch)
#if not os.path.exists(getSrcPath()):
# subprocess.check_call("fetch --nohooks webrtc", cwd=getRootPath(), shell=True)
# subprocess.check_call("git checkout -b release refs/remotes/branch-heads/68", cwd=getSrcPath(), shell=True)
subprocess.check_call("gclient sync", shell=True)
subprocess.call("git apply --ignore-whitespace ../probeoverflowfix.patch",
cwd=getSrcPath(),
shell=True)
subprocess.call(
"git apply --ignore-whitespace ../disableframedropping.patch",
cwd=getSrcPath(),
shell=True)
subprocess.call(
"git apply --ignore-whitespace ../disableaudioprocessing.patch",
cwd=getSrcPath(),
shell=True)
subprocess.call("git apply --ignore-whitespace ../exposejitter.patch",
cwd=getSrcPath(),
shell=True)
subprocess.call("git apply --ignore-whitespace ../disablepacing.patch",
cwd=getSrcPath(),
shell=True)
subprocess.call("git apply --ignore-whitespace ../fasterprobing.patch",
cwd=getSrcPath(),
shell=True)
try:
os.makedirs(os.path.dirname(getArgsPath(target_arch)))
except os.error:
pass
try:
os.makedirs(os.path.dirname(getArgsPath(target_arch + "d")))
except os.error:
pass
with open(getArgsPath(target_arch), "w") as argsFile:
argsFile.write(GN_CONFIG.format(target_cpu, "true"))
with open(getArgsPath(target_arch + "d"), "w") as argsFile:
argsFile.write(GN_CONFIG.format(target_cpu, "false"))
subprocess.check_call("gn gen out/" + target_arch,
cwd=getSrcPath(),
shell=True)
subprocess.check_call("ninja -C out/" + target_arch,
cwd=getSrcPath(),
shell=True)
subprocess.check_call("gn gen out/" + target_arch + "d",
cwd=getSrcPath(),
shell=True)
subprocess.check_call("ninja -C out/" + target_arch + "d",
cwd=getSrcPath(),
shell=True)
regex = re.compile(r".*\.lib$")
mergetree(os.path.join(getOutPath(target_arch), "obj"),
os.path.join(installPath, "lib"), regex.match)
regex = re.compile(r".*\.lib$")
mergetree(os.path.join(getOutPath(target_arch) + "d", "obj"),
os.path.join(installPath, "lib"), regex.match,
lambda n: "d".join(os.path.splitext(n)))
regex = re.compile(r".*\.h$")
mergetree(getSrcPath(), os.path.join(installPath, "include"),
lambda n: regex.match(n) and "third_party" not in n)