xcrypt 0.1.0

data/ext/libxcrypt/build-aux/m4/zw_endianness.m4

@@ -0,0 +1,152 @@
+dnl Written by Zack Weinberg <zackw at panix.com> in 2018.
+dnl To the extent possible under law, Zack Weinberg has waived all
+dnl copyright and related or neighboring rights to this work.
+dnl
+dnl See https://creativecommons.org/publicdomain/zero/1.0/ for further
+dnl details.
+dnl
+dnl This macro is like AC_C_BIGENDIAN, but it doesn't try to determine
+dnl a final value at configure time.  Instead, it probes for a set of
+dnl headers and compile-time macros that may or may not be available,
+dnl and uses them to guide preprocessor logic that makes the final
+dnl determination.  This works better with MacOS "universal binaries",
+dnl which may involve compiling the program twice under opposite
+dnl endiannesses; no fixed byte-order macro is correct in that case,
+dnl but the compiler's built-ins will be.  This approach is also
+dnl friendlier to cross-compilation.
+dnl
+dnl This is the preprocessor logic that should be put in an appropriate
+dnl location, after including config.h:
+dnl
+dnl #include <limits.h>
+dnl #ifdef HAVE_ENDIAN_H
+dnl #include <endian.h>
+dnl #endif
+dnl #ifdef HAVE_SYS_ENDIAN_H
+dnl #include <sys/endian.h>
+dnl #endif
+dnl #ifdef HAVE_SYS_PARAM_H
+dnl #include <sys/param.h>
+dnl #endif
+dnl
+dnl #if ENDIANNESS_IS_BIG
+dnl # define ENDIAN_BIG
+dnl #elif ENDIANNESS_IS_LITTLE
+dnl # define ENDIAN_LITTLE
+dnl #elif ENDIANNESS_IS_PDP
+dnl # define ENDIAN_PDP
+dnl #else
+dnl # error "Unable to determine byte order"
+dnl #endif
+dnl ------------------------------------------------
+
+dnl There's no good way to implement this macro as a _shell_ loop, but we
+dnl can reasonably implement it as an _m4_ loop that expands to a sequence
+dnl of conditionals.  Actually two sequences of conditionals, one inside
+dnl AC_CACHE_CHECK and one outside.
+
+m4_define([zw_C_ENDIANNESS_options], [
+[ [BYTE_ORDER and xxx_ENDIAN],
+  [defined BYTE_ORDER && defined BIG_ENDIAN && defined LITTLE_ENDIAN && BIG_ENDIAN != LITTLE_ENDIAN],
+  [BYTE_ORDER == BIG_ENDIAN],
+  [BYTE_ORDER == LITTLE_ENDIAN],
+  [BYTE_ORDER == PDP_ENDIAN],
+],
+[ [__BYTE_ORDER and __xxx_ENDIAN],
+  [defined __BYTE_ORDER && defined __BIG_ENDIAN && defined __LITTLE_ENDIAN && __BIG_ENDIAN != __LITTLE_ENDIAN],
+  [__BYTE_ORDER == __BIG_ENDIAN],
+  [__BYTE_ORDER == __LITTLE_ENDIAN],
+  [__BYTE_ORDER == __PDP_ENDIAN],
+],
+[ [__BYTE_ORDER__ and __xxx_ENDIAN__],
+  [defined __BYTE_ORDER__ && defined __BIG_ENDIAN__ && defined __LITTLE_ENDIAN__ && __BIG_ENDIAN__ != __LITTLE_ENDIAN__],
+  [__BYTE_ORDER__ == __BIG_ENDIAN__],
+  [__BYTE_ORDER__ == __LITTLE_ENDIAN__],
+  [__BYTE_ORDER__ == __PDP_ENDIAN__],
+],
+[ [__BYTE_ORDER__ and __ORDER_xxx_ENDIAN__],
+  [defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__ && defined __ORDER_LITTLE_ENDIAN__ && __ORDER_BIG_ENDIAN__ != __ORDER_LITTLE_ENDIAN__],
+  [__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__],
+  [__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__],
+  [__BYTE_ORDER__ == __ORDER_PDP_ENDIAN__],
+],
+[ [_BIG_ENDIAN and _LITTLE_ENDIAN],
+  [(defined _BIG_ENDIAN) != (defined _LITTLE_ENDIAN)],
+  [defined _BIG_ENDIAN], [defined _LITTLE_ENDIAN], [0],
+],
+[ [__BIG_ENDIAN__ and __LITTLE_ENDIAN__],
+  [(defined __BIG_ENDIAN__) != (defined __LITTLE_ENDIAN__)],
+  [defined __BIG_ENDIAN__], [defined __LITTLE_ENDIAN__], [0],
+],
+[ [__ARMEB__ and __ARMEL__],
+  [(defined __ARMEB__) != (defined __ARMEL__)],
+  [defined __ARMEB__], [defined __ARMEL__], [0],
+],
+[ [__THUMBEB__ and __THUMBEL__],
+  [(defined __THUMBEB__) != (defined __THUMBEL__)],
+  [defined __THUMBEB__], [defined __THUMBEL__], [0],
+],
+[ [__AARCH64EB__ and __AARCH64EL__],
+  [(defined __AARCH64EB__) != (defined __AARCH64EL__)],
+  [defined __AARCH64EB__], [defined __AARCH64EL__], [0],
+],
+[ [__MIPSEB__ and __MIPSEL__],
+  [(defined __MIPSEB__) != (defined __MIPSEL__)],
+  [defined __MIPSEB__], [defined __MIPSEL__], [0],
+],
+[ [__MIPSEB and __MIPSEL],
+  [(defined __MIPSEB) != (defined __MIPSEL)],
+  [defined __MIPSEB], [defined __MIPSEL], [0],
+],
+[ [_MIPSEB and _MIPSEL],
+  [(defined _MIPSEB) != (defined _MIPSEL)],
+  [defined _MIPSEB], [defined _MIPSEL], [0],
+]
+])
+
+m4_define([zw_C_ENDIANNESS_test_one], [
+if test "$[]ac_cv_c_byte_order_macros" = unknown; then
+  AC_PREPROC_IFELSE([AC_LANG_PROGRAM([[
+#include <limits.h>
+#ifdef HAVE_ENDIAN_H
+#include <endian.h>
+#endif
+#ifdef HAVE_SYS_ENDIAN_H
+#include <sys/endian.h>
+#endif
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#if !($2)
+#error fail
+#endif
+]])],
+  [ac_cv_c_byte_order_macros="$1"])
+fi])
+
+m4_define([zw_C_ENDIANNESS_case_one],
+  [["$1"], [
+  zw_C_ENDIANNESS_IS_BIG="($3)"
+  zw_C_ENDIANNESS_IS_LIT="($4)"
+  zw_C_ENDIANNESS_IS_PDP="($5)"]])
+
+AC_DEFUN([zw_C_ENDIANNESS], [
+AC_REQUIRE([AC_PROG_CC])
+AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])
+AC_CHECK_HEADERS_ONCE([endian.h sys/endian.h sys/param.h])
+AC_CACHE_CHECK([for byte order macros],
+  [ac_cv_c_byte_order_macros], [
+  ac_cv_c_byte_order_macros=unknown
+  m4_map([zw_C_ENDIANNESS_test_one], [zw_C_ENDIANNESS_options])])
+
+AS_CASE([$ac_cv_c_byte_order_macros],
+        m4_map_sep([zw_C_ENDIANNESS_case_one], [,], [zw_C_ENDIANNESS_options]),
+        [AC_MSG_ERROR([unable to determine byte order at compile time])])
+
+AC_DEFINE_UNQUOTED([ENDIANNESS_IS_BIG], [$zw_C_ENDIANNESS_IS_BIG],
+  [Define as an @%:@if expression that is true when compiling for a big-endian CPU.])
+AC_DEFINE_UNQUOTED([ENDIANNESS_IS_LITTLE], [$zw_C_ENDIANNESS_IS_LIT],
+  [Define as an @%:@if expression that is true when compiling for a little-endian CPU.])
+AC_DEFINE_UNQUOTED([ENDIANNESS_IS_PDP], [$zw_C_ENDIANNESS_IS_PDP],
+  [Define as an @%:@if expression that is true when compiling for a PDP-endian CPU.])
+])

