def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) version = GetVersion() tarballUrl = "http://www.ijg.org/files/jpegsrc.v" + version + ".tar.gz" tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand( ["wget", "-P", "./", "-O", tarballShortFilename, tarballUrl], verbose) RunCommand( ["tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename], verbose) extractedDir = os.path.join(tempPath, "jpeg-" + version) with WorkingDir(extractedDir): RunCommand( ["./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix, "--disable-shared"], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) cc = GetCc(platformData["target"]) ar = GetAr(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) try: with WorkingDir(tempPath): RunCommand( ["git", "clone", "https://github.com/haipome/utf8.git"], verbose) clonedDir = os.path.join(tempPath, "utf8") with WorkingDir(clonedDir): RunCommand( [cc, "-O2", "-Wall", "-c", "utf8.c", "-o", "utf8.o"], verbose) RunCommand([ar, "rcs", "libutf8.a", "utf8.o"], verbose) if not os.path.exists(installPrefix + "/include"): RunCommand(["mkdir", "-p", installPrefix + "/include"], verbose) if not os.path.exists(installPrefix + "/lib"): RunCommand(["mkdir", "-p", installPrefix + "/lib"], verbose) RunCommand(["cp", "./utf8.h", installPrefix + "/include"], verbose) RunCommand(["cp", "./libutf8.a", installPrefix + "/lib"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tarballUrl = GetTarballUrl() tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): RunCommand([ "./configure", "--prefix=" + installPrefix, "--host=" + targetTriplet, "--enable-pcre16", "--enable-pcre32", "--enable-jit=auto", "--enable-newline-is-any", "--enable-utf", "--enable-unicode-properties" ], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tarballUrl = GetTarballUrl() tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand( ["wget", "-P", "./", "-O", tarballShortFilename, tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): RunCommand([ "./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix, "--disable-sdltest", "CPPFLAGS=-I" + installPrefix + "/include", "LDFLAGS=-L" + installPrefix + "/lib" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): configCmake = ConfigCmake(platformData) configCmake.GenerateCrossFile() installPrefix = GetInstallPrefix(platformData) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) try: with WorkingDir(tempPath): RunCommand( ["git", "clone", "https://github.com/criptych/physfs.git"], verbose) clonedDir = os.path.join(tempPath, "physfs") with WorkingDir(clonedDir): RunCommand(["mkdir", "build"], verbose) buildDir = os.path.join(clonedDir, "build") with WorkingDir(buildDir): RunCommand([ "cmake", "..", "-DCMAKE_TOOLCHAIN_FILE=" + configCmake.GetCrossFileName(), "-DCMAKE_INSTALL_PREFIX=" + installPrefix, "-DPHYSFS_BUILD_SHARED=FALSE", "-DPHYSFS_BUILD_TEST=FALSE", "-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) ar = GetAr(platformData["target"]) cc = GetCc(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) try: with WorkingDir(tempPath): RunCommand( ["git", "clone", "https://github.com/mmalecki/saneopt.git"], verbose) clonedDir = os.path.join(tempPath, "saneopt") with WorkingDir(clonedDir): RunCommand(["make", "CC=" + cc, "AR=" + ar], verbose) if not os.path.exists(installPrefix + "/include"): RunCommand(["mkdir", "-p", installPrefix + "/include"], verbose) if not os.path.exists(installPrefix + "/lib"): RunCommand(["mkdir", "-p", installPrefix + "/lib"], verbose) RunCommand( ["cp", "./include/saneopt.h", installPrefix + "/include"], verbose) RunCommand(["cp", "./libsaneopt.a", installPrefix + "/lib"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tarballUrl = requests.get( "https://sourceforge.net/projects/modplug-xmms/best_release.json" ).json()["release"]["url"] tarballShortFilename = tarballUrl.split("/")[-2] try: with WorkingDir(tempPath): RunCommand( ["wget", "-P", "./", "-O", tarballShortFilename, tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): RunCommand([ "./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix, "--enable-static=yes", "--disable-shared" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) sourceforgeMirrorsManager = mirrors["sourceforge"].CreateMirrorsManager( ["https", "http"]) filename = requests.get( "https://sourceforge.net/projects/pcre/best_release.json").json( )["release"]["filename"] arhiveShortFilename = filename.split("/")[-1] try: with WorkingDir(tempPath): SourceforgeDownloadTarballWhileErrorcodeFour( sourceforgeMirrorsManager, "pcre", filename, verbose) RunCommand(["unzip", arhiveShortFilename], verbose) extractedDir = os.path.join(tempPath, arhiveShortFilename[0:-4]) with WorkingDir(extractedDir): RunCommand([ "./configure", "--prefix=" + installPrefix, "--host=" + targetTriplet, "--enable-pcre2-16", "--enable-pcre2-32", "--enable-jit=auto", "--enable-newline-is-any" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) xorgMirrorsManager = mirrors["xorg"].CreateMirrorsManager( ["https", "http"]) tarballUrl = GetTarballUrl(xorgMirrorsManager) tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand( ["tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): RunCommand( ["./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) pkgConfig = GetPkgConfig(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tarballUrl = requests.get( "https://sourceforge.net/projects/freetype/best_release.json" ).json()["release"]["url"] tarballShortFilename = tarballUrl.split("/")[-2] if os.path.exists(installPrefix + "/lib/libharfbuzz.a"): withHarfbuzz = "yes" else: withHarfbuzz = "no" try: with WorkingDir(tempPath): RunCommand( ["wget", "-P", "./", "-O", tarballShortFilename, tarballUrl], verbose) RunCommand( ["tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): try: RunCommand( ["./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix, "--disable-shared", "--with-zlib=yes", "--with-bzip2=yes", "--with-png=yes", "--with-harfbuzz=" + withHarfbuzz, "--with-old-mac-fonts", "PKG_CONFIG=" + pkgConfig, "PKG_CONFIG_PATH=" + installPrefix + "/lib/pkgconfig", "BZIP2_CFLAGS=-I" + installPrefix + "/include", "BZIP2_LIBS=-L" + installPrefix + "/lib -lbz2", "HARFBUZZ_CFLAGS=-I" + installPrefix + "/include/harfbuzz", "HARFBUZZ_LIBS=-L" + installPrefix + "/lib -lharfbuzz"], verbose) except CommandError as e: try: RunCommand(["cat", "./config.log"], verbose) except CommandError: print("VGAZER: 'config.log' not found") finally: raise e RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): configCmake = ConfigCmake(platformData) configCmake.GenerateCrossFile() installPrefix = GetInstallPrefix(platformData) ar = GetArFullPath(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) releases = auth["github"].GetJson( "https://api.github.com/repos/jtanx/libclipboard/releases") if GithubCheckApiRateLimitExceeded(releases): raise GithubApiRateLimitExceeded( "Github API rate limit reached while searching last version of " "repo: jtanx/libclipboard") tarballUrl = releases[0]["tarball_url"] tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) output = GetCommandOutputUtf8( ["tar", "--list", "--file", tarballShortFilename]) extractedDir = os.path.join(tempPath, output.splitlines()[0].split("/")[0]) with WorkingDir(extractedDir): RunCommand(["mkdir", "build"], verbose) buildDir = os.path.join(extractedDir, "build") with WorkingDir(buildDir): RunCommand([ "sed", "-i", "s" "# include/libclipboard-config.h" "# ${CMAKE_BINARY_DIR}/include/libclipboard-config.h" "#g", "../CMakeLists.txt" ], verbose) RunCommand([ "cmake", "..", "-DCMAKE_TOOLCHAIN_FILE=" + configCmake.GetCrossFileName(), "-DCMAKE_INSTALL_PREFIX=" + installPrefix, "-DCMAKE_C_FLAGS=-std=c99 -Wall -pedantic -g -I./include " "-I../include -D_POSIX_C_SOURCE=199309L", "-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON", "-DCMAKE_AR=" + ar ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) # ar = GetAr(platformData["target"]) + " rcu" # cc = GetCc(platformData["target"]) triplet = GetTriplet(platformData["target"]) # ranlib = GetRanlib(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tarballUrl = GetTarballUrl() tarballShortFilename = tarballUrl.split("/")[-1] # luaTarget = { # "linux": "linux", # "windows": "mingw", # }[platformData["target"].GetOs()] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): # We need not Lua commandline tools, because it depends on readline # library. We need not extra depends like it. We need unly lua # library. This arguments prevent building commandline tools: # TO_BIN= # LUA_T= # LUAC_T= # INSTALL_BIN= # INSTALL_EXEC=true RunCommand([ "make", "BUILDMODE=static", "CROSS=" + triplet + "-", "TARGET_SYS=" + platformData["target"].GetOs().capitalize() ], verbose) RunCommand(["make", "install", "PREFIX=" + installPrefix], verbose) # RunCommand( # ["make", luaTarget, "CC=" + cc, "AR=" + ar, "RANLIB=" + ranlib, # "TO_BIN=", "LUA_T=", "LUAC_T="], # verbose) # RunCommand( # ["make", luaTarget, "install", "INSTALL_TOP=" + installPrefix, # "TO_BIN=", "LUA_T=", "LUAC_T=", "INSTALL_BIN=", # "INSTALL_EXEC=true"], # verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
class ConfigMeson(): def __init__(self, platformData): self.storeTemp = StoreTemp(".vgazer/meson") self.crossFileName = self.storeTemp.GetDirectoryFilePath("cross-file") self.storeTemp.ResolveDirectory() self.platformData = platformData def GetCrossFileName(self): return self.crossFileName def GenerateCrossFile(self): print("VGAZER: Generating Meson cross-build definition file...") ar = GetAr(self.platformData["target"]) cc = GetCc(self.platformData["target"]) cxx = GetCxx(self.platformData["target"]) pkgConfig = GetPkgConfig(self.platformData["target"]) strip = GetStrip(self.platformData["target"]) llvmConfig = GetLlvmConfig(self.platformData["target"]) genericOs = Platform.GetGenericOs(self.platformData["target"].GetOs()) if self.platformData["target"].GetArch() in [ "i386", "i486", "i586", "i686" ]: mesonCpuFamily = "x86" mesonCpu = self.platformData["target"].GetArch() elif self.platformData["target"].GetArch() == "x86_64": mesonCpuFamily = "x86_64" mesonCpu = "x86_64" else: raise UnknownTargetArch("Unknown target architecture: " + self.platformData["target"].GetArch()) self.storeTemp.DirectoryWriteTextFile( "cross-file", "[binaries]\n" "c = '{cc}'\n" "cpp = '{cxx}'\n" "ar = '{ar}'\n" "strip = '{strip}'\n" "pkgconfig = '{pkgConfig}'\n" "llvm-config = '{llvmConfig}'\n" "\n" "[host_machine]\n" "system = '{genericOs}'\n" "cpu_family = '{mesonCpuFamily}'\n" "cpu = '{mesonCpu}'\n" "endian = 'little'".format(ar=ar, cc=cc, cxx=cxx, pkgConfig=pkgConfig, llvmConfig=llvmConfig, strip=strip, genericOs=genericOs, mesonCpuFamily=mesonCpuFamily, mesonCpu=mesonCpu))
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) # ar = GetAr(platformData["target"]) # cc = GetCc(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) try: with WorkingDir(tempPath): RunCommand([ "git", "clone", "https://github.com/AltSysrq/libbsd-minimal.git" ], verbose) clonedDir = os.path.join(tempPath, "libbsd-minimal") with WorkingDir(clonedDir): RunCommand(["libtoolize"], verbose) RunCommand(["aclocal"], verbose) RunCommand(["autoheader"], verbose) # RunCommand(["automake"], verbose) RunCommand(["automake", "--add-missing"], verbose) RunCommand(["autoreconf"], verbose) RunCommand([ "./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix, "--disable-shared", "CFLAGS=-D__THROW= -include features.h" ], verbose) RunCommand([ "sed", "-i", "s" "/#define __nonnull(x)\t__attribute__((__nonnull__(x)))" "/#define __nonnull(x) __attribute__((__nonnull__ x))" "/g", "include/bsd/sys/freebsd-cdefs.h" ], verbose) RunCommand(["make", "V=1"], verbose) RunCommand(["make", "install"], verbose) # RunCommand(["make", "CC=" + cc, "AR=" + ar], verbose) # if not os.path.exists(installPrefix + "/include"): # RunCommand(["mkdir", "-p", installPrefix + "/include"], # verbose) # if not os.path.exists(installPrefix + "/lib"): # RunCommand(["mkdir", "-p", installPrefix + "/lib"], verbose) # RunCommand( # ["cp", "./include/saneopt.h", installPrefix + "/include"], # verbose) # RunCommand(["cp", "./libsaneopt.a", installPrefix + "/lib"], # verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): configCmake = ConfigCmake(platformData) configCmake.GenerateCrossFile() installPrefix = GetInstallPrefix(platformData) ar = GetArFullPath(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) minorVersionLink = GetMinorVersionLink() response = requests.get(minorVersionLink) html = response.content.decode("utf-8") parsedHtml = BeautifulSoup(html, "html.parser") links = parsedHtml.find_all("a") tarballUrl = minorVersionLink + "/" + links[-2]["href"] tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--xz", "--file", tarballShortFilename ], verbose) output = GetCommandOutputUtf8( ["tar", "--list", "--file", tarballShortFilename]) extractedDir = os.path.join(tempPath, output.splitlines()[0].split("/")[0]) with WorkingDir(extractedDir): RunCommand(["mkdir", "build"], verbose) buildDir = os.path.join(extractedDir, "build") with WorkingDir(buildDir): RunCommand([ "cmake", "..", "-DCMAKE_TOOLCHAIN_FILE=" + configCmake.GetCrossFileName(), "-DCMAKE_BUILD_TYPE=Debug", "-DCMAKE_INSTALL_PREFIX=" + installPrefix, "-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON", "-DCMAKE_AR=" + ar, "-DWITH_STATIC_LIB=ON" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) ar = GetAr(platformData["target"]) cc = GetCc(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tags = auth["github"].GetJson( "https://api.github.com/repos/XadillaX/xmempool/tags") if GithubCheckApiRateLimitExceeded(tags): raise GithubApiRateLimitExceeded( "Github API rate limit reached while searching last version of " "repo: ryanlederman/libsir") tarballUrl = tags[0]["tarball_url"] tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) output = GetCommandOutputUtf8( ["tar", "--list", "--file", tarballShortFilename]) extractedDir = os.path.join(tempPath, output.splitlines()[0].split("/")[0]) with WorkingDir(extractedDir): RunCommand([ "sed", "-i", "s/(unsigned int)pool->start,/pool->start,/g; " "s/(unsigned int)pool->end);/pool->end);/g", "xmempool.c" ], verbose) RunCommand(["make", "static", "CC=" + cc, "AR=" + ar], verbose) if not os.path.exists(installPrefix + "/include"): RunCommand(["mkdir", "-p", installPrefix + "/include"], verbose) if not os.path.exists(installPrefix + "/lib"): RunCommand(["mkdir", "-p", installPrefix + "/lib"], verbose) RunCommand( ["cp", "xmempool.a", installPrefix + "/lib/libxmempool.a"], verbose) RunCommand(["cp", "xmempool.h", installPrefix + "/include"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) ar = GetAr(platformData["target"]) cc = GetCc(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) releases = auth["github"].GetJson( "https://api.github.com/repos/benhoyt/inih/releases") if GithubCheckApiRateLimitExceeded(releases): raise GithubApiRateLimitExceeded( "Github API rate limit reached while searching last version of " "repo: benhoyt/inih") tarballUrl = releases[0]["tarball_url"] tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) output = GetCommandOutputUtf8( ["tar", "--list", "--file", tarballShortFilename]) extractedDir = os.path.join(tempPath, output.splitlines()[0].split("/")[0]) with WorkingDir(extractedDir): RunCommand([ cc, "-c", "ini.c", "-o", "ini.o", "-O2", "-Wall", "-fPIC", "-DINI_STOP_ON_FIRST_ERROR=1", "-DINI_HANDLER_LINENO=1", "-DINI_CALL_HANDLER_ON_NEW_SECTION=1", "-DINI_USE_STACK=0", "-DINI_ALLOW_REALLOC=1" ], verbose) RunCommand([ar, "rcs", "libinih.a", "ini.o"], verbose) if not os.path.exists(installPrefix + "/include"): RunCommand(["mkdir", "-p", installPrefix + "/include"], verbose) if not os.path.exists(installPrefix + "/lib"): RunCommand(["mkdir", "-p", installPrefix + "/lib"], verbose) RunCommand(["cp", "./ini.h", installPrefix + "/include"], verbose) RunCommand(["cp", "./libinih.a", installPrefix + "/lib"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tags = auth["github"].GetJson( "https://api.github.com/repos/freedesktop/xorg-libpciaccess/tags") if GithubCheckApiRateLimitExceeded(tags): raise GithubApiRateLimitExceeded( "Github API rate limit reached while searching last version of " "repo: freedesktop/xorg-libpciaccess") tagNum = 0 for tag in tags: if tag["name"] in [ "xf86-video-xgi-0.9.1", ]: tagNum = tagNum + 1 else: break tarballUrl = tags[tagNum]["tarball_url"] tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) output = GetCommandOutputUtf8( ["tar", "--list", "--file", tarballShortFilename]) extractedDir = os.path.join(tempPath, output.splitlines()[0].split("/")[0]) with WorkingDir(extractedDir): RunCommand([ "./autogen.sh", "--host=" + targetTriplet, "--prefix=" + installPrefix ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): configCmake = ConfigCmake(platformData) configCmake.GenerateCrossFile() installPrefix = GetInstallPrefix(platformData) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) releases = auth["github"].GetJson( "https://api.github.com/repos/harfbuzz/harfbuzz/releases") if GithubCheckApiRateLimitExceeded(releases): raise GithubApiRateLimitExceeded( "Github API rate limit reached while searching last version of " "repo: harfbuzz/harfbuzz") tarballUrl = releases[0]["tarball_url"] tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) output = GetCommandOutputUtf8( ["tar", "--list", "--file", tarballShortFilename]) extractedDir = os.path.join(tempPath, output.splitlines()[0].split("/")[0]) with WorkingDir(extractedDir): RunCommand(["mkdir", "build"], verbose) buildDir = os.path.join(extractedDir, "build") with WorkingDir(buildDir): RunCommand([ "cmake", "..", "-DCMAKE_TOOLCHAIN_FILE=" + configCmake.GetCrossFileName(), "-DCMAKE_INSTALL_PREFIX=" + installPrefix, "-DHB_HAVE_FREETYPE=ON", "-DHB_HAVE_GRAPHITE2=ON", "-DHB_HAVE_GLIB=ON", "-DHB_HAVE_ICU=ON", "-DHB_BUILD_TESTS=OFF", "-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) pkgConfig = GetPkgConfig(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tarballUrl = GetTarballUrl() tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand( ["wget", "-P", "./", "-O", tarballShortFilename, tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): #tiffLibs = GetCommandOutputUtf8( #[pkgConfig, "--libs", "--static", "libtiff-4"], verbose=False) #RunCommand( #["sed", "-i", #"-e", "s/" #"AC_CHECK_LIB(" #"[tiff], [TIFFClientOpen], [have_tif_lib=yes], [], [-lz]" #")/" #"AC_CHECK_LIB(" #"[tiff], [TIFFClientOpen], [have_tif_lib=yes], [], " #"[" + tiffLibs + "]" #")/g", #"./configure.in"], #verbose) #RunCommand(["./autogen.sh"], verbose) RunCommand([ "./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix, "--disable-sdltest", "CPPFLAGS=-I" + installPrefix + "/include", "LDFLAGS=-L" + installPrefix + "/lib" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tarballUrl = requests.get( "https://sourceforge.net/projects/mpg123/best_release.json").json( )["release"]["url"] tarballShortFilename = tarballUrl.split("/")[-2] if platformData["target"].GetArch() == "i386": cpu = "i386_fpu" elif platformData["target"].GetArch() == "i486": cpu = "i486" elif platformData["target"].GetArch() in ["i586", "i686"]: cpu = "i586_dither" elif platformData["target"].GetArch() == "x86_64": cpu = "x86-64" else: raise UnknownTargetArch("Unknown target architecture: " + platformData["target"].GetArch()) try: with WorkingDir(tempPath): RunCommand( ["wget", "-P", "./", "-O", tarballShortFilename, tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--bzip2", "--file", tarballShortFilename ], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-8]) with WorkingDir(extractedDir): RunCommand([ "./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix, "--enable-nagging=no", "--enable-ipv6=yes", "--enable-network=yes", "--with-cpu=" + cpu, "--with-audio=dummy", "--with-default-audio=dummy" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) cc = GetCc(platformData["target"]) ar = GetAr(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) sourceforgeMirrorsManager = mirrors["sourceforge"].CreateMirrorsManager( ["https", "http"]) filename = requests.get( "https://sourceforge.net/projects/tinyfiledialogs/best_release.json" ).json()["release"]["filename"] archiveShortFilename = filename.split("/")[-1] try: with WorkingDir(tempPath): SourceforgeDownloadTarballWhileErrorcodeFour( sourceforgeMirrorsManager, "tinyfiledialogs", filename, verbose) RunCommand(["unzip", archiveShortFilename], verbose) extractedDir = os.path.join(tempPath, archiveShortFilename[0:-4]) with WorkingDir(extractedDir): RunCommand([ cc, "-c", "tinyfiledialogs.c", "-o", "tinyfiledialogs.o", "-O2", "-Wall", "-fPIC" ], verbose) RunCommand( [ar, "rcs", "libtinyfiledialogs.a", "tinyfiledialogs.o"], verbose) if not os.path.exists(installPrefix + "/include"): RunCommand(["mkdir", "-p", installPrefix + "/include"], verbose) if not os.path.exists(installPrefix + "/lib"): RunCommand(["mkdir", "-p", installPrefix + "/lib"], verbose) RunCommand( ["cp", "./tinyfiledialogs.h", installPrefix + "/include"], verbose) RunCommand( ["cp", "./libtinyfiledialogs.a", installPrefix + "/lib"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): configMeson = ConfigMeson(platformData) configMeson.GenerateCrossFile() installPrefix = GetInstallPrefix(platformData) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tags = auth["base"].GetJson( "https://gitlab.freedesktop.org/api/v4/projects/887/repository/tags") tarballUrl = ( "https://gitlab.freedesktop.org/api/v4/projects/887/repository/" "archive.tar.gz?sha=" + tags[0]["name"]) tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) output = GetCommandOutputUtf8( ["tar", "--list", "--file", tarballShortFilename]) extractedDir = os.path.join(tempPath, output.splitlines()[0].split("/")[0]) with WorkingDir(extractedDir): RunCommand(["mkdir", "build"], verbose) SetEnvVar("PKG_CONFIG_PATH", installPrefix + "/lib/pkgconfig") buildDir = os.path.join(extractedDir, "build") with WorkingDir(buildDir): RunCommand([ "meson", "--prefix=" + installPrefix, "--libdir=" + installPrefix + "/lib", "--cross-file", configMeson.GetCrossFileName(), "-Ddocumentation=false" ], verbose) RunCommand( ["ln", "-s", installPrefix + "/include/X11", "../include/X11"], verbose) RunCommand(["ninja"], verbose) RunCommand(["ninja", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) sourceforgeMirrorsManager = mirrors["sourceforge"].CreateMirrorsManager( ["https", "http"]) filename = requests.get( "https://sourceforge.net/projects/sdl2gfx/best_release.json").json( )["release"]["filename"] tarballShortFilename = filename.split("/")[-1] try: with WorkingDir(tempPath): SourceforgeDownloadTarballWhileErrorcodeFour( sourceforgeMirrorsManager, "sdl2gfx", filename, verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): RunCommand([ "wget", "-O", "config.guess", "https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;" "f=config.guess;hb=HEAD" ], verbose) RunCommand([ "wget", "-O", "config.sub", "https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;" "f=config.sub;hb=HEAD" ], verbose) RunCommand([ "./configure", "--prefix=" + installPrefix, "--host=" + targetTriplet, "--disable-dependency-tracking", "--disable-sdltest" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
class ConfigCmake(): def __init__(self, platformData): self.storeTemp = StoreTemp(".vgazer/cmake") self.crossFileName = self.storeTemp.GetDirectoryFilePath( "toolchain.cmake") self.storeTemp.ResolveDirectory() self.platformData = platformData def GetCrossFileName(self): return self.crossFileName def GenerateCrossFile(self): print("VGAZER: Generating CMake toolchain file...") cmakeOs = Platform.GetGenericOs( self.platformData["target"].GetOs()).capitalize() prefix = GetInstallPrefix(self.platformData) targetTriplet = GetTriplet(self.platformData["target"]) cc = GetCc(self.platformData["target"]) cxx = GetCxx(self.platformData["target"]) if self.platformData["target"].PlatformsEqual( self.platformData["host"]): findMode = "BOTH" else: findMode = "ONLY" self.storeTemp.DirectoryWriteTextFile( "toolchain.cmake", "set(CMAKE_SYSTEM_NAME {cmakeOs})\n" "set(CMAKE_SYSTEM_PROCESSOR {cpu})\n" "set(CMAKE_C_COMPILER {cc})\n" "set(CMAKE_CXX_COMPILER {cxx})\n" "set(CMAKE_FIND_ROOT_PATH {prefix})\n" "SET(" "ENV{{PKG_CONFIG_LIBDIR}} " "${{CMAKE_FIND_ROOT_PATH}}/lib/pkgconfig/:" "/usr/lib/{triplet}/pkgconfig" ")\n" "SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)\n" "SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY {findMode})\n" "SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE {findMode})".format( cmakeOs=cmakeOs, cpu=self.platformData["target"].GetArch(), cc=cc, cxx=cxx, prefix=prefix, triplet=targetTriplet, findMode=findMode))
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) ar = GetAr(platformData["target"]) cxx = GetCxx(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) archiveUrl = GetArchiveUrl(auth) arhiveShortFilename = archiveUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["mkdir", "build"], verbose) buildDir = os.path.join(tempPath, "build") with WorkingDir(buildDir): RunCommand(["wget", "-P", "./", archiveUrl], verbose) RunCommand(["unzip", arhiveShortFilename], verbose) sourcesDir = os.path.join(buildDir, "Sources") with WorkingDir(sourcesDir): RunCommand([ "sed", "-i", "-e", "s/g++/$(CXX)/g", "-e", "s/\\tar/\\t$(AR)/g", "./makefile" ], verbose) RunCommand(["mkdir", "-p", "./../Binaries"], verbose) RunCommand(["mkdir", "-p", "./../Binaries/Temp"], verbose) RunCommand( ["make", "./../Binaries/libP7.so", "CXX=" + cxx, "AR=" + ar], verbose) with WorkingDir(buildDir): if not os.path.exists(installPrefix + "/include"): RunCommand(["mkdir", "-p", installPrefix + "/include"], verbose) if not os.path.exists(installPrefix + "/lib"): RunCommand(["mkdir", "-p", installPrefix + "/lib"], verbose) RunCommand( ["sh", "-c", "cp ./Headers/*.h " + installPrefix + "/include"], verbose) RunCommand(["cp", "./Binaries/libP7.so", installPrefix + "/lib"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) cc = GetCc(platformData["target"]) cflags = "-Wall -Winline -O2 -g -D_FILE_OFFSED_BITS=64 -fPIC" ar = GetAr(platformData["target"]) ranlib = GetRanlib(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) sourceforgeMirrorsManager = mirrors["sourceforge"].CreateMirrorsManager( ["https", "http"]) filename = requests.get( "https://sourceforge.net/projects/bzip2/best_release.json").json( )["release"]["filename"] tarballShortFilename = filename.split("/")[-1] try: with WorkingDir(tempPath): SourceforgeDownloadTarballWhileErrorcodeFour( sourceforgeMirrorsManager, "bzip2", filename, verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): RunCommand([ "make", "libbz2.a", "CC=" + cc, "AR=" + ar, "RANLIB=" + ranlib, "CFLAGS=" + cflags ], verbose) if not os.path.exists(installPrefix + "/include"): RunCommand(["mkdir", "-p", installPrefix + "/include"], verbose) if not os.path.exists(installPrefix + "/lib"): RunCommand(["mkdir", "-p", installPrefix + "/lib"], verbose) RunCommand(["cp", "./bzlib.h", installPrefix + "/include"], verbose) RunCommand(["cp", "./libbz2.a", installPrefix + "/lib"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) releases = auth["github"].GetJson( "https://api.github.com/repos/intel/libva/releases") if GithubCheckApiRateLimitExceeded(releases): raise GithubApiRateLimitExceeded( "Github API rate limit reached while searching last version of " "repo: intel/libva" ) tarballUrl = releases[0]["tarball_url"] tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand( ["tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename], verbose) output = GetCommandOutputUtf8( ["tar", "--list", "--file", tarballShortFilename] ) extractedDir = os.path.join(tempPath, output.splitlines()[0].split("/")[0]) with WorkingDir(extractedDir): RunCommand( ["./autogen.sh", "--host=" + targetTriplet, "--prefix=" + installPrefix, "PKG_CONFIG_PATH=" + installPrefix + "/lib/pkgconfig"], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) xorgMirrorsManager = mirrors["xorg"].CreateMirrorsManager( ["https", "http"]) tarballUrl = GetTarballUrl(xorgMirrorsManager, suburl="individual/lib/", projectName="xlib", linksMustHave=["libX11-", ".tar.gz"], linksMustNotHave=[".sig"]) tarballShortFilename = tarballUrl.split("/")[-1] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand( ["tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename], verbose) extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7]) with WorkingDir(extractedDir): RunCommand( [ "./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix, "CPPFLAGS=-I" + installPrefix + "/include", "PKG_CONFIG_PATH={installPrefix}/lib/pkgconfig:" "{installPrefix}/share/pkgconfig".format( installPrefix=installPrefix) ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")
def Install(auth, software, platform, platformData, mirrors, verbose): installPrefix = GetInstallPrefix(platformData) targetTriplet = GetTriplet(platformData["target"]) storeTemp = StoreTemp() storeTemp.ResolveEmptySubdirectory(software) tempPath = storeTemp.GetSubdirectoryPath(software) tarballUrl = GetTarballUrl() tarballShortFilename = tarballUrl.split("/")[-1] libs = { "linux": "LIBS=-lasound", "windows": "", }[platformData["target"].GetOs()] try: with WorkingDir(tempPath): RunCommand(["wget", "-P", "./", tarballUrl], verbose) RunCommand([ "tar", "--verbose", "--extract", "--gzip", "--file", tarballShortFilename ], verbose) extractedDir = os.path.join(tempPath, "portaudio") with WorkingDir(extractedDir): RunCommand([ "./configure", "--host=" + targetTriplet, "--prefix=" + installPrefix, "--disable-shared", "--with-alsa=yes", "--with-oss=yes", "--with-winapi=wmme,directx,wdmks", "LDFLAGS=-L" + installPrefix + "/lib", libs, "CPPFLAGS=-I" + installPrefix + "/include" ], verbose) RunCommand([ "sed", "-i", "-e", "s#CFLAGS = #CFLAGS = -I" + installPrefix + "/include #g", "./Makefile" ], verbose) RunCommand(["make"], verbose) RunCommand(["make", "install"], verbose) except CommandError: print("VGAZER: Unable to install", software) raise InstallError(software + " not installed") print("VGAZER:", software, "installed")