diff --git a/ASCOfficeXlsFile2/source/VbaFormat/Records.cpp b/ASCOfficeXlsFile2/source/VbaFormat/Records.cpp new file mode 100644 index 0000000000..dfdbb04c0e --- /dev/null +++ b/ASCOfficeXlsFile2/source/VbaFormat/Records.cpp @@ -0,0 +1,768 @@ +/* + * (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 +#include +#include +#include "../../../UnicodeConverter/UnicodeConverter.h" + +namespace VBA +{ + 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::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 const &facet = std::use_facet >(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(stream); break; + case rt_MODULENAMEUNICODE: NameUnicodeRecord = boost::make_shared(stream); break; + case rt_MODULESTREAMNAME: StreamNameRecord = boost::make_shared(stream); break; + case rt_MODULEDOCSTRING: DocStringRecord = boost::make_shared(stream); break; + case rt_MODULEOFFSET: OffsetRecord = boost::make_shared(stream); break; + case rt_MODULEHELPCONTEXT: HelpContextRecord = boost::make_shared(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(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(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(stream); + + }break; + case rt_PROJECTCODEPAGE: + { + CodePageRecord = boost::make_shared(stream); + }break; + case rt_PROJECTCOMPATVERSION: + { + CompatVersionRecord = boost::make_shared(stream); + }break; + case rt_PROJECTLCID: + { + LcidRecord = boost::make_shared(stream); + }break; + case rt_PROJECTLCIDINVOKE: + { + LcidInvokeRecord = boost::make_shared(stream); + }break; + case rt_PROJECTNAME: + { + NameRecord = boost::make_shared(stream); + }break; + case rt_PROJECTDOCSTRING: + { + DocStringRecord = boost::make_shared(stream); + }break; + case rt_PROJECTHELPFILEPATH: + { + HelpFilePathRecord = boost::make_shared(stream); + }break; + case rt_PROJECTHELPCONTEXT: + { + HelpContextRecord = boost::make_shared(stream); + }break; + case rt_PROJECTLIBFLAGS: + { + LibFlagsRecord = boost::make_shared(stream); + }break; + case rt_PROJECTVERSION: + { + VersionRecord = boost::make_shared(stream); + }break; + case rt_PROJECTCONSTANTS: + { + ConstantsRecord = boost::make_shared(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(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(stream); break; + case rt_REFERENCEORIGINAL: ReferenceRecord = boost::make_shared(stream); break; + case rt_REFERENCECONTROL: ReferenceRecord = boost::make_shared(stream); break; + case rt_REFERENCEREGISTERED: ReferenceRecord = boost::make_shared(stream); break; + case rt_REFERENCEPROJECT: ReferenceRecord = boost::make_shared(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 nCount; + + // proc.nCount; + + // if (proc.optional()) + // { + // 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 + diff --git a/ASCOfficeXlsFile2/source/VbaFormat/Records.h b/ASCOfficeXlsFile2/source/VbaFormat/Records.h new file mode 100644 index 0000000000..4e846e0bb1 --- /dev/null +++ b/ASCOfficeXlsFile2/source/VbaFormat/Records.h @@ -0,0 +1,611 @@ +/* + * (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 + * + */ +#pragma once + +#include "VbaRecordType.h" +#include "VbaBinary.h" + + +namespace VBA +{ + const std::wstring convert_string_icu(const char* buffer, const unsigned int& size, _UINT32 nCodePage); + const std::wstring guid2bstr(const _GUID_ guid); + + class BaseRecord; + typedef boost::shared_ptr BaseRecordPtr; + + class BaseRecord + { + public: + virtual BaseRecordPtr clone() = 0; + virtual void load(CVbaFileStreamPtr stream) = 0; + virtual RecordType get_type() = 0; + virtual const std::string & getClassName() const = 0; + }; + +#define BASE_STRUCTURE_DEFINE_CLASS_NAME(class_name)\ + private: \ + static const RecordType type = rt_##class_name; \ + public: \ + const std::string & getClassName() const { static std::string str(#class_name); return str;}\ + virtual RecordType get_type() { return type; } + +//-------------------------------------------------------------------------------------------------- + class AnsiString : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(AnsiString) + public: + AnsiString() {} + AnsiString(CVbaFileStreamPtr stream); + ~AnsiString() {} + + BaseRecordPtr clone(); + virtual void load(CVbaFileStreamPtr stream); + + std::wstring value; + }; + typedef boost::shared_ptr AnsiStringPtr; + +//-------------------------------------------------------------------------------------------------- + class Utf16String : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(Utf16String) + public: + Utf16String() {} + Utf16String(CVbaFileStreamPtr stream); + ~Utf16String() {} + + BaseRecordPtr clone(); + virtual void load(CVbaFileStreamPtr stream); + + std::wstring value; + }; + typedef boost::shared_ptr Utf16StringPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTSYSKIND : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULESTREAMNAME) + public: + PROJECTSYSKIND(CVbaFileStreamPtr stream); + ~PROJECTSYSKIND() {} + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 SysKind; + }; + typedef boost::shared_ptr PROJECTSYSKINDPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTCOMPATVERSION : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTCOMPATVERSION) + public: + PROJECTCOMPATVERSION(CVbaFileStreamPtr stream); + ~PROJECTCOMPATVERSION(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 CompatVersion; + }; + typedef boost::shared_ptr PROJECTCOMPATVERSIONPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTLCID : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTLCID) + public: + PROJECTLCID(CVbaFileStreamPtr stream); + ~PROJECTLCID(); + BaseRecordPtr clone(); + + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 Lcid; + }; + typedef boost::shared_ptr PROJECTLCIDPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTLCIDINVOKE : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTLCIDINVOKE) + public: + PROJECTLCIDINVOKE(CVbaFileStreamPtr stream); + ~PROJECTLCIDINVOKE(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 LcidInvoke; + }; + typedef boost::shared_ptr PROJECTLCIDINVOKEPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTCODEPAGE : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTCODEPAGE) + public: + PROJECTCODEPAGE(CVbaFileStreamPtr stream); + ~PROJECTCODEPAGE(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + unsigned short CodePage; + }; + typedef boost::shared_ptr PROJECTCODEPAGEPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTNAME : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTNAME) + public: + PROJECTNAME(CVbaFileStreamPtr stream); + ~PROJECTNAME(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString ProjectName; + }; + typedef boost::shared_ptr PROJECTNAMEPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTDOCSTRING : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTDOCSTRING) + public: + PROJECTDOCSTRING(CVbaFileStreamPtr stream); + ~PROJECTDOCSTRING(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString aDocString; + Utf16String uDocString; + }; + typedef boost::shared_ptr PROJECTDOCSTRINGPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTHELPFILEPATH : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTHELPFILEPATH) + public: + PROJECTHELPFILEPATH(CVbaFileStreamPtr stream); + ~PROJECTHELPFILEPATH(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + Utf16String HelpFile1; + Utf16String HelpFile2; + }; + typedef boost::shared_ptr PROJECTHELPFILEPATHPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTHELPCONTEXT : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTHELPCONTEXT) + public: + PROJECTHELPCONTEXT(CVbaFileStreamPtr stream); + ~PROJECTHELPCONTEXT(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 HelpContext; + }; + typedef boost::shared_ptr PROJECTHELPCONTEXTPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTLIBFLAGS : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTLIBFLAGS) + public: + PROJECTLIBFLAGS(CVbaFileStreamPtr stream); + ~PROJECTLIBFLAGS(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 ProjectLibFlags; + }; + typedef boost::shared_ptr PROJECTLIBFLAGSPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTVERSION : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTVERSION) + public: + PROJECTVERSION(CVbaFileStreamPtr stream); + ~PROJECTVERSION(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 VersionMajor; + _UINT16 VersionMinor; + }; + typedef boost::shared_ptr PROJECTVERSIONPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTCONSTANTS : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTCONSTANTS) + public: + PROJECTCONSTANTS(CVbaFileStreamPtr stream); + ~PROJECTCONSTANTS(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString aConstants; + Utf16String uConstants; + }; + typedef boost::shared_ptr PROJECTCONSTANTSPtr; +//-------------------------------------------------------------------------------------------------- + class REFERENCENAME : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(REFERENCENAME) + public: + REFERENCENAME(CVbaFileStreamPtr stream); + ~REFERENCENAME(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString aName; + Utf16String uName; + }; + typedef boost::shared_ptr REFERENCENAMEPtr; +//-------------------------------------------------------------------------------------------------- + class REFERENCEORIGINAL : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(REFERENCEORIGINAL) + public: + REFERENCEORIGINAL(CVbaFileStreamPtr stream); + ~REFERENCEORIGINAL(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString LibidOriginal; + }; + typedef boost::shared_ptr REFERENCEORIGINALPtr; +//-------------------------------------------------------------------------------------------------- + class REFERENCEREGISTERED : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(REFERENCEREGISTERED) + public: + REFERENCEREGISTERED(CVbaFileStreamPtr stream); + ~REFERENCEREGISTERED(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString Libid; + }; + typedef boost::shared_ptr REFERENCEREGISTEREDPtr; +//-------------------------------------------------------------------------------------------------- + class REFERENCEPROJECT : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(REFERENCEPROJECT) + public: + REFERENCEPROJECT(CVbaFileStreamPtr stream); + ~REFERENCEPROJECT(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 MajorVersion; + _UINT16 MinorVersion; + + AnsiString LibidAbsolute; + AnsiString LibidRelative; + }; + typedef boost::shared_ptr REFERENCEPROJECTPtr; +//-------------------------------------------------------------------------------------------------- + class REFERENCECONTROL : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(REFERENCECONTROL) + public: + REFERENCECONTROL(CVbaFileStreamPtr stream); + ~REFERENCECONTROL(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString LibidTwiddled; + AnsiString LibidExtended; + + REFERENCENAMEPtr NameRecordExtended; + _GUID_ OriginalTypeLib; + }; + typedef boost::shared_ptr REFERENCECONTROLPtr; +//-------------------------------------------------------------------------------------------------- + class PROJECTCOOKIE : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTCOOKIE) + public: + PROJECTCOOKIE(CVbaFileStreamPtr stream); + ~PROJECTCOOKIE(); + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + unsigned short Cookie; + }; + typedef boost::shared_ptr PROJECTCOOKIEPtr; +//------------------------------------------------------------------------------------------------- + class MODULENAME : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULENAME) + public: + MODULENAME(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString ModuleName; + }; + typedef boost::shared_ptr MODULENAMEPtr; +//----------------------------------------------------------------------------- + class MODULENAMEUNICODE : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULENAMEUNICODE) + public: + MODULENAMEUNICODE(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + Utf16String ModuleNameUnicode; + }; + typedef boost::shared_ptr MODULENAMEUNICODEPtr; +//----------------------------------------------------------------------------- + class MODULESTREAMNAME : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULESTREAMNAME) + public: + MODULESTREAMNAME(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString StreamName; + Utf16String StreamNameUnicode; + }; + typedef boost::shared_ptr MODULESTREAMNAMEPtr; +//----------------------------------------------------------------------------- + class MODULEDOCSTRING : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULEDOCSTRING) + public: + MODULEDOCSTRING(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + AnsiString DocString; + Utf16String DocStringUnicode; + }; + typedef boost::shared_ptr MODULEDOCSTRINGPtr; +//----------------------------------------------------------------------------- + class MODULEOFFSET : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULEOFFSET) + public: + MODULEOFFSET(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 TextOffset; + }; + typedef boost::shared_ptr MODULEOFFSETPtr; +//----------------------------------------------------------------------------- + class MODULEHELPCONTEXT : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULEHELPCONTEXT) + public: + MODULEHELPCONTEXT(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + _UINT32 HelpContext; + }; + typedef boost::shared_ptr MODULEHELPCONTEXTPtr; +//----------------------------------------------------------------------------- + class MODULECOOKIE : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULECOOKIE) + public: + MODULECOOKIE(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + }; + typedef boost::shared_ptr MODULECOOKIEPtr; +//----------------------------------------------------------------------------- + class MODULETYPE : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULETYPE) + public: + MODULETYPE(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + }; + typedef boost::shared_ptr MODULETYPEPtr; +//----------------------------------------------------------------------------- + class MODULEREADONLY : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULEREADONLY) + public: + MODULEREADONLY(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + }; + typedef boost::shared_ptr MODULEREADONLYPtr; +//----------------------------------------------------------------------------- + class MODULEPRIVATE : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULEPRIVATE) + public: + MODULEPRIVATE(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + }; + typedef boost::shared_ptr MODULEPRIVATEPtr; +//------------------------------------------------------------------------------------ + class MODULE : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(MODULE) + public: + MODULE(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + virtual void load(CVbaFileStreamPtr stream); + + MODULENAMEPtr NameRecord; + MODULENAMEUNICODEPtr NameUnicodeRecord; + MODULESTREAMNAMEPtr StreamNameRecord; + MODULEDOCSTRINGPtr DocStringRecord; + MODULEOFFSETPtr OffsetRecord; + MODULEHELPCONTEXTPtr HelpContextRecord; + + bool bReadOnly = false; + bool bPrivate = false; + bool bProceduralModule = false; + }; + typedef boost::shared_ptr MODULEPtr; +//---------------------------------------------------------------------------------------- + class PROJECTINFORMATION : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTINFORMATION) + public: + PROJECTINFORMATION(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + PROJECTSYSKINDPtr SysKindRecord; + PROJECTCOMPATVERSIONPtr CompatVersionRecord; + PROJECTLCIDPtr LcidRecord; + PROJECTLCIDINVOKEPtr LcidInvokeRecord; + PROJECTCODEPAGEPtr CodePageRecord; + PROJECTNAMEPtr NameRecord; + PROJECTDOCSTRINGPtr DocStringRecord; + PROJECTHELPFILEPATHPtr HelpFilePathRecord; + PROJECTHELPCONTEXTPtr HelpContextRecord; + PROJECTLIBFLAGSPtr LibFlagsRecord; + PROJECTVERSIONPtr VersionRecord; + PROJECTCONSTANTSPtr ConstantsRecord; + }; + typedef boost::shared_ptr PROJECTINFORMATIONPtr; +//----------------------------------------------------------------------------- + class REFERENCE : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(REFERENCE) + public: + REFERENCE(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + REFERENCENAMEPtr NameRecord; + BaseRecordPtr ReferenceRecord; + }; + typedef boost::shared_ptr REFERENCEPtr; + class PROJECTREFERENCES : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTINFORMATION) + public: + PROJECTREFERENCES(CVbaFileStreamPtr stream) + { + load(stream); + } + BaseRecordPtr clone(); + + virtual void load(CVbaFileStreamPtr stream); + + std::vector ReferenceArray; + }; + typedef boost::shared_ptr PROJECTREFERENCESPtr; +//---------------------------------------------------------------------------------------------- + class PROJECTMODULES : public BaseRecord + { + BASE_STRUCTURE_DEFINE_CLASS_NAME(PROJECTMODULES) + public: + PROJECTMODULES(CVbaFileStreamPtr stream); + ~PROJECTMODULES(); + BaseRecordPtr clone(); + virtual void load(CVbaFileStreamPtr stream); + + std::vector modules; + PROJECTCOOKIEPtr ProjectCookieRecord; + }; + typedef boost::shared_ptr PROJECTMODULESPtr; +} // namespace VBA + diff --git a/ASCOfficeXlsFile2/source/VbaFormat/StreamObjects.cpp b/ASCOfficeXlsFile2/source/VbaFormat/StreamObjects.cpp new file mode 100644 index 0000000000..0926ba548e --- /dev/null +++ b/ASCOfficeXlsFile2/source/VbaFormat/StreamObjects.cpp @@ -0,0 +1,56 @@ +/* + * (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 "StreamObjects.h" +#include "VbaRecordType.h" + +#include + +namespace VBA +{; + +bool DirStreamObject::loadContent() +{ + InformationRecord = boost::make_shared(reader); + ReferencesRecord = boost::make_shared(reader); + ModulesRecord = boost::make_shared(reader); + + return (InformationRecord && ReferencesRecord && ModulesRecord); +} + +bool ModuleStreamObject::loadContent() +{ + SourceCode = convert_string_icu((char*)reader->getData(), (unsigned int)reader->getDataSize(), reader->CodePage); + + return true; +} +} // namespace VBA diff --git a/ASCOfficeXlsFile2/source/VbaFormat/StreamObjects.h b/ASCOfficeXlsFile2/source/VbaFormat/StreamObjects.h new file mode 100644 index 0000000000..7b236275b7 --- /dev/null +++ b/ASCOfficeXlsFile2/source/VbaFormat/StreamObjects.h @@ -0,0 +1,73 @@ +/* + * (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 + * + */ +#pragma once + +#include "Records.h" + +class CVbaFileStream; +typedef boost::shared_ptr CVbaFileStreamPtr; + +namespace VBA +{ + class DirStreamObject + { + public: + DirStreamObject(CVbaFileStreamPtr _reader) { reader = _reader; } + ~DirStreamObject() {} + + bool loadContent(); + + PROJECTINFORMATIONPtr InformationRecord; + PROJECTREFERENCESPtr ReferencesRecord; + PROJECTMODULESPtr ModulesRecord; + + private: + CVbaFileStreamPtr reader; + }; + typedef boost::shared_ptr DirStreamObjectPtr; + + class ModuleStreamObject + { + public: + ModuleStreamObject(CVbaFileStreamPtr _reader) { reader = _reader; } + ~ModuleStreamObject() {} + + bool loadContent(); + + std::wstring SourceCode; + + private: + CVbaFileStreamPtr reader; + }; + typedef boost::shared_ptr ModuleStreamObjectPtr; + +} // namespace VBA diff --git a/ASCOfficeXlsFile2/source/VbaFormat/VbaBinary.cpp b/ASCOfficeXlsFile2/source/VbaFormat/VbaBinary.cpp new file mode 100644 index 0000000000..456a693f48 --- /dev/null +++ b/ASCOfficeXlsFile2/source/VbaFormat/VbaBinary.cpp @@ -0,0 +1,237 @@ +/* + * (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 "VbaBinary.h" + +#include + +#include +#include + + + +CVbaFile::~CVbaFile() +{ + streams.clear(); + + if (storage_)delete storage_; + storage_ = NULL; +} + +bool CVbaFile::isError() +{ + if (storage_ != NULL) return false; + return true; +} + +bool CVbaFile::Open(const std::wstring & file_path) +{ + if (storage_) delete storage_; + storage_ = NULL; + + storage_ = new POLE::Storage(file_path.c_str()); + if (storage_ == NULL) return false; + + if (storage_->open(false, false) == false) + { + delete storage_; + storage_ = NULL; + } + + if (storage_ == NULL) return false; + return true; +} +CVbaFile::CVbaFile(const std::wstring & file_path) +{ + storage_ = NULL; + Open(file_path); +} +CVbaFileStreamPtr CVbaFile::getNamedStream(const std::wstring& name, _UINT32 offset) +{ + if (!streams[name]) + { + POLE::Stream * pStream = openStream(name.c_str()); + if (pStream) + streams[name].reset(new CVbaFileStream(pStream, offset)); + } + return streams[name]; +} + +void CVbaFile::closeNamedStream(const std::wstring& name) +{ + streams[name].reset(); +} + +POLE::Stream* CVbaFile::openStream(const std::wstring & stream_name) +{ + if (storage_ == NULL) return NULL; + + POLE::Stream* pStream = new POLE::Stream(storage_, stream_name); + if (pStream == NULL) + { + return NULL; + } + if ((pStream) && (pStream->size() > 0)) + return pStream; + else return NULL; +} +const unsigned char VBASTREAM_SIGNATURE = 1; + +const _UINT16 CHUNK_SIGMASK = 0x7000; +const _UINT16 CHUNK_SIG = 0x3000; +const _UINT16 CHUNK_COMPRESSED = 0x8000; +const _UINT16 CHUNK_LENMASK = 0x0FFF; + +inline _UINT16 extract(_UINT16 nBitField, unsigned char nStartBit, unsigned char nBitCount) +{ + _UINT64 nMask = 1; nMask <<= nBitCount; --nMask; + return static_cast< _UINT16 >(nMask & (nBitField >> nStartBit)); +} +CVbaFileStream::CVbaFileStream(POLE::Stream* stream, _UINT32 offset) +{ + size_t dataSize = stream->size(); + + unsigned char sig = 0; + stream->read(&sig, 1); + + if (sig != 1) + { + stream->seek(0); + arrChunks.resize(dataSize); + stream->read(arrChunks.data(), dataSize); + + return; + } + dataSize -= 1; + + stream->seek(stream->tell() + offset); + dataSize -= offset; +//readchunks + unsigned char *data = new unsigned char[dataSize]; + stream->read(data, dataSize); + + unsigned char *dataCur = data; + size_t dataPos = 0; + + while (dataPos + 2 < dataSize) + { + std::vector arrChunk; + _UINT16 header = *((_UINT32*)dataCur); dataCur += 2; + + bool bCompressed = ((header & CHUNK_COMPRESSED) != 0); + _UINT16 chunkSize = (header & CHUNK_LENMASK); + + if ((header & CHUNK_SIGMASK) != CHUNK_SIG) + { + bCompressed = true; + chunkSize = 4094; //по факту + } + POLE::uint64 target = (dataCur - data) + chunkSize; + + if (bCompressed) + { + unsigned char nBitCount = 4; + _UINT16 chunkPos = 0; + + bool bEof = stream->eof(); + while (!bEof && ((dataCur - data) > 0) && (chunkPos < chunkSize)) + { + unsigned char nToken = *dataCur; dataCur++; + ++chunkPos; + + for (int bit = 0; !bEof && ((dataCur - data) > 0) && (bit < 8) && (chunkPos < chunkSize); ++bit, nToken >>= 1) + { + if (nToken & 1) + { + _UINT16 nCopyToken = *((_UINT32*)dataCur); dataCur += 2; + chunkPos += 2; + + while ((static_cast(1) << nBitCount) < arrChunk.size()) + ++nBitCount; + + _UINT16 nLength = extract(nCopyToken, 0, 16 - nBitCount) + 3; + _UINT16 nOffset = extract(nCopyToken, 16 - nBitCount, nBitCount) + 1; + + bEof = (nOffset > arrChunk.size()) || (arrChunk.size() + nLength > 4096); + + if (!bEof) + { + arrChunk.resize(arrChunk.size() + nLength); + + unsigned char* pnTo = &*(arrChunk.end() - nLength); + + const unsigned char* pnEnd = pnTo + nLength; + const unsigned char* pnFrom = pnTo - nOffset; + + size_t nRunLen = (std::min)(nLength, nOffset); + while (pnTo < pnEnd) + { + size_t nStepLen = (std::min)(nRunLen, (size_t)(pnEnd - pnTo)); + memcpy(pnTo, pnFrom, nStepLen); + pnTo += nStepLen; + } + } + } + else + { + arrChunk.emplace_back(); + arrChunk.back() = *dataCur; dataCur++; + ++chunkPos; + } + } + } + } + else + { + arrChunk.resize(chunkSize); + memcpy(arrChunk.data(), dataCur, chunkSize); dataCur += chunkSize; + } + dataPos = target; + arrChunks.insert(arrChunks.end(), arrChunk.begin(), arrChunk.end()); + } +} +CVbaFileStream::~CVbaFileStream() +{ + arrChunks.clear(); +} +void CVbaFileStream::read(void* buf, size_t size) +{ + if (NULL == buf || arrChunks.empty()) + { + return; + } + if (pos + size > arrChunks.size()) + size = arrChunks.size() - pos; + memcpy(buf, arrChunks.data() + pos, size); + pos += size; + +} diff --git a/ASCOfficeXlsFile2/source/VbaFormat/VbaBinary.h b/ASCOfficeXlsFile2/source/VbaFormat/VbaBinary.h new file mode 100644 index 0000000000..914f57e6df --- /dev/null +++ b/ASCOfficeXlsFile2/source/VbaFormat/VbaBinary.h @@ -0,0 +1,144 @@ +/* + * (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 + * + */ +#pragma once + +#include "../../../Common/3dParty/pole/pole.h" +#include "../../../Common/DocxFormat/Source/Base/Types_32.h" + +#include +#include +#include +#include + + +typedef struct +{ + _UINT32 Data1; + _UINT16 Data2; + _UINT16 Data3; + unsigned char Data4[8]; +} _GUID_; + +class CVbaFileStream +{ +public: + CVbaFileStream(POLE::Stream* stream, _UINT32 offset = 0); + ~CVbaFileStream(); + + template + CVbaFileStream& operator >> (Type& val) + { + read(&val, sizeof(Type)); + return *this; + } + + void read(void* buf, size_t size); + +//--------------------------------------------------------------------- + void skipBytes(const size_t n) + { + pos += n; + if (pos > arrChunks.size()) + pos = arrChunks.size(); + } + void RollBack(const size_t n) + { + if (pos - n >= 0) + { + pos -= n; + } + } + unsigned char* getData() { return arrChunks.data(); } + size_t getDataSize() { return arrChunks.size(); } + + const bool checkFitReadSafe(const size_t size) const + { + return (!arrChunks.empty() && (pos + size < arrChunks.size())); + } + bool checkFitRead(const size_t size) const + { + if (!checkFitReadSafe(size)) + { + return false; + } + return true; + } + template + bool loadAnyData(T& val) //for static size objects + { + size_t size = sizeof(T); + if (checkFitRead(size)) + { + memcpy((unsigned char*)&val, arrChunks.data() + pos, size); + pos += size; + return true; + } + return false; + } + + CVbaFileStream& operator >> (unsigned char& val) { loadAnyData(val); return *this; } + CVbaFileStream& operator >> (int& val) { loadAnyData(val); return *this; } + CVbaFileStream& operator >> (double& val) { loadAnyData(val); return *this; } + CVbaFileStream& operator >> (short& val) { loadAnyData(val); return *this; } + CVbaFileStream& operator >> (char& val) { loadAnyData(val); return *this; } + CVbaFileStream& operator >> (_GUID_& val) { loadAnyData(val); return *this; } + CVbaFileStream& operator >> (_UINT32& val) { loadAnyData(val); return *this; } + CVbaFileStream& operator >> (_UINT16& val) { loadAnyData(val); return *this; } + + _UINT32 CodePage = 0; +private: + std::vector arrChunks; + size_t pos = 0; +}; +typedef boost::shared_ptr CVbaFileStreamPtr; + +class CVbaFile +{ +public: + CVbaFile(const std::wstring & file_path); + ~CVbaFile(); + + bool Open(const std::wstring & file_path); + + bool isError(); + bool isDirectory(const std::wstring & name) { return (storage_ ? storage_->isDirectory(name) : false); } + + CVbaFileStreamPtr getNamedStream(const std::wstring& name, _UINT32 offset = 0); +private: + POLE::Storage *storage_; + + POLE::Stream* openStream(const std::wstring & stream_name); // Opens a stream in the storage (shall be called not more than once per stream) + void closeNamedStream(const std::wstring& name); + + std::map streams; +}; +typedef boost::shared_ptr CVbaFilePtr; diff --git a/ASCOfficeXlsFile2/source/VbaFormat/VbaReader.cpp b/ASCOfficeXlsFile2/source/VbaFormat/VbaReader.cpp new file mode 100644 index 0000000000..3558634d88 --- /dev/null +++ b/ASCOfficeXlsFile2/source/VbaFormat/VbaReader.cpp @@ -0,0 +1,159 @@ +#include "VbaReader.h" +#include "StreamObjects.h" +#include "../Common/simple_xml_writer.h" +#include "../../../DesktopEditor/common/File.h" +#include "../../../Common/DocxFormat/Source/XML/Utils.h" + +CVbaReader::CVbaReader(const std::wstring & vbaFileName, const std::wstring & vbaExtractFile) +{ + vbaExtractFile_ = vbaExtractFile; + + vbaProject_file_ = boost::shared_ptr(new CVbaFile(vbaFileName)); + + if (vbaProject_file_->isError()) return; +} +bool CVbaReader::convert() +{ + _UINT32 code_page_ = 0; + + CVbaFileStreamPtr strmPROJECT = vbaProject_file_->getNamedStream(L"PROJECT"); + + if (false == vbaProject_file_->isDirectory(L"VBA")) return false; + + CVbaFileStreamPtr strmDir = vbaProject_file_->getNamedStream(L"VBA/dir"); + VBA::DirStreamObjectPtr DirStreamObject = VBA::DirStreamObjectPtr(new VBA::DirStreamObject(strmDir)); + + if (false == DirStreamObject->loadContent()) return false; + + code_page_ = strmDir->CodePage; + + std::wstringstream strm; + + CP_XML_WRITER(strm) + { + CP_XML_NODE(L"Information") + { + if (DirStreamObject->InformationRecord->NameRecord) + CP_XML_ATTR(L"Name", DirStreamObject->InformationRecord->NameRecord->ProjectName.value); + + if (DirStreamObject->InformationRecord->LcidRecord) + CP_XML_ATTR(L"Lcid", DirStreamObject->InformationRecord->LcidRecord->Lcid); + + if (DirStreamObject->InformationRecord->ConstantsRecord) + CP_XML_ATTR(L"Constants", DirStreamObject->InformationRecord->ConstantsRecord->uConstants.value.empty() ? + DirStreamObject->InformationRecord->ConstantsRecord->aConstants.value : + DirStreamObject->InformationRecord->ConstantsRecord->uConstants.value); + + } + CP_XML_NODE(L"References") + { + for (size_t i = 0; i < DirStreamObject->ReferencesRecord->ReferenceArray.size(); ++i) + { + CP_XML_NODE(L"Reference") + { + if (DirStreamObject->ReferencesRecord->ReferenceArray[i]->NameRecord) + CP_XML_ATTR(L"Name", DirStreamObject->ReferencesRecord->ReferenceArray[i]->NameRecord->uName.value.empty() ? + DirStreamObject->ReferencesRecord->ReferenceArray[i]->NameRecord->aName.value : + DirStreamObject->ReferencesRecord->ReferenceArray[i]->NameRecord->uName.value); + + VBA::REFERENCEORIGINAL* original = dynamic_cast(DirStreamObject->ReferencesRecord->ReferenceArray[i]->ReferenceRecord.get()); + VBA::REFERENCECONTROL* control = dynamic_cast(DirStreamObject->ReferencesRecord->ReferenceArray[i]->ReferenceRecord.get()); + VBA::REFERENCEREGISTERED* registered = dynamic_cast(DirStreamObject->ReferencesRecord->ReferenceArray[i]->ReferenceRecord.get()); + VBA::REFERENCEPROJECT* project = dynamic_cast(DirStreamObject->ReferencesRecord->ReferenceArray[i]->ReferenceRecord.get()); + + if (original) + { + CP_XML_NODE(L"Original") + { + CP_XML_ATTR(L"val", original->LibidOriginal.value); + } + } + if (project) + { + CP_XML_NODE(L"Project") + { + if (!project->LibidAbsolute.value.empty()) + CP_XML_ATTR(L"LibidAbsolute", project->LibidAbsolute.value); + if (!project->LibidRelative.value.empty()) + CP_XML_ATTR(L"LibidRelative", project->LibidRelative.value); + } + } + if (control) + { + CP_XML_NODE(L"Control") + { + CP_XML_ATTR(L"TypeLib", VBA::guid2bstr(control->OriginalTypeLib)); + if (!control->LibidTwiddled.value.empty()) + CP_XML_ATTR(L"LibidTwiddled", control->LibidTwiddled.value); + if (!control->LibidExtended.value.empty()) + CP_XML_ATTR(L"LibidExtended", control->LibidExtended.value); + } + } + if (registered) + { + CP_XML_NODE(L"Registered") + { + CP_XML_ATTR(L"val", registered->Libid.value); + } + } + } + } + } + CP_XML_NODE(L"Modules") + { + for (size_t i = 0; i < DirStreamObject->ModulesRecord->modules.size(); ++i) + { + CP_XML_NODE(L"Module") + { + if (DirStreamObject->ModulesRecord->modules[i]->StreamNameRecord) + { + if (DirStreamObject->ModulesRecord->modules[i]->NameUnicodeRecord) + CP_XML_ATTR(L"Name", DirStreamObject->ModulesRecord->modules[i]->NameUnicodeRecord->ModuleNameUnicode.value); + else if (DirStreamObject->ModulesRecord->modules[i]->NameRecord) + CP_XML_ATTR(L"Name", DirStreamObject->ModulesRecord->modules[i]->NameRecord->ModuleName.value); + + CP_XML_ATTR(L"Type", DirStreamObject->ModulesRecord->modules[i]->bProceduralModule ? L"Procedural" : L"Class"); + CP_XML_ATTR(L"ReadOnly", DirStreamObject->ModulesRecord->modules[i]->bReadOnly); + CP_XML_ATTR(L"Private", DirStreamObject->ModulesRecord->modules[i]->bPrivate); + + std::wstring streamName = L"VBA/" + (DirStreamObject->ModulesRecord->modules[i]->StreamNameRecord->StreamNameUnicode.value.empty() ? + DirStreamObject->ModulesRecord->modules[i]->StreamNameRecord->StreamName.value : + DirStreamObject->ModulesRecord->modules[i]->StreamNameRecord->StreamNameUnicode.value); + + _UINT32 offset = DirStreamObject->ModulesRecord->modules[i]->OffsetRecord ? + DirStreamObject->ModulesRecord->modules[i]->OffsetRecord->TextOffset : 0;//skip cache + + CVbaFileStreamPtr strmModule = vbaProject_file_->getNamedStream(streamName, offset); + strmModule->CodePage = code_page_; + + VBA::ModuleStreamObjectPtr ModuleStreamObject = VBA::ModuleStreamObjectPtr(new VBA::ModuleStreamObject(strmModule)); + ModuleStreamObject->loadContent(); + CP_XML_NODE(L"SourceCode") + { + CP_XML_STREAM() << XmlUtils::EncodeXmlString(ModuleStreamObject->SourceCode); + } + } + } + } + } + } + + NSFile::CFileBinary file; + if (file.CreateFileW(vbaExtractFile_)) + { + std::string root = ""; + file.WriteFile((BYTE*)root.c_str(), (DWORD)root.length()); + + file.WriteStringUTF8(strm.str()); + file.CloseFile(); + + return true; + } + return false; +} + +CVbaReader::~CVbaReader() +{ + //if (vba_context) delete vba_context; + //if (output_document) delete output_document; +} diff --git a/ASCOfficeXlsFile2/source/VbaFormat/VbaReader.h b/ASCOfficeXlsFile2/source/VbaFormat/VbaReader.h new file mode 100644 index 0000000000..a17eb28c8f --- /dev/null +++ b/ASCOfficeXlsFile2/source/VbaFormat/VbaReader.h @@ -0,0 +1,20 @@ +#pragma once + +#include +#include + +class CVbaFile; +typedef boost::shared_ptr CVbaFilePtr; + +class CVbaReader +{ +public: + CVbaReader(const std::wstring & vbaFileName, const std::wstring & vbaExtractFile); + ~CVbaReader(); + + bool CVbaReader::convert(); +private: + std::wstring vbaExtractFile_; + CVbaFilePtr vbaProject_file_; +}; + diff --git a/ASCOfficeXlsFile2/source/VbaFormat/VbaRecordType.h b/ASCOfficeXlsFile2/source/VbaFormat/VbaRecordType.h new file mode 100644 index 0000000000..f05ff12dad --- /dev/null +++ b/ASCOfficeXlsFile2/source/VbaFormat/VbaRecordType.h @@ -0,0 +1,81 @@ +/* + * (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 + * + */ +#pragma once + +namespace VBA +{ + typedef enum CF_RECORD_TYPE + { + rt_PROJECTSYSKIND = 0x0001, + rt_PROJECTCOMPATVERSION = 0x004A, + rt_PROJECTLCID = 0x0002, + rt_PROJECTLCIDINVOKE = 0x0014, + rt_PROJECTCODEPAGE = 0x0003, + rt_PROJECTNAME = 0x0004, + rt_PROJECTDOCSTRING = 0x0005, + rt_PROJECTHELPFILEPATH = 0x0006, + rt_PROJECTHELPCONTEXT = 0x0007, + rt_PROJECTLIBFLAGS = 0x0008, + rt_PROJECTVERSION = 0x0009, + rt_PROJECTCONSTANTS = 0x000C, + rt_REFERENCENAME = 0x0016, + rt_REFERENCEORIGINAL = 0x0033, + rt_REFERENCEREGISTERED = 0x000D, + rt_REFERENCEPROJECT = 0x000E, + rt_REFERENCECONTROL = 0x002F, + rt_PROJECTMODULES = 0x000F, + rt_PROJECTCOOKIE = 0x0013, + rt_MODULENAME = 0x0019, + rt_MODULENAMEUNICODE = 0x0047, + rt_MODULESTREAMNAME = 0x001A, + rt_MODULEDOCSTRING = 0x001C, + rt_MODULEOFFSET = 0x0031, + rt_MODULEHELPCONTEXT = 0x001E, + rt_MODULECOOKIE = 0x002C, + rt_MODULETYPE_Procedural = 0x0021, + rt_MODULETYPE_Class = 0x0022, + rt_MODULEREADONLY = 0x0025, + rt_MODULEPRIVATE = 0x0028, + rt_Terminator = 0x002B, + rt_TerminatorStream = 0x0010, + + rt_PROJECTINFORMATION = 0xFF01, + rt_REFERENCE, + rt_MODULE, + rt_MODULETYPE, + rt_AnsiString, + rt_Utf16String, + + rt_Unknown = 0xffff + } RecordType; +} + diff --git a/ASCOfficeXlsFile2/source/XlsFormat/Binary/CFRecord.cpp b/ASCOfficeXlsFile2/source/XlsFormat/Binary/CFRecord.cpp index badad213dc..af74b566e2 100644 --- a/ASCOfficeXlsFile2/source/XlsFormat/Binary/CFRecord.cpp +++ b/ASCOfficeXlsFile2/source/XlsFormat/Binary/CFRecord.cpp @@ -54,7 +54,7 @@ CFRecord::CFRecord(CFStreamPtr stream, GlobalWorkbookInfoPtr global_info) unsigned long rec_data_pos = stream->getStreamPointer(); stream->read(data_, size_); - if(global_info->decryptor && 0 != size_) + if((global_info) && (global_info->decryptor) && (0 != size_)) { size_t block_size = global_info->Version == 0x0500 ? 16 : 1024; diff --git a/ASCOfficeXlsFile2/source/linux/VbaFormatLib.pro b/ASCOfficeXlsFile2/source/linux/VbaFormatLib.pro new file mode 100644 index 0000000000..007244c6ff --- /dev/null +++ b/ASCOfficeXlsFile2/source/linux/VbaFormatLib.pro @@ -0,0 +1,49 @@ +#------------------------------------------------- +# +# Project created by QtCreator 2014-12-16T18:28:23 +# +#------------------------------------------------- + +QT -= core gui + +TARGET = VbaFormatLib +TEMPLATE = lib +CONFIG += staticlib + +CORE_ROOT_DIR = $$PWD/../../.. +PWD_ROOT_DIR = $$PWD + +CONFIG += core_x2t +include(../../../Common/base.pri) + +#BOOST +include($$PWD/../../../Common/3dParty/boost/boost.pri) + +DEFINES += UNICODE \ + _UNICODE \ + DONT_WRITE_EMBEDDED_FONTS + +CONFIG(debug, debug|release){ + +message(Debug) +DEFINES += _DEBUG +} + +core_mac { +LIBS += $$DESTDIR -lUnicodeConverter +} + +SOURCES += \ + ../VbaFormat/Records.cpp \ + ../VbaFormat/StreamObjects.cpp \ + ../VbaFormat/VbaBinary.cpp \ + ../VbaFormat/VbaReader.cpp + + +HEADERS += \ + ../VbaFormat/Records.h \ + ../VbaFormat/StreamObjects.h \ + ../VbaFormat/VbaBinary.h \ + ../VbaFormat/VbaReader.h \ + ../VbaFormat/VbaRecordType.h + diff --git a/ASCOfficeXlsFile2/source/win32/VbaFormat.vcxproj b/ASCOfficeXlsFile2/source/win32/VbaFormat.vcxproj new file mode 100644 index 0000000000..34e7e65964 --- /dev/null +++ b/ASCOfficeXlsFile2/source/win32/VbaFormat.vcxproj @@ -0,0 +1,148 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + + + + + + + + + + + {041DD428-2D5C-4D97-8AB7-7207F3D5B801} + Win32Proj + VbaFormat + 8.1 + + + + StaticLibrary + true + v140 + Unicode + + + StaticLibrary + false + v140 + true + Unicode + + + StaticLibrary + true + v140 + Unicode + + + StaticLibrary + false + v140 + true + Unicode + + + + + + + + + + + + + + + + + + + + + ..\..\..\Common\3dParty\boost\build\win_32\include;$(VC_IncludePath);$(WindowsSDK_IncludePath); + ..\..\..\Common\3dParty\boost\build\win_32\lib;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + + + Windows + + + + + + + Level3 + Disabled + _DEBUG;_LIB;%(PreprocessorDefinitions) + + + Windows + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + + + Windows + true + true + + + + + Level3 + + + MaxSpeed + true + true + NDEBUG;_LIB;%(PreprocessorDefinitions) + + + Windows + true + true + + + + + + \ No newline at end of file diff --git a/ASCOfficeXlsFile2/source/win32/VbaFormat.vcxproj.filters b/ASCOfficeXlsFile2/source/win32/VbaFormat.vcxproj.filters new file mode 100644 index 0000000000..66e2ced36a --- /dev/null +++ b/ASCOfficeXlsFile2/source/win32/VbaFormat.vcxproj.filters @@ -0,0 +1,44 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/Common/OfficeFileFormatChecker.h b/Common/OfficeFileFormatChecker.h index c8798ff000..596c5a74af 100644 --- a/Common/OfficeFileFormatChecker.h +++ b/Common/OfficeFileFormatChecker.h @@ -59,7 +59,8 @@ public: } bool isOfficeFile(const std::wstring & fileName); - + bool isVbaProjectFile(const std::wstring & fileName); + std::wstring GetFormatExtension(const std::wstring & fileName); std::wstring GetExtensionByType(int type); static int GetFormatByExtension(const std::wstring& ext); @@ -73,6 +74,7 @@ public: bool isPptFormatFile (POLE::Storage *storage); bool isMS_OFFICECRYPTOFormatFile(POLE::Storage * storage, std::wstring & documentID); bool isMS_MITCRYPTOFormatFile(POLE::Storage * storage, std::wstring & documentID); + bool isVbaProjectFile(POLE::Storage * storage); bool isMS_OFFCRYPTOFormatFile (const std::wstring & fileName, std::wstring & documentID); std::wstring getDocumentID (const std::wstring & fileName); diff --git a/Common/OfficeFileFormatChecker2.cpp b/Common/OfficeFileFormatChecker2.cpp index fcacb1bab4..c6cfc0faf4 100644 --- a/Common/OfficeFileFormatChecker2.cpp +++ b/Common/OfficeFileFormatChecker2.cpp @@ -205,6 +205,28 @@ bool COfficeFileFormatChecker::isDocFormatFile (POLE::Storage * storage) return false; } +bool COfficeFileFormatChecker::isVbaProjectFile(POLE::Storage * storage) +{ + if (storage == NULL) return false; + + unsigned char buffer[10]; + + POLE::Stream stream(storage, L"PROJECT"); + if (stream.read(buffer, 10) < 1) + { + return false; + } + if (false == storage->isDirectory(L"VBA")) + { + return false; + } + POLE::Stream stream2(storage, L"VBA/dir"); + if (stream2.read(buffer, 10) < 1) + { + return false; + } + return true; +} bool COfficeFileFormatChecker::isXlsFormatFile (POLE::Storage * storage) { if (storage == NULL) return false; @@ -392,6 +414,24 @@ bool COfficeFileFormatChecker::isMS_MITCRYPTOFormatFile (POLE::Storage * storage return result; } +bool COfficeFileFormatChecker::isVbaProjectFile(const std::wstring & _fileName) +{ +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(_WIN64) + std::wstring fileName = CorrectPathW(_fileName); +#else + std::wstring fileName = _fileName; +#endif + POLE::Storage storage(fileName.c_str()); + if (storage.open()) + { + if (isVbaProjectFile(&storage)) + { + nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT; + return true; + } + } + return false; +} bool COfficeFileFormatChecker::isOfficeFile(const std::wstring & _fileName) { #if defined(_WIN32) || defined(_WIN32_WCE) || defined(_WIN64) @@ -441,6 +481,11 @@ bool COfficeFileFormatChecker::isOfficeFile(const std::wstring & _fileName) nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_MITCRYPTO; return true; } + else if (isVbaProjectFile(&storage)) + { + nFileType = AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT; + return true; + } } COfficeUtils OfficeUtils(NULL); diff --git a/Common/OfficeFileFormats.h b/Common/OfficeFileFormats.h index 0e3ec12006..db784aece1 100644 --- a/Common/OfficeFileFormats.h +++ b/Common/OfficeFileFormats.h @@ -122,6 +122,7 @@ #define AVS_OFFICESTUDIO_FILE_OTHER_ZIP AVS_OFFICESTUDIO_FILE_OTHER + 0x0009 #define AVS_OFFICESTUDIO_FILE_OTHER_ODF AVS_OFFICESTUDIO_FILE_OTHER + 0x000a #define AVS_OFFICESTUDIO_FILE_OTHER_MS_MITCRYPTO AVS_OFFICESTUDIO_FILE_OTHER + 0x000b +#define AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT AVS_OFFICESTUDIO_FILE_OTHER + 0x000c #define AVS_OFFICESTUDIO_FILE_TEAMLAB 0x1000 #define AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY AVS_OFFICESTUDIO_FILE_TEAMLAB + 0x0001 diff --git a/X2tConverter/build/Qt/X2tConverter.pri b/X2tConverter/build/Qt/X2tConverter.pri index 5cb96d9b7b..b76a715ebe 100755 --- a/X2tConverter/build/Qt/X2tConverter.pri +++ b/X2tConverter/build/Qt/X2tConverter.pri @@ -70,6 +70,8 @@ HEADERS += ../../src/cextracttools.h \ ../../src/ASCConverters.h +#vbaformat +LIBS += -L$$CORE_BUILDS_LIBRARIES_PATH -lVbaFormatLib #Xls file LIBS += -L$$CORE_BUILDS_LIBRARIES_PATH -lXlsFormatLib # odf format writer diff --git a/X2tConverter/build/Qt/X2tSLN.pri b/X2tConverter/build/Qt/X2tSLN.pri index 7d7beee5ec..fe27d481d8 100644 --- a/X2tConverter/build/Qt/X2tSLN.pri +++ b/X2tConverter/build/Qt/X2tSLN.pri @@ -7,6 +7,7 @@ include(../../../Common/base.pri) SUBDIRS = \ XlsbFormatLib \ + VbaFormatLib \ DocxFormatLib \ PPTXFormatLib \ ASCOfficeDocxFile2Lib \ @@ -35,6 +36,7 @@ DocFormatLib.file = ../../../ASCOfficeDocFile/DocFormatLib/Linux/DocFormatLib.pr OdfFileReaderLib.file = ../../../ASCOfficeOdfFile/linux/OdfFileReaderLib.pro OdfFileWriterLib.file = ../../../ASCOfficeOdfFileW/linux/OdfFileWriterLib.pro XlsFormatLib.file = ../../../ASCOfficeXlsFile2/source/linux/XlsFormatLib.pro +VbaFormatLib.file = ../../../ASCOfficeXlsFile2/source/linux/VbaFormatLib.pro HtmlFile2.file = ../../../HtmlFile2/HtmlFile2.pro EpubFile.file = ../../../EpubFile/CEpubFile.pro XpsFile.file = ../../../XpsFile/XpsFile.pro @@ -42,6 +44,7 @@ kernel.file = ../../../Common/kernel.pro doctrenderer.file = ../../../DesktopEditor/doctrenderer/doctrenderer.pro X2tConverter.depends = \ + VbaFormatLib \ XlsbFormatLib \ DocxFormatLib \ PPTXFormatLib \ diff --git a/X2tConverter/src/ASCConverters.cpp b/X2tConverter/src/ASCConverters.cpp index 7c56a72b0c..88e446573f 100644 --- a/X2tConverter/src/ASCConverters.cpp +++ b/X2tConverter/src/ASCConverters.cpp @@ -60,6 +60,7 @@ #include "../../HtmlFile2/htmlfile2.h" #include "../../EpubFile/CEpubFile.h" #include "../../ASCOfficeXlsFile2/source/XlsXlsxConverter/ConvertXls2Xlsx.h" +#include "../../ASCOfficeXlsFile2/source/VbaFormat/VbaReader.h" #include "../../OfficeCryptReader/source/ECMACryptFile.h" #include "../../XlsxSerializerCom/Reader/CSVReader.h" @@ -3215,7 +3216,15 @@ namespace NExtractTools //todo return AVS_FILEUTILS_ERROR_CONVERT_DRM_UNSUPPORTED; } + _UINT32 msVbaProject2Xml(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params) + { + CVbaReader vbaReader(sFrom, sTo); + if (false == vbaReader.convert()) + return AVS_FILEUTILS_ERROR_CONVERT; + + return 0; + } _UINT32 oox2mscrypt (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params) { std::wstring password = params.getSavePassword(); @@ -5409,6 +5418,10 @@ namespace NExtractTools { result = fb2docx (sFileFrom, sFileTo, sTempDir, oInputParams); }break; + case TCD_VBAPROJECT2XML: + { + result = msVbaProject2Xml(sFileFrom, sFileTo, sTempDir, oInputParams); + }break; //TCD_FB22DOCT, //TCD_FB22DOCT_BIN, diff --git a/X2tConverter/src/ASCConverters.h b/X2tConverter/src/ASCConverters.h index 04db092a41..4145fe81b6 100644 --- a/X2tConverter/src/ASCConverters.h +++ b/X2tConverter/src/ASCConverters.h @@ -195,6 +195,8 @@ namespace NExtractTools _UINT32 oox2mscrypt (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params); + _UINT32 msVbaProject2dir(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params); + _UINT32 html2doct_bin (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params); _UINT32 html2doct (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params); _UINT32 html2docx (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params); diff --git a/X2tConverter/src/cextracttools.cpp b/X2tConverter/src/cextracttools.cpp index 0135e8c95b..32c7783885 100644 --- a/X2tConverter/src/cextracttools.cpp +++ b/X2tConverter/src/cextracttools.cpp @@ -87,7 +87,6 @@ namespace NExtractTools } else { - // zip -> dir return TCD_UNZIPDIR; } } @@ -347,12 +346,16 @@ namespace NExtractTools 0 == sExt2.compare(_T(".xlsm")) || 0 == sExt2.compare(_T(".pptm"))) res = TCD_ODF_FLAT2OOX; }break; + case AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT: + { + res = TCD_VBAPROJECT2XML; + }break; case AVS_OFFICESTUDIO_FILE_OTHER_MS_OFFCRYPTO: { - if (0 == sExt2.compare(_T(".doct"))) res = TCD_MSCRYPT2DOCT; - else if (0 == sExt2.compare(_T(".xlst"))) res = TCD_MSCRYPT2XLST; - else if (0 == sExt2.compare(_T(".pptt"))) res = TCD_MSCRYPT2PPTT; - else if (0 == sExt2.compare(_T(".bin"))) res = TCD_MSCRYPT2BIN; + if (0 == sExt2.compare(_T(".doct"))) res = TCD_MSCRYPT2DOCT; + else if (0 == sExt2.compare(_T(".xlst"))) res = TCD_MSCRYPT2XLST; + else if (0 == sExt2.compare(_T(".pptt"))) res = TCD_MSCRYPT2PPTT; + else if (0 == sExt2.compare(_T(".bin"))) res = TCD_MSCRYPT2BIN; }break; case AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML_IN_CONTAINER: { diff --git a/X2tConverter/src/cextracttools.h b/X2tConverter/src/cextracttools.h index 59e4a0c8ed..e610a3b9df 100644 --- a/X2tConverter/src/cextracttools.h +++ b/X2tConverter/src/cextracttools.h @@ -196,6 +196,8 @@ namespace NExtractTools TCD_MITCRYPT2, + TCD_VBAPROJECT2XML, + // TCD_HTML2DOCX, TCD_HTML2DOCT, @@ -927,7 +929,9 @@ namespace NExtractTools eRes = TCD_MITCRYPT2; else if(AVS_OFFICESTUDIO_FILE_OTHER_ZIP == nFormatFrom && AVS_OFFICESTUDIO_FILE_UNKNOWN == nFormatTo) eRes = TCD_UNZIPDIR; - else if(AVS_OFFICESTUDIO_FILE_UNKNOWN == nFormatFrom && AVS_OFFICESTUDIO_FILE_OTHER_ZIP == nFormatTo) + else if (AVS_OFFICESTUDIO_FILE_OTHER_MS_VBAPROJECT == nFormatFrom && AVS_OFFICESTUDIO_FILE_UNKNOWN == nFormatTo) + eRes = TCD_VBAPROJECT2XML; + else if(AVS_OFFICESTUDIO_FILE_UNKNOWN == nFormatFrom && AVS_OFFICESTUDIO_FILE_OTHER_ZIP == nFormatTo) eRes = TCD_ZIPDIR; } else diff --git a/X2tConverter/test/win32Test/X2tConverter_win_test.sln b/X2tConverter/test/win32Test/X2tConverter_win_test.sln index 5acef1743b..18122d8b73 100644 --- a/X2tConverter/test/win32Test/X2tConverter_win_test.sln +++ b/X2tConverter/test/win32Test/X2tConverter_win_test.sln @@ -39,6 +39,10 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cryptlib", "..\..\..\Common EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "XlsbFormatLib", "..\..\..\Common\DocxFormat\Projects\XlsbFormatLib.vcxproj", "{13E13907-49DA-482E-AD58-026D06A5CD11}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{7C53A1E0-F93F-4E32-88B5-6274AF921ABE}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VbaFormat", "..\..\..\ASCOfficeXlsFile2\source\win32\VbaFormat.vcxproj", "{041DD428-2D5C-4D97-8AB7-7207F3D5B801}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 @@ -410,6 +414,26 @@ Global {13E13907-49DA-482E-AD58-026D06A5CD11}.ReleaseOpenSource|Win32.Build.0 = Release|Win32 {13E13907-49DA-482E-AD58-026D06A5CD11}.ReleaseOpenSource|x64.ActiveCfg = Release|x64 {13E13907-49DA-482E-AD58-026D06A5CD11}.ReleaseOpenSource|x64.Build.0 = Release|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.Debug|Win32.ActiveCfg = Debug|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.Debug|Win32.Build.0 = Debug|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.Debug|x64.ActiveCfg = Debug|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.Debug|x64.Build.0 = Debug|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.DLL-Import Debug|Win32.ActiveCfg = Debug|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.DLL-Import Debug|Win32.Build.0 = Debug|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.DLL-Import Debug|x64.ActiveCfg = Debug|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.DLL-Import Debug|x64.Build.0 = Debug|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.DLL-Import Release|Win32.ActiveCfg = Release|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.DLL-Import Release|Win32.Build.0 = Release|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.DLL-Import Release|x64.ActiveCfg = Release|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.DLL-Import Release|x64.Build.0 = Release|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.Release|Win32.ActiveCfg = Release|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.Release|Win32.Build.0 = Release|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.Release|x64.ActiveCfg = Release|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.Release|x64.Build.0 = Release|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.ReleaseOpenSource|Win32.ActiveCfg = Release|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.ReleaseOpenSource|Win32.Build.0 = Release|Win32 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.ReleaseOpenSource|x64.ActiveCfg = Release|x64 + {041DD428-2D5C-4D97-8AB7-7207F3D5B801}.ReleaseOpenSource|x64.Build.0 = Release|x64 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/X2tConverter/test/win32Test/X2tTest.vcxproj b/X2tConverter/test/win32Test/X2tTest.vcxproj index 0446ce6820..883c110860 100644 --- a/X2tConverter/test/win32Test/X2tTest.vcxproj +++ b/X2tConverter/test/win32Test/X2tTest.vcxproj @@ -317,6 +317,9 @@ {dacbe6ca-e089-47d1-8ce7-c7db59c15417} + + {041dd428-2d5c-4d97-8ab7-7207f3d5b801} + {77ddc8d7-5b12-4ff2-9629-26aebca8436d}