data/ext/libxcrypt/build-aux/m4/zw_ld_wrap.m4

@@ -0,0 +1,47 @@
+dnl Written by Zack Weinberg <zackw at panix.com> in 2018.
+dnl To the extent possible under law, Zack Weinberg has waived all
+dnl copyright and related or neighboring rights to this work.
+dnl
+dnl See https://creativecommons.org/publicdomain/zero/1.0/ for further
+dnl details.
+dnl
+dnl Find out whether ld --wrap is supported.
+AC_DEFUN([zw_PROG_LD_WRAP],
+  [AC_REQUIRE([AC_PROG_CC])
+   AC_CACHE_CHECK([for ld --wrap], [zw_cv_prog_ld_wrap],
+     [save_LDFLAGS="$LDFLAGS"
+      save_LIBS="$LIBS"
+      LDFLAGS=""
+      LIBS=""
+      AC_COMPILE_IFELSE(
+        [AC_LANG_SOURCE([[
+            extern void bar(void);
+            void foo(void) { bar(); }
+        ]])],
+        [mv conftest.$OBJEXT conftest2.$OBJEXT
+         LDFLAGS="-Wl,--wrap,bar"
+         LIBS="conftest2.$OBJEXT"
+         AC_LINK_IFELSE(
+           [AC_LANG_PROGRAM([[
+               extern void foo(void);
+               void __wrap_bar(void) {}
+            ]], [[
+               foo();
+            ]])],
+           [zw_cv_prog_ld_wrap=yes],
+           [zw_cv_prog_ld_wrap=no])
+         rm -f conftest2.$OBJEXT
+        ],
+        [zw_cv_prog_ld_wrap=no])
+      LDFLAGS="$save_LDFLAGS"
+      LIBS="$save_LIBS"])
+   if test x$zw_cv_prog_ld_wrap = xyes; then
+      have_ld_wrap=yes
+      AC_DEFINE([HAVE_LD_WRAP], 1,
+                [Define to 1 if -Wl,--wrap,SYMBOL can be used to intercept
+                 calls to SYMBOL at link time.])
+   else
+      have_ld_wrap=no
+   fi
+   AM_CONDITIONAL([HAVE_LD_WRAP], [test $have_ld_wrap = yes])
+])

