Example #1
0
def build():
    #needed by mozilla patch, swig must be run again
    shelltools.cd("python")
    shelltools.system("./swig_lcms")
    shelltools.cd("..")

    autotools.make()
Example #2
0
def setup():
    shelltools.export("PTHREAD_LIBS", "-lpthread")
    shelltools.system("./autogen.sh")
    autotools.autoreconf("-vif")
    autotools.configure("--disable-static")
    
    pisitools.dosed("libtool", " -shared ", " -Wl,-O1,--as-needed -shared ")
Example #3
0
def setup():
    for (path, dirs, files) in os.walk(get.workDIR()):
        for file in files:
            if file.endswith(".c"):
                with open("%s/%s" % (path, file)) as f:
                    lines = f.readlines()
                new_file = ""
                for line in lines:
                    if not line.find("g_type_init()") == -1:
                        new_file = new_file + "#if !GLIB_CHECK_VERSION(2,35,0)\n" + line + "#endif\n"
                    else: 
                        new_file = new_file + line
                open("%s/%s" % (path, file), "w").write(new_file)
    
    options = "--disable-static \
               --disable-silent-rules \
               --disable-scrollkeeper \
               --disable-dumper \
               --disable-tests \
               --enable-introspection=yes"
    
    shelltools.makedirs("../gtk2-rebuild")
    shelltools.system("cp -R * ../gtk2-rebuild &>/dev/null")

    #autotools.autoreconf("-fvi")
    autotools.configure("%s --with-gtk=3" % options)
    shelltools.cd("../gtk2-rebuild")
    #autotools.autoreconf("-fvi")
    autotools.configure("%s --with-gtk=2" % options)
Example #4
0
def setup():
    shelltools.makedirs(NCURSES)
    shelltools.makedirs(NCURSESW)
    shelltools.cd(NCURSESW)

    global CONFIGPARAMS

    if get.buildTYPE() == "_emul32":
        pisitools.flags.add("-m32")
        pisitools.ldflags.add("-m32")
        CONFIGPARAMS += " --prefix=/_emul32 \
                          --libdir=/usr/lib32 \
                          --libexecdir=/_emul32/lib \
                          --bindir=/_emul32/bin \
                          --sbindir=/_emul32/sbin \
                          --mandir=/_emul32/share/man"
    else:
        CONFIGPARAMS += " --prefix=/usr \
                          --libdir=/usr/lib \
                          --libexecdir=/usr/lib \
                          --bindir=/usr/bin \
                          --sbindir=/usr/sbin \
                          --mandir=/usr/share/man"

    shelltools.system("%s/configure --enable-widec --enable-pc-files %s" % (WORKDIR, CONFIGPARAMS))
Example #5
0
def setup():
    pisitools.dosed("configure.ac", "-O3", "")
    shelltools.export("CPPFLAGS", get.CXXFLAGS())

    shelltools.system("./autogen.sh")
    autotools.configure("--disable-static \
                         --enable-glib")
Example #6
0
def setup():
	shelltools.system ("sed -i -e '/gets is a/d' gnu/stdio.in.h")
	autotools.configure("--prefix=/usr\
						 --bindir=/bin\
						 --libexecdir=/tmp\
						 --enable-mt\
						 --with-rmt=/usr/sbin/rmt")
Example #7
0
def setup():
    # Fix build with 1.2.2
    pisitools.dosed("build.xml", "property name=\"src_dir\" value=\"src\"", "property name=\"src_dir\" value=\".\"")

    shelltools.cd("lib/")
    shelltools.chmod("jsapi.sh")
    shelltools.system("./jsapi.sh")
Example #8
0
def install():
    # root owns sandbox as it is setuid
    shelltools.system("chown root:root opt/google/chrome/chrome-sandbox")
    # ensure setuid
    shelltools.system("chmod 4755 opt/google/chrome/chrome-sandbox")
    pisitools.insinto("/", "opt")
    pisitools.insinto("/", "usr")
