From ad94c0b247ebc4a5bd35b56652b5f35a16b781b0 Mon Sep 17 00:00:00 2001
From: bolero-MURAKAMI <bolero.murakami@gmail.com>
Date: Mon, 14 Nov 2011 13:22:04 +0900
Subject: [PATCH] =?UTF-8?q?sprout/weed/parser/numeric/*=20=E6=9B=B4?=
 =?UTF-8?q?=E6=96=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 sprout/weed/detail/bdigits.hpp        |  88 +++++++++++++++
 sprout/weed/detail/digits.hpp         |  88 +++++++++++++++
 sprout/weed/detail/ndigits.hpp        |  52 +++++++++
 sprout/weed/detail/odigits.hpp        |  88 +++++++++++++++
 sprout/weed/detail/xdigits.hpp        |   2 +
 sprout/weed/parser/numeric.hpp        |   4 +
 sprout/weed/parser/numeric/bin.hpp    |  40 +++++++
 sprout/weed/parser/numeric/hex.hpp    | 122 +++-----------------
 sprout/weed/parser/numeric/oct.hpp    |  40 +++++++
 sprout/weed/parser/numeric/uint.hpp   |  29 +++++
 sprout/weed/parser/numeric/uint_p.hpp | 157 ++++++++++++++++++++++++++
 11 files changed, 603 insertions(+), 107 deletions(-)
 create mode 100644 sprout/weed/detail/bdigits.hpp
 create mode 100644 sprout/weed/detail/digits.hpp
 create mode 100644 sprout/weed/detail/ndigits.hpp
 create mode 100644 sprout/weed/detail/odigits.hpp
 create mode 100644 sprout/weed/parser/numeric/bin.hpp
 create mode 100644 sprout/weed/parser/numeric/oct.hpp
 create mode 100644 sprout/weed/parser/numeric/uint.hpp
 create mode 100644 sprout/weed/parser/numeric/uint_p.hpp

diff --git a/sprout/weed/detail/bdigits.hpp b/sprout/weed/detail/bdigits.hpp
new file mode 100644
index 00000000..71c1b0d7
--- /dev/null
+++ b/sprout/weed/detail/bdigits.hpp
@@ -0,0 +1,88 @@
+#ifndef SPROUT_WEED_DETAIL_BDIGITS_HPP
+#define SPROUT_WEED_DETAIL_BDIGITS_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/string.hpp>
+#include <sprout/array.hpp>
+#include <sprout/tuple/tuple.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT_DETAIL
+#include HDR_ITERATOR_SSCRISK_CEL_OR_SPROUT_DETAIL
+
+namespace sprout {
+	namespace weed {
+		namespace detail {
+			template<typename Elem>
+			struct bdigits;
+
+			template<>
+			struct bdigits<char> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<char, 2> table = sprout::to_string("01");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<char, 2> sprout::weed::detail::bdigits<char>::table;
+
+			template<>
+			struct bdigits<wchar_t> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<wchar_t, 2> table = sprout::to_string(L"01");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<wchar_t, 2> sprout::weed::detail::bdigits<wchar_t>::table;
+
+			template<>
+			struct bdigits<char16_t> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<char16_t, 2> table = sprout::to_string(u"01");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<char16_t, 2> sprout::weed::detail::bdigits<char16_t>::table;
+
+			template<>
+			struct bdigits<char32_t> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<char32_t, 2> table = sprout::to_string(U"01");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<char32_t, 2> sprout::weed::detail::bdigits<char32_t>::table;
+
+			template<typename Dummy>
+			struct bvalues;
+
+			template<>
+			struct bvalues<void> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::array<std::uint8_t, 2> table = sprout::array<std::uint8_t, 2>{
+					{0, 1}
+					};
+			};
+			SPROUT_CONSTEXPR sprout::array<std::uint8_t, 2> sprout::weed::detail::bvalues<void>::table;
+
+			template<typename IntType>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> bvalue_at(std::size_t i) {
+				return i < 2
+					? sprout::tuples::tuple<IntType, bool>(
+						static_cast<IntType>(sprout::weed::detail::bvalues<void>::table[i]),
+						true
+						)
+					: sprout::tuples::tuple<IntType, bool>(
+						IntType(),
+						false
+						)
+					;
+			}
+			template<typename IntType, typename Elem>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> from_bdigit(Elem c) {
+				return sprout::weed::detail::bvalue_at<IntType>(
+					NS_SSCRISK_CEL_OR_SPROUT_DETAIL::distance(
+						sprout::weed::detail::bdigits<Elem>::table.begin(),
+						NS_SSCRISK_CEL_OR_SPROUT_DETAIL::find(
+							sprout::weed::detail::bdigits<Elem>::table.begin(),
+							sprout::weed::detail::bdigits<Elem>::table.end(),
+							c
+							)
+						)
+					);
+			}
+		}	// namespace detail
+	}	// namespace weed
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_WEED_DETAIL_BDIGITS_HPP
diff --git a/sprout/weed/detail/digits.hpp b/sprout/weed/detail/digits.hpp
new file mode 100644
index 00000000..adaea7c5
--- /dev/null
+++ b/sprout/weed/detail/digits.hpp
@@ -0,0 +1,88 @@
+#ifndef SPROUT_WEED_DETAIL_DIGITS_HPP
+#define SPROUT_WEED_DETAIL_DIGITS_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/string.hpp>
+#include <sprout/array.hpp>
+#include <sprout/tuple/tuple.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT_DETAIL
+#include HDR_ITERATOR_SSCRISK_CEL_OR_SPROUT_DETAIL
+
+namespace sprout {
+	namespace weed {
+		namespace detail {
+			template<typename Elem>
+			struct digits;
+
+			template<>
+			struct digits<char> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<char, 10> table = sprout::to_string("0123456789");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<char, 10> sprout::weed::detail::digits<char>::table;
+
+			template<>
+			struct digits<wchar_t> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<wchar_t, 10> table = sprout::to_string(L"0123456789");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<wchar_t, 10> sprout::weed::detail::digits<wchar_t>::table;
+
+			template<>
+			struct digits<char16_t> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<char16_t, 10> table = sprout::to_string(u"0123456789");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<char16_t, 10> sprout::weed::detail::digits<char16_t>::table;
+
+			template<>
+			struct digits<char32_t> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<char32_t, 10> table = sprout::to_string(U"0123456789");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<char32_t, 10> sprout::weed::detail::digits<char32_t>::table;
+
+			template<typename Dummy>
+			struct values;
+
+			template<>
+			struct values<void> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::array<std::uint8_t, 10> table = sprout::array<std::uint8_t, 10>{
+					{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+					};
+			};
+			SPROUT_CONSTEXPR sprout::array<std::uint8_t, 10> sprout::weed::detail::values<void>::table;
+
+			template<typename IntType>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> value_at(std::size_t i) {
+				return i < 10
+					? sprout::tuples::tuple<IntType, bool>(
+						static_cast<IntType>(sprout::weed::detail::values<void>::table[i]),
+						true
+						)
+					: sprout::tuples::tuple<IntType, bool>(
+						IntType(),
+						false
+						)
+					;
+			}
+			template<typename IntType, typename Elem>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> from_digit(Elem c) {
+				return sprout::weed::detail::value_at<IntType>(
+					NS_SSCRISK_CEL_OR_SPROUT_DETAIL::distance(
+						sprout::weed::detail::digits<Elem>::table.begin(),
+						NS_SSCRISK_CEL_OR_SPROUT_DETAIL::find(
+							sprout::weed::detail::digits<Elem>::table.begin(),
+							sprout::weed::detail::digits<Elem>::table.end(),
+							c
+							)
+						)
+					);
+			}
+		}	// namespace detail
+	}	// namespace weed
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_WEED_DETAIL_DIGITS_HPP
diff --git a/sprout/weed/detail/ndigits.hpp b/sprout/weed/detail/ndigits.hpp
new file mode 100644
index 00000000..430fe59a
--- /dev/null
+++ b/sprout/weed/detail/ndigits.hpp
@@ -0,0 +1,52 @@
+#ifndef SPROUT_WEED_DETAIL_NDIGITS_HPP
+#define SPROUT_WEED_DETAIL_NDIGITS_HPP
+
+#include <cstddef>
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/tuple/tuple.hpp>
+#include <sprout/weed/detail/digits.hpp>
+#include <sprout/weed/detail/bdigits.hpp>
+#include <sprout/weed/detail/odigits.hpp>
+#include <sprout/weed/detail/xdigits.hpp>
+
+namespace sprout {
+	namespace weed {
+		namespace detail {
+			template<std::size_t Radix, typename IntType, typename Elem>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> from_ndigit(
+				Elem c,
+				typename std::enable_if<Radix == 10>::type* = 0
+				)
+			{
+				return sprout::weed::detail::from_digit<IntType>(c);
+			}
+			template<std::size_t Radix, typename IntType, typename Elem>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> from_ndigit(
+				Elem c,
+				typename std::enable_if<Radix == 2>::type* = 0
+				)
+			{
+				return sprout::weed::detail::from_bdigit<IntType>(c);
+			}
+			template<std::size_t Radix, typename IntType, typename Elem>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> from_ndigit(
+				Elem c,
+				typename std::enable_if<Radix == 8>::type* = 0
+				)
+			{
+				return sprout::weed::detail::from_odigit<IntType>(c);
+			}
+			template<std::size_t Radix, typename IntType, typename Elem>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> from_ndigit(
+				Elem c,
+				typename std::enable_if<Radix == 16>::type* = 0
+				)
+			{
+				return sprout::weed::detail::from_xdigit<IntType>(c);
+			}
+		}	// namespace detail
+	}	// namespace weed
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_WEED_DETAIL_NDIGITS_HPP
diff --git a/sprout/weed/detail/odigits.hpp b/sprout/weed/detail/odigits.hpp
new file mode 100644
index 00000000..ea692df0
--- /dev/null
+++ b/sprout/weed/detail/odigits.hpp
@@ -0,0 +1,88 @@
+#ifndef SPROUT_WEED_DETAIL_ODIGITS_HPP
+#define SPROUT_WEED_DETAIL_ODIGITS_HPP
+
+#include <type_traits>
+#include <sprout/config.hpp>
+#include <sprout/string.hpp>
+#include <sprout/array.hpp>
+#include <sprout/tuple/tuple.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT_DETAIL
+#include HDR_ITERATOR_SSCRISK_CEL_OR_SPROUT_DETAIL
+
+namespace sprout {
+	namespace weed {
+		namespace detail {
+			template<typename Elem>
+			struct odigits;
+
+			template<>
+			struct odigits<char> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<char, 8> table = sprout::to_string("01234567");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<char, 8> sprout::weed::detail::odigits<char>::table;
+
+			template<>
+			struct odigits<wchar_t> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<wchar_t, 8> table = sprout::to_string(L"01234567");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<wchar_t, 8> sprout::weed::detail::odigits<wchar_t>::table;
+
+			template<>
+			struct odigits<char16_t> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<char16_t, 8> table = sprout::to_string(u"01234567");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<char16_t, 8> sprout::weed::detail::odigits<char16_t>::table;
+
+			template<>
+			struct odigits<char32_t> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::basic_string<char32_t, 8> table = sprout::to_string(U"01234567");
+			};
+			SPROUT_CONSTEXPR sprout::basic_string<char32_t, 8> sprout::weed::detail::odigits<char32_t>::table;
+
+			template<typename Dummy>
+			struct ovalues;
+
+			template<>
+			struct ovalues<void> {
+			public:
+				SPROUT_STATIC_CONSTEXPR sprout::array<std::uint8_t, 8> table = sprout::array<std::uint8_t, 8>{
+					{0, 1, 2, 3, 4, 5, 6, 7}
+					};
+			};
+			SPROUT_CONSTEXPR sprout::array<std::uint8_t, 8> sprout::weed::detail::ovalues<void>::table;
+
+			template<typename IntType>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> ovalue_at(std::size_t i) {
+				return i < 8
+					? sprout::tuples::tuple<IntType, bool>(
+						static_cast<IntType>(sprout::weed::detail::ovalues<void>::table[i]),
+						true
+						)
+					: sprout::tuples::tuple<IntType, bool>(
+						IntType(),
+						false
+						)
+					;
+			}
+			template<typename IntType, typename Elem>
+			SPROUT_CONSTEXPR sprout::tuples::tuple<IntType, bool> from_odigit(Elem c) {
+				return sprout::weed::detail::ovalue_at<IntType>(
+					NS_SSCRISK_CEL_OR_SPROUT_DETAIL::distance(
+						sprout::weed::detail::odigits<Elem>::table.begin(),
+						NS_SSCRISK_CEL_OR_SPROUT_DETAIL::find(
+							sprout::weed::detail::odigits<Elem>::table.begin(),
+							sprout::weed::detail::odigits<Elem>::table.end(),
+							c
+							)
+						)
+					);
+			}
+		}	// namespace detail
+	}	// namespace weed
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_WEED_DETAIL_ODIGITS_HPP
diff --git a/sprout/weed/detail/xdigits.hpp b/sprout/weed/detail/xdigits.hpp
index 319c9b80..948c7f1e 100644
--- a/sprout/weed/detail/xdigits.hpp
+++ b/sprout/weed/detail/xdigits.hpp
@@ -6,6 +6,8 @@
 #include <sprout/string.hpp>
 #include <sprout/array.hpp>
 #include <sprout/tuple/tuple.hpp>
+#include HDR_ALGORITHM_SSCRISK_CEL_OR_SPROUT_DETAIL
+#include HDR_ITERATOR_SSCRISK_CEL_OR_SPROUT_DETAIL
 
 namespace sprout {
 	namespace weed {
diff --git a/sprout/weed/parser/numeric.hpp b/sprout/weed/parser/numeric.hpp
index 5ebc6083..b38c4962 100644
--- a/sprout/weed/parser/numeric.hpp
+++ b/sprout/weed/parser/numeric.hpp
@@ -2,6 +2,10 @@
 #define SPROUT_WEED_PARSER_NUMERIC_HPP
 
 #include <sprout/config.hpp>
+#include <sprout/weed/parser/numeric/uint_p.hpp>
+#include <sprout/weed/parser/numeric/uint.hpp>
+#include <sprout/weed/parser/numeric/bin.hpp>
+#include <sprout/weed/parser/numeric/oct.hpp>
 #include <sprout/weed/parser/numeric/hex.hpp>
 
 #endif	// #ifndef SPROUT_WEED_PARSER_NUMERIC_HPP
diff --git a/sprout/weed/parser/numeric/bin.hpp b/sprout/weed/parser/numeric/bin.hpp
new file mode 100644
index 00000000..92cb05c5
--- /dev/null
+++ b/sprout/weed/parser/numeric/bin.hpp
@@ -0,0 +1,40 @@
+#ifndef SPROUT_WEED_PARSER_NUMERIC_BIN_HPP
+#define SPROUT_WEED_PARSER_NUMERIC_BIN_HPP
+
+#include <cstdint>
+#include <sprout/config.hpp>
+#include <sprout/integer/integer_digits.hpp>
+#include <sprout/weed/parser/numeric/uint_p.hpp>
+
+namespace sprout {
+	namespace weed {
+		//
+		// bin
+		//
+		SPROUT_STATIC_CONSTEXPR auto bin = sprout::weed::uint_p<std::uintmax_t, 2, -1>();
+
+		//
+		// bin8
+		// bin16
+		// bin32
+		// bin64
+		//
+		SPROUT_STATIC_CONSTEXPR auto bin8 = sprout::weed::uint_p<std::uint8_t, 2>();
+		SPROUT_STATIC_CONSTEXPR auto bin16 = sprout::weed::uint_p<std::uint16_t, 2>();
+		SPROUT_STATIC_CONSTEXPR auto bin32 = sprout::weed::uint_p<std::uint32_t, 2>();
+		SPROUT_STATIC_CONSTEXPR auto bin64 = sprout::weed::uint_p<std::uint64_t, 2>();
+
+		//
+		// bin8f
+		// bin16f
+		// bin32f
+		// bin64f
+		//
+		SPROUT_STATIC_CONSTEXPR auto bin8f = sprout::weed::uint_p<std::uint8_t, 2, sprout::integer_digits<std::uint8_t, 2>::value>();
+		SPROUT_STATIC_CONSTEXPR auto bin16f = sprout::weed::uint_p<std::uint16_t, 2, sprout::integer_digits<std::uint16_t, 2>::value>();
+		SPROUT_STATIC_CONSTEXPR auto bin32f = sprout::weed::uint_p<std::uint32_t, 2, sprout::integer_digits<std::uint32_t, 2>::value>();
+		SPROUT_STATIC_CONSTEXPR auto bin64f = sprout::weed::uint_p<std::uint64_t, 2, sprout::integer_digits<std::uint64_t, 2>::value>();
+	}	// namespace weed
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_WEED_PARSER_NUMERIC_BIN_HPP
diff --git a/sprout/weed/parser/numeric/hex.hpp b/sprout/weed/parser/numeric/hex.hpp
index a2ddf42a..827bb714 100644
--- a/sprout/weed/parser/numeric/hex.hpp
+++ b/sprout/weed/parser/numeric/hex.hpp
@@ -1,131 +1,39 @@
 #ifndef SPROUT_WEED_PARSER_NUMERIC_HEX_HPP
 #define SPROUT_WEED_PARSER_NUMERIC_HEX_HPP
 
-#include <cstddef>
+#include <cstdint>
 #include <sprout/config.hpp>
-#include <sprout/iterator/next.hpp>
-#include <sprout/tuple/tuple.hpp>
-#include <sprout/weed/unused.hpp>
-#include <sprout/weed/parser_result.hpp>
-#include <sprout/weed/parser/parser_base.hpp>
-#include <sprout/weed/detail/xdigits.hpp>
+#include <sprout/integer/integer_digits.hpp>
+#include <sprout/weed/parser/numeric/uint_p.hpp>
 
 namespace sprout {
 	namespace weed {
 		//
-		// hex_p
+		// hex
 		//
-		template<typename IntType, std::size_t Min = sizeof(IntType) * 2, std::size_t Max = sizeof(IntType) * 2>
-		struct hex_p
-			: public sprout::weed::parser_base
-		{
-		public:
-			template<typename Context, typename Iterator>
-			struct attribute {
-			public:
-				typedef IntType type;
-			};
-			template<typename Context, typename Iterator>
-			struct result {
-			public:
-				typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type;
-			};
-		private:
-			template<std::size_t N, typename Context, typename Iterator, typename PResult>
-			SPROUT_CONSTEXPR typename std::enable_if<
-				N == Max,
-				typename result<Context, Iterator>::type
-			>::type call_1(Iterator first, Iterator last, Iterator temp_first, IntType t, PResult const& res) const {
-				typedef typename result<Context, Iterator>::type result_type;
-				typedef typename attribute<Context, Iterator>::type attribute_type;
-				return sprout::tuples::get<1>(res)
-					? result_type(true, sprout::next(first), static_cast<IntType>(t << 4 | sprout::tuples::get<0>(res)))
-					: N < Min
-						? result_type(false, temp_first, attribute_type())
-						: result_type(true, first, t)
-					;
-			}
-			template<std::size_t N, typename Context, typename Iterator, typename PResult>
-			SPROUT_CONSTEXPR typename std::enable_if<
-				N != Max,
-				typename result<Context, Iterator>::type
-			>::type call_1(Iterator first, Iterator last, Iterator temp_first, IntType t, PResult const& res) const {
-				typedef typename result<Context, Iterator>::type result_type;
-				typedef typename attribute<Context, Iterator>::type attribute_type;
-				return sprout::tuples::get<1>(res)
-					? call_0<N, Context>(sprout::next(first), last, temp_first, static_cast<IntType>(t << 4 | sprout::tuples::get<0>(res)))
-					: N < Min
-						? result_type(false, temp_first, attribute_type())
-						: result_type(true, first, t)
-					;
-			}
-			template<std::size_t N, typename Context, typename Iterator>
-			SPROUT_CONSTEXPR typename result<Context, Iterator>::type call_0(Iterator first, Iterator last, Iterator temp_first, IntType t) const {
-				typedef typename result<Context, Iterator>::type result_type;
-				typedef typename attribute<Context, Iterator>::type attribute_type;
-				return first != last
-					? call_1<N + 1, Context>(first, last, temp_first, t, sprout::weed::detail::from_xdigit<IntType>(*first))
-					: N < Min
-						? result_type(false, temp_first, attribute_type())
-						: result_type(true, first, t)
-					;
-			}
-			template<typename Context, typename Iterator, typename PResult>
-			SPROUT_CONSTEXPR typename result<Context, Iterator>::type call(Iterator first, Iterator last, Iterator temp_first, PResult const& res) const {
-				typedef typename result<Context, Iterator>::type result_type;
-				typedef typename attribute<Context, Iterator>::type attribute_type;
-				return sprout::tuples::get<1>(res)
-					? call_0<1, Context>(sprout::next(first), last, temp_first, sprout::tuples::get<0>(res))
-					: result_type(false, temp_first, attribute_type())
-					;
-			}
-		public:
-			template<typename Context, typename Iterator>
-			SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()(Iterator first, Iterator last, Context const&) const {
-				typedef typename result<Context, Iterator>::type result_type;
-				typedef typename attribute<Context, Iterator>::type attribute_type;
-				return first != last
-					? call<Context>(first, last, first, sprout::weed::detail::from_xdigit<IntType>(*first))
-					: result_type(false, first, attribute_type())
-					;
-			}
-		};
+		SPROUT_STATIC_CONSTEXPR auto hex = sprout::weed::uint_p<std::uintmax_t, 16, -1>();
+
 		//
 		// hex8
 		// hex16
 		// hex32
 		// hex64
-		// uhex8
-		// uhex16
-		// uhex32
-		// uhex64
 		//
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::int8_t, 1> hex8 = sprout::weed::hex_p<std::int8_t, 1>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::int16_t, 1> hex16 = sprout::weed::hex_p<std::int16_t, 1>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::int32_t, 1> hex32 = sprout::weed::hex_p<std::int32_t, 1>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::int64_t, 1> hex64 = sprout::weed::hex_p<std::int64_t, 1>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::uint8_t, 1> uhex8 = sprout::weed::hex_p<std::uint8_t, 1>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::uint16_t, 1> uhex16 = sprout::weed::hex_p<std::uint16_t, 1>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::uint32_t, 1> uhex32 = sprout::weed::hex_p<std::uint32_t, 1>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::uint64_t, 1> uhex64 = sprout::weed::hex_p<std::uint64_t, 1>();
+		SPROUT_STATIC_CONSTEXPR auto hex8 = sprout::weed::uint_p<std::uint8_t, 16>();
+		SPROUT_STATIC_CONSTEXPR auto hex16 = sprout::weed::uint_p<std::uint16_t, 16>();
+		SPROUT_STATIC_CONSTEXPR auto hex32 = sprout::weed::uint_p<std::uint32_t, 16>();
+		SPROUT_STATIC_CONSTEXPR auto hex64 = sprout::weed::uint_p<std::uint64_t, 16>();
+
 		//
 		// hex8f
 		// hex16f
 		// hex32f
 		// hex64f
-		// uhex8f
-		// uhex16f
-		// uhex32f
-		// uhex64f
 		//
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::int8_t> hex8f = sprout::weed::hex_p<std::int8_t>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::int16_t> hex16f = sprout::weed::hex_p<std::int16_t>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::int32_t> hex32f = sprout::weed::hex_p<std::int32_t>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::int64_t> hex64f = sprout::weed::hex_p<std::int64_t>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::uint8_t> uhex8f = sprout::weed::hex_p<std::uint8_t>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::uint16_t> uhex16f = sprout::weed::hex_p<std::uint16_t>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::uint32_t> uhex32f = sprout::weed::hex_p<std::uint32_t>();
-		SPROUT_STATIC_CONSTEXPR sprout::weed::hex_p<std::uint64_t> uhex64f = sprout::weed::hex_p<std::uint64_t>();
+		SPROUT_STATIC_CONSTEXPR auto hex8f = sprout::weed::uint_p<std::uint8_t, 16, sprout::integer_digits<std::uint8_t, 16>::value>();
+		SPROUT_STATIC_CONSTEXPR auto hex16f = sprout::weed::uint_p<std::uint16_t, 16, sprout::integer_digits<std::uint16_t, 16>::value>();
+		SPROUT_STATIC_CONSTEXPR auto hex32f = sprout::weed::uint_p<std::uint32_t, 16, sprout::integer_digits<std::uint32_t, 16>::value>();
+		SPROUT_STATIC_CONSTEXPR auto hex64f = sprout::weed::uint_p<std::uint64_t, 16, sprout::integer_digits<std::uint64_t, 16>::value>();
 	}	// namespace weed
 }	// namespace sprout
 
diff --git a/sprout/weed/parser/numeric/oct.hpp b/sprout/weed/parser/numeric/oct.hpp
new file mode 100644
index 00000000..8d65a4eb
--- /dev/null
+++ b/sprout/weed/parser/numeric/oct.hpp
@@ -0,0 +1,40 @@
+#ifndef SPROUT_WEED_PARSER_NUMERIC_OCT_HPP
+#define SPROUT_WEED_PARSER_NUMERIC_OCT_HPP
+
+#include <cstdint>
+#include <sprout/config.hpp>
+#include <sprout/integer/integer_digits.hpp>
+#include <sprout/weed/parser/numeric/uint_p.hpp>
+
+namespace sprout {
+	namespace weed {
+		//
+		// oct
+		//
+		SPROUT_STATIC_CONSTEXPR auto oct = sprout::weed::uint_p<std::uintmax_t, 8, -1>();
+
+		//
+		// oct8
+		// oct16
+		// oct32
+		// oct64
+		//
+		SPROUT_STATIC_CONSTEXPR auto oct8 = sprout::weed::uint_p<std::uint8_t, 8>();
+		SPROUT_STATIC_CONSTEXPR auto oct16 = sprout::weed::uint_p<std::uint16_t, 8>();
+		SPROUT_STATIC_CONSTEXPR auto oct32 = sprout::weed::uint_p<std::uint32_t, 8>();
+		SPROUT_STATIC_CONSTEXPR auto oct64 = sprout::weed::uint_p<std::uint64_t, 8>();
+
+		//
+		// oct8f
+		// oct16f
+		// oct32f
+		// oct64f
+		//
+		SPROUT_STATIC_CONSTEXPR auto oct8f = sprout::weed::uint_p<std::uint8_t, 8, sprout::integer_digits<std::uint8_t, 8>::value>();
+		SPROUT_STATIC_CONSTEXPR auto oct16f = sprout::weed::uint_p<std::uint16_t, 8, sprout::integer_digits<std::uint16_t, 8>::value>();
+		SPROUT_STATIC_CONSTEXPR auto oct32f = sprout::weed::uint_p<std::uint32_t, 8, sprout::integer_digits<std::uint32_t, 8>::value>();
+		SPROUT_STATIC_CONSTEXPR auto oct64f = sprout::weed::uint_p<std::uint64_t, 8, sprout::integer_digits<std::uint64_t, 8>::value>();
+	}	// namespace weed
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_WEED_PARSER_NUMERIC_OCT_HPP
diff --git a/sprout/weed/parser/numeric/uint.hpp b/sprout/weed/parser/numeric/uint.hpp
new file mode 100644
index 00000000..2bb583ad
--- /dev/null
+++ b/sprout/weed/parser/numeric/uint.hpp
@@ -0,0 +1,29 @@
+#ifndef SPROUT_WEED_PARSER_NUMERIC_UINT_HPP
+#define SPROUT_WEED_PARSER_NUMERIC_UINT_HPP
+
+#include <cstdint>
+#include <sprout/config.hpp>
+#include <sprout/integer/integer_digits.hpp>
+#include <sprout/weed/parser/numeric/uint_p.hpp>
+
+namespace sprout {
+	namespace weed {
+		//
+		// uint
+		//
+		SPROUT_STATIC_CONSTEXPR auto uint = sprout::weed::uint_p<std::uintmax_t, 10, -1>();
+
+		//
+		// uint8
+		// uint16
+		// uint32
+		// uint64
+		//
+		SPROUT_STATIC_CONSTEXPR auto uint8 = sprout::weed::uint_p<std::uint8_t, 10>();
+		SPROUT_STATIC_CONSTEXPR auto uint16 = sprout::weed::uint_p<std::uint16_t, 10>();
+		SPROUT_STATIC_CONSTEXPR auto uint32 = sprout::weed::uint_p<std::uint32_t, 10>();
+		SPROUT_STATIC_CONSTEXPR auto uint64 = sprout::weed::uint_p<std::uint64_t, 10>();
+	}	// namespace weed
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_WEED_PARSER_NUMERIC_UINT_HPP
diff --git a/sprout/weed/parser/numeric/uint_p.hpp b/sprout/weed/parser/numeric/uint_p.hpp
new file mode 100644
index 00000000..8595bc84
--- /dev/null
+++ b/sprout/weed/parser/numeric/uint_p.hpp
@@ -0,0 +1,157 @@
+#ifndef SPROUT_WEED_PARSER_NUMERIC_UINT_P_HPP
+#define SPROUT_WEED_PARSER_NUMERIC_UINT_P_HPP
+
+#include <cstddef>
+#include <sprout/config.hpp>
+#include <sprout/iterator/next.hpp>
+#include <sprout/tuple/tuple.hpp>
+#include <sprout/integer/integer_digits.hpp>
+#include <sprout/weed/unused.hpp>
+#include <sprout/weed/parser_result.hpp>
+#include <sprout/weed/parser/parser_base.hpp>
+#include <sprout/weed/detail/ndigits.hpp>
+
+namespace sprout {
+	namespace weed {
+		//
+		// uint_p
+		//
+		template<
+			typename IntType,
+			std::size_t Radix,
+			std::size_t MinDigits = 1,
+			std::size_t MaxDigits = sprout::integer_digits<IntType, Radix>::value
+		>
+		struct uint_p
+			: public sprout::weed::parser_base
+		{
+		public:
+			template<typename Context, typename Iterator>
+			struct attribute {
+			public:
+				typedef IntType type;
+			};
+			template<typename Context, typename Iterator>
+			struct result {
+			public:
+				typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type;
+			};
+		private:
+			template<std::size_t N, typename Context, typename Iterator, typename PResult>
+			SPROUT_CONSTEXPR typename std::enable_if<
+				N == MaxDigits,
+				typename result<Context, Iterator>::type
+			>::type call_1(
+				Iterator first,
+				Iterator last,
+				Iterator temp_first,
+				IntType t,
+				PResult const& res
+				) const
+			{
+				typedef typename result<Context, Iterator>::type result_type;
+				typedef typename attribute<Context, Iterator>::type attribute_type;
+				return sprout::tuples::get<1>(res)
+					? result_type(
+						true,
+						sprout::next(first),
+						static_cast<IntType>(t * Radix | sprout::tuples::get<0>(res))
+						)
+					: N < MinDigits
+						? result_type(false, temp_first, attribute_type())
+						: result_type(true, first, t)
+					;
+			}
+			template<std::size_t N, typename Context, typename Iterator, typename PResult>
+			SPROUT_CONSTEXPR typename std::enable_if<
+				N != MaxDigits,
+				typename result<Context, Iterator>::type
+			>::type call_1(
+				Iterator first,
+				Iterator last,
+				Iterator temp_first,
+				IntType t,
+				PResult const& res
+				) const
+			{
+				typedef typename result<Context, Iterator>::type result_type;
+				typedef typename attribute<Context, Iterator>::type attribute_type;
+				return sprout::tuples::get<1>(res)
+					? call_0<N, Context>(
+						sprout::next(first),
+						last, temp_first,
+						static_cast<IntType>(t * Radix | sprout::tuples::get<0>(res))
+						)
+					: N < MinDigits
+						? result_type(false, temp_first, attribute_type())
+						: result_type(true, first, t)
+					;
+			}
+			template<std::size_t N, typename Context, typename Iterator>
+			SPROUT_CONSTEXPR typename result<Context, Iterator>::type call_0(
+				Iterator first,
+				Iterator last,
+				Iterator temp_first,
+				IntType t
+				) const
+			{
+				typedef typename result<Context, Iterator>::type result_type;
+				typedef typename attribute<Context, Iterator>::type attribute_type;
+				return first != last
+					? call_1<N + 1, Context>(
+						first,
+						last,
+						temp_first,
+						t,
+						sprout::weed::detail::from_ndigit<Radix, IntType>(*first)
+						)
+					: N < MinDigits
+						? result_type(false, temp_first, attribute_type())
+						: result_type(true, first, t)
+					;
+			}
+			template<typename Context, typename Iterator, typename PResult>
+			SPROUT_CONSTEXPR typename result<Context, Iterator>::type call(
+				Iterator first,
+				Iterator last,
+				Iterator temp_first,
+				PResult const& res
+				) const
+			{
+				typedef typename result<Context, Iterator>::type result_type;
+				typedef typename attribute<Context, Iterator>::type attribute_type;
+				return sprout::tuples::get<1>(res)
+					? call_0<1, Context>(
+						sprout::next(first),
+						last,
+						temp_first,
+						sprout::tuples::get<0>(res)
+						)
+					: result_type(false, temp_first, attribute_type())
+					;
+			}
+		public:
+			template<typename Context, typename Iterator>
+			SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()(
+				Iterator first,
+				Iterator last,
+				Context const&
+				) const
+			{
+				typedef typename result<Context, Iterator>::type result_type;
+				typedef typename attribute<Context, Iterator>::type attribute_type;
+				return first != last
+					? call<Context>(
+						first,
+						last,
+						first,
+						sprout::weed::detail::from_ndigit<Radix, IntType>(*first)
+						)
+					: result_type(false, first, attribute_type())
+					;
+			}
+		};
+	}	// namespace weed
+}	// namespace sprout
+
+#endif	// #ifndef SPROUT_WEED_PARSER_NUMERIC_UINT_P_HPP