Removed part of the Boost files from the SPIRIT_MINIBOOST branch.

[SVN r26352]

doc/tribool.boostbook

@@ -2,7 +2,7 @@
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <library name="Tribool" dirname="logic" id="tribool"
-         last-revision="$Date: 2007/05/03 03:28:53 $" xmlns:xi="http://www.w3.org/2001/XInclude">
+         last-revision="$Date: 2004/07/25 03:01:38 $" xmlns:xi="http://www.w3.org/2001/XInclude">
   <libraryinfo>
     <author>
       <firstname>Douglas</firstname>
@@ -197,7 +197,7 @@ cout &lt;&lt; boolalpha &lt;&lt; x &lt;&lt; endl; // Prints "maybe"</programlist
 
   </section>
 
-  <xi:include href="reference.xml"/>
+  <xi:include href="reference.boostbook"/>
 
   <testsuite id="tribool.tests">
     <run-test filename="tribool_test.cpp">

include/boost/logic/tribool.hpp

@@ -1,460 +0,0 @@
-// Three-state boolean logic library
-
-// Copyright Douglas Gregor 2002-2004. Use, modification and
-// distribution is subject to the Boost Software License, Version
-// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-
-// For more information, see http://www.boost.org
-#ifndef BOOST_LOGIC_TRIBOOL_HPP
-#define BOOST_LOGIC_TRIBOOL_HPP
-
-#include <boost/logic/tribool_fwd.hpp>
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#if BOOST_WORKAROUND(_MSC_VER, >= 1200)
-#  pragma once
-#endif
-
-namespace boost { namespace logic {
-
-/// INTERNAL ONLY
-namespace detail {
-/**
- * INTERNAL ONLY
- *
- * \brief A type used only to uniquely identify the 'indeterminate'
- * function/keyword.
- */
-struct indeterminate_t
-{
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x0600)
-  char dummy_; // BCB would use 8 bytes by default
-#endif
-};
-
-} // end namespace detail
-
-/**
- * INTERNAL ONLY
- * The type of the 'indeterminate' keyword. This has the same type as the
- * function 'indeterminate' so that we can recognize when the keyword is
- * used.
- */
-typedef bool (*indeterminate_keyword_t)(tribool, detail::indeterminate_t);
-
-/**
- * \brief Keyword and test function for the indeterminate tribool value
- *
- * The \c indeterminate function has a dual role. It's first role is
- * as a unary function that tells whether the tribool value is in the
- * "indeterminate" state. It's second role is as a keyword
- * representing the indeterminate (just like "true" and "false"
- * represent the true and false states). If you do not like the name
- * "indeterminate", and would prefer to use a different name, see the
- * macro \c BOOST_TRIBOOL_THIRD_STATE.
- *
- * \returns <tt>x.value == tribool::indeterminate_value</tt>
- * \throws nothrow
- */
-inline bool
-indeterminate(tribool x,
-              detail::indeterminate_t dummy = detail::indeterminate_t());
-
-/**
- * \brief A 3-state boolean type.
- *
- * 3-state boolean values are either true, false, or
- * indeterminate.
- */
-class tribool
-{
-private:
-  /// INTERNAL ONLY
-  struct dummy {
-    void nonnull() {};
-  };
-
-  typedef void (dummy::*safe_bool)();
-
-public:
-  /**
-   * Construct a new 3-state boolean value with the value 'false'.
-   *
-   * \throws nothrow
-   */
-  tribool() : value(false_value) {}
-
-  /**
-   * Construct a new 3-state boolean value with the given boolean
-   * value, which may be \c true or \c false.
-   *
-   * \throws nothrow
-   */
-  tribool(bool value) : value(value? true_value : false_value) {}
-
-  /**
-   * Construct a new 3-state boolean value with an indeterminate value.
-   *
-   * \throws nothrow
-   */
-  tribool(indeterminate_keyword_t) : value(indeterminate_value) {}
-
-  /**
-   * Use a 3-state boolean in a boolean context. Will evaluate true in a
-   * boolean context only when the 3-state boolean is definitely true.
-   *
-   * \returns true if the 3-state boolean is true, false otherwise
-   * \throws nothrow
-   */
-  operator safe_bool() const
-  {
-    return value == true_value? &dummy::nonnull : 0;
-  }
-
-  /**
-   * The actual stored value in this 3-state boolean, which may be false, true,
-   * or indeterminate.
-   */
-  enum value_t { false_value, true_value, indeterminate_value } value;
-};
-
-// Check if the given tribool has an indeterminate value. Also doubles as a
-// keyword for the 'indeterminate' value
-inline bool indeterminate(tribool x, detail::indeterminate_t)
-{
-  return x.value == tribool::indeterminate_value;
-}
-
-/** @defgroup logical Logical operations
- */
-//@{
-/**
- * \brief Computes the logical negation of a tribool
- *
- * \returns the logical negation of the tribool, according to the
- * table:
- *  <table border=1>
- *    <tr>
- *      <th><center><code>!</code></center></th>
- *      <th/>
- *    </tr>
- *    <tr>
- *      <th><center>false</center></th>
- *      <td><center>true</center></td>
- *    </tr>
- *    <tr>
- *      <th><center>true</center></th>
- *      <td><center>false</center></td>
- *    </tr>
- *    <tr>
- *      <th><center>indeterminate</center></th>
- *      <td><center>indeterminate</center></td>
- *    </tr>
- *  </table>
- * \throws nothrow
- */
-inline tribool operator!(tribool x)
-{
-  return x.value == tribool::false_value? tribool(true)
-        :x.value == tribool::true_value? tribool(false)
-        :tribool(indeterminate);
-}
-
-/**
- * \brief Computes the logical conjuction of two tribools
- *
- * \returns the result of logically ANDing the two tribool values,
- * according to the following table:
- *       <table border=1>
- *           <tr>
- *             <th><center><code>&amp;&amp;</code></center></th>
- *             <th><center>false</center></th>
- *             <th><center>true</center></th>
- *             <th><center>indeterminate</center></th>
- *           </tr>
- *           <tr>
- *             <th><center>false</center></th>
- *             <td><center>false</center></td>
- *             <td><center>false</center></td>
- *             <td><center>false</center></td>
- *           </tr>
- *           <tr>
- *             <th><center>true</center></th>
- *             <td><center>false</center></td>
- *             <td><center>true</center></td>
- *             <td><center>indeterminate</center></td>
- *           </tr>
- *           <tr>
- *             <th><center>indeterminate</center></th>
- *             <td><center>false</center></td>
- *             <td><center>indeterminate</center></td>
- *             <td><center>indeterminate</center></td>
- *           </tr>
- *       </table>
- * \throws nothrow
- */
-inline tribool operator&&(tribool x, tribool y)
-{
-  if (static_cast<bool>(!x) || static_cast<bool>(!y))
-    return false;
-  else if (static_cast<bool>(x) && static_cast<bool>(y))
-    return true;
-  else
-    return indeterminate;
-}
-
-/**
- * \overload
- */
-inline tribool operator&&(tribool x, bool y)
-{ return y? x : tribool(false); }
-
-/**
- * \overload
- */
-inline tribool operator&&(bool x, tribool y)
-{ return x? y : tribool(false); }
-
-/**
- * \overload
- */
-inline tribool operator&&(indeterminate_keyword_t, tribool x)
-{ return !x? tribool(false) : tribool(indeterminate); }
-
-/**
- * \overload
- */
-inline tribool operator&&(tribool x, indeterminate_keyword_t)
-{ return !x? tribool(false) : tribool(indeterminate); }
-
-/**
- * \brief Computes the logical disjunction of two tribools
- *
- * \returns the result of logically ORing the two tribool values,
- * according to the following table:
- *       <table border=1>
- *           <tr>
- *             <th><center><code>||</code></center></th>
- *             <th><center>false</center></th>
- *             <th><center>true</center></th>
- *             <th><center>indeterminate</center></th>
- *           </tr>
- *           <tr>
- *             <th><center>false</center></th>
- *             <td><center>false</center></td>
- *             <td><center>true</center></td>
- *             <td><center>indeterminate</center></td>
- *           </tr>
- *           <tr>
- *             <th><center>true</center></th>
- *             <td><center>true</center></td>
- *             <td><center>true</center></td>
- *             <td><center>true</center></td>
- *           </tr>
- *           <tr>
- *             <th><center>indeterminate</center></th>
- *             <td><center>indeterminate</center></td>
- *             <td><center>true</center></td>
- *             <td><center>indeterminate</center></td>
- *           </tr>
- *       </table>
- *  \throws nothrow
- */
-inline tribool operator||(tribool x, tribool y)
-{
-  if (static_cast<bool>(!x) && static_cast<bool>(!y))
-    return false;
-  else if (static_cast<bool>(x) || static_cast<bool>(y))
-    return true;
-  else
-    return indeterminate;
-}
-
-/**
- * \overload
- */
-inline tribool operator||(tribool x, bool y)
-{ return y? tribool(true) : x; }
-
-/**
- * \overload
- */
-inline tribool operator||(bool x, tribool y)
-{ return x? tribool(true) : y; }
-
-/**
- * \overload
- */
-inline tribool operator||(indeterminate_keyword_t, tribool x)
-{ return x? tribool(true) : tribool(indeterminate); }
-
-/**
- * \overload
- */
-inline tribool operator||(tribool x, indeterminate_keyword_t)
-{ return x? tribool(true) : tribool(indeterminate); }
-//@}
-
-/**
- * \brief Compare tribools for equality
- *
- * \returns the result of comparing two tribool values, according to
- * the following table:
- *       <table border=1>
- *          <tr>
- *            <th><center><code>==</code></center></th>
- *            <th><center>false</center></th>
- *            <th><center>true</center></th>
- *            <th><center>indeterminate</center></th>
- *          </tr>
- *          <tr>
- *            <th><center>false</center></th>
- *            <td><center>true</center></td>
- *            <td><center>false</center></td>
- *            <td><center>indeterminate</center></td>
- *          </tr>
- *          <tr>
- *            <th><center>true</center></th>
- *            <td><center>false</center></td>
- *            <td><center>true</center></td>
- *            <td><center>indeterminate</center></td>
- *          </tr>
- *          <tr>
- *            <th><center>indeterminate</center></th>
- *            <td><center>indeterminate</center></td>
- *            <td><center>indeterminate</center></td>
- *            <td><center>indeterminate</center></td>
- *          </tr>
- *      </table>
- * \throws nothrow
- */
-inline tribool operator==(tribool x, tribool y)
-{
-  if (indeterminate(x) || indeterminate(y))
-    return indeterminate;
-  else
-    return (x && y) || (!x && !y);
-}
-
-/**
- * \overload
- */
-inline tribool operator==(tribool x, bool y) { return x == tribool(y); }
-
-/**
- * \overload
- */
-inline tribool operator==(bool x, tribool y) { return tribool(x) == y; }
-
-/**
- * \overload
- */
-inline tribool operator==(indeterminate_keyword_t, tribool x)
-{ return tribool(indeterminate) == x; }
-
-/**
- * \overload
- */
-inline tribool operator==(tribool x, indeterminate_keyword_t)
-{ return tribool(indeterminate) == x; }
-
-/**
- * \brief Compare tribools for inequality
- *
- * \returns the result of comparing two tribool values for inequality,
- * according to the following table:
- *       <table border=1>
- *           <tr>
- *             <th><center><code>!=</code></center></th>
- *             <th><center>false</center></th>
- *             <th><center>true</center></th>
- *             <th><center>indeterminate</center></th>
- *           </tr>
- *           <tr>
- *             <th><center>false</center></th>
- *             <td><center>false</center></td>
- *             <td><center>true</center></td>
- *             <td><center>indeterminate</center></td>
- *           </tr>
- *           <tr>
- *             <th><center>true</center></th>
- *             <td><center>true</center></td>
- *             <td><center>false</center></td>
- *             <td><center>indeterminate</center></td>
- *           </tr>
- *           <tr>
- *             <th><center>indeterminate</center></th>
- *             <td><center>indeterminate</center></td>
- *             <td><center>indeterminate</center></td>
- *             <td><center>indeterminate</center></td>
- *           </tr>
- *       </table>
- * \throws nothrow
- */
-inline tribool operator!=(tribool x, tribool y)
-{
-  if (indeterminate(x) || indeterminate(y))
-    return indeterminate;
-  else
-    return !((x && y) || (!x && !y));
-}
-
-/**
- * \overload
- */
-inline tribool operator!=(tribool x, bool y) { return x != tribool(y); }
-
-/**
- * \overload
- */
-inline tribool operator!=(bool x, tribool y) { return tribool(x) != y; }
-
-/**
- * \overload
- */
-inline tribool operator!=(indeterminate_keyword_t, tribool x)
-{ return tribool(indeterminate) != x; }
-
-/**
- * \overload
- */
-inline tribool operator!=(tribool x, indeterminate_keyword_t)
-{ return x != tribool(indeterminate); }
-
-} } // end namespace boost::logic
-
-// Pull tribool and indeterminate into namespace "boost"
-namespace boost {
-  using logic::tribool;
-  using logic::indeterminate;
-}
-
-/**
- * \brief Declare a new name for the third state of a tribool
- *
- * Use this macro to declare a new name for the third state of a
- * tribool. This state can have any number of new names (in addition
- * to \c indeterminate), all of which will be equivalent. The new name will be
- * placed in the namespace in which the macro is expanded.
- *
- * Example:
- *   BOOST_TRIBOOL_THIRD_STATE(true_or_false)
- *
- *   tribool x(true_or_false);
- *   // potentially set x
- *   if (true_or_false(x)) {
- *     // don't know what x is
- *   }
- */
-#define BOOST_TRIBOOL_THIRD_STATE(Name)                                 \
-inline bool                                                             \
-Name(boost::logic::tribool x,                                           \
-     boost::logic::detail::indeterminate_t dummy =                      \
-       boost::logic::detail::indeterminate_t())                         \
-{ return x.value == boost::logic::tribool::indeterminate_value; }
-
-#endif // BOOST_LOGIC_TRIBOOL_HPP
-