Example #9
0
def setup():
  
    shelltools.copytree("%s/PyQt-gpl-5.4.1" % get.workDIR(), "%s/Py2Qt-gpl-5.4.1" % get.workDIR())
    pythonmodules.run("configure.py  --confirm-license \
                                     --assume-shared \
                                     --no-timestamp \
                                     --qsci-api \
                                     --enable=QtCore \
                                     --enable=QtWidgets \
                                     --enable=QtXml \
                                     --enable=QtGui \
                                     --qmake='/usr/bin/qmake' \
                                     --destdir='/usr/lib/python3.4/site-packages' \
                                     --sip-incdir='/usr/include/python3.4' \
                                     CFLAGS='%s' CXXFLAGS='%s'" % (get.CFLAGS(), get.CXXFLAGS()), pyVer = "3")
    
    shelltools.cd("%s/Py2Qt-gpl-5.4.1" % get.workDIR())
    shelltools.system("python configure.py  --confirm-license \
                                     --assume-shared \
                                     --no-timestamp \
                                     --qsci-api \
                                     --enable=QtCore \
                                     --enable=QtWidgets \
                                     --enable=QtXml \
                                     --enable=QtGui \
                                     --qmake='/usr/bin/qmake'")
Example #10
0
def setup():
    setupVars()

    pisitools.dosed("runConfigure", '^CXXFLAGS="\\$compileroptions', "CXXFLAGS=\"${CXXFLAGS}")
    pisitools.dosed("runConfigure", '^CFLAGS="\\$compileroptions', "CFLAGS=\"${CXXFLAGS}")

    shelltools.system("./runConfigure -p linux -c gcc -x g++ -P /usr -t icu -C --libdir=/usr/lib")
Example #11
0
def setup():
    crosstools.prepare()

    # Build binutils with LD_SYMBOLIC_FUNCTIONS=1 and reduce PLT relocations in libfd.so by 84%.
    shelltools.export("LD_SYMBOLIC_FUNCTIONS", "1")

    shelltools.system('AR=ar AS=as ./configure \
                       --prefix=/%(defaultprefixDIR)s \
                       --mandir=/%(manDIR)s \
                       --infodir=/%(infoDIR)s \
                       --datadir=/%(dataDIR)s \
                       --sysconfdir=/%(sysconfDIR)s \
                       --localstatedir=/%(localstateDIR)s \
                       --libexecdir=/%(libexecDIR)s \
                       --build=%(build)s \
                       --host=%(host)s \
                       --target=%(target)s \
                       --disable-nls \
                       --disable-werror \
                       --enable-shared \
                       --with-pkgversion="Pardus Linux for ARM" \
                       --with-bugurl=http://bugs.pardus.org.tr/' %
                       crosstools.environment)

    crosstools.make("configure-host")
Example #12
0
def setup():
    shelltools.chmod("scripts/*.sh")

    undef_variables()

    conf = "--disable-dev-erandom \
            --with-tls \
            --with-__thread \
            --enable-add-ons=nptl,c_stubs,glibc-compat,libidn \
            --enable-kernel=2.6.11 \
            --without-cvs \
            --without-selinux \
            --enable-bind-now \
            --build=%s \
            --host=%s \
            --disable-profile \
            --without-gd \
            --with-headers=/usr/include \
            --prefix=/usr \
            --mandir=/usr/share/man \
            --infodir=/usr/share/info \
            --libexecdir=/usr/lib/misc" % (get.HOST(), get.HOST())

    shelltools.makedirs("%s/build-default-i686-pc-linux-gnu-nptl" % get.workDIR())
    shelltools.cd("%s/build-default-i686-pc-linux-gnu-nptl" % get.workDIR())
    shelltools.system("%s/%s/configure %s" % (get.workDIR(), WorkDir, conf))
Example #13
0
def install():
    shelltools.system("lrelease-qt4 translations/qtemu_de.ts")
    shelltools.system("lrelease-qt4 translations/qtemu_tr.ts")
    pisitools.insinto("/usr/share/qtemu", "qtemu")
    pisitools.insinto("/usr/share/qtemu/translations", "translations/qtemu_de.qm")
    pisitools.insinto("/usr/share/qtemu/translations", "translations/qtemu_tr.qm")
    pisitools.insinto("/usr/share/qtemu", "help")
Example #14
0
def setup():
    shelltools.system("""sed -i -r 's:"(/desktop):"/org/gnome\1:' schema/*.xml""")
    autotools.configure("--prefix=/usr \
                         --sysconfdir=/etc \
                         --with-pam-dir=/lib/security")
                        
    pisitools.dosed("libtool", " -shared ", " -Wl,-O1,--as-needed -shared ")
