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)
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):
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):
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")
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):
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)
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):
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)
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")
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)
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")
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)
tags = auth["base"].GetJson(
"https://gitlab.freedesktop.org/api/v4/projects/715/repository/tags")
tarballUrl = (
"https://gitlab.freedesktop.org/api/v4/projects/715/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([
"./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)
sourceforgeMirrorsManager = mirrors["sourceforge"].CreateMirrorsManager(
["https", "http"])
filename = requests.get(
"https://sourceforge.net/projects/libpng/best_release.json").json(
)["release"]["filename"]
tarballShortFilename = filename.split("/")[-1]
try:
with WorkingDir(tempPath):
SourceforgeDownloadTarballWhileErrorcodeFour(
sourceforgeMirrorsManager, "libpng", filename, verbose)
RunCommand([
"tar", "--verbose", "--extract", "--xz", "--file",
tarballShortFilename
], verbose)
extractedDir = os.path.join(tempPath, tarballShortFilename[0:-7])
with WorkingDir(extractedDir):
RunCommand([
"./configure", "--host=" + targetTriplet,
"--prefix=" + installPrefix, "--disable-shared",
"--enable-hardware-optimizations=yes",
"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 = 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.split(".tar.gz")[0])
with WorkingDir(extractedDir):
RunCommand(["./autogen.sh"], verbose)
RunCommand(
[
"./configure", "--prefix=" + installPrefix,
"--host=" + targetTriplet, "--disable-static",
"--disable-all-programs", "--enable-libblkid",
"--enable-libmount"
],
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]
if platformData["target"].GetArch() in ["i386", "i486", "i586", "i686"]:
gccArch = platformData["target"].GetArch()
elif platformData["target"].GetArch() == "x86_64":
gccArch = "x86-64"
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, "--disable-shared",
"--enable-portable-binary", "--with-gcc-arch=" + gccArch
], 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 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)
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", "--xz", "--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", "--disable-thorough-tests",
"--disable-doxygen-docs", "--disable-xmms-plugin",
"--disable-cpplibs", "--enable-ogg", "--disable-oggtest"
], 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"])
targetOs = platformData["target"].GetOs()
cc = GetCc(platformData["target"])
ar = GetAr(platformData["target"])
strip = GetStrip(platformData["target"])
storeTemp = StoreTemp()
storeTemp.ResolveEmptySubdirectory(software)
tempPath = storeTemp.GetSubdirectoryPath(software)
sourceforgeMirrorsManager = mirrors["sourceforge"].CreateMirrorsManager(
["https", "http"])
filename = requests.get(
"https://sourceforge.net/projects/glew/best_release.json").json(
)["release"]["filename"]
tarballShortFilename = filename.split("/")[-1]
try:
with WorkingDir(tempPath):
SourceforgeDownloadTarballWhileErrorcodeFour(
sourceforgeMirrorsManager, "glew", filename, verbose)
RunCommand([
"tar", "--verbose", "--extract", "--gzip", "--file",
tarballShortFilename
], verbose)
extractedDir = os.path.join(tempPath, tarballShortFilename[0:-4])
with WorkingDir(extractedDir):
if targetOs == "windows":
RunCommand([
"make", "glew.lib.static", "SYSTEM=linux-mingw64",
"HOST=" + targetTriplet, "AR=" + ar, "STRIP=" + strip,
"CFLAGS.EXTRA=-I" + installPrefix + "/include -fPIC",
"LDFLAGS.EXTRA=-L" + installPrefix + "/lib"
], verbose)
RunCommand([
"make", "install.include", "SYSTEM=linux-mingw64",
"GLEW_PREFIX=" + installPrefix,
"GLEW_DEST=" + installPrefix
], verbose)
if not os.path.exists(installPrefix + "/lib"):
RunCommand(["mkdir", "-p", installPrefix + "/lib"],
verbose)
#if not os.path.exists(installPrefix + "/bin"):
#RunCommand(["mkdir", "-p", installPrefix + "/bin"],
#verbose)
RunCommand(["cp", "lib/libglew32.a", installPrefix + "/lib"],
verbose)
#RunCommand(["cp", "lib/glew32.dll", installPrefix + "/bin"],
#verbose)
RunCommand([
"make", "install.pkgconfig", "SYSTEM=linux-mingw64",
"GLEW_PREFIX=" + installPrefix,
"GLEW_DEST=" + installPrefix
], verbose)
else:
RunCommand([
"make", "glew.lib", "CC=" + cc, "LD=" + cc, "AR=" + ar,
"STRIP=" + strip,
"CFLAGS.EXTRA=-I" + installPrefix + "/include -fPIC",
"LDFLAGS.EXTRA=-L" + installPrefix + "/lib"
], verbose)
RunCommand([
"make", "install", "GLEW_PREFIX=" + installPrefix,
"GLEW_DEST=" + installPrefix
], 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):
isCrossbuild = not (platformData["target"].PlatformsEqual(
platformData["host"]))
hostBitness = GetBitness(platformData["host"])
hostTriplet = GetTriplet(platformData["host"])
hostCc = GetCc(platformData["host"])
hostCxx = GetCxx(platformData["host"])
hostOs = platformData["host"].GetOs()
hostIcuPlatformName = GetIcuPlatformName(
platformData["host"].GetGenericOs(hostOs))
if isCrossbuild:
hostInstallPrefix = "/usr/local"
targetInstallPrefix = GetInstallPrefix(platformData)
targetTriplet = GetTriplet(platformData["target"])
targetCc = GetCc(platformData["target"])
targetCxx = GetCxx(platformData["target"])
targetOs = platformData["host"].GetOs()
targetIcuPlatformName = GetIcuPlatformName(
platformData["target"].GetGenericOs(targetOs))
else:
hostInstallPrefix = GetInstallPrefix(platformData)
storeTemp = StoreTemp()
storeTemp.ResolveEmptySubdirectory(software)
tempPath = storeTemp.GetSubdirectoryPath(software)
releases = auth["github"].GetJson(
"https://api.github.com/repos/unicode-org/icu/releases")
if GithubCheckApiRateLimitExceeded(releases):
raise GithubApiRateLimitExceeded(
"Github API rate limit reached while searching last version of "
"repo: unicode-org/icu")
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", "icu4c/hostBuild"], verbose)
hostBuildDir = os.path.join(extractedDir, "icu4c/hostBuild")
with WorkingDir(hostBuildDir):
RunCommand([
"../source/runConfigureICU", hostIcuPlatformName,
"--host=" + hostTriplet, "--prefix=" + hostInstallPrefix,
"--disable-shared", "--enable-static=yes",
"--enable-extras=no", "--enable-icuio=no",
"--enable-layoutex=no", "--enable-tools", "--enable-tests=no",
"--enable-samples=no", "--with-library-bits=" +
str(hostBitness), "CC=" + hostCc, "CXX=" + hostCxx
], verbose)
RunCommand(["make"], verbose)
if not isCrossbuild:
RunCommand(["make", "install"], verbose)
if isCrossbuild:
with WorkingDir(extractedDir):
RunCommand(["mkdir", "icu4c/targetBuild"], verbose)
targetBuildDir = os.path.join(extractedDir, "icu4c/targetBuild")
with WorkingDir(targetBuildDir):
RunCommand([
"../source/runConfigureICU", targetIcuPlatformName,
"--host=" + targetTriplet,
"--prefix=" + targetInstallPrefix,
"--with-cross-build=" + hostBuildDir, "--disable-shared",
"--enable-static=yes", "--enable-extras=no",
"--enable-icuio=no", "--enable-layoutex=no",
"--enable-tools", "--enable-tests=no",
"--enable-samples=no", "CC=" + targetCc, "CXX=" + targetCxx
], 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):
targetOs = platformData["target"].GetOs()
if targetOs == "linux":
configCmake = ConfigCmake(platformData)
configCmake.GenerateCrossFile()
elif targetOs == "windows":
targetTriplet = GetTriplet(platformData["target"])
pkgConfig = GetPkgConfig(platformData["target"])
else:
raise UnknownOs("Unknown OS: " + targetOs)
installPrefix = GetInstallPrefix(platformData)
storeTemp = StoreTemp()
storeTemp.ResolveEmptySubdirectory(software)
tempPath = storeTemp.GetSubdirectoryPath(software)
releases = auth["github"].GetJson(
"https://api.github.com/repos/libts/tslib/releases")
if GithubCheckApiRateLimitExceeded(releases):
raise GithubApiRateLimitExceeded(
"Github API rate limit reached while searching last version of "
"repo: libts/tslib")
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)
if targetOs == "windows":
RunCommand(["./autogen.sh"], verbose)
buildDir = os.path.join(extractedDir, "build")
with WorkingDir(buildDir):
if targetOs == "linux":
RunCommand([
"cmake", "..",
"-DCMAKE_TOOLCHAIN_FILE=" + configCmake.GetCrossFileName(),
"-DCMAKE_INSTALL_PREFIX=" + installPrefix,
"-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON", "-DENABLE_TOOLS=OFF"
], verbose)
RunCommand(["cmake", "--build", "."], verbose)
RunCommand(["cmake", "-P", "cmake_install.cmake"], verbose)
elif targetOs == "windows":
RunCommand([
"../configure", "--host=" + targetTriplet, "--prefix=" +
installPrefix, "--disable-input", "--disable-touchkit",
"--disable-waveshare", "PKG_CONFIG=" + 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)
tags = auth["github"].GetJson(
"https://api.github.com/repos/freedesktop/libXext/tags")
if GithubCheckApiRateLimitExceeded(tags):
raise GithubApiRateLimitExceeded(
"Github API rate limit reached while searching last version of "
"repo: freedesktop/libXext"
)
tagNum = 0
for tag in tags:
if tag["name"] in [
"xo-6_7_0",
"xf86-012804-2330",
"xf86-4_4_99_1",
"xf86-4_4_0",
"xf86-4_3_99_903",
"xf86-4_3_99_903_special",
"xf86-4_3_99_902",
"xf86-4_3_99_901",
"xf86-4_3_99_16",
"xf86-4_3_0_1",
"sco_port_update-base",
"rel-0-6-1",
"lg3d-rel-0-7-0",
]:
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,
"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")
