home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast2.iso / turbopas / crc.pas < prev    next >
Pascal/Delphi Source File  |  1994-03-05  |  5KB  |  109 lines
  1. (*
  2. The example of how to to CRC a stream of bytes (CRC.ASM)
  3. in <INFO-IBMPC> is relatively worthless.  I needed to compute
  4. a running CRC during file encryption to insure the file hadn't
  5. been hit somehow.  Figure you all might be able to use a more
  6. practical implementation of the cyclic redundancy check.
  7. And, no, I do NOT know which one this is, and I do NOT know if
  8. it's the "legal", kosher, full-house CRC or not .. and I don't
  9. care!  What counts is that this returns a value after a stream
  10. of bytes, and if a single bit in that stream changes, the
  11. crc value changes.  And THAT's what I wanted.  You want something
  12. else .. you write something else.
  13.  
  14. I cribbed the following assembler code from a recent MS-DOS
  15. Kermit.  Incorporate the various types, constants, etc., into
  16. your code, and just send the procedure a byte.  When all
  17. done, grab the resultant crcval integer and use it as you will.
  18.  
  19. Remember to initialize crcval to 0 when you begin each run.
  20.  
  21. I just hacked this thing .. it SEEMS to work just fine, and
  22. sure 'nuff, crcval remains consistent when repeatedly fed a long
  23. (100+ Kb) stream of bytes, yet changes with a single bit changed
  24. in that stream.
  25.  
  26. But if it doesn't .. would appreciate any improvements.  I'm VERY
  27. shakey with 8086/8088 assembler right now, and there might be
  28. some silly things in the code!  (Like:  I KNOW crcval doesn't HAVE
  29. to be in the code segment .. but in my particular application,
  30. I needed it there.)
  31.  
  32. Released to public domain.  I am the author of this particular
  33. translation, but the people who put together MS-DOS Kermit deserve
  34. the credit .. and of course they cribbed the routine from others ..
  35. and on and on in the true Public Domain fashion.
  36.  
  37. Distribution and copying encouraged (if it works).  Use it commercially
  38. even, if the Kermit guys don't care.  But leave the Kermit (and my)
  39. credits in it.
  40.  
  41. Regards,
  42. David Kirschbaum
  43. Toad Hall
  44. ABN.ISCAMS@USC-ISID.ARPA
  45. ________ CUT HERE ________
  46. *)
  47.  
  48. TYPE
  49.   CRCTable    = ARRAY[1..32] OF BYTE;
  50.   {yeah, yeah, it COULD be an array of integers .. but I used
  51.    these two tables for something else later in my application.
  52.    So I don't KNOW if it'll work as integers.  YOU try it.  [TH]
  53.   }
  54. CONST
  55.   crc  : INTEGER =    0;  {typed constant to force it into code segment}
  56.  
  57. crctab : CRCTable =
  58.       ($00,$00, $10,$81, $21,$02, $31,$83,
  59.        $42,$04, $52,$85, $63,$06, $73,$87,
  60.        $84,$08, $94,$89, $A5,$0A, $B5,$8B,
  61.        $C6,$0C, $D6,$8D, $E7,$0E, $F7,$8F);
  62.  
  63. crctb2 : CRCTable =
  64.       ($00,$00, $11,$89, $23,$12, $32,$9B,
  65.        $46,$24, $57,$AD, $65,$36, $74,$BF,
  66.        $8C,$48, $9D,$C1, $AF,$5A, $BE,$D3,
  67.        $CA,$6C, $DB,$E5, $E9,$7E, $F8,$F7);
  68.  
  69. VAR
  70.   crcval     : INTEGER Absolute crc;    {force it into code segment}
  71.  
  72. PROCEDURE DoCRC(chrval : BYTE);
  73.   {courtesy of MS-Kermit and Toad Hall, Nov 85}
  74.   {computes ongoing CRC.  assumes CRC table has been
  75.    established as a typed constant so CS can access it.
  76.    Notice we aren't changing chrval at all .. just using
  77.    it to modify our running crc value.
  78.   }
  79.  
  80.   BEGIN
  81.   inline
  82. ($2E/$8B/$16/crcval/    {mov dx,CS:crcval ;get current CRC value.}
  83. $8A/$86/chrval/         {mov al,chrval[BP] ; Get char ord  }
  84. $32/$C2/                {xor al,dl        ; Xor input with lo order
  85.                                             byte of CRC.   }
  86. $8A/$E0/                {mov ah,al        ; Get a copy.    }
  87. $80/$E4/$F0/            {and ah,0F0H      ; Get hi 4 bits  }
  88. $B1/$04/                {mov cl,4                          }
  89. $D2/$EC/                {shr ah,cl        ; Right justify  }
  90. $24/$0F/                {and al,0FH       ; Get lo 4 bits  }
  91. $BE/crctb2/             {mov si,offset CS:crctb2 ; Low portion
  92.                                             of CRC factor  }
  93. $B7/$00/                {mov bh,0                          }
  94. $8A/$D8/                {mov bl,al                         }
  95. $02/$D8/                {add bl,al        ; Get word index }
  96. $2E/$8B/$08/            {mov cx,CS:[si+bx] ; Low portion.  }
  97. $BE/crctab/             {mov si,offset CS:crctab ; High portion
  98.                                             of CRC factor. }
  99. $B7/$00/                {mov bh,0                          }
  100. $8A/$DC/                {mov bl,ah                         }
  101. $02/$DC/                {add bl,ah        ; Get word index }
  102. $2E/$8B/$18/            {mov bx,CS:[si+bx]                 }
  103. $33/$D9/                {xor bx,cx        ; Add the two.   }
  104. $B1/$08/                {mov cl,8                          }
  105. $D3/$EA/                {shr dx,cl        ; Shift CRC 8 bits to the right.}
  106. $33/$D3/                {xor dx,bx        ; XOR table value and CRC.}
  107. $2E/$89/$16/crcval);    {mov CS:crcval,dx ; save new value }
  108. END;  {of DoCRC}
  109.