Example #15
0
def install():
    pisitools.dodir("/usr/bin")
    pisitools.dodir("/usr/share/man/man1")

    shelltools.system("./vncinstall %s/usr/bin %s/usr/share/man" % (get.installDIR(), get.installDIR()))

    pisitools.insinto("/usr/share/tightvnc/classes", "classes/*")
Example #16
0
def setup():
    shelltools.system("./autogen.sh")
    autotools.configure("--enable-locking \
			 --with-xf86gamma-ext \
			 --with-kbd-layout-indicator \
			 --with-xscreensaverdir=/usr/share/xscreensaver/config \
			 --with-xscreensaverhackdir=/usr/lib/misc/xscreensaver")
Example #17
0
def build():
    shelltools.cd("source/")
    autotools.make("proto")
    autotools.make("everything")
    
    # build python modules
    shelltools.system("python python/setup.py build")
Example #18
0
def setup():
    # Remove local copies for system libs
    for directory in ["jpeg", "libpng", "zlib", "jasper", "expat"]:
        shelltools.unlinkDir(directory)

    shelltools.export("CFLAGS", "%s -fno-strict-aliasing" % get.CFLAGS())

    autotools.autoreconf("-fi")

    autotools.configure("--disable-compile-inits \
                         --disable-gtk \
                         --enable-dynamic \
                         --enable-cups \
                         --with-system-libtiff \
                         --with-ijs \
                         --with-drivers=ALL \
                         --with-libpaper \
                         --with-jbig2dec \
                         --with-jasper \
                         --with-omni \
                         --with-x \
                         --with-fontpath=/usr/share/fonts:/usr/share/fonts/default/ghostscript:/usr/share/cups/fonts:/usr/share/fonts/TTF:/usr/share/fonts/Type1")

    shelltools.cd("ijs/")
    shelltools.system("./autogen.sh \
                       --prefix=/usr \
                       --mandir=/usr/share/man \
                       --disable-static \
                       --enable-shared")
Example #19
0
def setup():
    shelltools.export("CFLAGS", "%s -fPIC -O3" % get.CFLAGS())
    shelltools.export("CXXFLAGS", "%s -fPIC -O3" % get.CXXFLAGS())

    # for libtool version matching
    #shelltools.copy("/usr/share/aclocal/ltversion.m4", "acinclude/")
    shelltools.system("./autogen.sh")

    #libtools.libtoolize("--force --copy")

    options = "--enable-sdl-dlopen \
               --disable-arts \
               --disable-esd \
               --disable-nas \
               --enable-pulseaudio-shared \
               --enable-alsa \
               --disable-rpath"

    if get.buildTYPE() == "emul32":
        options += " --libdir=/usr/lib32 \
                     --bindir=/emul32/bin \
                     --mandir=/emul32/man \
                     "

        shelltools.export("PKG_CONFIG_PATH", "/usr/lib32/pkgconfig")
        shelltools.export("CFLAGS", "%s -fPIC -O3 -m32" % get.CFLAGS())
        shelltools.export("CXXFLAGS", "%s -fPIC -O3 -m32" % get.CXXFLAGS())
        shelltools.export("LDFLAGS", "%s -m32" % get.LDFLAGS())

    autotools.configure(options)
Example #20
0
def setup():
    shelltools.system("./autogen.sh \
                       --prefix=/usr \
                       --disable-scrollkeeper \
                       --sysconfdir=/etc \
                       --mandir=/usr/share/man \
                       --localstatedir=/var")
Example #21
0
def install():
    if get.buildTYPE() == "emul32":
        autotools.rawInstall("-C src \
                              lib_LTLIBRARIES=\"%s\" \
                              DESTDIR=%s" % (emul32_libs, get.installDIR()),
                             "install-libLTLIBRARIES")
        autotools.rawInstall("DESTDIR=%s" % get.installDIR(), "install-pkgconfigDATA")
        return

    autotools.rawInstall("DESTDIR=%s" % get.installDIR())

    # Disable autospawn by default
    shelltools.system("sed -e '/autospawn/iautospawn=no' -i '%s/etc/pulse/client.conf'" % get.installDIR())
    # Speed up pulseaudio shutdown
    # Lower resample quality, saves CPU
    shelltools.system("sed -e '/exit-idle-time/iexit-idle-time=0' \
                       -e '/resample-method/iresample-method=speex-float-0' \
                       -i '%s/etc/pulse/daemon.conf'" % get.installDIR())

    # Needed for service.py
    pisitools.dodir("/run/pulse")
    pisitools.dodir("/var/lib/pulse")

    # HAL is no longer supported by default
    pisitools.removeDir("/etc/dbus-1")

    pisitools.dodoc("README", "LICENSE", "GPL", "LGPL")
    pisitools.dohtml("doxygen/html/*")
