From 698b15615cbcee71e23de59014143d48ab3d2c97 Mon Sep 17 00:00:00 2001 From: Vishal Biswas Date: Wed, 7 Feb 2018 02:53:31 +0530 Subject: [PATCH] Add some disabled packages (#2106) --- disabled-packages/cups/build.sh | 22 + disabled-packages/cups/cups-thread.c.patch | 19 + disabled-packages/cups/file.c.patch | 12 + disabled-packages/cups/lockf.cpp.patch | 92 +++ disabled-packages/cutter/build.sh | 13 + disabled-packages/dovecot/build.sh | 49 ++ disabled-packages/dovecot/configure.patch | 28 + .../dovecot/src-lib-connection.h.patch | 10 + disabled-packages/libwebp/build.sh | 24 + disabled-packages/mono/build.sh | 22 + disabled-packages/mono/complex.h | 118 ++++ disabled-packages/mono/math_private.h | 764 +++++++++++++++++++++ disabled-packages/mono/tkill.patch | 27 + disabled-packages/qt5/build.sh | 84 +++ disabled-packages/qt5/execinfo.h | 6 + disabled-packages/qt5/mkspec.diff | 81 +++ disabled-packages/qt5/qsystemdetection.h.patch | 12 + disabled-packages/qt5/qthread_unix.cpp.patch | 47 ++ ...n-src-plugins-geoservices-geoservices.pro.patch | 14 + ...nsors-src-plugins-sensors-linux-linux.pro.patch | 10 + ...lport-src-serialport-qserialport_unix.cpp.patch | 11 + packages/pcre2/build.sh | 1 + 22 files changed, 1466 insertions(+) create mode 100644 disabled-packages/cups/build.sh create mode 100644 disabled-packages/cups/cups-thread.c.patch create mode 100644 disabled-packages/cups/file.c.patch create mode 100644 disabled-packages/cups/lockf.cpp.patch create mode 100644 disabled-packages/cutter/build.sh create mode 100644 disabled-packages/dovecot/build.sh create mode 100644 disabled-packages/dovecot/configure.patch create mode 100644 disabled-packages/dovecot/src-lib-connection.h.patch create mode 100644 disabled-packages/libwebp/build.sh create mode 100644 disabled-packages/mono/build.sh create mode 100644 disabled-packages/mono/complex.h create mode 100644 disabled-packages/mono/math_private.h create mode 100644 disabled-packages/mono/tkill.patch create mode 100644 disabled-packages/qt5/build.sh create mode 100644 disabled-packages/qt5/execinfo.h create mode 100644 disabled-packages/qt5/mkspec.diff create mode 100644 disabled-packages/qt5/qsystemdetection.h.patch create mode 100644 disabled-packages/qt5/qthread_unix.cpp.patch create mode 100644 disabled-packages/qt5/qtlocation-src-plugins-geoservices-geoservices.pro.patch create mode 100644 disabled-packages/qt5/qtsensors-src-plugins-sensors-linux-linux.pro.patch create mode 100644 disabled-packages/qt5/qtserialport-src-serialport-qserialport_unix.cpp.patch diff --git a/disabled-packages/cups/build.sh b/disabled-packages/cups/build.sh new file mode 100644 index 00000000..c21ce54b --- /dev/null +++ b/disabled-packages/cups/build.sh @@ -0,0 +1,22 @@ +TERMUX_PKG_HOMEPAGE=https://www.cups.org +TERMUX_PKG_VERSION=2.2.4 +TERMUX_PKG_DEPENDS=krb5 +TERMUX_PKG_SRCURL=https://github.com/apple/cups/releases/download/v$TERMUX_PKG_VERSION/cups-$TERMUX_PKG_VERSION-source.tar.gz +TERMUX_PKG_MAINTAINER="Vishal Biswas @vishalbiswas" +TERMUX_PKG_SHA256=596d4db72651c335469ae5f37b0da72ac9f97d73e30838d787065f559dea98cc +TERMUX_PKG_DEPENDS="libandroid-support, libcrypt" +TERMUX_PKG_FOLDERNAME=cups-$TERMUX_PKG_VERSION +TERMUX_PKG_BUILD_IN_SRC=true +TERMUX_PKG_EXTRA_CONFIGURE_ARGS=" +--disable-option-checking +--disable-gssapi +--with-components=core +" + +termux_step_pre_configure () { + LDFLAGS="$LDFLAGS -llog -lcrypt" +} + +termux_step_post_make_install () { + mv "$TERMUX_PREFIX"/lib64/libcups.so* "$TERMUX_PREFIX"/lib/ +} diff --git a/disabled-packages/cups/cups-thread.c.patch b/disabled-packages/cups/cups-thread.c.patch new file mode 100644 index 00000000..8668da41 --- /dev/null +++ b/disabled-packages/cups/cups-thread.c.patch @@ -0,0 +1,19 @@ +--- ./cups/thread.c 2017-06-30 21:14:38.000000000 +0530 ++++ ../thread.c 2017-09-24 10:12:11.169628258 +0530 +@@ -18,6 +18,7 @@ + + #include "cups-private.h" + #include "thread-private.h" ++#include + + + #if defined(HAVE_PTHREAD_H) +@@ -150,7 +151,7 @@ + void + _cupsThreadCancel(_cups_thread_t thread)/* I - Thread ID */ + { +- pthread_cancel(thread); ++ pthread_kill(thread, SIGTERM); + } + + diff --git a/disabled-packages/cups/file.c.patch b/disabled-packages/cups/file.c.patch new file mode 100644 index 00000000..4f434e2e --- /dev/null +++ b/disabled-packages/cups/file.c.patch @@ -0,0 +1,12 @@ +--- ./cups/file.c 2016-10-04 01:25:40.000000000 +0530 ++++ ../file.c 2016-12-11 09:51:21.994431659 +0530 +@@ -39,6 +39,9 @@ + static ssize_t cups_read(cups_file_t *fp, char *buf, size_t bytes); + static ssize_t cups_write(cups_file_t *fp, const char *buf, size_t bytes); + ++#ifdef __ANDROID__ ++#include "lockf.cpp" ++#endif + + #ifndef WIN32 + /* diff --git a/disabled-packages/cups/lockf.cpp.patch b/disabled-packages/cups/lockf.cpp.patch new file mode 100644 index 00000000..5f87d582 --- /dev/null +++ b/disabled-packages/cups/lockf.cpp.patch @@ -0,0 +1,92 @@ +--- /dev/null 2016-12-11 08:33:21.825618476 +0530 ++++ ./cups/lockf.cpp 2016-12-11 09:44:20.050966252 +0530 +@@ -0,0 +1,89 @@ ++/* ++ * Copyright (C) 2016 The Android Open Source Project ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * * Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * * Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ++ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, ++ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS ++ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED ++ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, ++ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ++ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ */ ++#include ++#include ++#include ++#include ++ ++#ifndef _BITS_LOCKF_H_ ++#define _BITS_LOCKF_H_ ++ ++#include ++ ++#define F_ULOCK 0 ++#define F_LOCK 1 ++#define F_TLOCK 2 ++#define F_TEST 3 ++ ++__BEGIN_DECLS ++ ++#if defined(__USE_FILE_OFFSET64) ++int lockf(int, int, off_t) __RENAME(lockf64); ++#else ++int lockf(int, int, off_t); ++#endif ++int lockf64(int, int, off64_t); ++ ++__END_DECLS ++ ++#endif ++ ++ ++int lockf64(int fd, int cmd, off64_t length) { ++ // Translate POSIX lockf into fcntl. ++ struct flock fl; ++ memset(&fl, 0, sizeof(fl)); ++ fl.l_whence = SEEK_CUR; ++ fl.l_start = 0; ++ fl.l_len = length; ++ if (cmd == F_ULOCK) { ++ fl.l_type = F_UNLCK; ++ cmd = F_SETLK64; ++ return fcntl(fd, F_SETLK64, &fl); ++ } ++ if (cmd == F_LOCK) { ++ fl.l_type = F_WRLCK; ++ return fcntl(fd, F_SETLKW64, &fl); ++ } ++ if (cmd == F_TLOCK) { ++ fl.l_type = F_WRLCK; ++ return fcntl(fd, F_SETLK64, &fl); ++ } ++ if (cmd == F_TEST) { ++ fl.l_type = F_RDLCK; ++ if (fcntl(fd, F_GETLK64, &fl) == -1) return -1; ++ if (fl.l_type == F_UNLCK || fl.l_pid == getpid()) return 0; ++ errno = EACCES; ++ return -1; ++ } ++ errno = EINVAL; ++ return -1; ++} ++int lockf(int fd, int cmd, off_t length) { ++ return lockf64(fd, cmd, length); ++} diff --git a/disabled-packages/cutter/build.sh b/disabled-packages/cutter/build.sh new file mode 100644 index 00000000..38b08334 --- /dev/null +++ b/disabled-packages/cutter/build.sh @@ -0,0 +1,13 @@ +TERMUX_PKG_HOMEPAGE=https://github.com/radareorg/cutter +TERMUX_PKG_VERSION=1.0-alpha +TERMUX_PKG_SRCURL=https://github.com/radareorg/cutter/archive/v$TERMUX_PKG_VERSION.tar.gz +TERMUX_PKG_SHA256=58ea937709637d59089c6656eaa276d0863dd96142afb97bab797c834bb4c085 +TERMUX_PKG_DEPENDS="qt5, radare2" + +termux_step_pre_configure () { + export TERMUX_PKG_SRCDIR="$TERMUX_PKG_SRCDIR/src" +} + +termux_step_make_install () { + cp $TERMUX_PKG_BUILDDIR/cutter $TERMUX_PREFIX/bin/cutter +} diff --git a/disabled-packages/dovecot/build.sh b/disabled-packages/dovecot/build.sh new file mode 100644 index 00000000..1d54fe01 --- /dev/null +++ b/disabled-packages/dovecot/build.sh @@ -0,0 +1,49 @@ +TERMUX_PKG_HOMEPAGE=https://www.dovecot.org +TERMUX_PKG_DESCRIPTION="Secure IMAP and POP3 email server" +TERMUX_PKG_VERSION=2.2.31 +TERMUX_PKG_SRCURL=https://www.dovecot.org/releases/2.2/dovecot-$TERMUX_PKG_VERSION.tar.gz +TERMUX_PKG_SHA256=034be40907748128d65088a4f59789b2f99ae7b33a88974eae0b6a68ece376a1 +TERMUX_PKG_MAINTAINER="Vishal Biswas @vishalbiswas" +TERMUX_PKG_DEPENDS="openssl, libcrypt" +# turning on icu gives undefined reference to __cxa_call_unexpected +TERMUX_PKG_EXTRA_CONFIGURE_ARGS=" +--with-zlib +--with-ssl=openssl +--with-ssldir=$TERMUX_PREFIX/etc/tls +--without-icu +--without-shadow +i_cv_epoll_works=yes +i_cv_posix_fallocate_works=yes +i_cv_signed_size_t=no +i_cv_gmtime_max_time_t=40 +i_cv_signed_time_t=yes +i_cv_mmap_plays_with_write=yes +i_cv_fd_passing=yes +i_cv_c99_vsnprintf=yes +lib_cv_va_copy=yes +lib_cv___va_copy=yes +" + +termux_step_pre_configure () { + LDFLAGS="$LDFLAGS -llog" + + for i in `find $TERMUX_PKG_SRCDIR/src/director -type f`; do sed 's|\bstruct user\b|struct usertest|g' -i $i; done + + if [ "$TERMUX_ARCH" == "aarch64" ]; then + TERMUX_PKG_EXTRA_CONFIGURE_ARGS+="lib_cv_va_val_copy=yes" + else + TERMUX_PKG_EXTRA_CONFIGURE_ARGS+="lib_cv_va_val_copy=no" + fi +} + +termux_step_post_make_install () { + for binary in doveadm doveconf; do + mv $TERMUX_PREFIX/bin/$binary $TERMUX_PREFIX/libexec/dovecot/$binary + cat > $TERMUX_PREFIX/bin/$binary <>confdefs.h +- +- have_rquota=yes +-fi + if test "$have_rquota" = "yes"; then + HAVE_RQUOTA_TRUE= + HAVE_RQUOTA_FALSE='#' diff --git a/disabled-packages/dovecot/src-lib-connection.h.patch b/disabled-packages/dovecot/src-lib-connection.h.patch new file mode 100644 index 00000000..dbb1e514 --- /dev/null +++ b/disabled-packages/dovecot/src-lib-connection.h.patch @@ -0,0 +1,10 @@ +--- ./src/lib/connection.h 2016-12-03 22:43:21.000000000 +0530 ++++ ../connection.h 2017-06-09 22:47:48.138342901 +0530 +@@ -2,6 +2,7 @@ + #define CONNECTION_H + + #include "net.h" ++#include + + struct connection; + diff --git a/disabled-packages/libwebp/build.sh b/disabled-packages/libwebp/build.sh new file mode 100644 index 00000000..74cfd56d --- /dev/null +++ b/disabled-packages/libwebp/build.sh @@ -0,0 +1,24 @@ +TERMUX_PKG_HOMEPAGE=https://chromium.googlesource.com/webm/libwebp +TERMUX_PKG_VERSION=0.6.0 +TERMUX_PKG_SRCURL=https://github.com/webmproject/libwebp/archive/v$TERMUX_PKG_VERSION.tar.gz +TERMUX_PKG_SHA256=e1bd8b81098b8094edba0f161baf89f9fb1492e3fca19cf1d28eff4b88518702 +TERMUX_PKG_MAINTAINER="Vishal Biswas @vishalbiswas" +TERMUX_PKG_DEPENDS="libpng, libjpeg-turbo, libtiff" +TERMUX_PKG_EXTRA_CONFIGURE_ARGS=" +--enable-png +--enable-tiff +--enable-jpeg +--enable-libwebpmux +--enable-libwebpdemux +--enable-libwebpdecoder +--enable-libwebpextras +" + +termux_step_pre_configure () { + CPPFLAGS="$CPPFLAGS -I$NDK/sources/android/cpufeatures" + $CC -c -o $TERMUX_PKG_BUILDDIR/libcpufeatures.o $CPPFLAGS $CFLAGS $NDK/sources/android/cpufeatures/cpu-features.c + $AR rcs $TERMUX_PKG_BUILDDIR/libcpufeatures.a $TERMUX_PKG_BUILDDIR/libcpufeatures.o + LDFLAGS="$LDFLAGS -l$TERMUX_PKG_BUILDDIR/libcpufeatures.a" + + autoreconf -fi +} diff --git a/disabled-packages/mono/build.sh b/disabled-packages/mono/build.sh new file mode 100644 index 00000000..e3e513ca --- /dev/null +++ b/disabled-packages/mono/build.sh @@ -0,0 +1,22 @@ +TERMUX_PKG_HOMEPAGE=http://www.mono-project.com/ +TERMUX_PKG_MAINTAINER='Vishal Biswas @vishalbiswas' +_MONO_VERSION=5.0.0 +_MONO_PATCH=100 +TERMUX_PKG_VERSION=$_MONO_VERSION.$_MONO_PATCH +# official package is missing support/libm/math_private.h +#TERMUX_PKG_SRCURL=https://github.com/mono/mono/archive/mono-$TERMUX_PKG_VERSION.tar.gz +TERMUX_PKG_SRCURL=https://download.mono-project.com/sources/mono/mono-$TERMUX_PKG_VERSION.tar.bz2 +TERMUX_PKG_SHA256=368da3ff9f42592920cd8cf6fa15c6c16558e967144c4d3df873352e5d2bb6df +TERMUX_PKG_FOLDERNAME=mono-$_MONO_VERSION +#TERMUX_PKG_EXTRA_CONFIGURE_ARGS='--disable-mcs-build --disable-boehm --with-sigaltstack=no' +TERMUX_PKG_EXTRA_CONFIGURE_ARGS+="--disable-btls --disable-dynamic-btls" #--with-btls-android-ndk=$ANDROID_NDK" +TERMUX_PKG_BUILD_IN_SRC=true + +termux_step_pre_configure () { +# export CFLAGS="$CFLAGS -mthumb" + cd "$TERMUX_PKG_SRCDIR" +# NOCONFIGURE=1 ./autogen.sh +# cp $TERMUX_PKG_BUILDER_DIR/{complex,math_private}.h $TERMUX_PKG_SRCDIR/support/libm/ + export ANDROID_STANDALONE_TOOLCHAIN=$TERMUX_STANDALONE_TOOLCHAIN +} + diff --git a/disabled-packages/mono/complex.h b/disabled-packages/mono/complex.h new file mode 100644 index 00000000..b8a16a8b --- /dev/null +++ b/disabled-packages/mono/complex.h @@ -0,0 +1,118 @@ +/*- + * Copyright (c) 2001-2011 The FreeBSD Project. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _COMPLEX_H +#define _COMPLEX_H + +#include + +#ifdef __GNUC__ +#if __STDC_VERSION__ < 199901 +#define _Complex __complex__ +#endif +#define _Complex_I ((float _Complex)1.0i) +#endif + +#ifdef __generic +_Static_assert(__generic(_Complex_I, float _Complex, 1, 0), + "_Complex_I must be of type float _Complex"); +#endif + +#define complex _Complex +#define I _Complex_I + +#if __ISO_C_VISIBLE >= 2011 +#ifdef __clang__ +#define CMPLX(x, y) ((double complex){ x, y }) +#define CMPLXF(x, y) ((float complex){ x, y }) +#define CMPLXL(x, y) ((long double complex){ x, y }) +#elif __GNUC_PREREQ__(4, 7) +#define CMPLX(x, y) __builtin_complex((double)(x), (double)(y)) +#define CMPLXF(x, y) __builtin_complex((float)(x), (float)(y)) +#define CMPLXL(x, y) __builtin_complex((long double)(x), (long double)(y)) +#endif +#endif /* __ISO_C_VISIBLE >= 2011 */ + +__BEGIN_DECLS +#pragma GCC visibility push(default) + +double cabs(double complex); +float cabsf(float complex); +long double cabsl(long double complex); +double complex cacos(double complex); +float complex cacosf(float complex); +double complex cacosh(double complex); +float complex cacoshf(float complex); +double carg(double complex); +float cargf(float complex); +long double cargl(long double complex); +double complex casin(double complex); +float complex casinf(float complex); +double complex casinh(double complex); +float complex casinhf(float complex); +double complex catan(double complex); +float complex catanf(float complex); +double complex catanh(double complex); +float complex catanhf(float complex); +double complex ccos(double complex); +float complex ccosf(float complex); +double complex ccosh(double complex); +float complex ccoshf(float complex); +double complex cexp(double complex); +float complex cexpf(float complex); +double cimag(double complex) __pure2; +float cimagf(float complex) __pure2; +long double cimagl(long double complex) __pure2; +double complex conj(double complex) __pure2; +float complex conjf(float complex) __pure2; +long double complex + conjl(long double complex) __pure2; +float complex cprojf(float complex) __pure2; +double complex cproj(double complex) __pure2; +long double complex + cprojl(long double complex) __pure2; +double creal(double complex) __pure2; +float crealf(float complex) __pure2; +long double creall(long double complex) __pure2; +double complex csin(double complex); +float complex csinf(float complex); +double complex csinh(double complex); +float complex csinhf(float complex); +double complex csqrt(double complex); +float complex csqrtf(float complex); +long double complex + csqrtl(long double complex); +double complex ctan(double complex); +float complex ctanf(float complex); +double complex ctanh(double complex); +float complex ctanhf(float complex); + +#pragma GCC visibility pop +__END_DECLS + +#endif /* _COMPLEX_H */ \ No newline at end of file diff --git a/disabled-packages/mono/math_private.h b/disabled-packages/mono/math_private.h new file mode 100644 index 00000000..b33cf602 --- /dev/null +++ b/disabled-packages/mono/math_private.h @@ -0,0 +1,764 @@ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunPro, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * from: @(#)fdlibm.h 5.1 93/09/24 + * $FreeBSD$ + */ + +#ifndef _MATH_PRIVATE_H_ +#define _MATH_PRIVATE_H_ + +#include +#include + +/* + * The original fdlibm code used statements like: + * n0 = ((*(int*)&one)>>29)^1; * index of high word * + * ix0 = *(n0+(int*)&x); * high word of x * + * ix1 = *((1-n0)+(int*)&x); * low word of x * + * to dig two 32 bit words out of the 64 bit IEEE floating point + * value. That is non-ANSI, and, moreover, the gcc instruction + * scheduler gets it wrong. We instead use the following macros. + * Unlike the original code, we determine the endianness at compile + * time, not at run time; I don't see much benefit to selecting + * endianness at run time. + */ + +/* + * A union which permits us to convert between a double and two 32 bit + * ints. + */ + +#ifdef __arm__ +#if defined(__VFP_FP__) || defined(__ARM_EABI__) +#define IEEE_WORD_ORDER BYTE_ORDER +#else +#define IEEE_WORD_ORDER BIG_ENDIAN +#endif +#else /* __arm__ */ +#define IEEE_WORD_ORDER BYTE_ORDER +#endif + +#if IEEE_WORD_ORDER == BIG_ENDIAN + +typedef union +{ + double value; + struct + { + u_int32_t msw; + u_int32_t lsw; + } parts; + struct + { + u_int64_t w; + } xparts; +} ieee_double_shape_type; + +#endif + +#if IEEE_WORD_ORDER == LITTLE_ENDIAN + +typedef union +{ + double value; + struct + { + u_int32_t lsw; + u_int32_t msw; + } parts; + struct + { + u_int64_t w; + } xparts; +} ieee_double_shape_type; + +#endif + +/* Get two 32 bit ints from a double. */ + +#define EXTRACT_WORDS(ix0,ix1,d) \ +do { \ + ieee_double_shape_type ew_u; \ + ew_u.value = (d); \ + (ix0) = ew_u.parts.msw; \ + (ix1) = ew_u.parts.lsw; \ +} while (0) + +/* Get a 64-bit int from a double. */ +#define EXTRACT_WORD64(ix,d) \ +do { \ + ieee_double_shape_type ew_u; \ + ew_u.value = (d); \ + (ix) = ew_u.xparts.w; \ +} while (0) + +/* Get the more significant 32 bit int from a double. */ + +#define GET_HIGH_WORD(i,d) \ +do { \ + ieee_double_shape_type gh_u; \ + gh_u.value = (d); \ + (i) = gh_u.parts.msw; \ +} while (0) + +/* Get the less significant 32 bit int from a double. */ + +#define GET_LOW_WORD(i,d) \ +do { \ + ieee_double_shape_type gl_u; \ + gl_u.value = (d); \ + (i) = gl_u.parts.lsw; \ +} while (0) + +/* Set a double from two 32 bit ints. */ + +#define INSERT_WORDS(d,ix0,ix1) \ +do { \ + ieee_double_shape_type iw_u; \ + iw_u.parts.msw = (ix0); \ + iw_u.parts.lsw = (ix1); \ + (d) = iw_u.value; \ +} while (0) + +/* Set a double from a 64-bit int. */ +#define INSERT_WORD64(d,ix) \ +do { \ + ieee_double_shape_type iw_u; \ + iw_u.xparts.w = (ix); \ + (d) = iw_u.value; \ +} while (0) + +/* Set the more significant 32 bits of a double from an int. */ + +#define SET_HIGH_WORD(d,v) \ +do { \ + ieee_double_shape_type sh_u; \ + sh_u.value = (d); \ + sh_u.parts.msw = (v); \ + (d) = sh_u.value; \ +} while (0) + +/* Set the less significant 32 bits of a double from an int. */ + +#define SET_LOW_WORD(d,v) \ +do { \ + ieee_double_shape_type sl_u; \ + sl_u.value = (d); \ + sl_u.parts.lsw = (v); \ + (d) = sl_u.value; \ +} while (0) + +/* + * A union which permits us to convert between a float and a 32 bit + * int. + */ + +typedef union +{ + float value; + /* FIXME: Assumes 32 bit int. */ + unsigned int word; +} ieee_float_shape_type; + +/* Get a 32 bit int from a float. */ + +#define GET_FLOAT_WORD(i,d) \ +do { \ + ieee_float_shape_type gf_u; \ + gf_u.value = (d); \ + (i) = gf_u.word; \ +} while (0) + +/* Set a float from a 32 bit int. */ + +#define SET_FLOAT_WORD(d,i) \ +do { \ + ieee_float_shape_type sf_u; \ + sf_u.word = (i); \ + (d) = sf_u.value; \ +} while (0) + +/* + * Get expsign and mantissa as 16 bit and 64 bit ints from an 80 bit long + * double. + */ + +#define EXTRACT_LDBL80_WORDS(ix0,ix1,d) \ +do { \ + union IEEEl2bits ew_u; \ + ew_u.e = (d); \ + (ix0) = ew_u.xbits.expsign; \ + (ix1) = ew_u.xbits.man; \ +} while (0) + +/* + * Get expsign and mantissa as one 16 bit and two 64 bit ints from a 128 bit + * long double. + */ + +#define EXTRACT_LDBL128_WORDS(ix0,ix1,ix2,d) \ +do { \ + union IEEEl2bits ew_u; \ + ew_u.e = (d); \ + (ix0) = ew_u.xbits.expsign; \ + (ix1) = ew_u.xbits.manh; \ + (ix2) = ew_u.xbits.manl; \ +} while (0) + +/* Get expsign as a 16 bit int from a long double. */ + +#define GET_LDBL_EXPSIGN(i,d) \ +do { \ + union IEEEl2bits ge_u; \ + ge_u.e = (d); \ + (i) = ge_u.xbits.expsign; \ +} while (0) + +/* + * Set an 80 bit long double from a 16 bit int expsign and a 64 bit int + * mantissa. + */ + +#define INSERT_LDBL80_WORDS(d,ix0,ix1) \ +do { \ + union IEEEl2bits iw_u; \ + iw_u.xbits.expsign = (ix0); \ + iw_u.xbits.man = (ix1); \ + (d) = iw_u.e; \ +} while (0) + +/* + * Set a 128 bit long double from a 16 bit int expsign and two 64 bit ints + * comprising the mantissa. + */ + +#define INSERT_LDBL128_WORDS(d,ix0,ix1,ix2) \ +do { \ + union IEEEl2bits iw_u; \ + iw_u.xbits.expsign = (ix0); \ + iw_u.xbits.manh = (ix1); \ + iw_u.xbits.manl = (ix2); \ + (d) = iw_u.e; \ +} while (0) + +/* Set expsign of a long double from a 16 bit int. */ + +#define SET_LDBL_EXPSIGN(d,v) \ +do { \ + union IEEEl2bits se_u; \ + se_u.e = (d); \ + se_u.xbits.expsign = (v); \ + (d) = se_u.e; \ +} while (0) + +#ifdef __i386__ +/* Long double constants are broken on i386. */ +#define LD80C(m, ex, v) { \ + .xbits.man = __CONCAT(m, ULL), \ + .xbits.expsign = (0x3fff + (ex)) | ((v) < 0 ? 0x8000 : 0), \ +} +#else +/* The above works on non-i386 too, but we use this to check v. */ +#define LD80C(m, ex, v) { .e = (v), } +#endif + +#ifdef FLT_EVAL_METHOD +/* + * Attempt to get strict C99 semantics for assignment with non-C99 compilers. + */ +#if FLT_EVAL_METHOD == 0 || __GNUC__ == 0 +#define STRICT_ASSIGN(type, lval, rval) ((lval) = (rval)) +#else +#define STRICT_ASSIGN(type, lval, rval) do { \ + volatile type __lval; \ + \ + if (sizeof(type) >= sizeof(long double)) \ + (lval) = (rval); \ + else { \ + __lval = (rval); \ + (lval) = __lval; \ + } \ +} while (0) +#endif +#endif /* FLT_EVAL_METHOD */ + +/* Support switching the mode to FP_PE if necessary. */ +#if defined(__i386__) && !defined(NO_FPSETPREC) +#define ENTERI() \ + long double __retval; \ + fp_prec_t __oprec; \ + \ + if ((__oprec = fpgetprec()) != FP_PE) \ + fpsetprec(FP_PE) +#define RETURNI(x) do { \ + __retval = (x); \ + if (__oprec != FP_PE) \ + fpsetprec(__oprec); \ + RETURNF(__retval); \ +} while (0) +#else +#define ENTERI(x) +#define RETURNI(x) RETURNF(x) +#endif + +/* Default return statement if hack*_t() is not used. */ +#define RETURNF(v) return (v) + +/* + * 2sum gives the same result as 2sumF without requiring |a| >= |b| or + * a == 0, but is slower. + */ +#define _2sum(a, b) do { \ + __typeof(a) __s, __w; \ + \ + __w = (a) + (b); \ + __s = __w - (a); \ + (b) = ((a) - (__w - __s)) + ((b) - __s); \ + (a) = __w; \ +} while (0) + +/* + * 2sumF algorithm. + * + * "Normalize" the terms in the infinite-precision expression a + b for + * the sum of 2 floating point values so that b is as small as possible + * relative to 'a'. (The resulting 'a' is the value of the expression in + * the same precision as 'a' and the resulting b is the rounding error.) + * |a| must be >= |b| or 0, b's type must be no larger than 'a's type, and + * exponent overflow or underflow must not occur. This uses a Theorem of + * Dekker (1971). See Knuth (1981) 4.2.2 Theorem C. The name "TwoSum" + * is apparently due to Skewchuk (1997). + * + * For this to always work, assignment of a + b to 'a' must not retain any + * extra precision in a + b. This is required by C standards but broken + * in many compilers. The brokenness cannot be worked around using + * STRICT_ASSIGN() like we do elsewhere, since the efficiency of this + * algorithm would be destroyed by non-null strict assignments. (The + * compilers are correct to be broken -- the efficiency of all floating + * point code calculations would be destroyed similarly if they forced the + * conversions.) + * + * Fortunately, a case that works well can usually be arranged by building + * any extra precision into the type of 'a' -- 'a' should have type float_t, + * double_t or long double. b's type should be no larger than 'a's type. + * Callers should use these types with scopes as large as possible, to + * reduce their own extra-precision and efficiciency problems. In + * particular, they shouldn't convert back and forth just to call here. + */ +#ifdef DEBUG +#define _2sumF(a, b) do { \ + __typeof(a) __w; \ + volatile __typeof(a) __ia, __ib, __r, __vw; \ + \ + __ia = (a); \ + __ib = (b); \ + assert(__ia == 0 || fabsl(__ia) >= fabsl(__ib)); \ + \ + __w = (a) + (b); \ + (b) = ((a) - __w) + (b); \ + (a) = __w; \ + \ + /* The next 2 assertions are weak if (a) is already long double. */ \ + assert((long double)__ia + __ib == (long double)(a) + (b)); \ + __vw = __ia + __ib; \ + __r = __ia - __vw; \ + __r += __ib; \ + assert(__vw == (a) && __r == (b)); \ +} while (0) +#else /* !DEBUG */ +#define _2sumF(a, b) do { \ + __typeof(a) __w; \ + \ + __w = (a) + (b); \ + (b) = ((a) - __w) + (b); \ + (a) = __w; \ +} while (0) +#endif /* DEBUG */ + +/* + * Set x += c, where x is represented in extra precision as a + b. + * x must be sufficiently normalized and sufficiently larger than c, + * and the result is then sufficiently normalized. + * + * The details of ordering are that |a| must be >= |c| (so that (a, c) + * can be normalized without extra work to swap 'a' with c). The details of + * the normalization are that b must be small relative to the normalized 'a'. + * Normalization of (a, c) makes the normalized c tiny relative to the + * normalized a, so b remains small relative to 'a' in the result. However, + * b need not ever be tiny relative to 'a'. For example, b might be about + * 2**20 times smaller than 'a' to give about 20 extra bits of precision. + * That is usually enough, and adding c (which by normalization is about + * 2**53 times smaller than a) cannot change b significantly. However, + * cancellation of 'a' with c in normalization of (a, c) may reduce 'a' + * significantly relative to b. The caller must ensure that significant + * cancellation doesn't occur, either by having c of the same sign as 'a', + * or by having |c| a few percent smaller than |a|. Pre-normalization of + * (a, b) may help. + * + * This is is a variant of an algorithm of Kahan (see Knuth (1981) 4.2.2 + * exercise 19). We gain considerable efficiency by requiring the terms to + * be sufficiently normalized and sufficiently increasing. + */ +#define _3sumF(a, b, c) do { \ + __typeof(a) __tmp; \ + \ + __tmp = (c); \ + _2sumF(__tmp, (a)); \ + (b) += (a); \ + (a) = __tmp; \ +} while (0) + +/* + * Common routine to process the arguments to nan(), nanf(), and nanl(). + */ +void _scan_nan(uint32_t *__words, int __num_words, const char *__s); + +#ifdef _COMPLEX_H + +/* + * C99 specifies that complex numbers have the same representation as + * an array of two elements, where the first element is the real part + * and the second element is the imaginary part. + */ +typedef union { + float complex f; + float a[2]; +} float_complex; +typedef union { + double complex f; + double a[2]; +} double_complex; +typedef union { + long double complex f; + long double a[2]; +} long_double_complex; +#define REALPART(z) ((z).a[0]) +#define IMAGPART(z) ((z).a[1]) + +/* + * Inline functions that can be used to construct complex values. + * + * The C99 standard intends x+I*y to be used for this, but x+I*y is + * currently unusable in general since gcc introduces many overflow, + * underflow, sign and efficiency bugs by rewriting I*y as + * (0.0+I)*(y+0.0*I) and laboriously computing the full complex product. + * In particular, I*Inf is corrupted to NaN+I*Inf, and I*-0 is corrupted + * to -0.0+I*0.0. + */ +static __inline float complex +cpackf(float x, float y) +{ + float_complex z; + + REALPART(z) = x; + IMAGPART(z) = y; + return (z.f); +} + +static __inline double complex +cpack(double x, double y) +{ + double_complex z; + + REALPART(z) = x; + IMAGPART(z) = y; + return (z.f); +} + +static __inline long double complex +cpackl(long double x, long double y) +{ + long_double_complex z; + + REALPART(z) = x; + IMAGPART(z) = y; + return (z.f); +} +#endif /* _COMPLEX_H */ + +#ifdef __GNUCLIKE_ASM + +/* Asm versions of some functions. */ + +#ifdef __amd64__ +static __inline int +irint(double x) +{ + int n; + + asm("cvtsd2si %1,%0" : "=r" (n) : "x" (x)); + return (n); +} +#define HAVE_EFFICIENT_IRINT +#endif + +#ifdef __i386__ +static __inline int +irint(double x) +{ + int n; + + asm("fistl %0" : "=m" (n) : "t" (x)); + return (n); +} +#define HAVE_EFFICIENT_IRINT +#endif + +#if defined(__amd64__) || defined(__i386__) +static __inline int +irintl(long double x) +{ + int n; + + asm("fistl %0" : "=m" (n) : "t" (x)); + return (n); +} +#define HAVE_EFFICIENT_IRINTL +#endif + +#endif /* __GNUCLIKE_ASM */ + +#ifdef DEBUG +#if defined(__amd64__) || defined(__i386__) +#define breakpoint() asm("int $3") +#else +#include + +#define breakpoint() raise(SIGTRAP) +#endif +#endif + +/* Write a pari script to test things externally. */ +#ifdef DOPRINT +#include + +#ifndef DOPRINT_SWIZZLE +#define DOPRINT_SWIZZLE 0 +#endif + +#ifdef DOPRINT_LD80 + +#define DOPRINT_START(xp) do { \ + uint64_t __lx; \ + uint16_t __hx; \ + \ + /* Hack to give more-problematic args. */ \ + EXTRACT_LDBL80_WORDS(__hx, __lx, *xp); \ + __lx ^= DOPRINT_SWIZZLE; \ + INSERT_LDBL80_WORDS(*xp, __hx, __lx); \ + printf("x = %.21Lg; ", (long double)*xp); \ +} while (0) +#define DOPRINT_END1(v) \ + printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v)) +#define DOPRINT_END2(hi, lo) \ + printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \ + (long double)(hi), (long double)(lo)) + +#elif defined(DOPRINT_D64) + +#define DOPRINT_START(xp) do { \ + uint32_t __hx, __lx; \ + \ + EXTRACT_WORDS(__hx, __lx, *xp); \ + __lx ^= DOPRINT_SWIZZLE; \ + INSERT_WORDS(*xp, __hx, __lx); \ + printf("x = %.21Lg; ", (long double)*xp); \ +} while (0) +#define DOPRINT_END1(v) \ + printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v)) +#define DOPRINT_END2(hi, lo) \ + printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \ + (long double)(hi), (long double)(lo)) + +#elif defined(DOPRINT_F32) + +#define DOPRINT_START(xp) do { \ + uint32_t __hx; \ + \ + GET_FLOAT_WORD(__hx, *xp); \ + __hx ^= DOPRINT_SWIZZLE; \ + SET_FLOAT_WORD(*xp, __hx); \ + printf("x = %.21Lg; ", (long double)*xp); \ +} while (0) +#define DOPRINT_END1(v) \ + printf("y = %.21Lg; z = 0; show(x, y, z);\n", (long double)(v)) +#define DOPRINT_END2(hi, lo) \ + printf("y = %.21Lg; z = %.21Lg; show(x, y, z);\n", \ + (long double)(hi), (long double)(lo)) + +#else /* !DOPRINT_LD80 && !DOPRINT_D64 (LD128 only) */ + +#ifndef DOPRINT_SWIZZLE_HIGH +#define DOPRINT_SWIZZLE_HIGH 0 +#endif + +#define DOPRINT_START(xp) do { \ + uint64_t __lx, __llx; \ + uint16_t __hx; \ + \ + EXTRACT_LDBL128_WORDS(__hx, __lx, __llx, *xp); \ + __llx ^= DOPRINT_SWIZZLE; \ + __lx ^= DOPRINT_SWIZZLE_HIGH; \ + INSERT_LDBL128_WORDS(*xp, __hx, __lx, __llx); \ + printf("x = %.36Lg; ", (long double)*xp); \ +} while (0) +#define DOPRINT_END1(v) \ + printf("y = %.36Lg; z = 0; show(x, y, z);\n", (long double)(v)) +#define DOPRINT_END2(hi, lo) \ + printf("y = %.36Lg; z = %.36Lg; show(x, y, z);\n", \ + (long double)(hi), (long double)(lo)) + +#endif /* DOPRINT_LD80 */ + +#else /* !DOPRINT */ +#define DOPRINT_START(xp) +#define DOPRINT_END1(v) +#define DOPRINT_END2(hi, lo) +#endif /* DOPRINT */ + +#define RETURNP(x) do { \ + DOPRINT_END1(x); \ + RETURNF(x); \ +} while (0) +#define RETURNPI(x) do { \ + DOPRINT_END1(x); \ + RETURNI(x); \ +} while (0) +#define RETURN2P(x, y) do { \ + DOPRINT_END2((x), (y)); \ + RETURNF((x) + (y)); \ +} while (0) +#define RETURN2PI(x, y) do { \ + DOPRINT_END2((x), (y)); \ + RETURNI((x) + (y)); \ +} while (0) +#ifdef STRUCT_RETURN +#define RETURNSP(rp) do { \ + if (!(rp)->lo_set) \ + RETURNP((rp)->hi); \ + RETURN2P((rp)->hi, (rp)->lo); \ +} while (0) +#define RETURNSPI(rp) do { \ + if (!(rp)->lo_set) \ + RETURNPI((rp)->hi); \ + RETURN2PI((rp)->hi, (rp)->lo); \ +} while (0) +#endif +#define SUM2P(x, y) ({ \ + const __typeof (x) __x = (x); \ + const __typeof (y) __y = (y); \ + \ + DOPRINT_END2(__x, __y); \ + __x + __y; \ +}) + +/* + * ieee style elementary functions + * + * We rename functions here to improve other sources' diffability + * against fdlibm. + */ +#define __ieee754_sqrt sqrt +#define __ieee754_acos acos +#define __ieee754_acosh acosh +#define __ieee754_log log +#define __ieee754_log2 log2 +#define __ieee754_atanh atanh +#define __ieee754_asin asin +#define __ieee754_atan2 atan2 +#define __ieee754_exp exp +#define __ieee754_cosh cosh +#define __ieee754_fmod fmod +#define __ieee754_pow pow +#define __ieee754_lgamma lgamma +#define __ieee754_gamma gamma +#define __ieee754_lgamma_r lgamma_r +#define __ieee754_gamma_r gamma_r +#define __ieee754_log10 log10 +#define __ieee754_sinh sinh +#define __ieee754_hypot hypot +#define __ieee754_j0 j0 +#define __ieee754_j1 j1 +#define __ieee754_y0 y0 +#define __ieee754_y1 y1 +#define __ieee754_jn jn +#define __ieee754_yn yn +#define __ieee754_remainder remainder +#define __ieee754_scalb scalb +#define __ieee754_sqrtf sqrtf +#define __ieee754_acosf acosf +#define __ieee754_acoshf acoshf +#define __ieee754_logf logf +#define __ieee754_atanhf atanhf +#define __ieee754_asinf asinf +#define __ieee754_atan2f atan2f +#define __ieee754_expf expf +#define __ieee754_coshf coshf +#define __ieee754_fmodf fmodf +#define __ieee754_powf powf +#define __ieee754_lgammaf lgammaf +#define __ieee754_gammaf gammaf +#define __ieee754_lgammaf_r lgammaf_r +#define __ieee754_gammaf_r gammaf_r +#define __ieee754_log10f log10f +#define __ieee754_log2f log2f +#define __ieee754_sinhf sinhf +#define __ieee754_hypotf hypotf +#define __ieee754_j0f j0f +#define __ieee754_j1f j1f +#define __ieee754_y0f y0f +#define __ieee754_y1f y1f +#define __ieee754_jnf jnf +#define __ieee754_ynf ynf +#define __ieee754_remainderf remainderf +#define __ieee754_scalbf scalbf + +/* fdlibm kernel function */ +int __kernel_rem_pio2(double*,double*,int,int,int); + +/* double precision kernel functions */ +#ifndef INLINE_REM_PIO2 +int __ieee754_rem_pio2(double,double*); +#endif +double __kernel_sin(double,double,int); +double __kernel_cos(double,double); +double __kernel_tan(double,double,int); +double __ldexp_exp(double,int); +#ifdef _COMPLEX_H +double complex __ldexp_cexp(double complex,int); +#endif + +/* float precision kernel functions */ +#ifndef INLINE_REM_PIO2F +int __ieee754_rem_pio2f(float,double*); +#endif +#ifndef INLINE_KERNEL_SINDF +float __kernel_sindf(double); +#endif +#ifndef INLINE_KERNEL_COSDF +float __kernel_cosdf(double); +#endif +#ifndef INLINE_KERNEL_TANDF +float __kernel_tandf(double,int); +#endif +float __ldexp_expf(float,int); +#ifdef _COMPLEX_H +float complex __ldexp_cexpf(float complex,int); +#endif + +/* long double precision kernel functions */ +long double __kernel_sinl(long double, long double, int); +long double __kernel_cosl(long double, long double); +long double __kernel_tanl(long double, long double, int); + +#endif /* !_MATH_PRIVATE_H_ */ \ No newline at end of file diff --git a/disabled-packages/mono/tkill.patch b/disabled-packages/mono/tkill.patch new file mode 100644 index 00000000..ff0c8b15 --- /dev/null +++ b/disabled-packages/mono/tkill.patch @@ -0,0 +1,27 @@ +--- ./libgc/pthread_stop_world.c 2017-01-03 15:49:34.000000000 +0530 ++++ ../pthread_stop_world.c 2017-01-05 18:54:28.314868754 +0530 +@@ -379,11 +379,7 @@ + GC_printf1("Sending suspend signal to 0x%lx\n", p -> id); + #endif + +-#ifndef PLATFORM_ANDROID + result = pthread_kill(p -> id, SIG_SUSPEND); +-#else +- result = android_thread_kill(p -> kernel_id, SIG_SUSPEND); +-#endif + switch(result) { + case ESRCH: + /* Not really there anymore. Possible? */ +--- ./mono/utils/mono-threads-posix.c 2017-01-03 15:49:38.000000000 +0530 ++++ ../mono-threads-posix.c 2017-01-05 18:57:48.313245586 +0530 +@@ -21,10 +21,6 @@ + + #include + +-#if defined(PLATFORM_ANDROID) && !defined(TARGET_ARM64) && !defined(TARGET_AMD64) +-#define USE_TKILL_ON_ANDROID 1 +-#endif +- + #ifdef USE_TKILL_ON_ANDROID + extern int tkill (pid_t tid, int signal); + #endif diff --git a/disabled-packages/qt5/build.sh b/disabled-packages/qt5/build.sh new file mode 100644 index 00000000..4fa8fb2d --- /dev/null +++ b/disabled-packages/qt5/build.sh @@ -0,0 +1,84 @@ +TERMUX_PKG_VERSION=5.10.0 +TERMUX_PKG_HOMEPAGE=https://www.qt.io +TERMUX_PKG_MAINTAINER="Vishal Biswas @vishalbiswas" +TERMUX_PKG_SRCURL="http://download.qt.io/official_releases/qt/${TERMUX_PKG_VERSION%.*}/$TERMUX_PKG_VERSION/single/qt-everywhere-src-$TERMUX_PKG_VERSION.tar.xz" +TERMUX_PKG_SHA256=936d4cf5d577298f4f9fdb220e85b008ae321554a5fcd38072dc327a7296230e +TERMUX_PKG_DEPENDS="libsqlite, libjpeg-turbo, libpng, pcre2, openssl, libandroid-support, freetype, harfbuzz, libwebp, postgresql, mariadb, fontconfig, libopus, libevent, jsoncpp, libprotobuf" +TERMUX_PKG_BUILD_IN_SRC=true +TERMUX_PKG_EXTRA_MAKE_ARGS=" -s" + +termux_step_pre_configure () { + #if [ $TERMUX_ARCH_BITS = 32 ]; then + # CPPFLAGS+=" -DTERMUX_EXPOSE_FILE_OFFSET64=1" + #fi + LDFLAGS+=" -llog -lpcre2-16 -lpng16 -ljpeg -lsqlite3 -lssl -lfreetype -lharfbuzz -lz -lfontconfig -lwebp -lpq -lmariadb" + CPPFLAGS+=" -I$TERMUX_PKG_SRCDIR/include -I$TERMUX_PREFIX/include/freetype2 -I$TERMUX_PREFIX/include/fontconfig -I$TERMUX_PREFIX/include/mysql -I$TERMUX_PKG_BUILDER_DIR" + #CFLAGS+=" $CPPFLAGS" + #CXXFLAGS+=" $CPPFLAGS" + sed -e "s|@TERMUX_HOST_PLATFORM@|$TERMUX_HOST_PLATFORM|g" \ + -e "s|@CFLAGS@|$CPPFLAGS $CFLAGS|" \ + -e "s|@CXXFLAGS@|$CPPFLAGS $CXXFLAGS|" \ + -e "s|@LDFLAGS@|$LDFLAGS|" $TERMUX_PKG_BUILDER_DIR/mkspec.diff | patch -p1 +} + +termux_step_configure () { + export PKG_CONFIG_SYSROOT_DIR="/" + + $TERMUX_PKG_SRCDIR/configure \ + -confirm-license \ + -optimize-size \ + -optimized-tools \ + -opensource \ + -pkg-config \ + -system-sqlite \ + -system-zlib \ + -system-libjpeg \ + -system-libpng \ + -system-pcre \ + -system-freetype \ + -system-harfbuzz \ + -qpa vnc \ + -opengl es2\ + -opengles3 \ + -no-eglfs \ + -syslog \ + -no-assimp \ + -no-cups \ + -no-icu \ + -no-glib \ + -no-dbus \ + -no-fontconfig \ + -force-asserts \ + -system-webp \ + -system-opus \ + -no-pulseaudio \ + -openssl-runtime \ + -nomake examples \ + -prefix $TERMUX_PREFIX \ + -xplatform linux-termux-clang \ + -nomake tests \ + -plugindir "$TERMUX_PREFIX/libexec/Qt" + + make -j $TERMUX_MAKE_PROCESSES -C "$TERMUX_PKG_BUILDDIR" qmake_all || true + + for _makefile in `find "$TERMUX_PKG_BUILDDIR" -type f -name Makefile`; do + sed -i "s| -lrt||g" "$_makefile" + done +} + +termux_step_post_massage () { + # cross compilation only builds tools usable on build machine (i.e. cross tools) + # manually make tools to be used by the host machine + for tool in src/tools/{moc,qlalr,uic,rcc} qmake; do + cd "$TERMUX_PKG_SRCDIR"/qtbase/$tool + make clean $TERMUX_PKG_EXTRA_MAKE_ARGS + $TERMUX_PREFIX/bin/qmake + make -j $TERMUX_MAKE_PROCESSES $TERMUX_PKG_EXTRA_MAKE_ARGS + #make -j $TERMUX_MAKE_PROCESSES $TERMUX_PKG_EXTRA_MAKE_ARGS CC=$CC CXX=$CXX LINK=$CXX AR="$AR cqs" STRIP=$STRIP \ + # QMAKESPEC=$TERMUX_PKG_SRCDIR/qtbase/mkspecs/linux-termux-clang \ + # QMAKE_LFLAGS=$TERMUX_PREFIX/lib/libc++_shared.so \ + # LIBS="$TERMUX_PREFIX/lib/libc++_shared.so $TERMUX_PKG_BUILDDIR/qtbase/lib/libQt5Core.so $LDFLAGS" + done + + cp "$TERMUX_PKG_BUILDDIR"/qtbase/bin/{moc,qlalr,uic,rcc,qmake} "$TERMUX_PKG_MASSAGEDIR/$TERMUX_PREFIX"/bin/ +} diff --git a/disabled-packages/qt5/execinfo.h b/disabled-packages/qt5/execinfo.h new file mode 100644 index 00000000..d62d3f73 --- /dev/null +++ b/disabled-packages/qt5/execinfo.h @@ -0,0 +1,6 @@ +#ifndef FAKE_EXECINFO_H +#define FAKE_EXECINFO_H +int backtrace(void **array, int size) { return 0; } +char **backtrace_symbols(void *const *array, int size) { return 0; } +void backtrace_symbols_fd (void *const *array, int size, int fd) {} +#endif diff --git a/disabled-packages/qt5/mkspec.diff b/disabled-packages/qt5/mkspec.diff new file mode 100644 index 00000000..7d14b1a9 --- /dev/null +++ b/disabled-packages/qt5/mkspec.diff @@ -0,0 +1,81 @@ +--- ./qtbase/mkspecs/linux-termux-clang/qmake.conf 1970-01-01 05:30:00.000000000 +0530 ++++ ./qtbase/mkspecs/linux-termux-clang/qmake.conf 2017-07-14 23:06:45.553367565 +0530 +@@ -0,0 +1,32 @@ ++MAKEFILE_GENERATOR = UNIX ++CONFIG += incremental unversioned_libname unversioned_soname plugin_with_soname qt ++QMAKE_INCREMENTAL_STYLE = sublib ++ ++include(../common/linux.conf) ++include(../common/gcc-base-unix.conf) ++include(../common/clang.conf) ++ ++QMAKE_CC = @TERMUX_HOST_PLATFORM@-clang ++QMAKE_CXX = @TERMUX_HOST_PLATFORM@-clang++ ++QMAKE_LINK = @TERMUX_HOST_PLATFORM@-clang++ ++QMAKE_LINK_SHLIB = @TERMUX_HOST_PLATFORM@-clang++ ++ ++QMAKE_AR = @TERMUX_HOST_PLATFORM@-ar cqs ++QMAKE_OBJCOPY = @TERMUX_HOST_PLATFORM@-objcopy ++QMAKE_NM = @TERMUX_HOST_PLATFORM@-nm -P ++QMAKE_STRIP = @TERMUX_HOST_PLATFORM@-strip ++ ++QMAKE_CFLAGS = @CFLAGS@ ++QMAKE_CXXFLAGS = @CXXFLAGS@ ++QMAKE_LFLAGS = @LDFLAGS@ ++ ++QMAKE_LFLAGS_APP = -Wl,--no-undefined -Wl,-z,noexecstack -shared ++QMAKE_LFLAGS_SHLIB = -Wl,--no-undefined -Wl,-z,noexecstack -shared ++QMAKE_LFLAGS_PLUGIN = $$QMAKE_LFLAGS_SHLIB ++QMAKE_LFLAGS_NOUNDEF = -Wl,--no-undefined ++ ++QMAKE_LIBS_THREAD = ++QMAKE_LIBS_X11 = ++QMAKE_LIBS_OPENGL = ++QMAKE_LIBS_OPENGL_ES2 = -lGLESv3 ++load(qt_config) +--- ./qtbase/mkspecs/linux-termux-clang/qplatformdefs.h 1970-01-01 05:30:00.000000000 +0530 ++++ ./qtbase/mkspecs/linux-termux-clang/qplatformdefs.h 2017-07-14 23:08:02.031153237 +0530 +@@ -0,0 +1,43 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2016 The Qt Company Ltd. ++** Contact: https://www.qt.io/licensing/ ++** ++** This file is part of the qmake spec of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** Commercial License Usage ++** Licensees holding valid commercial Qt licenses may use this file in ++** accordance with the commercial license agreement provided with the ++** Software or, alternatively, in accordance with the terms contained in ++** a written agreement between you and The Qt Company. For licensing terms ++** and conditions see https://www.qt.io/terms-conditions. For further ++** information use the contact form at https://www.qt.io/contact-us. ++** ++** GNU Lesser General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU Lesser ++** General Public License version 3 as published by the Free Software ++** Foundation and appearing in the file LICENSE.LGPL3 included in the ++** packaging of this file. Please review the following information to ++** ensure the GNU Lesser General Public License version 3 requirements ++** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. ++** ++** GNU General Public License Usage ++** Alternatively, this file may be used under the terms of the GNU ++** General Public License version 2.0 or (at your option) the GNU General ++** Public license version 3 or any later version approved by the KDE Free ++** Qt Foundation. The licenses are as published by the Free Software ++** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 ++** included in the packaging of this file. Please review the following ++** information to ensure the GNU General Public License requirements will ++** be met: https://www.gnu.org/licenses/gpl-2.0.html and ++** https://www.gnu.org/licenses/gpl-3.0.html. ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include "../android-clang/qplatformdefs.h" ++#define fseeko64 fseeko ++#define ftello64 ftello ++#define fopen64 fopen diff --git a/disabled-packages/qt5/qsystemdetection.h.patch b/disabled-packages/qt5/qsystemdetection.h.patch new file mode 100644 index 00000000..89f96ca3 --- /dev/null +++ b/disabled-packages/qt5/qsystemdetection.h.patch @@ -0,0 +1,12 @@ +--- ./qtbase/src/corelib/global/qsystemdetection.h 2017-06-28 15:24:29.000000000 +0530 ++++ ../qsystemdetection.h 2017-07-19 19:39:39.617805768 +0530 +@@ -120,9 +120,6 @@ + # else + # error "Qt has not been ported to this Apple platform - see http://www.qt.io/developers" + # endif +-#elif defined(__ANDROID__) || defined(ANDROID) +-# define Q_OS_ANDROID +-# define Q_OS_LINUX + #elif defined(__CYGWIN__) + # define Q_OS_CYGWIN + #elif !defined(SAG_COM) && (!defined(WINAPI_FAMILY) || WINAPI_FAMILY==WINAPI_FAMILY_DESKTOP_APP) && (defined(WIN64) || defined(_WIN64) || defined(__WIN64__)) diff --git a/disabled-packages/qt5/qthread_unix.cpp.patch b/disabled-packages/qt5/qthread_unix.cpp.patch new file mode 100644 index 00000000..7ae123c4 --- /dev/null +++ b/disabled-packages/qt5/qthread_unix.cpp.patch @@ -0,0 +1,47 @@ +--- ./qtbase/src/corelib/thread/qthread_unix.cpp 2017-06-28 15:24:29.000000000 +0530 ++++ ../qthread_unix.cpp 2017-07-19 20:19:40.071681378 +0530 +@@ -101,7 +101,7 @@ + # define SCHED_IDLE 5 + #endif + +-#if defined(Q_OS_DARWIN) || !defined(Q_OS_ANDROID) && !defined(Q_OS_OPENBSD) && defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING-0 >= 0) ++#if !defined(__ANDROID__) && (defined(Q_OS_DARWIN) || !defined(Q_OS_OPENBSD) && defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING-0 >= 0)) + #define QT_HAS_THREAD_PRIORITY_SCHEDULING + #endif + +@@ -319,7 +319,7 @@ + + void *QThreadPrivate::start(void *arg) + { +-#if !defined(Q_OS_ANDROID) ++#if !defined(__ANDROID__) + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); + #endif + pthread_cleanup_push(QThreadPrivate::finish, arg); +@@ -369,7 +369,7 @@ + #endif + + emit thr->started(QThread::QPrivateSignal()); +-#if !defined(Q_OS_ANDROID) ++#if !defined(__ANDROID__) + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); + pthread_testcancel(); + #endif +@@ -666,7 +666,7 @@ + + void QThread::terminate() + { +-#if !defined(Q_OS_ANDROID) ++#if !defined(__ANDROID__) + Q_D(QThread); + QMutexLocker locker(&d->mutex); + +@@ -708,7 +708,7 @@ + "Current thread was not started with QThread."); + + Q_UNUSED(thr) +-#if defined(Q_OS_ANDROID) ++#if defined(__ANDROID__) + Q_UNUSED(enabled); + #else + pthread_setcancelstate(enabled ? PTHREAD_CANCEL_ENABLE : PTHREAD_CANCEL_DISABLE, NULL); diff --git a/disabled-packages/qt5/qtlocation-src-plugins-geoservices-geoservices.pro.patch b/disabled-packages/qt5/qtlocation-src-plugins-geoservices-geoservices.pro.patch new file mode 100644 index 00000000..7a91869e --- /dev/null +++ b/disabled-packages/qt5/qtlocation-src-plugins-geoservices-geoservices.pro.patch @@ -0,0 +1,14 @@ +--- ./qtlocation/src/plugins/geoservices/geoservices.pro 2017-09-25 22:25:20.000000000 +0530 ++++ ../geoservices.pro 2017-11-16 11:28:04.911486902 +0530 +@@ -8,11 +8,3 @@ + qtConfig(geoservices_itemsoverlay): SUBDIRS += itemsoverlay + qtConfig(geoservices_osm): SUBDIRS += osm + +-qtConfig(geoservices_mapboxgl) { +- !exists(../../3rdparty/mapbox-gl-native/mapbox-gl-native.pro) { +- warning("Submodule mapbox-gl-native does not exist. Run 'git submodule update --init' on qtlocation.") +- } else { +- SUBDIRS += mapboxgl ../../3rdparty/mapbox-gl-native +- mapboxgl.depends = ../../3rdparty/mapbox-gl-native +- } +-} diff --git a/disabled-packages/qt5/qtsensors-src-plugins-sensors-linux-linux.pro.patch b/disabled-packages/qt5/qtsensors-src-plugins-sensors-linux-linux.pro.patch new file mode 100644 index 00000000..71398c69 --- /dev/null +++ b/disabled-packages/qt5/qtsensors-src-plugins-sensors-linux-linux.pro.patch @@ -0,0 +1,10 @@ +--- ./qtsensors/src/plugins/sensors/linux/linux.pro 2017-06-23 12:02:15.000000000 +0530 ++++ ../linux.pro 2017-10-01 11:18:29.309218546 +0530 +@@ -3,7 +3,6 @@ + + OTHER_FILES = plugin.json + +-!android:LIBS += -lrt + HEADERS += linuxsysaccelerometer.h + SOURCES += linuxsysaccelerometer.cpp \ + main.cpp diff --git a/disabled-packages/qt5/qtserialport-src-serialport-qserialport_unix.cpp.patch b/disabled-packages/qt5/qtserialport-src-serialport-qserialport_unix.cpp.patch new file mode 100644 index 00000000..dcd27e58 --- /dev/null +++ b/disabled-packages/qt5/qtserialport-src-serialport-qserialport_unix.cpp.patch @@ -0,0 +1,11 @@ +--- ./qtserialport/src/serialport/qserialport_unix.cpp 2017-06-20 12:29:20.000000000 +0530 ++++ ../qserialport_unix.cpp 2017-10-01 10:21:47.899850693 +0530 +@@ -66,7 +66,7 @@ + # define __ANDROID_API__ 21 + # endif + +-# if !defined(Q_OS_ANDROID) || (!defined(Q_PROCESSOR_X86) && __ANDROID_API__ < 21) ++# if 0 + struct termios2 { + tcflag_t c_iflag; /* input mode flags */ + tcflag_t c_oflag; /* output mode flags */ diff --git a/packages/pcre2/build.sh b/packages/pcre2/build.sh index defbef8f..8c5ff025 100644 --- a/packages/pcre2/build.sh +++ b/packages/pcre2/build.sh @@ -12,5 +12,6 @@ lib/libpcre2-posix.so " TERMUX_PKG_EXTRA_CONFIGURE_ARGS=" --enable-jit +--enable-pcre2-16 --enable-pcre2-32 " -- 2.11.0