发个在AS/400上可以跑的算CRC32的C程序

ux400

发个在AS/400上可以跑的算CRC32的C程序

1. 
   
2. /*                                                                              
   
3.    CRC32F.c -- Calculate CRC32 for a file                                       
   
4.    M.L.Y  2005.5                                                               
   
5.                                                                                 
   
6.    MODIFIED   (YYYY.MM.DD)                                                      
   
7.     M.L.Y      2005.05.   -  Creation                                          
   
8. */                                                                              
   
9.                                                                                 
   
10. #ifdef __OS400__                      /* AS/400 */                              
    
11.   #include "CRC32FH"                                                            
    
12. #else                                                                           
    
13. # include "CRC32F.h"                                                            
    
14. #endif                                                                          
    
15.                                                                                 
    
16. #include <stdlib.h>                                                            
    
17.                                                                                 
    
18. USGL CRC32Table[256] = {0, 0};                                                  
    
19.                                                                                 
    
20. #define CRC32_POLYNOMIAL     0xEDB88320UL                                       
    
21.                                                                                 
    
22. /* ------------------------------------------------------------------------- */
    
23. void BuildCRC32Table(USGL aPoly)                                                
    
24. /*                                                                              
    
25.    构造 32 位 CRC 表                                                      
    
26. */                                                                              
    
27. {                                                                              
    
28.   int  i;                                                                       
    
29.   int  j;                                                                       
    
30.   USGL crc;                                                                     
    
31.                                                                                 
    
32.   for(i = 0; i <= 255 ; i++)                                                   
    
33.   {                                                                             
    
34.     crc = i;                                                                    
    
35.     for(j = 8 ; j > 0; j--)                                                     
    
36.     {                                                                           
    
37.       if(crc & 1)                                                               
    
38.         crc = (crc >> 1) ^ aPoly;                                               
    
39.       else                                                                     
    
40.         crc >>= 1;                                                              
    
41.     }                                                                           
    
42.     CRC32Table[i] = crc;                                                        
    
43.   }                                                                             
    
44. }                                                                              
    
45.                                                                                 
    
46. /* ------------------------------------------------------------------------- */
    
47. USGL CalculateBufferCRC32(void *buffer, USGI count, USGL crc)                  
    
48. {                                                                              
    
49.   USGC *p;                                                                     
    
50.   USGL temp1;                                                                  
    
51.   USGL temp2;                                                                  
    
52.                                                                                 
    
53.   if(CRC32Table[1] == 0)                                                        
    
54.     BuildCRC32Table(CRC32_POLYNOMIAL);                                          
    
55.   p = (USGC*) buffer;                                                           
    
56.   while(count-- != 0)                                                           
    
57.   {                                                                             
    
58.     temp1 = (crc >> 8) & 0x00FFFFFFUL;                                          
    
59.     temp2 = CRC32Table[((int) crc ^ *p++) & 0xff];                              
    
60.     crc = temp1 ^ temp2;                                                        
    
61.   }                                                                             
    
62.   return crc;                                                                  
    
63. }                                                                              
    
64.                                                                                 
    
65. /* ------------------------------------------------------------------------- */
    
66. USGL CalculateFileCRC32(FILE *fp)                                               
    
67. {                                                                              
    
68.   USGL crc;                                                                     
    
69.   int  count;                                                                  
    
70.   USGC buffer[512];                                                            
    
71.                                                                                 
    
72.   crc = 0xFFFFFFFFUL;                                                           
    
73.   for( ; ;)                                                                     
    
74.   {                                                                             
    
75.     count = fread(buffer, 1, 512, fp);                                          
    
76.     if(count == 0)                                                              
    
77.       break;                                                                    
    
78.     crc = CalculateBufferCRC32(buffer, count, crc);                             
    
79.   }                                                                             
    
80.   return(crc ^= 0xFFFFFFFFUL);                                                  
    
81. }                                                                              
    
82.                                                                                 
    
83. /* ------------------------------------------------------------------------- */
    
84. USGL CalculateStringCRC32(void *buffer, USGI len)                              
    
85. /*                                                                              
    
86.    计算字符串的 32 位 CRC 值                                             
    
87. */                                                                              
    
88. {                                                                              
    
89.   USGL crc;                                                                     
    
90.                                                                                 
    
91.   if(CRC32Table[1] == 0)                                                        
    
92.     BuildCRC32Table(CRC32_POLYNOMIAL);                                          
    
93.   crc = 0xFFFFFFFFUL;                                                           
    
94.   crc = CalculateBufferCRC32(buffer, len, crc);                                 
    
95.   return (crc ^= 0xFFFFFFFFUL);                                                
    
96. }                                                                              
    
97.                                                                                 
    
98. /* ------------------------------------------------------------------------- */
    
99. int  DispFileCRC32(char *filename)                                             
    
