git.oblomov.eu Git - wine/blob - dlls/lzexpand/lzexpand_main.c

   1 /*
   2  * LZ Decompression functions
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  */
   6 /*
   7  * FIXME: return values might be wrong
   8  */
   9
  10 #include "config.h"
  11
  12 #include <string.h>
  13 #include <ctype.h>
  14 #include <sys/types.h>
  15 #include <unistd.h>
  16
  17 #include "winbase.h"
  18 #include "lzexpand.h"
  19
  20 #include "wine/unicode.h"
  21 #include "wine/winbase16.h"
  22
  23 #include "debugtools.h"
  24
  25 DEFAULT_DEBUG_CHANNEL(file);
  26
  27 /* The readahead length of the decompressor. Reading single bytes
  28  * using _lread() would be SLOW.
  29  */
  30 #define GETLEN  2048
  31
  32 /* Format of first 14 byte of LZ compressed file */
  33 struct lzfileheader {
  34         BYTE    magic[8];
  35         BYTE    compressiontype;
  36         CHAR    lastchar;
  37         DWORD   reallength;
  38 };
  39 static BYTE LZMagic[8]={'S','Z','D','D',0x88,0xf0,0x27,0x33};
  40
  41 struct lzstate {
  42         HFILE   realfd;         /* the real filedescriptor */
  43         CHAR    lastchar;       /* the last char of the filename */
  44
  45         DWORD   reallength;     /* the decompressed length of the file */
  46         DWORD   realcurrent;    /* the position the decompressor currently is */
  47         DWORD   realwanted;     /* the position the user wants to read from */
  48
  49         BYTE    table[0x1000];  /* the rotating LZ table */
  50         UINT    curtabent;      /* CURrent TABle ENTry */
  51
  52         BYTE    stringlen;      /* length and position of current string */
  53         DWORD   stringpos;      /* from stringtable */
  54
  55
  56         WORD    bytetype;       /* bitmask within blocks */
  57
  58         BYTE    *get;           /* GETLEN bytes */
  59         DWORD   getcur;         /* current read */
  60         DWORD   getlen;         /* length last got */
  61 };
  62
  63 #define MAX_LZSTATES 16
  64 static struct lzstate *lzstates[MAX_LZSTATES];
  65
  66 #define IS_LZ_HANDLE(h) (((h) >= 0x400) && ((h) < 0x400+MAX_LZSTATES))
  67 #define GET_LZ_STATE(h) (IS_LZ_HANDLE(h) ? lzstates[(h)-0x400] : NULL)
  68
  69 /* reads one compressed byte, including buffering */
  70 #define GET(lzs,b)      _lzget(lzs,&b)
  71 #define GET_FLUSH(lzs)  lzs->getcur=lzs->getlen;
  72
  73 static int
  74 _lzget(struct lzstate *lzs,BYTE *b) {
  75         if (lzs->getcur<lzs->getlen) {
  76                 *b              = lzs->get[lzs->getcur++];
  77                 return          1;
  78         } else {
  79                 int ret = _lread(lzs->realfd,lzs->get,GETLEN);
  80                 if (ret==HFILE_ERROR)
  81                         return HFILE_ERROR;
  82                 if (ret==0)
  83                         return 0;
  84                 lzs->getlen     = ret;
  85                 lzs->getcur     = 1;
  86                 *b              = *(lzs->get);
  87                 return 1;
  88         }
  89 }
  90 /* internal function, reads lzheader
  91  * returns BADINHANDLE for non filedescriptors
  92  * return 0 for file not compressed using LZ
  93  * return UNKNOWNALG for unknown algorithm
  94  * returns lzfileheader in *head
  95  */
  96 static INT read_header(HFILE fd,struct lzfileheader *head)
  97 {
  98         BYTE    buf[14];
  99
 100         if (_llseek(fd,0,SEEK_SET)==-1)
 101                 return LZERROR_BADINHANDLE;
 102
 103         /* We can't directly read the lzfileheader struct due to
 104          * structure element alignment
 105          */
 106         if (_lread(fd,buf,14)<14)
 107                 return 0;
 108         memcpy(head->magic,buf,8);
 109         memcpy(&(head->compressiontype),buf+8,1);
 110         memcpy(&(head->lastchar),buf+9,1);
 111
 112         /* FIXME: consider endianess on non-intel architectures */
 113         memcpy(&(head->reallength),buf+10,4);
 114
 115         if (memcmp(head->magic,LZMagic,8))
 116                 return 0;
 117         if (head->compressiontype!='A')
 118                 return LZERROR_UNKNOWNALG;
 119         return 1;
 120 }
 121
 122 /***********************************************************************
 123  *           LZStart   (LZEXPAND.7)
 124  */
 125 INT16 WINAPI LZStart16(void)
 126 {
 127     TRACE("(void)\n");
 128     return 1;
 129 }
 130
 131
 132 /***********************************************************************
 133  *           LZStart   (LZ32.@)
 134  */
 135 INT WINAPI LZStart(void)
 136 {
 137     TRACE("(void)\n");
 138     return 1;
 139 }
 140
 141
 142 /***********************************************************************
 143  *           LZInit   (LZEXPAND.3)
 144  */
 145 HFILE16 WINAPI LZInit16( HFILE16 hfSrc )
 146 {
 147     HFILE ret = LZInit( DosFileHandleToWin32Handle(hfSrc) );
 148     if (IS_LZ_HANDLE(ret)) return ret;
 149     if ((INT)ret <= 0) return ret;
 150     return hfSrc;
 151 }
 152
 153
 154 /***********************************************************************
 155  *           LZInit   (LZ32.@)
 156  *
 157  * initializes internal decompression buffers, returns lzfiledescriptor.
 158  * (return value the same as hfSrc, if hfSrc is not compressed)
 159  * on failure, returns error code <0
 160  * lzfiledescriptors range from 0x400 to 0x410 (only 16 open files per process)
 161  *
 162  * since _llseek uses the same types as libc.lseek, we just use the macros of
 163  *  libc
 164  */
 165 HFILE WINAPI LZInit( HFILE hfSrc )
 166 {
 167
 168         struct  lzfileheader    head;
 169         struct  lzstate         *lzs;
 170         DWORD   ret;
 171         int i;
 172
 173         TRACE("(%d)\n",hfSrc);
 174         ret=read_header(hfSrc,&head);
 175         if (ret<=0) {
 176                 _llseek(hfSrc,0,SEEK_SET);
 177                 return ret?ret:hfSrc;
 178         }
 179         for (i = 0; i < MAX_LZSTATES; i++) if (!lzstates[i]) break;
 180         if (i == MAX_LZSTATES) return LZERROR_GLOBALLOC;
 181         lzstates[i] = lzs = HeapAlloc( GetProcessHeap(), 0, sizeof(struct lzstate) );
 182         if(lzs == NULL) return LZERROR_GLOBALLOC;
 183
 184         memset(lzs,'\0',sizeof(*lzs));
 185         lzs->realfd     = hfSrc;
 186         lzs->lastchar   = head.lastchar;
 187         lzs->reallength = head.reallength;
 188
 189         lzs->get        = HeapAlloc( GetProcessHeap(), 0, GETLEN );
 190         lzs->getlen     = 0;
 191         lzs->getcur     = 0;
 192
 193         if(lzs->get == NULL) {
 194                 HeapFree(GetProcessHeap(), 0, lzs);
 195                 lzstates[i] = NULL;
 196                 return LZERROR_GLOBALLOC;
 197         }
 198
 199         /* Yes, preinitialize with spaces */
 200         memset(lzs->table,' ',0x1000);
 201         /* Yes, start 16 byte from the END of the table */
 202         lzs->curtabent  = 0xff0;
 203         return 0x400 + i;
 204 }
 205
 206
 207 /***********************************************************************
 208  *           LZDone   (LZEXPAND.9)
 209  *           LZDone   (LZ32.@)
 210  */
 211 void WINAPI LZDone(void)
 212 {
 213     TRACE("(void)\n");
 214 }
 215
 216
 217 /***********************************************************************
 218  *           GetExpandedName   (LZEXPAND.10)
 219  */
 220 INT16 WINAPI GetExpandedName16( LPCSTR in, LPSTR out )
 221 {
 222     return (INT16)GetExpandedNameA( in, out );
 223 }
 224
 225
 226 /***********************************************************************
 227  *           GetExpandedNameA   (LZ32.@)
 228  *
 229  * gets the full filename of the compressed file 'in' by opening it
 230  * and reading the header
 231  *
 232  * "file." is being translated to "file"
 233  * "file.bl_" (with lastchar 'a') is being translated to "file.bla"
 234  * "FILE.BL_" (with lastchar 'a') is being translated to "FILE.BLA"
 235  */
 236
 237 INT WINAPI GetExpandedNameA( LPCSTR in, LPSTR out )
 238 {
 239         struct lzfileheader     head;
 240         HFILE           fd;
 241         OFSTRUCT        ofs;
 242         INT             fnislowercased,ret,len;
 243         LPSTR           s,t;
 244
 245         TRACE("(%s)\n",in);
 246         fd=OpenFile(in,&ofs,OF_READ);
 247         if (fd==HFILE_ERROR)
 248                 return (INT)(INT16)LZERROR_BADINHANDLE;
 249         strcpy(out,in);
 250         ret=read_header(fd,&head);
 251         if (ret<=0) {
 252                 /* not a LZ compressed file, so the expanded name is the same
 253                  * as the input name */
 254                 _lclose(fd);
 255                 return 1;
 256         }
 257
 258
 259         /* look for directory prefix and skip it. */
 260         s=out;
 261         while (NULL!=(t=strpbrk(s,"/\\:")))
 262                 s=t+1;
 263
 264         /* now mangle the basename */
 265         if (!*s) {
 266                 /* FIXME: hmm. shouldn't happen? */
 267                 WARN("Specified a directory or what? (%s)\n",in);
 268                 _lclose(fd);
 269                 return 1;
 270         }
 271         /* see if we should use lowercase or uppercase on the last char */
 272         fnislowercased=1;
 273         t=s+strlen(s)-1;
 274         while (t>=out) {
 275                 if (!isalpha(*t)) {
 276                         t--;
 277                         continue;
 278                 }
 279                 fnislowercased=islower(*t);
 280                 break;
 281         }
 282         if (isalpha(head.lastchar)) {
 283                 if (fnislowercased)
 284                         head.lastchar=tolower(head.lastchar);
 285                 else
 286                         head.lastchar=toupper(head.lastchar);
 287         }
 288
 289         /* now look where to replace the last character */
 290         if (NULL!=(t=strchr(s,'.'))) {
 291                 if (t[1]=='\0') {
 292                         t[0]='\0';
 293                 } else {
 294                         len=strlen(t)-1;
 295                         if (t[len]=='_')
 296                                 t[len]=head.lastchar;
 297                 }
 298         } /* else no modification necessary */
 299         _lclose(fd);
 300         return 1;
 301 }
 302
 303
 304 /***********************************************************************
 305  *           GetExpandedNameW   (LZ32.@)
 306  */
 307 INT WINAPI GetExpandedNameW( LPCWSTR in, LPWSTR out )
 308 {
 309     INT ret;
 310     DWORD len = WideCharToMultiByte( CP_ACP, 0, in, -1, NULL, 0, NULL, NULL );
 311     char *xin = HeapAlloc( GetProcessHeap(), 0, len );
 312     char *xout = HeapAlloc( GetProcessHeap(), 0, len+3 );
 313     WideCharToMultiByte( CP_ACP, 0, in, -1, xin, len, NULL, NULL );
 314     if ((ret = GetExpandedNameA( xin, xout )) > 0)
 315         MultiByteToWideChar( CP_ACP, 0, xout, -1, out, strlenW(in)+4 );
 316     HeapFree( GetProcessHeap(), 0, xin );
 317     HeapFree( GetProcessHeap(), 0, xout );
 318     return ret;
 319 }
 320
 321
 322 /***********************************************************************
 323  *           LZRead   (LZEXPAND.5)
 324  */
 325 INT16 WINAPI LZRead16( HFILE16 fd, LPVOID buf, UINT16 toread )
 326 {
 327     if (IS_LZ_HANDLE(fd)) return LZRead( fd, buf, toread );
 328     return _lread( DosFileHandleToWin32Handle(fd), buf, toread );
 329 }
 330
 331
 332 /***********************************************************************
 333  *           LZRead   (LZ32.@)
 334  */
 335 INT WINAPI LZRead( HFILE fd, LPVOID vbuf, UINT toread )
 336 {
 337         int     howmuch;
 338         BYTE    b,*buf;
 339         struct  lzstate *lzs;
 340
 341         buf=(LPBYTE)vbuf;
 342         TRACE("(%d,%p,%d)\n",fd,buf,toread);
 343         howmuch=toread;
 344         if (!(lzs = GET_LZ_STATE(fd))) return _lread(fd,buf,toread);
 345
 346 /* The decompressor itself is in a define, cause we need it twice
 347  * in this function. (the decompressed byte will be in b)
 348  */
 349 #define DECOMPRESS_ONE_BYTE                                             \
 350                 if (lzs->stringlen) {                                   \
 351                         b               = lzs->table[lzs->stringpos];   \
 352                         lzs->stringpos  = (lzs->stringpos+1)&0xFFF;     \
 353                         lzs->stringlen--;                               \
 354                 } else {                                                \
 355                         if (!(lzs->bytetype&0x100)) {                   \
 356                                 if (1!=GET(lzs,b))                      \
 357                                         return toread-howmuch;          \
 358                                 lzs->bytetype = b|0xFF00;               \
 359                         }                                               \
 360                         if (lzs->bytetype & 1) {                        \
 361                                 if (1!=GET(lzs,b))                      \
 362                                         return toread-howmuch;          \
 363                         } else {                                        \
 364                                 BYTE    b1,b2;                          \
 365                                                                         \
 366                                 if (1!=GET(lzs,b1))                     \
 367                                         return toread-howmuch;          \
 368                                 if (1!=GET(lzs,b2))                     \
 369                                         return toread-howmuch;          \
 370                                 /* Format:                              \
 371                                  * b1 b2                                \
 372                                  * AB CD                                \
 373                                  * where CAB is the stringoffset in the table\
 374                                  * and D+3 is the len of the string     \
 375                                  */                                     \
 376                                 lzs->stringpos  = b1|((b2&0xf0)<<4);    \
 377                                 lzs->stringlen  = (b2&0xf)+2;           \
 378                                 /* 3, but we use a  byte already below ... */\
 379                                 b               = lzs->table[lzs->stringpos];\
 380                                 lzs->stringpos  = (lzs->stringpos+1)&0xFFF;\
 381                         }                                               \
 382                         lzs->bytetype>>=1;                              \
 383                 }                                                       \
 384                 /* store b in table */                                  \
 385                 lzs->table[lzs->curtabent++]= b;                        \
 386                 lzs->curtabent  &= 0xFFF;                               \
 387                 lzs->realcurrent++;
 388
 389         /* if someone has seeked, we have to bring the decompressor
 390          * to that position
 391          */
 392         if (lzs->realcurrent!=lzs->realwanted) {
 393                 /* if the wanted position is before the current position
 394                  * I see no easy way to unroll ... We have to restart at
 395                  * the beginning. *sigh*
 396                  */
 397                 if (lzs->realcurrent>lzs->realwanted) {
 398                         /* flush decompressor state */
 399                         _llseek(lzs->realfd,14,SEEK_SET);
 400                         GET_FLUSH(lzs);
 401                         lzs->realcurrent= 0;
 402                         lzs->bytetype   = 0;
 403                         lzs->stringlen  = 0;
 404                         memset(lzs->table,' ',0x1000);
 405                         lzs->curtabent  = 0xFF0;
 406                 }
 407                 while (lzs->realcurrent<lzs->realwanted) {
 408                         DECOMPRESS_ONE_BYTE;
 409                 }
 410         }
 411
 412         while (howmuch) {
 413                 DECOMPRESS_ONE_BYTE;
 414                 lzs->realwanted++;
 415                 *buf++          = b;
 416                 howmuch--;
 417         }
 418         return  toread;
 419 #undef DECOMPRESS_ONE_BYTE
 420 }
 421
 422
 423 /***********************************************************************
 424  *           LZSeek   (LZEXPAND.4)
 425  */
 426 LONG WINAPI LZSeek16( HFILE16 fd, LONG off, INT16 type )
 427 {
 428     if (IS_LZ_HANDLE(fd)) return LZSeek( fd, off, type );
 429     return _llseek( DosFileHandleToWin32Handle(fd), off, type );
 430 }
 431
 432
 433 /***********************************************************************
 434  *           LZSeek   (LZ32.@)
 435  */
 436 LONG WINAPI LZSeek( HFILE fd, LONG off, INT type )
 437 {
 438         struct  lzstate *lzs;
 439         LONG    newwanted;
 440
 441         TRACE("(%d,%ld,%d)\n",fd,off,type);
 442         /* not compressed? just use normal _llseek() */
 443         if (!(lzs = GET_LZ_STATE(fd))) return _llseek(fd,off,type);
 444         newwanted = lzs->realwanted;
 445         switch (type) {
 446         case 1: /* SEEK_CUR */
 447                 newwanted      += off;
 448                 break;
 449         case 2: /* SEEK_END */
 450                 newwanted       = lzs->reallength-off;
 451                 break;
 452         default:/* SEEK_SET */
 453                 newwanted       = off;
 454                 break;
 455         }
 456         if (newwanted>lzs->reallength)
 457                 return LZERROR_BADVALUE;
 458         if (newwanted<0)
 459                 return LZERROR_BADVALUE;
 460         lzs->realwanted = newwanted;
 461         return newwanted;
 462 }
 463
 464
 465 /***********************************************************************
 466  *           LZCopy   (LZEXPAND.1)
 467  *
 468  */
 469 LONG WINAPI LZCopy16( HFILE16 src, HFILE16 dest )
 470 {
 471     /* already a LZ handle? */
 472     if (IS_LZ_HANDLE(src)) return LZCopy( src, DosFileHandleToWin32Handle(dest) );
 473
 474     /* no, try to open one */
 475     src = LZInit16(src);
 476     if ((INT16)src <= 0) return 0;
 477     if (IS_LZ_HANDLE(src))
 478     {
 479         LONG ret = LZCopy( src, DosFileHandleToWin32Handle(dest) );
 480         LZClose( src );
 481         return ret;
 482     }
 483     /* it was not a compressed file */
 484     return LZCopy( DosFileHandleToWin32Handle(src), DosFileHandleToWin32Handle(dest) );
 485 }
 486
 487
 488 /***********************************************************************
 489  *           LZCopy   (LZ32.@)
 490  *
 491  * Copies everything from src to dest
 492  * if src is a LZ compressed file, it will be uncompressed.
 493  * will return the number of bytes written to dest or errors.
 494  */
 495 LONG WINAPI LZCopy( HFILE src, HFILE dest )
 496 {
 497         int     usedlzinit=0,ret,wret;
 498         LONG    len;
 499         HFILE   oldsrc = src;
 500 #define BUFLEN  1000
 501         BYTE    buf[BUFLEN];
 502         /* we need that weird typedef, for i can't seem to get function pointer
 503          * casts right. (Or they probably just do not like WINAPI in general)
 504          */
 505         typedef UINT    WINAPI (*_readfun)(HFILE,LPVOID,UINT);
 506
 507         _readfun        xread;
 508
 509         TRACE("(%d,%d)\n",src,dest);
 510         if (!IS_LZ_HANDLE(src)) {
 511                 src = LZInit(src);
 512                 if ((INT)src <= 0) return 0;
 513                 if (src != oldsrc) usedlzinit=1;
 514         }
 515
 516         /* not compressed? just copy */
 517         if (!IS_LZ_HANDLE(src))
 518                 xread=_lread;
 519         else
 520                 xread=(_readfun)LZRead;
 521         len=0;
 522         while (1) {
 523                 ret=xread(src,buf,BUFLEN);
 524                 if (ret<=0) {
 525                         if (ret==0)
 526                                 break;
 527                         if (ret==-1)
 528                                 return LZERROR_READ;
 529                         return ret;
 530                 }
 531                 len    += ret;
 532                 wret    = _lwrite(dest,buf,ret);
 533                 if (wret!=ret)
 534                         return LZERROR_WRITE;
 535         }
 536         if (usedlzinit)
 537                 LZClose(src);
 538         return len;
 539 #undef BUFLEN
 540 }
 541
 542 /* reverses GetExpandedPathname */
 543 static LPSTR LZEXPAND_MangleName( LPCSTR fn )
 544 {
 545     char *p;
 546     char *mfn = (char *)HeapAlloc( GetProcessHeap(), 0,
 547                                    strlen(fn) + 3 ); /* "._" and \0 */
 548     if(mfn == NULL) return NULL;
 549     strcpy( mfn, fn );
 550     if (!(p = strrchr( mfn, '\\' ))) p = mfn;
 551     if ((p = strchr( p, '.' )))
 552     {
 553         p++;
 554         if (strlen(p) < 3) strcat( p, "_" );  /* append '_' */
 555         else p[strlen(p)-1] = '_';  /* replace last character */
 556     }
 557     else strcat( mfn, "._" );   /* append "._" */
 558     return mfn;
 559 }
 560
 561
 562 /***********************************************************************
 563  *           LZOpenFile   (LZEXPAND.2)
 564  */
 565 HFILE16 WINAPI LZOpenFile16( LPCSTR fn, LPOFSTRUCT ofs, UINT16 mode )
 566 {
 567     HFILE hfret = LZOpenFileA( fn, ofs, mode );
 568     /* return errors and LZ handles unmodified */
 569     if ((INT)hfret <= 0) return hfret;
 570     if (IS_LZ_HANDLE(hfret)) return hfret;
 571     /* but allocate a dos handle for 'normal' files */
 572     return Win32HandleToDosFileHandle(hfret);
 573 }
 574
 575
 576 /***********************************************************************
 577  *           LZOpenFileA   (LZ32.@)
 578  *
 579  * Opens a file. If not compressed, open it as a normal file.
 580  */
 581 HFILE WINAPI LZOpenFileA( LPCSTR fn, LPOFSTRUCT ofs, UINT mode )
 582 {
 583         HFILE   fd,cfd;
 584
 585         TRACE("(%s,%p,%d)\n",fn,ofs,mode);
 586         /* 0x70 represents all OF_SHARE_* flags, ignore them for the check */
 587         fd=OpenFile(fn,ofs,mode);
 588         if (fd==HFILE_ERROR)
 589         {
 590             LPSTR mfn = LZEXPAND_MangleName(fn);
 591             fd = OpenFile(mfn,ofs,mode);
 592             HeapFree( GetProcessHeap(), 0, mfn );
 593         }
 594         if ((mode&~0x70)!=OF_READ)
 595                 return fd;
 596         if (fd==HFILE_ERROR)
 597                 return HFILE_ERROR;
 598         cfd=LZInit(fd);
 599         if ((INT)cfd <= 0) return fd;
 600         return cfd;
 601 }
 602
 603
 604 /***********************************************************************
 605  *           LZOpenFileW   (LZ32.@)
 606  */
 607 HFILE WINAPI LZOpenFileW( LPCWSTR fn, LPOFSTRUCT ofs, UINT mode )
 608 {
 609     HFILE ret;
 610     DWORD len = WideCharToMultiByte( CP_ACP, 0, fn, -1, NULL, 0, NULL, NULL );
 611     LPSTR xfn = HeapAlloc( GetProcessHeap(), 0, len );
 612     WideCharToMultiByte( CP_ACP, 0, fn, -1, xfn, len, NULL, NULL );
 613     ret = LZOpenFileA(xfn,ofs,mode);
 614     HeapFree( GetProcessHeap(), 0, xfn );
 615     return ret;
 616 }
 617
 618
 619 /***********************************************************************
 620  *           LZClose   (LZEXPAND.6)
 621  */
 622 void WINAPI LZClose16( HFILE16 fd )
 623 {
 624     if (IS_LZ_HANDLE(fd)) LZClose( fd );
 625     else DisposeLZ32Handle( DosFileHandleToWin32Handle(fd) );
 626 }
 627
 628
 629 /***********************************************************************
 630  *           LZClose   (LZ32.@)
 631  */
 632 void WINAPI LZClose( HFILE fd )
 633 {
 634         struct lzstate *lzs;
 635
 636         TRACE("(%d)\n",fd);
 637         if (!(lzs = GET_LZ_STATE(fd))) _lclose(fd);
 638         else
 639         {
 640             if (lzs->get) HeapFree( GetProcessHeap(), 0, lzs->get );
 641             CloseHandle(lzs->realfd);
 642             lzstates[fd - 0x400] = NULL;
 643             HeapFree( GetProcessHeap(), 0, lzs );
 644         }
 645 }
 646
 647 /***********************************************************************
 648  *           CopyLZFile   (LZEXPAND.8)
 649  */
 650 LONG WINAPI CopyLZFile16( HFILE16 src, HFILE16 dest )
 651 {
 652     TRACE("(%d,%d)\n",src,dest);
 653     return LZCopy16(src,dest);
 654 }
 655
 656
 657 /***********************************************************************
 658  *           CopyLZFile  (LZ32.@)
 659  *
 660  * Copy src to dest (including uncompressing src).
 661  * NOTE: Yes. This is exactly the same function as LZCopy.
 662  */
 663 LONG WINAPI CopyLZFile( HFILE src, HFILE dest )
 664 {
 665     TRACE("(%d,%d)\n",src,dest);
 666     return LZCopy(src,dest);
 667 }