Example #22
0
def setup():
    shelltools.system("NOCONFIGURE=1 ./autogen.sh")
    autotools.configure("--prefix=/usr \
                         --sysconfdir=/etc \
                         --localstatedir=/var \
                         --libexecdir=/usr/lib/mate-document-viewer \
                         --disable-static \
                         --disable-rpath \
                         --enable-caja \
                         --enable-pdf \
                         --enable-tiff \
                         --enable-djvu \
                         --enable-dvi \
                         --enable-xps \
                         --enable-t1lib \
                         --enable-comics \
                         --enable-pixbuf \
                         --enable-impress \
                         --with-gtk=2.0 \
                         --disable-scrollkeeper \
                         --disable-introspection \
                         --disable-schemas-compile \
                         --disable-schemas-install")
    
    # for fix unused dependency
    pisitools.dosed("libtool"," -shared ", " -Wl,--as-needed -shared ")
Example #23
0
def fixPermissions():
    import os
    for root, dirs, files in os.walk("%s/opt" % get.installDIR()):
        for d in dirs:
            shelltools.system("/bin/chmod 0755 %s/%s" % (root, d))
        for f in files:
            shelltools.system("/bin/chmod 0644 %s/%s" % (root, f))
Example #24
0
def setup():
    autotools.autoreconf("-vif")
    shelltools.system("./autogen.sh")
    autotools.configure("--libexecdir=/usr/lib/cinnamon-desktop \
                         --disable-schemas-compile")
    
    pisitools.dosed("libtool"," -shared ", " -Wl,--as-needed -shared ")
Example #25
0
def setup():
    shelltools.system("sed -i 's/ memfd_create/ qemu_memfd_create/' util/memfd.c")
    
    # disable fdt until dtc is in repo
    # pisitools.dosed("configure", 'fdt="yes"', 'fdt="no"')

    shelltools.export("CFLAGS", cflags)
    shelltools.export("LDFLAGS", extraldflags)

    # different build dir setups are not supported yet, so we build kvm by hand for now
    printfancy("configuring kvm")
    autotools.rawConfigure('%s \
                            --target-list="%s" \
                            ' % (cfgParamsCommon, targetListKvm))

    printfancy("building kvm")
    autotools.make("V=1 -j1 config-host.h %s" % buildldflags)
    autotools.make("V=1 %s" % buildldflags)
    shelltools.copy("x86_64-softmmu/qemu-system-x86_64", "qemu-kvm")
    autotools.make("clean")


    # kvmtest stuff is not in upstream tarball anymore, but they may put it back, be ready
    #printfancy("configuring kvmtest")
    #shelltools.cd(builddirkvmtest)
    #autotools.rawConfigure("--prefix=/usr \
    #                        --kerneldir=../../kernel")
    #shelltools.cd("../..")


    printfancy("configuring qemu")
    autotools.rawConfigure('%s \
                            --target-list="%s" \
                            --disable-kvm \
                            ' % (cfgParamsCommon, targetList))
Example #26
0
def setup():
    shelltools.makedirs("build")
    shelltools.cd("build")
    shelltools.system('../mozilla/nsprpub/configure \
                       --prefix=/usr \
                       --disable-debug \
                       --enable-optimize="%s -g -fno-strict-aliasing"' % get.CFLAGS())
Example #27
0
def build():
    shelltools.cd("generator")
    autotools.make("-j1")
    shelltools.system("QTDIR=/usr/share/qt4 ./generator --include-paths='/usr/include'")

    shelltools.cd("../qtbindings")
    autotools.make("-j1")
Example #28
0
def setup():
    shelltools.system("./waf configure \
                        --prefix=/usr \
                        --classic \
                        --firewire \
                        --freebob \
                        --alsa")
