binary.h

00001 ///\file
00002 
00003 /******************************************************************************
00004 The MIT License(MIT)
00005 
00006 Embedded Template Library.
00007 https://github.com/ETLCPP/etl
00008 http://www.etlcpp.com
00009 
00010 Copyright(c) 2015 jwellbelove
00011 
00012 Permission is hereby granted, free of charge, to any person obtaining a copy
00013 of this software and associated documentation files(the "Software"), to deal
00014 in the Software without restriction, including without limitation the rights
00015 to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
00016 copies of the Software, and to permit persons to whom the Software is
00017 furnished to do so, subject to the following conditions :
00018 
00019 The above copyright notice and this permission notice shall be included in all
00020 copies or substantial portions of the Software.
00021 
00022 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00023 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00024 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
00025 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00026 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00027 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
00028 SOFTWARE.
00029 ******************************************************************************/
00030 
00031 #ifndef __ETL_BINARY__
00032 #define __ETL_BINARY__
00033 
00034 ///\defgroup binary binary
00035 /// Binary utilities
00036 ///\ingroup utilities
00037 
00038 #include <limits>
00039 #include <assert.h>
00040 
00041 #include "platform.h "
00042 #include "type_traits.h "
00043 #include "integral_limits.h "
00044 #include "static_assert.h"
00045 #include "log.h "
00046 #include "power.h "
00047 #include "smallest.h "
00048 #include "platform.h "
00049 
00050 namespace etl
00051 {
00052   //***************************************************************************
00053   /// Maximum value that can be contained in N bits.
00054   //***************************************************************************
00055   /// Definition for non-zero NBITS.
00056   template <const size_t NBITS>
00057   struct max_value_for_nbits
00058   {
00059     typedef typename etl::smallest_uint_for_bits<NBITS>::type value_type;
00060     static const value_type value = (value_type(1) << (NBITS - 1)) | max_value_for_nbits<NBITS - 1>::value;
00061   };
00062 
00063   /// Specialisation for when NBITS == 0.
00064   template <>
00065   struct max_value_for_nbits<0>
00066   {
00067       typedef etl::smallest_uint_for_bits<0>::type value_type;
00068       static const value_type value = 0;
00069   };
00070 
00071   template <const size_t NBITS>
00072   const typename max_value_for_nbits<NBITS>::value_type max_value_for_nbits<NBITS>::value;
00073 
00074   //***************************************************************************
00075   /// Rotate left.
00076   //***************************************************************************
00077   template <typename T>
00078   T rotate_left(T value)
00079   {
00080     STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
00081 
00082     const size_t SHIFT = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits - 1;
00083 
00084     return (value << 1) | (value >> SHIFT);
00085   }
00086 
00087   //***************************************************************************
00088   /// Rotate left.
00089   //***************************************************************************
00090   template <typename T>
00091   T rotate_left(T value, size_t distance)
00092   {
00093     STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
00094 
00095     const size_t BITS = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits;
00096     distance %= BITS;
00097     const size_t SHIFT = BITS - distance;
00098 
00099     return (value << distance) | (value >> SHIFT);
00100   }
00101 
00102   //***************************************************************************
00103   /// Rotate right.
00104   //***************************************************************************
00105   template <typename T>
00106   T rotate_right(T value)
00107   {
00108     STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
00109 
00110     const size_t SHIFT = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits - 1;
00111 
00112     return (value >> 1) | (value << SHIFT);
00113   }
00114 
00115   //***************************************************************************
00116   /// Rotate right.
00117   //***************************************************************************
00118   template <typename T>
00119   T rotate_right(T value, size_t distance)
00120   {
00121     STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
00122 
00123     const size_t BITS = etl::integral_limits<typename etl::make_unsigned<T>::type>::bits;
00124     distance %= BITS;
00125     const size_t SHIFT = BITS - distance;
00126 
00127     return (value >> distance) | (value << SHIFT);
00128   }
00129 
00130   //***************************************************************************
00131   /// Rotate.
00132   /// Positive is left, negative is right.
00133   //***************************************************************************
00134   template <typename T>
00135   T rotate(T value, typename etl::make_signed<size_t>::type distance)
00136   {
00137     STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
00138 
00139     T result;
00140 
00141     if (distance > 0)
00142     {
00143       result = rotate_left(value, size_t(distance));
00144     }
00145     else
00146     {
00147       result = rotate_right(value, size_t(-distance));
00148     }
00149 
00150     return result;
00151   }
00152 
00153   //***************************************************************************
00154   /// Reverse bits.
00155   //***************************************************************************
00156 #if ETL_8BIT_SUPPORT
00157   uint8_t reverse_bits(uint8_t value);
00158   inline int8_t reverse_bits(int8_t value) { return int8_t(reverse_bits(uint8_t(value))); }
00159 #endif
00160   uint16_t reverse_bits(uint16_t value);
00161   inline int16_t reverse_bits(int16_t value) { return int16_t(reverse_bits(uint16_t(value))); }
00162   uint32_t reverse_bits(uint32_t value);
00163   inline int32_t reverse_bits(int32_t value) { return int32_t(reverse_bits(uint32_t(value))); }
00164   uint64_t reverse_bits(uint64_t value);
00165   inline int64_t reverse_bits(int64_t value) { return int64_t(reverse_bits(uint64_t(value))); }
00166 
00167   //***************************************************************************
00168   /// Reverse bytes.
00169   //***************************************************************************
00170 #if ETL_8BIT_SUPPORT
00171   inline uint8_t reverse_bytes(uint8_t value) { return value; }
00172   inline int8_t reverse_bytes(int8_t value) { return value; }
00173 #endif
00174   uint16_t reverse_bytes(uint16_t value);
00175   inline int16_t reverse_bytes(int16_t value) { return int16_t(reverse_bytes(uint16_t(value))); }
00176   uint32_t reverse_bytes(uint32_t value);
00177   inline int32_t reverse_bytes(int32_t value) { return int32_t(reverse_bytes(uint32_t(value))); }
00178   uint64_t reverse_bytes(uint64_t value);
00179   inline int64_t reverse_bytes(int64_t value) { return int64_t(reverse_bytes(uint64_t(value))); }
00180 
00181   //***************************************************************************
00182   /// Converts binary to Gray code.
00183   //***************************************************************************
00184   template <typename T>
00185   T binary_to_gray(T value)
00186   {
00187     STATIC_ASSERT(etl::is_integral<T>::value, "Not an integral type");
00188 
00189     return (value >> 1) ^ value;
00190   }
00191 
00192   //***************************************************************************
00193   /// Converts Gray code to binary.
00194   //***************************************************************************
00195 #if ETL_8BIT_SUPPORT
00196   uint8_t gray_to_binary(uint8_t value);
00197   inline int8_t gray_to_binary(int8_t value) { return int8_t(gray_to_binary(uint8_t(value))); }
00198 #endif
00199   uint16_t gray_to_binary(uint16_t value);
00200   inline int16_t gray_to_binary(int16_t value) { return int16_t(gray_to_binary(uint16_t(value))); }
00201   uint32_t gray_to_binary(uint32_t value);
00202   inline int32_t gray_to_binary(int32_t value) { return int32_t(gray_to_binary(uint32_t(value))); }
00203   uint64_t gray_to_binary(uint64_t value);
00204   inline int64_t gray_to_binary(int64_t value) { return int64_t(gray_to_binary(uint64_t(value))); }
00205 
00206   //***************************************************************************
00207   /// Count set bits.
00208   //***************************************************************************
00209 #if ETL_8BIT_SUPPORT
00210   uint_least8_t count_bits(uint8_t value);
00211   inline uint_least8_t count_bits(int8_t value) { return count_bits(uint8_t(value)); }
00212 #endif
00213   uint_least8_t count_bits(uint16_t value);
00214   inline uint_least8_t count_bits(int16_t value) { return count_bits(uint16_t(value)); }
00215   uint_least8_t count_bits(uint32_t value);
00216   inline uint_least8_t count_bits(int32_t value) { return count_bits(uint32_t(value)); }
00217   uint_least8_t count_bits(uint64_t value);
00218   inline uint_least8_t count_bits(int64_t value) { return count_bits(uint64_t(value)); }
00219 
00220   //***************************************************************************
00221   /// Parity. 0 = even, 1 = odd
00222   //***************************************************************************
00223 #if ETL_8BIT_SUPPORT
00224   uint_least8_t parity(uint8_t value);
00225   inline uint_least8_t parity(int8_t value) { return parity(uint8_t(value)); }
00226 #endif
00227   uint_least8_t parity(uint16_t value);
00228   inline uint_least8_t parity(int16_t value) { return parity(uint16_t(value)); }
00229   uint_least8_t parity(uint32_t value);
00230   inline uint_least8_t parity(int32_t value) { return parity(uint32_t(value)); }
00231   uint_least8_t parity(uint64_t value);
00232   inline uint_least8_t parity(int64_t value) { return parity(uint64_t(value)); }
00233 
00234   //***************************************************************************
00235   /// Fold a binary number down to a set number of bits using XOR.
00236   //***************************************************************************
00237   template <typename TReturn, const size_t NBITS, typename TValue>
00238   TReturn fold_bits(TValue value)
00239   {
00240     STATIC_ASSERT(integral_limits<TReturn>::bits >= NBITS, "Return type too small to hold result");
00241 
00242     const TValue mask  = etl::power<2, NBITS>::value - 1;
00243     const size_t shift = NBITS;
00244 
00245     // Fold the value down to fit the width.
00246     TReturn folded_value = 0;
00247 
00248     // Keep shifting down and XORing the lower bits.
00249     while (value >= etl::max_value_for_nbits<NBITS>::value)
00250     {
00251       folded_value ^= value & mask;
00252       value >>= shift;
00253     }
00254 
00255     // Fold the remaining bits.
00256     folded_value ^= value & mask;
00257 
00258     return folded_value;
00259   }
00260 
00261   //***************************************************************************
00262   /// Sign extend.
00263   /// Converts an N bit binary number, where bit N-1 is the sign bit, to a signed integral type.
00264   //***************************************************************************
00265   template <typename TReturn, const size_t NBITS, typename TValue>
00266   TReturn sign_extend(TValue value)
00267   {
00268     STATIC_ASSERT(etl::is_integral<TValue>::value,  "TValue not an integral type");
00269     STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
00270     STATIC_ASSERT(etl::is_signed<TReturn>::value,   "TReturn not a signed type");
00271     STATIC_ASSERT(NBITS <= std::numeric_limits<TReturn>::digits, "NBITS too large for return type");
00272 
00273     const TReturn negative = (TReturn(1) << (NBITS - 1));
00274     TReturn signed_value = value & ((1 << NBITS) - 1);
00275 
00276     if ((signed_value & negative) != 0)
00277     {
00278       const TReturn sign_bits = ~((TReturn(1) << NBITS) - 1);
00279       signed_value |= sign_bits;
00280     }
00281 
00282     return signed_value;
00283   }
00284 
00285   //***************************************************************************
00286   /// Sign extend.
00287   /// Converts an N bit binary number, where bit N-1 is the sign bit, and SHIFT
00288   /// is the right shift amount, to a signed integral type.
00289   //***************************************************************************
00290   template <typename TReturn, const size_t NBITS, const size_t SHIFT, typename TValue>
00291   TReturn sign_extend(TValue value)
00292   {
00293     STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
00294     STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
00295     STATIC_ASSERT(etl::is_signed<TReturn>::value, "TReturn not a signed type");
00296     STATIC_ASSERT(NBITS <= std::numeric_limits<TReturn>::digits, "NBITS too large for return type");
00297     STATIC_ASSERT(SHIFT <= std::numeric_limits<TReturn>::digits, "SHIFT too large");
00298 
00299     const TReturn negative = (TReturn(1) << (NBITS - 1));
00300     TReturn signed_value = (value >> SHIFT) & ((1 << NBITS) - 1);
00301 
00302     if ((signed_value & negative) != 0)
00303     {
00304       const TReturn sign_bits = ~((TReturn(1) << NBITS) - 1);
00305       signed_value |= sign_bits;
00306     }
00307 
00308     return signed_value;
00309   }
00310 
00311   //***************************************************************************
00312   /// Sign extend.
00313   /// Converts an N bit binary number, where bit N-1 is the sign bit, to a signed integral type.
00314   //***************************************************************************
00315   template <typename TReturn, typename TValue>
00316   TReturn sign_extend(TValue value, const size_t NBITS)
00317   {
00318     STATIC_ASSERT(etl::is_integral<TValue>::value,  "TValue not an integral type");
00319     STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
00320     STATIC_ASSERT(etl::is_signed<TReturn>::value,   "TReturn not a signed type");
00321     assert(NBITS <= std::numeric_limits<TReturn>::digits);
00322 
00323     const TReturn negative = (TReturn(1) << (NBITS - 1));
00324     TReturn signed_value = value & ((1 << NBITS) - 1);
00325 
00326     if ((signed_value & negative) != 0)
00327     {
00328       const TReturn sign_bits = ~((TReturn(1) << NBITS) - 1);
00329       signed_value |= sign_bits;
00330     }
00331 
00332     return signed_value;
00333   }
00334 
00335   //***************************************************************************
00336   /// Sign extend.
00337   /// Converts an N bit binary number, where bit N-1 is the sign bit, and SHIFT
00338   /// is the right shift amount, to a signed integral type.
00339   //***************************************************************************
00340   template <typename TReturn, typename TValue>
00341   TReturn sign_extend(TValue value, const size_t NBITS, const size_t SHIFT)
00342   {
00343     STATIC_ASSERT(etl::is_integral<TValue>::value, "TValue not an integral type");
00344     STATIC_ASSERT(etl::is_integral<TReturn>::value, "TReturn not an integral type");
00345     STATIC_ASSERT(etl::is_signed<TReturn>::value, "TReturn not a signed type");
00346     assert(NBITS <= std::numeric_limits<TReturn>::digits);
00347 
00348     const TReturn negative = (TReturn(1) << (NBITS - 1));
00349     TReturn signed_value = (value >> SHIFT) & ((1 << NBITS) - 1);
00350 
00351     if ((signed_value & negative) != 0)
00352     {
00353       const TReturn sign_bits = ~((TReturn(1) << NBITS) - 1);
00354       signed_value |= sign_bits;
00355     }
00356 
00357     return signed_value;
00358   }
00359 
00360   //***************************************************************************
00361   /// Count trailing zeros. bit.
00362   /// Uses a binary search.
00363   //***************************************************************************
00364 #if ETL_8BIT_SUPPORT
00365   uint_least8_t count_trailing_zeros(uint8_t value);
00366   inline uint_least8_t count_trailing_zeros(int8_t value) { return count_trailing_zeros(uint8_t(value)); }
00367 #endif
00368   uint_least8_t count_trailing_zeros(uint16_t value);
00369   inline uint_least8_t count_trailing_zeros(int16_t value) { return count_trailing_zeros(uint16_t(value)); }
00370   uint_least8_t count_trailing_zeros(uint32_t value);
00371   inline uint_least8_t count_trailing_zeros(int32_t value) { return count_trailing_zeros(uint32_t(value)); }
00372   uint_least8_t count_trailing_zeros(uint64_t value);
00373   inline uint_least8_t count_trailing_zeros(int64_t value) { return count_trailing_zeros(uint64_t(value)); }
00374 
00375   //***************************************************************************
00376   /// Find the position of the first set bit.
00377   /// Starts from LSB.
00378   //***************************************************************************
00379   template <typename T>
00380   uint_least8_t first_set_bit_position(T value)
00381   {
00382     return count_trailing_zeros(value);
00383   }
00384 
00385   //***************************************************************************
00386   /// Find the position of the first clear bit.
00387   /// Starts from LSB.
00388   //***************************************************************************
00389   template <typename T>
00390   uint_least8_t first_clear_bit_position(T value)
00391   {
00392     value = ~value;
00393     return count_trailing_zeros(value);
00394   }
00395 
00396   //***************************************************************************
00397   /// Find the position of the first bit that is clear or set.
00398   /// Starts from LSB.
00399   //***************************************************************************
00400   template <typename T>
00401   uint_least8_t first_bit_position(bool state, T value)
00402   {
00403     if (!state)
00404     {
00405       value = ~value;
00406     }
00407 
00408     return count_trailing_zeros(value);
00409   }
00410 
00411   //***************************************************************************
00412   /// Gets the value of the bit at POSITION
00413   /// Starts from LSB.
00414   //***************************************************************************
00415   template <const size_t POSITION>
00416   struct bit
00417   {
00418     typedef typename etl::smallest_uint_for_bits<POSITION + 1>::type value_type;
00419     static const value_type value = value_type(1) << POSITION;
00420   };
00421 
00422   template <const size_t POSITION>
00423   const typename bit<POSITION>::value_type bit<POSITION>::value;
00424 
00425   //***************************************************************************
00426   /// 8 bit binary constants.
00427   //***************************************************************************
00428   enum binary_constant
00429   {
00430     b00000000 = 0,
00431     b00000001 = 1,
00432     b00000010 = 2,
00433     b00000011 = 3,
00434     b00000100 = 4,
00435     b00000101 = 5,
00436     b00000110 = 6,
00437     b00000111 = 7,
00438     b00001000 = 8,
00439     b00001001 = 9,
00440     b00001010 = 10,
00441     b00001011 = 11,
00442     b00001100 = 12,
00443     b00001101 = 13,
00444     b00001110 = 14,
00445     b00001111 = 15,
00446     b00010000 = 16,
00447     b00010001 = 17,
00448     b00010010 = 18,
00449     b00010011 = 19,
00450     b00010100 = 20,
00451     b00010101 = 21,
00452     b00010110 = 22,
00453     b00010111 = 23,
00454     b00011000 = 24,
00455     b00011001 = 25,
00456     b00011010 = 26,
00457     b00011011 = 27,
00458     b00011100 = 28,
00459     b00011101 = 29,
00460     b00011110 = 30,
00461     b00011111 = 31,
00462     b00100000 = 32,
00463     b00100001 = 33,
00464     b00100010 = 34,
00465     b00100011 = 35,
00466     b00100100 = 36,
00467     b00100101 = 37,
00468     b00100110 = 38,
00469     b00100111 = 39,
00470     b00101000 = 40,
00471     b00101001 = 41,
00472     b00101010 = 42,
00473     b00101011 = 43,
00474     b00101100 = 44,
00475     b00101101 = 45,
00476     b00101110 = 46,
00477     b00101111 = 47,
00478     b00110000 = 48,
00479     b00110001 = 49,
00480     b00110010 = 50,
00481     b00110011 = 51,
00482     b00110100 = 52,
00483     b00110101 = 53,
00484     b00110110 = 54,
00485     b00110111 = 55,
00486     b00111000 = 56,
00487     b00111001 = 57,
00488     b00111010 = 58,
00489     b00111011 = 59,
00490     b00111100 = 60,
00491     b00111101 = 61,
00492     b00111110 = 62,
00493     b00111111 = 63,
00494     b01000000 = 64,
00495     b01000001 = 65,
00496     b01000010 = 66,
00497     b01000011 = 67,
00498     b01000100 = 68,
00499     b01000101 = 69,
00500     b01000110 = 70,
00501     b01000111 = 71,
00502     b01001000 = 72,
00503     b01001001 = 73,
00504     b01001010 = 74,
00505     b01001011 = 75,
00506     b01001100 = 76,
00507     b01001101 = 77,
00508     b01001110 = 78,
00509     b01001111 = 79,
00510     b01010000 = 80,
00511     b01010001 = 81,
00512     b01010010 = 82,
00513     b01010011 = 83,
00514     b01010100 = 84,
00515     b01010101 = 85,
00516     b01010110 = 86,
00517     b01010111 = 87,
00518     b01011000 = 88,
00519     b01011001 = 89,
00520     b01011010 = 90,
00521     b01011011 = 91,
00522     b01011100 = 92,
00523     b01011101 = 93,
00524     b01011110 = 94,
00525     b01011111 = 95,
00526     b01100000 = 96,
00527     b01100001 = 97,
00528     b01100010 = 98,
00529     b01100011 = 99,
00530     b01100100 = 100,
00531     b01100101 = 101,
00532     b01100110 = 102,
00533     b01100111 = 103,
00534     b01101000 = 104,
00535     b01101001 = 105,
00536     b01101010 = 106,
00537     b01101011 = 107,
00538     b01101100 = 108,
00539     b01101101 = 109,
00540     b01101110 = 110,
00541     b01101111 = 111,
00542     b01110000 = 112,
00543     b01110001 = 113,
00544     b01110010 = 114,
00545     b01110011 = 115,
00546     b01110100 = 116,
00547     b01110101 = 117,
00548     b01110110 = 118,
00549     b01110111 = 119,
00550     b01111000 = 120,
00551     b01111001 = 121,
00552     b01111010 = 122,
00553     b01111011 = 123,
00554     b01111100 = 124,
00555     b01111101 = 125,
00556     b01111110 = 126,
00557     b01111111 = 127,
00558     b10000000 = 128,
00559     b10000001 = 129,
00560     b10000010 = 130,
00561     b10000011 = 131,
00562     b10000100 = 132,
00563     b10000101 = 133,
00564     b10000110 = 134,
00565     b10000111 = 135,
00566     b10001000 = 136,
00567     b10001001 = 137,
00568     b10001010 = 138,
00569     b10001011 = 139,
00570     b10001100 = 140,
00571     b10001101 = 141,
00572     b10001110 = 142,
00573     b10001111 = 143,
00574     b10010000 = 144,
00575     b10010001 = 145,
00576     b10010010 = 146,
00577     b10010011 = 147,
00578     b10010100 = 148,
00579     b10010101 = 149,
00580     b10010110 = 150,
00581     b10010111 = 151,
00582     b10011000 = 152,
00583     b10011001 = 153,
00584     b10011010 = 154,
00585     b10011011 = 155,
00586     b10011100 = 156,
00587     b10011101 = 157,
00588     b10011110 = 158,
00589     b10011111 = 159,
00590     b10100000 = 160,
00591     b10100001 = 161,
00592     b10100010 = 162,
00593     b10100011 = 163,
00594     b10100100 = 164,
00595     b10100101 = 165,
00596     b10100110 = 166,
00597     b10100111 = 167,
00598     b10101000 = 168,
00599     b10101001 = 169,
00600     b10101010 = 170,
00601     b10101011 = 171,
00602     b10101100 = 172,
00603     b10101101 = 173,
00604     b10101110 = 174,
00605     b10101111 = 175,
00606     b10110000 = 176,
00607     b10110001 = 177,
00608     b10110010 = 178,
00609     b10110011 = 179,
00610     b10110100 = 180,
00611     b10110101 = 181,
00612     b10110110 = 182,
00613     b10110111 = 183,
00614     b10111000 = 184,
00615     b10111001 = 185,
00616     b10111010 = 186,
00617     b10111011 = 187,
00618     b10111100 = 188,
00619     b10111101 = 189,
00620     b10111110 = 190,
00621     b10111111 = 191,
00622     b11000000 = 192,
00623     b11000001 = 193,
00624     b11000010 = 194,
00625     b11000011 = 195,
00626     b11000100 = 196,
00627     b11000101 = 197,
00628     b11000110 = 198,
00629     b11000111 = 199,
00630     b11001000 = 200,
00631     b11001001 = 201,
00632     b11001010 = 202,
00633     b11001011 = 203,
00634     b11001100 = 204,
00635     b11001101 = 205,
00636     b11001110 = 206,
00637     b11001111 = 207,
00638     b11010000 = 208,
00639     b11010001 = 209,
00640     b11010010 = 210,
00641     b11010011 = 211,
00642     b11010100 = 212,
00643     b11010101 = 213,
00644     b11010110 = 214,
00645     b11010111 = 215,
00646     b11011000 = 216,
00647     b11011001 = 217,
00648     b11011010 = 218,
00649     b11011011 = 219,
00650     b11011100 = 220,
00651     b11011101 = 221,
00652     b11011110 = 222,
00653     b11011111 = 223,
00654     b11100000 = 224,
00655     b11100001 = 225,
00656     b11100010 = 226,
00657     b11100011 = 227,
00658     b11100100 = 228,
00659     b11100101 = 229,
00660     b11100110 = 230,
00661     b11100111 = 231,
00662     b11101000 = 232,
00663     b11101001 = 233,
00664     b11101010 = 234,
00665     b11101011 = 235,
00666     b11101100 = 236,
00667     b11101101 = 237,
00668     b11101110 = 238,
00669     b11101111 = 239,
00670     b11110000 = 240,
00671     b11110001 = 241,
00672     b11110010 = 242,
00673     b11110011 = 243,
00674     b11110100 = 244,
00675     b11110101 = 245,
00676     b11110110 = 246,
00677     b11110111 = 247,
00678     b11111000 = 248,
00679     b11111001 = 249,
00680     b11111010 = 250,
00681     b11111011 = 251,
00682     b11111100 = 252,
00683     b11111101 = 253,
00684     b11111110 = 254,
00685     b11111111 = 255
00686   };
00687 
00688   enum bit_constant
00689   {
00690     b0  = 0x1,
00691     b1  = 0x2,
00692     b2  = 0x4,
00693     b3  = 0x8,
00694     b4  = 0x10,
00695     b5  = 0x20,
00696     b6  = 0x40,
00697     b7  = 0x80,
00698     b8  = 0x100,
00699     b9  = 0x200,
00700     b10 = 0x400,
00701     b11 = 0x800,
00702     b12 = 0x1000,
00703     b13 = 0x2000,
00704     b14 = 0x4000,
00705     b15 = 0x8000,
00706     b16 = 0x10000,
00707     b17 = 0x20000,
00708     b18 = 0x40000,
00709     b19 = 0x80000,
00710     b20 = 0x100000,
00711     b21 = 0x200000,
00712     b22 = 0x400000,
00713     b23 = 0x800000,
00714     b24 = 0x1000000,
00715     b25 = 0x2000000,
00716     b26 = 0x4000000,
00717     b27 = 0x8000000,
00718     b28 = 0x10000000,
00719     b29 = 0x20000000,
00720     b30 = 0x40000000,
00721     b31 = 0x80000000
00722   };
00723 }
00724 
00725 #endif
00726