From fc637fb28da700da71ec2064d65ca5a7a31b9c6c Mon Sep 17 00:00:00 2001 From: V3n3RiX Date: Sun, 18 Aug 2019 18:16:17 +0100 Subject: gentoo resync : 18.08.2019 --- app-i18n/libchewing/Manifest | 5 +- ...chewing-0.5.1-autoconf-archive-2019.01.06.patch | 809 +++++++++++++++++++++ app-i18n/libchewing/libchewing-0.5.1.ebuild | 22 +- app-i18n/libchewing/libchewing-9999.ebuild | 22 +- 4 files changed, 844 insertions(+), 14 deletions(-) create mode 100644 app-i18n/libchewing/files/libchewing-0.5.1-autoconf-archive-2019.01.06.patch (limited to 'app-i18n/libchewing') diff --git a/app-i18n/libchewing/Manifest b/app-i18n/libchewing/Manifest index 2cfcde2e9252..12330029963b 100644 --- a/app-i18n/libchewing/Manifest +++ b/app-i18n/libchewing/Manifest @@ -1,4 +1,5 @@ +AUX libchewing-0.5.1-autoconf-archive-2019.01.06.patch 34944 BLAKE2B 582e2041ff8e99c90df6726ffe0fe7c3f09672ba841def4ded4f367d704a56349da9fe8c555e9b24ec5c82d73774c8690219532c08904cda29a2a33845d2f3d6 SHA512 8e93539fdea3fc6ef01ea070a64d6bdd873ec1c2555fbcb40cc639a22c74a07f8c2936eb100ebb36d146c0e17ce5f80afa8dd3468ff1f5c26a835c3d12b98bb2 DIST libchewing-0.5.1.tar.bz2 3141084 BLAKE2B 28f9e803c8815c0e1b1a1134becffe12f92c1ae24b4b6d4163769d898861fec024db8332befe7130487a72fc20859b6292837e9d68ab1b6477de4cf4f789f2ee SHA512 a6551661bb5e56bba59730b93b373db56af7d42f2ab4881fbfff8727689dd2604d42d2e5c0b04820df66a431dfb5fcb73cc5c9b538615da76198ee3635501c1f -EBUILD libchewing-0.5.1.ebuild 1157 BLAKE2B f9e817f8ef01af9e0e7519784030e1fcfcee909aa1e0668c48b4bcaac1e19f751339d06438629792edf0e16e1637f4f97d8e69dec1841430bbacaf55de86c2f4 SHA512 dbf2d3b7ff80fe5ec410ce3dd8aa3ae3633d98611e053e7d7178d197669364043d9df558a9f4c3e5ba19958a4d951cb04d47da4c2e6e60c063254dbc81d85f59 -EBUILD libchewing-9999.ebuild 1126 BLAKE2B 4e5e2f52f0794e5d411be7b0fcbe28a8e1fc8abfa08e79d57554cfe2f82233072036239ec651bc53ce0cbeaf8ffb6e7c01b6ac41ac02039561afa93e78dea8cd SHA512 b346f7510b75aa0f7e28db5e66b366ae082a5fc4fcdc4b6c21679604c3021de659aa643b7da47e47ad172b11c3009411f51fbcd1179f37e8942fd2896ebe3649 +EBUILD libchewing-0.5.1.ebuild 1313 BLAKE2B b6790434e94f5e82811dfc421c00e23199fe6e6748bebd53bd370a9bd6a3dbc5747e727036de51134607728e60875f11a1df083b2da3f7224f5031aa32fdca0f SHA512 da6256d7a243a8cfb5fcd019deb9dea17fed8cdc54c0c9849efcf5e16cf8b99d3fa3587a9dbfcd22c0d11e3b0a62d6a852c8a3e6957304cbfced95195062fccb +EBUILD libchewing-9999.ebuild 1282 BLAKE2B 2f634e9bbfbd708e33a907639066f90dacf2e4d68463642223f92fadee8e43940d8a738771dba712d0326fd0689fcef313b3cafe0819fbfe799ea4c31cf6dbf0 SHA512 d31d22a67c4a7f0f5690313b11792fee0e0e3489131361ecacbd0b9e9992f19e3031de13dae03c8d0864c6aeda710663d1f8ad4f48be9b09321481961afb1f06 MISC metadata.xml 327 BLAKE2B 3f9b234590aef775dc0ae62f4eef42cc1e363e04c3dabc2464eee9cfb44ec0b1fc4fe9b233f781c15784b3a699537d67e884ee7f1648a62b3a863480a5e831cd SHA512 c9ab28ab34d940a30e97b989fd96904d2e0816e4b1bc5b843b082d64d6cd476335d9402640e71f2cf8f57f44dcae9af66d5e07075b189fa74f21faba40d819e3 diff --git a/app-i18n/libchewing/files/libchewing-0.5.1-autoconf-archive-2019.01.06.patch b/app-i18n/libchewing/files/libchewing-0.5.1-autoconf-archive-2019.01.06.patch new file mode 100644 index 000000000000..5db3d0a23ab0 --- /dev/null +++ b/app-i18n/libchewing/files/libchewing-0.5.1-autoconf-archive-2019.01.06.patch @@ -0,0 +1,809 @@ +https://github.com/chewing/libchewing/issues/308 + +--- /m4/ax_pthread.m4 ++++ /m4/ax_pthread.m4 +@@ -1,5 +1,5 @@ + # =========================================================================== +-# http://www.gnu.org/software/autoconf-archive/ax_pthread.html ++# https://www.gnu.org/software/autoconf-archive/ax_pthread.html + # =========================================================================== + # + # SYNOPSIS +@@ -19,10 +19,10 @@ + # is necessary on AIX to use the special cc_r compiler alias.) + # + # NOTE: You are assumed to not only compile your program with these flags, +-# but also link it with them as well. e.g. you should link with ++# but also to link with them as well. For example, you might link with + # $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS + # +-# If you are only building threads programs, you may wish to use these ++# If you are only building threaded programs, you may wish to use these + # variables in your default LIBS, CFLAGS, and CC: + # + # LIBS="$PTHREAD_LIBS $LIBS" +@@ -30,8 +30,8 @@ + # CC="$PTHREAD_CC" + # + # In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant +-# has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name +-# (e.g. PTHREAD_CREATE_UNDETACHED on AIX). ++# has a nonstandard name, this macro defines PTHREAD_CREATE_JOINABLE to ++# that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX). + # + # Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the + # PTHREAD_PRIO_INHERIT symbol is defined when compiling with +@@ -67,7 +67,7 @@ + # Public License for more details. + # + # You should have received a copy of the GNU General Public License along +-# with this program. If not, see . ++# with this program. If not, see . + # + # As a special exception, the respective Autoconf Macro's copyright owner + # gives unlimited permission to copy, distribute and modify the configure +@@ -82,35 +82,40 @@ + # modified version of the Autoconf Macro, you may extend this special + # exception to the GPL to apply to your modified version as well. + +-#serial 20 ++#serial 24 + + AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD]) + AC_DEFUN([AX_PTHREAD], [ + AC_REQUIRE([AC_CANONICAL_HOST]) ++AC_REQUIRE([AC_PROG_CC]) ++AC_REQUIRE([AC_PROG_SED]) + AC_LANG_PUSH([C]) + ax_pthread_ok=no + + # We used to check for pthread.h first, but this fails if pthread.h +-# requires special compiler flags (e.g. on True64 or Sequent). ++# requires special compiler flags (e.g. on Tru64 or Sequent). + # It gets checked for in the link test anyway. + + # First of all, check if the user has set any of the PTHREAD_LIBS, + # etcetera environment variables, and if threads linking works using + # them: +-if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then +- save_CFLAGS="$CFLAGS" ++if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then ++ ax_pthread_save_CC="$CC" ++ ax_pthread_save_CFLAGS="$CFLAGS" ++ ax_pthread_save_LIBS="$LIBS" ++ AS_IF([test "x$PTHREAD_CC" != "x"], [CC="$PTHREAD_CC"]) + CFLAGS="$CFLAGS $PTHREAD_CFLAGS" +- save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" +- AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS]) +- AC_TRY_LINK_FUNC(pthread_join, ax_pthread_ok=yes) +- AC_MSG_RESULT($ax_pthread_ok) +- if test x"$ax_pthread_ok" = xno; then ++ AC_MSG_CHECKING([for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS]) ++ AC_LINK_IFELSE([AC_LANG_CALL([], [pthread_join])], [ax_pthread_ok=yes]) ++ AC_MSG_RESULT([$ax_pthread_ok]) ++ if test "x$ax_pthread_ok" = "xno"; then + PTHREAD_LIBS="" + PTHREAD_CFLAGS="" + fi +- LIBS="$save_LIBS" +- CFLAGS="$save_CFLAGS" ++ CC="$ax_pthread_save_CC" ++ CFLAGS="$ax_pthread_save_CFLAGS" ++ LIBS="$ax_pthread_save_LIBS" + fi + + # We must check for the threads library under a number of different +@@ -123,7 +128,7 @@ + # which indicates that we try without any flags at all, and "pthread-config" + # which is a program returning the flags for the Pth emulation library. + +-ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config" ++ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config" + + # The ordering *is* (sometimes) important. Some notes on the + # individual items follow: +@@ -132,68 +137,225 @@ + # none: in case threads are in libc; should be tried before -Kthread and + # other compiler flags to prevent continual compiler warnings + # -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) +-# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) +-# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) +-# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads) +-# -pthreads: Solaris/gcc +-# -mthreads: Mingw32/gcc, Lynx/gcc ++# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64 ++# (Note: HP C rejects this with "bad form for `-t' option") ++# -pthreads: Solaris/gcc (Note: HP C also rejects) + # -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it +-# doesn't hurt to check since this sometimes defines pthreads too; +-# also defines -D_REENTRANT) +-# ... -mt is also the pthreads flag for HP/aCC ++# doesn't hurt to check since this sometimes defines pthreads and ++# -D_REENTRANT too), HP C (must be checked before -lpthread, which ++# is present but should not be used directly; and before -mthreads, ++# because the compiler interprets this as "-mt" + "-hreads") ++# -mthreads: Mingw32/gcc, Lynx/gcc + # pthread: Linux, etcetera + # --thread-safe: KAI C++ + # pthread-config: use pthread-config program (for GNU Pth library) + +-case ${host_os} in ++case $host_os in ++ ++ freebsd*) ++ ++ # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) ++ # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) ++ ++ ax_pthread_flags="-kthread lthread $ax_pthread_flags" ++ ;; ++ ++ hpux*) ++ ++ # From the cc(1) man page: "[-mt] Sets various -D flags to enable ++ # multi-threading and also sets -lpthread." ++ ++ ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags" ++ ;; ++ ++ openedition*) ++ ++ # IBM z/OS requires a feature-test macro to be defined in order to ++ # enable POSIX threads at all, so give the user a hint if this is ++ # not set. (We don't define these ourselves, as they can affect ++ # other portions of the system API in unpredictable ways.) ++ ++ AC_EGREP_CPP([AX_PTHREAD_ZOS_MISSING], ++ [ ++# if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS) ++ AX_PTHREAD_ZOS_MISSING ++# endif ++ ], ++ [AC_MSG_WARN([IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support.])]) ++ ;; ++ + solaris*) + + # On Solaris (at least, for some versions), libc contains stubbed + # (non-functional) versions of the pthreads routines, so link-based +- # tests will erroneously succeed. (We need to link with -pthreads/-mt/ +- # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather +- # a function called by this macro, so we could check for that, but +- # who knows whether they'll stub that too in a future libc.) So, +- # we'll just look for -pthreads and -lpthread first: ++ # tests will erroneously succeed. (N.B.: The stubs are missing ++ # pthread_cleanup_push, or rather a function called by this macro, ++ # so we could check for that, but who knows whether they'll stub ++ # that too in a future libc.) So we'll check first for the ++ # standard Solaris way of linking pthreads (-mt -lpthread). ++ ++ ax_pthread_flags="-mt,pthread pthread $ax_pthread_flags" ++ ;; ++esac ++ ++# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC) + +- ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags" ++AS_IF([test "x$GCC" = "xyes"], ++ [ax_pthread_flags="-pthread -pthreads $ax_pthread_flags"]) ++ ++# The presence of a feature test macro requesting re-entrant function ++# definitions is, on some systems, a strong hint that pthreads support is ++# correctly enabled ++ ++case $host_os in ++ darwin* | hpux* | linux* | osf* | solaris*) ++ ax_pthread_check_macro="_REENTRANT" + ;; + +- darwin*) +- ax_pthread_flags="-pthread $ax_pthread_flags" ++ aix*) ++ ax_pthread_check_macro="_THREAD_SAFE" ++ ;; ++ ++ *) ++ ax_pthread_check_macro="--" + ;; + esac ++AS_IF([test "x$ax_pthread_check_macro" = "x--"], ++ [ax_pthread_check_cond=0], ++ [ax_pthread_check_cond="!defined($ax_pthread_check_macro)"]) ++ ++# Are we compiling with Clang? ++ ++AC_CACHE_CHECK([whether $CC is Clang], ++ [ax_cv_PTHREAD_CLANG], ++ [ax_cv_PTHREAD_CLANG=no ++ # Note that Autoconf sets GCC=yes for Clang as well as GCC ++ if test "x$GCC" = "xyes"; then ++ AC_EGREP_CPP([AX_PTHREAD_CC_IS_CLANG], ++ [/* Note: Clang 2.7 lacks __clang_[a-z]+__ */ ++# if defined(__clang__) && defined(__llvm__) ++ AX_PTHREAD_CC_IS_CLANG ++# endif ++ ], ++ [ax_cv_PTHREAD_CLANG=yes]) ++ fi ++ ]) ++ax_pthread_clang="$ax_cv_PTHREAD_CLANG" ++ ++ax_pthread_clang_warning=no ++ ++# Clang needs special handling, because older versions handle the -pthread ++# option in a rather... idiosyncratic way ++ ++if test "x$ax_pthread_clang" = "xyes"; then ++ ++ # Clang takes -pthread; it has never supported any other flag ++ ++ # (Note 1: This will need to be revisited if a system that Clang ++ # supports has POSIX threads in a separate library. This tends not ++ # to be the way of modern systems, but it's conceivable.) ++ ++ # (Note 2: On some systems, notably Darwin, -pthread is not needed ++ # to get POSIX threads support; the API is always present and ++ # active. We could reasonably leave PTHREAD_CFLAGS empty. But ++ # -pthread does define _REENTRANT, and while the Darwin headers ++ # ignore this macro, third-party headers might not.) ++ ++ PTHREAD_CFLAGS="-pthread" ++ PTHREAD_LIBS= ++ ++ ax_pthread_ok=yes ++ ++ # However, older versions of Clang make a point of warning the user ++ # that, in an invocation where only linking and no compilation is ++ # taking place, the -pthread option has no effect ("argument unused ++ # during compilation"). They expect -pthread to be passed in only ++ # when source code is being compiled. ++ # ++ # Problem is, this is at odds with the way Automake and most other ++ # C build frameworks function, which is that the same flags used in ++ # compilation (CFLAGS) are also used in linking. Many systems ++ # supported by AX_PTHREAD require exactly this for POSIX threads ++ # support, and in fact it is often not straightforward to specify a ++ # flag that is used only in the compilation phase and not in ++ # linking. Such a scenario is extremely rare in practice. ++ # ++ # Even though use of the -pthread flag in linking would only print ++ # a warning, this can be a nuisance for well-run software projects ++ # that build with -Werror. So if the active version of Clang has ++ # this misfeature, we search for an option to squash it. ++ ++ AC_CACHE_CHECK([whether Clang needs flag to prevent "argument unused" warning when linking with -pthread], ++ [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG], ++ [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown ++ # Create an alternate version of $ac_link that compiles and ++ # links in two steps (.c -> .o, .o -> exe) instead of one ++ # (.c -> exe), because the warning occurs only in the second ++ # step ++ ax_pthread_save_ac_link="$ac_link" ++ ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g' ++ ax_pthread_link_step=`$as_echo "$ac_link" | sed "$ax_pthread_sed"` ++ ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)" ++ ax_pthread_save_CFLAGS="$CFLAGS" ++ for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do ++ AS_IF([test "x$ax_pthread_try" = "xunknown"], [break]) ++ CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS" ++ ac_link="$ax_pthread_save_ac_link" ++ AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])], ++ [ac_link="$ax_pthread_2step_ac_link" ++ AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])], ++ [break]) ++ ]) ++ done ++ ac_link="$ax_pthread_save_ac_link" ++ CFLAGS="$ax_pthread_save_CFLAGS" ++ AS_IF([test "x$ax_pthread_try" = "x"], [ax_pthread_try=no]) ++ ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try" ++ ]) ++ ++ case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in ++ no | unknown) ;; ++ *) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;; ++ esac ++ ++fi # $ax_pthread_clang = yes + +-if test x"$ax_pthread_ok" = xno; then +-for flag in $ax_pthread_flags; do ++if test "x$ax_pthread_ok" = "xno"; then ++for ax_pthread_try_flag in $ax_pthread_flags; do + +- case $flag in ++ case $ax_pthread_try_flag in + none) + AC_MSG_CHECKING([whether pthreads work without any flags]) + ;; + ++ -mt,pthread) ++ AC_MSG_CHECKING([whether pthreads work with -mt -lpthread]) ++ PTHREAD_CFLAGS="-mt" ++ PTHREAD_LIBS="-lpthread" ++ ;; ++ + -*) +- AC_MSG_CHECKING([whether pthreads work with $flag]) +- PTHREAD_CFLAGS="$flag" ++ AC_MSG_CHECKING([whether pthreads work with $ax_pthread_try_flag]) ++ PTHREAD_CFLAGS="$ax_pthread_try_flag" + ;; + + pthread-config) +- AC_CHECK_PROG(ax_pthread_config, pthread-config, yes, no) +- if test x"$ax_pthread_config" = xno; then continue; fi ++ AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no]) ++ AS_IF([test "x$ax_pthread_config" = "xno"], [continue]) + PTHREAD_CFLAGS="`pthread-config --cflags`" + PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" + ;; + + *) +- AC_MSG_CHECKING([for the pthreads library -l$flag]) +- PTHREAD_LIBS="-l$flag" ++ AC_MSG_CHECKING([for the pthreads library -l$ax_pthread_try_flag]) ++ PTHREAD_LIBS="-l$ax_pthread_try_flag" + ;; + esac + +- save_LIBS="$LIBS" +- save_CFLAGS="$CFLAGS" +- LIBS="$PTHREAD_LIBS $LIBS" ++ ax_pthread_save_CFLAGS="$CFLAGS" ++ ax_pthread_save_LIBS="$LIBS" + CFLAGS="$CFLAGS $PTHREAD_CFLAGS" ++ LIBS="$PTHREAD_LIBS $LIBS" + + # Check for various functions. We must include pthread.h, + # since some functions may be macros. (On the Sequent, we +@@ -204,7 +366,11 @@ + # pthread_cleanup_push because it is one of the few pthread + # functions on Solaris that doesn't have a non-functional libc stub. + # We try pthread_create on general principles. ++ + AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ++# if $ax_pthread_check_cond ++# error "$ax_pthread_check_macro must be defined" ++# endif + static void routine(void *a) { a = 0; } + static void *start_routine(void *a) { return a; }], + [pthread_t th; pthread_attr_t attr; +@@ -213,16 +379,14 @@ + pthread_attr_init(&attr); + pthread_cleanup_push(routine, 0); + pthread_cleanup_pop(0) /* ; */])], +- [ax_pthread_ok=yes], +- []) ++ [ax_pthread_ok=yes], ++ []) + +- LIBS="$save_LIBS" +- CFLAGS="$save_CFLAGS" ++ CFLAGS="$ax_pthread_save_CFLAGS" ++ LIBS="$ax_pthread_save_LIBS" + +- AC_MSG_RESULT($ax_pthread_ok) +- if test "x$ax_pthread_ok" = xyes; then +- break; +- fi ++ AC_MSG_RESULT([$ax_pthread_ok]) ++ AS_IF([test "x$ax_pthread_ok" = "xyes"], [break]) + + PTHREAD_LIBS="" + PTHREAD_CFLAGS="" +@@ -230,70 +394,74 @@ + fi + + # Various other checks: +-if test "x$ax_pthread_ok" = xyes; then +- save_LIBS="$LIBS" +- LIBS="$PTHREAD_LIBS $LIBS" +- save_CFLAGS="$CFLAGS" ++if test "x$ax_pthread_ok" = "xyes"; then ++ ax_pthread_save_CFLAGS="$CFLAGS" ++ ax_pthread_save_LIBS="$LIBS" + CFLAGS="$CFLAGS $PTHREAD_CFLAGS" ++ LIBS="$PTHREAD_LIBS $LIBS" + + # Detect AIX lossage: JOINABLE attribute is called UNDETACHED. +- AC_MSG_CHECKING([for joinable pthread attribute]) +- attr_name=unknown +- for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do +- AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ], +- [int attr = $attr; return attr /* ; */])], +- [attr_name=$attr; break], +- []) +- done +- AC_MSG_RESULT($attr_name) +- if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then +- AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name, +- [Define to necessary symbol if this constant +- uses a non-standard name on your system.]) +- fi +- +- AC_MSG_CHECKING([if more special flags are required for pthreads]) +- flag=no +- case ${host_os} in +- aix* | freebsd* | darwin*) flag="-D_THREAD_SAFE";; +- osf* | hpux*) flag="-D_REENTRANT";; +- solaris*) +- if test "$GCC" = "yes"; then +- flag="-D_REENTRANT" +- else +- flag="-mt -D_REENTRANT" +- fi +- ;; +- esac +- AC_MSG_RESULT(${flag}) +- if test "x$flag" != xno; then +- PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS" +- fi ++ AC_CACHE_CHECK([for joinable pthread attribute], ++ [ax_cv_PTHREAD_JOINABLE_ATTR], ++ [ax_cv_PTHREAD_JOINABLE_ATTR=unknown ++ for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do ++ AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ], ++ [int attr = $ax_pthread_attr; return attr /* ; */])], ++ [ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break], ++ []) ++ done ++ ]) ++ AS_IF([test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \ ++ test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \ ++ test "x$ax_pthread_joinable_attr_defined" != "xyes"], ++ [AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE], ++ [$ax_cv_PTHREAD_JOINABLE_ATTR], ++ [Define to necessary symbol if this constant ++ uses a non-standard name on your system.]) ++ ax_pthread_joinable_attr_defined=yes ++ ]) ++ ++ AC_CACHE_CHECK([whether more special flags are required for pthreads], ++ [ax_cv_PTHREAD_SPECIAL_FLAGS], ++ [ax_cv_PTHREAD_SPECIAL_FLAGS=no ++ case $host_os in ++ solaris*) ++ ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS" ++ ;; ++ esac ++ ]) ++ AS_IF([test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \ ++ test "x$ax_pthread_special_flags_added" != "xyes"], ++ [PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS" ++ ax_pthread_special_flags_added=yes]) + + AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT], +- ax_cv_PTHREAD_PRIO_INHERIT, [ +- AC_LINK_IFELSE([ +- AC_LANG_PROGRAM([[#include ]], [[int i = PTHREAD_PRIO_INHERIT;]])], +- [ax_cv_PTHREAD_PRIO_INHERIT=yes], +- [ax_cv_PTHREAD_PRIO_INHERIT=no]) ++ [ax_cv_PTHREAD_PRIO_INHERIT], ++ [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], ++ [[int i = PTHREAD_PRIO_INHERIT;]])], ++ [ax_cv_PTHREAD_PRIO_INHERIT=yes], ++ [ax_cv_PTHREAD_PRIO_INHERIT=no]) + ]) +- AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"], +- AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], 1, [Have PTHREAD_PRIO_INHERIT.])) ++ AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \ ++ test "x$ax_pthread_prio_inherit_defined" != "xyes"], ++ [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.]) ++ ax_pthread_prio_inherit_defined=yes ++ ]) + +- LIBS="$save_LIBS" +- CFLAGS="$save_CFLAGS" ++ CFLAGS="$ax_pthread_save_CFLAGS" ++ LIBS="$ax_pthread_save_LIBS" + + # More AIX lossage: compile with *_r variant +- if test "x$GCC" != xyes; then ++ if test "x$GCC" != "xyes"; then + case $host_os in + aix*) + AS_CASE(["x/$CC"], +- [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6], +- [#handle absolute path differently from PATH based program lookup +- AS_CASE(["x$CC"], +- [x/*], +- [AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])], +- [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])]) ++ [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6], ++ [#handle absolute path differently from PATH based program lookup ++ AS_CASE(["x$CC"], ++ [x/*], ++ [AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])], ++ [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])]) + ;; + esac + fi +@@ -301,13 +469,13 @@ + + test -n "$PTHREAD_CC" || PTHREAD_CC="$CC" + +-AC_SUBST(PTHREAD_LIBS) +-AC_SUBST(PTHREAD_CFLAGS) +-AC_SUBST(PTHREAD_CC) ++AC_SUBST([PTHREAD_LIBS]) ++AC_SUBST([PTHREAD_CFLAGS]) ++AC_SUBST([PTHREAD_CC]) + + # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: +-if test x"$ax_pthread_ok" = xyes; then +- ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1]) ++if test "x$ax_pthread_ok" = "xyes"; then ++ ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1]) + : + else + ax_pthread_ok=no +--- /m4/ax_with_curses.m4 ++++ /m4/ax_with_curses.m4 +@@ -1,5 +1,5 @@ + # =========================================================================== +-# http://www.gnu.org/software/autoconf-archive/ax_with_curses.html ++# https://www.gnu.org/software/autoconf-archive/ax_with_curses.html + # =========================================================================== + # + # SYNOPSIS +@@ -12,7 +12,9 @@ + # present, along with the associated header file. The NcursesW + # (wide-character) library is searched for first, followed by Ncurses, + # then the system-default plain Curses. The first library found is the +-# one returned. ++# one returned. Finding libraries will first be attempted by using ++# pkg-config, and should the pkg-config files not be available, will ++# fallback to combinations of known flags itself. + # + # The following options are understood: --with-ncursesw, --with-ncurses, + # --without-ncursesw, --without-ncurses. The "--with" options force the +@@ -52,23 +54,29 @@ + # + # (These preprocessor symbols are discussed later in this document.) + # +-# The following output variable is defined by this macro; it is precious +-# and may be overridden on the ./configure command line: ++# The following output variables are defined by this macro; they are ++# precious and may be overridden on the ./configure command line: + # +-# CURSES_LIB - library to add to xxx_LDADD ++# CURSES_LIBS - library to add to xxx_LDADD ++# CURSES_CFLAGS - include paths to add to xxx_CPPFLAGS + # +-# The library listed in CURSES_LIB is NOT added to LIBS by default. You +-# need to add CURSES_LIB to the appropriate xxx_LDADD line in your +-# Makefile.am. For example: +-# +-# prog_LDADD = @CURSES_LIB@ +-# +-# If CURSES_LIB is set on the configure command line (such as by running +-# "./configure CURSES_LIB=-lmycurses"), then the only header searched for +-# is . The user may use the CPPFLAGS precious variable to +-# override the standard #include search path. If the user needs to +-# specify an alternative path for a library (such as for a non-standard +-# NcurseW), the user should use the LDFLAGS variable. ++# In previous versions of this macro, the flags CURSES_LIB and ++# CURSES_CPPFLAGS were defined. These have been renamed, in keeping with ++# AX_WITH_CURSES's close bigger brother, PKG_CHECK_MODULES, which should ++# eventually supersede the use of AX_WITH_CURSES. Neither the library ++# listed in CURSES_LIBS, nor the flags in CURSES_CFLAGS are added to LIBS, ++# respectively CPPFLAGS, by default. You need to add both to the ++# appropriate xxx_LDADD/xxx_CPPFLAGS line in your Makefile.am. For ++# example: ++# ++# prog_LDADD = @CURSES_LIBS@ ++# prog_CPPFLAGS = @CURSES_CFLAGS@ ++# ++# If CURSES_LIBS is set on the configure command line (such as by running ++# "./configure CURSES_LIBS=-lmycurses"), then the only header searched for ++# is . If the user needs to specify an alternative path for a ++# library (such as for a non-standard NcurseW), the user should use the ++# LDFLAGS variable. + # + # The following shell variables may be defined by this macro: + # +@@ -88,7 +96,7 @@ + # + # AX_WITH_CURSES + # if test "x$ax_cv_ncursesw" != xyes && test "x$ax_cv_ncurses" != xyes; then +-# AX_MSG_ERROR([requires either NcursesW or Ncurses library]) ++# AC_MSG_ERROR([requires either NcursesW or Ncurses library]) + # fi + # + # If any Curses library will do (but one must be present and must support +@@ -167,7 +175,7 @@ + # Public License for more details. + # + # You should have received a copy of the GNU General Public License along +-# with this program. If not, see . ++# with this program. If not, see . + # + # As a special exception, the respective Autoconf Macro's copyright owner + # gives unlimited permission to copy, distribute and modify the configure +@@ -182,11 +190,66 @@ + # modified version of the Autoconf Macro, you may extend this special + # exception to the GPL to apply to your modified version as well. + +-#serial 13 ++#serial 18 ++ ++# internal function to factorize common code that is used by both ncurses ++# and ncursesw ++AC_DEFUN([_FIND_CURSES_FLAGS], [ ++ AC_MSG_CHECKING([for $1 via pkg-config]) ++ ++ AX_REQUIRE_DEFINED([PKG_CHECK_EXISTS]) ++ _PKG_CONFIG([_ax_cv_$1_libs], [libs], [$1]) ++ _PKG_CONFIG([_ax_cv_$1_cppflags], [cflags], [$1]) ++ ++ AS_IF([test "x$pkg_failed" = "xyes" || test "x$pkg_failed" = "xuntried"],[ ++ AC_MSG_RESULT([no]) ++ # No suitable .pc file found, have to find flags via fallback ++ AC_CACHE_CHECK([for $1 via fallback], [ax_cv_$1], [ ++ AS_ECHO() ++ pkg_cv__ax_cv_$1_libs="-l$1" ++ pkg_cv__ax_cv_$1_cppflags="-D_GNU_SOURCE $CURSES_CFLAGS" ++ LIBS="$ax_saved_LIBS $pkg_cv__ax_cv_$1_libs" ++ CPPFLAGS="$ax_saved_CPPFLAGS $pkg_cv__ax_cv_$1_cppflags" ++ ++ AC_MSG_CHECKING([for initscr() with $pkg_cv__ax_cv_$1_libs]) ++ AC_LINK_IFELSE([AC_LANG_CALL([], [initscr])], ++ [ ++ AC_MSG_RESULT([yes]) ++ AC_MSG_CHECKING([for nodelay() with $pkg_cv__ax_cv_$1_libs]) ++ AC_LINK_IFELSE([AC_LANG_CALL([], [nodelay])],[ ++ ax_cv_$1=yes ++ ],[ ++ AC_MSG_RESULT([no]) ++ m4_if( ++ [$1],[ncursesw],[pkg_cv__ax_cv_$1_libs="$pkg_cv__ax_cv_$1_libs -ltinfow"], ++ [$1],[ncurses],[pkg_cv__ax_cv_$1_libs="$pkg_cv__ax_cv_$1_libs -ltinfo"] ++ ) ++ LIBS="$ax_saved_LIBS $pkg_cv__ax_cv_$1_libs" ++ ++ AC_MSG_CHECKING([for nodelay() with $pkg_cv__ax_cv_$1_libs]) ++ AC_LINK_IFELSE([AC_LANG_CALL([], [nodelay])],[ ++ ax_cv_$1=yes ++ ],[ ++ ax_cv_$1=no ++ ]) ++ ]) ++ ],[ ++ ax_cv_$1=no ++ ]) ++ ]) ++ ],[ ++ AC_MSG_RESULT([yes]) ++ # Found .pc file, using its information ++ LIBS="$ax_saved_LIBS $pkg_cv__ax_cv_$1_libs" ++ CPPFLAGS="$ax_saved_CPPFLAGS $pkg_cv__ax_cv_$1_cppflags" ++ ax_cv_$1=yes ++ ]) ++]) + + AU_ALIAS([MP_WITH_CURSES], [AX_WITH_CURSES]) + AC_DEFUN([AX_WITH_CURSES], [ +- AC_ARG_VAR([CURSES_LIB], [linker library for Curses, e.g. -lcurses]) ++ AC_ARG_VAR([CURSES_LIBS], [linker library for Curses, e.g. -lcurses]) ++ AC_ARG_VAR([CURSES_CFLAGS], [preprocessor flags for Curses, e.g. -I/usr/include/ncursesw]) + AC_ARG_WITH([ncurses], [AS_HELP_STRING([--with-ncurses], + [force the use of Ncurses or NcursesW])], + [], [with_ncurses=check]) +@@ -195,20 +258,17 @@ + [], [with_ncursesw=check]) + + ax_saved_LIBS=$LIBS ++ ax_saved_CPPFLAGS=$CPPFLAGS ++ + AS_IF([test "x$with_ncurses" = xyes || test "x$with_ncursesw" = xyes], + [ax_with_plaincurses=no], [ax_with_plaincurses=check]) + + ax_cv_curses_which=no + + # Test for NcursesW ++ AS_IF([test "x$CURSES_LIBS" = x && test "x$with_ncursesw" != xno], [ ++ _FIND_CURSES_FLAGS([ncursesw]) + +- AS_IF([test "x$CURSES_LIB" = x && test "x$with_ncursesw" != xno], [ +- LIBS="$ax_saved_LIBS -lncursesw" +- +- AC_CACHE_CHECK([for NcursesW wide-character library], [ax_cv_ncursesw], [ +- AC_LINK_IFELSE([AC_LANG_CALL([], [initscr])], +- [ax_cv_ncursesw=yes], [ax_cv_ncursesw=no]) +- ]) + AS_IF([test "x$ax_cv_ncursesw" = xno && test "x$with_ncursesw" = xyes], [ + AC_MSG_ERROR([--with-ncursesw specified but could not find NcursesW library]) + ]) +@@ -216,7 +276,8 @@ + AS_IF([test "x$ax_cv_ncursesw" = xyes], [ + ax_cv_curses=yes + ax_cv_curses_which=ncursesw +- CURSES_LIB="-lncursesw" ++ CURSES_LIBS="$pkg_cv__ax_cv_ncursesw_libs" ++ CURSES_CFLAGS="$pkg_cv__ax_cv_ncursesw_cppflags" + AC_DEFINE([HAVE_NCURSESW], [1], [Define to 1 if the NcursesW library is present]) + AC_DEFINE([HAVE_CURSES], [1], [Define to 1 if a SysV or X/Open compatible Curses library is present]) + +@@ -318,16 +379,13 @@ + ]) + ]) + ]) ++ unset pkg_cv__ax_cv_ncursesw_libs ++ unset pkg_cv__ax_cv_ncursesw_cppflags + + # Test for Ncurses ++ AS_IF([test "x$CURSES_LIBS" = x && test "x$with_ncurses" != xno && test "x$ax_cv_curses_which" = xno], [ ++ _FIND_CURSES_FLAGS([ncurses]) + +- AS_IF([test "x$CURSES_LIB" = x && test "x$with_ncurses" != xno && test "x$ax_cv_curses_which" = xno], [ +- LIBS="$ax_saved_LIBS -lncurses" +- +- AC_CACHE_CHECK([for Ncurses library], [ax_cv_ncurses], [ +- AC_LINK_IFELSE([AC_LANG_CALL([], [initscr])], +- [ax_cv_ncurses=yes], [ax_cv_ncurses=no]) +- ]) + AS_IF([test "x$ax_cv_ncurses" = xno && test "x$with_ncurses" = xyes], [ + AC_MSG_ERROR([--with-ncurses specified but could not find Ncurses library]) + ]) +@@ -335,7 +393,8 @@ + AS_IF([test "x$ax_cv_ncurses" = xyes], [ + ax_cv_curses=yes + ax_cv_curses_which=ncurses +- CURSES_LIB="-lncurses" ++ CURSES_LIBS="$pkg_cv__ax_cv_ncurses_libs" ++ CURSES_CFLAGS="$pkg_cv__ax_cv_ncurses_cppflags" + AC_DEFINE([HAVE_NCURSES], [1], [Define to 1 if the Ncurses library is present]) + AC_DEFINE([HAVE_CURSES], [1], [Define to 1 if a SysV or X/Open compatible Curses library is present]) + +@@ -390,12 +449,13 @@ + ]) + ]) + ]) ++ unset pkg_cv__ax_cv_ncurses_libs ++ unset pkg_cv__ax_cv_ncurses_cppflags + +- # Test for plain Curses (or if CURSES_LIB was set by user) +- ++ # Test for plain Curses (or if CURSES_LIBS was set by user) + AS_IF([test "x$with_plaincurses" != xno && test "x$ax_cv_curses_which" = xno], [ +- AS_IF([test "x$CURSES_LIB" != x], [ +- LIBS="$ax_saved_LIBS $CURSES_LIB" ++ AS_IF([test "x$CURSES_LIBS" != x], [ ++ LIBS="$ax_saved_LIBS $CURSES_LIBS" + ], [ + LIBS="$ax_saved_LIBS -lcurses" + ]) +@@ -408,8 +468,8 @@ + AS_IF([test "x$ax_cv_plaincurses" = xyes], [ + ax_cv_curses=yes + ax_cv_curses_which=plaincurses +- AS_IF([test "x$CURSES_LIB" = x], [ +- CURSES_LIB="-lcurses" ++ AS_IF([test "x$CURSES_LIBS" = x], [ ++ CURSES_LIBS="-lcurses" + ]) + AC_DEFINE([HAVE_CURSES], [1], [Define to 1 if a SysV or X/Open compatible Curses library is present]) + +@@ -515,4 +575,8 @@ + AS_IF([test "x$ax_cv_curses_obsolete" != xyes], [ax_cv_curses_obsolete=no]) + + LIBS=$ax_saved_LIBS ++ CPPFLAGS=$ax_saved_CPPFLAGS ++ ++ unset ax_saved_LIBS ++ unset ax_saved_CPPFLAGS + ])dnl +--- /test/Makefile.am ++++ /test/Makefile.am +@@ -65,7 +65,8 @@ + if ENABLE_TEXT_UI + TEXT_UI_BIN=genkeystroke + genkeystroke_SOURCES = genkeystroke.c +-genkeystroke_LDADD = $(LDADD) @CURSES_LIB@ ++genkeystroke_CPPFLAGS = $(AM_CPPFLAGS) @CURSES_CFLAGS@ ++genkeystroke_LDADD = $(LDADD) @CURSES_LIBS@ + else + TEXT_UI_BIN= + endif diff --git a/app-i18n/libchewing/libchewing-0.5.1.ebuild b/app-i18n/libchewing/libchewing-0.5.1.ebuild index 4a2f116c20e0..1c78e61d60e1 100644 --- a/app-i18n/libchewing/libchewing-0.5.1.ebuild +++ b/app-i18n/libchewing/libchewing-0.5.1.ebuild @@ -3,8 +3,11 @@ EAPI="7" +inherit autotools + if [[ "${PV}" == "9999" ]]; then - inherit autotools git-r3 +# inherit autotools git-r3 + inherit git-r3 EGIT_REPO_URI="https://github.com/chewing/libchewing" fi @@ -27,12 +30,17 @@ RDEPEND="dev-db/sqlite:3" DEPEND="${RDEPEND} test? ( sys-libs/ncurses[unicode] )" +PATCHES=( + "${FILESDIR}/${PN}-0.5.1-autoconf-archive-2019.01.06.patch" +) + src_prepare() { default + eautoreconf - if [[ "${PV}" == "9999" ]]; then - eautoreconf - fi +# if [[ "${PV}" == "9999" ]]; then +# eautoreconf +# fi } src_configure() { @@ -48,6 +56,8 @@ src_test() { src_install() { default - find "${D}" -name "*.la" -delete || die - use static-libs || find "${D}" -name "*.a" -delete || die + find "${D}" -name "*.la" -type f -delete || die + if ! use static-libs; then + find "${D}" -name "*.a" -type f -delete || die + fi } diff --git a/app-i18n/libchewing/libchewing-9999.ebuild b/app-i18n/libchewing/libchewing-9999.ebuild index 9353fc5f3dd0..e059c2147b15 100644 --- a/app-i18n/libchewing/libchewing-9999.ebuild +++ b/app-i18n/libchewing/libchewing-9999.ebuild @@ -3,8 +3,11 @@ EAPI="7" +inherit autotools + if [[ "${PV}" == "9999" ]]; then - inherit autotools git-r3 +# inherit autotools git-r3 + inherit git-r3 EGIT_REPO_URI="https://github.com/chewing/libchewing" fi @@ -27,12 +30,17 @@ RDEPEND="dev-db/sqlite:3" DEPEND="${RDEPEND} test? ( sys-libs/ncurses[unicode] )" +PATCHES=( + "${FILESDIR}/${PN}-0.5.1-autoconf-archive-2019.01.06.patch" +) + src_prepare() { default + eautoreconf - if [[ "${PV}" == "9999" ]]; then - eautoreconf - fi +# if [[ "${PV}" == "9999" ]]; then +# eautoreconf +# fi } src_configure() { @@ -48,6 +56,8 @@ src_test() { src_install() { default - find "${D}" -name "*.la" -delete || die - use static-libs || find "${D}" -name "*.a" -delete || die + find "${D}" -name "*.la" -type f -delete || die + if ! use static-libs; then + find "${D}" -name "*.a" -type f -delete || die + fi } -- cgit v1.2.3