include/boost/logic/tribool_fwd.hpp

@@ -1,15 +0,0 @@
-// Three-state boolean logic library
-
-// Copyright Douglas Gregor 2002-2004. Use, modification and
-// distribution is subject to the Boost Software License, Version
-// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-
-// For more information, see http://www.boost.org
-#ifndef BOOST_LOGIC_TRIBOOL_FWD_HPP
-#define BOOST_LOGIC_TRIBOOL_FWD_HPP
-
-namespace boost { namespace logic { class tribool; } }
-
-#endif // BOOST_LOGIC_TRIBOOL_FWD_HPP

include/boost/logic/tribool_io.hpp

@@ -1,348 +0,0 @@
-// Three-state boolean logic library
-
-// Copyright Douglas Gregor 2002-2004. Use, modification and
-// distribution is subject to the Boost Software License, Version
-// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_LOGIC_TRIBOOL_IO_HPP
-#define BOOST_LOGIC_TRIBOOL_IO_HPP
-
-#include <boost/logic/tribool.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/noncopyable.hpp>
-
-#if BOOST_WORKAROUND(_MSC_VER, >= 1200)
-#  pragma once
-#endif
-
-#ifndef BOOST_NO_STD_LOCALE
-#  include <locale>
-#endif
-
-#include <string>
-#include <iostream>
-
-namespace boost { namespace logic {
-
-#ifdef BOOST_NO_STD_LOCALE
-
-/**
- * \brief Returns a string containing the default name for the \c
- * false value of a tribool with the given character type T.
- *
- * This function only exists when the C++ standard library
- * implementation does not support locales.
- */
-template<typename T> std::basic_string<T> default_false_name();
-
-/**
- * \brief Returns the character string "false".
- *
- * This function only exists when the C++ standard library
- * implementation does not support locales.
- */
-template<>
-inline std::basic_string<char> default_false_name<char>()
-{ return "false"; }
-
-#  ifndef BOOST_NO_WCHAR_T
-/**
- * \brief Returns the wide character string L"false".
- *
- * This function only exists when the C++ standard library
- * implementation does not support locales.
- */
-template<>
-inline std::basic_string<wchar_t> default_false_name<wchar_t>()
-{ return L"false"; }
-#  endif
-
-/**
- * \brief Returns a string containing the default name for the \c true
- * value of a tribool with the given character type T.
- *
- * This function only exists when the C++ standard library
- * implementation does not support locales.
- */
-template<typename T> std::basic_string<T> default_true_name();
-
-/**
- * \brief Returns the character string "true".
- *
- * This function only exists when the C++ standard library
- * implementation does not support locales.
- */
-template<>
-inline std::basic_string<char> default_true_name<char>()
-{ return "true"; }
-
-#  ifndef BOOST_NO_WCHAR_T
-/**
- * \brief Returns the wide character string L"true".
- *
- *  This function only exists * when the C++ standard library
- *  implementation does not support * locales.
- */
-template<>
-inline std::basic_string<wchar_t> default_true_name<wchar_t>()
-{ return L"true"; }
-#  endif
-#endif
-
-/**
- * \brief Returns a string containing the default name for the indeterminate
- * value of a tribool with the given character type T.
- *
- * This routine is used by the input and output streaming operators
- * for tribool when there is no locale support or the stream's locale
- * does not contain the indeterminate_name facet.
- */
-template<typename T> std::basic_string<T> get_default_indeterminate_name();
-
-/// Returns the character string "indeterminate".
-template<>
-inline std::basic_string<char> get_default_indeterminate_name<char>()
-{ return "indeterminate"; }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// VC++ 6.0 chokes on the specialization below, so we're stuck without 
-// wchar_t support. What a pain. TODO: it might just need a the template 
-// parameter as function parameter...
-#else
-#  ifndef BOOST_NO_WCHAR_T
-/// Returns the wide character string L"indeterminate".
-template<>
-inline std::basic_string<wchar_t> get_default_indeterminate_name<wchar_t>()
-{ return L"indeterminate"; }
-#  endif
-#endif
-
-// http://www.cantrip.org/locale.html
-
-#ifndef BOOST_NO_STD_LOCALE
-/**
- * \brief A locale facet specifying the name of the indeterminate
- * value of a tribool.
- *
- * The facet is used to perform I/O on tribool values when \c
- * std::boolalpha has been specified. This class template is only
- * available if the C++ standard library implementation supports
- * locales.
- */
-template<typename CharT>
-class indeterminate_name : public std::locale::facet, private boost::noncopyable
-{
-public:
-  typedef CharT char_type;
-  typedef std::basic_string<CharT> string_type;
-
-  /// Construct the facet with the default name
-  indeterminate_name() : name_(get_default_indeterminate_name<CharT>()) {}
-
-  /// Construct the facet with the given name for the indeterminate value
-  explicit indeterminate_name(const string_type& name) : name_(name) {}
-
-  /// Returns the name for the indeterminate value
-  string_type name() const { return name_; }
-
-  /// Uniquily identifies this facet with the locale.
-  static std::locale::id id;
-
-private:
-  string_type name_;
-};
-
-template<typename CharT> std::locale::id indeterminate_name<CharT>::id;
-#endif
-
-/**
- * \brief Writes the value of a tribool to a stream.
- *
- * When the value of @p x is either \c true or \c false, this routine
- * is semantically equivalent to:
- * \code out << static_cast<bool>(x); \endcode
- *
- * When @p x has an indeterminate value, it outputs either the integer
- * value 2 (if <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>)
- * or the name of the indeterminate value. The name of the
- * indeterminate value comes from the indeterminate_name facet (if it
- * is defined in the output stream's locale), or from the
- * get_default_indeterminate_name function (if it is not defined in the
- * locale or if the C++ standard library implementation does not
- * support locales).
- *
- * \returns @p out
- */
-template<typename CharT, typename Traits>
-inline std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& out, tribool x)
-{
-  if (!indeterminate(x)) {
-    out << static_cast<bool>(x);
-  } else {
-    typename std::basic_ostream<CharT, Traits>::sentry cerberus(out);
-    if (cerberus) {
-      if (out.flags() & std::ios_base::boolalpha) {
-#ifndef BOOST_NO_STD_LOCALE
-        if (BOOST_HAS_FACET(indeterminate_name<CharT>, out.getloc())) {
-          const indeterminate_name<CharT>& facet =
-            BOOST_USE_FACET(indeterminate_name<CharT>, out.getloc());
-          out << facet.name();
-        } else {
-          out << get_default_indeterminate_name<CharT>();
-        }
-#else
-        out << get_default_indeterminate_name<CharT>();
-#endif
-      }
-      else
-        out << 2;
-    }
-  }
-  return out;
-}
-
-/**
- * \brief Writes the indeterminate tribool value to a stream.
- *
- * This routine outputs either the integer
- * value 2 (if <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>)
- * or the name of the indeterminate value. The name of the
- * indeterminate value comes from the indeterminate_name facet (if it
- * is defined in the output stream's locale), or from the
- * get_default_indeterminate_name function (if it is not defined in the
- * locale or if the C++ standard library implementation does not
- * support locales).
- *
- * \returns @p out
- */
-template<typename CharT, typename Traits>
-inline std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& out, 
-           bool (*)(tribool, detail::indeterminate_t))
-{ return out << tribool(indeterminate); } 
-
-/**
- * \brief Reads a tribool value from a stream.
- *
- * When <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>, this
- * function reads a \c long value from the input stream @p in and
- * converts that value to a tribool. If that value is 0, @p x becomes
- * \c false; if it is 1, @p x becomes \c true; if it is 2, @p becomes
- * \c indetermine; otherwise, the operation fails (and the fail bit is
- * set on the input stream @p in).
- *
- * When <tt>(out.flags() & std::ios_base::boolalpha) != 0</tt>, this
- * function first determines the names of the false, true, and
- * indeterminate values. The false and true names are extracted from
- * the \c std::numpunct facet of the input stream's locale (if the C++
- * standard library implementation supports locales), or from the \c
- * default_false_name and \c default_true_name functions (if there is
- * no locale support). The indeterminate name is extracted from the
- * appropriate \c indeterminate_name facet (if it is available in the
- * input stream's locale), or from the \c get_default_indeterminate_name
- * function (if the C++ standard library implementation does not
- * support locales, or the \c indeterminate_name facet is not
- * specified for this locale object). The input is then matched to
- * each of these names, and the tribool @p x is assigned the value
- * corresponding to the longest name that matched. If no name is
- * matched or all names are empty, the operation fails (and the fail
- * bit is set on the input stream @p in).
- *
- * \returns @p in
- */
-template<typename CharT, typename Traits>
-inline std::basic_istream<CharT, Traits>&
-operator>>(std::basic_istream<CharT, Traits>& in, tribool& x)
-{
-  if (in.flags() & std::ios_base::boolalpha) {
-    typename std::basic_istream<CharT, Traits>::sentry cerberus(in);
-    if (cerberus) {
-      typedef std::basic_string<CharT> string_type;
-
-#ifndef BOOST_NO_STD_LOCALE
-      const std::numpunct<CharT>& numpunct_facet =
-        BOOST_USE_FACET(std::numpunct<CharT>, in.getloc());
-
-      string_type falsename = numpunct_facet.falsename();
-      string_type truename = numpunct_facet.truename();
-
-      string_type othername;
-      if (BOOST_HAS_FACET(indeterminate_name<CharT>, in.getloc())) {
-        othername =
-          BOOST_USE_FACET(indeterminate_name<CharT>, in.getloc()).name();
-      } else {
-        othername = get_default_indeterminate_name<CharT>();
-      }
-#else
-      string_type falsename = default_false_name<CharT>();
-      string_type truename = default_true_name<CharT>();
-      string_type othername = get_default_indeterminate_name<CharT>();
-#endif
-
-      typename string_type::size_type pos = 0;
-      bool falsename_ok = true, truename_ok = true, othername_ok = true;
-
-      // Modeled after the code from Library DR 17
-      while (falsename_ok && pos < falsename.size()
-             || truename_ok && pos < truename.size()
-             || othername_ok && pos < othername.size()) {
-        typename Traits::int_type c = in.get();
-        if (c == Traits::eof())
-          return in;
-
-        bool matched = false;
-        if (falsename_ok && pos < falsename.size()) {
-          if (Traits::eq(Traits::to_char_type(c), falsename[pos]))
-            matched = true;
-          else
-            falsename_ok = false;
-        }
-
-        if (truename_ok && pos < truename.size()) {
-          if (Traits::eq(Traits::to_char_type(c), truename[pos]))
-            matched = true;
-          else
-            truename_ok = false;
-        }
-
-        if (othername_ok && pos < othername.size()) {
-          if (Traits::eq(Traits::to_char_type(c), othername[pos]))
-            matched = true;
-          else
-            othername_ok = false;
-        }
-
-        if (matched) { ++pos; }
-        if (pos > falsename.size()) falsename_ok = false;
-        if (pos > truename.size())  truename_ok = false;
-        if (pos > othername.size()) othername_ok = false;
-      }
-
-      if (pos == 0)
-        in.setstate(std::ios_base::failbit);
-      else {
-        if (falsename_ok)      x = false;
-        else if (truename_ok)  x = true;
-        else if (othername_ok) x = indeterminate;
-        else in.setstate(std::ios_base::failbit);
-      }
-    }
-  } else {
-    long value;
-    if (in >> value) {
-      switch (value) {
-      case 0: x = false; break;
-      case 1: x = true; break;
-      case 2: x = indeterminate; break;
-      default: in.setstate(std::ios_base::failbit); break;
-      }
-    }
-  }
-
-  return in;
-}
-
-} } // end namespace boost::logic
-
-#endif // BOOST_LOGIC_TRIBOOL_IO_HPP