100. {                                                                              
     
101.   FILE *fp;                                                                     
     
102.   USGL crc;                                                                     
     
103.                                                                                 
     
104.   fp = fopen(filename, "rb");                                                   
     
105.   if(fp == NULL )                                                               
     
106.   {                                                                             
     
107.     printf("Error: could not open file %s!\n", filename);                       
     
108.     return -1;                                                                  
     
109.   }                                                                             
     
110.   crc = CalculateFileCRC32(fp);                                                
     
111.   fclose(fp);                                                                  
     
112.   printf("CRC32: %08lX\n", crc);                                                
     
113.   return 0;                                                                     
     
114. }                                                                              
     
115.                                                                                 
     
116. /* ------------------------------------------------------------------------- */
     
117. long filesize(FILE *stream)                                                     
     
118. {                                                                              
     
119.   long curpos, length;                                                         
     
120.                                                                                 
     
121.   curpos = ftell(stream);                                                      
     
122.   fseek(stream, 0L, SEEK_END);                                                  
     
123.   length = ftell(stream);                                                      
     
124.   fseek(stream, curpos, SEEK_SET);                                             
     
125.   return length;                                                               
     
126. }                                                                              
     
127.                                                                                 
     
128. /* ------------------------------------------------------------------------- */
     
129. int  FileCRC32(char *filename)                                                  
     
130. {                                                                              
     
131.   FILE *fp;                                                                     
     
132.   USGL crc;                                                                     
     
133.   char *str;                                                                    
     
134.   USGI flen;                                                                    
     
135.                                                                                 
     
136.   fp = fopen(filename, "rb");                                                   
     
137.   if(fp == NULL )                                                               
     
138.   {                                                                             
     
139.     printf("Error: could not open file %s!\n", filename);                       
     
140.     return -1;                                                                  
     
141.   }                                                                             
     
142.   flen = filesize(fp);                                                         
     
143.   /* allocate memory for string */                                             
     
144.   if((str = (char *) malloc((USGI)flen)) == NULL)                              
     
145.   {                                                                             
     
146.     printf("Not enough memory to allocate buffer\n");                           
     
147.     fclose(fp);                                                                 
     
148.     exit(1);  /* terminate program if out of memory */                          
     
149.   }                                                                             
     
150.   fread(str, 1, flen, fp);                                                      
     
151.   fclose(fp);                                                                  
     
152.   crc = CalculateStringCRC32(str, flen);                                       
     
153.   printf("string CRC32: %08lX\n", crc);                                         
     
154.   /* free memory */                                                            
     
155.   free(str);                                                                    
     
156.   return 0;                                                                     
     
157. }                                                                              
     
158.                                                                                 
     
159. /* ------------------------------------------------------------------------- */
     
160. int  main(int argc, char *argv[])                                               
     
161. {                                                                              
     
162.   printf("CRC32F -- 计算文件的 CRC32 值\n");                                
     
163.   if(argc != 2)                                                                 
     
164.   {                                                                             
     
165.     printf("用法：CRC32F 文件名\n");                                       
     
166.     return 1;                                                                  
     
167.   }                                                                             
     
168.   printf("\nCalculating ...\n");                                                
     
169.   DispFileCRC32(argv[1]);                                                      
     
170.   FileCRC32(argv[1]);                                                           
     
171.   return 0;                                                                     
     
172. }                                                                              
     
173.                                                                                 
     
174. /* End of file */                                                               
     
175. 
     

复制代码

[ 本帖最后由 ux400 于 2008-8-26 17:57 编辑 ]

ux400

头文件：

1. 
   
2. /*                                                                              
   
3.    CRC32F.h -- Calculate CRC32 for a file                                       
   
4.    M.L.Y  2005.5                                                               
   
5.                                                                                 
   
6.    MODIFIED   (YYYY.MM.DD)                                                      
   
7.     M.L.Y      2005.05.   -  Creation                                          
   
8. */                                                                              
   
9.                                                                                 
   
10. #ifndef  USG_TYPE                                                               
    
11. # define USG_TYPE                                                               
    
12.   typedef unsigned char  USGC;                                                  
    
13.   typedef unsigned short USGS;                                                  
    
14.   typedef unsigned int   USGI;                                                  
    
15.   typedef unsigned long  USGL;                                                  
    
16. #endif                                                                          
    
17.                                                                                 
    
18. #include <stdio.h>                                                              
    
19.                                                                                 
    
20. void BuildCRC32Table(USGL aPoly);                                               
    
21. USGL CalculateBufferCRC32(void *buffer, USGI count, USGL crc);                  
    
22. USGL CalculateFileCRC32(FILE *file);                                            
    
23. USGL CalculateStringCRC32(void *buffer, USGI len);                              
    
24. int  DispFileCRC32(char *filename);                                             
    
25.                                                                                 
    
26. /* End of file */                                                               
    
27. 
    

复制代码

[ 本帖最后由 ux400 于 2008-8-26 17:58 编辑 ]

ux400

论坛中“crc; ”竟然会变成斜体？

ux400

原来要用 code  标签