data/ext/libxcrypt/build-aux/m4/zw_prog_perl.m4

@@ -0,0 +1,40 @@
+# zw_prog_perl.m4  -*- autoconf -*-
+# serial 1
+#
+# inspired by, but shares no code with, ax_prog_perl_version.m4 by
+# Franceso Salvestrini
+#
+# SYNOPSIS
+#
+#   zw_PROG_PERL([VERSION], [ACTION-IF-TRUE],
+#                [ACTION-IF-FALSE = (error out)])
+#
+# DESCRIPTION
+#
+#   Locate a Perl interpreter, and then verify that its version number
+#   is greater than or equal to VERSION.  If it is, set output variable
+#   PERL to the absolute path of that interpreter, and execute
+#   ACTION-IF-TRUE, if present.  Otherwise, execute ACTION-IF-FALSE.
+#   If ACTION-IF-FALSE is not present it defaults to issuing an error
+#   and stopping the configuration process.
+#
+# LICENSE
+#
+#   Copyright (c) 2020 Zack Weinberg <zackw@panix.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 13
+
+AC_DEFUN([zw_PROG_PERL],
+[AC_PATH_PROG([PERL], [perl])
+AC_MSG_CHECKING([whether $PERL is version $1 or later])
+_AS_ECHO_LOG([$PERL -e 'use v$1;'])
+AS_IF(["$PERL" -e 'use v$1;' >&AS_MESSAGE_LOG_FD 2>&1],
+  [AC_MSG_RESULT([yes])m4_ifnblank([$2], [
+  $2])],
+  [AC_MSG_RESULT([no])
+m4_default([$3], [AC_MSG_ERROR([Perl version $1 or later is required])])])])

data/ext/libxcrypt/build-aux/m4/zw_simple_warnings.m4

