source/crc32.cpp

   1 #include <ail/crc32.hpp>
   2 #include <ail/array.hpp>
   3
   4 namespace ail
   5 {
   6         namespace
   7         {
   8                 ulong crc32_table[256];
   9
  10                 struct initialise_crc32_table
  11                 {
  12                         initialise_crc32_table()
  13                         {
  14                                 char const polynomial_terms[] =
  15                                 {
  16                                          0,  1,  2,  4,  5,  7,  8,
  17                                         10, 11, 12, 16, 22,     23, 26
  18                                 };
  19
  20                                 ulong polynomial_pattern = 0;
  21                                 for(std::size_t i = 0; i < sizeof(polynomial_terms); ++i)
  22                                 {
  23                                         ulong shifts = 31 - polynomial_terms[i];
  24                                         polynomial_pattern |= 1 << shifts;
  25                                 }
  26
  27                                 for(std::size_t i = 0; i < ail::countof(crc32_table); ++i)
  28                                 {
  29                                         ulong new_table_entry = static_cast<ulong>(i);
  30                                         for(int j = 0; j < 8; ++j)
  31                                         {
  32                                                 bool first_bit_was_set = (new_table_entry & 1);
  33                                                 new_table_entry >>= 1;
  34                                                 if(first_bit_was_set == true)
  35                                                         new_table_entry ^= polynomial_pattern;
  36                                                 crc32_table[i] = new_table_entry;
  37                                         }
  38                                 }
  39                         }
  40                 }
  41                         crc32_initialiser;
  42         }
  43
  44         crc32::crc32():
  45                 sum(0)
  46         {
  47         }
  48
  49         crc32::crc32(char const * data, std::size_t size):
  50                 sum(0)
  51         {
  52                 hash(data, size);
  53         }
  54
  55         ulong crc32::hash(char const * data, std::size_t size)
  56         {
  57                 sum ^= 0xffffffff;
  58                 while(size > 0)
  59                 {
  60                         ulong index = (*data ^ sum) & 0xff;
  61                         ulong shifted_sum = sum >> 8;
  62                         sum = crc32_table[index] ^ shifted_sum;
  63                         --size;
  64                         ++data;
  65                 }
  66                 sum ^= 0xffffffff;
  67                 return sum;
  68         }
  69
  70         ulong crc32::checksum() const
  71         {
  72                 return sum;
  73         }
  74 }