test/Jamfile

@@ -0,0 +1,35 @@
+# Tribool library
+
+# Copyright (C) 2002-2003 Douglas Gregor
+
+# Use, modification and distribution is subject to the Boost Software License, 
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
+# http://www.boost.org/LICENSE_1_0.txt) 
+
+# For more information, see http://www.boost.org/
+
+
+# Testing Jamfile autogenerated from XML source
+subproject libs/logic/test ;
+
+# bring in rules for testing
+SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
+include testing.jam ;
+
+# Make tests run by default.
+DEPENDS all : test ;
+
+{
+  # look in BOOST_ROOT for sources first, just in this Jamfile
+  local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
+
+  test-suite logic
+    : 
+    [ run libs/logic/test/tribool_test.cpp :  :  :  :  ]
+
+    [ run libs/logic/test/tribool_rename_test.cpp :  :  :  :  ]
+
+    [ run libs/logic/test/tribool_io_test.cpp :  :  :  :  ]
+   ;
+}
+      

test/Jamfile.v2

@@ -1,17 +0,0 @@
-# Tribool library
-
-# Copyright (C) 2002-2003 Douglas Gregor
-
-# Use, modification and distribution is subject to the Boost Software License, 
-# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
-# http://www.boost.org/LICENSE_1_0.txt) 
-
-# For more information, see http://www.boost.org/
-
-  test-suite logic  : 
-    [ run tribool_test.cpp ]
-    [ run tribool_rename_test.cpp ]
-    [ run tribool_io_test.cpp ]
-   ;
-
-      