@@ -0,0 +1,150 @@
+# serial 1
+dnl Copyright 2017 Zack Weinberg <zackw at panix.com>.
+dnl Partially based on Autoconf, copyright 1992-2017 Free Software Foundation.
+dnl
+dnl This program is free software; you can redistribute it and/or
+dnl modify it under the terms of the GNU General Public License as
+dnl published by the Free Software Foundation, either version 3 of the
+dnl License, or (at your option) any later version.
+dnl
+dnl This program is distributed in the hope that it will be useful,
+dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
+dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+dnl GNU General Public License for more details.
+dnl
+dnl Under Section 7 of GPL version 3, you are granted additional
+dnl permissions described in the Autoconf Configure Script Exception,
+dnl version 3.0, as published by the Free Software Foundation.
+dnl
+dnl Because only two files in this source tree are released
+dnl under GPLv3 with exceptions, neither the GPLv3 nor the exception are
+dnl distributed with this source tree.  Copies can be retrieved from
+dnl https://www.gnu.org/licenses/
+dnl
+dnl Autoconf core has no good way of enabling compiler warnings.
+dnl This is a cut-down version of the elaborate thing in the extras
+dnl archive, which we do not need nearly all of.
+dnl
+dnl Partly based on:
+dnl https://www.gnu.org/software/autoconf-archive/ax_compiler_flags_cflags.html
+
+AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_IF
+
+AC_DEFUN([zw_SIMPLE_ENABLE_WARNINGS],
+[
+AC_ARG_ENABLE(
+   [werror],
+   AS_HELP_STRING(
+        [--disable-werror],
+        [do not treat all warnings as errors]
+    ),
+    [case "${enableval}" in
+        yes) warnings_are_errors=true ;;
+         no) warnings_are_errors=false ;;
+          *) AC_MSG_ERROR([bad value ${enableval} for --enable-werror]) ;;
+     esac],
+     [warnings_are_errors=true]
+)
+
+    # Always pass -Werror=unknown-warning-option to get Clang to fail
+    # on bad flags, otherwise they are always appended to the
+    # warn_cflags variable, and Clang warns on them for every
+    # compilation unit.  If this is passed to GCC, it will explode, so
+    # the flag must be enabled conditionally.
+    AX_CHECK_COMPILE_FLAG([-Werror=unknown-warning-option],[
+        ax_compiler_flags_test="-Werror=unknown-warning-option"
+    ],[
+        ax_compiler_flags_test=""
+    ])
+
+    # Don't enable -pedantic if we don't have C11, or we may get junk
+    # warnings about static_assert.
+    ax_candidate_warnings="dnl
+        -Wall dnl
+        -Wextra dnl
+        -Walloc-zero dnl
+        -Walloca dnl
+        -Wbad-function-cast dnl
+        -Wcast-align dnl
+        -Wcast-qual dnl
+        -Wconversion dnl
+        -Wformat=2 dnl
+        -Wformat-overflow=2 dnl
+        -Wformat-signedness dnl
+        -Wformat-truncation=1 dnl
+        -Wlogical-op dnl
+        -Wmissing-declarations dnl
+        -Wmissing-prototypes dnl
+        -Wnested-externs dnl
+        -Wnull-dereference dnl
+        -Wold-style-definition dnl
+        -Wpointer-arith dnl
+        -Wrestrict dnl
+        -Wshadow dnl
+        -Wstrict-overflow=2 dnl
+        -Wstrict-prototypes dnl
+        -Wundef dnl
+        -Wvla dnl
+        -Wwrite-strings dnl
+    "
+    if test x$ac_prog_cc_stdc = xc11; then
+        ax_candidate_warnings="$ax_candidate_warnings -Wpedantic"
+    fi
+    if test x$warnings_are_errors = xtrue; then
+        ax_candidate_warnings="$ax_candidate_warnings -Werror"
+    fi
+
+    # If we are building for OSX, turn -Wdeprecated-declarations off.
+    # Apple is a little too trigger-happy with deprecations.
+    case "$host_os" in
+      (*darwin*)
+        ax_candidate_warnings="$ax_candidate_warnings -Wno-deprecated-declarations"
+      ;;
+    esac
+
+    AX_APPEND_COMPILE_FLAGS(
+        [$ax_candidate_warnings], [WARN_CFLAGS],
+        [$ax_compiler_flags_test])
+
+    AC_SUBST(WARN_CFLAGS)
+
+   if test $cross_compiling = yes; then
+       # Repeat the above logic for the build compiler.
+
+       save_cross_compiling=$cross_compiling
+       save_ac_tool_prefix=$ac_tool_prefix
+       save_CC="$CC"
+       save_CFLAGS="$CFLAGS"
+       save_CPPFLAGS="$CPPFLAGS"
+       save_LDFLAGS="$LDFLAGS"
+
+       cross_compiling=no
+       ac_tool_prefix=
+       CC="$CC_FOR_BUILD"
+       CFLAGS="$CFLAGS_FOR_BUILD"
+       CPPFLAGS="$CPPFLAGS_FOR_BUILD"
+       LDFLAGS="$LDFLAGS_FOR_BUILD"
+
+       pushdef([_AC_LANG_ABBREV],[build_c])
+
+       AX_CHECK_COMPILE_FLAG([-Werror=unknown-warning-option],[
+           ax_compiler_flags_test="-Werror=unknown-warning-option"
+       ],[
+           ax_compiler_flags_test=""
+       ])
+       AX_APPEND_COMPILE_FLAGS(
+           [$ax_candidate_warnings], [WARN_CFLAGS_FOR_BUILD],
+           [$ax_compiler_flags_test])
+
+       popdef([_AC_LANG_ABBREV])
+
+       AC_SUBST(WARN_CFLAGS_FOR_BUILD)
+
+       cross_compiling=$save_cross_compiling
+       ac_tool_prefix=$save_ac_tool_prefix
+       CC="$save_CC"
+       CFLAGS="$save_CFLAGS"
+       CPPFLAGS="$save_CPPFLAGS"
+       LDFLAGS="$save_LDFLAGS"
+    fi # cross_compiling
+])

