，，单位压缩LZW文件，贡献者：伊恩猎人，（*，来自：伊恩亨特，主题：LZW压缩单元，*），单位ihlzw；，  {单元处理数据压缩}，接口，const，  StackOverflow = 1；，  deniedwrite = 2；，型，  getcharfunc =功能（VAR CH：char）：布尔；，  putcharproc =程序（CH：char）；，  LZW =对象，          getchar：getcharfunc；，          putchar：putcharproc；，          LastError：词；，          构造函数初始化；，          功能get_hash_code（prevc，先：整数）：整数；，          程序make_table_entry（prevc，先：整数），initialize_string_tab          程序；乐；，          程序初始化；，          功能lookup_string（prevc，先：整数）：整数；，          程序get_char（变量整数）；，          程序put_char（C：整数）；          程序，压缩，解压缩，          ；程序；          端；，实施，const，  maxtab = 4095；，  no_prev = 7fff美元；，  eof_char = 2；，  end_list = 1；，  空= 3；，类型，  anystr =字符串；，  string_table_entry =记录，    ：布尔；，    prevchar：整数；，    follchar：整数，    下；：整数；，    端；，VaR，  string_table：阵列[ 0 .. maxtab ]的，  table_used string_table_entry；：整数；，  output_code：整数；，  input_code：整数；，  if_compressing：布尔；，构造函数初始化；LZW。，开始，  LastError：= 0；，结束；，功能lzw.get_hash_code（prevc，先：整数）：整数；，VaR，  指数：整数；，  指数：整数；，开始，  指数：=（（prevc SHL 5）异或先）和maxtab；，  如果（不string_table [索引]。使用），    然后，      get_hash_code：=指数，    别的，      开始时，        （string_table [指数]。下<；>；end_list）做的，          指数：= string_table [索引]。下；，        指数：=（指数101）和maxtab；同时，        （string_table [指数]。使用）做的，          指数：=成功（指数）和maxTAB；，        string_table [索引]。下：=指数；，        get_hash_code：=指数；，      结束；结束；，，程序lzw.make_table_entry（prevc，先：整数）；，开始，  如果（table_used <；= maxtab），    然后，      开始，与string_table [ get_hash_code         （prevc，先做           ）]，开始，             用：= true；，             下：= end_list；，             prevchar：= prevc；，             follchar：=先；，           端；，         公司（table_used）；，（*，         如果（table_used >；（maxtab + 1然后，            ））开始，               Writeln（与# 39；哈希表满。与# 39；）；最后，            ；，*），      结束；结束；，程序，LZW。initialize_string_table；，VaR，  我：整数；，开始，  table_used：= 0；，  我：= 0 maxtab做，    与string_table [我]这样做，      开始，        prevchar：= no_prev；，        follchar：= no_prev；，        下：= 1；，        用：= false；，      端；，  我：= 0到255做的，    make_table_entry（no_prev，I）；，结束；，程序初始化LZW。；，开始，  output_code：=空；，  input_code：=空；，  initialize_string_table；，结束；，功能lzw.lookup_string（prevc，先：整数）：整数；，VaR，  指数：整数；，  Index2：整数；，  发现：布尔，乞求；in,   Index := ((PrevC Shl 5) Xor FollC) And MaxTab;,   Lookup_String := End_List;,   Repeat,     Found := (String_Table[Index].PrevChar = PrevC) And,              (String_Table[Index].FollChar = FollC);,     If (Not Found),       Then,         Index := String_Table [Index].Next;,   Until Found Or (Index = End_List);,   If Found,     Then,       Lookup_String := Index;, End;, Procedure LZW.Get_Char (Var C : Integer);, Var,   Ch : Char;, Begin,   If Not GetChar (Ch),     Then,       C := EOF_Char,     Else,       C := Ord (Ch);, End;, Procedure LZW.Put_Char (C : Integer);, Var,   Ch : Char;, Begin,   Ch := Chr (C);,   PutChar (Ch);, End;, Procedure LZW.C与  程序；，put_code（hash_code：整数）；，  开始，    如果（output_code =空），      然后，        开始，          put_char（（hash_code SHR 4）美元和法郎）；，          output_code：= hash_code美元，        结束，      中；否则，        开始，          put_char（（（output_code SHL 4）美元和ff0）+，                   （（hash_code SHR 8）和$ 00F））；，          put_char（hash_code美元和法郎）；，          output_code：=空；，        结束；结束，  ；，  程序do_compression；，  VaR，    C：整数；，    WC：整数；，    W：整数；，  开始，    get_char（C）；，    W = lookup_string（no_prev，C）；，    get_char（C）；同时，    （C <；>；eof_char）做的，      开始，        WC：= lookup_string（W，C）；如果，        （WC = end_list），          然后，            开始，              make_table_entry（W，C）；，              put_code（W）；，              W = lookup_string（no_prev，C）；最后，            ，          别的，            W = WC；，        get_char（C）；最后，      ；，    put_code（W）；最后，  ；，开始，  if_compressing：= true；，  初始化；，  do_compression；，，程序结束；LZW。减压；，const，  maxstack = 4096；，VaR，  栈：阵列[ 1 ] .. maxstack整数；，  stack_pointer：整数；，  程序推（C：整数）；，  开始，    公司（stack_pointer）；，    栈[ stack_pointer ]：= C；，    如果（stack_pointer >；= maxstack），      然后，        开始，          LastError：= 1；，          退出；最后，        ；，  端；，  程序流行（变量整数）；，  开始；如果，    （stack_pointer >；0），      然后，        开始，          C =栈[ stack_pointer ]；，          DEC（stack_pointer）；最后，        ，      别的，        C =空；，  端；，  程序get_code（VAR hash_code：整数）；，  VaR，    local_buf：整数；，  开始，    如果（input_code =空），      然后，        开始，          get_char（local_buf）；，          如果（local_buf = eof_char），            然后，              开始，                hash_code：= eof_char；，                退出；，              端；，          get_char（input_code）；，          如果（input_code = eof_char），            然后，              开始，                hash_code：= eof_char；，                退出；，              端；，          hash_code：=（（local_buf SHL 4）美元和ff0）+，                       （（input_code SHR 4）和$ 00F）；，          input_code：= input_code美元，        结束，      中；否则，        开始，          get_char（local_buf）；，          如果（local_buf = eof_char），            然后，              开始，                hash_code：= eof_char；，                ，退出；              端；，          hash_code：= local_buf +（（input_code SHL 8）和$ F00）；，          input_code：=空；，        结束；结束，  ；，  程序do_decompression；，  VaR，    C：整数；，    代码：整数；，    old_code：整数，    ；fin_char：整数；，    in_code：整数；，    last_char：整数；，    未知：布尔；，    temp_c：整数；，  开始，    stack_pointer：= 0；，    未知：= false；，    get_code（old_code）；，    代码：= old_code；，    C = string_table [代码]。follchar；，    put_char（C）；，    fin_char：= C；，    get_code（in_code）；同时，    （in_code <；>；eof_char）做的，      开始，        代码：= in_code；，        如果（不string_table [代码]。使用），          然后，            开始，              last_char：= fin_char；，              代码：= old_code；，              未知：= true；，            ，    结束；    而（string_table [代码]。prevchar <；>；no_prev）做的，用string_table [代码]          做，            开始，              推（follchar）；，              如果（LastError <；>；0），                然后，                  退出；，              代码：= prevchar；，            端；，        fin_char：= string_table [代码]。follchar；，        put_char（fin_char）；，        流行（temp_c）；同时，        （temp_c <；>；空）做的，          开始，            put_char（temp_c）；，            流行（temp_c）；，          端；，        如果未知，          然后，            开始，              fin_char：= last_char；，              put_char（fin_char）；，              未知：= false；，            端；，        make_table_entry（old_code，fin_char）；，        old_code：= in_code；，        get_code（in_code）；最后，      ；，  ，开始，结束；  if_compressing：= false；，  初始化；，  do_decompression；结束；结束，，，（* *****************************测试程序****************** *），程序lzwtest；，{程序演示/测试LZW对象}，用途，  ihlzw；{只需要这个}，VaR，  C：LZW；{明星的表演；压缩对象}，{ $ F + }功能好Hechar (var CH:char): Bull. {% f} {laat je&#getchar conventionele &39; de verklaring van dit uiterlijk begin  }, als niet   EOF (input) (aan het einde van de input.       }, dan             beginnen,                 lezen (input, CH); - lees dan een karakter is ch en...},                 getthechar:= waar; {...Terug waar  },           voorbij,         andere,             getthechar:= valse;} {of valse, aan het einde, F +} {%; de procedure putthechar (CH:char); {% f} {laat je&#putchar conventionele &39; de verklaring van op deze manier begonnen,    }, schrijven (output, CH - CH); {en produktie), einde beginnen,     {;} open bestand,     toewijzing (input, en' en'); {standaard input nodig is; een nuttige},     toewijzing (output, en' en'); {standaard output; die moeten leiden   nuttig is),   reset (input);   herschrijven,   (output); en     {kan en' T - gefaald? - misschien kinderen, maar...},     als niet -         dan,             stoppen,     {toewijzing; O.},     c.getchar:= getthechar; {set. En' s getchar conventionele getthechar},     c.putchar:= putthechar; {set. En' s putchar conventionele putthechar},     {we - of uitpakken?},     als (paramcount = 0),         dan,             c.compress {-),         andere,             c.decompress; {} {alle decompressie doen,    !Aan het einde van},.,