test/tribool_io_test.cpp

@@ -8,7 +8,6 @@
 #include <sstream>
 #include <string>
 #include <iostream>
-#include <ios>     // for std::boolalpha
 
 #ifndef BOOST_NO_STD_LOCALE
 #  include <locale>
@@ -28,14 +27,14 @@ int test_main(int, char*[])
   x = false;
   out << x;
   std::cout << "Output false (noboolalpha): " << out.str() << std::endl;
-  BOOST_CHECK(out.str() == "0");
+  BOOST_TEST(out.str() == "0");
 
   // Output true (noboolalpha)
   out.str(std::string());
   x = true;
   out << x;
   std::cout << "Output true (noboolalpha): " << out.str() << std::endl;
-  BOOST_CHECK(out.str() == "1");
+  BOOST_TEST(out.str() == "1");
 
   // Output indeterminate (noboolalpha)
   out.str(std::string());
@@ -43,14 +42,7 @@ int test_main(int, char*[])
   out << x;
   std::cout << "Output indeterminate (noboolalpha): " << out.str()
             << std::endl;
-  BOOST_CHECK(out.str() == "2");
-
-  // Output indeterminate (noboolalpha)
-  out.str(std::string());
-  out << indeterminate;
-  std::cout << "Output indeterminate (noboolalpha): " << out.str()
-            << std::endl;
-  BOOST_CHECK(out.str() == "2");
+  BOOST_TEST(out.str() == "2");
 
 #ifndef BOOST_NO_STD_LOCALE
   const std::numpunct<char>& punct =