data/ext/libxcrypt/build-aux/m4/zw_static_assert.m4

@@ -0,0 +1,68 @@
+dnl Written by Zack Weinberg <zackw at panix.com> in 2017.
+dnl To the extent possible under law, Zack Weinberg has waived all
+dnl copyright and related or neighboring rights to this work.
+dnl
+dnl See https://creativecommons.org/publicdomain/zero/1.0/ for further
+dnl details.
+dnl
+dnl Check for static_assert in <assert.h>; failing that, check for intrinsic
+dnl support for C11 _Static_assert.
+dnl assert.h itself is in C89 and does not need to be probed for;
+dnl moreover, AC_PROG_CC's check for C11 includes _Static_assert (but not
+dnl static_assert).
+dnl Some logic borrowed from gnulib's assert_h.m4.
+dnl 2*2 != 7 is tested in honor of Stanisław Lem.
+AC_DEFUN([zw_C_STATIC_ASSERT],
+  [AC_REQUIRE([AC_PROG_CC])
+   AC_CACHE_CHECK([for static_assert in assert.h],
+     [zw_cv_c_assert_h_static_assert],
+     [AC_COMPILE_IFELSE(
+        [AC_LANG_PROGRAM([[
+           #undef NDEBUG
+           #include <assert.h>
+           static_assert(2 + 2 == 4, "arithmetic does not work");
+        ]], [[
+           static_assert(sizeof (char) == 1, "sizeof does not work");
+        ]])],
+        [static_assert_true=yes],
+        [static_assert_true=no])
+      AC_COMPILE_IFELSE(
+        [AC_LANG_PROGRAM([[
+           #undef NDEBUG
+           #include <assert.h>
+           static_assert(2 * 2 == 7, "this assertion should fail");
+        ]])],
+        [static_assert_false=no],
+        [static_assert_false=yes])
+      AS_IF([test $static_assert_false$static_assert_true = yesyes],
+        [zw_cv_c_assert_h_static_assert=yes],
+        [zw_cv_c_assert_h_static_assert=no])])
+   AS_IF([test $zw_cv_c_assert_h_static_assert = yes],
+     [AC_DEFINE([HAVE_STATIC_ASSERT_IN_ASSERT_H], 1,
+        [Define if <assert.h> defines static_assert.])],
+     [AC_CACHE_CHECK([for _Static_assert],
+        [zw_cv_c__Static_assert],
+        [AS_IF([test x$ac_prog_cc_stdc = xc11],
+           [zw_cv_c__Static_assert=yes],
+           [AC_COMPILE_IFELSE(
+              [AC_LANG_PROGRAM([[
+                 _Static_assert(2 + 2 == 4, "arithmetic does not work");
+              ]], [[
+                 _Static_assert(sizeof (char) == 1, "sizeof does not work");
+              ]])],
+              [_Static_assert_true=yes],
+              [_Static_assert_true=no])
+            AC_COMPILE_IFELSE(
+              [AC_LANG_PROGRAM([[
+                 _Static_assert(2 * 2 == 7, "this assertion should fail");
+              ]])],
+              [_Static_assert_false=no],
+              [_Static_assert_false=yes])
+            AS_IF([test $static_assert_false$static_assert_true = yesyes],
+              [zw_cv_c__Static_assert=yes],
+              [zw_cv_c__Static_assert=no])])])
+      AS_IF([test $zw_cv_c__Static_assert = yes],
+        [AC_DEFINE([HAVE__STATIC_ASSERT], 1,
+           [Define if the compiler supports the _Static_assert intrinsic.])])
+   ])
+])