source: NonGTP/Boost/boost/crc.hpp @ 857

Revision 857, 33.4 KB checked in by igarcia, 19 years ago (diff)
Line 
1//  Boost CRC library crc.hpp header file  -----------------------------------//
2
3//  Copyright 2001, 2004 Daryle Walker.  Use, modification, and distribution are
4//  subject to the Boost Software License, Version 1.0.  (See accompanying file
5//  LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
6
7//  See <http://www.boost.org/libs/crc/> for the library's home page.
8
9#ifndef BOOST_CRC_HPP
10#define BOOST_CRC_HPP
11
12#include <boost/config.hpp>   // for BOOST_STATIC_CONSTANT, etc.
13#include <boost/integer.hpp>  // for boost::uint_t
14
15#include <climits>  // for CHAR_BIT, etc.
16#include <cstddef>  // for std::size_t
17
18#include <boost/limits.hpp>  // for std::numeric_limits
19
20
21// The type of CRC parameters that can go in a template should be related
22// on the CRC's bit count.  This macro expresses that type in a compact
23// form, but also allows an alternate type for compilers that don't support
24// dependent types (in template value-parameters).
25#if !(defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS) || (defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)))
26#define BOOST_CRC_PARM_TYPE  typename ::boost::uint_t<Bits>::fast
27#else
28#define BOOST_CRC_PARM_TYPE  unsigned long
29#endif
30
31// Some compilers [MS VC++ 6] cannot correctly set up several versions of a
32// function template unless every template argument can be unambiguously
33// deduced from the function arguments.  (The bug is hidden if only one version
34// is needed.)  Since all of the CRC function templates have this problem, the
35// workaround is to make up a dummy function argument that encodes the template
36// arguments.  Calls to such template functions need all their template
37// arguments explicitly specified.  At least one compiler that needs this
38// workaround also needs the default value for the dummy argument to be
39// specified in the definition.
40#if defined(__GNUC__) || !defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
41#define BOOST_CRC_DUMMY_PARM_TYPE
42#define BOOST_CRC_DUMMY_INIT
43#define BOOST_ACRC_DUMMY_PARM_TYPE
44#define BOOST_ACRC_DUMMY_INIT
45#else
46namespace boost { namespace detail {
47    template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
48     BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
49     bool ReflectIn, bool ReflectRem >
50    struct dummy_crc_argument  { };
51} }
52#define BOOST_CRC_DUMMY_PARM_TYPE   , detail::dummy_crc_argument<Bits, \
53 TruncPoly, InitRem, FinalXor, ReflectIn, ReflectRem> *p_
54#define BOOST_CRC_DUMMY_INIT        BOOST_CRC_DUMMY_PARM_TYPE = 0
55#define BOOST_ACRC_DUMMY_PARM_TYPE  , detail::dummy_crc_argument<Bits, \
56 TruncPoly, 0, 0, false, false> *p_
57#define BOOST_ACRC_DUMMY_INIT       BOOST_ACRC_DUMMY_PARM_TYPE = 0
58#endif
59
60
61namespace boost
62{
63
64
65//  Forward declarations  ----------------------------------------------------//
66
67template < std::size_t Bits >
68    class crc_basic;
69
70template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly = 0u,
71           BOOST_CRC_PARM_TYPE InitRem = 0u,
72           BOOST_CRC_PARM_TYPE FinalXor = 0u, bool ReflectIn = false,
73           bool ReflectRem = false >
74    class crc_optimal;
75
76template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
77           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
78           bool ReflectIn, bool ReflectRem >
79    typename uint_t<Bits>::fast  crc( void const *buffer,
80     std::size_t byte_count
81     BOOST_CRC_DUMMY_PARM_TYPE );
82
83template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly >
84    typename uint_t<Bits>::fast  augmented_crc( void const *buffer,
85     std::size_t byte_count, typename uint_t<Bits>::fast initial_remainder
86     BOOST_ACRC_DUMMY_PARM_TYPE );
87
88template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly >
89    typename uint_t<Bits>::fast  augmented_crc( void const *buffer,
90     std::size_t byte_count
91     BOOST_ACRC_DUMMY_PARM_TYPE );
92
93typedef crc_optimal<16, 0x8005, 0, 0, true, true>         crc_16_type;
94typedef crc_optimal<16, 0x1021, 0xFFFF, 0, false, false>  crc_ccitt_type;
95typedef crc_optimal<16, 0x8408, 0, 0, true, true>         crc_xmodem_type;
96
97typedef crc_optimal<32, 0x04C11DB7, 0xFFFFFFFF, 0xFFFFFFFF, true, true>
98  crc_32_type;
99
100
101//  Forward declarations for implementation detail stuff  --------------------//
102//  (Just for the stuff that will be needed for the next two sections)
103
104namespace detail
105{
106    template < std::size_t Bits >
107        struct mask_uint_t;
108
109    template <  >
110        struct mask_uint_t< std::numeric_limits<unsigned char>::digits >;
111
112    #if USHRT_MAX > UCHAR_MAX
113    template <  >
114        struct mask_uint_t< std::numeric_limits<unsigned short>::digits >;
115    #endif
116
117    #if UINT_MAX > USHRT_MAX
118    template <  >
119        struct mask_uint_t< std::numeric_limits<unsigned int>::digits >;
120    #endif
121
122    #if ULONG_MAX > UINT_MAX
123    template <  >
124        struct mask_uint_t< std::numeric_limits<unsigned long>::digits >;
125    #endif
126
127    template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, bool Reflect >
128        struct crc_table_t;
129
130    template < std::size_t Bits, bool DoReflect >
131        class crc_helper;
132
133    #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
134    template < std::size_t Bits >
135        class crc_helper< Bits, false >;
136    #endif
137
138}  // namespace detail
139
140
141//  Simple cyclic redundancy code (CRC) class declaration  -------------------//
142
143template < std::size_t Bits >
144class crc_basic
145{
146    // Implementation type
147    typedef detail::mask_uint_t<Bits>  masking_type;
148
149public:
150    // Type
151    typedef typename masking_type::least  value_type;
152
153    // Constant for the template parameter
154    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
155
156    // Constructor
157    explicit  crc_basic( value_type truncated_polynominal,
158               value_type initial_remainder = 0, value_type final_xor_value = 0,
159               bool reflect_input = false, bool reflect_remainder = false );
160
161    // Internal Operations
162    value_type  get_truncated_polynominal() const;
163    value_type  get_initial_remainder() const;
164    value_type  get_final_xor_value() const;
165    bool        get_reflect_input() const;
166    bool        get_reflect_remainder() const;
167
168    value_type  get_interim_remainder() const;
169    void        reset( value_type new_rem );
170    void        reset();
171
172    // External Operations
173    void  process_bit( bool bit );
174    void  process_bits( unsigned char bits, std::size_t bit_count );
175    void  process_byte( unsigned char byte );
176    void  process_block( void const *bytes_begin, void const *bytes_end );
177    void  process_bytes( void const *buffer, std::size_t byte_count );
178
179    value_type  checksum() const;
180
181private:
182    // Member data
183    value_type  rem_;
184    value_type  poly_, init_, final_;  // non-const to allow assignability
185    bool        rft_in_, rft_out_;     // non-const to allow assignability
186
187};  // boost::crc_basic
188
189
190//  Optimized cyclic redundancy code (CRC) class declaration  ----------------//
191
192template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
193           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
194           bool ReflectIn, bool ReflectRem >
195class crc_optimal
196{
197    // Implementation type
198    typedef detail::mask_uint_t<Bits>  masking_type;
199
200public:
201    // Type
202    typedef typename masking_type::fast  value_type;
203
204    // Constants for the template parameters
205    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
206    BOOST_STATIC_CONSTANT( value_type, truncated_polynominal = TruncPoly );
207    BOOST_STATIC_CONSTANT( value_type, initial_remainder = InitRem );
208    BOOST_STATIC_CONSTANT( value_type, final_xor_value = FinalXor );
209    BOOST_STATIC_CONSTANT( bool, reflect_input = ReflectIn );
210    BOOST_STATIC_CONSTANT( bool, reflect_remainder = ReflectRem );
211
212    // Constructor
213    explicit  crc_optimal( value_type init_rem = InitRem );
214
215    // Internal Operations
216    value_type  get_truncated_polynominal() const;
217    value_type  get_initial_remainder() const;
218    value_type  get_final_xor_value() const;
219    bool        get_reflect_input() const;
220    bool        get_reflect_remainder() const;
221
222    value_type  get_interim_remainder() const;
223    void        reset( value_type new_rem = InitRem );
224
225    // External Operations
226    void  process_byte( unsigned char byte );
227    void  process_block( void const *bytes_begin, void const *bytes_end );
228    void  process_bytes( void const *buffer, std::size_t byte_count );
229
230    value_type  checksum() const;
231
232    // Operators
233    void        operator ()( unsigned char byte );
234    value_type  operator ()() const;
235
236private:
237    // The implementation of output reflection depends on both reflect states.
238    BOOST_STATIC_CONSTANT( bool, reflect_output = (ReflectRem != ReflectIn) );
239
240    #ifndef __BORLANDC__
241    #define BOOST_CRC_REF_OUT_VAL  reflect_output
242    #else
243    typedef crc_optimal  self_type;
244    #define BOOST_CRC_REF_OUT_VAL  (self_type::reflect_output)
245    #endif
246
247    // More implementation types
248    typedef detail::crc_table_t<Bits, TruncPoly, ReflectIn>  crc_table_type;
249    typedef detail::crc_helper<Bits, ReflectIn>              helper_type;
250    typedef detail::crc_helper<Bits, BOOST_CRC_REF_OUT_VAL>  reflect_out_type;
251
252    #undef BOOST_CRC_REF_OUT_VAL
253
254    // Member data
255    value_type  rem_;
256
257};  // boost::crc_optimal
258
259
260//  Implementation detail stuff  ---------------------------------------------//
261
262namespace detail
263{
264    // Forward declarations for more implementation details
265    template < std::size_t Bits >
266        struct high_uint_t;
267
268    template < std::size_t Bits >
269        struct reflector;
270
271
272    // Traits class for mask; given the bit number
273    // (1-based), get the mask for that bit by itself.
274    template < std::size_t Bits >
275    struct high_uint_t
276        : boost::uint_t< Bits >
277    {
278        typedef boost::uint_t<Bits>        base_type;
279        typedef typename base_type::least  least;
280        typedef typename base_type::fast   fast;
281
282#if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 243
283        static const least high_bit = 1ul << ( Bits - 1u );
284        static const fast high_bit_fast = 1ul << ( Bits - 1u );
285#else
286        BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << ( Bits
287         - 1u )) );
288        BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << ( Bits
289         - 1u )) );
290#endif
291
292    };  // boost::detail::high_uint_t
293
294
295    // Reflection routine class wrapper
296    // (since MS VC++ 6 couldn't handle the unwrapped version)
297    template < std::size_t Bits >
298    struct reflector
299    {
300        typedef typename boost::uint_t<Bits>::fast  value_type;
301
302        static  value_type  reflect( value_type x );
303
304    };  // boost::detail::reflector
305
306    // Function that reflects its argument
307    template < std::size_t Bits >
308    typename reflector<Bits>::value_type
309    reflector<Bits>::reflect
310    (
311        typename reflector<Bits>::value_type  x
312    )
313    {
314        value_type        reflection = 0;
315        value_type const  one = 1;
316
317        for ( std::size_t i = 0 ; i < Bits ; ++i, x >>= 1 )
318        {
319            if ( x & one )
320            {
321                reflection |= ( one << (Bits - 1u - i) );
322            }
323        }
324
325        return reflection;
326    }
327
328
329    // Traits class for masks; given the bit number (1-based),
330    // get the mask for that bit and its lower bits.
331    template < std::size_t Bits >
332    struct mask_uint_t
333        : high_uint_t< Bits >
334    {
335        typedef high_uint_t<Bits>          base_type;
336        typedef typename base_type::least  least;
337        typedef typename base_type::fast   fast;
338
339        #ifndef __BORLANDC__
340        using base_type::high_bit;
341        using base_type::high_bit_fast;
342        #else
343        BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit );
344        BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast );
345        #endif
346
347#if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 243
348        static const least sig_bits = (~( ~( 0ul ) << Bits )) ;
349#else
350        BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
351#endif
352#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
353        // Work around a weird bug that ICEs the compiler in build_c_cast
354        BOOST_STATIC_CONSTANT( fast, sig_bits_fast = static_cast<fast>(sig_bits) );
355#else
356        BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
357#endif
358    };  // boost::detail::mask_uint_t
359
360    template <  >
361    struct mask_uint_t< std::numeric_limits<unsigned char>::digits >
362        : high_uint_t< std::numeric_limits<unsigned char>::digits >
363    {
364        typedef high_uint_t<std::numeric_limits<unsigned char>::digits>
365          base_type;
366        typedef base_type::least  least;
367        typedef base_type::fast   fast;
368
369        #ifndef __BORLANDC__
370        using base_type::high_bit;
371        using base_type::high_bit_fast;
372        #else
373        BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit );
374        BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast );
375        #endif
376
377        BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) );
378        BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
379
380    };  // boost::detail::mask_uint_t
381
382    #if USHRT_MAX > UCHAR_MAX
383    template <  >
384    struct mask_uint_t< std::numeric_limits<unsigned short>::digits >
385        : high_uint_t< std::numeric_limits<unsigned short>::digits >
386    {
387        typedef high_uint_t<std::numeric_limits<unsigned short>::digits>
388          base_type;
389        typedef base_type::least  least;
390        typedef base_type::fast   fast;
391
392        #ifndef __BORLANDC__
393        using base_type::high_bit;
394        using base_type::high_bit_fast;
395        #else
396        BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit );
397        BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast );
398        #endif
399
400        BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) );
401        BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
402
403    };  // boost::detail::mask_uint_t
404    #endif
405
406    #if UINT_MAX > USHRT_MAX
407    template <  >
408    struct mask_uint_t< std::numeric_limits<unsigned int>::digits >
409        : high_uint_t< std::numeric_limits<unsigned int>::digits >
410    {
411        typedef high_uint_t<std::numeric_limits<unsigned int>::digits>
412          base_type;
413        typedef base_type::least  least;
414        typedef base_type::fast   fast;
415
416        #ifndef __BORLANDC__
417        using base_type::high_bit;
418        using base_type::high_bit_fast;
419        #else
420        BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit );
421        BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast );
422        #endif
423
424        BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) );
425        BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
426
427    };  // boost::detail::mask_uint_t
428    #endif
429
430    #if ULONG_MAX > UINT_MAX
431    template <  >
432    struct mask_uint_t< std::numeric_limits<unsigned long>::digits >
433        : high_uint_t< std::numeric_limits<unsigned long>::digits >
434    {
435        typedef high_uint_t<std::numeric_limits<unsigned long>::digits>
436          base_type;
437        typedef base_type::least  least;
438        typedef base_type::fast   fast;
439
440        #ifndef __BORLANDC__
441        using base_type::high_bit;
442        using base_type::high_bit_fast;
443        #else
444        BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit );
445        BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast );
446        #endif
447
448        BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) );
449        BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
450
451    };  // boost::detail::mask_uint_t
452    #endif
453
454
455    // CRC table generator
456    template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, bool Reflect >
457    struct crc_table_t
458    {
459        BOOST_STATIC_CONSTANT( std::size_t, byte_combos = (1ul << CHAR_BIT) );
460
461        typedef mask_uint_t<Bits>            masking_type;
462        typedef typename masking_type::fast  value_type;
463#if defined(__BORLANDC__) && defined(_M_IX86) && (__BORLANDC__ == 0x560)
464        // for some reason Borland's command line compiler (version 0x560)
465        // chokes over this unless we do the calculation for it:
466        typedef value_type                   table_type[ 0x100 ];
467#else
468        typedef value_type                   table_type[ byte_combos ];
469#endif
470
471        static  void  init_table();
472
473        static  table_type  table_;
474
475    };  // boost::detail::crc_table_t
476
477    // CRC table generator static data member definition
478    // (Some compilers [Borland C++] require the initializer to be present.)
479    template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, bool Reflect >
480    typename crc_table_t<Bits, TruncPoly, Reflect>::table_type
481    crc_table_t<Bits, TruncPoly, Reflect>::table_
482     = { 0 };
483
484    // Populate CRC lookup table
485    template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, bool Reflect >
486    void
487    crc_table_t<Bits, TruncPoly, Reflect>::init_table
488    (
489    )
490    {
491        // compute table only on the first run
492        static  bool  did_init = false;
493        if ( did_init )  return;
494
495        // factor-out constants to avoid recalculation
496        value_type const     fast_hi_bit = masking_type::high_bit_fast;
497        unsigned char const  byte_hi_bit = 1u << (CHAR_BIT - 1u);
498
499        // loop over every possible dividend value
500        unsigned char  dividend = 0;
501        do
502        {
503            value_type  remainder = 0;
504
505            // go through all the dividend's bits
506            for ( unsigned char mask = byte_hi_bit ; mask ; mask >>= 1 )
507            {
508                // check if divisor fits
509                if ( dividend & mask )
510                {
511                    remainder ^= fast_hi_bit;
512                }
513
514                // do polynominal division
515                if ( remainder & fast_hi_bit )
516                {
517                    remainder <<= 1;
518                    remainder ^= TruncPoly;
519                }
520                else
521                {
522                    remainder <<= 1;
523                }
524            }
525
526            table_[ crc_helper<CHAR_BIT, Reflect>::reflect(dividend) ]
527             = crc_helper<Bits, Reflect>::reflect( remainder );
528        }
529        while ( ++dividend );
530
531        did_init = true;
532    }
533
534    #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
535    // Align the msb of the remainder to a byte
536    template < std::size_t Bits, bool RightShift >
537    class remainder
538    {
539    public:
540        typedef typename uint_t<Bits>::fast  value_type;
541
542        static unsigned char align_msb( value_type rem )
543            { return rem >> (Bits - CHAR_BIT); }
544    };
545
546    // Specialization for the case that the remainder has less
547    // bits than a byte: align the remainder msb to the byte msb
548    template < std::size_t Bits >
549    class remainder< Bits, false >
550    {
551    public:
552        typedef typename uint_t<Bits>::fast  value_type;
553
554        static unsigned char align_msb( value_type rem )
555            { return rem << (CHAR_BIT - Bits); }
556    };
557    #endif
558
559    // CRC helper routines
560    template < std::size_t Bits, bool DoReflect >
561    class crc_helper
562    {
563    public:
564        // Type
565        typedef typename uint_t<Bits>::fast  value_type;
566
567    #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
568        // Possibly reflect a remainder
569        static  value_type  reflect( value_type x )
570            { return detail::reflector<Bits>::reflect( x ); }
571
572        // Compare a byte to the remainder's highest byte
573        static  unsigned char  index( value_type rem, unsigned char x )
574            { return x ^ rem; }
575
576        // Shift out the remainder's highest byte
577        static  value_type  shift( value_type rem )
578            { return rem >> CHAR_BIT; }
579    #else
580        // Possibly reflect a remainder
581        static  value_type  reflect( value_type x )
582            { return DoReflect ? detail::reflector<Bits>::reflect( x ) : x; }
583
584        // Compare a byte to the remainder's highest byte
585        static  unsigned char  index( value_type rem, unsigned char x )
586            { return x ^ ( DoReflect ? rem :
587                                ((Bits>CHAR_BIT)?( rem >> (Bits - CHAR_BIT) ) :
588                                    ( rem << (CHAR_BIT - Bits) ))); }
589
590        // Shift out the remainder's highest byte
591        static  value_type  shift( value_type rem )
592            { return DoReflect ? rem >> CHAR_BIT : rem << CHAR_BIT; }
593    #endif
594
595    };  // boost::detail::crc_helper
596
597    #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
598    template < std::size_t Bits >
599    class crc_helper<Bits, false>
600    {
601    public:
602        // Type
603        typedef typename uint_t<Bits>::fast  value_type;
604
605        // Possibly reflect a remainder
606        static  value_type  reflect( value_type x )
607            { return x; }
608
609        // Compare a byte to the remainder's highest byte
610        static  unsigned char  index( value_type rem, unsigned char x )
611            { return x ^ remainder<Bits,(Bits>CHAR_BIT)>::align_msb( rem ); }
612
613        // Shift out the remainder's highest byte
614        static  value_type  shift( value_type rem )
615            { return rem << CHAR_BIT; }
616
617    };  // boost::detail::crc_helper
618    #endif
619
620
621}  // namespace detail
622
623
624//  Simple CRC class function definitions  -----------------------------------//
625
626template < std::size_t Bits >
627inline
628crc_basic<Bits>::crc_basic
629(
630    typename crc_basic<Bits>::value_type  truncated_polynominal,
631    typename crc_basic<Bits>::value_type  initial_remainder,      // = 0
632    typename crc_basic<Bits>::value_type  final_xor_value,        // = 0
633    bool                                  reflect_input,          // = false
634    bool                                  reflect_remainder       // = false
635)
636    : rem_( initial_remainder ), poly_( truncated_polynominal )
637    , init_( initial_remainder ), final_( final_xor_value )
638    , rft_in_( reflect_input ), rft_out_( reflect_remainder )
639{
640}
641
642template < std::size_t Bits >
643inline
644typename crc_basic<Bits>::value_type
645crc_basic<Bits>::get_truncated_polynominal
646(
647) const
648{
649    return poly_;
650}
651
652template < std::size_t Bits >
653inline
654typename crc_basic<Bits>::value_type
655crc_basic<Bits>::get_initial_remainder
656(
657) const
658{
659    return init_;
660}
661
662template < std::size_t Bits >
663inline
664typename crc_basic<Bits>::value_type
665crc_basic<Bits>::get_final_xor_value
666(
667) const
668{
669    return final_;
670}
671
672template < std::size_t Bits >
673inline
674bool
675crc_basic<Bits>::get_reflect_input
676(
677) const
678{
679    return rft_in_;
680}
681
682template < std::size_t Bits >
683inline
684bool
685crc_basic<Bits>::get_reflect_remainder
686(
687) const
688{
689    return rft_out_;
690}
691
692template < std::size_t Bits >
693inline
694typename crc_basic<Bits>::value_type
695crc_basic<Bits>::get_interim_remainder
696(
697) const
698{
699    return rem_ & masking_type::sig_bits;
700}
701
702template < std::size_t Bits >
703inline
704void
705crc_basic<Bits>::reset
706(
707    typename crc_basic<Bits>::value_type  new_rem
708)
709{
710    rem_ = new_rem;
711}
712
713template < std::size_t Bits >
714inline
715void
716crc_basic<Bits>::reset
717(
718)
719{
720    this->reset( this->get_initial_remainder() );
721}
722
723template < std::size_t Bits >
724inline
725void
726crc_basic<Bits>::process_bit
727(
728    bool  bit
729)
730{
731    value_type const  high_bit_mask = masking_type::high_bit;
732
733    // compare the new bit with the remainder's highest
734    rem_ ^= ( bit ? high_bit_mask : 0u );
735
736    // a full polynominal division step is done when the highest bit is one
737    bool const  do_poly_div = static_cast<bool>( rem_ & high_bit_mask );
738
739    // shift out the highest bit
740    rem_ <<= 1;
741
742    // carry out the division, if needed
743    if ( do_poly_div )
744    {
745        rem_ ^= poly_;
746    }
747}
748
749template < std::size_t Bits >
750void
751crc_basic<Bits>::process_bits
752(
753    unsigned char  bits,
754    std::size_t    bit_count
755)
756{
757    // ignore the bits above the ones we want
758    bits <<= CHAR_BIT - bit_count;
759
760    // compute the CRC for each bit, starting with the upper ones
761    unsigned char const  high_bit_mask = 1u << ( CHAR_BIT - 1u );
762    for ( std::size_t i = bit_count ; i > 0u ; --i, bits <<= 1u )
763    {
764        process_bit( static_cast<bool>(bits & high_bit_mask) );
765    }
766}
767
768template < std::size_t Bits >
769inline
770void
771crc_basic<Bits>::process_byte
772(
773    unsigned char  byte
774)
775{
776    process_bits( (rft_in_ ? detail::reflector<CHAR_BIT>::reflect(byte)
777     : byte), CHAR_BIT );
778}
779
780template < std::size_t Bits >
781void
782crc_basic<Bits>::process_block
783(
784    void const *  bytes_begin,
785    void const *  bytes_end
786)
787{
788    for ( unsigned char const * p
789     = static_cast<unsigned char const *>(bytes_begin) ; p < bytes_end ; ++p )
790    {
791        process_byte( *p );
792    }
793}
794
795template < std::size_t Bits >
796inline
797void
798crc_basic<Bits>::process_bytes
799(
800    void const *  buffer,
801    std::size_t   byte_count
802)
803{
804    unsigned char const * const  b = static_cast<unsigned char const *>(
805     buffer );
806
807    process_block( b, b + byte_count );
808}
809
810template < std::size_t Bits >
811inline
812typename crc_basic<Bits>::value_type
813crc_basic<Bits>::checksum
814(
815) const
816{
817    return ( (rft_out_ ? detail::reflector<Bits>::reflect( rem_ ) : rem_)
818     ^ final_ ) & masking_type::sig_bits;
819}
820
821
822//  Optimized CRC class function definitions  --------------------------------//
823
824// Macro to compact code
825#define BOOST_CRC_OPTIMAL_NAME  crc_optimal<Bits, TruncPoly, InitRem, \
826 FinalXor, ReflectIn, ReflectRem>
827
828template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
829           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
830           bool ReflectIn, bool ReflectRem >
831inline
832BOOST_CRC_OPTIMAL_NAME::crc_optimal
833(
834    typename BOOST_CRC_OPTIMAL_NAME::value_type  init_rem  // = InitRem
835)
836    : rem_( helper_type::reflect(init_rem) )
837{
838    crc_table_type::init_table();
839}
840
841template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
842           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
843           bool ReflectIn, bool ReflectRem >
844inline
845typename BOOST_CRC_OPTIMAL_NAME::value_type
846BOOST_CRC_OPTIMAL_NAME::get_truncated_polynominal
847(
848) const
849{
850    return TruncPoly;
851}
852
853template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
854           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
855           bool ReflectIn, bool ReflectRem >
856inline
857typename BOOST_CRC_OPTIMAL_NAME::value_type
858BOOST_CRC_OPTIMAL_NAME::get_initial_remainder
859(
860) const
861{
862    return InitRem;
863}
864
865template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
866           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
867           bool ReflectIn, bool ReflectRem >
868inline
869typename BOOST_CRC_OPTIMAL_NAME::value_type
870BOOST_CRC_OPTIMAL_NAME::get_final_xor_value
871(
872) const
873{
874    return FinalXor;
875}
876
877template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
878           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
879           bool ReflectIn, bool ReflectRem >
880inline
881bool
882BOOST_CRC_OPTIMAL_NAME::get_reflect_input
883(
884) const
885{
886    return ReflectIn;
887}
888
889template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
890           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
891           bool ReflectIn, bool ReflectRem >
892inline
893bool
894BOOST_CRC_OPTIMAL_NAME::get_reflect_remainder
895(
896) const
897{
898    return ReflectRem;
899}
900
901template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
902           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
903           bool ReflectIn, bool ReflectRem >
904inline
905typename BOOST_CRC_OPTIMAL_NAME::value_type
906BOOST_CRC_OPTIMAL_NAME::get_interim_remainder
907(
908) const
909{
910    // Interim remainder should be _un_-reflected, so we have to undo it.
911    return helper_type::reflect( rem_ ) & masking_type::sig_bits_fast;
912}
913
914template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
915           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
916           bool ReflectIn, bool ReflectRem >
917inline
918void
919BOOST_CRC_OPTIMAL_NAME::reset
920(
921    typename BOOST_CRC_OPTIMAL_NAME::value_type  new_rem  // = InitRem
922)
923{
924    rem_ = helper_type::reflect( new_rem );
925}
926
927template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
928           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
929           bool ReflectIn, bool ReflectRem >
930inline
931void
932BOOST_CRC_OPTIMAL_NAME::process_byte
933(
934    unsigned char  byte
935)
936{
937    process_bytes( &byte, sizeof(byte) );
938}
939
940template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
941           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
942           bool ReflectIn, bool ReflectRem >
943void
944BOOST_CRC_OPTIMAL_NAME::process_block
945(
946    void const *  bytes_begin,
947    void const *  bytes_end
948)
949{
950    // Recompute the CRC for each byte passed
951    for ( unsigned char const * p
952     = static_cast<unsigned char const *>(bytes_begin) ; p < bytes_end ; ++p )
953    {
954        // Compare the new byte with the remainder's higher bits to
955        // get the new bits, shift out the remainder's current higher
956        // bits, and update the remainder with the polynominal division
957        // of the new bits.
958        unsigned char const  byte_index = helper_type::index( rem_, *p );
959        rem_ = helper_type::shift( rem_ );
960        rem_ ^= crc_table_type::table_[ byte_index ];
961    }
962}
963
964template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
965           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
966           bool ReflectIn, bool ReflectRem >
967inline
968void
969BOOST_CRC_OPTIMAL_NAME::process_bytes
970(
971    void const *   buffer,
972    std::size_t  byte_count
973)
974{
975    unsigned char const * const  b = static_cast<unsigned char const *>(
976     buffer );
977    process_block( b, b + byte_count );
978}
979
980template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
981           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
982           bool ReflectIn, bool ReflectRem >
983inline
984typename BOOST_CRC_OPTIMAL_NAME::value_type
985BOOST_CRC_OPTIMAL_NAME::checksum
986(
987) const
988{
989    return ( reflect_out_type::reflect(rem_) ^ get_final_xor_value() )
990     & masking_type::sig_bits_fast;
991}
992
993template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
994           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
995           bool ReflectIn, bool ReflectRem >
996inline
997void
998BOOST_CRC_OPTIMAL_NAME::operator ()
999(
1000    unsigned char  byte
1001)
1002{
1003    process_byte( byte );
1004}
1005
1006template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
1007           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
1008           bool ReflectIn, bool ReflectRem >
1009inline
1010typename BOOST_CRC_OPTIMAL_NAME::value_type
1011BOOST_CRC_OPTIMAL_NAME::operator ()
1012(
1013) const
1014{
1015    return checksum();
1016}
1017
1018
1019//  CRC computation function definition  -------------------------------------//
1020
1021template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
1022           BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
1023           bool ReflectIn, bool ReflectRem >
1024inline
1025typename uint_t<Bits>::fast
1026crc
1027(
1028    void const *  buffer,
1029    std::size_t   byte_count
1030    BOOST_CRC_DUMMY_INIT
1031)
1032{
1033    BOOST_CRC_OPTIMAL_NAME  computer;
1034    computer.process_bytes( buffer, byte_count );
1035    return computer.checksum();
1036}
1037
1038
1039//  Augmented-message CRC computation function definitions  ------------------//
1040
1041template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly >
1042typename uint_t<Bits>::fast
1043augmented_crc
1044(
1045    void const *                 buffer,
1046    std::size_t                  byte_count,
1047    typename uint_t<Bits>::fast  initial_remainder
1048    BOOST_ACRC_DUMMY_INIT
1049)
1050{
1051    typedef unsigned char                                byte_type;
1052    typedef detail::mask_uint_t<Bits>                    masking_type;
1053    typedef detail::crc_table_t<Bits, TruncPoly, false>  crc_table_type;
1054
1055    typename masking_type::fast  rem = initial_remainder;
1056    byte_type const * const      b = static_cast<byte_type const *>( buffer );
1057    byte_type const * const      e = b + byte_count;
1058
1059    crc_table_type::init_table();
1060    for ( byte_type const * p = b ; p < e ; ++p )
1061    {
1062        // Use the current top byte as the table index to the next
1063        // "partial product."  Shift out that top byte, shifting in
1064        // the next augmented-message byte.  Complete the division.
1065        byte_type const  byte_index = rem >> ( Bits - CHAR_BIT );
1066        rem <<= CHAR_BIT;
1067        rem |= *p;
1068        rem ^= crc_table_type::table_[ byte_index ];
1069    }
1070
1071    return rem & masking_type::sig_bits_fast;
1072}
1073
1074template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly >
1075inline
1076typename uint_t<Bits>::fast
1077augmented_crc
1078(
1079    void const *  buffer,
1080    std::size_t   byte_count
1081    BOOST_ACRC_DUMMY_INIT
1082)
1083{
1084   // The last function argument has its type specified so the other version of
1085   // augmented_crc will be called.  If the cast wasn't in place, and the
1086   // BOOST_ACRC_DUMMY_INIT added a third argument (for a workaround), the "0"
1087   // would match as that third argument, leading to infinite recursion.
1088   return augmented_crc<Bits, TruncPoly>( buffer, byte_count,
1089    static_cast<typename uint_t<Bits>::fast>(0) );
1090}
1091
1092
1093}  // namespace boost
1094
1095
1096// Undo header-private macros
1097#undef BOOST_CRC_OPTIMAL_NAME
1098#undef BOOST_ACRC_DUMMY_INIT
1099#undef BOOST_ACRC_DUMMY_PARM_TYPE
1100#undef BOOST_CRC_DUMMY_INIT
1101#undef BOOST_CRC_DUMMY_PARM_TYPE
1102#undef BOOST_CRC_PARM_TYPE
1103
1104
1105#endif  // BOOST_CRC_HPP
1106
Note: See TracBrowser for help on using the repository browser.