285 lines
7.1 KiB
C++
285 lines
7.1 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* 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-6 Ernesta Birznieka-Upish
|
|
* 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 "VirtualStreamReader.h"
|
|
#include "WideString.h"
|
|
#include "IVisitable.h"
|
|
|
|
#include "../Common/Base/FormatUtils.h"
|
|
|
|
namespace DocFileFormat
|
|
{
|
|
template<class T> class StringTableEx;
|
|
|
|
template<class T> class StringTable: public IVisitable
|
|
{
|
|
public:
|
|
bool fExtend = false;
|
|
int cbData = 0;
|
|
unsigned short cbExtra = 0;
|
|
int code_page = 1250;
|
|
|
|
std::vector<ByteStructure*> Data;
|
|
std::vector<unsigned char*> DataExtra;
|
|
|
|
StringTable()
|
|
{
|
|
}
|
|
virtual ~StringTable()
|
|
{
|
|
for ( size_t i = 0; i < Data.size(); ++i )
|
|
{
|
|
RELEASEOBJECT( Data[i] );
|
|
}
|
|
for (size_t i = 0; i < DataExtra.size(); ++i)
|
|
{
|
|
RELEASEOBJECT(DataExtra[i]);
|
|
}
|
|
}
|
|
StringTable( VirtualStreamReader *reader, int code_page_ )
|
|
{
|
|
code_page = code_page_;
|
|
parse( reader, (unsigned int)reader->GetPosition(), 0, false );
|
|
}
|
|
StringTable( POLE::Stream* tableStream, unsigned int fc, unsigned int lcb, int nWordVersion, bool bReadExta = false)
|
|
{
|
|
if ( lcb > 0 )
|
|
{
|
|
VirtualStreamReader reader( tableStream, fc, nWordVersion);
|
|
|
|
parse( &reader, fc, lcb, bReadExta ) ;
|
|
}
|
|
}
|
|
std::vector<unsigned char*> & getDataExtra() {return DataExtra;}
|
|
unsigned short getDataExtraSize() {return cbExtra;}
|
|
|
|
ByteStructure* operator [] ( size_t index ) const
|
|
{
|
|
if ( index < Data.size() )
|
|
{
|
|
return Data.at( index );
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
private:
|
|
|
|
virtual void parse( VirtualStreamReader *reader, unsigned int fc, unsigned int lcb = 0, bool bReadExta = false )
|
|
{
|
|
if ( reader == NULL ) return;
|
|
if (fc > reader->GetSize()) return;
|
|
|
|
cbData = lcb;
|
|
|
|
int count_elements = 0;
|
|
|
|
if ( reader->ReadUInt16() == 0xFFFF )
|
|
{
|
|
//if the first 2 bytes are 0xFFFF the STTB contains unicode characters
|
|
fExtend = true;
|
|
code_page = ENCODING_UTF16;
|
|
}
|
|
else
|
|
{
|
|
//else the STTB contains 1byte characters and the fExtend field is non-existend
|
|
//seek back to the beginning
|
|
fExtend = false;
|
|
code_page = ENCODING_WINDOWS_1250;
|
|
|
|
reader->Seek( (int)fc, 0/*STREAM_SEEK_SET*/ );
|
|
}
|
|
|
|
long cDataStart = reader->GetPosition();
|
|
unsigned short cb = 0, elem_sz = 0;
|
|
|
|
if (reader->nWordVersion > 0)
|
|
{
|
|
cb = reader->ReadUInt16();
|
|
cbData = cb; // all size
|
|
}
|
|
else if (reader->nWordVersion == 0)
|
|
{
|
|
cb = reader->ReadUInt16();
|
|
if ( cb != 0xFFFF )
|
|
{
|
|
count_elements = cb;
|
|
}
|
|
else
|
|
{
|
|
reader->Seek( (int)( fc + cDataStart ), 0/*STREAM_SEEK_SET*/ );
|
|
cbData = reader->ReadInt32();
|
|
}
|
|
}
|
|
|
|
if (reader->nWordVersion == 0)
|
|
{
|
|
cbExtra = reader->ReadUInt16();
|
|
}
|
|
|
|
while (true)
|
|
{
|
|
if (reader->GetPosition() >= fc + cbData + cbExtra && count_elements < 1)
|
|
break; //1995 and older
|
|
|
|
if (Data.size() == count_elements && count_elements > 0)
|
|
break; //1997 and newer
|
|
|
|
int cchData = 0;
|
|
int cbData = 0;
|
|
|
|
if ( fExtend )
|
|
{
|
|
cchData = (int)reader->ReadUInt16();
|
|
cbData = cchData * 2;
|
|
}
|
|
else
|
|
{
|
|
cchData = (int)reader->ReadByte();
|
|
cbData = cchData;
|
|
}
|
|
|
|
long posBeforeType = reader->GetPosition();
|
|
|
|
Data.push_back( T().ConstructObject( reader, cbData ) );
|
|
|
|
reader->Seek( (int)( posBeforeType + cbData ), 0/*STREAM_SEEK_SET */);
|
|
|
|
if (bReadExta)
|
|
{
|
|
unsigned char* pData = reader->ReadBytes( cbExtra, true );
|
|
DataExtra.push_back(pData);
|
|
}
|
|
else
|
|
{
|
|
reader->ReadBytes( cbExtra, false );
|
|
}
|
|
}
|
|
}
|
|
};
|
|
template<class T> class StringTableEx : public StringTable<T>
|
|
{
|
|
public:
|
|
StringTableEx(VirtualStreamReader *reader, int code_page_)
|
|
{
|
|
StringTable<T>::code_page = code_page_;
|
|
parse(reader, (unsigned int)reader->GetPosition(), 0, true);
|
|
}
|
|
|
|
StringTableEx(POLE::Stream* tableStream, unsigned int fc, unsigned int lcb, int nWordVersion)
|
|
{
|
|
if (lcb > 0)
|
|
{
|
|
VirtualStreamReader reader(tableStream, fc, nWordVersion);
|
|
|
|
parse(&reader, fc, lcb, true);
|
|
}
|
|
}
|
|
private:
|
|
virtual void parse(VirtualStreamReader *reader, unsigned int fc, unsigned int lcb = 0, bool bReadExta = false)
|
|
{
|
|
if (reader == NULL) return;
|
|
if (fc > reader->GetSize()) return;
|
|
|
|
if (reader->ReadUInt16() == 0xFFFF)
|
|
{
|
|
StringTable<T>::fExtend = true;
|
|
StringTable<T>::code_page = ENCODING_UTF16;
|
|
}
|
|
else
|
|
{
|
|
StringTable<T>::fExtend = false;
|
|
StringTable<T>::code_page = ENCODING_WINDOWS_1250;
|
|
}
|
|
|
|
_UINT32 cDataStart = reader->GetPosition(), count_elements = 0;
|
|
_UINT32 cb = 0, elem_sz = 0;
|
|
|
|
cb = reader->ReadUInt32();
|
|
if (cb != 0xFFFF)
|
|
{
|
|
count_elements = cb;
|
|
StringTable<T>::cbData = 0;
|
|
}
|
|
else
|
|
{
|
|
StringTable<T>::cbData = cb;
|
|
}
|
|
|
|
StringTable<T>::cbExtra = reader->ReadUInt16();
|
|
|
|
while (true)
|
|
{
|
|
if (reader->GetPosition() >= fc + lcb)
|
|
break;
|
|
|
|
int cchData = 0;
|
|
|
|
if (StringTable<T>::fExtend)
|
|
{
|
|
cchData = (int)reader->ReadUInt16();
|
|
if (cchData > 0) cchData -= 2; //??? cchData (2 bytes): This value MUST be 0
|
|
}
|
|
else
|
|
{
|
|
cchData = (int)reader->ReadByte(); //??
|
|
}
|
|
|
|
if (cchData > 0)
|
|
{
|
|
ByteStructure* object = T().ConstructObject(reader, cchData);
|
|
StringTable<T>::Data.push_back(object);
|
|
|
|
if (bReadExta)
|
|
{
|
|
unsigned char* pData = reader->ReadBytes(StringTable<T>::cbExtra, true);
|
|
StringTable<T>::DataExtra.push_back(pData);
|
|
}
|
|
else
|
|
{
|
|
reader->ReadBytes(StringTable<T>::cbExtra, false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ByteStructure* object = T().ConstructObject(reader, StringTable<T>::cbExtra);
|
|
StringTable<T>::Data.push_back(object);
|
|
}
|
|
}
|
|
reader->Seek((int)(fc + lcb), 0/*STREAM_SEEK_SET */);
|
|
}
|
|
};
|
|
}
|