Example #29
0
def install():
    shelltools.cd(NCURSESW)
    autotools.rawInstall("DESTDIR=%s" % get.installDIR())
    LIB = "/usr/lib32" if get.buildTYPE() == "_emul32" else "/usr/lib"
    print LIB
    for lib in ["ncurses", "form", "panel", "menu"]:
        shelltools.echo("lib%s.so" % lib, "INPUT(-l%sw)" % lib)
        pisitools.dolib_so("lib%s.so" % lib, destinationDirectory = LIB)
        pisitools.dosym("lib%sw.a" % lib, "%s/lib%s.a" % (LIB, lib))
    pisitools.dosym("libncurses++w.a", "%s/libncurses++.a" % LIB)
    for lib in ["ncurses", "ncurses++", "form", "panel", "menu"]:
        pisitools.dosym("%sw.pc" % lib, "%s/pkgconfig/%s.pc" % (LIB, lib))

    shelltools.echo("libcursesw.so", "INPUT(-lncursesw)")
    pisitools.dolib_so("libcursesw.so", destinationDirectory = LIB)
    pisitools.dosym("libncurses.so", "%s/libcurses.so" % LIB)
    pisitools.dosym("libncursesw.a", "%s/libcursesw.a" % LIB)
    pisitools.dosym("libncurses.a", "%s/libcurses.a" % LIB)

    shelltools.cd("../%s" % NCURSES)
    for lib in ["ncurses", "form", "panel", "menu"]:
        pisitools.dolib_so("lib/lib%s.so.%s" % (lib, get.srcVERSION()), destinationDirectory = LIB)
        pisitools.dosym("lib%s.so.%s" % (lib, get.srcVERSION()), "%s/lib%s.so.5" % (LIB, lib))

    if get.buildTYPE() == "_emul32":
        pisitools.removeDir("/_emul32")
        return

    shelltools.cd(WORKDIR)
    shelltools.system("grep -B 100 '$Id' README > license.txt")
    pisitools.dodoc("ANNOUNCE", "NEWS", "README*", "TO-DO", "license.txt")
Example #30
0
def setup():
    shelltools.system("install=wine.keyring")
    # For 32bit machines:
    #   * It get compiled with the normal options below. The emul32 are ignored
    #     on 32bit machines. Nothing is added to options variable.
    #
    # For 64bit machines:
    #   * First we compile for 64bit with the option --enable-win64. These build
    #     files are stored in the normal "work" dir
    #   * In the second run (for emul32 buildType), the 32bit part is compiled
    #     with the spesific libdir and the --with-wine64 options that is pointing
    #     to the 64bit files that was compiled in the first step (files in the work)
    #
    # More info can be obtained here: http://wiki.winehq.org/Wine64
    # shelltools.export("CPPFLAGS", "-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0")
    autotools.autoreconf("-vif")
    options = "--without-capi \
               --with-curses \
               --without-hal \
               --without-gstreamer \
               --with-dbus \
               --with-opengl \
               --with-alsa \
               --with-x"

    if get.buildTYPE() == "emul32":
        options += " --with-wine64=%s/work/wine-%s" % (get.pkgDIR(), get.srcVERSION())
    elif get.ARCH() == "x86_64":
        options += " --enable-win64"

    autotools.configure(options)
Example #31
0
def build():
    shelltools.system("./bam-0.2.0/src/bam release")
Example #32
0
def build():
    shelltools.system("ant jar")
Example #33
0
def build():
    cmaketools.make()
    shelltools.system("./AstroMenace --pack --rawdata=./RAW_VFS_DATA --dir=./")
Example #34
0
def setup():
    shelltools.system("./autogen.sh")
    autotools.configure()
Example #35
0
def build():
    shelltools.cd("src/C/")
    shelltools.system("cc -o bbox bbox.c")
Example #36
0
def setup():
    shelltools.system("./autogen.sh")
    autotools.configure("--disable-login \
						 --disable-su")
Example #37
0
def setup():
    shelltools.cd("pyqt4")
    shelltools.system("python config.py")
    pisitools.dosed("Makefile", "^(CXXFLAGS.*)$", "\\1 -fpermissive")
    pisitools.dosed("Makefile", "-lqtermwidget ", "-lqtermwidget4 ")