@@ -61,7 +53,7 @@ int test_main(int, char*[])
   x = false;
   out << std::boolalpha << x;
   std::cout << "Output false (boolalpha): " << out.str() << std::endl;
-  BOOST_CHECK(out.str() == punct.falsename());
+  BOOST_TEST(out.str() == punct.falsename());
 
   // Output true (boolalpha)
   out.str(std::string());
@@ -69,7 +61,7 @@ int test_main(int, char*[])
   out << std::boolalpha << x;
   std::cout << "Output true (boolalpha): " << out.str() << std::endl;
 
-  BOOST_CHECK(out.str() == punct.truename());
+  BOOST_TEST(out.str() == punct.truename());
 
   // Output indeterminate (boolalpha - default name)
   out.str(std::string());
@@ -77,14 +69,7 @@ int test_main(int, char*[])
   out << std::boolalpha << x;
   std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
             << std::endl;
-  BOOST_CHECK(out.str() == "indeterminate");
-
-  // Output indeterminate (boolalpha - default name)
-  out.str(std::string());
-  out << std::boolalpha << indeterminate;
-  std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
-            << std::endl;
-  BOOST_CHECK(out.str() == "indeterminate");
+  BOOST_TEST(out.str() == "indeterminate");
 
 #  if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
   // No template constructors, so we can't build the test locale
