Import the kyua testing framework for infrastructure softwarevendor/kyua/0.13-a685f91vendor/kyua

Imported at 0.13 plus assumulated changes to git hash a685f91.

Obtained from:	https://github.com/jmmv/kyua
Sponsored by:	DARPA

10 files changed, 2031 insertions, 0 deletions

diff --git a/m4/ax_cxx_compile_stdcxx.m4 b/m4/ax_cxx_compile_stdcxx.m4
new file mode 100644
index 000000000000..43087b2e6889
--- /dev/null
+++ b/m4/ax_cxx_compile_stdcxx.m4
@@ -0,0 +1,951 @@
+# ===========================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the specified
+#   version of the C++ standard.  If necessary, add switches to CXX and
+#   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
+#   or '14' (for the C++14 standard).
+#
+#   The second argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for an extended mode.
+#
+#   The third argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline support for the specified C++ standard is
+#   required and that the macro should error out if no mode with that
+#   support is found.  If specified 'optional', then configuration proceeds
+#   regardless, after defining HAVE_CXX${VERSION} if and only if a
+#   supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#   Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com>
+#   Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.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 11
+
+dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
+dnl  (serial version number 13).
+
+AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
+  m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
+        [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
+        [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
+        [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$2], [], [],
+        [$2], [ext], [],
+        [$2], [noext], [],
+        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
+        [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
+  AC_LANG_PUSH([C++])dnl
+  ac_success=no
+
+  m4_if([$2], [noext], [], [dnl
+  if test x$ac_success = xno; then
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      switch="-std=gnu++${alternative}"
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                     $cachevar,
+        [ac_save_CXX="$CXX"
+         CXX="$CXX $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXX="$ac_save_CXX"])
+      if eval test x\$$cachevar = xyes; then
+        CXX="$CXX $switch"
+        if test -n "$CXXCPP" ; then
+          CXXCPP="$CXXCPP $switch"
+        fi
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+
+  m4_if([$2], [ext], [], [dnl
+  if test x$ac_success = xno; then
+    dnl HP's aCC needs +std=c++11 according to:
+    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
+    dnl Cray's crayCC needs "-h std=c++11"
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
+        cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+        AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                       $cachevar,
+          [ac_save_CXX="$CXX"
+           CXX="$CXX $switch"
+           AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+            [eval $cachevar=yes],
+            [eval $cachevar=no])
+           CXX="$ac_save_CXX"])
+        if eval test x\$$cachevar = xyes; then
+          CXX="$CXX $switch"
+          if test -n "$CXXCPP" ; then
+            CXXCPP="$CXXCPP $switch"
+          fi
+          ac_success=yes
+          break
+        fi
+      done
+      if test x$ac_success = xyes; then
+        break
+      fi
+    done
+  fi])
+  AC_LANG_POP([C++])
+  if test x$ax_cxx_compile_cxx$1_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
+    fi
+  fi
+  if test x$ac_success = xno; then
+    HAVE_CXX$1=0
+    AC_MSG_NOTICE([No compiler with C++$1 support was found])
+  else
+    HAVE_CXX$1=1
+    AC_DEFINE(HAVE_CXX$1,1,
+              [define if the compiler supports basic C++$1 syntax])
+  fi
+  AC_SUBST(HAVE_CXX$1)
+])
+
+
+dnl  Test body for checking C++11 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+)
+
+
+dnl  Test body for checking C++14 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+)
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
+)
+
+dnl  Tests for new features in C++11
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual ~Base() {}
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual ~Derived() override {}
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = [](){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = [](int i, int j){ return i + j; }(1, 2);
+      auto b = []() -> int { return '0'; }();
+      auto c = [=](){ return a + b; }();
+      auto d = [&](){ return c; }();
+      auto e = [a, &b](int x) mutable {
+        const auto identity = [](int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = [](){ return 0; };
+      const auto unary = [](int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = [](nullary_t f){ return f(); };
+      const auto higher2nd = [unary](nullary_t f1){
+        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+]])
+
+
+dnl  Tests for new features in C++14
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+  namespace test_polymorphic_lambdas
+  {
+
+    int
+    test()
+    {
+      const auto lambda = [](auto&&... args){
+        const auto istiny = [](auto x){
+          return (sizeof(x) == 1UL) ? 1 : 0;
+        };
+        const int aretiny[] = { istiny(args)... };
+        return aretiny[0];
+      };
+      return lambda(1, 1L, 1.0f, '1');
+    }
+
+  }
+
+  namespace test_binary_literals
+  {
+
+    constexpr auto ivii = 0b0000000000101010;
+    static_assert(ivii == 42, "wrong value");
+
+  }
+
+  namespace test_generalized_constexpr
+  {
+
+    template < typename CharT >
+    constexpr unsigned long
+    strlen_c(const CharT *const s) noexcept
+    {
+      auto length = 0UL;
+      for (auto p = s; *p; ++p)
+        ++length;
+      return length;
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("x") == 1UL, "");
+    static_assert(strlen_c("test") == 4UL, "");
+    static_assert(strlen_c("another\0test") == 7UL, "");
+
+  }
+
+  namespace test_lambda_init_capture
+  {
+
+    int
+    test()
+    {
+      auto x = 0;
+      const auto lambda1 = [a = x](int b){ return a + b; };
+      const auto lambda2 = [a = lambda1(x)](){ return a; };
+      return lambda2();
+    }
+
+  }
+
+  namespace test_digit_separators
+  {
+
+    constexpr auto ten_million = 100'000'000;
+    static_assert(ten_million == 100000000, "");
+
+  }
+
+  namespace test_return_type_deduction
+  {
+
+    auto f(int& x) { return x; }
+    decltype(auto) g(int& x) { return x; }
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static constexpr auto value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static constexpr auto value = true;
+    };
+
+    int
+    test()
+    {
+      auto x = 0;
+      static_assert(is_same<int, decltype(f(x))>::value, "");
+      static_assert(is_same<int&, decltype(g(x))>::value, "");
+      return x;
+    }
+
+  }
+
+}  // namespace cxx14
+
+#endif  // __cplusplus >= 201402L
+
+]])
+
+
+dnl  Tests for new features in C++17
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
+
+// If the compiler admits that it is not ready for C++17, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201703L
+
+#error "This is not a C++17 compiler"
+
+#else
+
+#include <initializer_list>
+#include <utility>
+#include <type_traits>
+
+namespace cxx17
+{
+
+  namespace test_constexpr_lambdas
+  {
+
+    constexpr int foo = [](){return 42;}();
+
+  }
+
+  namespace test::nested_namespace::definitions
+  {
+
+  }
+
+  namespace test_fold_expression
+  {
+
+    template<typename... Args>
+    int multiply(Args... args)
+    {
+      return (args * ... * 1);
+    }
+
+    template<typename... Args>
+    bool all(Args... args)
+    {
+      return (args && ...);
+    }
+
+  }
+
+  namespace test_extended_static_assert
+  {
+
+    static_assert (true);
+
+  }
+
+  namespace test_auto_brace_init_list
+  {
+
+    auto foo = {5};
+    auto bar {5};
+
+    static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
+    static_assert(std::is_same<int, decltype(bar)>::value);
+  }
+
+  namespace test_typename_in_template_template_parameter
+  {
+
+    template<template<typename> typename X> struct D;
+
+  }
+
+  namespace test_fallthrough_nodiscard_maybe_unused_attributes
+  {
+
+    int f1()
+    {
+      return 42;
+    }
+
+    [[nodiscard]] int f2()
+    {
+      [[maybe_unused]] auto unused = f1();
+
+      switch (f1())
+      {
+      case 17:
+        f1();
+        [[fallthrough]];
+      case 42:
+        f1();
+      }
+      return f1();
+    }
+
+  }
+
+  namespace test_extended_aggregate_initialization
+  {
+
+    struct base1
+    {
+      int b1, b2 = 42;
+    };
+
+    struct base2
+    {
+      base2() {
+        b3 = 42;
+      }
+      int b3;
+    };
+
+    struct derived : base1, base2
+    {
+        int d;
+    };
+
+    derived d1 {{1, 2}, {}, 4};  // full initialization
+    derived d2 {{}, {}, 4};      // value-initialized bases
+
+  }
+
+  namespace test_general_range_based_for_loop
+  {
+
+    struct iter
+    {
+      int i;
+
+      int& operator* ()
+      {
+        return i;
+      }
+
+      const int& operator* () const
+      {
+        return i;
+      }
+
+      iter& operator++()
+      {
+        ++i;
+        return *this;
+      }
+    };
+
+    struct sentinel
+    {
+      int i;
+    };
+
+    bool operator== (const iter& i, const sentinel& s)
+    {
+      return i.i == s.i;
+    }
+
+    bool operator!= (const iter& i, const sentinel& s)
+    {
+      return !(i == s);
+    }
+
+    struct range
+    {
+      iter begin() const
+      {
+        return {0};
+      }
+
+      sentinel end() const
+      {
+        return {5};
+      }
+    };
+
+    void f()
+    {
+      range r {};
+
+      for (auto i : r)
+      {
+        [[maybe_unused]] auto v = i;
+      }
+    }
+
+  }
+
+  namespace test_lambda_capture_asterisk_this_by_value
+  {
+
+    struct t
+    {
+      int i;
+      int foo()
+      {
+        return [*this]()
+        {
+          return i;
+        }();
+      }
+    };
+
+  }
+
+  namespace test_enum_class_construction
+  {
+
+    enum class byte : unsigned char
+    {};
+
+    byte foo {42};
+
+  }
+
+  namespace test_constexpr_if
+  {
+
+    template <bool cond>
+    int f ()
+    {
+      if constexpr(cond)
+      {
+        return 13;
+      }
+      else
+      {
+        return 42;
+      }
+    }
+
+  }
+
+  namespace test_selection_statement_with_initializer
+  {
+
+    int f()
+    {
+      return 13;
+    }
+
+    int f2()
+    {
+      if (auto i = f(); i > 0)
+      {
+        return 3;
+      }
+
+      switch (auto i = f(); i + 4)
+      {
+      case 17:
+        return 2;
+
+      default:
+        return 1;
+      }
+    }
+
+  }
+
+  namespace test_template_argument_deduction_for_class_templates
+  {
+
+    template <typename T1, typename T2>
+    struct pair
+    {
+      pair (T1 p1, T2 p2)
+        : m1 {p1},
+          m2 {p2}
+      {}
+
+      T1 m1;
+      T2 m2;
+    };
+
+    void f()
+    {
+      [[maybe_unused]] auto p = pair{13, 42u};
+    }
+
+  }
+
+  namespace test_non_type_auto_template_parameters
+  {
+
+    template <auto n>
+    struct B
+    {};
+
+    B<5> b1;
+    B<'a'> b2;
+
+  }
+
+  namespace test_structured_bindings
+  {
+
+    int arr[2] = { 1, 2 };
+    std::pair<int, int> pr = { 1, 2 };
+
+    auto f1() -> int(&)[2]
+    {
+      return arr;
+    }
+
+    auto f2() -> std::pair<int, int>&
+    {
+      return pr;
+    }
+
+    struct S
+    {
+      int x1 : 2;
+      volatile double y1;
+    };
+
+    S f3()
+    {
+      return {};
+    }
+
+    auto [ x1, y1 ] = f1();
+    auto& [ xr1, yr1 ] = f1();
+    auto [ x2, y2 ] = f2();
+    auto& [ xr2, yr2 ] = f2();
+    const auto [ x3, y3 ] = f3();
+
+  }
+
+  namespace test_exception_spec_type_system
+  {
+
+    struct Good {};
+    struct Bad {};
+
+    void g1() noexcept;
+    void g2();
+
+    template<typename T>
+    Bad
+    f(T*, T*);
+
+    template<typename T1, typename T2>
+    Good
+    f(T1*, T2*);
+
+    static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
+
+  }
+
+  namespace test_inline_variables
+  {
+
+    template<class T> void f(T)
+    {}
+
+    template<class T> inline T g(T)
+    {
+      return T{};
+    }
+
+    template<> inline void f<>(int)
+    {}
+
+    template<> int g<>(int)
+    {
+      return 5;
+    }
+
+  }
+
+}  // namespace cxx17
+
+#endif  // __cplusplus < 201703L
+
+]])
diff --git a/m4/compiler-features.m4 b/m4/compiler-features.m4
new file mode 100644
index 000000000000..840f292383d5
--- /dev/null
+++ b/m4/compiler-features.m4
@@ -0,0 +1,122 @@
+dnl Copyright 2010 The Kyua Authors.
+dnl All rights reserved.
+dnl
+dnl Redistribution and use in source and binary forms, with or without
+dnl modification, are permitted provided that the following conditions are
+dnl met:
+dnl
+dnl * Redistributions of source code must retain the above copyright
+dnl   notice, this list of conditions and the following disclaimer.
+dnl * Redistributions in binary form must reproduce the above copyright
+dnl   notice, this list of conditions and the following disclaimer in the
+dnl   documentation and/or other materials provided with the distribution.
+dnl * Neither the name of Google Inc. nor the names of its contributors
+dnl   may be used to endorse or promote products derived from this software
+dnl   without specific prior written permission.
+dnl
+dnl THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+dnl "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+dnl LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+dnl A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+dnl OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+dnl LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+dnl DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+dnl THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+dnl (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+dnl OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+dnl
+dnl KYUA_ATTRIBUTE_NORETURN
+dnl
+dnl Checks if the current compiler has a way to mark functions that do not
+dnl return and defines ATTRIBUTE_NORETURN to the appropriate string.
+dnl
+AC_DEFUN([KYUA_ATTRIBUTE_NORETURN], [
+    dnl This check is overly simple and should be fixed.  For example,
+    dnl Sun's cc does support the noreturn attribute but CC (the C++
+    dnl compiler) does not.  And in that case, CC just raises a warning
+    dnl during compilation, not an error.
+    AC_CACHE_CHECK(
+        [whether __attribute__((noreturn)) is supported],
+        [kyua_cv_attribute_noreturn], [
+        AC_RUN_IFELSE([AC_LANG_PROGRAM([], [
+#if ((__GNUC__ == 2 && __GNUC_MINOR__ >= 5) || __GNUC__ > 2)
+    return 0;
+#else
+    return 1;
+#endif
+            ])],
+            [kyua_cv_attribute_noreturn=yes],
+            [kyua_cv_attribute_noreturn=no])
+    ])
+    if test "${kyua_cv_attribute_noreturn}" = yes; then
+        attribute_value="__attribute__((noreturn))"
+    else
+        attribute_value=""
+    fi
+    AC_SUBST([ATTRIBUTE_NORETURN], [${attribute_value}])
+])
+
+
+dnl
+dnl KYUA_ATTRIBUTE_PURE
+dnl
+dnl Checks if the current compiler has a way to mark functions as pure.
+dnl
+AC_DEFUN([KYUA_ATTRIBUTE_PURE], [
+    AC_CACHE_CHECK(
+        [whether __attribute__((__pure__)) is supported],
+        [kyua_cv_attribute_pure], [
+        AC_COMPILE_IFELSE(
+            [AC_LANG_PROGRAM([
+static int function(int, int) __attribute__((__pure__));
+
+static int
+function(int a, int b)
+{
+    return a + b;
+}], [
+    return function(3, 4);
+])],
+            [kyua_cv_attribute_pure=yes],
+            [kyua_cv_attribute_pure=no])
+    ])
+    if test "${kyua_cv_attribute_pure}" = yes; then
+        attribute_value="__attribute__((__pure__))"
+    else
+        attribute_value=""
+    fi
+    AC_SUBST([ATTRIBUTE_PURE], [${attribute_value}])
+])
+
+
+dnl
+dnl KYUA_ATTRIBUTE_UNUSED
+dnl
+dnl Checks if the current compiler has a way to mark parameters as unused
+dnl so that the -Wunused-parameter warning can be avoided.
+dnl
+AC_DEFUN([KYUA_ATTRIBUTE_UNUSED], [
+    AC_CACHE_CHECK(
+        [whether __attribute__((__unused__)) is supported],
+        [kyua_cv_attribute_unused], [
+        AC_COMPILE_IFELSE(
+            [AC_LANG_PROGRAM([
+static void
+function(int a __attribute__((__unused__)))
+{
+}], [
+    function(3);
+    return 0;
+])],
+            [kyua_cv_attribute_unused=yes],
+            [kyua_cv_attribute_unused=no])
+    ])
+    if test "${kyua_cv_attribute_unused}" = yes; then
+        attribute_value="__attribute__((__unused__))"
+    else
+        attribute_value=""
+    fi
+    AC_SUBST([ATTRIBUTE_UNUSED], [${attribute_value}])
+])
diff --git a/m4/compiler-flags.m4 b/m4/compiler-flags.m4
new file mode 100644
index 000000000000..f8dd555118d4
--- /dev/null
+++ b/m4/compiler-flags.m4
@@ -0,0 +1,169 @@
+dnl Copyright 2010 The Kyua Authors.
+dnl All rights reserved.
+dnl
+dnl Redistribution and use in source and binary forms, with or without
+dnl modification, are permitted provided that the following conditions are
+dnl met:
+dnl
+dnl * Redistributions of source code must retain the above copyright
+dnl   notice, this list of conditions and the following disclaimer.
+dnl * Redistributions in binary form must reproduce the above copyright
+dnl   notice, this list of conditions and the following disclaimer in the
+dnl   documentation and/or other materials provided with the distribution.
+dnl * Neither the name of Google Inc. nor the names of its contributors
+dnl   may be used to endorse or promote products derived from this software
+dnl   without specific prior written permission.
+dnl
+dnl THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+dnl "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+dnl LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+dnl A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+dnl OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+dnl LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+dnl DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+dnl THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+dnl (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+dnl OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+dnl \file compiler-flags.m4
+dnl
+dnl Macros to check for the existence of compiler flags.  The macros in this
+dnl file support both C and C++.
+dnl
+dnl Be aware that, in order to detect a flag accurately, we may need to enable
+dnl strict warning checking in the compiler (i.e. enable -Werror).  Some
+dnl compilers, e.g. Clang, report unknown -W flags as warnings unless -Werror is
+dnl selected.  This fact would confuse the flag checks below because we would
+dnl conclude that a flag is valid while in reality it is not.  To resolve this,
+dnl the macros below will pass -Werror to the compiler along with any other flag
+dnl being checked.
+
+
+dnl Checks for a compiler flag and sets a result variable.
+dnl
+dnl This is an auxiliary macro for the implementation of _KYUA_FLAG.
+dnl
+dnl \param 1 The shell variable containing the compiler name.  Used for
+dnl     reporting purposes only.  C or CXX.
+dnl \param 2 The shell variable containing the flags for the compiler.
+dnl     CFLAGS or CXXFLAGS.
+dnl \param 3 The name of the compiler flag to check for.
+dnl \param 4 The shell variable to set with the result of the test.  Will
+dnl     be set to 'yes' if the flag is valid, 'no' otherwise.
+dnl \param 5 Additional, optional flags to pass to the C compiler while
+dnl     looking for the flag in $3.  We use this here to pass -Werror to the
+dnl     flag checks (unless we are checking for -Werror already).
+AC_DEFUN([_KYUA_FLAG_AUX], [
+    if test x"${$4-unset}" = xunset; then
+        AC_MSG_CHECKING(whether ${$1} supports $3)
+        saved_flags="${$2}"
+        $4=no
+        $2="${$2} $5 $3"
+        # The inclusion of a header file in the test program below is needed
+        # because some compiler flags that we test for may actually not be
+        # compatible with other flags, and such compatibility checks are
+        # performed within the system header files.
+        #
+        # As an example, if we are testing for -D_FORTIFY_SOURCE=2 and the
+        # compilation is being done with -O2, Linux's /usr/include/features.h
+        # will abort the compilation of our code later on.  By including a
+        # generic header file here that pulls in features.h we ensure that
+        # this test is accurate for the build stage.
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <stdio.h>], [return 0;])],
+                       AC_MSG_RESULT(yes)
+                       $4=yes,
+                       AC_MSG_RESULT(no))
+        $2="${saved_flags}"
+    fi
+])
+
+
+dnl Checks for a compiler flag and appends it to a result variable.
+dnl
+dnl \param 1 The shell variable containing the compiler name.  Used for
+dnl     reporting purposes only.  CC or CXX.
+dnl \param 2 The shell variable containing the flags for the compiler.
+dnl     CFLAGS or CXXFLAGS.
+dnl \param 3 The name of the compiler flag to check for.
+dnl \param 4 The shell variable to which to append $3 if the flag is valid.
+AC_DEFUN([_KYUA_FLAG], [
+    _KYUA_FLAG_AUX([$1], [$2], [-Werror], [kyua_$1_has_werror])
+    if test "$3" = "-Werror"; then
+        found=${kyua_$1_has_werror}
+    else
+        found=unset
+        if test ${kyua_$1_has_werror} = yes; then
+            _KYUA_FLAG_AUX([$1], [$2], [$3], [found], [-Werror])
+        else
+            _KYUA_FLAG_AUX([$1], [$2], [$3], [found], [])
+        fi
+    fi
+    if test ${found} = yes; then
+        $4="${$4} $3"
+    fi
+])
+
+
+dnl Checks for a C compiler flag and appends it to a variable.
+dnl
+dnl \pre The current language is C.
+dnl
+dnl \param 1 The name of the compiler flag to check for.
+dnl \param 2 The shell variable to which to append $1 if the flag is valid.
+AC_DEFUN([KYUA_CC_FLAG], [
+    AC_LANG_ASSERT([C])
+    _KYUA_FLAG([CC], [CFLAGS], [$1], [$2])
+])
+
+
+dnl Checks for a C++ compiler flag and appends it to a variable.
+dnl
+dnl \pre The current language is C++.
+dnl
+dnl \param 1 The name of the compiler flag to check for.
+dnl \param 2 The shell variable to which to append $1 if the flag is valid.
+AC_DEFUN([KYUA_CXX_FLAG], [
+    AC_LANG_ASSERT([C++])
+    _KYUA_FLAG([CXX], [CXXFLAGS], [$1], [$2])
+])
+
+
+dnl Checks for a set of C compiler flags and appends them to CFLAGS.
+dnl
+dnl The checks are performed independently and only when all the checks are
+dnl done, the output variable is modified.
+dnl
+dnl \param 1 Whitespace-separated list of C flags to check.
+AC_DEFUN([KYUA_CC_FLAGS], [
+    AC_LANG_PUSH([C])
+    valid_cflags=
+    for f in $1; do
+        KYUA_CC_FLAG(${f}, valid_cflags)
+    done
+    if test -n "${valid_cflags}"; then
+        CFLAGS="${CFLAGS} ${valid_cflags}"
+    fi
+    AC_LANG_POP([C])
+])
+
+
+dnl Checks for a set of C++ compiler flags and appends them to CXXFLAGS.
+dnl
+dnl The checks are performed independently and only when all the checks are
+dnl done, the output variable is modified.
+dnl
+dnl \pre The current language is C++.
+dnl
+dnl \param 1 Whitespace-separated list of C flags to check.
+AC_DEFUN([KYUA_CXX_FLAGS], [
+    AC_LANG_PUSH([C++])
+    valid_cxxflags=
+    for f in $1; do
+        KYUA_CXX_FLAG(${f}, valid_cxxflags)
+    done
+    if test -n "${valid_cxxflags}"; then
+        CXXFLAGS="${CXXFLAGS} ${valid_cxxflags}"
+    fi
+    AC_LANG_POP([C++])
+])
diff --git a/m4/developer-mode.m4 b/m4/developer-mode.m4
new file mode 100644
index 000000000000..ad946056f63c
--- /dev/null
+++ b/m4/developer-mode.m4
@@ -0,0 +1,112 @@
+dnl Copyright 2010 The Kyua Authors.
+dnl All rights reserved.
+dnl
+dnl Redistribution and use in source and binary forms, with or without
+dnl modification, are permitted provided that the following conditions are
+dnl met:
+dnl
+dnl * Redistributions of source code must retain the above copyright
+dnl   notice, this list of conditions and the following disclaimer.
+dnl * Redistributions in binary form must reproduce the above copyright
+dnl   notice, this list of conditions and the following disclaimer in the
+dnl   documentation and/or other materials provided with the distribution.
+dnl * Neither the name of Google Inc. nor the names of its contributors
+dnl   may be used to endorse or promote products derived from this software
+dnl   without specific prior written permission.
+dnl
+dnl THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+dnl "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+dnl LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+dnl A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+dnl OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+dnl LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+dnl DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+dnl THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+dnl (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+dnl OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+dnl \file developer-mode.m4
+dnl
+dnl "Developer mode" is a mode in which the build system reports any
+dnl build-time warnings as fatal errors.  This helps in minimizing the
+dnl amount of trivial coding problems introduced in the code.
+dnl Unfortunately, this is not bullet-proof due to the wide variety of
+dnl compilers available and their different warning diagnostics.
+dnl
+dnl When developer mode support is added to a package, the compilation will
+dnl gain a bunch of extra warning diagnostics.  These will NOT be enforced
+dnl unless developer mode is enabled.
+dnl
+dnl Developer mode is enabled when the user requests it through the
+dnl configure command line, or when building from the repository.  The
+dnl latter is to minimize the risk of committing new code with warnings
+dnl into the tree.
+
+
+dnl Adds "developer mode" support to the package.
+dnl
+dnl This macro performs the actual definition of the --enable-developer
+dnl flag and implements all of its logic.  See the file-level comment for
+dnl details as to what this implies.
+AC_DEFUN([KYUA_DEVELOPER_MODE], [
+    m4_foreach([language], [$1], [m4_set_add([languages], language)])
+
+    AC_ARG_ENABLE(
+        [developer],
+        AS_HELP_STRING([--enable-developer], [enable developer features]),,
+        [if test -d "${srcdir}/.git"; then
+             AC_MSG_NOTICE([building from HEAD; developer mode autoenabled])
+             enable_developer=yes
+         else
+             enable_developer=no
+         fi])
+
+    #
+    # The following warning flags should also be enabled but cannot be.
+    # Reasons given below.
+    #
+    # -Wold-style-cast: Raises errors when using TIOCGWINSZ, at least under
+    #                   Mac OS X.  This is due to the way _IOR is defined.
+    #
+
+    try_c_cxx_flags="-D_FORTIFY_SOURCE=2 \
+                     -Wall \
+                     -Wcast-qual \
+                     -Wextra \
+                     -Wpointer-arith \
+                     -Wredundant-decls \
+                     -Wreturn-type \
+                     -Wshadow \
+                     -Wsign-compare \
+                     -Wswitch \
+                     -Wwrite-strings"
+
+    try_c_flags="-Wmissing-prototypes \
+                 -Wno-traditional \
+                 -Wstrict-prototypes"
+
+    try_cxx_flags="-Wabi \
+                   -Wctor-dtor-privacy \
+                   -Wno-deprecated \
+                   -Wno-non-template-friend \
+                   -Wno-pmf-conversions \
+                   -Wnon-virtual-dtor \
+                   -Woverloaded-virtual \
+                   -Wreorder \
+                   -Wsign-promo \
+                   -Wsynth"
+
+    if test ${enable_developer} = yes; then
+        try_werror=yes
+        try_c_cxx_flags="${try_c_cxx_flags} -g -Werror"
+    else
+        try_werror=no
+        try_c_cxx_flags="${try_c_cxx_flags} -DNDEBUG"
+    fi
+
+    m4_set_contains([languages], [C],
+                    [KYUA_CC_FLAGS(${try_c_cxx_flags} ${try_c_flags})])
+    m4_set_contains([languages], [C++],
+                    [KYUA_CXX_FLAGS(${try_c_cxx_flags} ${try_cxx_flags})])
+])
diff --git a/m4/doxygen.m4 b/m4/doxygen.m4
new file mode 100644
index 000000000000..24fd2a408f88
--- /dev/null
+++ b/m4/doxygen.m4
@@ -0,0 +1,62 @@
+dnl Copyright 2010 The Kyua Authors.
+dnl All rights reserved.
+dnl
+dnl Redistribution and use in source and binary forms, with or without
+dnl modification, are permitted provided that the following conditions are
+dnl met:
+dnl
+dnl * Redistributions of source code must retain the above copyright
+dnl   notice, this list of conditions and the following disclaimer.
+dnl * Redistributions in binary form must reproduce the above copyright
+dnl   notice, this list of conditions and the following disclaimer in the
+dnl   documentation and/or other materials provided with the distribution.
+dnl * Neither the name of Google Inc. nor the names of its contributors
+dnl   may be used to endorse or promote products derived from this software
+dnl   without specific prior written permission.
+dnl
+dnl THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+dnl "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+dnl LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+dnl A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+dnl OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+dnl LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+dnl DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+dnl THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+dnl (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+dnl OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+dnl
+dnl KYUA_DOXYGEN
+dnl
+dnl Adds a --with-doxygen flag to the configure script and, when Doxygen support
+dnl is requested by the user, sets DOXYGEN to the path of the Doxygen binary and
+dnl enables the WITH_DOXYGEN Automake conditional.
+dnl
+AC_DEFUN([KYUA_DOXYGEN], [
+    AC_ARG_WITH([doxygen],
+                AS_HELP_STRING([--with-doxygen],
+                               [build documentation for internal APIs]),
+                [],
+                [with_doxygen=auto])
+
+    if test "${with_doxygen}" = yes; then
+        AC_PATH_PROG([DOXYGEN], [doxygen], [])
+        if test -z "${DOXYGEN}"; then
+            AC_MSG_ERROR([Doxygen explicitly requested but not found])
+        fi
+    elif test "${with_doxygen}" = auto; then
+        AC_PATH_PROG([DOXYGEN], [doxygen], [])
+    elif test "${with_doxygen}" = no; then
+        DOXYGEN=
+    else
+        AC_MSG_CHECKING([for doxygen])
+        DOXYGEN="${with_doxygen}"
+        AC_MSG_RESULT([${DOXYGEN}])
+        if test ! -x "${DOXYGEN}"; then
+            AC_MSG_ERROR([Doxygen binary ${DOXYGEN} is not executable])
+        fi
+    fi
+    AM_CONDITIONAL([WITH_DOXYGEN], [test -n "${DOXYGEN}"])
+    AC_SUBST([DOXYGEN])
+])
diff --git a/m4/fs.m4 b/m4/fs.m4
new file mode 100644
index 000000000000..7cb103eb1370
--- /dev/null
+++ b/m4/fs.m4
@@ -0,0 +1,125 @@
+dnl Copyright 2011 The Kyua Authors.
+dnl All rights reserved.
+dnl
+dnl Redistribution and use in source and binary forms, with or without
+dnl modification, are permitted provided that the following conditions are
+dnl met:
+dnl
+dnl * Redistributions of source code must retain the above copyright
+dnl   notice, this list of conditions and the following disclaimer.
+dnl * Redistributions in binary form must reproduce the above copyright
+dnl   notice, this list of conditions and the following disclaimer in the
+dnl   documentation and/or other materials provided with the distribution.
+dnl * Neither the name of Google Inc. nor the names of its contributors
+dnl   may be used to endorse or promote products derived from this software
+dnl   without specific prior written permission.
+dnl
+dnl THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+dnl "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+dnl LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+dnl A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+dnl OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+dnl LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+dnl DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+dnl THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+dnl (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+dnl OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+dnl \file m4/fs.m4
+dnl File system related checks.
+dnl
+dnl The macros in this file check for features required in the utils/fs
+dnl module.  The global KYUA_FS_MODULE macro will call all checks required
+dnl for the library.
+
+
+dnl KYUA_FS_GETCWD_DYN
+dnl
+dnl Checks whether getcwd(NULL, 0) works; i.e. if getcwd(3) can dynamically
+dnl allocate the output buffer to fit the whole current path.
+AC_DEFUN([KYUA_FS_GETCWD_DYN], [
+    AC_CACHE_CHECK(
+        [whether getcwd(NULL, 0) works],
+        [kyua_cv_getcwd_dyn], [
+        AC_RUN_IFELSE([AC_LANG_PROGRAM([#include <stdlib.h>
+#include <unistd.h>
+], [
+    char *cwd = getcwd(NULL, 0);
+    return (cwd != NULL) ? EXIT_SUCCESS : EXIT_FAILURE;
+])],
+        [kyua_cv_getcwd_dyn=yes],
+        [kyua_cv_getcwd_dyn=no])
+    ])
+    if test "${kyua_cv_getcwd_dyn}" = yes; then
+        AC_DEFINE_UNQUOTED([HAVE_GETCWD_DYN], [1],
+                           [Define to 1 if getcwd(NULL, 0) works])
+    fi
+])
+
+
+dnl KYUA_FS_LCHMOD
+dnl
+dnl Checks whether lchmod(3) exists and if it works.  Some systems, such as
+dnl Ubuntu 10.04.1 LTS, provide a lchmod(3) stub that is not implemented yet
+dnl allows programs to compile cleanly (albeit for a warning).  It would be
+dnl nice to detect if lchmod(3) works at run time to prevent side-effects of
+dnl this test but doing so means we will keep receiving a noisy compiler
+dnl warning.
+AC_DEFUN([KYUA_FS_LCHMOD], [
+    AC_CACHE_CHECK(
+        [for a working lchmod],
+        [kyua_cv_lchmod_works], [
+        AC_RUN_IFELSE([AC_LANG_PROGRAM([#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+], [
+    int fd = open("conftest.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
+    if (fd == -1) {
+        perror("creation of conftest.txt failed");
+        return EXIT_FAILURE;
+    }
+
+    return lchmod("conftest.txt", 0640) != -1 ?  EXIT_SUCCESS : EXIT_FAILURE;
+])],
+        [kyua_cv_lchmod_works=yes],
+        [kyua_cv_lchmod_works=no])
+    ])
+    rm -f conftest.txt
+    if test "${kyua_cv_lchmod_works}" = yes; then
+        AC_DEFINE_UNQUOTED([HAVE_WORKING_LCHMOD], [1],
+                           [Define to 1 if your lchmod works])
+    fi
+])
+
+
+dnl KYUA_FS_UNMOUNT
+dnl
+dnl Detect the correct method to unmount a file system.
+AC_DEFUN([KYUA_FS_UNMOUNT], [
+    AC_CHECK_FUNCS([unmount], [have_unmount2=yes], [have_unmount2=no])
+    if test "${have_unmount2}" = no; then
+        have_umount8=yes
+        AC_PATH_PROG([UMOUNT], [umount], [have_umount8=no])
+        if test "${have_umount8}" = yes; then
+            AC_DEFINE_UNQUOTED([UMOUNT], ["${UMOUNT}"],
+                               [Set to the path of umount(8)])
+        else
+            AC_MSG_ERROR([Don't know how to unmount a file system])
+        fi
+    fi
+])
+
+
+dnl KYUA_FS_MODULE
+dnl
+dnl Performs all checks needed by the utils/fs library.
+AC_DEFUN([KYUA_FS_MODULE], [
+    AC_CHECK_HEADERS([sys/mount.h sys/statvfs.h sys/vfs.h])
+    AC_CHECK_FUNCS([statfs statvfs])
+    KYUA_FS_GETCWD_DYN
+    KYUA_FS_LCHMOD
+    KYUA_FS_UNMOUNT
+])
diff --git a/m4/getopt.m4 b/m4/getopt.m4
new file mode 100644
index 000000000000..f58635330704
--- /dev/null
+++ b/m4/getopt.m4
@@ -0,0 +1,213 @@
+dnl Copyright 2010 The Kyua Authors.
+dnl All rights reserved.
+dnl
+dnl Redistribution and use in source and binary forms, with or without
+dnl modification, are permitted provided that the following conditions are
+dnl met:
+dnl
+dnl * Redistributions of source code must retain the above copyright
+dnl   notice, this list of conditions and the following disclaimer.
+dnl * Redistributions in binary form must reproduce the above copyright
+dnl   notice, this list of conditions and the following disclaimer in the
+dnl   documentation and/or other materials provided with the distribution.
+dnl * Neither the name of Google Inc. nor the names of its contributors
+dnl   may be used to endorse or promote products derived from this software
+dnl   without specific prior written permission.
+dnl
+dnl THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+dnl "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+dnl LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+dnl A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+dnl OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+dnl LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+dnl DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+dnl THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+dnl (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+dnl OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+dnl Checks if getopt(3) supports a + sign to enforce POSIX correctness.
+dnl
+dnl In the GNU implementation of getopt(3), we need to pass a + sign at
+dnl the beginning of the options string to request POSIX behavior.
+dnl
+dnl Defines HAVE_GETOPT_GNU if a + sign is supported.
+AC_DEFUN([_KYUA_GETOPT_GNU], [
+    AC_CACHE_CHECK(
+        [whether getopt allows a + sign for POSIX behavior optreset],
+        [kyua_cv_getopt_gnu], [
+        AC_RUN_IFELSE([AC_LANG_PROGRAM([#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>], [
+    int argc = 4;
+    char* argv@<:@5@:>@ = {
+        strdup("conftest"),
+        strdup("-+"),
+        strdup("-a"),
+        strdup("bar"),
+        NULL
+    };
+    int ch;
+    int seen_a = 0, seen_plus = 0;
+
+    while ((ch = getopt(argc, argv, "+a:")) != -1) {
+        switch (ch) {
+        case 'a':
+            seen_a = 1;
+            break;
+
+        case '+':
+            seen_plus = 1;
+            break;
+
+        case '?':
+        default:
+            ;
+        }
+    }
+
+    return (seen_a && !seen_plus) ? EXIT_SUCCESS : EXIT_FAILURE;
+])],
+        [kyua_cv_getopt_gnu=yes],
+        [kyua_cv_getopt_gnu=no])
+    ])
+    if test "${kyua_cv_getopt_gnu}" = yes; then
+        AC_DEFINE([HAVE_GETOPT_GNU], [1],
+                   [Define to 1 if getopt allows a + sign for POSIX behavior])
+    fi
+])
+
+dnl Checks if optreset exists to reset the processing of getopt(3) options.
+dnl
+dnl getopt(3) has an optreset global variable to reset internal state
+dnl before calling getopt(3) again.  However, optreset is not standard and
+dnl is only present in the BSD versions of getopt(3).
+dnl
+dnl Defines HAVE_GETOPT_WITH_OPTRESET if optreset exists.
+AC_DEFUN([_KYUA_GETOPT_WITH_OPTRESET], [
+    AC_CACHE_CHECK(
+        [whether getopt has optreset],
+        [kyua_cv_getopt_optreset], [
+        AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+#include <stdlib.h>
+#include <unistd.h>
+
+int
+main(void)
+{
+    optreset = 1;
+    return EXIT_SUCCESS;
+}
+])],
+        [kyua_cv_getopt_optreset=yes],
+        [kyua_cv_getopt_optreset=no])
+    ])
+    if test "${kyua_cv_getopt_optreset}" = yes; then
+        AC_DEFINE([HAVE_GETOPT_WITH_OPTRESET], [1],
+                  [Define to 1 if getopt has optreset])
+    fi
+])
+
+
+dnl Checks the value to pass to optind to reset getopt(3) processing.
+dnl
+dnl The standard value to pass to optind to reset the processing of command
+dnl lines with getopt(3) is 1.  However, the GNU extensions to getopt_long(3)
+dnl are not properly reset unless optind is set to 0, causing crashes later
+dnl on and incorrect option processing behavior.
+dnl
+dnl Sets the GETOPT_OPTIND_RESET_VALUE macro to the integer value that has to
+dnl be passed to optind to reset option processing.
+AC_DEFUN([_KYUA_GETOPT_OPTIND_RESET_VALUE], [
+    AC_CACHE_CHECK(
+        [for the optind value to reset getopt processing],
+        [kyua_cv_getopt_optind_reset_value], [
+        AC_RUN_IFELSE([AC_LANG_SOURCE([
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static void
+first_pass(void)
+{
+    int argc, ch, flag;
+    char* argv@<:@5@:>@;
+
+    argc = 4;
+    argv@<:@0@:>@ = strdup("progname");
+    argv@<:@1@:>@ = strdup("-a");
+    argv@<:@2@:>@ = strdup("foo");
+    argv@<:@3@:>@ = strdup("bar");
+    argv@<:@4@:>@ = NULL;
+
+    flag = 0;
+    while ((ch = getopt(argc, argv, "+:a")) != -1) {
+        switch (ch) {
+        case 'a':
+            flag = 1;
+            break;
+        default:
+            break;
+        }
+    }
+    if (!flag) {
+        exit(EXIT_FAILURE);
+    }
+}
+
+static void
+second_pass(void)
+{
+    int argc, ch, flag;
+    char* argv@<:@5@:>@;
+
+    argc = 4;
+    argv@<:@0@:>@ = strdup("progname");
+    argv@<:@1@:>@ = strdup("-b");
+    argv@<:@2@:>@ = strdup("foo");
+    argv@<:@3@:>@ = strdup("bar");
+    argv@<:@4@:>@ = NULL;
+
+    flag = 0;
+    while ((ch = getopt(argc, argv, "b")) != -1) {
+        switch (ch) {
+        case 'b':
+            flag = 1;
+            break;
+        default:
+            break;
+        }
+    }
+    if (!flag) {
+        exit(EXIT_FAILURE);
+    }
+}
+
+int
+main(void)
+{
+    /* We do two passes in two different functions to prevent the reuse of
+     * variables and, specially, to force the use of two different argument
+     * vectors. */
+    first_pass();
+    optind = 0;
+    second_pass();
+    return EXIT_SUCCESS;
+}
+])],
+        [kyua_cv_getopt_optind_reset_value=0],
+        [kyua_cv_getopt_optind_reset_value=1])
+    ])
+    AC_DEFINE_UNQUOTED([GETOPT_OPTIND_RESET_VALUE],
+        [${kyua_cv_getopt_optind_reset_value}],
+        [Define to the optind value to reset getopt processing])
+])
+
+
+dnl Wrapper macro to detect all getopt(3) necessary features.
+AC_DEFUN([KYUA_GETOPT], [
+    _KYUA_GETOPT_GNU
+    _KYUA_GETOPT_OPTIND_RESET_VALUE
+    _KYUA_GETOPT_WITH_OPTRESET
+])
diff --git a/m4/memory.m4 b/m4/memory.m4
new file mode 100644
index 000000000000..3d9a83a20ab5
--- /dev/null
+++ b/m4/memory.m4
@@ -0,0 +1,122 @@
+dnl Copyright 2012 The Kyua Authors.
+dnl All rights reserved.
+dnl
+dnl Redistribution and use in source and binary forms, with or without
+dnl modification, are permitted provided that the following conditions are
+dnl met:
+dnl
+dnl * Redistributions of source code must retain the above copyright
+dnl   notice, this list of conditions and the following disclaimer.
+dnl * Redistributions in binary form must reproduce the above copyright
+dnl   notice, this list of conditions and the following disclaimer in the
+dnl   documentation and/or other materials provided with the distribution.
+dnl * Neither the name of Google Inc. nor the names of its contributors
+dnl   may be used to endorse or promote products derived from this software
+dnl   without specific prior written permission.
+dnl
+dnl THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+dnl "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+dnl LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+dnl A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+dnl OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+dnl LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+dnl DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+dnl THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+dnl (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+dnl OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+dnl \file m4/memory.m4
+dnl
+dnl Macros to configure the utils::memory module.
+
+
+dnl Entry point to detect all features needed by utils::memory.
+dnl
+dnl This looks for a mechanism to check the available physical memory in the
+dnl system.
+AC_DEFUN([KYUA_MEMORY], [
+    memory_query=unknown
+    memory_mib=none
+
+    _KYUA_SYSCTLBYNAME([have_sysctlbyname=yes], [have_sysctlbyname=no])
+    if test "${have_sysctlbyname}" = yes; then
+        _KYUA_SYSCTL_MIB([hw.usermem64], [hw_usermem64],
+                         [memory_mib="hw.usermem64"], [])
+        if test "${memory_mib}" = none; then
+            _KYUA_SYSCTL_MIB([hw.usermem], [hw_usermem],
+                             [memory_mib="hw.usermem"], [])
+        fi
+        if test "${memory_mib}" != none; then
+            memory_query=sysctlbyname
+        fi
+    fi
+
+    if test "${memory_query}" = unknown; then
+        AC_MSG_WARN([Don't know how to query the amount of physical memory])
+        AC_MSG_WARN([The test case's require.memory property will not work])
+    fi
+
+    AC_DEFINE_UNQUOTED([MEMORY_QUERY_TYPE], ["${memory_query}"],
+                       [Define to the memory query type])
+    AC_DEFINE_UNQUOTED([MEMORY_QUERY_SYSCTL_MIB], ["${memory_mib}"],
+                       [Define to the name of the sysctl MIB])
+])
+
+
+dnl Detects the availability of the sysctlbyname(3) function.
+dnl
+dnl \param action_if_found Code to run if the function is found.
+dnl \param action_if_not_found Code to run if the function is not found.
+AC_DEFUN([_KYUA_SYSCTLBYNAME], [
+    AC_CHECK_HEADERS([sys/types.h sys/sysctl.h])  dnl Darwin 11.2
+    AC_CHECK_HEADERS([sys/param.h sys/sysctl.h])  dnl NetBSD 6.0
+
+    AC_CHECK_FUNCS([sysctlbyname], [$1], [$2])
+])
+
+
+dnl Looks for a specific sysctl MIB.
+dnl
+dnl \pre sysctlbyname(3) must be present in the system.
+dnl
+dnl \param mib_name The name of the MIB to check for.
+dnl \param flat_mib_name The name of the MIB as a shell variable, for use in
+dnl     cache variable names.  This should be automatically computed with
+dnl     m4_bpatsubst or similar, but my inability to make the code readable
+dnl     made me add this parameter instead.
+dnl \param action_if_found Code to run if the MIB is found.
+dnl \param action_if_not_found Code to run if the MIB is not found.
+AC_DEFUN([_KYUA_SYSCTL_MIB], [
+    AC_CACHE_CHECK(
+        [if the $1 sysctl MIB exists],
+        [kyua_cv_sysctl_$2], [
+        AC_RUN_IFELSE([AC_LANG_PROGRAM([
+#if defined(HAVE_SYS_TYPES_H)
+#   include <sys/types.h>
+#endif
+#if defined(HAVE_SYS_PARAM_H)
+#   include <sys/param.h>
+#endif
+#if defined(HAVE_SYS_SYSCTL_H)
+#   include <sys/sysctl.h>
+#endif
+#include <stdint.h>
+#include <stdlib.h>
+], [
+    int64_t memory;
+    size_t memory_length = sizeof(memory);
+    if (sysctlbyname("$1", &memory, &memory_length, NULL, 0) == -1)
+        return EXIT_FAILURE;
+    else
+        return EXIT_SUCCESS;
+])],
+        [kyua_cv_sysctl_$2=yes],
+        [kyua_cv_sysctl_$2=no])
+    ])
+    if test "${kyua_cv_sysctl_$2}" = yes; then
+        m4_default([$3], [:])
+    else
+        m4_default([$4], [:])
+    fi
+])
diff --git a/m4/signals.m4 b/m4/signals.m4
new file mode 100644
index 000000000000..8e8b56e1eb73
--- /dev/null
+++ b/m4/signals.m4
@@ -0,0 +1,92 @@
+dnl Copyright 2010 The Kyua Authors.
+dnl All rights reserved.
+dnl
+dnl Redistribution and use in source and binary forms, with or without
+dnl modification, are permitted provided that the following conditions are
+dnl met:
+dnl
+dnl * Redistributions of source code must retain the above copyright
+dnl   notice, this list of conditions and the following disclaimer.
+dnl * Redistributions in binary form must reproduce the above copyright
+dnl   notice, this list of conditions and the following disclaimer in the
+dnl   documentation and/or other materials provided with the distribution.
+dnl * Neither the name of Google Inc. nor the names of its contributors
+dnl   may be used to endorse or promote products derived from this software
+dnl   without specific prior written permission.
+dnl
+dnl THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+dnl "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+dnl LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+dnl A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+dnl OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+dnl LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+dnl DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+dnl THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+dnl (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+dnl OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+dnl
+dnl KYUA_LAST_SIGNO
+dnl
+dnl Detect the last valid signal number.
+dnl
+AC_DEFUN([KYUA_LAST_SIGNO], [
+    AC_CACHE_CHECK(
+        [for the last valid signal],
+        [kyua_cv_signals_lastno], [
+        AC_RUN_IFELSE([AC_LANG_PROGRAM([#include <err.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdio.h>
+#include <stdlib.h>], [
+    static const int max_signals = 256;
+    int i;
+    FILE *f;
+
+    i = 0;
+    while (i < max_signals) {
+        i++;
+        if (i != SIGKILL && i != SIGSTOP) {
+            struct sigaction sa;
+            int ret;
+
+            sa.sa_handler = SIG_DFL;
+            sigemptyset(&sa.sa_mask);
+            sa.sa_flags = 0;
+
+            ret = sigaction(i, &sa, NULL);
+            if (ret == -1) {
+                warn("sigaction(%d) failed", i);
+                if (errno == EINVAL) {
+                    i--;
+                    break;
+                } else
+                    err(EXIT_FAILURE, "sigaction failed");
+            }
+        }
+    }
+    if (i == max_signals)
+        errx(EXIT_FAILURE, "too many signals");
+
+    f = fopen("conftest.cnt", "w");
+    if (f == NULL)
+        err(EXIT_FAILURE, "failed to open file");
+
+    fprintf(f, "%d\n", i);
+    fclose(f);
+
+    return EXIT_SUCCESS;
+])],
+        [if test ! -f conftest.cnt; then
+             kyua_cv_signals_lastno=15
+         else
+             kyua_cv_signals_lastno=$(cat conftest.cnt)
+             rm -f conftest.cnt
+         fi],
+        [kyua_cv_signals_lastno=15])
+    ])
+    AC_DEFINE_UNQUOTED([LAST_SIGNO], [${kyua_cv_signals_lastno}],
+                       [Define to the last valid signal number])
+])
diff --git a/m4/uname.m4 b/m4/uname.m4
new file mode 100644
index 000000000000..bcb3d0d39a71
--- /dev/null
+++ b/m4/uname.m4
@@ -0,0 +1,63 @@
+dnl Copyright 2010 The Kyua Authors.
+dnl All rights reserved.
+dnl
+dnl Redistribution and use in source and binary forms, with or without
+dnl modification, are permitted provided that the following conditions are
+dnl met:
+dnl
+dnl * Redistributions of source code must retain the above copyright
+dnl   notice, this list of conditions and the following disclaimer.
+dnl * Redistributions in binary form must reproduce the above copyright
+dnl   notice, this list of conditions and the following disclaimer in the
+dnl   documentation and/or other materials provided with the distribution.
+dnl * Neither the name of Google Inc. nor the names of its contributors
+dnl   may be used to endorse or promote products derived from this software
+dnl   without specific prior written permission.
+dnl
+dnl THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+dnl "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+dnl LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+dnl A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+dnl OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+dnl SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+dnl LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+dnl DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+dnl THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+dnl (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+dnl OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+dnl
+dnl KYUA_UNAME_ARCHITECTURE
+dnl
+dnl Checks for the current architecture name (aka processor type) and defines
+dnl the KYUA_ARCHITECTURE macro to its value.
+dnl
+AC_DEFUN([KYUA_UNAME_ARCHITECTURE], [
+    AC_MSG_CHECKING([for architecture name])
+    AC_ARG_VAR([KYUA_ARCHITECTURE],
+               [Name of the system architecture (aka processor type)])
+    if test x"${KYUA_ARCHITECTURE-unset}" = x"unset"; then
+        KYUA_ARCHITECTURE="$(uname -p)"
+    fi
+    AC_DEFINE_UNQUOTED([KYUA_ARCHITECTURE], "${KYUA_ARCHITECTURE}",
+                       [Name of the system architecture (aka processor type)])
+    AC_MSG_RESULT([${KYUA_ARCHITECTURE}])
+])
+
+dnl
+dnl KYUA_UNAME_PLATFORM
+dnl
+dnl Checks for the current platform name (aka machine name) and defines
+dnl the KYUA_PLATFORM macro to its value.
+dnl
+AC_DEFUN([KYUA_UNAME_PLATFORM], [
+    AC_MSG_CHECKING([for platform name])
+    AC_ARG_VAR([KYUA_PLATFORM],
+               [Name of the system platform (aka machine name)])
+    if test x"${KYUA_PLATFORM-unset}" = x"unset"; then
+        KYUA_PLATFORM="$(uname -m)"
+    fi
+    AC_DEFINE_UNQUOTED([KYUA_PLATFORM], "${KYUA_PLATFORM}",
+                       [Name of the system platform (aka machine name)])
+    AC_MSG_RESULT([${KYUA_PLATFORM}])
+])