Changeset 526 in xtideuniversalbios for trunk/Serial_Server/library/Checksum.cpp

Timestamp:

Mar 15, 2013, 1:38:58 AM (11 years ago)

Author:

krille_n_@…

google:author:

krille_n_@hotmail.com

Message:

Changes:

• Update of the copyright notices to include the year 2013.

File:

• trunk/Serial_Server/library/Checksum.cpp (modified) (19 diffs)

trunk/Serial_Server/library/Checksum.cpp

@@ -6 +6 @@
 
 //
-// XTIDE Universal BIOS and Associated Tools 
-// Copyright (C) 2009-2010 by Tomi Tilli, 2011-2012 by XTIDE Universal BIOS Team.
+// XTIDE Universal BIOS and Associated Tools
+// Copyright (C) 2009-2010 by Tomi Tilli, 2011-2013 by XTIDE Universal BIOS Team.
 //
 // This program is free software; you can redistribute it and/or modify
@@ -13 +13 @@
 // the Free Software Foundation; either version 2 of the License, or
 // (at your option) any later version.
-// 
+//
 // This program is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.     
+// GNU General Public License for more details.
 // Visit http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 //
 
 //
-// This file implements Fletcher's Checksum.  The serial code uses this checksum, as it is very quick 
+// This file implements Fletcher's Checksum.  The serial code uses this checksum, as it is very quick
 // to calculate in assembly and offers reasonable error detection.
 // For more information, see http://en.wikipedia.org/wiki/Fletcher%27s_checksum.
 //
-// Since it is faster in 8088 assembly code to deal with 16-bit quantities than 8-bit quantities, 
+// Since it is faster in 8088 assembly code to deal with 16-bit quantities than 8-bit quantities,
 // Fletcher's Checksum has been modified to calculate the 32-bit checksum, and then "fold" the result into a
-// 16-bit quantity.  Fletcher's 32-bit Checksum consists of two parts: concatenated 16-bit accumulators.  
-// To "fold" to 16-bits, The upper and lower 8-bits of each of these accumulators is XOR'd independently, and then 
+// 16-bit quantity.  Fletcher's 32-bit Checksum consists of two parts: concatenated 16-bit accumulators.
+// To "fold" to 16-bits, The upper and lower 8-bits of each of these accumulators is XOR'd independently, and then
 // the two results concatenated together, resulting in 16-bits.  Although simpler, an early attempt to XOR the
 // 16-bit accumulators results in poorer error detection behavior.  Folding as described here results in error
@@ -35 +35 @@
 //
 // With #define CHECKSUM_TEST, this file becomes a self-contained command line program that runs
-// some statistical tests comparing various checksum algorithms with random 512-byte sectors and various 
+// some statistical tests comparing various checksum algorithms with random 512-byte sectors and various
 // levels of errors introduced.
 //
@@ -58 +58 @@
     b = (b & 0xffff) + (b >> 16);
 
-// Although tempting to use, for its simplicity and size/speed in assembly, the following folding 
+// Although tempting to use, for its simplicity and size/speed in assembly, the following folding
 // algorithm results in many undetected single bit errors and therefore should not be used.
 //  return( (unsigned short) (a ^ b) );
@@ -68 +68 @@
 
 //====================================================================================================
-// 
+//
 // Test Code
 //
@@ -82 +82 @@
 unsigned char bit[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
 
-class algorithm 
+class algorithm
 {
 public:
@@ -113 +113 @@
 
 //----------------------------------------------------------------------------------------------------
-// 
+//
 // Standard CRC-16
 //
@@ -131 +131 @@
         unsigned short j;
 
-        for(i = 0; i < 256; ++i) 
+        for(i = 0; i < 256; ++i)
         {
             value = 0;
@@ -147 +147 @@
     }
 
-    unsigned short checksum( unsigned char *data, int len );  
+    unsigned short checksum( unsigned char *data, int len );
 
 private:
@@ -158 +158 @@
     int i;
 
-    for(i = 0; i < len; ++i) 
+    for(i = 0; i < len; ++i)
     {
         unsigned char index = (unsigned char)(crc ^ data[i]);
@@ -168 +168 @@
 
 //----------------------------------------------------------------------------------------------------
-// 
+//
 // Basic checksum (just add up the bytes)
 //
@@ -175 +175 @@
 {
 public:
-    unsigned short checksum( unsigned char *data, int len );  
+    unsigned short checksum( unsigned char *data, int len );
     basic_algorithm( algorithm *last ) : algorithm( last, (char *) "basic" ) { };
 };
@@ -193 +193 @@
 {
 public:
-    unsigned short checksum( unsigned char *data, int len );  
+    unsigned short checksum( unsigned char *data, int len );
     fletcher16_algorithm( algorithm *last ) : algorithm( last, (char *) "f-16" ) { }
 };
@@ -213 +213 @@
 
 //----------------------------------------------------------------------------------------------------
-// 
+//
 // Folded Fletcher's Checksum (what we use in the serial code, from the top of this file)
 //
@@ -220 +220 @@
 {
 public:
-    unsigned short checksum( unsigned char *data, int len );  
+    unsigned short checksum( unsigned char *data, int len );
     folded_fletcher32_algorithm( algorithm *last ) : algorithm( last, (char *) "fold-f-32" ) { }
 };
@@ -230 +230 @@
 
 //----------------------------------------------------------------------------------------------------
-// 
+//
 // Test Driver and Support routines
 //
@@ -283 +283 @@
     {
         a->found = (unsigned long *) calloc( BUCKETS, sizeof(long) );
-        
+
         a->zero = (unsigned long) a->checksum( bbuff, BBUFF_LENGTH );
 
         a->min = iterations+1;
     }
-    
+
     printf( "\n" );
     PRINTROW( "zero   ", "%10d  ", a->zero );
@@ -344 +344 @@
 
             bbuff[ rand() % 512 ] ^= bit[ rand() % 8 ];
-            
+
             if( b > 0 )
             {
@@ -354 +354 @@
             }
         }
-    }  
+    }
 
     printf( "\nbit change test:\n" );