@@ -97,7 +82,7 @@ int test_main(int, char*[])
   out << std::boolalpha << x;
   std::cout << "Output indeterminate (boolalpha - \"maybe\"): " << out.str()
             << std::endl;
-  BOOST_CHECK(out.str() == "maybe");
+  BOOST_TEST(out.str() == "maybe");
 #  endif
 #endif // ! BOOST_NO_STD_LOCALE
 
@@ -108,7 +93,7 @@ int test_main(int, char*[])
     std::istringstream in("0");
     std::cout << "Input \"0\" (checks for false)" << std::endl;
     in >> x;
-    BOOST_CHECK(x == false);
+    BOOST_TEST(x == false);
   }
 
   // Input true (noboolalpha)
@@ -116,7 +101,7 @@ int test_main(int, char*[])
     std::istringstream in("1");
     std::cout << "Input \"1\" (checks for true)" << std::endl;
     in >> x;
-    BOOST_CHECK(x == true);
+    BOOST_TEST(x == true);
   }
 
   // Input false (noboolalpha)
@@ -124,14 +109,14 @@ int test_main(int, char*[])
     std::istringstream in("2");
     std::cout << "Input \"2\" (checks for indeterminate)" << std::endl;
     in >> x;
-    BOOST_CHECK(indeterminate(x));
+    BOOST_TEST(indeterminate(x));
   }
 
   // Input bad number (noboolalpha)
   {
     std::istringstream in("3");
     std::cout << "Input \"3\" (checks for failure)" << std::endl;
-    BOOST_CHECK(!(in >> x));
+    BOOST_TEST(!(in >> x));
   }
 
   // Input false (boolalpha)
@@ -139,7 +124,7 @@ int test_main(int, char*[])
     std::istringstream in("false");
     std::cout << "Input \"false\" (checks for false)" << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(x == false);
+    BOOST_TEST(x == false);
   }
 
   // Input true (boolalpha)
@@ -147,7 +132,7 @@ int test_main(int, char*[])
     std::istringstream in("true");
     std::cout << "Input \"true\" (checks for true)" << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(x == true);
+    BOOST_TEST(x == true);
   }
 
   // Input indeterminate (boolalpha)
@@ -156,7 +141,7 @@ int test_main(int, char*[])
     std::cout << "Input \"indeterminate\" (checks for indeterminate)"
               << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(indeterminate(x));
+    BOOST_TEST(indeterminate(x));
   }
 
   // Input bad string (boolalpha)
@@ -164,7 +149,7 @@ int test_main(int, char*[])
     std::istringstream in("bad");
     std::cout << "Input \"bad\" (checks for failure)"
               << std::endl;
-    BOOST_CHECK(!(in >> std::boolalpha >> x));
+    BOOST_TEST(!(in >> std::boolalpha >> x));
   }
 
 #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
@@ -178,7 +163,7 @@ int test_main(int, char*[])
     std::cout << "Input \"maybe\" (checks for indeterminate, uses locales)"
               << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(indeterminate(x));
+    BOOST_TEST(indeterminate(x));
   }
 
   // Input indeterminate named "true_or_false" (boolalpha)
@@ -190,7 +175,7 @@ int test_main(int, char*[])
     std::cout << "Input \"true_or_false\" (checks for indeterminate)"
               << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_CHECK(indeterminate(x));
+    BOOST_TEST(indeterminate(x));
   }
 #endif
 

test/tribool_rename_test.cpp

@@ -19,103 +19,103 @@ int test_main(int,char*[])
   tribool y(true); // true
   tribool z(maybe); // maybe
 
-  BOOST_CHECK(!x);
-  BOOST_CHECK(x == false);
-  BOOST_CHECK(false == x);
-  BOOST_CHECK(x != true);
-  BOOST_CHECK(true != x);
-  BOOST_CHECK(maybe(x == maybe));
-  BOOST_CHECK(maybe(maybe == x));
-  BOOST_CHECK(maybe(x != maybe));
-  BOOST_CHECK(maybe(maybe != x));
-  BOOST_CHECK(x == x);
-  BOOST_CHECK(!(x != x));
-  BOOST_CHECK(!(x && true));
-  BOOST_CHECK(!(true && x));
-  BOOST_CHECK(x || true);
-  BOOST_CHECK(true || x);
+  BOOST_TEST(!x);
+  BOOST_TEST(x == false);
+  BOOST_TEST(false == x);
+  BOOST_TEST(x != true);
+  BOOST_TEST(true != x);
+  BOOST_TEST(maybe(x == maybe));
+  BOOST_TEST(maybe(maybe == x));
+  BOOST_TEST(maybe(x != maybe));
+  BOOST_TEST(maybe(maybe != x));
+  BOOST_TEST(x == x);
+  BOOST_TEST(!(x != x));
+  BOOST_TEST(!(x && true));
+  BOOST_TEST(!(true && x));
+  BOOST_TEST(x || true);
+  BOOST_TEST(true || x);
 
