[PATCH 0/5] MR7334: oleaut32: Fix logic for deciding whether type description follows the name.
From: Dmitry Timoshkov dmitry@baikal.ru
It looks like the lowest bit actually indicates whether type description follows the name, and since the name offsets are always aligned that makes sense.
Signed-off-by: Dmitry Timoshkov dmitry@baikal.ru --- dlls/oleaut32/typelib.c | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-)
diff --git a/dlls/oleaut32/typelib.c b/dlls/oleaut32/typelib.c index f421a76fe95..1b3fa67a006 100644 --- a/dlls/oleaut32/typelib.c +++ b/dlls/oleaut32/typelib.c @@ -4167,7 +4167,7 @@ static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, pArg = (WORD*)(pBlk + pFunc->arg_off);
for(param = 0; param < pFuncDesc->funcdesc.cParams; param++) { - char *paramName = pNameTable + *pArg; + char *paramName = pNameTable + (*pArg & ~1); BOOL HaveOffs; /* If arg type follows then paramName points to the 2nd letter of the name, else the next WORD is an offset to @@ -4178,26 +4178,21 @@ static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, meaning that the next WORD is the type, the latter meaning that the next WORD is an offset to the type. */
- HaveOffs = FALSE; - if(*pArg == 0xffff) + if(*pArg == 0xffff || *pArg == 0xfffe) paramName = NULL; - else if(*pArg == 0xfffe) { - paramName = NULL; - HaveOffs = TRUE; - } - else if(paramName[-1] && !isalnum(paramName[-1])) - HaveOffs = TRUE;
+ HaveOffs = !(*pArg & 1); pArg++;
+ TRACE_(typelib)("param %d: paramName %s, *pArg %#x\n", + param, debugstr_a(paramName), *pArg); + if(HaveOffs) { /* the next word is an offset to type */ pType = (WORD*)(pBlk + *pArg); SLTG_DoElem(pType, pBlk, &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup); pArg++; } else { - if(paramName) - paramName--; pArg = SLTG_DoElem(pArg, pBlk, &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup); }
From: Dmitry Timoshkov dmitry@baikal.ru
Signed-off-by: Dmitry Timoshkov dmitry@baikal.ru --- dlls/oleaut32/typelib.c | 39 ++++++++++++++++++--------------------- dlls/oleaut32/typelib.h | 2 +- 2 files changed, 19 insertions(+), 22 deletions(-)
diff --git a/dlls/oleaut32/typelib.c b/dlls/oleaut32/typelib.c index 1b3fa67a006..bdf8232408f 100644 --- a/dlls/oleaut32/typelib.c +++ b/dlls/oleaut32/typelib.c @@ -4353,7 +4353,6 @@ static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI, /* Because SLTG_OtherTypeInfo is such a painful struct, we make a more manageable copy of it into this */ typedef struct { - WORD small_no; char *index_name; char *other_name; WORD res1a; @@ -4364,6 +4363,7 @@ typedef struct { DWORD helpcontext; WORD res26; GUID uuid; + WORD typekind; } SLTG_InternalOtherTypeInfo;
/**************************************************************************** @@ -4382,7 +4382,6 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength) LPVOID pBlk, pFirstBlk; SLTG_LibBlk *pLibBlk; SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks; - char *pAfterOTIBlks = NULL; char *pNameTable, *ptr; int i; DWORD len, order; @@ -4449,53 +4448,51 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength) len += 0x40;
/* And now TypeInfoCount of SLTG_OtherTypeInfo */ + pTypeLibImpl->TypeInfoCount = *(WORD *)((char *)pLibBlk + len); + len += sizeof(WORD);
pOtherTypeInfoBlks = calloc(pTypeLibImpl->TypeInfoCount, sizeof(*pOtherTypeInfoBlks));
- ptr = (char*)pLibBlk + len;
for(i = 0; i < pTypeLibImpl->TypeInfoCount; i++) { WORD w, extra; len = 0;
- pOtherTypeInfoBlks[i].small_no = *(WORD*)ptr; - - w = *(WORD*)(ptr + 2); + w = *(WORD*)ptr; if(w != 0xffff) { len += w; pOtherTypeInfoBlks[i].index_name = malloc(w + 1); - memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 4, w); + memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 2, w); pOtherTypeInfoBlks[i].index_name[w] = '\0'; } - w = *(WORD*)(ptr + 4 + len); + w = *(WORD*)(ptr + 2 + len); if(w != 0xffff) { - TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 6 + len, w)); + TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 4 + len, w)); len += w; pOtherTypeInfoBlks[i].other_name = malloc(w + 1); - memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 6 + len, w); + memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 4 + len, w); pOtherTypeInfoBlks[i].other_name[w] = '\0'; } - pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 6); + pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 4); pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + len + 8); - extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 10 + len); + extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 8 + len); if(extra) { pOtherTypeInfoBlks[i].extra = malloc(extra); - memcpy(pOtherTypeInfoBlks[i].extra, ptr + 12, extra); + memcpy(pOtherTypeInfoBlks[i].extra, ptr + 10, extra); len += extra; } - pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 12 + len); - pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 14 + len); - pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 18 + len); - memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 20 + len, sizeof(GUID)); + pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 10 + len); + pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 12 + len); + pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 16 + len); + memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 18 + len, sizeof(GUID)); + pOtherTypeInfoBlks[i].typekind = *(WORD*)(ptr + 18 + len + sizeof(GUID)); len += sizeof(SLTG_OtherTypeInfo); ptr += len; }
- pAfterOTIBlks = ptr; - - /* Skip this WORD and get the next DWORD */ - len = *(DWORD*)(pAfterOTIBlks + 2); + /* Get the next DWORD */ + len = *(DWORD*)ptr;
/* Now add this to pLibBLk look at what we're pointing at and possibly add 0x20, then add 0x216, sprinkle a bit a magic diff --git a/dlls/oleaut32/typelib.h b/dlls/oleaut32/typelib.h index 515d4b557e6..2762cae70ad 100644 --- a/dlls/oleaut32/typelib.h +++ b/dlls/oleaut32/typelib.h @@ -382,7 +382,6 @@ typedef struct { /* we then get 0x40 bytes worth of 0xffff or small numbers followed by nrOfFileBlks - 2 of these */ typedef struct { - WORD small_no; SLTG_Name index_name; /* This refers to a name in the directory */ SLTG_Name other_name; /* Another one of these weird names */ WORD res1a; /* 0xffff */ @@ -394,6 +393,7 @@ typedef struct { DWORD helpcontext; WORD res26; /* 0xffff */ GUID uuid; + WORD typekind; } SLTG_OtherTypeInfo;
/* Next we get WORD 0x0003 followed by a DWORD which if we add to
From: Dmitry Timoshkov dmitry@baikal.ru
Based on a patch by Sebastian Lackner sebastian@fds-team.de.
Signed-off-by: Dmitry Timoshkov dmitry@baikal.ru --- dlls/oleaut32/typelib.c | 91 ++++++++++++++++++++++++++++++++++++++++- dlls/oleaut32/typelib.h | 2 +- 2 files changed, 90 insertions(+), 3 deletions(-)
diff --git a/dlls/oleaut32/typelib.c b/dlls/oleaut32/typelib.c index bdf8232408f..323d2ed848c 100644 --- a/dlls/oleaut32/typelib.c +++ b/dlls/oleaut32/typelib.c @@ -3667,6 +3667,87 @@ static BOOL TLB_GUIDFromString(const char *str, GUID *guid) return TRUE; }
+struct bitstream +{ + const BYTE *buffer; + DWORD length; + WORD current; +}; + +static const char *lookup_code(const BYTE *table, DWORD table_size, struct bitstream *bits) +{ + const BYTE *p = table; + + while (p < table + table_size && *p == 0x80) + { + if (p + 2 >= table + table_size) return NULL; + + if (!(bits->current & 0xff)) + { + if (!bits->length) return NULL; + bits->current = (*bits->buffer << 8) | 1; + bits->buffer++; + bits->length--; + } + + if (bits->current & 0x8000) + { + p += 3; + } + else + { + p = table + (*(p + 2) | (*(p + 1) << 8)); + } + + bits->current <<= 1; + } + + if (p + 1 < table + table_size && *(p + 1)) + { + /* FIXME: Whats the meaning of *p? */ + const BYTE *q = p + 1; + while (q < table + table_size && *q) q++; + return (q < table + table_size) ? (const char *)(p + 1) : NULL; + } + + return NULL; +} + +static const TLBString *decode_string(const BYTE *table, const char *stream, DWORD stream_length, ITypeLibImpl *lib) +{ + DWORD buf_size, table_size; + const char *p; + struct bitstream bits; + BSTR buf; + TLBString *tlbstr; + + if (!stream_length) return NULL; + + bits.buffer = (const BYTE *)stream; + bits.length = stream_length; + bits.current = 0; + + buf_size = *(const WORD *)table; + table += sizeof(WORD); + table_size = *(const DWORD *)table; + table += sizeof(DWORD); + + buf = SysAllocStringLen(NULL, buf_size); + buf[0] = 0; + + while ((p = lookup_code(table, table_size, &bits))) + { + static const WCHAR spaceW[] = { ' ',0 }; + if (buf[0]) lstrcatW(buf, spaceW); + MultiByteToWideChar(CP_ACP, 0, p, -1, buf + lstrlenW(buf), buf_size - lstrlenW(buf)); + } + + tlbstr = TLB_append_str(&lib->string_list, buf); + SysFreeString(buf); + + return tlbstr; +} + static WORD SLTG_ReadString(const char *ptr, const TLBString **pStr, ITypeLibImpl *lib) { WORD bytelen; @@ -4357,7 +4438,7 @@ typedef struct { char *other_name; WORD res1a; WORD name_offs; - WORD more_bytes; + WORD hlpstr_len; char *extra; WORD res20; DWORD helpcontext; @@ -4383,6 +4464,7 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength) SLTG_LibBlk *pLibBlk; SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks; char *pNameTable, *ptr; + const BYTE *hlp_strings; int i; DWORD len, order; ITypeInfoImpl **ppTypeInfoImpl; @@ -4476,7 +4558,7 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength) } pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 4); pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + len + 8); - extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 8 + len); + extra = pOtherTypeInfoBlks[i].hlpstr_len = *(WORD*)(ptr + 8 + len); if(extra) { pOtherTypeInfoBlks[i].extra = malloc(extra); memcpy(pOtherTypeInfoBlks[i].extra, ptr + 10, extra); @@ -4494,6 +4576,10 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength) /* Get the next DWORD */ len = *(DWORD*)ptr;
+ hlp_strings = (const BYTE *)ptr + sizeof(DWORD); + TRACE("max help string length %#x, help strings length %#lx\n", + *(WORD *)hlp_strings, *(DWORD *)(hlp_strings + 2)); + /* Now add this to pLibBLk look at what we're pointing at and possibly add 0x20, then add 0x216, sprinkle a bit a magic dust and we should be pointing at the beginning of the name @@ -4558,6 +4644,7 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength) (*ppTypeInfoImpl)->index = i; (*ppTypeInfoImpl)->Name = SLTG_ReadName(pNameTable, pOtherTypeInfoBlks[i].name_offs, pTypeLibImpl); (*ppTypeInfoImpl)->dwHelpContext = pOtherTypeInfoBlks[i].helpcontext; + (*ppTypeInfoImpl)->DocString = decode_string(hlp_strings, pOtherTypeInfoBlks[i].extra, pOtherTypeInfoBlks[i].hlpstr_len, pTypeLibImpl); (*ppTypeInfoImpl)->guid = TLB_append_guid(&pTypeLibImpl->guid_list, &pOtherTypeInfoBlks[i].uuid, 2); (*ppTypeInfoImpl)->typeattr.typekind = pTIHeader->typekind; (*ppTypeInfoImpl)->typeattr.wMajorVerNum = pTIHeader->major_version; diff --git a/dlls/oleaut32/typelib.h b/dlls/oleaut32/typelib.h index 2762cae70ad..bfe908c035f 100644 --- a/dlls/oleaut32/typelib.h +++ b/dlls/oleaut32/typelib.h @@ -386,7 +386,7 @@ typedef struct { SLTG_Name other_name; /* Another one of these weird names */ WORD res1a; /* 0xffff */ WORD name_offs; /* offset to name in name table */ - WORD more_bytes; /* if this is non-zero we get this many + WORD hlpstr_len; /* if this is non-zero we get this many bytes before the next element, which seem to reference the docstring of the type ? */ WORD res20; /* 0xffff */
From: Dmitry Timoshkov dmitry@baikal.ru
Signed-off-by: Dmitry Timoshkov dmitry@baikal.ru --- dlls/oleaut32/typelib.c | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-)
diff --git a/dlls/oleaut32/typelib.c b/dlls/oleaut32/typelib.c index 323d2ed848c..ad2f591ad3f 100644 --- a/dlls/oleaut32/typelib.c +++ b/dlls/oleaut32/typelib.c @@ -4190,7 +4190,8 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign }
static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, - unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup) + unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup, + const BYTE *hlp_strings) { SLTG_Function *pFunc; unsigned short i; @@ -4231,6 +4232,9 @@ static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, else pFuncDesc->funcdesc.oVft = (unsigned short)(pFunc->vtblpos & ~1) * sizeof(void *) / pTI->pTypeLib->ptr_size;
+ if (pFunc->helpstring != 0xffff) + pFuncDesc->HelpString = decode_string(hlp_strings, pBlk + pFunc->helpstring, pNameTable - pBlk, pTI->pTypeLib); + if(pFunc->magic & SLTG_FUNCTION_FLAGS_PRESENT) pFuncDesc->funcdesc.wFuncFlags = pFunc->funcflags;
@@ -4317,7 +4321,7 @@ static void SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI, char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, - const SLTG_TypeInfoTail *pTITail) + const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings) { char *pFirstItem; sltg_ref_lookup_t *ref_lookup = NULL; @@ -4334,7 +4338,7 @@ static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI, }
if (pTITail->funcs_off != 0xffff) - SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup); + SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings);
free(ref_lookup);
@@ -4379,7 +4383,7 @@ static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI,
static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI, char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, - const SLTG_TypeInfoTail *pTITail) + const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings) { sltg_ref_lookup_t *ref_lookup = NULL; if (pTIHeader->href_table != 0xffffffff) @@ -4390,7 +4394,7 @@ static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI, SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
if (pTITail->funcs_off != 0xffff) - SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup); + SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings);
if (pTITail->impls_off != 0xffff) SLTG_DoImpls(pBlk + pTITail->impls_off, pTI, FALSE, ref_lookup); @@ -4414,7 +4418,7 @@ static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI,
static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI, char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, - const SLTG_TypeInfoTail *pTITail) + const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings) { sltg_ref_lookup_t *ref_lookup = NULL; if (pTIHeader->href_table != 0xffffffff) @@ -4425,7 +4429,7 @@ static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI, SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
if (pTITail->funcs_off != 0xffff) - SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup); + SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings); free(ref_lookup); if (TRACE_ON(typelib)) dump_TypeInfo(pTI); @@ -4687,7 +4691,7 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
case TKIND_INTERFACE: SLTG_ProcessInterface((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable, - pTIHeader, pTITail); + pTIHeader, pTITail, hlp_strings); break;
case TKIND_COCLASS: @@ -4702,12 +4706,12 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
case TKIND_DISPATCH: SLTG_ProcessDispatch((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable, - pTIHeader, pTITail); + pTIHeader, pTITail, hlp_strings); break;
case TKIND_MODULE: SLTG_ProcessModule((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable, - pTIHeader, pTITail); + pTIHeader, pTITail, hlp_strings); break;
default:
From: Dmitry Timoshkov dmitry@baikal.ru
Signed-off-by: Dmitry Timoshkov dmitry@baikal.ru --- dlls/oleaut32/typelib.c | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-)
diff --git a/dlls/oleaut32/typelib.c b/dlls/oleaut32/typelib.c index ad2f591ad3f..de319f3ef4d 100644 --- a/dlls/oleaut32/typelib.c +++ b/dlls/oleaut32/typelib.c @@ -4079,7 +4079,7 @@ static char *SLTG_DoImpls(char *pBlk, ITypeInfoImpl *pTI, }
static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsigned short cVars, - const char *pNameTable, const sltg_ref_lookup_t *ref_lookup) + const char *pNameTable, const sltg_ref_lookup_t *ref_lookup, const BYTE *hlp_strings) { TLBVarDesc *pVarDesc; const TLBString *prevName = NULL; @@ -4109,6 +4109,12 @@ static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsign TRACE_(typelib)("byte_offs = 0x%x\n", pItem->byte_offs); TRACE_(typelib)("memid = %#lx\n", pItem->memid);
+ if (pItem->helpstring != 0xffff) + { + pVarDesc->HelpString = decode_string(hlp_strings, pBlk + pItem->helpstring, pNameTable - pBlk, pTI->pTypeLib); + TRACE_(typelib)("helpstring = %s\n", debugstr_w(pVarDesc->HelpString->str)); + } + if(pItem->flags & 0x02) pType = &pItem->type; else @@ -4348,9 +4354,9 @@ static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
static void SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI, const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, - const SLTG_TypeInfoTail *pTITail) + const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings) { - SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL); + SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL, hlp_strings); }
static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI, @@ -4391,7 +4397,7 @@ static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI, pNameTable);
if (pTITail->vars_off != 0xffff) - SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup); + SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup, hlp_strings);
if (pTITail->funcs_off != 0xffff) SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings); @@ -4411,9 +4417,9 @@ static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI,
static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI, const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader, - const SLTG_TypeInfoTail *pTITail) + const SLTG_TypeInfoTail *pTITail, const BYTE *hlp_strings) { - SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL); + SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL, hlp_strings); }
static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI, @@ -4426,7 +4432,7 @@ static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI, pNameTable);
if (pTITail->vars_off != 0xffff) - SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup); + SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup, hlp_strings);
if (pTITail->funcs_off != 0xffff) SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup, hlp_strings); @@ -4681,12 +4687,12 @@ static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength) switch(pTIHeader->typekind) { case TKIND_ENUM: SLTG_ProcessEnum((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable, - pTIHeader, pTITail); + pTIHeader, pTITail, hlp_strings); break;
case TKIND_RECORD: SLTG_ProcessRecord((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable, - pTIHeader, pTITail); + pTIHeader, pTITail, hlp_strings); break;
case TKIND_INTERFACE:
Huw Davies (@huw) commented about dlls/oleaut32/typelib.c:
meaning that the next WORD is the type, the latter meaning that the next WORD is an offset to the type. */
HaveOffs = FALSE;if(*pArg == 0xffff)
if(*pArg == 0xffff || *pArg == 0xfffe) paramName = NULL;
else if(*pArg == 0xfffe) {paramName = NULL;HaveOffs = TRUE;}else if(paramName[-1] && !isalnum(paramName[-1]))HaveOffs = TRUE;
HaveOffs = !(*pArg & 1);
Let's remove the now outdated comment.
Also, how about condensing the tests into the initialisers? Something like:
```suggestion:-14+0 char *paramName = ((*pArg & ~1) == 0xfffe) ? NULL : pNameTable + (*pArg & ~1); BOOL HaveOffs = !(*pArg & 1); ```
Huw Davies (@huw) commented about dlls/oleaut32/typelib.c:
- bits.length = stream_length;
- bits.current = 0;
- buf_size = *(const WORD *)table;
- table += sizeof(WORD);
- table_size = *(const DWORD *)table;
- table += sizeof(DWORD);
- buf = SysAllocStringLen(NULL, buf_size);
- buf[0] = 0;
- while ((p = lookup_code(table, table_size, &bits)))
- {
static const WCHAR spaceW[] = { ' ',0 };if (buf[0]) lstrcatW(buf, spaceW);MultiByteToWideChar(CP_ACP, 0, p, -1, buf + lstrlenW(buf), buf_size - lstrlenW(buf));
Could we tidy this up a bit please? If we first get the length of `buf` (and let's use `wcslen()`), there shouldn't be a need for further `lstr` or `wcs`-type functions.
-
Dmitry Timoshkov -
Dmitry Timoshkov (＠dmitry)
-
Huw Davies (＠huw)