Example #38
0
def setup():
    # Unpack and prepare files
    for tar_file in shelltools.ls('.'):
        if tar_file.endswith("xz"):
            shelltools.system("tar Jxfv %s" % tar_file)
Example #39
0
def autoheader(parameters=''):
    '''generates templates for configure'''
    if system('autoheader %s' % parameters):
        raise RunTimeError(_('Running autoheader failed.'))
Example #40
0
def setup():
    shelltools.export("CC", get.CC())
    shelltools.export("CFLAGS", get.CFLAGS())

    shelltools.cd("bam-0.2.0")
    shelltools.system("./make_unix.sh")
Example #41
0
def autoreconf(parameters=''):
    '''re-generates a configure script'''
    if system('autoreconf %s' % parameters):
        raise RunTimeError(_('Running autoreconf failed.'))
Example #42
0
def setup():
    shelltools.system("./autogen.sh")
    #pisitools.dosed("doc/Makefile.in", "^DOC_MODULE = .*$", "DOC_MODULE = ${PACKAGE}")
    autotools.configure("--disable-static")
Example #43
0
def make(parameters=''):
    '''make source with given parameters = "all" || "doc" etc.'''
    if system('make %s %s' % (get.makeJOBS(), parameters)):
        raise MakeError(_('Make failed.'))
Example #44
0
def automake(parameters=''):
    '''generates a makefile'''
    if system('automake %s' % parameters):
        raise RunTimeError(_('Running automake failed.'))
Example #45
0
def setup():
    shelltools.system("ant clean")
Example #46
0
def aclocal(parameters=''):
    '''generates an aclocal.m4 based on the contents of configure.in.'''
    if system('aclocal %s' % parameters):
        raise RunTimeError(_('Running aclocal failed.'))
Example #47
0
def setup():
    #shelltools.system("qmake-qt5")
    shelltools.system("qmake-qt5 qt5-fsarchiver.pro")
Example #48
0
def compile(parameters=''):
    system('%s %s %s' % (get.CC(), get.CFLAGS(), parameters))
Example #49
0
def setup():
    # Make it build with libtool 1.5
    shelltools.system("rm -rf m4/lt* m4/libtool.m4")
    pisitools.cxxflags.add(" -std=c++11")
    
    shelltools.export("AUTOPOINT", "true")
    shelltools.system("./bootstrap")
    autotools.autoreconf("-vfi")
    autotools.rawConfigure("\
                            --prefix=/usr \
                            --libdir=/usr/lib \
                            --sysconfdir=/etc \
                            --with-default-font-family=Sans \
                            --with-default-monospace-font-family=Monospace \
                            --with-default-font=/usr/share/fonts/dejavu/DejaVuSans.ttf \
                            --with-default-monospace-font=/usr/share/fonts/dejavu/DejaVuSansMono.ttf \
                            --with-x \
                              LUAC=luac  LUA_LIBS='`pkg-config --libs lua`' \
                              RCC=/usr/bin/rcc \
                            --enable-ncurses \
                            --enable-a52 \
                            --enable-aa \
                            --enable-alsa \
                            --enable-dc1394 \
                            --enable-dbus \
                            --enable-dca \
                            --enable-dvbpsi \
                             --enable-faad \
                            --enable-fast-install \
                            --enable-flac \
                            --enable-freetype \
                            --enable-fribidi \
                            --enable-gnutls \
                            --enable-libcddb \
                            --enable-libmpeg2 \
                            --enable-libxml2 \
                            --enable-lirc \
                            --enable-libva \
                            --enable-live555 \
                            --enable-lua \
                            --enable-mad \
                            --enable-mkv \
                            --enable-mod \
                            --enable-mpc \
                            --enable-nls \
                            --enable-ogg \
                            --enable-opus \
                            --enable-png \
                            --enable-projectm \
                            --enable-pulse \
                            --enable-realrtsp \
                            --enable-screen \
                            --enable-sdl \
                            --enable-sftp \
                            --enable-schroedinger \
                            --enable-shared \
                            --enable-smbclient \
                            --enable-sout \
                            --enable-speex \
                            --enable-svg \
                            --enable-theora \
                            --enable-twolame \
                            --enable-upnp \
                            --enable-v4l2 \
			    --disable-atmo \
                            --enable-vlc \
                            --enable-mtp \
                            --enable-vlm \
                            --enable-vorbis \
                            --enable-x264 \
                            --enable-x265 \
                            --enable-xvideo \
                            --enable-qt5 \
                           ")
    #enable-skins2 \ --disable-qt4 \
    shelltools.export("CFLAGS", "%s -fPIC -O2 -Wall -Wextra -DLUA_COMPAT_5_1" % get.CFLAGS())

    # for fix unused dependency
    pisitools.dosed("libtool"," -shared ", " -Wl,--as-needed -shared ")
