(*----------------------------------------------------------------------*)
(*             Update_Crc --- Update cyclic redundancy check            *)
(*----------------------------------------------------------------------*)

VAR                                (* Easier addressing in INLINE *)
   Global_Crc : INTEGER;

FUNCTION Update_Crc( Old_Crc : INTEGER; C : BYTE ) : INTEGER;

(*----------------------------------------------------------------------*)
(*                                                                      *)
(*     Function:   Update_Crc                                           *)
(*                                                                      *)
(*     Purpose:    Computes cyclic redundancy check for 1 character     *)
(*                                                                      *)
(*     Calling Sequence:                                                *)
(*                                                                      *)
(*        New_Crc := Update_Crc( Old_Crc : INTEGER;                     *)
(*                               C       : BYTE ) : INTEGER;            *)
(*                                                                      *)
(*           Old_Crc --- previous CRC value.                            *)
(*           C       --- character for which CRC is computed.           *)
(*           New_Crc --- updated CRC.                                   *)
(*                                                                      *)
(*     Calls:    None                                                   *)
(*                                                                      *)
(*     Remarks:  An equivalent Pascal routine for this inline code is:  *)
(*                                                                      *)
(*----------------------------------------------------------------------*)
(*                                                                      *)
(*    FUNCTION Update_Crc( Old_Crc : INTEGER; C : BYTE ) : INTEGER;     *)
(*                                                                      *)
(*    VAR                                                               *)
(*       I     : INTEGER;                                               *)
(*       Carry : BOOLEAN;                                               *)
(*                                                                      *)
(*    BEGIN                                                             *)
(*                                                                      *)
(*       FOR I := 1 TO 8 DO                                             *)
(*          BEGIN                                                       *)
(*                                                                      *)
(*             Carry   := ( Old_Crc AND $8000 ) <> 0;                   *)
(*             Old_Crc := Old_Crc SHL 1;                                *)
(*                                                                      *)
(*             IF ( C AND $80 ) <> 0 THEN                               *)
(*                Old_Crc := Old_Crc OR 1;                              *)
(*                                                                      *)
(*             IF Carry THEN                                            *)
(*                Old_Crc := Old_Crc XOR $1021;                         *)
(*                                                                      *)
(*             C       := C SHL 1;                                      *)
(*                                                                      *)
(*          END;                                                        *)
(*                                                                      *)
(*       Update_Crc := Old_Crc;                                         *)
(*                                                                      *)
(*    END;                                                              *)
(*                                                                      *)
(*----------------------------------------------------------------------*)

BEGIN (* Update_Crc *)

   Global_Crc := Old_Crc;

   INLINE(   $8A / $46 / $04 /        (* Mov     Al,[Bp+4]     *)
             $8B / $1E / Global_Crc / (* Mov     Bx,Global_Crc *)
             $B9 / $08 / $00 /        (* Mov     Cx,8          *)
(* Oloop *)  $D0 / $E0 /              (* Shl     Al,1          *)
             $D1 / $D3 /              (* Rcl     Bx,1          *)
             $73 / $04 /              (* Jnc     Iloop         *)
             $81 / $F3 / $21 / $10 /  (* Xor     Bx,$1021      *)
(* Iloop *)  $E2 / $F4 /              (* Loop    Oloop         *)
             $89 / $1E / Global_Crc ) (* Mov     Global_Crc,BX *);

   Update_Crc := Global_Crc;

END   (* Update_Crc *);