ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/programs/winhelp/hlpfile.c

992 lines
23 KiB
C
Raw Blame History

/*
* Help Viewer
*
* Copyright 1996 Ulrich Schmid
*/
#include <stdio.h>
#include <string.h>
#include "windows.h"
#include "windowsx.h"
#include "winhelp.h"
static void Report(LPCSTR str)
{
#if 0
fprintf(stderr, "%s\n", str);
#endif
}
#define GET_USHORT(buffer, i)\
(((BYTE)((buffer)[(i)]) + 0x100 * (BYTE)((buffer)[(i)+1])))
#define GET_SHORT(buffer, i)\
(((BYTE)((buffer)[(i)]) + 0x100 * (signed char)((buffer)[(i)+1])))
#define GET_UINT(buffer, i)\
GET_USHORT(buffer, i) + 0x10000 * GET_USHORT(buffer, i+2)
static BOOL HLPFILE_DoReadHlpFile(HLPFILE*, LPCSTR);
static BOOL HLPFILE_ReadFileToBuffer(HFILE);
static BOOL HLPFILE_FindSubFile(LPCSTR name, BYTE**, BYTE**);
static VOID HLPFILE_SystemCommands(HLPFILE*);
static BOOL HLPFILE_Uncompress1_Phrases();
static BOOL HLPFILE_Uncompress1_Topic();
static BOOL HLPFILE_GetContext(HLPFILE*);
static BOOL HLPFILE_AddPage(HLPFILE*, BYTE*, BYTE*);
static BOOL HLPFILE_AddParagraph(HLPFILE*, BYTE *, BYTE*);
static UINT HLPFILE_Uncompressed2_Size(BYTE*, BYTE*);
static VOID HLPFILE_Uncompress2(BYTE**, BYTE*, BYTE*);
static HLPFILE *first_hlpfile = 0;
static HGLOBAL hFileBuffer;
static BYTE *file_buffer;
static struct
{
UINT num;
BYTE *buf;
HGLOBAL hBuffer;
} phrases;
static struct
{
BYTE **map;
BYTE *end;
UINT wMapLen;
HGLOBAL hMap;
HGLOBAL hBuffer;
} topic;
static struct
{
UINT bDebug;
UINT wFont;
UINT wIndent;
UINT wHSpace;
UINT wVSpace;
UINT wVBackSpace;
HLPFILE_LINK link;
} attributes;
/***********************************************************************
*
* HLPFILE_Contents
*/
HLPFILE_PAGE *HLPFILE_Contents(LPCSTR lpszPath)
{
HLPFILE *hlpfile = HLPFILE_ReadHlpFile(lpszPath);
if (!hlpfile) return(0);
return(hlpfile->first_page);
}
/***********************************************************************
*
* HLPFILE_PageByNumber
*/
HLPFILE_PAGE *HLPFILE_PageByNumber(LPCSTR lpszPath, UINT wNum)
{
HLPFILE_PAGE *page;
HLPFILE *hlpfile = HLPFILE_ReadHlpFile(lpszPath);
if (!hlpfile) return(0);
for (page = hlpfile->first_page; page && wNum; page = page->next) wNum--;
return page;
}
/***********************************************************************
*
* HLPFILE_HlpFilePageByHash
*/
HLPFILE_PAGE *HLPFILE_PageByHash(LPCSTR lpszPath, LONG lHash)
{
INT i;
UINT wNum;
HLPFILE_PAGE *page;
HLPFILE *hlpfile = HLPFILE_ReadHlpFile(lpszPath);
if (!hlpfile) return(0);
for (i = 0; i < hlpfile->wContextLen; i++)
if (hlpfile->Context[i].lHash == lHash) break;
if (i >= hlpfile->wContextLen)
{
HLPFILE_FreeHlpFile(hlpfile);
return(0);
}
wNum = hlpfile->Context[i].wPage;
for (page = hlpfile->first_page; page && wNum; page = page->next) wNum--;
return page;
}
/***********************************************************************
*
* HLPFILE_Hash
*/
LONG HLPFILE_Hash(LPCSTR lpszContext)
{
LONG lHash = 0;
CHAR c;
while((c = *lpszContext++))
{
CHAR x = 0;
if (c >= 'A' && c <= 'Z') x = c - 'A' + 17;
if (c >= 'a' && c <= 'z') x = c - 'a' + 17;
if (c >= '1' && c <= '9') x = c - '0';
if (c == '0') x = 10;
if (c == '.') x = 12;
if (c == '_') x = 13;
if (x) lHash = lHash * 43 + x;
}
return lHash;
}
/***********************************************************************
*
* HLPFILE_ReadHlpFile
*/
HLPFILE *HLPFILE_ReadHlpFile(LPCSTR lpszPath)
{
HGLOBAL hHlpFile;
HLPFILE *hlpfile;
for (hlpfile = first_hlpfile; hlpfile; hlpfile = hlpfile->next)
if (!lstrcmp(hlpfile->lpszPath, lpszPath))
{
hlpfile->wRefCount++;
return(hlpfile);
}
hHlpFile = GlobalAlloc(GMEM_FIXED, sizeof(HLPFILE) + lstrlen(lpszPath) + 1);
if (!hHlpFile) return(0);
hlpfile = GlobalLock(hHlpFile);
hlpfile->hSelf = hHlpFile;
hlpfile->wRefCount = 1;
hlpfile->hTitle = 0;
hlpfile->hContext = 0;
hlpfile->wContextLen = 0;
hlpfile->first_page = 0;
hlpfile->first_macro = 0;
hlpfile->prev = 0;
hlpfile->next = first_hlpfile;
first_hlpfile = hlpfile;
if (hlpfile->next) hlpfile->next->prev = hlpfile;
hlpfile->lpszPath = GlobalLock(hHlpFile);
hlpfile->lpszPath += sizeof(HLPFILE);
strcpy(hlpfile->lpszPath, lpszPath);
phrases.hBuffer = topic.hBuffer = hFileBuffer = 0;
if (!HLPFILE_DoReadHlpFile(hlpfile, lpszPath))
{
HLPFILE_FreeHlpFile(hlpfile);
hlpfile = 0;
}
if (phrases.hBuffer) GlobalFree(phrases.hBuffer);
if (topic.hBuffer) GlobalFree(topic.hBuffer);
if (topic.hMap) GlobalFree(topic.hMap);
if (hFileBuffer) GlobalFree(hFileBuffer);
return(hlpfile);
}
/***********************************************************************
*
* HLPFILE_DoReadHlpFile
*/
static BOOL HLPFILE_DoReadHlpFile(HLPFILE *hlpfile, LPCSTR lpszPath)
{
BOOL ret;
HFILE hFile;
OFSTRUCT ofs;
BYTE *buf;
hFile=OpenFile(lpszPath, &ofs, OF_READ | OF_SEARCH);
if (hFile == HFILE_ERROR) return FALSE;
ret = HLPFILE_ReadFileToBuffer(hFile);
_lclose(hFile);
if (!ret) return FALSE;
HLPFILE_SystemCommands(hlpfile);
if (!HLPFILE_Uncompress1_Phrases()) return FALSE;
if (!HLPFILE_Uncompress1_Topic()) return FALSE;
buf = topic.map[0] + 0xc;
while(buf + 0xc < topic.end)
{
BYTE *end = min(buf + GET_UINT(buf, 0), topic.end);
UINT next, index, offset;
switch (buf[0x14])
{
case 0x02:
if (!HLPFILE_AddPage(hlpfile, buf, end)) return(FALSE);
break;
case 0x20:
if (!HLPFILE_AddParagraph(hlpfile, buf, end)) return(FALSE);
break;
case 0x23:
if (!HLPFILE_AddParagraph(hlpfile, buf, end)) return(FALSE);
break;
default:
fprintf(stderr, "buf[0x14] = %x\n", buf[0x14]);
}
next = GET_UINT(buf, 0xc);
if (next == 0xffffffff) break;
index = next >> 14;
offset = next & 0x3fff;
if (index > topic.wMapLen) {Report("maplen"); break;}
buf = topic.map[index] + offset;
}
return(HLPFILE_GetContext(hlpfile));
}
/***********************************************************************
*
* HLPFILE_AddPage
*/
static BOOL HLPFILE_AddPage(HLPFILE *hlpfile, BYTE *buf, BYTE *end)
{
HGLOBAL hPage;
HLPFILE_PAGE *page, **pageptr;
BYTE *title;
UINT titlesize;
for (pageptr = &hlpfile->first_page; *pageptr; pageptr = &(*pageptr)->next)
/* Nothing */;
if (buf + 0x31 > end) {Report("page1"); return(FALSE);};
title = buf + GET_UINT(buf, 0x10);
if (title > end) {Report("page2"); return(FALSE);};
titlesize = HLPFILE_Uncompressed2_Size(title, end);
hPage = GlobalAlloc(GMEM_FIXED, sizeof(HLPFILE_PAGE) + titlesize);
if (!hPage) return FALSE;
page = *pageptr = GlobalLock(hPage);
pageptr = &page->next;
page->hSelf = hPage;
page->file = hlpfile;
page->next = 0;
page->first_paragraph = 0;
page->lpszTitle = GlobalLock(hPage);
page->lpszTitle += sizeof(HLPFILE_PAGE);
HLPFILE_Uncompress2(&title, end, page->lpszTitle);
page->wNumber = GET_UINT(buf, 0x21);
attributes.bDebug = 0;
attributes.wFont = 0;
attributes.wVSpace = 0;
attributes.wVBackSpace = 0;
attributes.wHSpace = 0;
attributes.wIndent = 0;
attributes.link.lpszPath = 0;
return TRUE;
}
/***********************************************************************
*
* HLPFILE_AddParagraph
*/
static BOOL HLPFILE_AddParagraph(HLPFILE *hlpfile, BYTE *buf, BYTE *end)
{
HGLOBAL hParagraph;
HLPFILE_PAGE *page;
HLPFILE_PARAGRAPH *paragraph, **paragraphptr;
UINT textsize;
BYTE *format, *text;
BOOL format_header = TRUE;
BOOL format_end = FALSE;
UINT mask, i;
if (!hlpfile->first_page) {Report("paragraph1"); return(FALSE);};
for (page = hlpfile->first_page; page->next; page = page->next) /* Nothing */;
for (paragraphptr = &page->first_paragraph; *paragraphptr;
paragraphptr = &(*paragraphptr)->next) /* Nothing */;
if (buf + 0x19 > end) {Report("paragraph2"); return(FALSE);};
if (buf[0x14] == 0x02) return TRUE;
text = buf + GET_UINT(buf, 0x10);
switch (buf[0x14])
{
case 0x20:
format = buf + 0x18;
while (*format) format++;
format += 4;
break;
case 0x23:
format = buf + 0x2b;
if (buf[0x17] & 1) format++;
break;
default:
Report("paragraph3");
return FALSE;
}
while (text < end)
{
if (format_header)
{
format_header = FALSE;
mask = GET_USHORT(format, 0);
mask &= 0x3ff;
format += 2;
for (i = 0; i < 10; i++, mask = mask >> 1)
{
if (mask & 1)
{
BOOL twoargs = FALSE;
CHAR prefix0 = ' ';
CHAR prefix1 = '*';
if (i == 9 && !twoargs)
{
switch (*format++)
{
default:
prefix0 = prefix1 = '?';
break;
case 0x82:
prefix0 = prefix1 = 'x';
break;
case 0x84:
prefix0 = prefix1 = 'X';
twoargs = TRUE;
}
}
if (*format & 1)
switch(*format)
{
default:
format += 2;
break;
}
else
switch(*format)
{
default:
format++;
break;
case 0x08:
format += 3;
break;
}
if (twoargs) format += (*format & 1) ? 2 : 1;
}
}
}
for (; !format_header && text < end && format < end && !*text; text++)
{
switch(*format)
{
case 0x80:
attributes.wFont = GET_USHORT(format, 1);
format += 3;
break;
case 0x81:
attributes.wVSpace++;
format += 1;
break;
case 0x82:
attributes.wVSpace += 2 - attributes.wVBackSpace;
attributes.wVBackSpace = 0;
attributes.wIndent = 0;
format += 1;
break;
case 0x83:
attributes.wIndent++;
format += 1;
break;
case 0x84:
format += 3;
break;
case 0x86:
case 0x87:
case 0x88:
format += 9;
break;
case 0x89:
attributes.wVBackSpace++;
format += 1;
break;
case 0xa9:
format += 2;
break;
case 0xe2:
case 0xe3:
attributes.link.lpszPath = hlpfile->lpszPath;
attributes.link.lHash = GET_UINT(format, 1);
attributes.link.bPopup = !(*format & 1);
format += 5;
break;
case 0xea:
attributes.link.lpszPath = format + 8;
attributes.link.lHash = GET_UINT(format, 4);
attributes.link.bPopup = !(*format & 1);
format += 3 + GET_USHORT(format, 1);
break;
case 0xff:
if (buf[0x14] != 0x23 || GET_USHORT(format, 1) == 0xffff)
{
if (format_end) Report("format_end");
format_end = TRUE;
break;
}
else
{
format_header = TRUE;
format += 10;
break;
}
default:
Report("format");
format++;
}
}
if (text > end || format > end) {Report("paragraph_end"); return(FALSE);};
if (text == end && !format_end) Report("text_end");
if (text == end) break;
textsize = HLPFILE_Uncompressed2_Size(text, end);
hParagraph = GlobalAlloc(GMEM_FIXED, sizeof(HLPFILE_PARAGRAPH) + textsize);
if (!hParagraph) return FALSE;
paragraph = *paragraphptr = GlobalLock(hParagraph);
paragraphptr = &paragraph->next;
paragraph->hSelf = hParagraph;
paragraph->next = 0;
paragraph->link = 0;
paragraph->lpszText = GlobalLock(hParagraph);
paragraph->lpszText += sizeof(HLPFILE_PARAGRAPH);
HLPFILE_Uncompress2(&text, end, paragraph->lpszText);
paragraph->bDebug = attributes.bDebug;
paragraph->wFont = attributes.wFont;
paragraph->wVSpace = attributes.wVSpace;
paragraph->wHSpace = attributes.wHSpace;
paragraph->wIndent = attributes.wIndent;
if (attributes.link.lpszPath)
{
LPSTR ptr;
HGLOBAL handle = GlobalAlloc(GMEM_FIXED, sizeof(HLPFILE_LINK) +
strlen(attributes.link.lpszPath) + 1);
if (!handle) return FALSE;
paragraph->link = GlobalLock(handle);
paragraph->link->hSelf = handle;
ptr = GlobalLock(handle);
ptr += sizeof(HLPFILE_LINK);
lstrcpy(ptr, (LPSTR) attributes.link.lpszPath);
paragraph->link->lpszPath = ptr;
paragraph->link->lHash = attributes.link.lHash;
paragraph->link->bPopup = attributes.link.bPopup;
}
attributes.bDebug = 0;
attributes.wVSpace = 0;
attributes.wHSpace = 0;
attributes.link.lpszPath = 0;
}
return TRUE;
}
/***********************************************************************
*
* HLPFILE_ReadFileToBuffer
*/
static BOOL HLPFILE_ReadFileToBuffer(HFILE hFile)
{
BYTE header[16], dummy[1];
UINT size;
if (_hread(hFile, header, 16) != 16) {Report("header"); return(FALSE);};
size = GET_UINT(header, 12);
hFileBuffer = GlobalAlloc(GMEM_FIXED, size + 1);
if (!hFileBuffer) return FALSE;
file_buffer = GlobalLock(hFileBuffer);
memcpy(file_buffer, header, 16);
if (_hread(hFile, file_buffer + 16, size - 16) != size - 16)
{Report("filesize1"); return(FALSE);};
if (_hread(hFile, dummy, 1) != 0) Report("filesize2");
file_buffer[size] = '0';
return TRUE;
}
/***********************************************************************
*
* HLPFILE_FindSubFile
*/
static BOOL HLPFILE_FindSubFile(LPCSTR name, BYTE **subbuf, BYTE **subend)
{
BYTE *root = file_buffer + GET_UINT(file_buffer, 4);
BYTE *end = file_buffer + GET_UINT(file_buffer, 12);
BYTE *ptr = root + 0x37;
while (ptr < end && ptr[0] == 0x7c)
{
BYTE *fname = ptr + 1;
ptr += strlen(ptr) + 1;
if (!lstrcmpi(fname, name))
{
*subbuf = file_buffer + GET_UINT(ptr, 0);
*subend = *subbuf + GET_UINT(*subbuf, 0);
if (file_buffer > *subbuf || *subbuf > *subend || *subend >= end)
{
Report("subfile");
return FALSE;
}
return TRUE;
}
else ptr += 4;
}
return FALSE;
}
/***********************************************************************
*
* HLPFILE_SystemCommands
*/
static VOID HLPFILE_SystemCommands(HLPFILE* hlpfile)
{
BYTE *buf, *ptr, *end;
HGLOBAL handle;
HLPFILE_MACRO *macro, **m;
LPSTR p;
hlpfile->lpszTitle = "";
if (!HLPFILE_FindSubFile("SYSTEM", &buf, &end)) return;
for (ptr = buf + 0x15; ptr + 4 <= end; ptr += GET_USHORT(ptr, 2) + 4)
{
switch (GET_USHORT(ptr, 0))
{
case 1:
if (hlpfile->hTitle) {Report("title"); break;}
hlpfile->hTitle = GlobalAlloc(GMEM_FIXED, strlen(ptr + 4) + 1);
if (!hlpfile->hTitle) return;
hlpfile->lpszTitle = GlobalLock(hlpfile->hTitle);
lstrcpy(hlpfile->lpszTitle, ptr + 4);
break;
case 2:
if (GET_USHORT(ptr, 2) != 1 || ptr[4] != 0) Report("system2");
break;
case 3:
if (GET_USHORT(ptr, 2) != 4 || GET_UINT(ptr, 4) != 0) Report("system3");
break;
case 4:
handle = GlobalAlloc(GMEM_FIXED, sizeof(HLPFILE_MACRO) + lstrlen(ptr + 4) + 1);
if (!handle) break;
macro = GlobalLock(handle);
macro->hSelf = handle;
p = GlobalLock(handle);
p += sizeof(HLPFILE_MACRO);
lstrcpy(p, (LPSTR) ptr + 4);
macro->lpszMacro = p;
macro->next = 0;
for (m = &hlpfile->first_macro; *m; m = &(*m)->next);
*m = macro;
break;
default:
Report("system");
}
}
}
/***********************************************************************
*
* HLPFILE_Uncompressed1_Size
*/
static INT HLPFILE_Uncompressed1_Size(BYTE *ptr, BYTE *end)
{
INT i, newsize = 0;
while (ptr < end)
{
INT mask=*ptr++;
for (i = 0; i < 8 && ptr < end; i++, mask = mask >> 1)
{
if (mask & 1)
{
INT code = GET_USHORT(ptr, 0);
INT len = 3 + (code >> 12);
newsize += len;
ptr += 2;
}
else newsize++, ptr++;
}
}
return(newsize);
}
/***********************************************************************
*
* HLPFILE_Uncompress1
*/
static BYTE *HLPFILE_Uncompress1(BYTE *ptr, BYTE *end, BYTE *newptr)
{
INT i;
while (ptr < end)
{
INT mask=*ptr++;
for (i = 0; i < 8 && ptr < end; i++, mask = mask >> 1)
{
if (mask & 1)
{
INT code = GET_USHORT(ptr, 0);
INT len = 3 + (code >> 12);
INT offset = code & 0xfff;
memcpy(newptr, newptr - offset - 1, len);
newptr += len;
ptr += 2;
}
else *newptr++ = *ptr++;
}
}
return(newptr);
}
/***********************************************************************
*
* HLPFILE_Uncompress1_Phrases
*/
static BOOL HLPFILE_Uncompress1_Phrases()
{
UINT i, num, newsize;
BYTE *buf, *end, *newbuf;
if (!HLPFILE_FindSubFile("Phrases", &buf, &end)) {Report("phrases0"); return FALSE;}
num = phrases.num = GET_USHORT(buf, 9);
if (buf + 2 * num + 0x13 >= end) {Report("uncompress1a"); return(FALSE);};
newsize = 2 * num + 2;
newsize += HLPFILE_Uncompressed1_Size(buf + 0x13 + 2 * num, end);
phrases.hBuffer = GlobalAlloc(GMEM_FIXED, newsize);
if (!phrases.hBuffer) return FALSE;
newbuf = phrases.buf = GlobalLock(phrases.hBuffer);
memcpy(newbuf, buf + 0x11, 2 * num + 2);
HLPFILE_Uncompress1(buf + 0x13 + 2 * num, end, newbuf + 2 * num + 2);
for (i = 0; i < num; i++)
{
INT i0 = GET_USHORT(newbuf, 2 * i);
INT i1 = GET_USHORT(newbuf, 2 * i + 2);
if (i1 < i0 || i1 > newsize) {Report("uncompress1b"); return(FALSE);};
}
return TRUE;
}
/***********************************************************************
*
* HLPFILE_Uncompress1_Topic
*/
static BOOL HLPFILE_Uncompress1_Topic()
{
BYTE *buf, *ptr, *end, *newptr;
INT i, newsize = 0;
if (!HLPFILE_FindSubFile("TOPIC", &buf, &end)) {Report("topic0"); return FALSE;}
buf += 9;
topic.wMapLen = (end - buf - 1) / 0x1000 + 1;
for (i = 0; i < topic.wMapLen; i++)
{
ptr = buf + i * 0x1000;
/* I don't know why, it's necessary for printman.hlp */
if (ptr + 0x44 > end) ptr = end - 0x44;
newsize += HLPFILE_Uncompressed1_Size(ptr + 0xc, min(end, ptr + 0x1000));
}
topic.hMap = GlobalAlloc(GMEM_FIXED, topic.wMapLen * sizeof(topic.map[0]));
topic.hBuffer = GlobalAlloc(GMEM_FIXED, newsize);
if (!topic.hMap || !topic.hBuffer) return FALSE;
topic.map = GlobalLock(topic.hMap);
newptr = GlobalLock(topic.hBuffer);
topic.end = newptr + newsize;
for (i = 0; i < topic.wMapLen; i++)
{
ptr = buf + i * 0x1000;
if (ptr + 0x44 > end) ptr = end - 0x44;
topic.map[i] = newptr - 0xc;
newptr = HLPFILE_Uncompress1(ptr + 0xc, min(end, ptr + 0x1000), newptr);
}
return TRUE;
}
/***********************************************************************
*
* HLPFILE_Uncompressed2_Size
*/
static UINT HLPFILE_Uncompressed2_Size(BYTE *ptr, BYTE *end)
{
UINT wSize = 0;
while (ptr < end && *ptr)
{
if (*ptr >= 0x20)
wSize++, ptr++;
else
{
BYTE *phptr, *phend;
UINT code = 0x100 * ptr[0] + ptr[1];
UINT index = (code - 0x100) / 2;
BOOL space = code & 1;
if (index < phrases.num)
{
phptr = phrases.buf + GET_USHORT(phrases.buf, 2 * index);
phend = phrases.buf + GET_USHORT(phrases.buf, 2 * index + 2);
if (phend < phptr) Report("uncompress2a");
wSize += phend - phptr;
if (space) wSize++;
}
else Report("uncompress2b");
ptr += 2;
}
}
return(wSize + 1);
}
/***********************************************************************
*
* HLPFILE_Uncompress2
*/
static VOID HLPFILE_Uncompress2(BYTE **pptr, BYTE *end, BYTE *newptr)
{
BYTE *ptr = *pptr;
while (ptr < end && *ptr)
{
if (*ptr >= 0x20)
*newptr++ = *ptr++;
else
{
BYTE *phptr, *phend;
UINT code = 0x100 * ptr[0] + ptr[1];
UINT index = (code - 0x100) / 2;
BOOL space = code & 1;
phptr = phrases.buf + GET_USHORT(phrases.buf, 2 * index);
phend = phrases.buf + GET_USHORT(phrases.buf, 2 * index + 2);
memcpy(newptr, phptr, phend - phptr);
newptr += phend - phptr;
if (space) *newptr++ = ' ';
ptr += 2;
}
}
*newptr = '\0';
*pptr = ptr;
}
/***********************************************************************
*
* HLPFILE_GetContext
*/
static BOOL HLPFILE_GetContext(HLPFILE *hlpfile)
{
UINT i, j, clen, tlen;
BYTE *cbuf, *cptr, *cend, *tbuf, *tptr, *tend;
if (!HLPFILE_FindSubFile("CONTEXT", &cbuf, &cend)) {Report("context0"); return FALSE;}
if (cbuf + 0x37 > cend) {Report("context1"); return(FALSE);};
clen = GET_UINT(cbuf, 0x2b);
if (cbuf + 0x37 + 8 * hlpfile->wContextLen > cend) {Report("context2"); return(FALSE);};
if (!HLPFILE_FindSubFile("TTLBTREE", &tbuf, &tend)) {Report("ttlb0"); return FALSE;}
if (tbuf + 0x37 > tend) {Report("ttlb1"); return(FALSE);};
tlen = GET_UINT(tbuf, 0x2b);
hlpfile->hContext = GlobalAlloc(GMEM_FIXED, clen * sizeof(HLPFILE_CONTEXT));
if (!hlpfile->hContext) return FALSE;
hlpfile->Context = GlobalLock(hlpfile->hContext);
hlpfile->wContextLen = clen;
cptr = cbuf + 0x37;
for (i = 0; i < clen; i++, cptr += 8)
{
tptr = tbuf + 0x37;
for (j = 0; j < tlen; j++, tptr += 5 + strlen(tptr + 4))
{
if (tptr + 4 >= tend) {Report("ttlb2"); return(FALSE);};
if (GET_UINT(tptr, 0) == GET_UINT(cptr, 4)) break;
}
if (j >= tlen)
{
Report("ttlb3");
j = 0;
}
hlpfile->Context[i].lHash = GET_UINT(cptr, 0);
hlpfile->Context[i].wPage = j;
}
return TRUE;
}
/***********************************************************************
*
* HLPFILE_DeleteParagraph
*/
static VOID HLPFILE_DeleteParagraph(HLPFILE_PARAGRAPH* paragraph)
{
if (!paragraph) return;
if (paragraph->link) GlobalFree(paragraph->link->hSelf);
HLPFILE_DeleteParagraph(paragraph->next);
GlobalFree(paragraph->hSelf);
}
/***********************************************************************
*
* DeletePage
*/
static VOID HLPFILE_DeletePage(HLPFILE_PAGE* page)
{
if (!page) return;
HLPFILE_DeletePage(page->next);
HLPFILE_DeleteParagraph(page->first_paragraph);
GlobalFree(page->hSelf);
}
/***********************************************************************
*
* DeleteMacro
*/
static VOID HLPFILE_DeleteMacro(HLPFILE_MACRO* macro)
{
if (!macro) return;
HLPFILE_DeleteMacro(macro->next);
GlobalFree(macro->hSelf);
}
/***********************************************************************
*
* HLPFILE_FreeHlpFile
*/
VOID HLPFILE_FreeHlpFile(HLPFILE* hlpfile)
{
if (!hlpfile) return;
if (--hlpfile->wRefCount) return;
if (hlpfile->next) hlpfile->next->prev = hlpfile->prev;
if (hlpfile->prev) hlpfile->prev->next = hlpfile->next;
else first_hlpfile = 0;
HLPFILE_DeletePage(hlpfile->first_page);
HLPFILE_DeleteMacro(hlpfile->first_macro);
if (hlpfile->hContext) GlobalFree(hlpfile->hContext);
if (hlpfile->hTitle) GlobalFree(hlpfile->hTitle);
GlobalFree(hlpfile->hSelf);
}
/***********************************************************************
*
* FreeHlpFilePage
*/
VOID HLPFILE_FreeHlpFilePage(HLPFILE_PAGE* page)
{
if (!page) return;
HLPFILE_FreeHlpFile(page->file);
}
/* Local Variables: */
/* c-file-style: "GNU" */
/* End: */
Reference in New Issue View Git Blame Copy Permalink