mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-04-07 13:55:33 +08:00
779 lines
23 KiB
C++
779 lines
23 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2019
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
#include "Records.h"
|
|
#include <boost/make_shared.hpp>
|
|
#include <map>
|
|
#include <locale>
|
|
#include "../../../UnicodeConverter/UnicodeConverter.h"
|
|
|
|
namespace VBA
|
|
{
|
|
const std::string int2str(const int val, const int radix)
|
|
{
|
|
static char num_buf[10] = {};
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
_itoa_s(val, num_buf, 9, radix);
|
|
#else
|
|
sprintf(num_buf, "%d", val);
|
|
#endif
|
|
return num_buf;
|
|
}
|
|
const std::wstring int2wstr(const int val, const int radix)
|
|
{
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
static wchar_t num_buf[20] = {};
|
|
_itow_s(val, num_buf, 19, radix);
|
|
return std::wstring(num_buf);
|
|
#else
|
|
static char num_buf[20] = {};
|
|
sprintf(num_buf, "%d", val);
|
|
std::string a_str(num_buf);
|
|
return std::wstring(a_str.begin(), a_str.end());
|
|
#endif
|
|
}
|
|
const std::wstring int2hex_wstr(const int val, const size_t size_of)
|
|
{
|
|
if (size_of > 4) return L"";
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
static wchar_t num_buf[10] = {};
|
|
std::wstring wstr = int2wstr(size_of << 1, 10);
|
|
swprintf_s(num_buf, 9, (L"%0" + wstr + L"X").c_str(), val);
|
|
return std::wstring(num_buf);
|
|
#else
|
|
char num_buf[10] = {};
|
|
std::string str = int2str(size_of << 1, 10);
|
|
snprintf(num_buf, 9, ("%0" + str + "X").c_str(), val);
|
|
std::string res(num_buf);
|
|
return std::wstring(res.begin(), res.end());
|
|
#endif
|
|
}
|
|
const std::wstring guid2bstr(const _GUID_ guid)
|
|
{
|
|
std::wstring guid_ret = L"{";
|
|
|
|
guid_ret += int2hex_wstr(guid.Data1, 4) + L"-" +
|
|
int2hex_wstr(guid.Data2, 2) + L"-" +
|
|
int2hex_wstr(guid.Data3, 2) + L"-" +
|
|
int2hex_wstr(guid.Data4[0], 1) + int2hex_wstr(guid.Data4[1], 1) + L"-" +
|
|
int2hex_wstr(guid.Data4[2], 1) + int2hex_wstr(guid.Data4[3], 1) +
|
|
int2hex_wstr(guid.Data4[4], 1) + int2hex_wstr(guid.Data4[5], 1) +
|
|
int2hex_wstr(guid.Data4[6], 1) + int2hex_wstr(guid.Data4[7], 1);
|
|
return guid_ret + L"}";
|
|
}
|
|
const std::wstring convert_string_icu(const char* buffer, const unsigned int& size, _UINT32 nCodePage)
|
|
{
|
|
if (!buffer || size < 1) return L"";
|
|
|
|
std::string sCodePage;
|
|
std::map<int, std::string>::const_iterator pFind = NSUnicodeConverter::mapEncodingsICU.find(nCodePage);
|
|
if (pFind != NSUnicodeConverter::mapEncodingsICU.end())
|
|
{
|
|
sCodePage = pFind->second;
|
|
}
|
|
if (!sCodePage.empty())
|
|
{
|
|
NSUnicodeConverter::CUnicodeConverter oConverter;
|
|
return oConverter.toUnicode(buffer, size, sCodePage.c_str(), true);
|
|
}
|
|
else if (nCodePage != 0)
|
|
{
|
|
NSUnicodeConverter::CUnicodeConverter oConverter;
|
|
return oConverter.toUnicode(buffer, size, nCodePage, true);
|
|
}
|
|
else
|
|
{//текущая локаль
|
|
|
|
std::locale loc("");
|
|
std::ctype<wchar_t> const &facet = std::use_facet<std::ctype<wchar_t> >(loc);
|
|
|
|
std::wstring result;
|
|
result.resize(size);
|
|
|
|
facet.widen(buffer, buffer + size, &result[0]);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------
|
|
AnsiString::AnsiString(CVbaFileStreamPtr stream) { load(stream); }
|
|
BaseRecordPtr AnsiString::clone()
|
|
{
|
|
return BaseRecordPtr(new AnsiString(*this));
|
|
}
|
|
void AnsiString::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf;
|
|
|
|
if (sizeOf > 0)
|
|
{
|
|
char *buf = new char[sizeOf];
|
|
if (buf)
|
|
{
|
|
stream->read(buf, sizeOf);
|
|
value = convert_string_icu(buf, sizeOf, stream->CodePage);
|
|
}
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------------------
|
|
Utf16String::Utf16String(CVbaFileStreamPtr stream) { load(stream); }
|
|
BaseRecordPtr Utf16String::clone()
|
|
{
|
|
return BaseRecordPtr(new Utf16String(*this));
|
|
}
|
|
void Utf16String::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf;
|
|
|
|
if (sizeOf > 0)
|
|
{
|
|
UTF16 *buf = new UTF16[sizeOf / 2];
|
|
if (buf)
|
|
{
|
|
stream->read(buf, sizeOf);
|
|
if (sizeof(wchar_t) == 2)
|
|
{
|
|
value = std::wstring((wchar_t*)buf, sizeOf / 2);
|
|
}
|
|
else
|
|
{
|
|
value = convertUtf16ToWString(buf, sizeOf / 2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//------------------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULENAME::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULENAME(*this));
|
|
}
|
|
void MODULENAME::load(CVbaFileStreamPtr stream)
|
|
{
|
|
ModuleName.load(stream);
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULENAMEUNICODE::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULENAMEUNICODE(*this));
|
|
}
|
|
void MODULENAMEUNICODE::load(CVbaFileStreamPtr stream)
|
|
{
|
|
ModuleNameUnicode.load(stream);
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULESTREAMNAME::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULESTREAMNAME(*this));
|
|
}
|
|
void MODULESTREAMNAME::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT16 Reserved;
|
|
|
|
StreamName.load(stream);
|
|
*stream >> Reserved;
|
|
StreamNameUnicode.load(stream);
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULEDOCSTRING::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULEDOCSTRING(*this));
|
|
}
|
|
void MODULEDOCSTRING::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT16 Reserved;
|
|
|
|
DocString.load(stream);
|
|
*stream >> Reserved;
|
|
DocStringUnicode.load(stream);
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULEOFFSET::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULEOFFSET(*this));
|
|
}
|
|
void MODULEOFFSET::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 SizeOf;
|
|
*stream >> SizeOf;
|
|
*stream >> TextOffset;
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULEHELPCONTEXT::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULEHELPCONTEXT(*this));
|
|
}
|
|
void MODULEHELPCONTEXT::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 SizeOf;
|
|
*stream >> SizeOf;
|
|
*stream >> HelpContext;
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULECOOKIE::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULECOOKIE(*this));
|
|
}
|
|
void MODULECOOKIE::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 SizeOf;
|
|
_UINT16 Cookie;
|
|
*stream >> SizeOf >> Cookie;
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULETYPE::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULETYPE(*this));
|
|
}
|
|
void MODULETYPE::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 Reserved;
|
|
*stream >> Reserved;
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULEREADONLY::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULEREADONLY(*this));
|
|
}
|
|
void MODULEREADONLY::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 Reserved;
|
|
*stream >> Reserved;
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULEPRIVATE::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULEPRIVATE(*this));
|
|
}
|
|
void MODULEPRIVATE::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 Reserved;
|
|
*stream >> Reserved;
|
|
}
|
|
//--------------------------------------------------------------------------------
|
|
BaseRecordPtr MODULE::clone()
|
|
{
|
|
return BaseRecordPtr(new MODULE(*this));
|
|
}
|
|
|
|
void MODULE::load(CVbaFileStreamPtr stream)
|
|
{
|
|
bool bEof = false;
|
|
while (!bEof && stream->checkFitRead(6))
|
|
{
|
|
_UINT16 Id;
|
|
*stream >> Id;
|
|
|
|
switch (Id)
|
|
{
|
|
case rt_MODULENAME: NameRecord = boost::make_shared<MODULENAME>(stream); break;
|
|
case rt_MODULENAMEUNICODE: NameUnicodeRecord = boost::make_shared<MODULENAMEUNICODE>(stream); break;
|
|
case rt_MODULESTREAMNAME: StreamNameRecord = boost::make_shared<MODULESTREAMNAME>(stream); break;
|
|
case rt_MODULEDOCSTRING: DocStringRecord = boost::make_shared<MODULEDOCSTRING>(stream); break;
|
|
case rt_MODULEOFFSET: OffsetRecord = boost::make_shared<MODULEOFFSET>(stream); break;
|
|
case rt_MODULEHELPCONTEXT: HelpContextRecord = boost::make_shared<MODULEHELPCONTEXT>(stream); break;
|
|
case rt_MODULECOOKIE: { MODULECOOKIE Cookie(stream); } break;
|
|
case rt_MODULEREADONLY: { bReadOnly = true; MODULEREADONLY ReadOnly(stream); } break;
|
|
case rt_MODULEPRIVATE: { bPrivate = true; MODULEPRIVATE Private(stream); } break;
|
|
case rt_MODULETYPE_Procedural:
|
|
bProceduralModule = true;
|
|
case rt_MODULETYPE_Class: { MODULETYPE type(stream); } break;
|
|
case rt_Terminator:
|
|
{
|
|
bEof = true;
|
|
_UINT32 Reserved;
|
|
*stream >> Reserved;
|
|
}break;
|
|
default:
|
|
_UINT32 SizeOf;
|
|
*stream >> SizeOf;
|
|
stream->skipBytes(SizeOf);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
//-------------------------------------------------------------------------------------------------------
|
|
PROJECTSYSKIND::PROJECTSYSKIND(CVbaFileStreamPtr stream) { load(stream); }
|
|
BaseRecordPtr PROJECTSYSKIND::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTSYSKIND(*this));
|
|
}
|
|
void PROJECTSYSKIND::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf >> SysKind;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTCOMPATVERSION::PROJECTCOMPATVERSION(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTCOMPATVERSION::~PROJECTCOMPATVERSION() {}
|
|
BaseRecordPtr PROJECTCOMPATVERSION::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTCOMPATVERSION(*this));
|
|
}
|
|
void PROJECTCOMPATVERSION::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf >> CompatVersion;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTLCID::PROJECTLCID(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTLCID::~PROJECTLCID() {}
|
|
BaseRecordPtr PROJECTLCID::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTLCID(*this));
|
|
}
|
|
void PROJECTLCID::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf >> Lcid;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTLCIDINVOKE::PROJECTLCIDINVOKE(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTLCIDINVOKE::~PROJECTLCIDINVOKE() {}
|
|
BaseRecordPtr PROJECTLCIDINVOKE::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTLCIDINVOKE(*this));
|
|
}
|
|
void PROJECTLCIDINVOKE::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf >> LcidInvoke;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTCODEPAGE::PROJECTCODEPAGE(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTCODEPAGE::~PROJECTCODEPAGE() {}
|
|
BaseRecordPtr PROJECTCODEPAGE::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTCODEPAGE(*this));
|
|
}
|
|
void PROJECTCODEPAGE::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf >> CodePage;
|
|
|
|
stream->CodePage = CodePage;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTNAME::PROJECTNAME(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTNAME::~PROJECTNAME() {}
|
|
BaseRecordPtr PROJECTNAME::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTNAME(*this));
|
|
}
|
|
void PROJECTNAME::load(CVbaFileStreamPtr stream)
|
|
{
|
|
ProjectName.load(stream);
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTDOCSTRING::PROJECTDOCSTRING(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTDOCSTRING::~PROJECTDOCSTRING() {}
|
|
BaseRecordPtr PROJECTDOCSTRING::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTDOCSTRING(*this));
|
|
}
|
|
void PROJECTDOCSTRING::load(CVbaFileStreamPtr stream)
|
|
{
|
|
unsigned short Reserved;
|
|
aDocString.load(stream);
|
|
*stream >> Reserved;
|
|
uDocString.load(stream);
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTHELPFILEPATH::PROJECTHELPFILEPATH(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTHELPFILEPATH::~PROJECTHELPFILEPATH() {}
|
|
BaseRecordPtr PROJECTHELPFILEPATH::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTHELPFILEPATH(*this));
|
|
}
|
|
void PROJECTHELPFILEPATH::load(CVbaFileStreamPtr stream)
|
|
{
|
|
unsigned short Reserved;
|
|
HelpFile1.load(stream);
|
|
*stream >> Reserved;
|
|
HelpFile2.load(stream);
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTHELPCONTEXT::PROJECTHELPCONTEXT(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTHELPCONTEXT::~PROJECTHELPCONTEXT() {}
|
|
BaseRecordPtr PROJECTHELPCONTEXT::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTHELPCONTEXT(*this));
|
|
}
|
|
void PROJECTHELPCONTEXT::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf >> HelpContext;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTLIBFLAGS::PROJECTLIBFLAGS(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTLIBFLAGS::~PROJECTLIBFLAGS() {}
|
|
BaseRecordPtr PROJECTLIBFLAGS::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTLIBFLAGS(*this));
|
|
}
|
|
void PROJECTLIBFLAGS::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf >> ProjectLibFlags;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTVERSION::PROJECTVERSION(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTVERSION::~PROJECTVERSION() {}
|
|
BaseRecordPtr PROJECTVERSION::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTVERSION(*this));
|
|
}
|
|
void PROJECTVERSION::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 sizeOf;
|
|
*stream >> sizeOf >> VersionMajor >> VersionMinor;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
//Constants = Constant *(" : " Constant)
|
|
//Constant = ConstantName " = " ConstantValue
|
|
//ConstantName = VbaIdentifier
|
|
//ConstantValue = ["-"] 1 * 5DIGIT
|
|
|
|
PROJECTCONSTANTS::PROJECTCONSTANTS(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTCONSTANTS::~PROJECTCONSTANTS() {}
|
|
BaseRecordPtr PROJECTCONSTANTS::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTCONSTANTS(*this));
|
|
}
|
|
void PROJECTCONSTANTS::load(CVbaFileStreamPtr stream)
|
|
{
|
|
unsigned short Reserved;
|
|
|
|
aConstants.load(stream);
|
|
*stream >> Reserved;
|
|
uConstants.load(stream);
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
REFERENCENAME::REFERENCENAME(CVbaFileStreamPtr stream) { load(stream); }
|
|
REFERENCENAME::~REFERENCENAME() {}
|
|
BaseRecordPtr REFERENCENAME::clone()
|
|
{
|
|
return BaseRecordPtr(new REFERENCENAME(*this));
|
|
}
|
|
void REFERENCENAME::load(CVbaFileStreamPtr stream)
|
|
{
|
|
unsigned short Reserved;
|
|
aName.load(stream);
|
|
*stream >> Reserved;
|
|
uName.load(stream);
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
REFERENCEORIGINAL::REFERENCEORIGINAL(CVbaFileStreamPtr stream) { load(stream); }
|
|
REFERENCEORIGINAL::~REFERENCEORIGINAL() {}
|
|
BaseRecordPtr REFERENCEORIGINAL::clone()
|
|
{
|
|
return BaseRecordPtr(new REFERENCEORIGINAL(*this));
|
|
}
|
|
void REFERENCEORIGINAL::load(CVbaFileStreamPtr stream)
|
|
{
|
|
LibidOriginal.load(stream);
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
REFERENCEREGISTERED::REFERENCEREGISTERED(CVbaFileStreamPtr stream) { load(stream); }
|
|
REFERENCEREGISTERED::~REFERENCEREGISTERED() {}
|
|
BaseRecordPtr REFERENCEREGISTERED::clone()
|
|
{
|
|
return BaseRecordPtr(new REFERENCEREGISTERED(*this));
|
|
}
|
|
void REFERENCEREGISTERED::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 Reserved1, Size;
|
|
_UINT16 Reserved2;
|
|
*stream >> Size;
|
|
Libid.load(stream);
|
|
*stream >> Reserved1 >> Reserved2;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
REFERENCEPROJECT::REFERENCEPROJECT(CVbaFileStreamPtr stream) { load(stream); }
|
|
REFERENCEPROJECT::~REFERENCEPROJECT() {}
|
|
BaseRecordPtr REFERENCEPROJECT::clone()
|
|
{
|
|
return BaseRecordPtr(new REFERENCEPROJECT(*this));
|
|
}
|
|
void REFERENCEPROJECT::load(CVbaFileStreamPtr stream)
|
|
{
|
|
LibidAbsolute.load(stream);
|
|
LibidRelative.load(stream);
|
|
|
|
*stream >> MajorVersion >> MinorVersion;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
REFERENCECONTROL::REFERENCECONTROL(CVbaFileStreamPtr stream) { load(stream); }
|
|
REFERENCECONTROL::~REFERENCECONTROL() {}
|
|
BaseRecordPtr REFERENCECONTROL::clone()
|
|
{
|
|
return BaseRecordPtr(new REFERENCECONTROL(*this));
|
|
}
|
|
void REFERENCECONTROL::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT32 Reserved1, Reserved4, SizeTwiddled, SizeExtended, Cookie;
|
|
_UINT16 Reserved2, Reserved3, Reserved5, Id;
|
|
|
|
*stream >> SizeTwiddled;
|
|
LibidTwiddled.load(stream);
|
|
*stream >> Reserved1 >> Reserved2;
|
|
|
|
*stream >> Id;
|
|
if (Id == 0x0016)
|
|
{
|
|
NameRecordExtended = boost::make_shared<REFERENCENAME>(stream);
|
|
*stream >> Reserved3;
|
|
}
|
|
else
|
|
{
|
|
Reserved3 = Id; // = 0x0030
|
|
}
|
|
|
|
*stream >> SizeExtended;
|
|
LibidExtended.load(stream);
|
|
*stream >> Reserved4 >> Reserved5 >> OriginalTypeLib >> Cookie;
|
|
}
|
|
//-------------------------------------------------------------------------------
|
|
PROJECTCOOKIE::PROJECTCOOKIE(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTCOOKIE::~PROJECTCOOKIE() {}
|
|
BaseRecordPtr PROJECTCOOKIE::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTCOOKIE(*this));
|
|
}
|
|
void PROJECTCOOKIE::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT16 Id;
|
|
_UINT32 sizeOf;
|
|
*stream >> Id >> sizeOf >> Cookie;
|
|
}
|
|
//-----------------------------------------------------------------------------------
|
|
PROJECTMODULES::PROJECTMODULES(CVbaFileStreamPtr stream) { load(stream); }
|
|
PROJECTMODULES::~PROJECTMODULES() {}
|
|
BaseRecordPtr PROJECTMODULES::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTMODULES(*this));
|
|
}
|
|
void PROJECTMODULES::load(CVbaFileStreamPtr stream)
|
|
{
|
|
_UINT16 Id, nCount;
|
|
_UINT32 sizeOf;
|
|
|
|
*stream >> Id >> sizeOf >> nCount;
|
|
|
|
ProjectCookieRecord = PROJECTCOOKIEPtr(new PROJECTCOOKIE(stream));
|
|
|
|
for (_UINT32 i = 0; i < nCount; i++)
|
|
{
|
|
modules.push_back(boost::make_shared<MODULE>(stream));
|
|
}
|
|
}
|
|
//----------------------------------------------------------------------------------
|
|
BaseRecordPtr PROJECTINFORMATION::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTINFORMATION(*this));
|
|
}
|
|
|
|
void PROJECTINFORMATION::load(CVbaFileStreamPtr stream)
|
|
{
|
|
while (stream->checkFitRead(6))
|
|
{
|
|
_UINT16 Id;
|
|
*stream >> Id;
|
|
|
|
if (Id == 0x0016)
|
|
{//next union
|
|
stream->RollBack(2);
|
|
break;
|
|
}
|
|
|
|
switch (Id)
|
|
{
|
|
case rt_PROJECTSYSKIND:
|
|
{
|
|
SysKindRecord = boost::make_shared<PROJECTSYSKIND>(stream);
|
|
|
|
}break;
|
|
case rt_PROJECTCODEPAGE:
|
|
{
|
|
CodePageRecord = boost::make_shared<PROJECTCODEPAGE>(stream);
|
|
}break;
|
|
case rt_PROJECTCOMPATVERSION:
|
|
{
|
|
CompatVersionRecord = boost::make_shared<PROJECTCOMPATVERSION>(stream);
|
|
}break;
|
|
case rt_PROJECTLCID:
|
|
{
|
|
LcidRecord = boost::make_shared<PROJECTLCID>(stream);
|
|
}break;
|
|
case rt_PROJECTLCIDINVOKE:
|
|
{
|
|
LcidInvokeRecord = boost::make_shared<PROJECTLCIDINVOKE>(stream);
|
|
}break;
|
|
case rt_PROJECTNAME:
|
|
{
|
|
NameRecord = boost::make_shared<PROJECTNAME>(stream);
|
|
}break;
|
|
case rt_PROJECTDOCSTRING:
|
|
{
|
|
DocStringRecord = boost::make_shared<PROJECTDOCSTRING>(stream);
|
|
}break;
|
|
case rt_PROJECTHELPFILEPATH:
|
|
{
|
|
HelpFilePathRecord = boost::make_shared<PROJECTHELPFILEPATH>(stream);
|
|
}break;
|
|
case rt_PROJECTHELPCONTEXT:
|
|
{
|
|
HelpContextRecord = boost::make_shared<PROJECTHELPCONTEXT>(stream);
|
|
}break;
|
|
case rt_PROJECTLIBFLAGS:
|
|
{
|
|
LibFlagsRecord = boost::make_shared<PROJECTLIBFLAGS>(stream);
|
|
}break;
|
|
case rt_PROJECTVERSION:
|
|
{
|
|
VersionRecord = boost::make_shared<PROJECTVERSION>(stream);
|
|
}break;
|
|
case rt_PROJECTCONSTANTS:
|
|
{
|
|
ConstantsRecord = boost::make_shared<PROJECTCONSTANTS>(stream);
|
|
}break;
|
|
default://unknown .... skip
|
|
{
|
|
_UINT32 SizeOf;
|
|
*stream >> SizeOf;
|
|
stream->skipBytes(SizeOf);
|
|
}break;
|
|
}
|
|
}
|
|
|
|
}
|
|
//---------------------------------------------------------------------------------------
|
|
|
|
BaseRecordPtr PROJECTREFERENCES::clone()
|
|
{
|
|
return BaseRecordPtr(new PROJECTREFERENCES(*this));
|
|
}
|
|
|
|
void PROJECTREFERENCES::load(CVbaFileStreamPtr stream)
|
|
{
|
|
while (stream->checkFitRead(6))
|
|
{
|
|
_UINT16 Id;
|
|
*stream >> Id;
|
|
|
|
if (Id == rt_REFERENCENAME)
|
|
{
|
|
stream->RollBack(2);
|
|
ReferenceArray.push_back(boost::make_shared<REFERENCE>(stream));
|
|
}
|
|
else if (Id == rt_PROJECTMODULES)
|
|
{//next union
|
|
stream->RollBack(2);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
_UINT32 SizeOf;
|
|
*stream >> SizeOf;
|
|
stream->skipBytes(SizeOf);
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------------------
|
|
BaseRecordPtr REFERENCE::clone()
|
|
{
|
|
return BaseRecordPtr(new REFERENCE(*this));
|
|
}
|
|
|
|
void REFERENCE::load(CVbaFileStreamPtr stream)
|
|
{
|
|
while (stream->checkFitRead(6))
|
|
{
|
|
_UINT16 Id;
|
|
*stream >> Id;
|
|
|
|
if (Id == rt_PROJECTMODULES ||
|
|
(NameRecord && Id == rt_REFERENCENAME))
|
|
{//next union
|
|
stream->RollBack(2);
|
|
break;
|
|
}
|
|
|
|
switch (Id)
|
|
{
|
|
case rt_REFERENCENAME: NameRecord = boost::make_shared<REFERENCENAME>(stream); break;
|
|
case rt_REFERENCEORIGINAL: ReferenceRecord = boost::make_shared<REFERENCEORIGINAL>(stream); break;
|
|
case rt_REFERENCECONTROL: ReferenceRecord = boost::make_shared<REFERENCECONTROL>(stream); break;
|
|
case rt_REFERENCEREGISTERED: ReferenceRecord = boost::make_shared<REFERENCEREGISTERED>(stream); break;
|
|
case rt_REFERENCEPROJECT: ReferenceRecord = boost::make_shared<REFERENCEPROJECT>(stream); break;
|
|
default://unknown .... skip
|
|
{
|
|
_UINT32 SizeOf;
|
|
*stream >> SizeOf;
|
|
stream->skipBytes(SizeOf);
|
|
}break;
|
|
}
|
|
}
|
|
}
|
|
//---------------------------------------------------------------------------------------
|
|
|
|
//-------------------------------------------------------------------------------
|
|
//PROJECTMODULES::PROJECTMODULES() {}
|
|
//PROJECTMODULES::~PROJECTMODULES() {}
|
|
//BaseObjectPtr PROJECTMODULES::clone()
|
|
//{
|
|
// return BaseObjectPtr(new PROJECTMODULES(*this));
|
|
//}
|
|
//const bool PROJECTMODULES::loadContent(BinProcessor& proc)
|
|
//{
|
|
// BiffAttributeSimple<unsigned short> nCount;
|
|
|
|
// proc.nCount;
|
|
|
|
// if (proc.optional<PROJECTCOOKIE>())
|
|
// {
|
|
// ProjectCookieRecord = boost::make_shared<>(stream);
|
|
// elements_.pop_back();
|
|
// }
|
|
|
|
// for (unsigned short i = 0; i < nCount; i++)
|
|
// {
|
|
// MODULE *m = new MODULE();
|
|
// m->loadContent(proc);
|
|
// modules.push_back(BaseObjectPtr(m));
|
|
// }
|
|
//}
|
|
} // namespace VBA
|
|
|