-  BOOST_CHECK(y);
-  BOOST_CHECK(y == true);
-  BOOST_CHECK(true == y);
-  BOOST_CHECK(y != false);
-  BOOST_CHECK(false != y);
-  BOOST_CHECK(maybe(y == maybe));
-  BOOST_CHECK(maybe(maybe == y));
-  BOOST_CHECK(maybe(y != maybe));
-  BOOST_CHECK(maybe(maybe != y));
-  BOOST_CHECK(y == y);
-  BOOST_CHECK(!(y != y));
+  BOOST_TEST(y);
+  BOOST_TEST(y == true);
+  BOOST_TEST(true == y);
+  BOOST_TEST(y != false);
+  BOOST_TEST(false != y);
+  BOOST_TEST(maybe(y == maybe));
+  BOOST_TEST(maybe(maybe == y));
+  BOOST_TEST(maybe(y != maybe));
+  BOOST_TEST(maybe(maybe != y));
+  BOOST_TEST(y == y);
+  BOOST_TEST(!(y != y));
 
-  BOOST_CHECK(maybe(z || !z));
-  BOOST_CHECK(maybe(z == true));
-  BOOST_CHECK(maybe(true == z));
-  BOOST_CHECK(maybe(z == false));
-  BOOST_CHECK(maybe(false == z));
-  BOOST_CHECK(maybe(z == maybe));
-  BOOST_CHECK(maybe(maybe == z));
-  BOOST_CHECK(maybe(z != maybe));
-  BOOST_CHECK(maybe(maybe != z));
-  BOOST_CHECK(maybe(z == z));
-  BOOST_CHECK(maybe(z != z));
+  BOOST_TEST(maybe(z || !z));
+  BOOST_TEST(maybe(z == true));
+  BOOST_TEST(maybe(true == z));
+  BOOST_TEST(maybe(z == false));
+  BOOST_TEST(maybe(false == z));
+  BOOST_TEST(maybe(z == maybe));
+  BOOST_TEST(maybe(maybe == z));
+  BOOST_TEST(maybe(z != maybe));
+  BOOST_TEST(maybe(maybe != z));
+  BOOST_TEST(maybe(z == z));
+  BOOST_TEST(maybe(z != z));
 
-  BOOST_CHECK(!(x == y));
-  BOOST_CHECK(x != y);
-  BOOST_CHECK(maybe(x == z));
-  BOOST_CHECK(maybe(x != z));
-  BOOST_CHECK(maybe(y == z));
-  BOOST_CHECK(maybe(y != z));
+  BOOST_TEST(!(x == y));
+  BOOST_TEST(x != y);
+  BOOST_TEST(maybe(x == z));
+  BOOST_TEST(maybe(x != z));
+  BOOST_TEST(maybe(y == z));
+  BOOST_TEST(maybe(y != z));
 
-  BOOST_CHECK(!(x && y));
-  BOOST_CHECK(x || y);
-  BOOST_CHECK(!(x && z));
-  BOOST_CHECK(maybe(y && z));
-  BOOST_CHECK(maybe(z && z));
-  BOOST_CHECK(maybe(z || z));
-  BOOST_CHECK(maybe(x || z));
-  BOOST_CHECK(y || z);
+  BOOST_TEST(!(x && y));
+  BOOST_TEST(x || y);
+  BOOST_TEST(!(x && z));
+  BOOST_TEST(maybe(y && z));
+  BOOST_TEST(maybe(z && z));
+  BOOST_TEST(maybe(z || z));
+  BOOST_TEST(maybe(x || z));
+  BOOST_TEST(y || z);
 
-  BOOST_CHECK(maybe(y && maybe));
-  BOOST_CHECK(maybe(maybe && y));
-  BOOST_CHECK(!(x && maybe));
-  BOOST_CHECK(!(maybe && x));
+  BOOST_TEST(maybe(y && maybe));
+  BOOST_TEST(maybe(maybe && y));
+  BOOST_TEST(!(x && maybe));
+  BOOST_TEST(!(maybe && x));
 