Example #50
0
def build():
    shelltools.system("ant -f resolver.xml jar")
Example #51
0
def setup():
    #shelltools.system("ar xf uyappardus.zip")
    shelltools.system(
        "ar xvf uyap_pardus_4_2_9_amd64/uyapeditor_4.2.9_amd64.deb")
    shelltools.system("tar xvf data.tar.xz")
Example #52
0
def install():
    zemberekdir = "/opt/LibreOffice/lib/libreoffice/share/extensions/zemberek-spell-checker"
    pisitools.dodir(zemberekdir)
    zemberekfile = glob.glob("*.oxt")[0]
    shelltools.system("unzip %s -d %s/%s" % (zemberekfile, get.installDIR(), zemberekdir))
Example #53
0
def setup():
    shelltools.system("rm -rf code/libcurl")
    shelltools.system("rm -rf code/SDL12")
    shelltools.system("rm -rf code/zlib")
    shelltools.system("rm -rf code/libspeex")
    shelltools.system("rm -rf code/libtheora")
    shelltools.system("rm -rf code/libvorbis")
    shelltools.system("rm -rf code/libogg")
    shelltools.system("rm -rf code/jpeg-8c")

    pisitools.dosed("Makefile", "-O3",
                    "%s -DUSE_ACTOR_DEFAULTS" % get.CFLAGS())
    pisitools.dosed("Makefile", "CC=gcc", "CC=%s" % get.CC())
Example #54
0
def install():
    pisitools.insinto("/usr", "%s/usr/*" % get.workDIR())

    #fixed the authentication problem.
    shelltools.system("chmod -R 0755 %s/usr/share/UYAPEditor/*" %
                      get.installDIR())
Example #55
0
def build():
    shelltools.system("./make.sh")
Example #56
0
def build():
    shelltools.cd("gdb-7.5.1")
    autotools.make()
    autotools.make("-C gdb libgdb.a")
    shelltools.system("cp libdecnumber/libdecnumber.a gdb/")
    shelltools.cd("..")
    shelltools.cd("fpcbuild-2.6.4/fpcsrc")
    shelltools.cd("compiler")
    shelltools.system("fpcmake -Tall")
    shelltools.cd("..")
    shelltools.cd("ide")
    shelltools.system("fpcmake -Tall")
    shelltools.cd("..")
    shelltools.cd("packages")
    shelltools.system("fpcmake -Tall")
    shelltools.cd("..")
    shelltools.cd("rtl")
    shelltools.system("fpcmake -Tall")
    shelltools.cd("..")
    shelltools.cd("utils")
    shelltools.system("fpcmake -Tall")
    shelltools.cd("..")
    shelltools.cd("..")
    shelltools.cd("fpcdocs")
    shelltools.system("fpcmake -Tall")
    shelltools.cd("..")
    autotools.make("build NOGDB=1")
Example #57
0
def build():
    autotools.make("prefix=/usr")

    # remove bundled packages, use our system libraries
    shelltools.system("rm -rf thirdparty/{curl,freeglut,freetype,harfbuzz,jpeg,lcms2,libjpeg,openjpeg,zlib}")
Example #58
0
def install():
    shelltools.system("./setup.py install %s" % get.installDIR())

    pisitools.dodir("/etc/mudur/services/enabled")
    pisitools.dodir("/etc/mudur/services/disabled")
    pisitools.dodir("/etc/mudur/services/conditional")
Example #59
0
def setup():
    shelltools.system("pwd")
    shelltools.system("ar xf franz_5.0.0-beta.18_amd64.deb")
    shelltools.system("tar xf data.tar.xz")
Example #60
0
def setup():
    shelltools.system("sh autogen.sh")
    autotools.configure("--prefix=/usr")