[PEN_CHECKING_STYLE(NONE)] MODULE PASCAL$DCX_ROUTINES;
{   © Copyright 2005 Hewlett-Packard Development Company, L.P.                 }
{                                                                              }
{   Confidential computer software.  Valid license from HP and/or              }
{   its subsidiaries required for possession, use, or copying.                 }
{                                                                              }
{   Consistent with FAR 12.211 and 12.212, Commercial Computer Software,       }
{   Computer Software Documentation, and Technical Data for Commercial         }
{   Items are licensed to the U.S. Government under vendor's standard          }
{   commercial license.                                                        }
{                                                                              }
{   Neither HP nor any of its subsidiaries shall be liable for technical       }
{   or editorial errors or omissions contained herein.  The information        }
{   in this document is provided "as is" without warranty of any kind and      }
{   is subject to change without notice.  The warranties for HP products       }
{   are set forth in the express limited warranty statements accompanying      }
{   such products.  Nothing herein should be construed as constituting an      }
{   additional warranty.                                                       }
{                                                                              }

[HIDDEN] TYPE	(**** Pre-declared data types ****)
	$BYTE = [BYTE] -128..127;
	$WORD = [WORD] -32768..32767;
	$QUAD = [QUAD,UNSAFE] RECORD
		L0:UNSIGNED; L1:INTEGER; END;
	$OCTA = [OCTA,UNSAFE] RECORD
		L0,L1,L2:UNSIGNED; L3:INTEGER; END;
	$UBYTE = [BYTE] 0..255;
	$UWORD = [WORD] 0..65535;
	$UQUAD = [QUAD,UNSAFE] RECORD
		L0,L1:UNSIGNED; END;
	$UOCTA = [OCTA,UNSAFE] RECORD
		L0,L1,L2,L3:UNSIGNED; END;
	$PACKED_DEC = [BIT(4),UNSAFE] 0..15;
	$DEFTYP = [UNSAFE] INTEGER;
	$DEFPTR = [UNSAFE] ^$DEFTYP;
	$BOOL = [BIT(1),UNSAFE] BOOLEAN;
	$BIT  = [BIT(1),UNSAFE] BOOLEAN;
	$BIT2 = [BIT(2),UNSAFE] 0..3;
	$BIT3 = [BIT(3),UNSAFE] 0..7;
	$BIT4 = [BIT(4),UNSAFE] 0..15;
	$BIT5 = [BIT(5),UNSAFE] 0..31;
	$BIT6 = [BIT(6),UNSAFE] 0..63;
	$BIT7 = [BIT(7),UNSAFE] 0..127;
	$BIT8 = [BIT(8),UNSAFE] 0..255;
	$BIT9 = [BIT(9),UNSAFE] 0..511;
	$BIT10 = [BIT(10),UNSAFE] 0..1023;
	$BIT11 = [BIT(11),UNSAFE] 0..2047;
	$BIT12 = [BIT(12),UNSAFE] 0..4095;
	$BIT13 = [BIT(13),UNSAFE] 0..8191;
	$BIT14 = [BIT(14),UNSAFE] 0..16383;
	$BIT15 = [BIT(15),UNSAFE] 0..32767;
	$BIT16 = [BIT(16),UNSAFE] 0..65535;
	$BIT17 = [BIT(17),UNSAFE] 0..131071;
	$BIT18 = [BIT(18),UNSAFE] 0..262143;
	$BIT19 = [BIT(19),UNSAFE] 0..524287;
	$BIT20 = [BIT(20),UNSAFE] 0..1048575;
	$BIT21 = [BIT(21),UNSAFE] 0..2097151;
	$BIT22 = [BIT(22),UNSAFE] 0..4194303;
	$BIT23 = [BIT(23),UNSAFE] 0..8388607;
	$BIT24 = [BIT(24),UNSAFE] 0..16777215;
	$BIT25 = [BIT(25),UNSAFE] 0..33554431;
	$BIT26 = [BIT(26),UNSAFE] 0..67108863;
	$BIT27 = [BIT(27),UNSAFE] 0..134217727;
	$BIT28 = [BIT(28),UNSAFE] 0..268435455;
	$BIT29 = [BIT(29),UNSAFE] 0..536870911;
	$BIT30 = [BIT(30),UNSAFE] 0..1073741823;
	$BIT31 = [BIT(31),UNSAFE] 0..2147483647;
	$BIT32 = [BIT(32),UNSAFE] UNSIGNED;
 
 
(* MODULE DCX$ROUTINES ;                                                    *)
 
(* [HIDDEN] TYPE	(**** Pre-declared data types ***??                 *)
(* 	$BYTE = [BYTE] -128..127;                                           *)
(* 	$WORD = [WORD] -32768..32767;                                       *)
(* 	$QUAD = [QUAD,UNSAFE] RECORD                                        *)
(* 		L0:UNSIGNED; L1:INTEGER; END;                               *)
(* 	$OCTA = [OCTA,UNSAFE] RECORD                                        *)
(* 		L0,L1,L2:UNSIGNED; L3:INTEGER; END;                         *)
(* 	$UBYTE = [BYTE] 0..255;                                             *)
(* 	$UWORD = [WORD] 0..65535;                                           *)
(* 	$UQUAD = [QUAD,UNSAFE] RECORD                                       *)
(* 		L0,L1:UNSIGNED; END;                                        *)
(* 	$UOCTA = [OCTA,UNSAFE] RECORD                                       *)
(* 		L0,L1,L2,L3:UNSIGNED; END;                                  *)
(* 	$UOCTAQUAD = [OCTA(2),UNSAFE] RECORD                                *)
(* 		L0,L1,L2,L3,L4,L5,L6,L7:UNSIGNED; END;                      *)
(* 	$PACKED_DEC = [BIT(4),UNSAFE] 0..15;                                *)
(* 	$DEFTYP = [UNSAFE] INTEGER;                                         *)
(* 	$DEFPTR = [UNSAFE] ^$DEFTYP;                                        *)
(* 	$BOOL = [BIT(1),UNSAFE] BOOLEAN;                                    *)
(* 	$BIT2 = [BIT(2),UNSAFE] 0..3;                                       *)
(* 	$BIT3 = [BIT(3),UNSAFE] 0..7;                                       *)
(* 	$BIT4 = [BIT(4),UNSAFE] 0..15;                                      *)
(* 	$BIT5 = [BIT(5),UNSAFE] 0..31;                                      *)
(* 	$BIT6 = [BIT(6),UNSAFE] 0..63;                                      *)
(* 	$BIT7 = [BIT(7),UNSAFE] 0..127;                                     *)
(* 	$BIT8 = [BIT(8),UNSAFE] 0..255;                                     *)
(* 	$BIT9 = [BIT(9),UNSAFE] 0..511;                                     *)
(* 	$BIT10 = [BIT(10),UNSAFE] 0..1023;                                  *)
(* 	$BIT11 = [BIT(11),UNSAFE] 0..2047;                                  *)
(* 	$BIT12 = [BIT(12),UNSAFE] 0..4095;                                  *)
(* 	$BIT13 = [BIT(13),UNSAFE] 0..8191;                                  *)
(* 	$BIT14 = [BIT(14),UNSAFE] 0..16383;                                 *)
(* 	$BIT15 = [BIT(15),UNSAFE] 0..32767;                                 *)
(* 	$BIT16 = [BIT(16),UNSAFE] 0..65535;                                 *)
(* 	$BIT17 = [BIT(17),UNSAFE] 0..131071;                                *)
(* 	$BIT18 = [BIT(18),UNSAFE] 0..262143;                                *)
(* 	$BIT19 = [BIT(19),UNSAFE] 0..524287;                                *)
(* 	$BIT20 = [BIT(20),UNSAFE] 0..1048575;                               *)
(* 	$BIT21 = [BIT(21),UNSAFE] 0..2097151;                               *)
(* 	$BIT22 = [BIT(22),UNSAFE] 0..4194303;                               *)
(* 	$BIT23 = [BIT(23),UNSAFE] 0..8388607;                               *)
(* 	$BIT24 = [BIT(24),UNSAFE] 0..16777215;                              *)
(* 	$BIT25 = [BIT(25),UNSAFE] 0..33554431;                              *)
(* 	$BIT26 = [BIT(26),UNSAFE] 0..67108863;                              *)
(* 	$BIT27 = [BIT(27),UNSAFE] 0..134217727;                             *)
(* 	$BIT28 = [BIT(28),UNSAFE] 0..268435455;                             *)
(* 	$BIT29 = [BIT(29),UNSAFE] 0..536870911;                             *)
(* 	$BIT30 = [BIT(30),UNSAFE] 0..1073741823;                            *)
(* 	$BIT31 = [BIT(31),UNSAFE] 0..2147483647;                            *)
(* 	$BIT32 = [BIT(32),UNSAFE] UNSIGNED;                                 *)
 
(*** MODULE DCX$ROUTINES IDENT X-1 ***)
 
(*---------------------------------------------------------------           *)
(*                                                                          *)
(* Data Compression/Expansion (DCX) Routines                                *)
(*                                                                          *)
(*                                                                          *)
(* DCX$ANALYZE_DATA - Analyze a data record                                 *)
(*                                                                          *)
(* status = DCX$ANALYZE_DATA (context, record)                              *)
(*                                                                          *)
(*  context - Context value returned by DCX$ANALYZE_INIT                    *)
(*  record  - Record to be analyzed                                         *)
 
[ASYNCHRONOUS] FUNCTION DCX$ANALYZE_DATA (
	CONTEXT : UNSIGNED;
	RECORD_ : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* DCX$ANALYZE_DONE - Complete analysis                                     *)
(*                                                                          *)
(* status = DCX$ANALYZE_DONE (context)                                      *)
(*                                                                          *)
(*  context - Context value returned by DCX$ANALYZE_INIT                    *)
 
[ASYNCHRONOUS] FUNCTION DCX$ANALYZE_DONE (
	VAR CONTEXT : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* DCX$ANALYZE_INIT - Initialize context for analysis                       *)
(*                                                                          *)
(* status = DCX$ANALYZE_INIT (context [,item_code, item_value])             *)
(*                                                                          *)
(*  context   - Receives context value for data stream                      *)
(*  item_code - Specifies information to be used during analysis            *)
(*  item_value - Value of information item                                  *)
(*  [Note - successive pairs of item_code and item_value can be passed      *)
(*   in the argument list]                                                  *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION DCX$ANALYZE_INIT (
	VAR CONTEXT : [VOLATILE] UNSIGNED;
	ITEM_CODE : UNSIGNED := %IMMED 0;
	ITEM_VALUE : [LIST] UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* DCX$COMPRESS_DATA - Compress a data record                               *)
(*                                                                          *)
(* status = DCX$COMPRESS_DATA (context, in_rec, out_rec, out_length)        *)
(*                                                                          *)
(*  context    - Value returned by DCX$COMPRESS_INIT                        *)
(*  in_rec     - Data record to be compressed                               *)
(*  out_rec    - Receives compressed record                                 *)
(*  out_length - Receives length of compressed record                       *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION DCX$COMPRESS_DATA (
	CONTEXT : UNSIGNED;
	IN_REC : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR;
	VAR OUT_REC : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR;
	VAR OUT_LENGTH : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* DCX$COMPRESS_DONE - Delete context for compression                       *)
(*                                                                          *)
(* status = DCX$COMPRESS_DONE (context)                                     *)
(*                                                                          *)
(*  context - Value returned by DCX$COMPRESS_INIT                           *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION DCX$COMPRESS_DONE (
	VAR CONTEXT : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* DCX$COMPRESS_INIT - Initialize context for compression                   *)
(*                                                                          *)
(* status = DCX$COMPRESS_INIT (context, map)                                *)
(*                                                                          *)
(*  context - Context value for this data stream                            *)
(*  map     - Map value returned by DCX$MAKE_MAP                            *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION DCX$COMPRESS_INIT (
	VAR CONTEXT : [VOLATILE] UNSIGNED;
	MAP : $DEFPTR) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* DCX$EXPAND_DATA - Expand a compressed data record                        *)
(*                                                                          *)
(* status = DCX$EXPAND_DATA (context, in_rec, out_rec [,out_length])        *)
(*                                                                          *)
(*  context    - Value returned by DCX$EXPAND_INIT                          *)
(*  in_rec     - Data record to be expanded                                 *)
(*  out_rec    - Receives expanded data record                              *)
(*  out_length - Receives length of expanded record                         *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION DCX$EXPAND_DATA (
	CONTEXT : UNSIGNED;
	IN_REC : [CLASS_S] PACKED ARRAY [$l2..$u2:INTEGER] OF CHAR;
	VAR OUT_REC : [CLASS_S,VOLATILE] PACKED ARRAY [$l3..$u3:INTEGER] OF CHAR;
	VAR OUT_LENGTH : [VOLATILE] $UWORD := %IMMED 0) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* DCX$EXPAND_DONE - Delete context for expansion                           *)
(*                                                                          *)
(* status = DCX$EXPAND_DONE (context)                                       *)
(*                                                                          *)
(*  context - Value returned by DCX$EXPAND_INIT                             *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION DCX$EXPAND_DONE (
	VAR CONTEXT : [VOLATILE] UNSIGNED) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* DCX$EXPAND_INIT - Initialize context for expansion                       *)
(*                                                                          *)
(* status = DCX$EXPAND_INIT (context, map)                                  *)
(*                                                                          *)
(*  context - Receives context value identifying data stream                *)
(*  map     - Map value returned by DCX$MAKE_MAP                            *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION DCX$EXPAND_INIT (
	VAR CONTEXT : [VOLATILE] UNSIGNED;
	MAP : $DEFPTR) : INTEGER; EXTERNAL;
 
(*                                                                          *)
(* DCX$MAKE_MAP - Compute compression/expansion map                         *)
(*                                                                          *)
(* status = DCX$MAKE_MAP (context, map_addr [, map_size])                   *)
(*                                                                          *)
(*  context - Value returned by DCX$ANALYZE_INIT                            *)
(*  map_addr - Receives address of allocated map data                       *)
(*  map_size - Receives size of allocated map data                          *)
(*                                                                          *)
 
[ASYNCHRONOUS] FUNCTION DCX$MAKE_MAP (
	CONTEXT : UNSIGNED;
	VAR MAP_ADDR : [VOLATILE] $DEFPTR;
	VAR MAP_SIZE : [VOLATILE] UNSIGNED := %IMMED 0) : INTEGER; EXTERNAL;
 
(* END.                                                                     *)
 
END.