-  BOOST_CHECK(maybe || y);
-  BOOST_CHECK(y || maybe);
-  BOOST_CHECK(maybe(x || maybe));
-  BOOST_CHECK(maybe(maybe || x));
+  BOOST_TEST(maybe || y);
+  BOOST_TEST(y || maybe);
+  BOOST_TEST(maybe(x || maybe));
+  BOOST_TEST(maybe(maybe || x));
 
   // Test the if (z) ... else (!z) ... else ... idiom
   if (z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else if (!z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
 
   z = true;
   if (z) {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
   else if (!z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
 
   z = false;
   if (z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else if (!z) {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
   else {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
 
   std::cout << "no errors detected\n";

test/tribool_test.cpp

@@ -15,103 +15,103 @@ int test_main(int, char*[])
   tribool y(true); // true
   tribool z(indeterminate); // indeterminate
 
-  BOOST_CHECK(!x);
-  BOOST_CHECK(x == false);
-  BOOST_CHECK(false == x);
-  BOOST_CHECK(x != true);
-  BOOST_CHECK(true != x);
-  BOOST_CHECK(indeterminate(x == indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate == x));
-  BOOST_CHECK(indeterminate(x != indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate != x));
-  BOOST_CHECK(x == x);
-  BOOST_CHECK(!(x != x));
-  BOOST_CHECK(!(x && true));
-  BOOST_CHECK(!(true && x));
-  BOOST_CHECK(x || true);
-  BOOST_CHECK(true || x);
+  BOOST_TEST(!x);
+  BOOST_TEST(x == false);
+  BOOST_TEST(false == x);
+  BOOST_TEST(x != true);
+  BOOST_TEST(true != x);
+  BOOST_TEST(indeterminate(x == indeterminate));
+  BOOST_TEST(indeterminate(indeterminate == x));
+  BOOST_TEST(indeterminate(x != indeterminate));
+  BOOST_TEST(indeterminate(indeterminate != x));
+  BOOST_TEST(x == x);
+  BOOST_TEST(!(x != x));
+  BOOST_TEST(!(x && true));
+  BOOST_TEST(!(true && x));
+  BOOST_TEST(x || true);
+  BOOST_TEST(true || x);
 
-  BOOST_CHECK(y);
-  BOOST_CHECK(y == true);
-  BOOST_CHECK(true == y);
-  BOOST_CHECK(y != false);
-  BOOST_CHECK(false != y);
-  BOOST_CHECK(indeterminate(y == indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate == y));
-  BOOST_CHECK(indeterminate(y != indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate != y));
-  BOOST_CHECK(y == y);
-  BOOST_CHECK(!(y != y));
+  BOOST_TEST(y);
+  BOOST_TEST(y == true);
+  BOOST_TEST(true == y);
+  BOOST_TEST(y != false);
+  BOOST_TEST(false != y);
+  BOOST_TEST(indeterminate(y == indeterminate));
+  BOOST_TEST(indeterminate(indeterminate == y));
+  BOOST_TEST(indeterminate(y != indeterminate));
+  BOOST_TEST(indeterminate(indeterminate != y));
+  BOOST_TEST(y == y);
+  BOOST_TEST(!(y != y));
 
-  BOOST_CHECK(indeterminate(z || !z));
-  BOOST_CHECK(indeterminate(z == true));
-  BOOST_CHECK(indeterminate(true == z));
-  BOOST_CHECK(indeterminate(z == false));
-  BOOST_CHECK(indeterminate(false == z));
-  BOOST_CHECK(indeterminate(z == indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate == z));
-  BOOST_CHECK(indeterminate(z != indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate != z));
-  BOOST_CHECK(indeterminate(z == z));
-  BOOST_CHECK(indeterminate(z != z));
+  BOOST_TEST(indeterminate(z || !z));
+  BOOST_TEST(indeterminate(z == true));
+  BOOST_TEST(indeterminate(true == z));
+  BOOST_TEST(indeterminate(z == false));
+  BOOST_TEST(indeterminate(false == z));
+  BOOST_TEST(indeterminate(z == indeterminate));
+  BOOST_TEST(indeterminate(indeterminate == z));
+  BOOST_TEST(indeterminate(z != indeterminate));
+  BOOST_TEST(indeterminate(indeterminate != z));
+  BOOST_TEST(indeterminate(z == z));
+  BOOST_TEST(indeterminate(z != z));
 
-  BOOST_CHECK(!(x == y));
-  BOOST_CHECK(x != y);
-  BOOST_CHECK(indeterminate(x == z));
-  BOOST_CHECK(indeterminate(x != z));
-  BOOST_CHECK(indeterminate(y == z));
-  BOOST_CHECK(indeterminate(y != z));
+  BOOST_TEST(!(x == y));
+  BOOST_TEST(x != y);
+  BOOST_TEST(indeterminate(x == z));
+  BOOST_TEST(indeterminate(x != z));
+  BOOST_TEST(indeterminate(y == z));
+  BOOST_TEST(indeterminate(y != z));
 
-  BOOST_CHECK(!(x && y));
-  BOOST_CHECK(x || y);
-  BOOST_CHECK(!(x && z));
-  BOOST_CHECK(indeterminate(y && z));
-  BOOST_CHECK(indeterminate(z && z));
-  BOOST_CHECK(indeterminate(z || z));
-  BOOST_CHECK(indeterminate(x || z));
-  BOOST_CHECK(y || z);
+  BOOST_TEST(!(x && y));
+  BOOST_TEST(x || y);
+  BOOST_TEST(!(x && z));
+  BOOST_TEST(indeterminate(y && z));
+  BOOST_TEST(indeterminate(z && z));
+  BOOST_TEST(indeterminate(z || z));
+  BOOST_TEST(indeterminate(x || z));
+  BOOST_TEST(y || z);
 
-  BOOST_CHECK(indeterminate(y && indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate && y));
-  BOOST_CHECK(!(x && indeterminate));
-  BOOST_CHECK(!(indeterminate && x));
+  BOOST_TEST(indeterminate(y && indeterminate));
+  BOOST_TEST(indeterminate(indeterminate && y));
+  BOOST_TEST(!(x && indeterminate));
+  BOOST_TEST(!(indeterminate && x));
 
-  BOOST_CHECK(indeterminate || y);
-  BOOST_CHECK(y || indeterminate);
-  BOOST_CHECK(indeterminate(x || indeterminate));
-  BOOST_CHECK(indeterminate(indeterminate || x));
+  BOOST_TEST(indeterminate || y);
+  BOOST_TEST(y || indeterminate);
+  BOOST_TEST(indeterminate(x || indeterminate));
+  BOOST_TEST(indeterminate(indeterminate || x));
 
   // Test the if (z) ... else (!z) ... else ... idiom
   if (z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else if (!z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
 
   z = true;
   if (z) {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
   else if (!z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
 
   z = false;
   if (z) {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
   else if (!z) {
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
   }
   else {
-    BOOST_CHECK(false);
+    BOOST_TEST(false);
   }
 
   std::cout << "no errors detected\n";