git.oblomov.eu Git - wine/blob - programs/winhlp32/hlpfile.c

   1 /*
   2  * Help Viewer
   3  *
   4  * Copyright    1996 Ulrich Schmid
   5  *              2002, 2008 Eric Pouech
   6  *              2007 Kirill K. Smirnov
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "winhelp.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(winhelp);
  36
  37 static inline unsigned short GET_USHORT(const BYTE* buffer, unsigned i)
  38 {
  39     return (BYTE)buffer[i] + 0x100 * (BYTE)buffer[i + 1];
  40 }
  41
  42 static inline short GET_SHORT(const BYTE* buffer, unsigned i)
  43 {
  44     return (BYTE)buffer[i] + 0x100 * (signed char)buffer[i+1];
  45 }
  46
  47 static inline unsigned GET_UINT(const BYTE* buffer, unsigned i)
  48 {
  49     return GET_USHORT(buffer, i) + 0x10000 * GET_USHORT(buffer, i + 2);
  50 }
  51
  52 static HLPFILE *first_hlpfile = 0;
  53
  54
  55 /**************************************************************************
  56  * HLPFILE_BPTreeSearch
  57  *
  58  * Searches for an element in B+ tree
  59  *
  60  * PARAMS
  61  *     buf        [I] pointer to the embedded file structured as a B+ tree
  62  *     key        [I] pointer to data to find
  63  *     comp       [I] compare function
  64  *
  65  * RETURNS
  66  *     Pointer to block identified by key, or NULL if failure.
  67  *
  68  */
  69 static void* HLPFILE_BPTreeSearch(BYTE* buf, const void* key,
  70                            HLPFILE_BPTreeCompare comp)
  71 {
  72     unsigned magic;
  73     unsigned page_size;
  74     unsigned cur_page;
  75     unsigned level;
  76     BYTE *pages, *ptr, *newptr;
  77     int i, entries;
  78     int ret;
  79
  80     magic = GET_USHORT(buf, 9);
  81     if (magic != 0x293B)
  82     {
  83         WINE_ERR("Invalid magic in B+ tree: 0x%x\n", magic);
  84         return NULL;
  85     }
  86     page_size = GET_USHORT(buf, 9+4);
  87     cur_page  = GET_USHORT(buf, 9+26);
  88     level     = GET_USHORT(buf, 9+32);
  89     pages     = buf + 9 + 38;
  90     while (--level > 0)
  91     {
  92         ptr = pages + cur_page*page_size;
  93         entries = GET_SHORT(ptr, 2);
  94         ptr += 6;
  95         for (i = 0; i < entries; i++)
  96         {
  97             if (comp(ptr, key, 0, (void **)&newptr) > 0) break;
  98             ptr = newptr;
  99         }
 100         cur_page = GET_USHORT(ptr-2, 0);
 101     }
 102     ptr = pages + cur_page*page_size;
 103     entries = GET_SHORT(ptr, 2);
 104     ptr += 8;
 105     for (i = 0; i < entries; i++)
 106     {
 107         ret = comp(ptr, key, 1, (void **)&newptr);
 108         if (ret == 0) return ptr;
 109         if (ret > 0) return NULL;
 110         ptr = newptr;
 111     }
 112     return NULL;
 113 }
 114
 115 /**************************************************************************
 116  * HLPFILE_BPTreeEnum
 117  *
 118  * Enumerates elements in B+ tree.
 119  *
 120  * PARAMS
 121  *     buf        [I]  pointer to the embedded file structured as a B+ tree
 122  *     cb         [I]  compare function
 123  *     cookie     [IO] cookie for cb function
 124  */
 125 void HLPFILE_BPTreeEnum(BYTE* buf, HLPFILE_BPTreeCallback cb, void* cookie)
 126 {
 127     unsigned magic;
 128     unsigned page_size;
 129     unsigned cur_page;
 130     unsigned level;
 131     BYTE *pages, *ptr, *newptr;
 132     int i, entries;
 133
 134     magic = GET_USHORT(buf, 9);
 135     if (magic != 0x293B)
 136     {
 137         WINE_ERR("Invalid magic in B+ tree: 0x%x\n", magic);
 138         return;
 139     }
 140     page_size = GET_USHORT(buf, 9+4);
 141     cur_page  = GET_USHORT(buf, 9+26);
 142     level     = GET_USHORT(buf, 9+32);
 143     pages     = buf + 9 + 38;
 144     while (--level > 0)
 145     {
 146         ptr = pages + cur_page*page_size;
 147         cur_page = GET_USHORT(ptr, 4);
 148     }
 149     while (cur_page != 0xFFFF)
 150     {
 151         ptr = pages + cur_page*page_size;
 152         entries = GET_SHORT(ptr, 2);
 153         ptr += 8;
 154         for (i = 0; i < entries; i++)
 155         {
 156             cb(ptr, (void **)&newptr, cookie);
 157             ptr = newptr;
 158         }
 159         cur_page = GET_USHORT(pages+cur_page*page_size, 6);
 160     }
 161 }
 162
 163
 164 /***********************************************************************
 165  *
 166  *           HLPFILE_UncompressedLZ77_Size
 167  */
 168 static INT HLPFILE_UncompressedLZ77_Size(const BYTE *ptr, const BYTE *end)
 169 {
 170     int  i, newsize = 0;
 171
 172     while (ptr < end)
 173     {
 174         int mask = *ptr++;
 175         for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
 176         {
 177             if (mask & 1)
 178             {
 179                 int code = GET_USHORT(ptr, 0);
 180                 int len  = 3 + (code >> 12);
 181                 newsize += len;
 182                 ptr     += 2;
 183             }
 184             else newsize++, ptr++;
 185         }
 186     }
 187
 188     return newsize;
 189 }
 190
 191 /***********************************************************************
 192  *
 193  *           HLPFILE_UncompressLZ77
 194  */
 195 static BYTE *HLPFILE_UncompressLZ77(const BYTE *ptr, const BYTE *end, BYTE *newptr)
 196 {
 197     int i;
 198
 199     while (ptr < end)
 200     {
 201         int mask = *ptr++;
 202         for (i = 0; i < 8 && ptr < end; i++, mask >>= 1)
 203         {
 204             if (mask & 1)
 205             {
 206                 int code   = GET_USHORT(ptr, 0);
 207                 int len    = 3 + (code >> 12);
 208                 int offset = code & 0xfff;
 209                 /*
 210                  * We must copy byte-by-byte here. We cannot use memcpy nor
 211                  * memmove here. Just example:
 212                  * a[]={1,2,3,4,5,6,7,8,9,10}
 213                  * newptr=a+2;
 214                  * offset=1;
 215                  * We expect:
 216                  * {1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 11, 12}
 217                  */
 218                 for (; len>0; len--, newptr++) *newptr = *(newptr-offset-1);
 219                 ptr    += 2;
 220             }
 221             else *newptr++ = *ptr++;
 222         }
 223     }
 224
 225     return newptr;
 226 }
 227
 228 /***********************************************************************
 229  *
 230  *           HLPFILE_Uncompress2
 231  */
 232
 233 static void HLPFILE_Uncompress2(HLPFILE* hlpfile, const BYTE *ptr, const BYTE *end, BYTE *newptr, const BYTE *newend)
 234 {
 235     BYTE *phptr, *phend;
 236     UINT code;
 237     UINT index;
 238
 239     while (ptr < end && newptr < newend)
 240     {
 241         if (!*ptr || *ptr >= 0x10)
 242             *newptr++ = *ptr++;
 243         else
 244         {
 245             code  = 0x100 * ptr[0] + ptr[1];
 246             index = (code - 0x100) / 2;
 247
 248             phptr = (BYTE*)hlpfile->phrases_buffer + hlpfile->phrases_offsets[index];
 249             phend = (BYTE*)hlpfile->phrases_buffer + hlpfile->phrases_offsets[index + 1];
 250
 251             if (newptr + (phend - phptr) > newend)
 252             {
 253                 WINE_FIXME("buffer overflow %p > %p for %lu bytes\n",
 254                            newptr, newend, (SIZE_T)(phend - phptr));
 255                 return;
 256             }
 257             memcpy(newptr, phptr, phend - phptr);
 258             newptr += phend - phptr;
 259             if (code & 1) *newptr++ = ' ';
 260
 261             ptr += 2;
 262         }
 263     }
 264     if (newptr > newend) WINE_FIXME("buffer overflow %p > %p\n", newptr, newend);
 265 }
 266
 267 /******************************************************************
 268  *              HLPFILE_Uncompress3
 269  *
 270  *
 271  */
 272 static BOOL HLPFILE_Uncompress3(HLPFILE* hlpfile, char* dst, const char* dst_end,
 273                                 const BYTE* src, const BYTE* src_end)
 274 {
 275     unsigned int idx, len;
 276
 277     for (; src < src_end; src++)
 278     {
 279         if ((*src & 1) == 0)
 280         {
 281             idx = *src / 2;
 282             if (idx > hlpfile->num_phrases)
 283             {
 284                 WINE_ERR("index in phrases %d/%d\n", idx, hlpfile->num_phrases);
 285                 len = 0;
 286             }
 287             else
 288             {
 289                 len = hlpfile->phrases_offsets[idx + 1] - hlpfile->phrases_offsets[idx];
 290                 if (dst + len <= dst_end)
 291                     memcpy(dst, &hlpfile->phrases_buffer[hlpfile->phrases_offsets[idx]], len);
 292             }
 293         }
 294         else if ((*src & 0x03) == 0x01)
 295         {
 296             idx = (*src + 1) * 64;
 297             idx += *++src;
 298             if (idx > hlpfile->num_phrases)
 299             {
 300                 WINE_ERR("index in phrases %d/%d\n", idx, hlpfile->num_phrases);
 301                 len = 0;
 302             }
 303             else
 304             {
 305                 len = hlpfile->phrases_offsets[idx + 1] - hlpfile->phrases_offsets[idx];
 306                 if (dst + len <= dst_end)
 307                     memcpy(dst, &hlpfile->phrases_buffer[hlpfile->phrases_offsets[idx]], len);
 308             }
 309         }
 310         else if ((*src & 0x07) == 0x03)
 311         {
 312             len = (*src / 8) + 1;
 313             if (dst + len <= dst_end)
 314                 memcpy(dst, src + 1, len);
 315             src += len;
 316         }
 317         else
 318         {
 319             len = (*src / 16) + 1;
 320             if (dst + len <= dst_end)
 321                 memset(dst, ((*src & 0x0F) == 0x07) ? ' ' : 0, len);
 322         }
 323         dst += len;
 324     }
 325
 326     if (dst > dst_end) WINE_ERR("buffer overflow (%p > %p)\n", dst, dst_end);
 327     return TRUE;
 328 }
 329
 330 /******************************************************************
 331  *              HLPFILE_UncompressRLE
 332  *
 333  *
 334  */
 335 static void HLPFILE_UncompressRLE(const BYTE* src, const BYTE* end, BYTE* dst, unsigned dstsz)
 336 {
 337     BYTE        ch;
 338     BYTE*       sdst = dst + dstsz;
 339
 340     while (src < end)
 341     {
 342         ch = *src++;
 343         if (ch & 0x80)
 344         {
 345             ch &= 0x7F;
 346             if (dst + ch <= sdst)
 347                 memcpy(dst, src, ch);
 348             src += ch;
 349         }
 350         else
 351         {
 352             if (dst + ch <= sdst)
 353                 memset(dst, (char)*src, ch);
 354             src++;
 355         }
 356         dst += ch;
 357     }
 358     if (dst != sdst)
 359         WINE_WARN("Buffer X-flow: d(%lu) instead of d(%u)\n",
 360                   (SIZE_T)(dst - (sdst - dstsz)), dstsz);
 361 }
 362
 363
 364 /******************************************************************
 365  *              HLPFILE_PageByOffset
 366  *
 367  *
 368  */
 369 HLPFILE_PAGE *HLPFILE_PageByOffset(HLPFILE* hlpfile, LONG offset, ULONG* relative)
 370 {
 371     HLPFILE_PAGE*       page;
 372     HLPFILE_PAGE*       found;
 373
 374     if (!hlpfile) return 0;
 375
 376     WINE_TRACE("<%s>[%x]\n", hlpfile->lpszPath, offset);
 377
 378     if (offset == 0xFFFFFFFF) return NULL;
 379     page = NULL;
 380
 381     for (found = NULL, page = hlpfile->first_page; page; page = page->next)
 382     {
 383         if (page->offset <= offset && (!found || found->offset < page->offset))
 384         {
 385             *relative = offset - page->offset;
 386             found = page;
 387         }
 388     }
 389     if (!found)
 390         WINE_ERR("Page of offset %u not found in file %s\n",
 391                  offset, hlpfile->lpszPath);
 392     return found;
 393 }
 394
 395 /***********************************************************************
 396  *
 397  *           HLPFILE_Contents
 398  */
 399 static HLPFILE_PAGE* HLPFILE_Contents(HLPFILE *hlpfile, ULONG* relative)
 400 {
 401     HLPFILE_PAGE*       page = NULL;
 402
 403     if (!hlpfile) return NULL;
 404
 405     page = HLPFILE_PageByOffset(hlpfile, hlpfile->contents_start, relative);
 406     if (!page)
 407     {
 408         page = hlpfile->first_page;
 409         *relative = 0;
 410     }
 411     return page;
 412 }
 413
 414 /**************************************************************************
 415  * comp_PageByHash
 416  *
 417  * HLPFILE_BPTreeCompare function for '|CONTEXT' B+ tree file
 418  *
 419  */
 420 static int comp_PageByHash(void *p, const void *key,
 421                            int leaf, void** next)
 422 {
 423     LONG lKey = (LONG_PTR)key;
 424     LONG lTest = (INT)GET_UINT(p, 0);
 425
 426     *next = (char *)p+(leaf?8:6);
 427     WINE_TRACE("Comparing '%d' with '%d'\n", lKey, lTest);
 428     if (lTest < lKey) return -1;
 429     if (lTest > lKey) return 1;
 430     return 0;
 431 }
 432
 433 /***********************************************************************
 434  *
 435  *           HLPFILE_PageByHash
 436  */
 437 HLPFILE_PAGE *HLPFILE_PageByHash(HLPFILE* hlpfile, LONG lHash, ULONG* relative)
 438 {
 439     BYTE *ptr;
 440
 441     if (!hlpfile) return NULL;
 442     if (!lHash) return HLPFILE_Contents(hlpfile, relative);
 443
 444     WINE_TRACE("<%s>[%x]\n", hlpfile->lpszPath, lHash);
 445
 446     /* For win 3.0 files hash values are really page numbers */
 447     if (hlpfile->version <= 16)
 448     {
 449         if (lHash >= hlpfile->wTOMapLen) return NULL;
 450         return HLPFILE_PageByOffset(hlpfile, hlpfile->TOMap[lHash], relative);
 451     }
 452
 453     ptr = HLPFILE_BPTreeSearch(hlpfile->Context, LongToPtr(lHash), comp_PageByHash);
 454     if (!ptr)
 455     {
 456         WINE_ERR("Page of hash %x not found in file %s\n", lHash, hlpfile->lpszPath);
 457         return NULL;
 458     }
 459
 460     return HLPFILE_PageByOffset(hlpfile, GET_UINT(ptr, 4), relative);
 461 }
 462
 463 /***********************************************************************
 464  *
 465  *           HLPFILE_PageByMap
 466  */
 467 HLPFILE_PAGE *HLPFILE_PageByMap(HLPFILE* hlpfile, LONG lMap, ULONG* relative)
 468 {
 469     unsigned int i;
 470
 471     if (!hlpfile) return 0;
 472
 473     WINE_TRACE("<%s>[%x]\n", hlpfile->lpszPath, lMap);
 474
 475     for (i = 0; i < hlpfile->wMapLen; i++)
 476     {
 477         if (hlpfile->Map[i].lMap == lMap)
 478             return HLPFILE_PageByOffset(hlpfile, hlpfile->Map[i].offset, relative);
 479     }
 480
 481     WINE_ERR("Page of Map %x not found in file %s\n", lMap, hlpfile->lpszPath);
 482     return NULL;
 483 }
 484
 485 /**************************************************************************
 486  * comp_FindSubFile
 487  *
 488  * HLPFILE_BPTreeCompare function for HLPFILE directory.
 489  *
 490  */
 491 static int comp_FindSubFile(void *p, const void *key,
 492                             int leaf, void** next)
 493 {
 494     *next = (char *)p+strlen(p)+(leaf?5:3);
 495     WINE_TRACE("Comparing '%s' with '%s'\n", (char *)p, (const char *)key);
 496     return strcmp(p, key);
 497 }
 498
 499 /***********************************************************************
 500  *
 501  *           HLPFILE_FindSubFile
 502  */
 503 static BOOL HLPFILE_FindSubFile(HLPFILE* hlpfile, LPCSTR name, BYTE **subbuf, BYTE **subend)
 504 {
 505     BYTE *ptr;
 506
 507     WINE_TRACE("looking for file '%s'\n", name);
 508     ptr = HLPFILE_BPTreeSearch(hlpfile->file_buffer + GET_UINT(hlpfile->file_buffer, 4),
 509                                name, comp_FindSubFile);
 510     if (!ptr) return FALSE;
 511     *subbuf = hlpfile->file_buffer + GET_UINT(ptr, strlen(name)+1);
 512     if (*subbuf >= hlpfile->file_buffer + hlpfile->file_buffer_size)
 513     {
 514         WINE_ERR("internal file %s does not fit\n", name);
 515         return FALSE;
 516     }
 517     *subend = *subbuf + GET_UINT(*subbuf, 0);
 518     if (*subend > hlpfile->file_buffer + hlpfile->file_buffer_size)
 519     {
 520         WINE_ERR("internal file %s does not fit\n", name);
 521         return FALSE;
 522     }
 523     if (GET_UINT(*subbuf, 0) < GET_UINT(*subbuf, 4) + 9)
 524     {
 525         WINE_ERR("invalid size provided for internal file %s\n", name);
 526         return FALSE;
 527     }
 528     return TRUE;
 529 }
 530
 531 /***********************************************************************
 532  *
 533  *           HLPFILE_Hash
 534  */
 535 LONG HLPFILE_Hash(LPCSTR lpszContext)
 536 {
 537     LONG lHash = 0;
 538     CHAR c;
 539
 540     while ((c = *lpszContext++))
 541     {
 542         CHAR x = 0;
 543         if (c >= 'A' && c <= 'Z') x = c - 'A' + 17;
 544         if (c >= 'a' && c <= 'z') x = c - 'a' + 17;
 545         if (c >= '1' && c <= '9') x = c - '0';
 546         if (c == '0') x = 10;
 547         if (c == '.') x = 12;
 548         if (c == '_') x = 13;
 549         if (x) lHash = lHash * 43 + x;
 550     }
 551     return lHash;
 552 }
 553
 554 static LONG fetch_long(const BYTE** ptr)
 555 {
 556     LONG        ret;
 557
 558     if (*(*ptr) & 1)
 559     {
 560         ret = (*(const ULONG*)(*ptr) - 0x80000000) / 2;
 561         (*ptr) += 4;
 562     }
 563     else
 564     {
 565         ret = (*(const USHORT*)(*ptr) - 0x8000) / 2;
 566         (*ptr) += 2;
 567     }
 568
 569     return ret;
 570 }
 571
 572 static ULONG fetch_ulong(const BYTE** ptr)
 573 {
 574     ULONG        ret;
 575
 576     if (*(*ptr) & 1)
 577     {
 578         ret = *(const ULONG*)(*ptr) / 2;
 579         (*ptr) += 4;
 580     }
 581     else
 582     {
 583         ret = *(const USHORT*)(*ptr) / 2;
 584         (*ptr) += 2;
 585     }
 586     return ret;
 587 }
 588
 589 static short fetch_short(const BYTE** ptr)
 590 {
 591     short       ret;
 592
 593     if (*(*ptr) & 1)
 594     {
 595         ret = (*(const unsigned short*)(*ptr) - 0x8000) / 2;
 596         (*ptr) += 2;
 597     }
 598     else
 599     {
 600         ret = (*(const unsigned char*)(*ptr) - 0x80) / 2;
 601         (*ptr)++;
 602     }
 603     return ret;
 604 }
 605
 606 static unsigned short fetch_ushort(const BYTE** ptr)
 607 {
 608     unsigned short ret;
 609
 610     if (*(*ptr) & 1)
 611     {
 612         ret = *(const unsigned short*)(*ptr) / 2;
 613         (*ptr) += 2;
 614     }
 615     else
 616     {
 617         ret = *(const unsigned char*)(*ptr) / 2;
 618         (*ptr)++;
 619     }
 620     return ret;
 621 }
 622
 623 /******************************************************************
 624  *              HLPFILE_DecompressGfx
 625  *
 626  * Decompress the data part of a bitmap or a metafile
 627  */
 628 static const BYTE*      HLPFILE_DecompressGfx(const BYTE* src, unsigned csz, unsigned sz, BYTE packing,
 629                                               BYTE** alloc)
 630 {
 631     const BYTE* dst;
 632     BYTE*       tmp;
 633     unsigned    sz77;
 634
 635     WINE_TRACE("Unpacking (%d) from %u bytes to %u bytes\n", packing, csz, sz);
 636
 637     switch (packing)
 638     {
 639     case 0: /* uncompressed */
 640         if (sz != csz)
 641             WINE_WARN("Bogus gfx sizes (uncompressed): %u / %u\n", sz, csz);
 642         dst = src;
 643         *alloc = NULL;
 644         break;
 645     case 1: /* RunLen */
 646         dst = *alloc = HeapAlloc(GetProcessHeap(), 0, sz);
 647         if (!dst) return NULL;
 648         HLPFILE_UncompressRLE(src, src + csz, *alloc, sz);
 649         break;
 650     case 2: /* LZ77 */
 651         sz77 = HLPFILE_UncompressedLZ77_Size(src, src + csz);
 652         dst = *alloc = HeapAlloc(GetProcessHeap(), 0, sz77);
 653         if (!dst) return NULL;
 654         HLPFILE_UncompressLZ77(src, src + csz, *alloc);
 655         if (sz77 != sz)
 656             WINE_WARN("Bogus gfx sizes (LZ77): %u / %u\n", sz77, sz);
 657         break;
 658     case 3: /* LZ77 then RLE */
 659         sz77 = HLPFILE_UncompressedLZ77_Size(src, src + csz);
 660         tmp = HeapAlloc(GetProcessHeap(), 0, sz77);
 661         if (!tmp) return FALSE;
 662         HLPFILE_UncompressLZ77(src, src + csz, tmp);
 663         dst = *alloc = HeapAlloc(GetProcessHeap(), 0, sz);
 664         if (!dst)
 665         {
 666             HeapFree(GetProcessHeap(), 0, tmp);
 667             return FALSE;
 668         }
 669         HLPFILE_UncompressRLE(tmp, tmp + sz77, *alloc, sz);
 670         HeapFree(GetProcessHeap(), 0, tmp);
 671         break;
 672     default:
 673         WINE_FIXME("Unsupported packing %u\n", packing);
 674         return NULL;
 675     }
 676     return dst;
 677 }
 678
 679 static BOOL HLPFILE_RtfAddRawString(struct RtfData* rd, const char* str, size_t sz)
 680 {
 681     if (rd->ptr + sz >= rd->data + rd->allocated)
 682     {
 683         char*   new = HeapReAlloc(GetProcessHeap(), 0, rd->data, rd->allocated *= 2);
 684         if (!new) return FALSE;
 685         rd->ptr = new + (rd->ptr - rd->data);
 686         rd->data = new;
 687     }
 688     memcpy(rd->ptr, str, sz);
 689     rd->ptr += sz;
 690
 691     return TRUE;
 692 }
 693
 694 static BOOL HLPFILE_RtfAddControl(struct RtfData* rd, const char* str)
 695 {
 696     if (*str == '\\' || *str == '{') rd->in_text = FALSE;
 697     else if (*str == '}') rd->in_text = TRUE;
 698     return HLPFILE_RtfAddRawString(rd, str, strlen(str));
 699 }
 700
 701 static BOOL HLPFILE_RtfAddText(struct RtfData* rd, const char* str)
 702 {
 703     const char* p;
 704     const char* last;
 705     const char* replace;
 706     unsigned    rlen;
 707
 708     if (!rd->in_text)
 709     {
 710         if (!HLPFILE_RtfAddRawString(rd, " ", 1)) return FALSE;
 711         rd->in_text = TRUE;
 712     }
 713     for (last = p = str; *p; p++)
 714     {
 715         if (*p < 0) /* escape non ASCII chars */
 716         {
 717             static char         xx[8];
 718             rlen = sprintf(xx, "\\'%x", *(const BYTE*)p);
 719             replace = xx;
 720         }
 721         else switch (*p)
 722         {
 723         case '{':  rlen = 2; replace = "\\{";  break;
 724         case '}':  rlen = 2; replace = "\\}";  break;
 725         case '\\': rlen = 2; replace = "\\\\"; break;
 726         default:   continue;
 727         }
 728         if ((p != last && !HLPFILE_RtfAddRawString(rd, last, p - last)) ||
 729             !HLPFILE_RtfAddRawString(rd, replace, rlen)) return FALSE;
 730         last = p + 1;
 731     }
 732     return HLPFILE_RtfAddRawString(rd, last, p - last);
 733 }
 734
 735 /******************************************************************
 736  *              RtfAddHexBytes
 737  *
 738  */
 739 static BOOL HLPFILE_RtfAddHexBytes(struct RtfData* rd, const void* _ptr, unsigned sz)
 740 {
 741     char        tmp[512];
 742     unsigned    i, step;
 743     const BYTE* ptr = _ptr;
 744     static const char* _2hex = "0123456789abcdef";
 745
 746     if (!rd->in_text)
 747     {
 748         if (!HLPFILE_RtfAddRawString(rd, " ", 1)) return FALSE;
 749         rd->in_text = TRUE;
 750     }
 751     for (; sz; sz -= step)
 752     {
 753         step = min(256, sz);
 754         for (i = 0; i < step; i++)
 755         {
 756             tmp[2 * i + 0] = _2hex[*ptr >> 4];
 757             tmp[2 * i + 1] = _2hex[*ptr++ & 0xF];
 758         }
 759         if (!HLPFILE_RtfAddRawString(rd, tmp, 2 * step)) return FALSE;
 760     }
 761     return TRUE;
 762 }
 763
 764 static HLPFILE_LINK*       HLPFILE_AllocLink(struct RtfData* rd, int cookie,
 765                                              const char* str, unsigned len, LONG hash,
 766                                              unsigned clrChange, unsigned bHotSpot, unsigned wnd);
 767
 768 /******************************************************************
 769  *              HLPFILE_AddHotSpotLinks
 770  *
 771  */
 772 static void HLPFILE_AddHotSpotLinks(struct RtfData* rd, HLPFILE* file,
 773                                     const BYTE* start, ULONG hs_size, ULONG hs_offset)
 774 {
 775     unsigned    i, hs_num;
 776     ULONG       hs_macro;
 777     const char* str;
 778
 779     if (hs_size == 0 || hs_offset == 0) return;
 780
 781     start += hs_offset;
 782     /* always 1 ?? */
 783     hs_num = GET_USHORT(start, 1);
 784     hs_macro = GET_UINT(start, 3);
 785
 786     str = (const char*)start + 7 + 15 * hs_num + hs_macro;
 787     /* FIXME: should use hs_size to prevent out of bounds reads */
 788     for (i = 0; i < hs_num; i++)
 789     {
 790         HLPFILE_HOTSPOTLINK*    hslink;
 791
 792         WINE_TRACE("%02x-%02x%02x {%s,%s}\n",
 793                    start[7 + 15 * i + 0], start[7 + 15 * i + 1], start[7 + 15 * i + 2],
 794                    str, str + strlen(str) + 1);
 795         /* str points to two null terminated strings:
 796          * hotspot name, then link name
 797          */
 798         str += strlen(str) + 1;     /* skip hotspot name */
 799
 800         hslink = NULL;
 801         switch (start[7 + 15 * i + 0])
 802         /* The next two chars always look like 0x04 0x00 ???
 803          * What are they for ?
 804          */
 805         {
 806         case 0xC8:
 807             hslink = (HLPFILE_HOTSPOTLINK*)
 808                 HLPFILE_AllocLink(rd, hlp_link_macro, str, -1, 0, 0, 1, -1);
 809             break;
 810
 811         case 0xE6:
 812         case 0xE7:
 813             hslink = (HLPFILE_HOTSPOTLINK*)
 814                 HLPFILE_AllocLink(rd, (start[7 + 15 * i + 0] & 1) ? hlp_link_link : hlp_link_popup,
 815                                   file->lpszPath, -1, HLPFILE_Hash(str),
 816                                   0, 1, -1);
 817             break;
 818
 819         case 0xEE:
 820         case 0xEF:
 821             {
 822                 const char* win = strchr(str, '>');
 823                 int wnd = -1;
 824                 char* tgt = NULL;
 825
 826                 if (win)
 827                 {
 828                     for (wnd = file->numWindows - 1; wnd >= 0; wnd--)
 829                     {
 830                         if (!strcmp(win + 1, file->windows[wnd].name)) break;
 831                     }
 832                     if (wnd == -1)
 833                         WINE_WARN("Couldn't find window info for %s\n", win);
 834                     if ((tgt = HeapAlloc(GetProcessHeap(), 0, win - str + 1)))
 835                     {
 836                         memcpy(tgt, str, win - str);
 837                         tgt[win - str] = '\0';
 838                     }
 839                 }
 840                 hslink = (HLPFILE_HOTSPOTLINK*)
 841                     HLPFILE_AllocLink(rd, (start[7 + 15 * i + 0] & 1) ? hlp_link_link : hlp_link_popup,
 842                                       file->lpszPath, -1, HLPFILE_Hash(tgt ? tgt : str), 0, 1, wnd);
 843                 HeapFree(GetProcessHeap(), 0, tgt);
 844                 break;
 845             }
 846         default:
 847             WINE_FIXME("unknown hotsport target 0x%x\n", start[7 + 15 * i + 0]);
 848         }
 849         if (hslink)
 850         {
 851             hslink->x      = GET_USHORT(start, 7 + 15 * i + 3);
 852             hslink->y      = GET_USHORT(start, 7 + 15 * i + 5);
 853             hslink->width  = GET_USHORT(start, 7 + 15 * i + 7);
 854             hslink->height = GET_USHORT(start, 7 + 15 * i + 9);
 855             /* target = GET_UINT(start, 7 + 15 * i + 11); */
 856         }
 857         str += strlen(str) + 1;
 858     }
 859 }
 860
 861 /******************************************************************
 862  *             HLPFILE_RtfAddTransparentBitmap
 863  *
 864  * We'll transform a transparent bitmap into an metafile that
 865  * we then transform into RTF
 866  */
 867 static BOOL HLPFILE_RtfAddTransparentBitmap(struct RtfData* rd, const BITMAPINFO* bi,
 868                                             const void* pict, unsigned nc)
 869 {
 870     HDC                 hdc, hdcMask, hdcMem, hdcEMF;
 871     HBITMAP             hbm, hbmMask, hbmOldMask, hbmOldMem;
 872     HENHMETAFILE        hEMF;
 873     BOOL                ret = FALSE;
 874     void*               data;
 875     UINT                sz;
 876
 877     hbm = CreateDIBitmap(hdc = GetDC(0), &bi->bmiHeader,
 878                          CBM_INIT, pict, bi, DIB_RGB_COLORS);
 879
 880     hdcMem = CreateCompatibleDC(hdc);
 881     hbmOldMem = SelectObject(hdcMem, hbm);
 882
 883     /* create the mask bitmap from the main bitmap */
 884     hdcMask = CreateCompatibleDC(hdc);
 885     hbmMask = CreateBitmap(bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, 1, 1, NULL);
 886     hbmOldMask = SelectObject(hdcMask, hbmMask);
 887     SetBkColor(hdcMem,
 888                RGB(bi->bmiColors[nc - 1].rgbRed,
 889                    bi->bmiColors[nc - 1].rgbGreen,
 890                    bi->bmiColors[nc - 1].rgbBlue));
 891     BitBlt(hdcMask, 0, 0, bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, hdcMem, 0, 0, SRCCOPY);
 892
 893     /* sets to RGB(0,0,0) the transparent bits in main bitmap */
 894     SetBkColor(hdcMem, RGB(0,0,0));
 895     SetTextColor(hdcMem, RGB(255,255,255));
 896     BitBlt(hdcMem, 0, 0, bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, hdcMask, 0, 0, SRCAND);
 897
 898     SelectObject(hdcMask, hbmOldMask);
 899     DeleteDC(hdcMask);
 900
 901     SelectObject(hdcMem, hbmOldMem);
 902     DeleteDC(hdcMem);
 903
 904     /* we create the bitmap on the fly */
 905     hdcEMF = CreateEnhMetaFileW(NULL, NULL, NULL, NULL);
 906     hdcMem = CreateCompatibleDC(hdcEMF);
 907
 908     /* sets to RGB(0,0,0) the transparent bits in final bitmap */
 909     hbmOldMem = SelectObject(hdcMem, hbmMask);
 910     SetBkColor(hdcEMF, RGB(255, 255, 255));
 911     SetTextColor(hdcEMF, RGB(0, 0, 0));
 912     BitBlt(hdcEMF, 0, 0, bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, hdcMem, 0, 0, SRCAND);
 913
 914     /* and copy the remaining bits of main bitmap */
 915     SelectObject(hdcMem, hbm);
 916     BitBlt(hdcEMF, 0, 0, bi->bmiHeader.biWidth, bi->bmiHeader.biHeight, hdcMem, 0, 0, SRCPAINT);
 917     SelectObject(hdcMem, hbmOldMem);
 918     DeleteDC(hdcMem);
 919
 920     /* do the cleanup */
 921     ReleaseDC(0, hdc);
 922     DeleteObject(hbmMask);
 923     DeleteObject(hbm);
 924
 925     hEMF = CloseEnhMetaFile(hdcEMF);
 926
 927     /* generate rtf stream */
 928     sz = GetEnhMetaFileBits(hEMF, 0, NULL);
 929     if (sz && (data = HeapAlloc(GetProcessHeap(), 0, sz)))
 930     {
 931         if (sz == GetEnhMetaFileBits(hEMF, sz, data))
 932         {
 933             ret = HLPFILE_RtfAddControl(rd, "{\\pict\\emfblip") &&
 934                 HLPFILE_RtfAddHexBytes(rd, data, sz) &&
 935                 HLPFILE_RtfAddControl(rd, "}");
 936         }
 937         HeapFree(GetProcessHeap(), 0, data);
 938     }
 939     DeleteEnhMetaFile(hEMF);
 940
 941     return ret;
 942 }
 943
 944 /******************************************************************
 945  *              HLPFILE_RtfAddBitmap
 946  *
 947  */
 948 static BOOL HLPFILE_RtfAddBitmap(struct RtfData* rd, HLPFILE* file, const BYTE* beg, BYTE type, BYTE pack)
 949 {
 950     const BYTE*         ptr;
 951     const BYTE*         pict_beg;
 952     BYTE*               alloc = NULL;
 953     BITMAPINFO*         bi;
 954     ULONG               off, csz;
 955     unsigned            nc = 0;
 956     BOOL                clrImportant = FALSE;
 957     BOOL                ret = FALSE;
 958     char                tmp[256];
 959     unsigned            hs_size, hs_offset;
 960
 961     bi = HeapAlloc(GetProcessHeap(), 0, sizeof(*bi));
 962     if (!bi) return FALSE;
 963
 964     ptr = beg + 2; /* for type and pack */
 965
 966     bi->bmiHeader.biSize          = sizeof(bi->bmiHeader);
 967     bi->bmiHeader.biXPelsPerMeter = fetch_ulong(&ptr);
 968     bi->bmiHeader.biYPelsPerMeter = fetch_ulong(&ptr);
 969     bi->bmiHeader.biPlanes        = fetch_ushort(&ptr);
 970     bi->bmiHeader.biBitCount      = fetch_ushort(&ptr);
 971     bi->bmiHeader.biWidth         = fetch_ulong(&ptr);
 972     bi->bmiHeader.biHeight        = fetch_ulong(&ptr);
 973     bi->bmiHeader.biClrUsed       = fetch_ulong(&ptr);
 974     clrImportant  = fetch_ulong(&ptr);
 975     bi->bmiHeader.biClrImportant  = (clrImportant > 1) ? clrImportant : 0;
 976     bi->bmiHeader.biCompression   = BI_RGB;
 977     if (bi->bmiHeader.biBitCount > 32) WINE_FIXME("Unknown bit count %u\n", bi->bmiHeader.biBitCount);
 978     if (bi->bmiHeader.biPlanes != 1) WINE_FIXME("Unsupported planes %u\n", bi->bmiHeader.biPlanes);
 979     bi->bmiHeader.biSizeImage = (((bi->bmiHeader.biWidth * bi->bmiHeader.biBitCount + 31) & ~31) / 8) * bi->bmiHeader.biHeight;
 980     WINE_TRACE("planes=%d bc=%d size=(%d,%d)\n",
 981                bi->bmiHeader.biPlanes, bi->bmiHeader.biBitCount,
 982                bi->bmiHeader.biWidth, bi->bmiHeader.biHeight);
 983
 984     csz = fetch_ulong(&ptr);
 985     hs_size = fetch_ulong(&ptr);
 986
 987     off = GET_UINT(ptr, 0); ptr += 4;
 988     hs_offset = GET_UINT(ptr, 0); ptr += 4;
 989     HLPFILE_AddHotSpotLinks(rd, file, beg, hs_size, hs_offset);
 990
 991     /* now read palette info */
 992     if (type == 0x06)
 993     {
 994         unsigned i;
 995
 996         nc = bi->bmiHeader.biClrUsed;
 997         /* not quite right, especially for bitfields type of compression */
 998         if (!nc && bi->bmiHeader.biBitCount <= 8)
 999             nc = 1 << bi->bmiHeader.biBitCount;
1000
1001         bi = HeapReAlloc(GetProcessHeap(), 0, bi, sizeof(*bi) + nc * sizeof(RGBQUAD));
1002         if (!bi) return FALSE;
1003         for (i = 0; i < nc; i++)
1004         {
1005             bi->bmiColors[i].rgbBlue     = ptr[0];
1006             bi->bmiColors[i].rgbGreen    = ptr[1];
1007             bi->bmiColors[i].rgbRed      = ptr[2];
1008             bi->bmiColors[i].rgbReserved = 0;
1009             ptr += 4;
1010         }
1011     }
1012     pict_beg = HLPFILE_DecompressGfx(beg + off, csz, bi->bmiHeader.biSizeImage, pack, &alloc);
1013
1014     if (clrImportant == 1 && nc > 0)
1015     {
1016         ret = HLPFILE_RtfAddTransparentBitmap(rd, bi, pict_beg, nc);
1017         goto done;
1018     }
1019     if (!HLPFILE_RtfAddControl(rd, "{\\pict")) goto done;
1020     if (type == 0x06)
1021     {
1022         sprintf(tmp, "\\dibitmap0\\picw%d\\pich%d",
1023                 bi->bmiHeader.biWidth, bi->bmiHeader.biHeight);
1024         if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1025         if (!HLPFILE_RtfAddHexBytes(rd, bi, sizeof(*bi) + nc * sizeof(RGBQUAD))) goto done;
1026     }
1027     else
1028     {
1029         sprintf(tmp, "\\wbitmap0\\wbmbitspixel%d\\wbmplanes%d\\picw%d\\pich%d",
1030                 bi->bmiHeader.biBitCount, bi->bmiHeader.biPlanes,
1031                 bi->bmiHeader.biWidth, bi->bmiHeader.biHeight);
1032         if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1033     }
1034     if (!HLPFILE_RtfAddHexBytes(rd, pict_beg, bi->bmiHeader.biSizeImage)) goto done;
1035     if (!HLPFILE_RtfAddControl(rd, "}")) goto done;
1036
1037     ret = TRUE;
1038 done:
1039     HeapFree(GetProcessHeap(), 0, bi);
1040     HeapFree(GetProcessHeap(), 0, alloc);
1041
1042     return ret;
1043 }
1044
1045 /******************************************************************
1046  *              HLPFILE_RtfAddMetaFile
1047  *
1048  */
1049 static BOOL     HLPFILE_RtfAddMetaFile(struct RtfData* rd, HLPFILE* file, const BYTE* beg, BYTE pack)
1050 {
1051     ULONG               size, csize, off, hs_offset, hs_size;
1052     const BYTE*         ptr;
1053     const BYTE*         bits;
1054     BYTE*               alloc = NULL;
1055     char                tmp[256];
1056     unsigned            mm;
1057     BOOL                ret;
1058
1059     WINE_TRACE("Loading metafile\n");
1060
1061     ptr = beg + 2; /* for type and pack */
1062
1063     mm = fetch_ushort(&ptr); /* mapping mode */
1064     sprintf(tmp, "{\\pict\\wmetafile%d\\picw%d\\pich%d",
1065             mm, GET_USHORT(ptr, 0), GET_USHORT(ptr, 2));
1066     if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
1067     ptr += 4;
1068
1069     size = fetch_ulong(&ptr); /* decompressed size */
1070     csize = fetch_ulong(&ptr); /* compressed size */
1071     hs_size = fetch_ulong(&ptr); /* hotspot size */
1072     off = GET_UINT(ptr, 0);
1073     hs_offset = GET_UINT(ptr, 4);
1074     ptr += 8;
1075
1076     HLPFILE_AddHotSpotLinks(rd, file, beg, hs_size, hs_offset);
1077
1078     WINE_TRACE("sz=%u csz=%u offs=%u/%u,%u/%u\n",
1079                size, csize, off, (ULONG)(ptr - beg), hs_size, hs_offset);
1080
1081     bits = HLPFILE_DecompressGfx(beg + off, csize, size, pack, &alloc);
1082     if (!bits) return FALSE;
1083
1084     ret = HLPFILE_RtfAddHexBytes(rd, bits, size) &&
1085         HLPFILE_RtfAddControl(rd, "}");
1086
1087     HeapFree(GetProcessHeap(), 0, alloc);
1088
1089     return ret;
1090 }
1091
1092 /******************************************************************
1093  *              HLPFILE_RtfAddGfxByAddr
1094  *
1095  */
1096 static  BOOL    HLPFILE_RtfAddGfxByAddr(struct RtfData* rd, HLPFILE *hlpfile,
1097                                         const BYTE* ref, ULONG size)
1098 {
1099     unsigned    i, numpict;
1100
1101     numpict = GET_USHORT(ref, 2);
1102     WINE_TRACE("Got picture magic=%04x #=%d\n", GET_USHORT(ref, 0), numpict);
1103
1104     for (i = 0; i < numpict; i++)
1105     {
1106         const BYTE*     beg;
1107         const BYTE*     ptr;
1108         BYTE            type, pack;
1109
1110         WINE_TRACE("Offset[%d] = %x\n", i, GET_UINT(ref, (1 + i) * 4));
1111         beg = ptr = ref + GET_UINT(ref, (1 + i) * 4);
1112
1113         type = *ptr++;
1114         pack = *ptr++;
1115
1116         switch (type)
1117         {
1118         case 5: /* device dependent bmp */
1119         case 6: /* device independent bmp */
1120             HLPFILE_RtfAddBitmap(rd, hlpfile, beg, type, pack);
1121             break;
1122         case 8:
1123             HLPFILE_RtfAddMetaFile(rd, hlpfile, beg, pack);
1124             break;
1125         default: WINE_FIXME("Unknown type %u\n", type); return FALSE;
1126         }
1127
1128         /* FIXME: hotspots */
1129
1130         /* FIXME: implement support for multiple picture format */
1131         if (numpict != 1) WINE_FIXME("Supporting only one bitmap format per logical bitmap (for now). Using first format\n");
1132         break;
1133     }
1134     return TRUE;
1135 }
1136
1137 /******************************************************************
1138  *              HLPFILE_RtfAddGfxByIndex
1139  *
1140  *
1141  */
1142 static  BOOL    HLPFILE_RtfAddGfxByIndex(struct RtfData* rd, HLPFILE *hlpfile,
1143                                          unsigned index)
1144 {
1145     char        tmp[16];
1146     BYTE        *ref, *end;
1147
1148     WINE_TRACE("Loading picture #%d\n", index);
1149
1150     sprintf(tmp, "|bm%u", index);
1151
1152     if (!HLPFILE_FindSubFile(hlpfile, tmp, &ref, &end)) {WINE_WARN("no sub file\n"); return FALSE;}
1153
1154     ref += 9;
1155     return HLPFILE_RtfAddGfxByAddr(rd, hlpfile, ref, end - ref);
1156 }
1157
1158 /******************************************************************
1159  *              HLPFILE_AllocLink
1160  *
1161  *
1162  */
1163 static HLPFILE_LINK*       HLPFILE_AllocLink(struct RtfData* rd, int cookie,
1164                                              const char* str, unsigned len, LONG hash,
1165                                              unsigned clrChange, unsigned bHotSpot, unsigned wnd)
1166 {
1167     HLPFILE_LINK*  link;
1168     char*          link_str;
1169     unsigned       asz = bHotSpot ? sizeof(HLPFILE_HOTSPOTLINK) : sizeof(HLPFILE_LINK);
1170
1171     /* FIXME: should build a string table for the attributes.link.lpszPath
1172      * they are reallocated for each link
1173      */
1174     if (len == -1) len = strlen(str);
1175     link = HeapAlloc(GetProcessHeap(), 0, asz + len + 1);
1176     if (!link) return NULL;
1177
1178     link->cookie     = cookie;
1179     link->string     = link_str = (char*)link + asz;
1180     memcpy(link_str, str, len);
1181     link_str[len] = '\0';
1182     link->hash       = hash;
1183     link->bClrChange = clrChange ? 1 : 0;
1184     link->bHotSpot   = bHotSpot;
1185     link->window     = wnd;
1186     link->next       = rd->first_link;
1187     rd->first_link   = link;
1188     link->cpMin      = rd->char_pos;
1189     rd->force_color  = clrChange;
1190     if (rd->current_link) WINE_FIXME("Pending link\n");
1191     if (bHotSpot)
1192         link->cpMax = rd->char_pos;
1193     else
1194         rd->current_link = link;
1195
1196     WINE_TRACE("Link[%d] to %s@%08x:%d\n",
1197                link->cookie, link->string, link->hash, link->window);
1198     return link;
1199 }
1200
1201 static unsigned HLPFILE_HalfPointsToTwips(unsigned pts)
1202 {
1203     static unsigned logPxY;
1204     if (!logPxY)
1205     {
1206         HDC hdc = GetDC(NULL);
1207         logPxY = GetDeviceCaps(hdc, LOGPIXELSY);
1208         ReleaseDC(NULL, hdc);
1209     }
1210     return MulDiv(pts, 72 * 10, logPxY);
1211 }
1212
1213 /***********************************************************************
1214  *
1215  *           HLPFILE_BrowseParagraph
1216  */
1217 static BOOL HLPFILE_BrowseParagraph(HLPFILE_PAGE* page, struct RtfData* rd,
1218                                     BYTE *buf, BYTE* end, unsigned* parlen)
1219 {
1220     UINT               textsize;
1221     const BYTE        *format, *format_end;
1222     char              *text, *text_base, *text_end;
1223     LONG               size, blocksize, datalen;
1224     unsigned short     bits;
1225     unsigned           nc, ncol = 1;
1226     short              table_width;
1227     BOOL               in_table = FALSE;
1228     char               tmp[256];
1229     BOOL               ret = FALSE;
1230
1231     if (buf + 0x19 > end) {WINE_WARN("header too small\n"); return FALSE;};
1232
1233     *parlen = 0;
1234     blocksize = GET_UINT(buf, 0);
1235     size = GET_UINT(buf, 0x4);
1236     datalen = GET_UINT(buf, 0x10);
1237     text = text_base = HeapAlloc(GetProcessHeap(), 0, size);
1238     if (!text) return FALSE;
1239     if (size > blocksize - datalen)
1240     {
1241         /* need to decompress */
1242         if (page->file->hasPhrases)
1243             HLPFILE_Uncompress2(page->file, buf + datalen, end, (BYTE*)text, (BYTE*)text + size);
1244         else if (page->file->hasPhrases40)
1245             HLPFILE_Uncompress3(page->file, text, text + size, buf + datalen, end);
1246         else
1247         {
1248             WINE_FIXME("Text size is too long, splitting\n");
1249             size = blocksize - datalen;
1250             memcpy(text, buf + datalen, size);
1251         }
1252     }
1253     else
1254         memcpy(text, buf + datalen, size);
1255
1256     text_end = text + size;
1257
1258     format = buf + 0x15;
1259     format_end = buf + GET_UINT(buf, 0x10);
1260
1261     if (buf[0x14] == 0x20 || buf[0x14] == 0x23)
1262     {
1263         fetch_long(&format);
1264         *parlen = fetch_ushort(&format);
1265     }
1266
1267     if (buf[0x14] == 0x23)
1268     {
1269         char    type;
1270
1271         in_table = TRUE;
1272         ncol = *format++;
1273
1274         if (!HLPFILE_RtfAddControl(rd, "\\trowd")) goto done;
1275         type = *format++;
1276         if (type == 0 || type == 2)
1277         {
1278             table_width = GET_SHORT(format, 0);
1279             format += 2;
1280         }
1281         else
1282             table_width = 32767;
1283         WINE_TRACE("New table: cols=%d type=%x width=%d\n",
1284                    ncol, type, table_width);
1285         if (ncol > 1)
1286         {
1287             int     pos;
1288             sprintf(tmp, "\\trgaph%d\\trleft%d",
1289                     HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 6), table_width, 32767)),
1290                     HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 0), table_width, 32767)));
1291             if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1292             pos = HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 6) / 2, table_width, 32767));
1293             for (nc = 0; nc < ncol; nc++)
1294             {
1295                 WINE_TRACE("column(%d/%d) gap=%d width=%d\n",
1296                            nc, ncol, GET_SHORT(format, nc*4),
1297                            GET_SHORT(format, nc*4+2));
1298                 pos += GET_SHORT(format, nc * 4) + GET_SHORT(format, nc * 4 + 2);
1299                 sprintf(tmp, "\\cellx%d",
1300                         HLPFILE_HalfPointsToTwips(MulDiv(pos, table_width, 32767)));
1301                 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1302             }
1303         }
1304         else
1305         {
1306             WINE_TRACE("column(0/%d) gap=%d width=%d\n",
1307                        ncol, GET_SHORT(format, 0), GET_SHORT(format, 2));
1308             sprintf(tmp, "\\trleft%d\\cellx%d ",
1309                     HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 0), table_width, 32767)),
1310                     HLPFILE_HalfPointsToTwips(MulDiv(GET_SHORT(format, 0) + GET_SHORT(format, 2),
1311                                       table_width, 32767)));
1312             if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1313         }
1314         format += ncol * 4;
1315     }
1316
1317     for (nc = 0; nc < ncol; /**/)
1318     {
1319         WINE_TRACE("looking for format at offset %lu in column %d\n", (SIZE_T)(format - (buf + 0x15)), nc);
1320         if (!HLPFILE_RtfAddControl(rd, "\\pard")) goto done;
1321         if (in_table)
1322         {
1323             nc = GET_SHORT(format, 0);
1324             if (nc == -1) break;
1325             format += 5;
1326             if (!HLPFILE_RtfAddControl(rd, "\\intbl")) goto done;
1327         }
1328         else nc++;
1329         if (buf[0x14] == 0x01)
1330             format += 6;
1331         else
1332             format += 4;
1333         bits = GET_USHORT(format, 0); format += 2;
1334         if (bits & 0x0001) fetch_long(&format);
1335         if (bits & 0x0002)
1336         {
1337             sprintf(tmp, "\\sb%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1338             if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1339         }
1340         if (bits & 0x0004)
1341         {
1342             sprintf(tmp, "\\sa%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1343             if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1344         }
1345         if (bits & 0x0008)
1346         {
1347             sprintf(tmp, "\\sl%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1348             if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1349         }
1350         if (bits & 0x0010)
1351         {
1352             sprintf(tmp, "\\li%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1353             if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1354         }
1355         if (bits & 0x0020)
1356         {
1357             sprintf(tmp, "\\ri%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1358             if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1359         }
1360         if (bits & 0x0040)
1361         {
1362             sprintf(tmp, "\\fi%d", HLPFILE_HalfPointsToTwips(fetch_short(&format)));
1363             if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1364         }
1365         if (bits & 0x0100)
1366         {
1367             BYTE        brdr = *format++;
1368             short       w;
1369
1370             if ((brdr & 0x01) && !HLPFILE_RtfAddControl(rd, "\\box")) goto done;
1371             if ((brdr & 0x02) && !HLPFILE_RtfAddControl(rd, "\\brdrt")) goto done;
1372             if ((brdr & 0x04) && !HLPFILE_RtfAddControl(rd, "\\brdrl")) goto done;
1373             if ((brdr & 0x08) && !HLPFILE_RtfAddControl(rd, "\\brdrb")) goto done;
1374             if ((brdr & 0x10) && !HLPFILE_RtfAddControl(rd, "\\brdrr")) goto done;
1375             if ((brdr & 0x20) && !HLPFILE_RtfAddControl(rd, "\\brdrth")) goto done;
1376             if (!(brdr & 0x20) && !HLPFILE_RtfAddControl(rd, "\\brdrs")) goto done;
1377             if ((brdr & 0x40) && !HLPFILE_RtfAddControl(rd, "\\brdrdb")) goto done;
1378             /* 0x80: unknown */
1379
1380             w = GET_SHORT(format, 0); format += 2;
1381             if (w)
1382             {
1383                 sprintf(tmp, "\\brdrw%d", HLPFILE_HalfPointsToTwips(w));
1384                 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1385             }
1386         }
1387         if (bits & 0x0200)
1388         {
1389             int                 i, ntab = fetch_short(&format);
1390             unsigned            tab, ts;
1391             const char*         kind;
1392
1393             for (i = 0; i < ntab; i++)
1394             {
1395                 tab = fetch_ushort(&format);
1396                 ts = (tab & 0x4000) ? fetch_ushort(&format) : 0 /* left */;
1397                 switch (ts)
1398                 {
1399                 default: WINE_FIXME("Unknown tab style %x\n", ts);
1400                 /* fall through */
1401                 case 0: kind = ""; break;
1402                 case 1: kind = "\\tqr"; break;
1403                 case 2: kind = "\\tqc"; break;
1404                 }
1405                 /* FIXME: do kind */
1406                 sprintf(tmp, "%s\\tx%d",
1407                         kind, HLPFILE_HalfPointsToTwips(tab & 0x3FFF));
1408                 if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1409             }
1410         }
1411         switch (bits & 0xc00)
1412         {
1413         default: WINE_FIXME("Unsupported alignment 0xC00\n"); break;
1414         case 0: if (!HLPFILE_RtfAddControl(rd, "\\ql")) goto done; break;
1415         case 0x400: if (!HLPFILE_RtfAddControl(rd, "\\qr")) goto done; break;
1416         case 0x800: if (!HLPFILE_RtfAddControl(rd, "\\qc")) goto done; break;
1417         }
1418
1419         /* 0x1000 doesn't need space */
1420         if ((bits & 0x1000) && !HLPFILE_RtfAddControl(rd, "\\keep")) goto done;
1421         if ((bits & 0xE080) != 0)
1422             WINE_FIXME("Unsupported bits %04x, potential trouble ahead\n", bits);
1423
1424         while (text < text_end && format < format_end)
1425         {
1426             WINE_TRACE("Got text: %s (%p/%p - %p/%p)\n", wine_dbgstr_a(text), text, text_end, format, format_end);
1427             textsize = strlen(text);
1428             if (textsize)
1429             {
1430                 if (rd->force_color)
1431                 {
1432                     if ((rd->current_link->cookie == hlp_link_popup) ?
1433                         !HLPFILE_RtfAddControl(rd, "{\\uld\\cf1") :
1434                         !HLPFILE_RtfAddControl(rd, "{\\ul\\cf1")) goto done;
1435                 }
1436                 if (!HLPFILE_RtfAddText(rd, text)) goto done;
1437                 if (rd->force_color && !HLPFILE_RtfAddControl(rd, "}")) goto done;
1438                 rd->char_pos += textsize;
1439             }
1440             /* else: null text, keep on storing attributes */
1441             text += textsize + 1;
1442
1443             if (*format == 0xff)
1444             {
1445                 format++;
1446                 break;
1447             }
1448
1449             WINE_TRACE("format=%02x\n", *format);
1450             switch (*format)
1451             {
1452             case 0x20:
1453                 WINE_FIXME("NIY20\n");
1454                 format += 5;
1455                 break;
1456
1457             case 0x21:
1458                 WINE_FIXME("NIY21\n");
1459                 format += 3;
1460                 break;
1461
1462             case 0x80:
1463                 {
1464                     unsigned    font = GET_USHORT(format, 1);
1465                     unsigned    fs;
1466
1467                     WINE_TRACE("Changing font to %d\n", font);
1468                     format += 3;
1469                     /* Font size in hlpfile is given in the same units as
1470                        rtf control word \fs uses (half-points). */
1471                     switch (rd->font_scale)
1472                     {
1473                     case 0: fs = page->file->fonts[font].LogFont.lfHeight - 4; break;
1474                     default:
1475                     case 1: fs = page->file->fonts[font].LogFont.lfHeight; break;
1476                     case 2: fs = page->file->fonts[font].LogFont.lfHeight + 4; break;
1477                     }
1478                     /* FIXME: missing at least colors, also bold attribute looses information */
1479
1480                     sprintf(tmp, "\\f%d\\cf%d\\fs%d%s%s%s%s",
1481                             font, font + 2, fs,
1482                             page->file->fonts[font].LogFont.lfWeight > 400 ? "\\b" : "\\b0",
1483                             page->file->fonts[font].LogFont.lfItalic ? "\\i" : "\\i0",
1484                             page->file->fonts[font].LogFont.lfUnderline ? "\\ul" : "\\ul0",
1485                             page->file->fonts[font].LogFont.lfStrikeOut ? "\\strike" : "\\strike0");
1486                     if (!HLPFILE_RtfAddControl(rd, tmp)) goto done;
1487                 }
1488                break;
1489
1490             case 0x81:
1491                 if (!HLPFILE_RtfAddControl(rd, "\\line")) goto done;
1492                 format += 1;
1493                 rd->char_pos++;
1494                 break;
1495
1496             case 0x82:
1497                 if (in_table)
1498                 {
1499                     if (format[1] != 0xFF)
1500                     {
1501                         if (!HLPFILE_RtfAddControl(rd, "\\par\\intbl")) goto done;
1502                     }
1503                     else
1504                     {
1505                         if (!HLPFILE_RtfAddControl(rd, "\\cell\\pard\\intbl")) goto done;
1506                     }
1507                 }
1508                 else if (!HLPFILE_RtfAddControl(rd, "\\par")) goto done;
1509                 format += 1;
1510                 rd->char_pos++;
1511                 break;
1512
1513             case 0x83:
1514                 if (!HLPFILE_RtfAddControl(rd, "\\tab")) goto done;
1515                 format += 1;
1516                 rd->char_pos++;
1517                 break;
1518
1519 #if 0
1520             case 0x84:
1521                 format += 3;
1522                 break;
1523 #endif
1524
1525             case 0x86:
1526             case 0x87:
1527             case 0x88:
1528                 {
1529                     BYTE    type = format[1];
1530
1531                     /* FIXME: we don't use 'BYTE    pos = (*format - 0x86);' for the image position */
1532                     format += 2;
1533                     size = fetch_long(&format);
1534
1535                     switch (type)
1536                     {
1537                     case 0x22:
1538                         fetch_ushort(&format); /* hot spot */
1539                         /* fall through */
1540                     case 0x03:
1541                         switch (GET_SHORT(format, 0))
1542                         {
1543                         case 0:
1544                             HLPFILE_RtfAddGfxByIndex(rd, page->file, GET_SHORT(format, 2));
1545                             rd->char_pos++;
1546                             break;
1547                         case 1:
1548                             WINE_FIXME("does it work ??? %x<%u>#%u\n",
1549                                        GET_SHORT(format, 0),
1550                                        size, GET_SHORT(format, 2));
1551                             HLPFILE_RtfAddGfxByAddr(rd, page->file, format + 2, size - 4);
1552                             rd->char_pos++;
1553                            break;
1554                         default:
1555                             WINE_FIXME("??? %u\n", GET_SHORT(format, 0));
1556                             break;
1557                         }
1558                         break;
1559                     case 0x05:
1560                         WINE_FIXME("Got an embedded element %s\n", format + 6);
1561                         break;
1562                     default:
1563                         WINE_FIXME("Got a type %d picture\n", type);
1564                         break;
1565                     }
1566                     format += size;
1567                 }
1568                 break;
1569
1570             case 0x89:
1571                 format += 1;
1572                 if (!rd->current_link)
1573                     WINE_FIXME("No existing link\n");
1574                 rd->current_link->cpMax = rd->char_pos;
1575                 rd->current_link = NULL;
1576                 rd->force_color = FALSE;
1577                 break;
1578
1579             case 0x8B:
1580                 if (!HLPFILE_RtfAddControl(rd, "\\~")) goto done;
1581                 format += 1;
1582                 rd->char_pos++;
1583                 break;
1584
1585             case 0x8C:
1586                 if (!HLPFILE_RtfAddControl(rd, "\\_")) goto done;
1587                 /* FIXME: it could be that hyphen is also in input stream !! */
1588                 format += 1;
1589                 rd->char_pos++;
1590                 break;
1591
1592 #if 0
1593             case 0xA9:
1594                 format += 2;
1595                 break;
1596 #endif
1597
1598             case 0xC8:
1599             case 0xCC:
1600                 WINE_TRACE("macro => %s\n", format + 3);
1601                 HLPFILE_AllocLink(rd, hlp_link_macro, (const char*)format + 3,
1602                                   GET_USHORT(format, 1), 0, !(*format & 4), 0, -1);
1603                 format += 3 + GET_USHORT(format, 1);
1604                 break;
1605
1606             case 0xE0:
1607             case 0xE1:
1608                 WINE_WARN("jump topic 1 => %u\n", GET_UINT(format, 1));
1609                 HLPFILE_AllocLink(rd, (*format & 1) ? hlp_link_link : hlp_link_popup,
1610                                   page->file->lpszPath, -1, GET_UINT(format, 1), 1, 0, -1);
1611
1612
1613                 format += 5;
1614                 break;
1615
1616             case 0xE2:
1617             case 0xE3:
1618             case 0xE6:
1619             case 0xE7:
1620                 HLPFILE_AllocLink(rd, (*format & 1) ? hlp_link_link : hlp_link_popup,
1621                                   page->file->lpszPath, -1, GET_UINT(format, 1),
1622                                   !(*format & 4), 0, -1);
1623                 format += 5;
1624                 break;
1625
1626             case 0xEA:
1627             case 0xEB:
1628             case 0xEE:
1629             case 0xEF:
1630                 {
1631                     const char*       ptr = (const char*) format + 8;
1632                     BYTE        type = format[3];
1633                     int         wnd = -1;
1634
1635                     switch (type)
1636                     {
1637                     case 1:
1638                         wnd = *ptr;
1639                         /* fall through */
1640                     case 0:
1641                         ptr = page->file->lpszPath;
1642                         break;
1643                     case 6:
1644                         for (wnd = page->file->numWindows - 1; wnd >= 0; wnd--)
1645                         {
1646                             if (!strcmp(ptr, page->file->windows[wnd].name)) break;
1647                         }
1648                         if (wnd == -1)
1649                             WINE_WARN("Couldn't find window info for %s\n", ptr);
1650                         ptr += strlen(ptr) + 1;
1651                         /* fall through */
1652                     case 4:
1653                         break;
1654                     default:
1655                         WINE_WARN("Unknown link type %d\n", type);
1656                         break;
1657                     }
1658                     HLPFILE_AllocLink(rd, (*format & 1) ? hlp_link_link : hlp_link_popup,
1659                                       ptr, -1, GET_UINT(format, 4), !(*format & 4), 0, wnd);
1660                 }
1661                 format += 3 + GET_USHORT(format, 1);
1662                 break;
1663
1664             default:
1665                 WINE_WARN("format %02x\n", *format);
1666                 format++;
1667             }
1668         }
1669     }
1670     if (in_table)
1671     {
1672         if (!HLPFILE_RtfAddControl(rd, "\\row\\par\\pard\\plain")) goto done;
1673         rd->char_pos += 2;
1674     }
1675     ret = TRUE;
1676 done:
1677
1678     HeapFree(GetProcessHeap(), 0, text_base);
1679     return ret;
1680 }
1681
1682 /******************************************************************
1683  *              HLPFILE_BrowsePage
1684  *
1685  */
1686 BOOL    HLPFILE_BrowsePage(HLPFILE_PAGE* page, struct RtfData* rd,
1687                            unsigned font_scale, unsigned relative)
1688 {
1689     HLPFILE     *hlpfile = page->file;
1690     BYTE        *buf, *end;
1691     DWORD       ref = page->reference;
1692     unsigned    index, old_index = -1, offset, count = 0, offs = 0;
1693     unsigned    cpg, parlen;
1694     char        tmp[1024];
1695     const char* ck = NULL;
1696
1697     rd->in_text = TRUE;
1698     rd->data = rd->ptr = HeapAlloc(GetProcessHeap(), 0, rd->allocated = 32768);
1699     rd->char_pos = 0;
1700     rd->first_link = rd->current_link = NULL;
1701     rd->force_color = FALSE;
1702     rd->font_scale = font_scale;
1703     rd->relative = relative;
1704     rd->char_pos_rel = 0;
1705
1706     switch (hlpfile->charset)
1707     {
1708     case DEFAULT_CHARSET:
1709     case ANSI_CHARSET:          cpg = 1252; break;
1710     case SHIFTJIS_CHARSET:      cpg = 932; break;
1711     case HANGEUL_CHARSET:       cpg = 949; break;
1712     case GB2312_CHARSET:        cpg = 936; break;
1713     case CHINESEBIG5_CHARSET:   cpg = 950; break;
1714     case GREEK_CHARSET:         cpg = 1253; break;
1715     case TURKISH_CHARSET:       cpg = 1254; break;
1716     case HEBREW_CHARSET:        cpg = 1255; break;
1717     case ARABIC_CHARSET:        cpg = 1256; break;
1718     case BALTIC_CHARSET:        cpg = 1257; break;
1719     case VIETNAMESE_CHARSET:    cpg = 1258; break;
1720     case RUSSIAN_CHARSET:       cpg = 1251; break;
1721     case EE_CHARSET:            cpg = 1250; break;
1722     case THAI_CHARSET:          cpg = 874; break;
1723     case JOHAB_CHARSET:         cpg = 1361; break;
1724     case MAC_CHARSET:           ck = "mac"; break;
1725     default:
1726         WINE_FIXME("Unsupported charset %u\n", hlpfile->charset);
1727         cpg = 1252;
1728     }
1729     if (ck)
1730     {
1731         sprintf(tmp, "{\\rtf1\\%s\\deff0", ck);
1732         if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
1733     }
1734     else
1735     {
1736         sprintf(tmp, "{\\rtf1\\ansi\\ansicpg%d\\deff0", cpg);
1737         if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
1738     }
1739
1740     /* generate font table */
1741     if (!HLPFILE_RtfAddControl(rd, "{\\fonttbl")) return FALSE;
1742     for (index = 0; index < hlpfile->numFonts; index++)
1743     {
1744         const char* family;
1745         switch (hlpfile->fonts[index].LogFont.lfPitchAndFamily & 0xF0)
1746         {
1747         case FF_MODERN:     family = "modern";  break;
1748         case FF_ROMAN:      family = "roman";   break;
1749         case FF_SWISS:      family = "swiss";   break;
1750         case FF_SCRIPT:     family = "script";  break;
1751         case FF_DECORATIVE: family = "decor";   break;
1752         default:            family = "nil";     break;
1753         }
1754         sprintf(tmp, "{\\f%d\\f%s\\fprq%d\\fcharset%d %s;}",
1755                 index, family,
1756                 hlpfile->fonts[index].LogFont.lfPitchAndFamily & 0x0F,
1757                 hlpfile->fonts[index].LogFont.lfCharSet,
1758                 hlpfile->fonts[index].LogFont.lfFaceName);
1759         if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
1760     }
1761     if (!HLPFILE_RtfAddControl(rd, "}")) return FALSE;
1762     /* generate color table */
1763     if (!HLPFILE_RtfAddControl(rd, "{\\colortbl ;\\red0\\green128\\blue0;")) return FALSE;
1764     for (index = 0; index < hlpfile->numFonts; index++)
1765     {
1766         sprintf(tmp, "\\red%d\\green%d\\blue%d;",
1767                 GetRValue(hlpfile->fonts[index].color),
1768                 GetGValue(hlpfile->fonts[index].color),
1769                 GetBValue(hlpfile->fonts[index].color));
1770         if (!HLPFILE_RtfAddControl(rd, tmp)) return FALSE;
1771     }
1772     if (!HLPFILE_RtfAddControl(rd, "}")) return FALSE;
1773
1774     do
1775     {
1776         if (hlpfile->version <= 16)
1777         {
1778             index  = (ref - 0x0C) / hlpfile->dsize;
1779             offset = (ref - 0x0C) % hlpfile->dsize;
1780         }
1781         else
1782         {
1783             index  = (ref - 0x0C) >> 14;
1784             offset = (ref - 0x0C) & 0x3FFF;
1785         }
1786
1787         if (hlpfile->version <= 16 && index != old_index && old_index != -1)
1788         {
1789             /* we jumped to the next block, adjust pointers */
1790             ref -= 12;
1791             offset -= 12;
1792         }
1793
1794         if (index >= hlpfile->topic_maplen) {WINE_WARN("maplen\n"); break;}
1795         buf = hlpfile->topic_map[index] + offset;
1796         if (buf + 0x15 >= hlpfile->topic_end) {WINE_WARN("extra\n"); break;}
1797         end = min(buf + GET_UINT(buf, 0), hlpfile->topic_end);
1798         if (index != old_index) {offs = 0; old_index = index;}
1799
1800         switch (buf[0x14])
1801         {
1802         case 0x02:
1803             if (count++) goto done;
1804             break;
1805         case 0x01:
1806         case 0x20:
1807         case 0x23:
1808             if (!HLPFILE_BrowseParagraph(page, rd, buf, end, &parlen)) return FALSE;
1809             if (relative > index * 0x8000 + offs)
1810                 rd->char_pos_rel = rd->char_pos;
1811             offs += parlen;
1812             break;
1813         default:
1814             WINE_ERR("buf[0x14] = %x\n", buf[0x14]);
1815         }
1816         if (hlpfile->version <= 16)
1817         {
1818             ref += GET_UINT(buf, 0xc);
1819             if (GET_UINT(buf, 0xc) == 0)
1820                 break;
1821         }
1822         else
1823             ref = GET_UINT(buf, 0xc);
1824     } while (ref != 0xffffffff);
1825 done:
1826     page->first_link = rd->first_link;
1827     return HLPFILE_RtfAddControl(rd, "}");
1828 }
1829
1830 /******************************************************************
1831  *              HLPFILE_ReadFont
1832  *
1833  *
1834  */
1835 static BOOL HLPFILE_ReadFont(HLPFILE* hlpfile)
1836 {
1837     BYTE        *ref, *end;
1838     unsigned    i, len, idx;
1839     unsigned    face_num, dscr_num, face_offset, dscr_offset;
1840     BYTE        flag, family;
1841
1842     if (!HLPFILE_FindSubFile(hlpfile, "|FONT", &ref, &end))
1843     {
1844         WINE_WARN("no subfile FONT\n");
1845         hlpfile->numFonts = 0;
1846         hlpfile->fonts = NULL;
1847         return FALSE;
1848     }
1849
1850     ref += 9;
1851
1852     face_num    = GET_USHORT(ref, 0);
1853     dscr_num    = GET_USHORT(ref, 2);
1854     face_offset = GET_USHORT(ref, 4);
1855     dscr_offset = GET_USHORT(ref, 6);
1856
1857     WINE_TRACE("Got NumFacenames=%u@%u NumDesc=%u@%u\n",
1858                face_num, face_offset, dscr_num, dscr_offset);
1859
1860     hlpfile->numFonts = dscr_num;
1861     hlpfile->fonts = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_FONT) * dscr_num);
1862
1863     len = (dscr_offset - face_offset) / face_num;
1864 /* EPP     for (i = face_offset; i < dscr_offset; i += len) */
1865 /* EPP         WINE_FIXME("[%d]: %*s\n", i / len, len, ref + i); */
1866     for (i = 0; i < dscr_num; i++)
1867     {
1868         flag = ref[dscr_offset + i * 11 + 0];
1869         family = ref[dscr_offset + i * 11 + 2];
1870
1871         hlpfile->fonts[i].LogFont.lfHeight = ref[dscr_offset + i * 11 + 1];
1872         hlpfile->fonts[i].LogFont.lfWidth = 0;
1873         hlpfile->fonts[i].LogFont.lfEscapement = 0;
1874         hlpfile->fonts[i].LogFont.lfOrientation = 0;
1875         hlpfile->fonts[i].LogFont.lfWeight = (flag & 1) ? 700 : 400;
1876         hlpfile->fonts[i].LogFont.lfItalic = (flag & 2) ? TRUE : FALSE;
1877         hlpfile->fonts[i].LogFont.lfUnderline = (flag & 4) ? TRUE : FALSE;
1878         hlpfile->fonts[i].LogFont.lfStrikeOut = (flag & 8) ? TRUE : FALSE;
1879         hlpfile->fonts[i].LogFont.lfCharSet = hlpfile->charset;
1880         hlpfile->fonts[i].LogFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
1881         hlpfile->fonts[i].LogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
1882         hlpfile->fonts[i].LogFont.lfQuality = DEFAULT_QUALITY;
1883         hlpfile->fonts[i].LogFont.lfPitchAndFamily = DEFAULT_PITCH;
1884
1885         switch (family)
1886         {
1887         case 0x01: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_MODERN;     break;
1888         case 0x02: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_ROMAN;      break;
1889         case 0x03: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SWISS;      break;
1890         case 0x04: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_SCRIPT;     break;
1891         case 0x05: hlpfile->fonts[i].LogFont.lfPitchAndFamily |= FF_DECORATIVE; break;
1892         default: WINE_FIXME("Unknown family %u\n", family);
1893         }
1894         idx = GET_USHORT(ref, dscr_offset + i * 11 + 3);
1895
1896         if (idx < face_num)
1897         {
1898             memcpy(hlpfile->fonts[i].LogFont.lfFaceName, ref + face_offset + idx * len, min(len, LF_FACESIZE - 1));
1899             hlpfile->fonts[i].LogFont.lfFaceName[min(len, LF_FACESIZE - 1)] = '\0';
1900         }
1901         else
1902         {
1903             WINE_FIXME("Too high face ref (%u/%u)\n", idx, face_num);
1904             strcpy(hlpfile->fonts[i].LogFont.lfFaceName, "Helv");
1905         }
1906         hlpfile->fonts[i].hFont = 0;
1907         hlpfile->fonts[i].color = RGB(ref[dscr_offset + i * 11 + 5],
1908                                       ref[dscr_offset + i * 11 + 6],
1909                                       ref[dscr_offset + i * 11 + 7]);
1910 #define X(b,s) ((flag & (1 << b)) ? "-"s: "")
1911         WINE_TRACE("Font[%d]: flags=%02x%s%s%s%s%s%s pSize=%u family=%u face=%s[%u] color=%08x\n",
1912                    i, flag,
1913                    X(0, "bold"),
1914                    X(1, "italic"),
1915                    X(2, "underline"),
1916                    X(3, "strikeOut"),
1917                    X(4, "dblUnderline"),
1918                    X(5, "smallCaps"),
1919                    ref[dscr_offset + i * 11 + 1],
1920                    family,
1921                    hlpfile->fonts[i].LogFont.lfFaceName, idx,
1922                    GET_UINT(ref, dscr_offset + i * 11 + 5) & 0x00FFFFFF);
1923     }
1924     return TRUE;
1925 }
1926
1927 /***********************************************************************
1928  *
1929  *           HLPFILE_ReadFileToBuffer
1930  */
1931 static BOOL HLPFILE_ReadFileToBuffer(HLPFILE* hlpfile, HFILE hFile)
1932 {
1933     BYTE  header[16], dummy[1];
1934
1935     if (_hread(hFile, header, 16) != 16) {WINE_WARN("header\n"); return FALSE;};
1936
1937     /* sanity checks */
1938     if (GET_UINT(header, 0) != 0x00035F3F)
1939     {WINE_WARN("wrong header\n"); return FALSE;};
1940
1941     hlpfile->file_buffer_size = GET_UINT(header, 12);
1942     hlpfile->file_buffer = HeapAlloc(GetProcessHeap(), 0, hlpfile->file_buffer_size + 1);
1943     if (!hlpfile->file_buffer) return FALSE;
1944
1945     memcpy(hlpfile->file_buffer, header, 16);
1946     if (_hread(hFile, hlpfile->file_buffer + 16, hlpfile->file_buffer_size - 16) !=hlpfile->file_buffer_size - 16)
1947     {WINE_WARN("filesize1\n"); return FALSE;};
1948
1949     if (_hread(hFile, dummy, 1) != 0) WINE_WARN("filesize2\n");
1950
1951     hlpfile->file_buffer[hlpfile->file_buffer_size] = '\0'; /* FIXME: was '0', sounds backwards to me */
1952
1953     return TRUE;
1954 }
1955
1956 /***********************************************************************
1957  *
1958  *           HLPFILE_SystemCommands
1959  */
1960 static BOOL HLPFILE_SystemCommands(HLPFILE* hlpfile)
1961 {
1962     BYTE *buf, *ptr, *end;
1963     HLPFILE_MACRO *macro, **m;
1964     LPSTR p;
1965     unsigned short magic, minor, major, flags;
1966
1967     hlpfile->lpszTitle = NULL;
1968
1969     if (!HLPFILE_FindSubFile(hlpfile, "|SYSTEM", &buf, &end)) return FALSE;
1970
1971     magic = GET_USHORT(buf + 9, 0);
1972     minor = GET_USHORT(buf + 9, 2);
1973     major = GET_USHORT(buf + 9, 4);
1974     /* gen date on 4 bytes */
1975     flags = GET_USHORT(buf + 9, 10);
1976     WINE_TRACE("Got system header: magic=%04x version=%d.%d flags=%04x\n",
1977                magic, major, minor, flags);
1978     if (magic != 0x036C || major != 1)
1979     {WINE_WARN("Wrong system header\n"); return FALSE;}
1980     if (minor <= 16)
1981     {
1982         hlpfile->tbsize = 0x800;
1983         hlpfile->compressed = 0;
1984     }
1985     else if (flags == 0)
1986     {
1987         hlpfile->tbsize = 0x1000;
1988         hlpfile->compressed = 0;
1989     }
1990     else if (flags == 4)
1991     {
1992         hlpfile->tbsize = 0x1000;
1993         hlpfile->compressed = 1;
1994     }
1995     else
1996     {
1997         hlpfile->tbsize = 0x800;
1998         hlpfile->compressed = 1;
1999     }
2000
2001     if (hlpfile->compressed)
2002         hlpfile->dsize = 0x4000;
2003     else
2004         hlpfile->dsize = hlpfile->tbsize - 0x0C;
2005
2006     hlpfile->version = minor;
2007     hlpfile->flags = flags;
2008     hlpfile->charset = DEFAULT_CHARSET;
2009
2010     if (hlpfile->version <= 16)
2011     {
2012         char *str = (char*)buf + 0x15;
2013
2014         hlpfile->lpszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(str) + 1);
2015         if (!hlpfile->lpszTitle) return FALSE;
2016         strcpy(hlpfile->lpszTitle, str);
2017         WINE_TRACE("Title: %s\n", hlpfile->lpszTitle);
2018         /* Nothing more to parse */
2019         return TRUE;
2020     }
2021     for (ptr = buf + 0x15; ptr + 4 <= end; ptr += GET_USHORT(ptr, 2) + 4)
2022     {
2023         char *str = (char*) ptr + 4;
2024         switch (GET_USHORT(ptr, 0))
2025         {
2026         case 1:
2027             if (hlpfile->lpszTitle) {WINE_WARN("title\n"); break;}
2028             hlpfile->lpszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(str) + 1);
2029             if (!hlpfile->lpszTitle) return FALSE;
2030             strcpy(hlpfile->lpszTitle, str);
2031             WINE_TRACE("Title: %s\n", hlpfile->lpszTitle);
2032             break;
2033
2034         case 2:
2035             if (hlpfile->lpszCopyright) {WINE_WARN("copyright\n"); break;}
2036             hlpfile->lpszCopyright = HeapAlloc(GetProcessHeap(), 0, strlen(str) + 1);
2037             if (!hlpfile->lpszCopyright) return FALSE;
2038             strcpy(hlpfile->lpszCopyright, str);
2039             WINE_TRACE("Copyright: %s\n", hlpfile->lpszCopyright);
2040             break;
2041
2042         case 3:
2043             if (GET_USHORT(ptr, 2) != 4) {WINE_WARN("system3\n");break;}
2044             hlpfile->contents_start = GET_UINT(ptr, 4);
2045             WINE_TRACE("Setting contents start at %08lx\n", hlpfile->contents_start);
2046             break;
2047
2048         case 4:
2049             macro = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_MACRO) + strlen(str) + 1);
2050             if (!macro) break;
2051             p = (char*)macro + sizeof(HLPFILE_MACRO);
2052             strcpy(p, str);
2053             macro->lpszMacro = p;
2054             macro->next = 0;
2055             for (m = &hlpfile->first_macro; *m; m = &(*m)->next);
2056             *m = macro;
2057             break;
2058
2059         case 5:
2060             if (GET_USHORT(ptr, 4 + 4) != 1)
2061                 WINE_FIXME("More than one icon, picking up first\n");
2062             /* 0x16 is sizeof(CURSORICONDIR), see user32/user_private.h */
2063             hlpfile->hIcon = CreateIconFromResourceEx(ptr + 4 + 0x16,
2064                                                       GET_USHORT(ptr, 2) - 0x16, TRUE,
2065                                                       0x30000, 0, 0, 0);
2066             break;
2067
2068         case 6:
2069             if (GET_USHORT(ptr, 2) != 90) {WINE_WARN("system6\n");break;}
2070
2071             if (hlpfile->windows)
2072                 hlpfile->windows = HeapReAlloc(GetProcessHeap(), 0, hlpfile->windows,
2073                                            sizeof(HLPFILE_WINDOWINFO) * ++hlpfile->numWindows);
2074             else
2075                 hlpfile->windows = HeapAlloc(GetProcessHeap(), 0,
2076                                            sizeof(HLPFILE_WINDOWINFO) * ++hlpfile->numWindows);
2077
2078             if (hlpfile->windows)
2079             {
2080                 HLPFILE_WINDOWINFO* wi = &hlpfile->windows[hlpfile->numWindows - 1];
2081
2082                 flags = GET_USHORT(ptr, 4);
2083                 if (flags & 0x0001) strcpy(wi->type, &str[2]);
2084                 else wi->type[0] = '\0';
2085                 if (flags & 0x0002) strcpy(wi->name, &str[12]);
2086                 else wi->name[0] = '\0';
2087                 if (flags & 0x0004) strcpy(wi->caption, &str[21]);
2088                 else lstrcpynA(wi->caption, hlpfile->lpszTitle, sizeof(wi->caption));
2089                 wi->origin.x = (flags & 0x0008) ? GET_USHORT(ptr, 76) : CW_USEDEFAULT;
2090                 wi->origin.y = (flags & 0x0010) ? GET_USHORT(ptr, 78) : CW_USEDEFAULT;
2091                 wi->size.cx = (flags & 0x0020) ? GET_USHORT(ptr, 80) : CW_USEDEFAULT;
2092                 wi->size.cy = (flags & 0x0040) ? GET_USHORT(ptr, 82) : CW_USEDEFAULT;
2093                 wi->style = (flags & 0x0080) ? GET_USHORT(ptr, 84) : SW_SHOW;
2094                 wi->win_style = WS_OVERLAPPEDWINDOW;
2095                 wi->sr_color = (flags & 0x0100) ? GET_UINT(ptr, 86) : 0xFFFFFF;
2096                 wi->nsr_color = (flags & 0x0200) ? GET_UINT(ptr, 90) : 0xFFFFFF;
2097                 WINE_TRACE("System-Window: flags=%c%c%c%c%c%c%c%c type=%s name=%s caption=%s (%d,%d)x(%d,%d)\n",
2098                            flags & 0x0001 ? 'T' : 't',
2099                            flags & 0x0002 ? 'N' : 'n',
2100                            flags & 0x0004 ? 'C' : 'c',
2101                            flags & 0x0008 ? 'X' : 'x',
2102                            flags & 0x0010 ? 'Y' : 'y',
2103                            flags & 0x0020 ? 'W' : 'w',
2104                            flags & 0x0040 ? 'H' : 'h',
2105                            flags & 0x0080 ? 'S' : 's',
2106                            wi->type, wi->name, wi->caption, wi->origin.x, wi->origin.y,
2107                            wi->size.cx, wi->size.cy);
2108             }
2109             break;
2110         case 8:
2111             WINE_WARN("Citation: '%s'\n", ptr + 4);
2112             break;
2113         case 11:
2114             hlpfile->charset = ptr[4];
2115             WINE_TRACE("Charset: %d\n", hlpfile->charset);
2116             break;
2117         default:
2118             WINE_WARN("Unsupported SystemRecord[%d]\n", GET_USHORT(ptr, 0));
2119         }
2120     }
2121     if (!hlpfile->lpszTitle)
2122         hlpfile->lpszTitle = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 1);
2123     return TRUE;
2124 }
2125
2126 /***********************************************************************
2127  *
2128  *           HLPFILE_GetContext
2129  */
2130 static BOOL HLPFILE_GetContext(HLPFILE *hlpfile)
2131 {
2132     BYTE                *cbuf, *cend;
2133     unsigned            clen;
2134
2135     if (!HLPFILE_FindSubFile(hlpfile, "|CONTEXT",  &cbuf, &cend))
2136     {WINE_WARN("context0\n"); return FALSE;}
2137
2138     clen = cend - cbuf;
2139     hlpfile->Context = HeapAlloc(GetProcessHeap(), 0, clen);
2140     if (!hlpfile->Context) return FALSE;
2141     memcpy(hlpfile->Context, cbuf, clen);
2142
2143     return TRUE;
2144 }
2145
2146 /***********************************************************************
2147  *
2148  *           HLPFILE_GetKeywords
2149  */
2150 static BOOL HLPFILE_GetKeywords(HLPFILE *hlpfile)
2151 {
2152     BYTE                *cbuf, *cend;
2153     unsigned            clen;
2154
2155     if (!HLPFILE_FindSubFile(hlpfile, "|KWBTREE", &cbuf, &cend)) return FALSE;
2156     clen = cend - cbuf;
2157     hlpfile->kwbtree = HeapAlloc(GetProcessHeap(), 0, clen);
2158     if (!hlpfile->kwbtree) return FALSE;
2159     memcpy(hlpfile->kwbtree, cbuf, clen);
2160
2161     if (!HLPFILE_FindSubFile(hlpfile, "|KWDATA", &cbuf, &cend))
2162     {
2163         WINE_ERR("corrupted help file: kwbtree present but kwdata absent\n");
2164         HeapFree(GetProcessHeap(), 0, hlpfile->kwbtree);
2165         return FALSE;
2166     }
2167     clen = cend - cbuf;
2168     hlpfile->kwdata = HeapAlloc(GetProcessHeap(), 0, clen);
2169     if (!hlpfile->kwdata)
2170     {
2171         HeapFree(GetProcessHeap(), 0, hlpfile->kwdata);
2172         return FALSE;
2173     }
2174     memcpy(hlpfile->kwdata, cbuf, clen);
2175
2176     return TRUE;
2177 }
2178
2179 /***********************************************************************
2180  *
2181  *           HLPFILE_GetMap
2182  */
2183 static BOOL HLPFILE_GetMap(HLPFILE *hlpfile)
2184 {
2185     BYTE                *cbuf, *cend;
2186     unsigned            entries, i;
2187
2188     if (!HLPFILE_FindSubFile(hlpfile, "|CTXOMAP",  &cbuf, &cend))
2189     {WINE_WARN("no map section\n"); return FALSE;}
2190
2191     entries = GET_USHORT(cbuf, 9);
2192     hlpfile->Map = HeapAlloc(GetProcessHeap(), 0, entries * sizeof(HLPFILE_MAP));
2193     if (!hlpfile->Map) return FALSE;
2194     hlpfile->wMapLen = entries;
2195     for (i = 0; i < entries; i++)
2196     {
2197         hlpfile->Map[i].lMap = GET_UINT(cbuf+11,i*8);
2198         hlpfile->Map[i].offset = GET_UINT(cbuf+11,i*8+4);
2199     }
2200     return TRUE;
2201 }
2202
2203 /***********************************************************************
2204  *
2205  *           HLPFILE_GetTOMap
2206  */
2207 static BOOL HLPFILE_GetTOMap(HLPFILE *hlpfile)
2208 {
2209     BYTE                *cbuf, *cend;
2210     unsigned            clen;
2211
2212     if (!HLPFILE_FindSubFile(hlpfile, "|TOMAP",  &cbuf, &cend))
2213     {WINE_WARN("no tomap section\n"); return FALSE;}
2214
2215     clen = cend - cbuf - 9;
2216     hlpfile->TOMap = HeapAlloc(GetProcessHeap(), 0, clen);
2217     if (!hlpfile->TOMap) return FALSE;
2218     memcpy(hlpfile->TOMap, cbuf+9, clen);
2219     hlpfile->wTOMapLen = clen/4;
2220     return TRUE;
2221 }
2222
2223 /***********************************************************************
2224  *
2225  *           DeleteMacro
2226  */
2227 static void HLPFILE_DeleteMacro(HLPFILE_MACRO* macro)
2228 {
2229     HLPFILE_MACRO*      next;
2230
2231     while (macro)
2232     {
2233         next = macro->next;
2234         HeapFree(GetProcessHeap(), 0, macro);
2235         macro = next;
2236     }
2237 }
2238
2239 /***********************************************************************
2240  *
2241  *           DeletePage
2242  */
2243 static void HLPFILE_DeletePage(HLPFILE_PAGE* page)
2244 {
2245     HLPFILE_PAGE* next;
2246
2247     while (page)
2248     {
2249         next = page->next;
2250         HLPFILE_DeleteMacro(page->first_macro);
2251         HeapFree(GetProcessHeap(), 0, page);
2252         page = next;
2253     }
2254 }
2255
2256 /***********************************************************************
2257  *
2258  *           HLPFILE_FreeHlpFile
2259  */
2260 void HLPFILE_FreeHlpFile(HLPFILE* hlpfile)
2261 {
2262     unsigned i;
2263
2264     if (!hlpfile || --hlpfile->wRefCount > 0) return;
2265
2266     if (hlpfile->next) hlpfile->next->prev = hlpfile->prev;
2267     if (hlpfile->prev) hlpfile->prev->next = hlpfile->next;
2268     else first_hlpfile = hlpfile->next;
2269
2270     if (hlpfile->numFonts)
2271     {
2272         for (i = 0; i < hlpfile->numFonts; i++)
2273         {
2274             DeleteObject(hlpfile->fonts[i].hFont);
2275         }
2276         HeapFree(GetProcessHeap(), 0, hlpfile->fonts);
2277     }
2278
2279     if (hlpfile->numBmps)
2280     {
2281         for (i = 0; i < hlpfile->numBmps; i++)
2282         {
2283             DeleteObject(hlpfile->bmps[i]);
2284         }
2285         HeapFree(GetProcessHeap(), 0, hlpfile->bmps);
2286     }
2287
2288     HLPFILE_DeletePage(hlpfile->first_page);
2289     HLPFILE_DeleteMacro(hlpfile->first_macro);
2290
2291     DestroyIcon(hlpfile->hIcon);
2292     if (hlpfile->numWindows)    HeapFree(GetProcessHeap(), 0, hlpfile->windows);
2293     HeapFree(GetProcessHeap(), 0, hlpfile->Context);
2294     HeapFree(GetProcessHeap(), 0, hlpfile->Map);
2295     HeapFree(GetProcessHeap(), 0, hlpfile->lpszTitle);
2296     HeapFree(GetProcessHeap(), 0, hlpfile->lpszCopyright);
2297     HeapFree(GetProcessHeap(), 0, hlpfile->file_buffer);
2298     HeapFree(GetProcessHeap(), 0, hlpfile->phrases_offsets);
2299     HeapFree(GetProcessHeap(), 0, hlpfile->phrases_buffer);
2300     HeapFree(GetProcessHeap(), 0, hlpfile->topic_map);
2301     HeapFree(GetProcessHeap(), 0, hlpfile->help_on_file);
2302     HeapFree(GetProcessHeap(), 0, hlpfile);
2303 }
2304
2305 /***********************************************************************
2306  *
2307  *           HLPFILE_UncompressLZ77_Phrases
2308  */
2309 static BOOL HLPFILE_UncompressLZ77_Phrases(HLPFILE* hlpfile)
2310 {
2311     UINT i, num, dec_size, head_size;
2312     BYTE *buf, *end;
2313
2314     if (!HLPFILE_FindSubFile(hlpfile, "|Phrases", &buf, &end)) return FALSE;
2315
2316     if (hlpfile->version <= 16)
2317         head_size = 13;
2318     else
2319         head_size = 17;
2320
2321     num = hlpfile->num_phrases = GET_USHORT(buf, 9);
2322     if (buf + 2 * num + 0x13 >= end) {WINE_WARN("1a\n"); return FALSE;};
2323
2324     if (hlpfile->version <= 16)
2325         dec_size = end - buf - 15 - 2 * num;
2326     else
2327         dec_size = HLPFILE_UncompressedLZ77_Size(buf + 0x13 + 2 * num, end);
2328
2329     hlpfile->phrases_offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
2330     hlpfile->phrases_buffer  = HeapAlloc(GetProcessHeap(), 0, dec_size);
2331     if (!hlpfile->phrases_offsets || !hlpfile->phrases_buffer)
2332     {
2333         HeapFree(GetProcessHeap(), 0, hlpfile->phrases_offsets);
2334         HeapFree(GetProcessHeap(), 0, hlpfile->phrases_buffer);
2335         return FALSE;
2336     }
2337
2338     for (i = 0; i <= num; i++)
2339         hlpfile->phrases_offsets[i] = GET_USHORT(buf, head_size + 2 * i) - 2 * num - 2;
2340
2341     if (hlpfile->version <= 16)
2342         memcpy(hlpfile->phrases_buffer, buf + 15 + 2*num, dec_size);
2343     else
2344         HLPFILE_UncompressLZ77(buf + 0x13 + 2 * num, end, (BYTE*)hlpfile->phrases_buffer);
2345
2346     hlpfile->hasPhrases = TRUE;
2347     return TRUE;
2348 }
2349
2350 /***********************************************************************
2351  *
2352  *           HLPFILE_Uncompress_Phrases40
2353  */
2354 static BOOL HLPFILE_Uncompress_Phrases40(HLPFILE* hlpfile)
2355 {
2356     UINT num;
2357     INT dec_size, cpr_size;
2358     BYTE *buf_idx, *end_idx;
2359     BYTE *buf_phs, *end_phs;
2360     ULONG* ptr, mask = 0;
2361     unsigned int i;
2362     unsigned short bc, n;
2363
2364     if (!HLPFILE_FindSubFile(hlpfile, "|PhrIndex", &buf_idx, &end_idx) ||
2365         !HLPFILE_FindSubFile(hlpfile, "|PhrImage", &buf_phs, &end_phs)) return FALSE;
2366
2367     ptr = (ULONG*)(buf_idx + 9 + 28);
2368     bc = GET_USHORT(buf_idx, 9 + 24) & 0x0F;
2369     num = hlpfile->num_phrases = GET_USHORT(buf_idx, 9 + 4);
2370
2371     WINE_TRACE("Index: Magic=%08x #entries=%u CpsdSize=%u PhrImgSize=%u\n"
2372                "\tPhrImgCprsdSize=%u 0=%u bc=%x ukn=%x\n",
2373                GET_UINT(buf_idx, 9 + 0),
2374                GET_UINT(buf_idx, 9 + 4),
2375                GET_UINT(buf_idx, 9 + 8),
2376                GET_UINT(buf_idx, 9 + 12),
2377                GET_UINT(buf_idx, 9 + 16),
2378                GET_UINT(buf_idx, 9 + 20),
2379                GET_USHORT(buf_idx, 9 + 24),
2380                GET_USHORT(buf_idx, 9 + 26));
2381
2382     dec_size = GET_UINT(buf_idx, 9 + 12);
2383     cpr_size = GET_UINT(buf_idx, 9 + 16);
2384
2385     if (dec_size != cpr_size &&
2386         dec_size != HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs))
2387     {
2388         WINE_WARN("size mismatch %u %u\n",
2389                   dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs));
2390         dec_size = max(dec_size, HLPFILE_UncompressedLZ77_Size(buf_phs + 9, end_phs));
2391     }
2392
2393     hlpfile->phrases_offsets = HeapAlloc(GetProcessHeap(), 0, sizeof(unsigned) * (num + 1));
2394     hlpfile->phrases_buffer  = HeapAlloc(GetProcessHeap(), 0, dec_size);
2395     if (!hlpfile->phrases_offsets || !hlpfile->phrases_buffer)
2396     {
2397         HeapFree(GetProcessHeap(), 0, hlpfile->phrases_offsets);
2398         HeapFree(GetProcessHeap(), 0, hlpfile->phrases_buffer);
2399         return FALSE;
2400     }
2401
2402 #define getbit() ((mask <<= 1) ? (*ptr & mask) != 0: (*++ptr & (mask=1)) != 0)
2403
2404     hlpfile->phrases_offsets[0] = 0;
2405     ptr--; /* as we'll first increment ptr because mask is 0 on first getbit() call */
2406     for (i = 0; i < num; i++)
2407     {
2408         for (n = 1; getbit(); n += 1 << bc);
2409         if (getbit()) n++;
2410         if (bc > 1 && getbit()) n += 2;
2411         if (bc > 2 && getbit()) n += 4;
2412         if (bc > 3 && getbit()) n += 8;
2413         if (bc > 4 && getbit()) n += 16;
2414         hlpfile->phrases_offsets[i + 1] = hlpfile->phrases_offsets[i] + n;
2415     }
2416 #undef getbit
2417
2418     if (dec_size == cpr_size)
2419         memcpy(hlpfile->phrases_buffer, buf_phs + 9, dec_size);
2420     else
2421         HLPFILE_UncompressLZ77(buf_phs + 9, end_phs, (BYTE*)hlpfile->phrases_buffer);
2422
2423     hlpfile->hasPhrases40 = TRUE;
2424     return TRUE;
2425 }
2426
2427 /***********************************************************************
2428  *
2429  *           HLPFILE_Uncompress_Topic
2430  */
2431 static BOOL HLPFILE_Uncompress_Topic(HLPFILE* hlpfile)
2432 {
2433     BYTE *buf, *ptr, *end, *newptr;
2434     unsigned int i, newsize = 0;
2435     unsigned int topic_size;
2436
2437     if (!HLPFILE_FindSubFile(hlpfile, "|TOPIC", &buf, &end))
2438     {WINE_WARN("topic0\n"); return FALSE;}
2439
2440     buf += 9; /* Skip file header */
2441     topic_size = end - buf;
2442     if (hlpfile->compressed)
2443     {
2444         hlpfile->topic_maplen = (topic_size - 1) / hlpfile->tbsize + 1;
2445
2446         for (i = 0; i < hlpfile->topic_maplen; i++)
2447         {
2448             ptr = buf + i * hlpfile->tbsize;
2449
2450             /* I don't know why, it's necessary for printman.hlp */
2451             if (ptr + 0x44 > end) ptr = end - 0x44;
2452
2453             newsize += HLPFILE_UncompressedLZ77_Size(ptr + 0xc, min(end, ptr + hlpfile->tbsize));
2454         }
2455
2456         hlpfile->topic_map = HeapAlloc(GetProcessHeap(), 0,
2457                                        hlpfile->topic_maplen * sizeof(hlpfile->topic_map[0]) + newsize);
2458         if (!hlpfile->topic_map) return FALSE;
2459         newptr = (BYTE*)(hlpfile->topic_map + hlpfile->topic_maplen);
2460         hlpfile->topic_end = newptr + newsize;
2461
2462         for (i = 0; i < hlpfile->topic_maplen; i++)
2463         {
2464             ptr = buf + i * hlpfile->tbsize;
2465             if (ptr + 0x44 > end) ptr = end - 0x44;
2466
2467             hlpfile->topic_map[i] = newptr;
2468             newptr = HLPFILE_UncompressLZ77(ptr + 0xc, min(end, ptr + hlpfile->tbsize), newptr);
2469         }
2470     }
2471     else
2472     {
2473         /* basically, we need to copy the TopicBlockSize byte pages
2474          * (removing the first 0x0C) in one single area in memory
2475          */
2476         hlpfile->topic_maplen = (topic_size - 1) / hlpfile->tbsize + 1;
2477         hlpfile->topic_map = HeapAlloc(GetProcessHeap(), 0,
2478                                        hlpfile->topic_maplen * (sizeof(hlpfile->topic_map[0]) + hlpfile->dsize));
2479         if (!hlpfile->topic_map) return FALSE;
2480         newptr = (BYTE*)(hlpfile->topic_map + hlpfile->topic_maplen);
2481         hlpfile->topic_end = newptr + topic_size;
2482
2483         for (i = 0; i < hlpfile->topic_maplen; i++)
2484         {
2485             hlpfile->topic_map[i] = newptr + i * hlpfile->dsize;
2486             memcpy(hlpfile->topic_map[i], buf + i * hlpfile->tbsize + 0x0C, hlpfile->dsize);
2487         }
2488     }
2489     return TRUE;
2490 }
2491
2492 /***********************************************************************
2493  *
2494  *           HLPFILE_AddPage
2495  */
2496 static BOOL HLPFILE_AddPage(HLPFILE *hlpfile, const BYTE *buf, const BYTE *end, unsigned ref, unsigned offset)
2497 {
2498     HLPFILE_PAGE* page;
2499     const BYTE*   title;
2500     UINT          titlesize, blocksize, datalen;
2501     char*         ptr;
2502     HLPFILE_MACRO*macro;
2503
2504     blocksize = GET_UINT(buf, 0);
2505     datalen = GET_UINT(buf, 0x10);
2506     title = buf + datalen;
2507     if (title > end) {WINE_WARN("page2\n"); return FALSE;};
2508
2509     titlesize = GET_UINT(buf, 4);
2510     page = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_PAGE) + titlesize + 1);
2511     if (!page) return FALSE;
2512     page->lpszTitle = (char*)page + sizeof(HLPFILE_PAGE);
2513
2514     if (titlesize > blocksize - datalen)
2515     {
2516         /* need to decompress */
2517         if (hlpfile->hasPhrases)
2518             HLPFILE_Uncompress2(hlpfile, title, end, (BYTE*)page->lpszTitle, (BYTE*)page->lpszTitle + titlesize);
2519         else if (hlpfile->hasPhrases40)
2520             HLPFILE_Uncompress3(hlpfile, page->lpszTitle, page->lpszTitle + titlesize, title, end);
2521         else
2522         {
2523             WINE_FIXME("Text size is too long, splitting\n");
2524             titlesize = blocksize - datalen;
2525             memcpy(page->lpszTitle, title, titlesize);
2526         }
2527     }
2528     else
2529         memcpy(page->lpszTitle, title, titlesize);
2530
2531     page->lpszTitle[titlesize] = '\0';
2532
2533     if (hlpfile->first_page)
2534     {
2535         hlpfile->last_page->next = page;
2536         page->prev = hlpfile->last_page;
2537         hlpfile->last_page = page;
2538     }
2539     else
2540     {
2541         hlpfile->first_page = page;
2542         hlpfile->last_page = page;
2543         page->prev = NULL;
2544     }
2545
2546     page->file            = hlpfile;
2547     page->next            = NULL;
2548     page->first_macro     = NULL;
2549     page->first_link      = NULL;
2550     page->wNumber         = GET_UINT(buf, 0x21);
2551     page->offset          = offset;
2552     page->reference       = ref;
2553
2554     page->browse_bwd = GET_UINT(buf, 0x19);
2555     page->browse_fwd = GET_UINT(buf, 0x1D);
2556
2557     if (hlpfile->version <= 16)
2558     {
2559         if (page->browse_bwd == 0xFFFF || page->browse_bwd == 0xFFFFFFFF)
2560             page->browse_bwd = 0xFFFFFFFF;
2561         else
2562             page->browse_bwd = hlpfile->TOMap[page->browse_bwd];
2563
2564         if (page->browse_fwd == 0xFFFF || page->browse_fwd == 0xFFFFFFFF)
2565             page->browse_fwd = 0xFFFFFFFF;
2566         else
2567             page->browse_fwd = hlpfile->TOMap[page->browse_fwd];
2568     }
2569
2570     WINE_TRACE("Added page[%d]: title='%s' %08x << %08x >> %08x\n",
2571                page->wNumber, page->lpszTitle,
2572                page->browse_bwd, page->offset, page->browse_fwd);
2573
2574     /* now load macros */
2575     ptr = page->lpszTitle + strlen(page->lpszTitle) + 1;
2576     while (ptr < page->lpszTitle + titlesize)
2577     {
2578         unsigned len = strlen(ptr);
2579         char*    macro_str;
2580
2581         WINE_TRACE("macro: %s\n", ptr);
2582         macro = HeapAlloc(GetProcessHeap(), 0, sizeof(HLPFILE_MACRO) + len + 1);
2583         macro->lpszMacro = macro_str = (char*)(macro + 1);
2584         memcpy(macro_str, ptr, len + 1);
2585         /* FIXME: shall we really link macro in reverse order ??
2586          * may produce strange results when played at page opening
2587          */
2588         macro->next = page->first_macro;
2589         page->first_macro = macro;
2590         ptr += len + 1;
2591     }
2592
2593     return TRUE;
2594 }
2595
2596 /***********************************************************************
2597  *
2598  *           HLPFILE_SkipParagraph
2599  */
2600 static BOOL HLPFILE_SkipParagraph(HLPFILE *hlpfile, const BYTE *buf, const BYTE *end, unsigned* len)
2601 {
2602     const BYTE  *tmp;
2603
2604     if (!hlpfile->first_page) {WINE_WARN("no page\n"); return FALSE;};
2605     if (buf + 0x19 > end) {WINE_WARN("header too small\n"); return FALSE;};
2606
2607     tmp = buf + 0x15;
2608     if (buf[0x14] == 0x20 || buf[0x14] == 0x23)
2609     {
2610         fetch_long(&tmp);
2611         *len = fetch_ushort(&tmp);
2612     }
2613     else *len = end-buf-15;
2614
2615     return TRUE;
2616 }
2617
2618 /***********************************************************************
2619  *
2620  *           HLPFILE_DoReadHlpFile
2621  */
2622 static BOOL HLPFILE_DoReadHlpFile(HLPFILE *hlpfile, LPCSTR lpszPath)
2623 {
2624     BOOL        ret;
2625     HFILE       hFile;
2626     OFSTRUCT    ofs;
2627     BYTE*       buf;
2628     DWORD       ref = 0x0C;
2629     unsigned    index, old_index, offset, len, offs, topicoffset;
2630
2631     hFile = OpenFile(lpszPath, &ofs, OF_READ);
2632     if (hFile == HFILE_ERROR) return FALSE;
2633
2634     ret = HLPFILE_ReadFileToBuffer(hlpfile, hFile);
2635     _lclose(hFile);
2636     if (!ret) return FALSE;
2637
2638     if (!HLPFILE_SystemCommands(hlpfile)) return FALSE;
2639
2640     if (hlpfile->version <= 16 && !HLPFILE_GetTOMap(hlpfile)) return FALSE;
2641
2642     /* load phrases support */
2643     if (!HLPFILE_UncompressLZ77_Phrases(hlpfile))
2644         HLPFILE_Uncompress_Phrases40(hlpfile);
2645
2646     if (!HLPFILE_Uncompress_Topic(hlpfile)) return FALSE;
2647     if (!HLPFILE_ReadFont(hlpfile)) return FALSE;
2648
2649     old_index = -1;
2650     offs = 0;
2651     do
2652     {
2653         BYTE*   end;
2654
2655         if (hlpfile->version <= 16)
2656         {
2657             index  = (ref - 0x0C) / hlpfile->dsize;
2658             offset = (ref - 0x0C) % hlpfile->dsize;
2659         }
2660         else
2661         {
2662             index  = (ref - 0x0C) >> 14;
2663             offset = (ref - 0x0C) & 0x3FFF;
2664         }
2665
2666         if (hlpfile->version <= 16 && index != old_index && old_index != -1)
2667         {
2668             /* we jumped to the next block, adjust pointers */
2669             ref -= 12;
2670             offset -= 12;
2671         }
2672
2673         WINE_TRACE("ref=%08x => [%u/%u]\n", ref, index, offset);
2674
2675         if (index >= hlpfile->topic_maplen) {WINE_WARN("maplen\n"); break;}
2676         buf = hlpfile->topic_map[index] + offset;
2677         if (buf + 0x15 >= hlpfile->topic_end) {WINE_WARN("extra\n"); break;}
2678         end = min(buf + GET_UINT(buf, 0), hlpfile->topic_end);
2679         if (index != old_index) {offs = 0; old_index = index;}
2680
2681         switch (buf[0x14])
2682         {
2683         case 0x02:
2684             if (hlpfile->version <= 16)
2685                 topicoffset = ref + index * 12;
2686             else
2687                 topicoffset = index * 0x8000 + offs;
2688             if (!HLPFILE_AddPage(hlpfile, buf, end, ref, topicoffset)) return FALSE;
2689             break;
2690
2691         case 0x01:
2692         case 0x20:
2693         case 0x23:
2694             if (!HLPFILE_SkipParagraph(hlpfile, buf, end, &len)) return FALSE;
2695             offs += len;
2696             break;
2697
2698         default:
2699             WINE_ERR("buf[0x14] = %x\n", buf[0x14]);
2700         }
2701
2702         if (hlpfile->version <= 16)
2703         {
2704             ref += GET_UINT(buf, 0xc);
2705             if (GET_UINT(buf, 0xc) == 0)
2706                 break;
2707         }
2708         else
2709             ref = GET_UINT(buf, 0xc);
2710     } while (ref != 0xffffffff);
2711
2712     HLPFILE_GetKeywords(hlpfile);
2713     HLPFILE_GetMap(hlpfile);
2714     if (hlpfile->version <= 16) return TRUE;
2715     return HLPFILE_GetContext(hlpfile);
2716 }
2717
2718 /***********************************************************************
2719  *
2720  *           HLPFILE_ReadHlpFile
2721  */
2722 HLPFILE *HLPFILE_ReadHlpFile(LPCSTR lpszPath)
2723 {
2724     HLPFILE*      hlpfile;
2725
2726     for (hlpfile = first_hlpfile; hlpfile; hlpfile = hlpfile->next)
2727     {
2728         if (!strcmp(lpszPath, hlpfile->lpszPath))
2729         {
2730             hlpfile->wRefCount++;
2731             return hlpfile;
2732         }
2733     }
2734
2735     hlpfile = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2736                         sizeof(HLPFILE) + strlen(lpszPath) + 1);
2737     if (!hlpfile) return 0;
2738
2739     hlpfile->lpszPath           = (char*)hlpfile + sizeof(HLPFILE);
2740     hlpfile->contents_start     = 0xFFFFFFFF;
2741     hlpfile->next               = first_hlpfile;
2742     hlpfile->wRefCount          = 1;
2743
2744     strcpy(hlpfile->lpszPath, lpszPath);
2745
2746     first_hlpfile = hlpfile;
2747     if (hlpfile->next) hlpfile->next->prev = hlpfile;
2748
2749     if (!HLPFILE_DoReadHlpFile(hlpfile, lpszPath))
2750     {
2751         HLPFILE_FreeHlpFile(hlpfile);
2752         hlpfile = 0;
2753     }
2754
2755     return hlpfile;
2756 }