Skip to content

O
onlyoffice_core
Commit e0485b85 authored by Elen.Subbotina's avatar Elen.Subbotina Committed by Alexander Trofimov
Browse files
Options

удаление старого неиспользуемого кода XlsFile 

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@65765 954022d7-b5bf-4e40-9824-e11837661b57
parent 8013237e
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 60296 deletions

Too many changes to show.
Plain diff Email patch

To preserve performance only 1000 of 1000+ files are displayed.

.gitattributes
View file @ e0485b85
......@@ -141,14 +141,6 @@ ASCOfficeUtils/ZLIB/zlib123dll/dll32/zlib_bor.lib svn_mime_002dtype=application%
ASCOfficeUtils/ZLIB/zlib123dll/dll32/zlibwapi.dll svn_mime_002dtype=application%2Foctet-stream
ASCOfficeUtils/ZLIB/zlib123dll/dll32/zlibwapi.lib svn_mime_002dtype=application%2Foctet-stream
ASCOfficeUtils/ZLIB/zlib123dll/static32/zlibstat.lib svn_mime_002dtype=application%2Foctet-stream
ASCOfficeXlsFile/ASCWorksheetConverter/Documents/22_04_09[!!-~]Презентация/xls-xlsx.odp svn_mime_002dtype=application%2Foctet-stream
ASCOfficeXlsFile/ASCWorksheetConverter/Documents/22_04_09[!!-~]Презентация/xls-xlsx_short.odp svn_mime_002dtype=application%2Foctet-stream
ASCOfficeXlsFile/ASCWorksheetConverter/Documents/22_04_09[!!-~]Презентация/Презентация[!!-~]конвертера[!!-~]XLSX.doc svn_mime_002dtype=application%2Foctet-stream
ASCOfficeXlsFile/ASCWorksheetConverter/Documents/Сводная[!!-~]таблица[!!-~]функциональности.xls svn_mime_002dtype=application%2Foctet-stream
ASCOfficeXlsFile/ASCWorksheetConverter/Documents/Сводная[!!-~]таблица[!!-~]функциональности_v1.2.xls svn_mime_002dtype=application%2Foctet-stream
ASCOfficeXlsFile/ASCWorksheetConverter/source/Streams_binaries/DocumentSummaryInformation.bin svn_mime_002dtype=application%2Foctet-stream
ASCOfficeXlsFile/ASCWorksheetConverter/source/Streams_binaries/SummaryInformation.bin svn_mime_002dtype=application%2Foctet-stream
ASCOfficeXlsFile/ASCWorksheetConverter/source/XLS_logic/Biff_structures/ODRAW svnc_bugtraq_003anumber=true
/ASCOfficeXlsFile2 svnc_tsvn_003alogminsize=5
ASCOfficeXlsFile2/ASCOfficeXlsFileTest svnc_tsvn_003alogminsize=5
ASCOfficeXlsFile2/ASCOfficeXlsFileTest/Guideline.docx svn_mime_002dtype=application%2Foctet-stream
ASCOfficeXlsFile/ASCOfficeXlsFile.sln deleted 100644 → 0
View file @ 8013237e

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ASCOfficeXlsFile", "ASCXlsFile\ASCXlsFile.vcproj", "{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}"
ProjectSection(ProjectDependencies) = postProject
{210CA046-BD12-4711-95E6-AF4F35AB3E61} = {210CA046-BD12-4711-95E6-AF4F35AB3E61}
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EWSCore", "ASCWorksheetConverter\source\main\EWSCore.vcproj", "{210CA046-BD12-4711-95E6-AF4F35AB3E61}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Debug|Win32.ActiveCfg = Debug|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Debug|Win32.Build.0 = Debug|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Release|Win32.ActiveCfg = Release|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Release|Win32.Build.0 = Release|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Debug|Win32.ActiveCfg = Debug|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Debug|Win32.Build.0 = Debug|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Release|Win32.ActiveCfg = Release|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
ASCOfficeXlsFile/ASCOfficeXlsFile_2005.sln deleted 100644 → 0
View file @ 8013237e

Microsoft Visual Studio Solution File, Format Version 9.00
# Visual Studio 2005
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ASCOfficeXlsFile", "ASCXlsFile\ASCXlsFile_2005.vcproj", "{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}"
ProjectSection(ProjectDependencies) = postProject
{210CA046-BD12-4711-95E6-AF4F35AB3E61} = {210CA046-BD12-4711-95E6-AF4F35AB3E61}
EndProjectSection
ProjectSection(WebsiteProperties) = preProject
Debug.AspNetCompiler.Debug = "True"
Release.AspNetCompiler.Debug = "False"
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EWSCore", "ASCWorksheetConverter\source\main\EWSCore_2005.vcproj", "{210CA046-BD12-4711-95E6-AF4F35AB3E61}"
ProjectSection(WebsiteProperties) = preProject
Debug.AspNetCompiler.Debug = "True"
Release.AspNetCompiler.Debug = "False"
EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ASCOfficeXlsFileTest", "ASCOfficeXlsFileTest\ASCOfficeXlsFileTest.vcproj", "{C2882DDD-07E6-4314-AD4B-48F43F38D722}"
ProjectSection(ProjectDependencies) = postProject
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D} = {E83B5FA5-ACDD-46F5-8E35-B19F398C806D}
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Debug|x64 = Debug|x64
Release|Win32 = Release|Win32
Release|x64 = Release|x64
ReleaseASC|Win32 = ReleaseASC|Win32
ReleaseASC|x64 = ReleaseASC|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Debug|Win32.ActiveCfg = Debug|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Debug|Win32.Build.0 = Debug|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Debug|x64.ActiveCfg = Debug|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Release|Win32.ActiveCfg = Release|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Release|Win32.Build.0 = Release|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.Release|x64.ActiveCfg = Release|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.ReleaseASC|Win32.ActiveCfg = ReleaseASC|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.ReleaseASC|Win32.Build.0 = ReleaseASC|Win32
{E83B5FA5-ACDD-46F5-8E35-B19F398C806D}.ReleaseASC|x64.ActiveCfg = ReleaseASC|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Debug|Win32.ActiveCfg = Debug|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Debug|Win32.Build.0 = Debug|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Debug|x64.ActiveCfg = Debug|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Release|Win32.ActiveCfg = Release|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Release|Win32.Build.0 = Release|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.Release|x64.ActiveCfg = Release|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.ReleaseASC|Win32.ActiveCfg = ReleaseASC|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.ReleaseASC|Win32.Build.0 = ReleaseASC|Win32
{210CA046-BD12-4711-95E6-AF4F35AB3E61}.ReleaseASC|x64.ActiveCfg = ReleaseASC|Win32
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.Debug|Win32.ActiveCfg = Debug|Win32
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.Debug|Win32.Build.0 = Debug|Win32
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.Debug|x64.ActiveCfg = Debug|x64
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.Debug|x64.Build.0 = Debug|x64
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.Release|Win32.ActiveCfg = Release|Win32
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.Release|Win32.Build.0 = Release|Win32
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.Release|x64.ActiveCfg = Release|x64
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.Release|x64.Build.0 = Release|x64
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.ReleaseASC|Win32.ActiveCfg = Release|x64
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.ReleaseASC|x64.ActiveCfg = Release|x64
{C2882DDD-07E6-4314-AD4B-48F43F38D722}.ReleaseASC|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/gen_AttribImportBiffStub.pl deleted 100644 → 0
View file @ 8013237e
#!/usr/bin/perl -w
# diffs two files and writes an HTML output file.
use strict;
use CGI qw(:standard :html3);
# MAIN PROGRAM
# Check for two arguments.
print "usage: $0 tag_name \n" if @ARGV != 1;
my $cpp_file = "$ARGV[0].cpp";
my $h_file = "$ARGV[0].h";
my $tag_name = $ARGV[0];
################################# CPP #####################################
open FCPP, ">$cpp_file";
print FCPP <<CPP_L1;
#include "stdafx.h"
#include "${tag_name}.h"
namespace XLS
{;
${tag_name}::${tag_name}(MSXML2::IXMLDOMDocument2Ptr xml_doc, MSXML2::IXMLDOMElementPtr parent)
: AttribImportBiffRecord(xml_doc, parent)
{
}
${tag_name}::~${tag_name}()
{
}
void ${tag_name}::readFields(CFRecordPtr record)
{
//*record >> some_value;
}
} // namespace XLS
CPP_L1
close FCPP;
################################### header #############################################
open FH, ">$h_file";
print FH <<H_L1;
#pragma once
#include "AttribImportBiffRecord.h"
namespace XLS
{;
// Logical representation of ${tag_name} record in BIFF8
class ${tag_name}: public AttribImportBiffRecord
{
// BIFF_RECORD_DEFINE_TYPE_INFO(${tag_name})
public:
${tag_name}(MSXML2::IXMLDOMDocument2Ptr xmlDoc, MSXML2::IXMLDOMElementPtr parent);
~${tag_name}();
void readFields(CFRecordPtr record);
public:
BO_ATTRIB_MARKUP_BEGIN
BO_ATTRIB_MARKUP_END
};
} // namespace XLS
H_L1
close FH;
exit(0);
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/gen_BiffStub.pl deleted 100644 → 0
View file @ 8013237e
#!/usr/bin/perl -w
# diffs two files and writes an HTML output file.
use strict;
use CGI qw(:standard :html3);
# MAIN PROGRAM
main();
exit 0;
sub main
{
# Check for two arguments.
print "usage: $0 tag_name [tag_name]\n" if @ARGV < 1;
for(my $i = 0; $i < @ARGV; $i++)
{
generateClass($ARGV[$i]);
}
}
sub generateClass
{
my $tag_name = $_[0];
$tag_name =~ s/[\[\]\(\)*\\\/]//g;
$tag_name =~ s/\d*(.+)/${1}/g;
return unless $tag_name; # if the tag absent
#print "$tag_name \n";
#return;
my $cpp_file = "${tag_name}.cpp";
my $h_file = "${tag_name}.h";
################################# CPP #####################################
open FCPP, ">$cpp_file";
print FCPP <<CPP_L1;
#include "stdafx.h"
#include "${tag_name}.h"
namespace XLS
{;
${tag_name}::${tag_name}(MSXML2::IXMLDOMDocument2Ptr xml_doc, MSXML2::IXMLDOMElementPtr parent)
: BiffRecord(xml_doc, parent)
{
}
${tag_name}::~${tag_name}()
{
}
BaseObjectPtr ${tag_name}::clone()
{
return BaseObjectPtr(new ${tag_name}(*this));
}
void ${tag_name}::readFields(CFRecord& record)
{
#pragma message("####################### ${tag_name} record is not implemented")
std::cout << " Error!!! ${tag_name} record is not implemented." << std::endl;
//record >> some_value;
}
/*
bool ${tag_name}::loadContent(MSXML2::IXMLDOMElementPtr own_tag, CFStreamCacheReader& reader)
{
cell.toXML(xml_doc_, own_tag);
return true;
}
*/
} // namespace XLS
CPP_L1
close FCPP;
################################### header #############################################
open FH, ">$h_file";
print FH <<H_L1;
#pragma once
#include "BiffRecord.h"
namespace XLS
{;
// Logical representation of ${tag_name} record in BIFF8
class ${tag_name}: public BiffRecord
{
// BIFF_RECORD_DEFINE_TYPE_INFO(${tag_name})
public:
${tag_name}(MSXML2::IXMLDOMDocument2Ptr xmlDoc, MSXML2::IXMLDOMElementPtr parent);
~${tag_name}();
BaseObjectPtr clone();
void readFields(CFRecord& record);
//bool loadContent(MSXML2::IXMLDOMElementPtr own_tag, CFStreamCacheReader& reader);
private:
// WORD userName;
public:
BO_ATTRIB_MARKUP_BEGIN
// BO_ATTRIB_MARKUP_ATTRIB(userName)
BO_ATTRIB_MARKUP_END
};
} // namespace XLS
H_L1
close FH;
system "move /-Y $h_file D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_records\\${h_file}";
system "move /-Y $cpp_file D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_records\\${cpp_file}";
system "svn add D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_records\\${tag_name}.*";
#system "devenv.exe /command \"File.AddExistingItem \"D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_records\\${tag_name}.h\"\""
}
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/gen_BitParsingCode.pl deleted 100644 → 0
View file @ 8013237e
#!/usr/bin/perl -w
# diffs two files and writes an HTML output file.
use strict;
use CGI qw(:standard :html3);
use Win32::Clipboard;
# MAIN PROGRAM
my $include = "";
my @names = ();
my $i = 0x1c;
main();
exit 0;
sub main
{
# Check for two arguments.
print "usage: $0 file_name\n" if @ARGV != 1;
generateClass($ARGV[0]);
print $include;
my $CLIP = Win32::Clipboard();
$CLIP->Set($include);
}
sub generateClass
{
my $file_name = $_[0];
open FH, $file_name;
my $i = 0;
my $setbit_inc = '';
while (<FH>)
{
while(/([A-Za-z] - )?([A-Za-z0-9_-]+) \((\d+) bits*\):(.*)/)
{
my $name = $2;
my $bits = $3;
my $the_rest = $4;
$_ = $the_rest;
$include .= "\t${name} = ";
$include .= ($bits > 1) ? "GETBITS" : "GETBIT";
$include .= "(flags, $i";
$setbit_inc .= "\t";
$setbit_inc .= ($bits > 1) ? "SETBITS" : "SETBIT";
$setbit_inc .= "(flags, $i, ";
$i += $bits - 1;
$include .= ($bits > 1) ? ", $i);\n" : ");\n";
$setbit_inc .= ($bits > 1) ? "$i, " : "";
$setbit_inc .= "${name});\n";
$i++;
push(@names, "$name($bits)");
}
}
$include .= "\n" . $setbit_inc;
$include .= "\n\n";
foreach my $iname (@names)
{
$iname =~ /(.+)\((\d+)\)/;
$include .= "\t";
if($2 == 1)
{
$include .= 'bool';
}
elsif($2 <= 8)
{
$include .= 'BYTE';
}
elsif($2 <= 16)
{
$include .= 'WORD';
}
else
{
$include .= 'DWORD';
}
$include .= " $1;\n";
}
$include .= "\n\n";
foreach my $iname (@names)
{
$iname =~ /(.+)\((\d+)\)/;
$include .= "\t own_tag->setAttribute(L\"$1\", $1);\n";
}
$include .= "\n\n";
foreach my $iname (@names)
{
$iname =~ /(.+)\((\d+)\)/;
$include .= "\t $1 = getStructAttribute(own_tag, L\"$1\");\n";
}
$include .= "\n\n";
foreach my $iname (@names)
{
$iname =~ /(.+)\((\d+)\)/;
$include .= "\t\tBO_ATTRIB_MARKUP_ATTRIB($1)\n";
}
}
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/gen_CompositeInclude.pl deleted 100644 → 0
View file @ 8013237e
#!/usr/bin/perl -w
# diffs two files and writes an HTML output file.
use strict;
use CGI qw(:standard :html3);
use Win32::Clipboard;
# MAIN PROGRAM
my $include = "";
my %tags = ();
my $i = 0x1c;
main();
exit 0;
sub main
{
# Check for two arguments.
print "usage: $0 tag_name [tag_name]\n" if @ARGV < 1;
for(my $i = 0; $i < @ARGV; $i++)
{
generateClass($ARGV[$i]);
}
print $include;
my $CLIP = Win32::Clipboard();
$CLIP->Set($include);
}
sub generateClass
{
my $tag_name = $_[0];
$tag_name =~ s/[\[\]\(\)*\\\/]//g;
$tag_name =~ s/\d*(.+)/${1}/g;
return unless $tag_name; # if the tag absent
return if $tags{$tag_name};
if($tag_name =~/^[A-Z0-9]+$/)
{
# $include .= "#include <XLS_logic/Biff_unions/${tag_name}.h>\n";
}
else
{
# $include .= "#include <XLS_logic/Biff_records/${tag_name}.h>\n";
}
# $include .= "#include \"${tag_name}.h\"\n";
# my $ii;
# $ii = sprintf("%02X", $i++);
# $include .= "\t\tcase 0x" . $ii . ":\n\t\t\tptg_record.reset(new ${tag_name}(record));\n\t\t\tbreak;\n";
$include .= "\t\tcase 0x0060:\n\t\t\tptg_records.push_back(boost::shared_ptr<${tag_name}>(new ${tag_name}(record)));\n\t\t\tbreak;\n";
#$tags{$tag_name} = "p";
}
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/gen_CompositeStub.pl deleted 100644 → 0
View file @ 8013237e
#!/usr/bin/perl -w
# diffs two files and writes an HTML output file.
use strict;
use CGI qw(:standard :html3);
# MAIN PROGRAM
main();
exit 0;
sub main
{
# Check for two arguments.
print "usage: $0 tag_name [tag_name]\n" if @ARGV < 1;
for(my $i = 0; $i < @ARGV; $i++)
{
generateClass($ARGV[$i]);
}
}
sub generateClass
{
my $tag_name = $_[0];
$tag_name =~ s/[\[\]\(\)*\\\/]//g;
$tag_name =~ s/\d*(.+)/${1}/g;
return unless $tag_name; # if the tag absent
#print "$tag_name \n";
#return;
my $cpp_file = "$tag_name.cpp";
my $h_file = "$tag_name.h";
################################# CPP #####################################
open FCPP, ">$cpp_file";
print FCPP <<CPP_L1;
#include "stdafx.h"
#include "${tag_name}.h"
//#include <XLS_logic/Biff_records/InterfaceHdr.h>
//#include <XLS_logic/Biff_unions/PAGESETUP.h>
namespace XLS
{;
${tag_name}::${tag_name}(MSXML2::IXMLDOMDocument2Ptr xml_doc, MSXML2::IXMLDOMElementPtr parent)
: CompositeObject(xml_doc, parent)
{
}
${tag_name}::~${tag_name}()
{
}
// ${tag_name} =
const bool ${tag_name}::loadContent(MSXML2::IXMLDOMElementPtr own_tag, CFStreamCacheReader& reader)
{
#pragma message("####################### ${tag_name} union is not implemented")
std::cout << " Error!!! ${tag_name} union is not implemented!!!!!!!!!!!!!!!" << std::endl;
/*
if(!loadFirstMandatory<InterfaceHdr>(own_tag, reader))
{
return false;
}
loadMandatory<Mms>(own_tag, reader);
loadOptional<Mms>(own_tag, reader);
loadChildN<Continue>(own_tag, reader, 0, 0);
*/
return true;
}
} // namespace XLS
CPP_L1
close FCPP;
################################### header #############################################
open FH, ">$h_file";
print FH <<H_L1;
#pragma once
#include <XLS_logic/CompositeObject.h>
namespace XLS
{;
// Logical representation of ${tag_name} union of records
class ${tag_name}: public CompositeObject
{
public:
${tag_name}(MSXML2::IXMLDOMDocument2Ptr xmlDoc, MSXML2::IXMLDOMElementPtr parent);
~${tag_name}();
virtual const bool loadContent(MSXML2::IXMLDOMElementPtr own_tag, CFStreamCacheReader& reader);
};
} // namespace XLS
H_L1
close FH;
system "move $h_file D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_unions\\${h_file}";
system "move $cpp_file D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_unions\\${cpp_file}";
system "svn add D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_unions\\${tag_name}.*";
}
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/gen_PtgStruct.pl deleted 100644 → 0
View file @ 8013237e
#!/usr/bin/perl -w
# diffs two files and writes an HTML output file.
use strict;
use CGI qw(:standard :html3);
# MAIN PROGRAM
main();
exit 0;
sub main
{
# Check for two arguments.
print "usage: $0 tag_name [tag_name]\n" if @ARGV < 1;
for(my $i = 0; $i < @ARGV; $i++)
{
generateClass($ARGV[$i]);
}
}
sub generateClass
{
my $tag_name = $_[0];
$tag_name =~ s/[\[\]\(\)*\\\/]//g;
$tag_name =~ s/\d*(.+)/${1}/g;
return unless $tag_name; # if the tag absent
#print "$tag_name \n";
#return;
my $cpp_file = "${tag_name}.cpp";
my $h_file = "${tag_name}.h";
################################# CPP #####################################
open FCPP, ">$cpp_file";
print FCPP <<CPP_L1;
#include "stdafx.h"
#include "${tag_name}.h"
#include <XLS_bin/CFRecord.h>
namespace XLS
{;
void ${tag_name}::toXML(MSXML2::IXMLDOMElementPtr parent)
{
MSXML2::IXMLDOMElementPtr own_tag = createElement(parent, getClassName().c_str());
own_tag->setAttribute("type", type);
own_tag->setAttribute("row", row);
own_tag->setAttribute("col", col);
}
void ${tag_name}::load(CFRecord& record)
{
BYTE rec_type;
record >> rec_type;
type = GETBITS(rec_type, 5, 6);
// record.skipNBytes(1); // record type
record >> row >> col;
}
void ${tag_name}::assemble(PtgStack& ptg_stack, PtgQueue& extra_data, MSXML2::IXMLDOMElementPtr parent)
{
#pragma message("####################### ${tag_name} record is not implemented")
std::cout << " Error!!! ${tag_name} record is not implemented." << std::endl;
ptg_stack.push("#REF!");
}
} // namespace XLS
CPP_L1
close FCPP;
################################### header #############################################
open FH, ">$h_file";
print FH <<H_L1;
#pragma once
#include "Ptg.h"
namespace XLS
{;
class CFRecord;
class ${tag_name} : public Ptg
{
public:
virtual void toXML(MSXML2::IXMLDOMElementPtr parent);
virtual void load(CFRecord& record);
virtual void assemble(PtgStack& ptg_stack, PtgQueue& extra_data, MSXML2::IXMLDOMElementPtr parent);
private:
BYTE type;
WORD row;
WORD col;
};
} // namespace XLS
H_L1
close FH;
system "move /-Y $h_file D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_structures\\${h_file}";
system "move /-Y $cpp_file D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_structures\\${cpp_file}";
system "svn add D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_structures\\${tag_name}.*";
#system "devenv.exe /command \"File.AddExistingItem \"D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_records\\${tag_name}.h\"\""
}
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/gen_Struct.pl deleted 100644 → 0
View file @ 8013237e
#!/usr/bin/perl -w
# diffs two files and writes an HTML output file.
use strict;
use CGI qw(:standard :html3);
# MAIN PROGRAM
main();
exit 0;
sub main
{
# Check for two arguments.
print "usage: $0 tag_name [tag_name]\n" if @ARGV < 1;
for(my $i = 0; $i < @ARGV; $i++)
{
generateClass($ARGV[$i]);
}
}
sub generateClass
{
my $tag_name = $_[0];
$tag_name =~ s/[\[\]\(\)*\\\/]//g;
$tag_name =~ s/\d*(.+)/${1}/g;
return unless $tag_name; # if the tag absent
#print "$tag_name \n";
#return;
my $cpp_file = "${tag_name}.cpp";
my $h_file = "${tag_name}.h";
################################# CPP #####################################
open FCPP, ">$cpp_file";
print FCPP <<CPP_L1;
#include "stdafx.h"
#include "${tag_name}.h"
#include <XLS_bin/CFRecord.h>
namespace XLS
{;
BiffStructurePtr ${tag_name}::clone()
{
return BiffStructurePtr(new ${tag_name}(*this));
}
void ${tag_name}::setXMLAttributes(MSXML2::IXMLDOMElementPtr xml_tag)
{
xml_tag->setAttribute(L"something", something);
//std::for_each(rgRun.begin(), rgRun.end(), boost::bind(&FormatRun::toXML, _1, xml_tag));
/*
if(fExtSt)
{
extRst.toXML(xml_tag);
}
*/
}
void ${tag_name}::getXMLAttributes(MSXML2::IXMLDOMElementPtr xml_tag)
{
#pragma message("####################### ${tag_name} record has no BiffStructure::fromXML() implemented")
Log::error(" Error!!! ${tag_name} record has no BiffStructure::fromXML() implemented.");
}
void ${tag_name}::store(CFRecord& record)
{
#pragma message("####################### ${tag_name} record has no BiffStructure::store() implemented")
Log::error(" Error!!! ${tag_name} record has no BiffStructure::store() implemented.");
//record << something;
}
void ${tag_name}::load(CFRecord& record)
{
record.skipNBytes(2); // reserved
WORD flags;
record >> flags;
record >> something >> something >> something >> something >> something;
GenerateCompileError();
}
} // namespace XLS
CPP_L1
close FCPP;
################################### header #############################################
open FH, ">$h_file";
print FH <<H_L1;
#pragma once
#include "BiffStructure.h"
//#include <XLS_logic/Biff_structures/Phs.h>
//#include <XLS_logic/Biff_structures/BiffString.h>
namespace XLS
{;
class CFRecord;
class ${tag_name} : public BiffStructure
{
public:
BiffStructurePtr clone();
virtual void setXMLAttributes(MSXML2::IXMLDOMElementPtr xml_tag);
virtual void getXMLAttributes(MSXML2::IXMLDOMElementPtr xml_tag);
virtual void load(CFRecord& record);
virtual void store(CFRecord& record);
private:
WORD something;
};
typedef boost::shared_ptr<${tag_name}> ${tag_name}Ptr;
} // namespace XLS
H_L1
close FH;
system "move /-Y $h_file ..\\source\\XLS_logic\\Biff_structures\\${h_file}";
system "move /-Y $cpp_file ..\\source\\XLS_logic\\Biff_structures\\${cpp_file}";
system "svn add ..\\source\\XLS_logic\\Biff_structures\\${tag_name}.*";
#system "devenv.exe /command \"File.AddExistingItem \"D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_records\\${tag_name}.h\"\""
}
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/gen_Struct_OSHARED.pl deleted 100644 → 0
View file @ 8013237e
#!/usr/bin/perl -w
# diffs two files and writes an HTML output file.
use strict;
use CGI qw(:standard :html3);
# MAIN PROGRAM
main();
exit 0;
sub main
{
# Check for two arguments.
print "usage: $0 tag_name [tag_name]\n" if @ARGV < 1;
for(my $i = 0; $i < @ARGV; $i++)
{
generateClass($ARGV[$i]);
}
}
sub generateClass
{
my $tag_name = $_[0];
$tag_name =~ s/[\[\]\(\)*\\\/]//g;
$tag_name =~ s/\d*(.+)/${1}/g;
return unless $tag_name; # if the tag absent
#print "$tag_name \n";
#return;
my $cpp_file = "${tag_name}.cpp";
my $h_file = "${tag_name}.h";
################################# CPP #####################################
open FCPP, ">$cpp_file";
print FCPP <<CPP_L1;
#include "stdafx.h"
#include "${tag_name}.h"
#include <XLS_bin/CFRecord.h>
namespace OSHARED
{;
void ${tag_name}::toXML(MSXML2::IXMLDOMElementPtr parent)
{
MSXML2::IXMLDOMElementPtr own_tag = BiffStructure::createElement(parent, getClassName().c_str());
own_tag->setAttribute("something", something);
//std::for_each(rgRun.begin(), rgRun.end(), boost::bind(&FormatRun::toXML, _1, own_tag));
/*
if(fExtSt)
{
extRst.toXML(own_tag);
}
*/
}
void ${tag_name}::load(XLS::CFRecord& record)
{
record.skipNBytes(2); // reserved
WORD flags;
record >> flags;
record >> something >> something >> something >> something >> something;
GenerateCompileError();
}
} // namespace OSHARED
CPP_L1
close FCPP;
################################### header #############################################
open FH, ">$h_file";
print FH <<H_L1;
#pragma once
#include "BiffStructure.h"
//#include <XLS_logic/Biff_structures/Phs.h>
//#include <XLS_logic/Biff_structures/BiffString.h>
namespace OSHARED
{;
class CFRecord;
class ${tag_name} : public XLS::BiffStructure
{
public:
virtual void toXML(MSXML2::IXMLDOMElementPtr parent);
virtual void load(XLS::CFRecord& record);
private:
WORD something;
};
} // namespace OSHARED
H_L1
close FH;
system "move /-Y $h_file D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_structures\\${h_file}";
system "move /-Y $cpp_file D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_structures\\${cpp_file}";
system "svn add D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_structures\\${tag_name}.*";
#system "devenv.exe /command \"File.AddExistingItem \"D:\\Projects\\AVSWorksheetConverter\\source\\XLS_logic\\Biff_records\\${tag_name}.h\"\""
}
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/gen_enum.pl deleted 100644 → 0
View file @ 8013237e
#!/usr/bin/perl -w
# diffs two files and writes an HTML output file.
use strict;
use CGI qw(:standard :html3);
# MAIN PROGRAM
# Check for two arguments.
#print "usage: $0 file1 > out.txt\n" if @ARGV != 1;
open FH, "tags.txt";#$ARGV[0];
while (<FH>)
{
if(/([A-Za-z][A-Za-z0-9_-]*)/)
{
# print "\trt_$1";
print "\t{\"$1\",";
for(my $i = 0; $i < 7 - (length($1)+4)/4; $i++)
{
print "\t";
}
print "rt_$1},\n";
next;
}
if(/(\d+)/)
{
# print $outFile "0x$1,\n";
# printf("0x%04x,\n", $1);
next;
}
}
exit(0);
ASCOfficeXlsFile/ASCWorksheetConverter/CodeGenerator/tags.txt deleted 100644 → 0
View file @ 8013237e
Formula
6
EOF
10
CalcCount
12
CalcMode
13
CalcPrecision
14
CalcRefMode
15
CalcDelta
16
CalcIter
17
Protect
18
Password
19
Header
20
Footer
21
ExternSheet
23
Lbl
24
WinProtect
25
VerticalPageBreaks
26
HorizontalPageBreaks
27
Note
28
Selection
29
Date1904
34
ExternName
35
LeftMargin
38
RightMargin
39
TopMargin
40
BottomMargin
41
PrintRowCol
42
PrintGrid
43
FilePass
47
Font
49
PrintSize
51
Continue
60
Window1
61
Backup
64
Pane
65
CodePage
66
Pls
77
DCon
80
DConRef
81
DConName
82
DefColWidth
85
XCT
89
CRN
90
FileSharing
91
WriteAccess
92
Obj
93
Uncalced
94
CalcSaveRecalc
95
Template
96
Intl
97
ObjProtect
99
ColInfo
125
Guts
128
WsBool
129
GridSet
130
HCenter
131
VCenter
132
BoundSheet8
133
WriteProtect
134
Country
140
HideObj
141
Sort
144
Palette
146
Sync
151
LPr
152
DxGCol
153
FnGroupName
154
FilterMode
155
BuiltInFnGroupCount
156
AutoFilterInfo
157
AutoFilter
158
Scl
160
Setup
161
ScenMan
174
SCENARIO
175
SxView
176
Sxvd
177
SXVI
178
SxIvd
180
SXLI
181
SXPI
182
DocRoute
184
RecipName
185
MulRk
189
MulBlank
190
Mms
193
SXDI
197
SXDB
198
SXFDB
199
SXDBB
200
SXNum
201
SxBool
202
SxErr
203
SXInt
204
SXString
205
SXDtr
206
SxNil
207
SXTbl
208
SXTBRGIITM
209
SxTbpg
210
ObProj
211
SXStreamID
213
DBCell
215
SXRng
216
SxIsxoper
217
BookBool
218
DbOrParamQry
220
ScenarioProtect
221
OleObjectSize
222
XF
224
InterfaceHdr
225
InterfaceEnd
226
SXVS
227
MergeCells
229
BkHim
233
MsoDrawingGroup
235
MsoDrawing
236
MsoDrawingSelection
237
PhoneticInfo
239
SxRule
240
SXEx
241
SxFilt
242
SxDXF
244
SxItm
245
SxName
246
SxSelect
247
SXPair
248
SxFmla
249
SxFormat
251
SST
252
LabelSst
253
ExtSST
255
SXVDEx
256
SXFormula
259
SXDBEx
290
RRDInsDel
311
RRDHead
312
RRDChgCell
315
RRTabId
317
RRDRenSheet
318
RRSort
319
RRDMove
320
RRFormat
330
RRAutoFmt
331
RRInsertSh
333
RRDMoveBegin
334
RRDMoveEnd
335
RRDInsDelBegin
336
RRDInsDelEnd
337
RRDConflict
338
RRDDefName
339
RRDRstEtxp
340
LRng
351
UsesELFs
352
DSF
353
CUsr
401
CbUsr
402
UsrInfo
403
UsrExcl
404
FileLock
405
RRDInfo
406
BCUsrs
407
UsrChk
408
UserBView
425
UserSViewBegin
426
UserSViewBegin_Chart
426
UserSViewEnd
427
RRDUserView
428
Qsi
429
SupBook
430
Prot4Rev
431
CondFmt
432
CF
433
DVal
434
DConBin
437
TxO
438
RefreshAll
439
HLink
440
Lel
441
CodeName
442
SXFDBType
443
Prot4RevPass
444
ObNoMacros
445
Dv
446
Excel9File
448
RecalcId
449
EntExU2
450
Dimensions
512
Blank
513
Number
515
Label
516
BoolErr
517
String
519
Row
520
Index
523
Array
545
DefaultRowHeight
549
Table
566
Window2
574
RK
638
Style
659
BigName
1048
Format
1054
ContinueBigName
1084
ShrFmla
1212
HLinkTooltip
2048
WebPub
2049
QsiSXTag
2050
DBQueryExt
2051
ExtString
2052
TxtQry
2053
Qsir
2054
Qsif
2055
RRDTQSIF
2056
BOF
2057
OleDbConn
2058
WOpt
2059
SXViewEx
2060
SXTH
2061
SXPIEx
2062
SXVDTEx
2063
SXViewEx9
2064
ContinueFrt
2066
RealTimeData
2067
ChartFrtInfo
2128
FrtWrapper
2129
StartBlock
2130
EndBlock
2131
StartObject
2132
EndObject
2133
CatLab
2134
YMult
2135
SXViewLink
2136
PivotChartBits
2137
FrtFontList
2138
SheetExt
2146
BookExt
2147
SXAddl
2148
CrErr
2149
HFPicture
2150
FeatHdr
2151
Feat
2152
DataLabExt
2154
DataLabExtContents
2155
CellWatch
2156
FeatHdr11
2161
Feature11
2162
DropDownObjIds
2164
ContinueFrt11
2165
DConn
2166
List12
2167
Feature12
2168
CondFmt12
2169
CF12
2170
CFEx
2171
XFCRC
2172
XFExt
2173
AutoFilter12
2174
ContinueFrt12
2175
MDTInfo
2180
MDXStr
2181
MDXTuple
2182
MDXSet
2183
MDXProp
2184
MDXKPI
2185
MDB
2186
PLV
2187
Compat12
2188
DXF
2189
TableStyles
2190
TableStyle
2191
TableStyleElement
2192
StyleExt
2194
NamePublish
2195
NameCmt
2196
SortData
2197
Theme
2198
GUIDTypeLib
2199
FnGrp12
2200
NameFnGrp12
2201
MTRSettings
2202
CompressPictures
2203
HeaderFooter
2204
CrtLayout12
2205
CrtMlFrt
2206
CrtMlFrtContinue
2207
ForceFullCalculation
2211
ShapePropsStream
2212
TextPropsStream
2213
RichTextStream
2214
CrtLayout12A
2215
Units
4097
Chart
4098
Series
4099
DataFormat
4102
LineFormat
4103
MarkerFormat
4105
AreaFormat
4106
PieFormat
4107
AttachedLabel
4108
SeriesText
4109
ChartFormat
4116
Legend
4117
SeriesList
4118
Bar
4119
Line
4120
Pie
4121
Area
4122
Scatter
4123
CrtLine
4124
Axis
4125
Tick
4126
ValueRange
4127
CatSerRange
4128
AxisLine
4129
CrtLink
4130
DefaultText
4132
Text
4133
FontX
4134
ObjectLink
4135
Frame
4146
Begin
4147
End
4148
PlotArea
4149
Chart3d
4154
PicF
4156
DropBar
4157
Radar
4158
Surf
4159
RadarArea
4160
AxisParent
4161
LegendException
4163
ShtProps
4164
SerToCrt
4165
AxesUsed
4166
SBaseRef
4168
SerParent
4170
SerAuxTrend
4171
IFmtRecord
4174
Pos
4175
AlRuns
4176
BRAI
4177
SerAuxErrBar
4187
ClrtClient
4188
SerFmt
4189
Chart3DBarShape
4191
Fbi
4192
BopPop
4193
AxcExt
4194
Dat
4195
PlotGrowth
4196
SIIndex
4197
GelFrame
4198
BopPopCustom
4199
Fbi2
4200
ASCOfficeXlsFile/ASCWorksheetConverter/source/Auxiliary/BetterVariantT.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "BetterVariantT.h"
#include <Exception/AttributeDataWrong.h>
namespace AUX
{;
BetterVariantT::BetterVariantT(const _variant_t& varSrc)
: _variant_t(varSrc)
{
}
// Extracts a VT_R8 into a double
//
BetterVariantT::operator double() const
{
if (V_VT(this) == VT_R8) {
return V_R8(this);
}
_variant_t varDest;
if(FAILED(::VariantChangeTypeEx(static_cast<VARIANT*>(&varDest),
const_cast<VARIANT*>(static_cast<const VARIANT*>(this)), 1252, 0, VT_R8)))
{
throw EXCEPT::LE::WrongIntermediateXMLFormat("Type mismatch", __FUNCTION__);
}
return V_R8(&varDest);
}
} // namespace AUX
ASCOfficeXlsFile/ASCWorksheetConverter/source/Auxiliary/BetterVariantT.h deleted 100644 → 0
View file @ 8013237e
#pragma once
namespace AUX
{;
class BetterVariantT : public _variant_t
{
public:
BetterVariantT(const _variant_t& varSrc) ;
operator double() const ; // Extracts a double from a VT_R8
};
} // namespace AUX
ASCOfficeXlsFile/ASCWorksheetConverter/source/Auxiliary/HelpFunc.h deleted 100644 → 0
View file @ 8013237e
#pragma once
namespace XLS
{;
class CellRangeRef;
}
namespace AUX
{;
const int normalizeColumn(const int column);
const int normalizeRow(const int row);
const std::wstring column2str(const int column);
const std::wstring row2str(const int row);
const std::wstring loc2str(const long row, const bool row_rel, const long column, const bool col_rel);
void str2loc(const std::wstring& str, long& row, bool& row_rel, long& column, bool& col_rel);
void str2loc(std::wstring::const_iterator& str_begin, std::wstring::const_iterator& str_end, long& row, bool& row_rel, long& column, bool& col_rel);
void str2refs(const std::wstring& str, std::vector<XLS::CellRangeRef>& vec);
}
namespace STR
{;
const std::string int2str(const int val, const int radix = 10);
const std::wstring int2wstr(const int val, const int radix = 10);
const std::wstring double2str(const double val);
const std::string bin2str(const char* buf, const size_t nbuf);
const _bstr_t guid2bstr(const GUID guid);
const std::string guid2str(const GUID guid);
const bool bstr2guid(const _bstr_t& guid_str, GUID& guid);
const std::string int2hex_str(const int val, const size_t size_of = 4);
const std::wstring wchar_t2hex_str(const wchar_t val);
const std::wstring escapeUrlW(const std::wstring& str);
const std::wstring escape_ST_Xstring(const std::wstring& str);
const std::wstring unescape_ST_Xstring(const std::wstring& str);
const std::string toARGB(const DWORD rgba);
const std::string toARGB(const BYTE red, const BYTE green, const BYTE blue, const BYTE alpha);
const std::string toRGB(const BYTE red, const BYTE green, const BYTE blue);
const bool fromARGB(const std::wstring& argb, BYTE& red, BYTE& green, BYTE& blue, BYTE& alpha);
const size_t hex_str2int(const std::wstring& hex);
const size_t hex_str2int(const std::wstring::const_iterator& it_begin, const std::wstring::const_iterator& it_end);
const std::string hres2str(const HRESULT hres);
const std::string toStdString(const std::wstring& wide_string, const UINT code_page);
const std::wstring toStdWString(const std::string& ansi_string, const UINT code_page);
}
namespace XMLSTUFF
{;
const bool loadXSLTFromResources(MSXML2::IXMLDOMDocumentPtr xslt_doc, const std::vector<std::wstring>& resources);
// Makes a new XML tag and append it to parent (no attributes set)
MSXML2::IXMLDOMElementPtr makeXMLNode(const _bstr_t& tag_name, MSXML2::IXMLDOMElementPtr parent);
const std::wstring make3dRef(const WORD ixti, const std::wstring cell_ref, std::vector<std::wstring>& xti_parsed);
const WORD sheetsnames2ixti(const std::wstring str, MSXML2::IXMLDOMDocumentPtr doc);
const std::wstring xti_indexes2sheet_name(const short itabFirst, const short itabLast, std::vector<std::wstring>& sheets_names);
}
ASCOfficeXlsFile/ASCWorksheetConverter/source/Auxiliary/HelpersTagsGenerator.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "HelpersTagsGenerator.h"
namespace AUX
{;
HelpersTagsGenerator::HelpersTagsGenerator(MSXML2::IXMLDOMElementPtr document_root)
: document_root_(document_root)
{
}
bool HelpersTagsGenerator::GenHelpers()
{
MSXML2::IXMLDOMDocumentPtr doc = document_root_->GetownerDocument();
MSXML2::IXMLDOMElementPtr helpers_tag = XMLSTUFF::makeXMLNode(L"Helpers", document_root_);
GenColumnsRefs(helpers_tag);
GenIndexedColors(helpers_tag);
return true;
}
void HelpersTagsGenerator::GenColumnsRefs(MSXML2::IXMLDOMElementPtr helpers_tag)
{
MSXML2::IXMLDOMDocumentPtr doc = document_root_->GetownerDocument();
MSXML2::IXMLDOMElementPtr col_names_tag = XMLSTUFF::makeXMLNode(L"col_names", helpers_tag);
for (int i = 0; i < 256; i++)
{
MSXML2::IXMLDOMElementPtr col_name_tag = doc->createElement(L"col_name");
col_names_tag->appendChild(col_name_tag);
col_name_tag->setAttribute(L"index", i);
col_name_tag->setAttribute(L"ref", column2str(i).c_str());
}
}
void HelpersTagsGenerator::GenIndexedColors(MSXML2::IXMLDOMElementPtr helpers_tag)
{
static std::wstring color_strings[64] =
{
L"000000", L"FFFFFF", L"FF0000", L"00FF00", L"0000FF", L"FFFF00", L"FF00FF", L"00FFFF",
L"000000", L"FFFFFF", L"FF0000", L"00FF00", L"0000FF", L"FFFF00", L"FF00FF", L"00FFFF",
L"800000", L"008000", L"000080", L"808000", L"800080", L"008080", L"C0C0C0", L"808080",
L"9999FF", L"993366", L"FFFFCC", L"CCFFFF", L"660066", L"FF8080", L"0066CC", L"CCCCFF",
L"000080", L"FF00FF", L"FFFF00", L"00FFFF", L"800080", L"800000", L"008080", L"0000FF",
L"00CCFF", L"CCFFFF", L"CCFFCC", L"FFFF99", L"99CCFF", L"FF99CC", L"CC99FF", L"FFCC99",
L"3366FF", L"33CCCC", L"99CC00", L"FFCC00", L"FF9900", L"FF6600", L"666699", L"969696",
L"003366", L"339966", L"003300", L"333300", L"993300", L"993366", L"333399", L"333333"
};
MSXML2::IXMLDOMDocumentPtr doc = document_root_->GetownerDocument();
MSXML2::IXMLDOMElementPtr indexed_colors_tag = XMLSTUFF::makeXMLNode(L"indexedColors", helpers_tag);
for (int i = 0; i < 64; i++)
{
MSXML2::IXMLDOMElementPtr rgb_color_tag = doc->createElement(L"rgbColor");
indexed_colors_tag->appendChild(rgb_color_tag);
rgb_color_tag->setAttribute(L"rgb", color_strings[i].c_str());
}
}
} // namespace AUX
ASCOfficeXlsFile/ASCWorksheetConverter/source/Auxiliary/HelpersTagsGenerator.h deleted 100644 → 0
View file @ 8013237e
#pragma once
namespace AUX
{;
class HelpersTagsGenerator
{
public:
HelpersTagsGenerator(MSXML2::IXMLDOMElementPtr document_root);
bool GenHelpers();
private:
void GenColumnsRefs(MSXML2::IXMLDOMElementPtr helpers_tag);
void GenIndexedColors(MSXML2::IXMLDOMElementPtr helpers_tag);
MSXML2::IXMLDOMElementPtr document_root_;
};
} // namespace AUX
ASCOfficeXlsFile/ASCWorksheetConverter/source/Auxiliary/nullable/nullable.h deleted 100644 → 0
View file @ 8013237e
#pragma once
#include <boost/optional.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/call_traits.hpp>
#include "../../Exception/WrongAPIUsage.h"
template<typename T>
class nullable
{
private:
typedef typename boost::call_traits<T>::param_type Parameter;
public:
nullable() {}
nullable(Parameter value) : _value(value) {}
template<typename U>
const nullable<T>& operator =(const U& value)
{
return ::nullable_setter(*this, value);
}
template<typename U>
const nullable<T>& nullable_setter(const U& value)
{
_value = static_cast<T>(value);
return *this;
}
const nullable<T>& nullable_setter(const nullable<T>& value)
{
_value = value;
return *this;
}
operator Parameter() const {return _value.get();}
Parameter get() const {return _value.get();}
Parameter get_value_or(Parameter value) const {return _value.get_value_or(value);}
T const* operator->() const {return _value.get_ptr();}
T* operator->() {return _value.get_ptr();}
T const* get_ptr() const {return _value.get_ptr();}
T* get_ptr() {return _value.get_ptr();}
T const& operator*() const {return *_value;}
T& operator*() {return *_value;}
const bool is_init() const {return _value.is_init();}
void reset() {_value.reset();};
const bool operator== (nullable<T> const& rhs) const {return _value.get() == rhs._value.get();}
const bool operator!= (nullable<T> const& rhs) const {return _value.get() != rhs._value.get();}
const bool operator< (nullable<T> const& rhs) const {return _value.get() < rhs._value.get();}
const bool operator> (nullable<T> const& rhs) const {return _value.get() > rhs._value.get();}
const bool operator<= (nullable<T> const& rhs) const {return _value.get() <= rhs._value.get();}
const bool operator>= (nullable<T> const& rhs) const {return _value.get() >= rhs._value.get();}
const bool operator== (Parameter rhs) const {return _value.get() == rhs;}
const bool operator!= (Parameter rhs) const {return _value.get() != rhs;}
const bool operator< (Parameter rhs) const {return _value.get() < rhs;}
const bool operator> (Parameter rhs) const {return _value.get() > rhs;}
const bool operator<= (Parameter rhs) const {return _value.get() <= rhs;}
const bool operator>= (Parameter rhs) const {return _value.get() >= rhs;}
private:
template<class T, bool big_type>
class _nullable
{
private:
typedef typename boost::call_traits<T>::param_type Parameter;
public:
_nullable() {}
_nullable(Parameter val) : _value(new T(val)) {}
void operator =(Parameter val) { _value.reset(new T(val));}
void operator =(const nullable<T>& other)
{
if (other.is_init())
_value.reset(new T(other));
else
_value = boost::shared_ptr<T>();
}
Parameter get() const
{
if(is_init())
return *_value;
else
throw EXCEPT::LE::WrongAPIUsage("One of nullable objects was used uninitialized.", __FUNCTION__);
}
Parameter get_value_or(Parameter val) const {return is_init() ? get() : val;}
const bool is_init() const {return _value != 0;}
void reset() {_value.reset();}
T const* get_ptr() const {return _value.get();}
T* get_ptr() {return _value.get();}
T const& operator*() const {return get();}
T& operator*() {return get();}
private:
boost::shared_ptr<T> _value;
};
template<class T>
class _nullable<T, false>
{
private:
typedef typename boost::call_traits<T>::param_type Parameter;
public:
_nullable() {}
_nullable(Parameter value) : _value(value) {}
void operator =(Parameter val) {_value = val;}
void operator =(const nullable<T>& other)
{
if (other.is_init())
_value = other;
else
_value = boost::optional<T>();
}
Parameter get() const
{
if(is_init())
return _value.get();
else
throw EXCEPT::LE::WrongAPIUsage("One of nullable objects was used uninitialized.", __FUNCTION__);
}
Parameter get_value_or(Parameter val) const {return _value.get_value_or(val);}
const bool is_init() const {return _value.is_initialized();}
void reset() {_value.reset();}
T const* get_ptr() const {return _value.get_ptr();}
T* get_ptr() {return _value.get_ptr();}
T const& operator*() const {return get();}
T& operator*() {return get();}
private:
boost::optional<T> _value;
};
private:
static const int size_of_big_object = 128;
_nullable<T, sizeof(T) / (size_of_big_object + 1) >= 1> _value;
};
template<class T> const bool operator== (typename boost::call_traits<T>::param_type x, nullable<T> const& y) {return y == x;}
template<class T> const bool operator!= (typename boost::call_traits<T>::param_type x, nullable<T> const& y) {return y != x;}
template<class T> const bool operator< (typename boost::call_traits<T>::param_type x, nullable<T> const& y) {return y >= x;}
template<class T> const bool operator> (typename boost::call_traits<T>::param_type x, nullable<T> const& y) {return y <= x;}
template<class T> const bool operator<= (typename boost::call_traits<T>::param_type x, nullable<T> const& y) {return y > x;}
template<class T> const bool operator>= (typename boost::call_traits<T>::param_type x, nullable<T> const& y) {return y < x;}
template<typename T, typename U>
const nullable<T>& nullable_setter(nullable<T>& lhs, const U& rhs)
{
return lhs.nullable_setter(rhs);
}
ASCOfficeXlsFile/ASCWorksheetConverter/source/Converter/Converter.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "Converter.h"
#include <Document/Document.h>
const bool Converter::convert(Document& doc, MSXML2::IXMLDOMDocumentPtr xslt)
{
return VARIANT_TRUE == doc.getDoc()->loadXML(doc.getDoc()->transformNode(xslt));
}
ASCOfficeXlsFile/ASCWorksheetConverter/source/Converter/Converter.h deleted 100644 → 0
View file @ 8013237e
#pragma once
class Document;
class Converter
{
public:
virtual const bool convertToX(Document& doc) = 0;
virtual const bool convertFromX(Document& doc) = 0;
protected:
const bool convert(Document& doc, MSXML2::IXMLDOMDocumentPtr xslt);
};
ASCOfficeXlsFile/ASCWorksheetConverter/source/Converter/XLSConverter.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "XLSConverter.h"
#include <Document/Document.h>
#include <fstream>
#include <iostream> // endl
#include "boost/filesystem.hpp"
namespace XLS
{;
XLSConverter::XLSConverter()
{
}
const bool XLSConverter::convertFromX(Document& doc)
{
MSXML2::IXMLDOMDocument3Ptr xslt_from_X(_T("Msxml2.FreeThreadedDOMDocument.6.0"));
xslt_from_X->Putasync(VARIANT_TRUE);
xslt_from_X->setProperty(L"SelectionNamespaces", L"xmlns:xsl='http://www.w3.org/1999/XSL/Transform'");
std::vector<std::wstring> resources;
wchar_t file_path[MAX_PATH];
GetModuleFileNameW(ATL::_AtlBaseModule.GetModuleInstance(), file_path, MAX_PATH);
std::wstring dll_file_name = boost::filesystem::wpath(file_path).filename();
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2012"); // x2xls.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2013"); // x2xls_Globals.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2014"); // propertiesTree.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2015"); // x2xls_Worksheet.xsl
if(!XMLSTUFF::loadXSLTFromResources(xslt_from_X, resources))
{
return false;
}
Log::event("XLSX to XLS XSLT table loaded from resources successfully");
#ifdef _DEBUG
// DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
//xslt_from_X->save(L"../InFiles/convert.xsl");
// DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
#endif
if(!convert(doc, xslt_from_X))
{
return false;
}
Log::event("The internal XLSX XML converted to XLS XML successfully");
return true;
}
const bool XLSConverter::convertToX(Document& doc)
{
MSXML2::IXMLDOMDocument3Ptr xslt_to_X(_T("Msxml2.FreeThreadedDOMDocument.6.0"));
xslt_to_X->setProperty(L"SelectionNamespaces", L"xmlns:xsl='http://www.w3.org/1999/XSL/Transform'");
xslt_to_X->Putasync(VARIANT_TRUE);
std::vector<std::wstring> resources;
wchar_t file_path[MAX_PATH];
GetModuleFileNameW(ATL::_AtlBaseModule.GetModuleInstance(), file_path, MAX_PATH);
std::wstring dll_file_name = boost::filesystem::wpath(file_path).filename();
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2001"); // xls2x.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2003"); // xls2x_rels.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2005"); // xls2x_wb.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2006"); // xls2x_ws.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2008"); // xls2x_styles.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2009"); // xls2x_sst.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2011"); // xls2x_comments.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2014"); // propertiesTree.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2018"); // xls2x_drawing.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2019"); // xls2x_chart.xsl
resources.push_back(L"res://" + dll_file_name + L"/XSL/#2020"); // xls2x_cs.xsl
if(!XMLSTUFF::loadXSLTFromResources(xslt_to_X, resources))
{
return false;
}
Log::event("XLS to XLSX XSLT table loaded from resources successfully");
#ifdef _DEBUG
// DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
//xslt_to_X->save(L"../InFiles/convert.xsl");
boost::filesystem::path curr_path = boost::filesystem::current_path();
xslt_to_X->save(L"c:/Temp/for_test/InFiles/convert.xsl");
// Log::event("../InFiles/convert.xsl saved successfully");
// DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
DWORD time_before = GetTickCount();
#endif
if(!convert(doc, xslt_to_X))
{
return false;
}
#ifdef _DEBUG
DWORD ticks_spent = GetTickCount() - time_before;
std::cout << "XSLT conversion took " << ticks_spent / 1000 << " seconds (" << ticks_spent << " ms)" << std::endl;
#endif
Log::event("The internal XLS XML converted to XLSX XML successfully");
return true;
}
} // namespace XLS
ASCOfficeXlsFile/ASCWorksheetConverter/source/Converter/XLSConverter.h deleted 100644 → 0
View file @ 8013237e
#pragma once
#include <Converter/Converter.h>
namespace XLS
{;
class XLSConverter : public Converter
{
public:
XLSConverter();
virtual const bool convertToX(Document& doc);
virtual const bool convertFromX(Document& doc);
};
} // namespace XLS
ASCOfficeXlsFile/ASCWorksheetConverter/source/Converter/XLSXConverter.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "XLSXConverter.h"
namespace XLSX
{;
const bool XLSXConverter::convertToX(Document& doc)
{
return true; // Already the necessary format
}
const bool XLSXConverter::convertFromX(Document& doc)
{
return true; // Already the necessary format
}
} // namespace XLS
ASCOfficeXlsFile/ASCWorksheetConverter/source/Converter/XLSXConverter.h deleted 100644 → 0
View file @ 8013237e
#pragma once
#include <Converter/Converter.h>
namespace XLSX
{;
class XLSXConverter : public Converter
{
public:
virtual const bool convertToX(Document& doc);
virtual const bool convertFromX(Document& doc);
};
} // namespace XLSX
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/BiffDecoder_RCF.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "BiffDecoder_RCF.h"
namespace CRYPT
{;
BiffDecoderBase::BiffDecoderBase() : mbValid(false)
{
}
BiffDecoderBase::~BiffDecoderBase()
{
}
bool BiffDecoderBase::verifyPassword(const std::wstring& rPassword)
{
mbValid = implVerify(rPassword);
return mbValid;
}
void BiffDecoderBase::decode(BYTE* pnDestData, const BYTE* pnSrcData, const LONGLONG nStreamPos, const WORD nBytes)
{
if(pnDestData && pnSrcData && (nBytes> 0))
{
if(mbValid)
implDecode(pnDestData, pnSrcData, nStreamPos, nBytes);
else
memcpy(pnDestData, pnSrcData, nBytes);
}
}
/** Returns the block index of the passed stream position for RCF decryption. */
int lclGetRcfBlock(LONGLONG nStreamPos)
{
return static_cast<int>(nStreamPos / BIFF_RCF_BLOCKSIZE);
}
/** Returns the offset of the passed stream position in a block for RCF decryption. */
int lclGetRcfOffset(LONGLONG nStreamPos)
{
return static_cast<int>(nStreamPos % BIFF_RCF_BLOCKSIZE);
}
BiffDecoder_RCF::BiffDecoder_RCF(BYTE pnSalt[16], BYTE pnVerifier[16], BYTE pnVerifierHash[16])
: maPassword(16, 0),
maSalt(pnSalt, pnSalt + 16),
maVerifier(pnVerifier, pnVerifier + 16),
maVerifierHash(pnVerifierHash, pnVerifierHash + 16)
{
}
bool BiffDecoder_RCF::implVerify(const std::wstring& rPassword)
{
int nLen = rPassword.length();
if((0 <nLen) && (nLen <16))
{
// copy string to WORD array
maPassword.clear();
maPassword.resize(16, 0);
const wchar_t* pcChar = rPassword.c_str();
const wchar_t* pcCharEnd = pcChar + nLen;
std::vector<WORD>::iterator aIt = maPassword.begin();
for(; pcChar <pcCharEnd; ++pcChar, ++aIt)
*aIt = static_cast<WORD>(*pcChar);
// init codec
maCodec.initKey(&maPassword.front(), &maSalt.front());
return maCodec.verifyKey(&maVerifier.front(), &maVerifierHash.front());
}
return false;
}
void BiffDecoder_RCF::implDecode(BYTE* pnDestData, const BYTE* pnSrcData, const LONGLONG nStreamPos, const WORD nBytes)
{
BYTE* pnCurrDest = pnDestData;
const BYTE* pnCurrSrc = pnSrcData;
LONGLONG nCurrPos = nStreamPos;
WORD nBytesLeft = nBytes;
while(nBytesLeft> 0)
{
// initialize codec for current stream position
maCodec.startBlock(lclGetRcfBlock(nCurrPos));
maCodec.skip(lclGetRcfOffset(nCurrPos));
// decode the block
WORD nBlockLeft = static_cast<WORD>(BIFF_RCF_BLOCKSIZE - lclGetRcfOffset(nCurrPos));
WORD nDecBytes = min(nBytesLeft, nBlockLeft);
maCodec.decode(pnCurrDest, pnCurrSrc, static_cast<int>(nDecBytes));
// prepare for next block
pnCurrDest += nDecBytes;
pnCurrSrc += nDecBytes;
nCurrPos += nDecBytes;
nBytesLeft = nBytesLeft - nDecBytes;
}
}
};
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/BiffDecoder_RCF.h deleted 100644 → 0
View file @ 8013237e
#pragma once
#include "BinaryCodec_RCF.h"
#include "rtl/cipher.h"
#include "rtl/digest.h"
namespace CRYPT
{;
const LONGLONG BIFF_RCF_BLOCKSIZE = 1024;
/** Base class for BIFF stream decoders. */
class BiffDecoderBase //: public ::comphelper::IDocPasswordVerifier
{
public:
explicit BiffDecoderBase();
virtual ~BiffDecoderBase();
/** Implementation of the ::comphelper::IDocPasswordVerifier interface,
calls the new virtual function implVerify(). */
virtual bool verifyPassword( const std::wstring& rPassword );
/** Returns true, if the decoder has been initialized correctly. */
inline bool isValid() const { return mbValid; }
/** Decodes nBytes bytes and writes encrypted data into the buffer pnDestData. */
void decode(BYTE* pnDestData, const BYTE* pnSrcData, const LONGLONG nStreamPos, const WORD nBytes);
private:
/** Derived classes implement password verification and initialization of
the decoder. */
virtual bool implVerify(const std::wstring& rPassword) = 0;
/** Implementation of decryption of a memory block. */
virtual void implDecode(BYTE* pnDestData, const BYTE* pnSrcData, const LONGLONG nStreamPos, const WORD nBytes) = 0;
private:
bool mbValid; /// True = decoder is correctly initialized.
};
typedef ::boost::shared_ptr<BiffDecoderBase> BiffDecoderRef;
class BiffDecoder_RCF : public BiffDecoderBase
{
public:
explicit BiffDecoder_RCF(BYTE pnSalt[ 16 ], BYTE pnVerifier[ 16 ], BYTE pnVerifierHash[ 16 ]);
private:
/** Implements password verification and initialization of the decoder. */
virtual bool implVerify(const std::wstring& rPassword);
/** Implementation of decryption of a memory block. */
virtual void implDecode(BYTE* pnDestData, const BYTE* pnSrcData, const LONGLONG nStreamPos, const WORD nBytes);
private:
BinaryCodec_RCF maCodec; /// Cipher algorithm implementation.
std::vector<WORD> maPassword;
std::vector<BYTE> maSalt;
std::vector<BYTE> maVerifier;
std::vector<BYTE> maVerifierHash;
};
} // namespace CRYPT
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/BinaryCodec_RCF.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "BinaryCodec_RCF.h"
namespace CRYPT
{;
BinaryCodec_RCF::BinaryCodec_RCF()
{
(void)memset( mpnDigestValue, 0, sizeof( mpnDigestValue ) );
}
BinaryCodec_RCF::~BinaryCodec_RCF()
{
(void)memset( mpnDigestValue, 0, sizeof( mpnDigestValue ) );
}
void BinaryCodec_RCF::initKey( const WORD pnPassData[ 16 ], const BYTE pnSalt[ 16 ] )
{
// create little-endian key data array from password data
BYTE pnKeyData[ 64 ];
(void)memset( pnKeyData, 0, sizeof( pnKeyData ) );
const WORD* pnCurrPass = pnPassData;
const WORD* pnPassEnd = pnPassData + 16;
BYTE* pnCurrKey = pnKeyData;
size_t nPassSize = 0;
for( ; (pnCurrPass < pnPassEnd) && (*pnCurrPass != 0); ++pnCurrPass, ++nPassSize )
{
*pnCurrKey++ = static_cast< BYTE >( *pnCurrPass );
*pnCurrKey++ = static_cast< BYTE >( *pnCurrPass >> 8 );
}
pnKeyData[ 2 * nPassSize ] = 0x80;
pnKeyData[ 56 ] = static_cast< BYTE >( nPassSize << 4 );
// fill raw digest of key data into key data
mhDigest.Update(pnKeyData, sizeof( pnKeyData ) );
mhDigest.Raw(pnKeyData, DigestMD5::RTL_DIGEST_LENGTH_MD5 );
// update digest with key data and passed salt data
for( size_t nIndex = 0; nIndex < 16; ++nIndex )
{
mhDigest.Update(pnKeyData, 5 );
mhDigest.Update(pnSalt, 16 );
}
// update digest with padding
pnKeyData[ 16 ] = 0x80;
(void)memset( pnKeyData + 17, 0, sizeof( pnKeyData ) - 17 );
pnKeyData[ 56 ] = 0x80;
pnKeyData[ 57 ] = 0x0A;
mhDigest.Update(pnKeyData + 16, sizeof( pnKeyData ) - 16 );
// fill raw digest of above updates into digest value
mhDigest.Raw(mpnDigestValue, sizeof( mpnDigestValue ) );
// erase key data array and leave
(void)memset( pnKeyData, 0, sizeof( pnKeyData ) );
}
bool BinaryCodec_RCF::verifyKey( const BYTE pnVerifier[ 16 ], const BYTE pnVerifierHash[ 16 ] )
{
if( !startBlock( 0 ) )
return false;
BYTE pnDigest[ DigestMD5::RTL_DIGEST_LENGTH_MD5 ];
BYTE pnBuffer[ 64 ];
// decode salt data into buffer
mhCipher.Decode(pnVerifier, 16, pnBuffer, sizeof(pnBuffer));
pnBuffer[ 16 ] = 0x80;
(void)memset( pnBuffer + 17, 0, sizeof( pnBuffer ) - 17 );
pnBuffer[ 56 ] = 0x80;
// fill raw digest of buffer into digest
mhDigest.Update(pnBuffer, sizeof( pnBuffer ) );
mhDigest.Raw(pnDigest, sizeof( pnDigest ) );
// decode original salt digest into buffer
mhCipher.Decode(pnVerifierHash, 16, pnBuffer, sizeof(pnBuffer));
// compare buffer with computed digest
bool bResult = memcmp( pnBuffer, pnDigest, sizeof( pnDigest ) ) == 0;
// erase buffer and digest arrays and leave
(void)memset( pnBuffer, 0, sizeof( pnBuffer ) );
(void)memset( pnDigest, 0, sizeof( pnDigest ) );
return bResult;
}
bool BinaryCodec_RCF::startBlock( size_t nCounter )
{
// initialize key data array
BYTE pnKeyData[ 64 ];
(void)memset( pnKeyData, 0, sizeof( pnKeyData ) );
// fill 40 bit of digest value into [0..4]
(void)memcpy( pnKeyData, mpnDigestValue, 5 );
// fill little-endian counter into [5..8], static_cast masks out unneeded bits
pnKeyData[ 5 ] = static_cast<BYTE>( nCounter );
pnKeyData[ 6 ] = static_cast<BYTE>( nCounter >> 8 );
pnKeyData[ 7 ] = static_cast<BYTE>( nCounter >> 16 );
pnKeyData[ 8 ] = static_cast<BYTE>( nCounter >> 24 );
pnKeyData[ 9 ] = 0x80;
pnKeyData[ 56 ] = 0x48;
// fill raw digest of key data into key data
mhDigest.Update(pnKeyData, sizeof( pnKeyData ) );
mhDigest.Raw(pnKeyData, DigestMD5::RTL_DIGEST_LENGTH_MD5 );
// initialize cipher with key data (for decoding)
CipherARCFOUR::rtlCipherError eResult = mhCipher.Init(CipherARCFOUR::rtl_Cipher_DirectionDecode, pnKeyData, DigestMD5::RTL_DIGEST_LENGTH_MD5, 0, 0 );
// rrase key data array and leave
(void)memset( pnKeyData, 0, sizeof( pnKeyData ) );
return eResult == CipherARCFOUR::rtl_Cipher_E_None;
}
bool BinaryCodec_RCF::decode( BYTE* pnDestData, const BYTE* pnSrcData, size_t nBytes )
{
return CipherARCFOUR::rtl_Cipher_E_None == mhCipher.Decode(pnSrcData, static_cast<size_t>(nBytes), pnDestData, static_cast<size_t>(nBytes));
}
bool BinaryCodec_RCF::skip( size_t nBytes )
{
// decode dummy data in memory to update internal state of RC4 cipher
BYTE pnDummy[ 1024 ];
size_t nBytesLeft = nBytes;
bool bResult = true;
while(bResult && (nBytesLeft > 0))
{
size_t nBlockLen = min(nBytesLeft, sizeof(pnDummy));
bResult = decode(pnDummy, pnDummy, nBlockLen);
nBytesLeft -= nBlockLen;
}
return bResult;
}
};
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/BinaryCodec_RCF.h deleted 100644 → 0
View file @ 8013237e
#pragma once
#include "Crypt.h"
#include "rtl/cipher.h"
#include "rtl/digest.h"
namespace CRYPT
{;
/** Encodes and decodes data from protected MSO 97+ documents.
This is a wrapper class around low level cryptographic functions from RTL.
Implementation is based on the wvDecrypt package by Caolan McNamara:
http://www.csn.ul.ie/~caolan/docs/wvDecrypt.html
*/
class BinaryCodec_RCF
{
public:
/** Default constructor.
Two-step construction in conjunction with the initKey() and verifyKey()
functions allows to try to initialize with different passwords (e.g.
built-in default password used for Excel workbook protection).
*/
explicit BinaryCodec_RCF();
~BinaryCodec_RCF();
/** Initializes the algorithm with the specified password and document ID.
@param pnPassData
Unicode character array containing the password. Must be zero
terminated, which results in a maximum length of 15 characters.
@param pnSalt
Random salt data block read from or written to the file.
*/
void initKey(const WORD pnPassData[ 16 ], const BYTE pnSalt[ 16 ] );
/** Verifies the validity of the password using the passed salt data.
@precond
The codec must be initialized with the initKey() function before
this function can be used.
@param pnVerifier
Verifier block read from the file.
@param pnVerifierHash
Verifier hash read from the file.
@return
True = test was successful.
*/
bool verifyKey(const BYTE pnVerifier[ 16 ], const BYTE pnVerifierHash[ 16 ] );
/** Rekeys the codec using the specified counter.
After reading a specific amount of data the cipher algorithm needs to
be rekeyed using a counter that counts the data blocks.
The block size is for example 512 bytes for MS Word files and 1024
bytes for MS Excel files.
@precond
The codec must be initialized with the initKey() function before
this function can be used.
@param nCounter
Block counter used to rekey the cipher.
*/
bool startBlock( size_t nCounter );
/** Decodes a block of memory.
@see rtl_cipher_decode()
@precond
The codec must be initialized with the initKey() function before
this function can be used.
@param pnDestData
Destination buffer. Will contain the decrypted data afterwards.
@param pnSrcData
Encrypted data block.
@param nBytes
Size of the passed data blocks. pnDestData and pnSrcData must be of
this size.
@return
True = decoding was successful (no error occured).
*/
bool decode(BYTE* pnDestData, const BYTE* pnSrcData, size_t nBytes );
/** Lets the cipher skip a specific amount of bytes.
This function sets the cipher to the same state as if the specified
amount of data has been decoded with one or more calls of decode().
@precond
The codec must be initialized with the initKey() function before
this function can be used.
@param nBytes
Number of bytes to be skipped (cipher "seeks" forward).
@return
True = skip was successful (no error occured).
*/
bool skip( size_t nBytes );
private:
CipherARCFOUR mhCipher;
DigestMD5 mhDigest;
BYTE mpnDigestValue[DigestMD5::RTL_DIGEST_LENGTH_MD5];
};
} // namespace CRYPT
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/Crypt.h deleted 100644 → 0
View file @ 8013237e
#pragma once
namespace CRYPT
{;
class Crypt
{
public:
virtual void Encrypt(char* data, const size_t size) = 0;
virtual void Decrypt(char* data, const size_t size, const ULONGLONG stream_pos) = 0;
typedef enum
{
RC4,
RC4CryptoAPI,
XOR
} crypt_type;
};
typedef boost::shared_ptr<Crypt> CryptPtr;
} // namespace CRYPT
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/Decryptor.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "Decryptor.h"
#include "RC4Crypt.h"
#include <XLS_logic/Biff_structures/RC4EncryptionHeader.h>
//#include <XLS_logic/Biff_structures/RC4CryptoAPIEncryptionHeader.h>
namespace CRYPT
{;
Decryptor::Decryptor(const CRYPTO::RC4EncryptionHeader& header)
: crypt(new RC4Crypt(header)),
type(Crypt::RC4)
{
}
void Decryptor::Decrypt(char* data, const size_t size, const ULONGLONG stream_pos)
{
crypt->Decrypt(data, size, stream_pos);
}
};
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/Decryptor.h deleted 100644 → 0
View file @ 8013237e
#pragma once
#include "Crypt.h"
namespace CRYPTO
{;
class RC4EncryptionHeader;
} // namespace CRYPTO
namespace CRYPT
{;
class Decryptor
{
public:
Decryptor(const CRYPTO::RC4EncryptionHeader& header);
void Decrypt(char* data, const size_t size, const ULONGLONG stream_pos);
private:
CryptPtr crypt;
Crypt::crypt_type type;
};
typedef boost::shared_ptr<Decryptor> DecryptorPtr;
} // namespace CRYPT
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/RC4Crypt.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "RC4Crypt.h"
#include <boost/scoped_array.hpp>
namespace CRYPT
{;
RC4Crypt::RC4Crypt(const CRYPTO::RC4EncryptionHeader& header)
{
CopyDWORDs2BYTEs(header.Salt.b1, header.Salt.b2, header.Salt.b3, header.Salt.b4, pnSalt);
CopyDWORDs2BYTEs(header.EncryptedVerifier.b1, header.EncryptedVerifier.b2, header.EncryptedVerifier.b3, header.EncryptedVerifier.b4, pnVerifier);
CopyDWORDs2BYTEs(header.EncryptedVerifierHash.b1, header.EncryptedVerifierHash.b2, header.EncryptedVerifierHash.b3, header.EncryptedVerifierHash.b4, pnVerifierHash);
mxDecoder.reset(new BiffDecoder_RCF(pnSalt, pnVerifier, pnVerifierHash));
mxDecoder->verifyPassword(L"VelvetSweatshop");
}
void RC4Crypt::Encrypt(char* data, const size_t size)
{
}
void RC4Crypt::CopyDWORDs2BYTEs(const DWORD b1, const DWORD b2, const DWORD b3, const DWORD b4, BYTE* byte_array)
{
byte_array[0] = static_cast<BYTE>((b1 & 0x000000ff) >> 0);
byte_array[1] = static_cast<BYTE>((b1 & 0x0000ff00) >> 8);
byte_array[2] = static_cast<BYTE>((b1 & 0x00ff0000) >> 16);
byte_array[3] = static_cast<BYTE>((b1 & 0xff000000) >> 24);
byte_array[4] = static_cast<BYTE>((b2 & 0x000000ff) >> 0);
byte_array[5] = static_cast<BYTE>((b2 & 0x0000ff00) >> 8);
byte_array[6] = static_cast<BYTE>((b2 & 0x00ff0000) >> 16);
byte_array[7] = static_cast<BYTE>((b2 & 0xff000000) >> 24);
byte_array[8] = static_cast<BYTE>((b3 & 0x000000ff) >> 0);
byte_array[9] = static_cast<BYTE>((b3 & 0x0000ff00) >> 8);
byte_array[10] = static_cast<BYTE>((b3 & 0x00ff0000) >> 16);
byte_array[11] = static_cast<BYTE>((b3 & 0xff000000) >> 24);
byte_array[12] = static_cast<BYTE>((b4 & 0x000000ff) >> 0);
byte_array[13] = static_cast<BYTE>((b4 & 0x0000ff00) >> 8);
byte_array[14] = static_cast<BYTE>((b4 & 0x00ff0000) >> 16);
byte_array[15] = static_cast<BYTE>((b4 & 0xff000000) >> 24);
}
void RC4Crypt::Decrypt(char* data, const size_t size, const ULONGLONG stream_pos)
{
static BYTE quick_buf[256];
if(size <= 256)
{
mxDecoder->decode( quick_buf, reinterpret_cast<BYTE*>(data), stream_pos, size );
memcpy_s(data, size, quick_buf, size);
}
else
{
boost::scoped_array<BYTE> out_data(new BYTE[size]);
mxDecoder->decode( out_data.get(), reinterpret_cast<BYTE*>(data), stream_pos, size );
memcpy_s(data, size, out_data.get(), size);
}
}
};
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/RC4Crypt.h deleted 100644 → 0
View file @ 8013237e
#pragma once
#include "Crypt.h"
#include <XLS_logic/Biff_structures/RC4EncryptionHeader.h>
#include "BiffDecoder_RCF.h"
namespace CRYPT
{;
class RC4Crypt : public Crypt
{
public:
RC4Crypt(const CRYPTO::RC4EncryptionHeader& header);
virtual void Encrypt(char* data, const size_t size);
virtual void Decrypt(char* data, const size_t size, const ULONGLONG stream_pos);
private:
void CopyDWORDs2BYTEs(const DWORD b1, const DWORD b2, const DWORD b3, const DWORD b4, BYTE* byte_array);
private:
BYTE pnSalt[16];
BYTE pnVerifier[16];
BYTE pnVerifierHash[16];
BiffDecoderRef mxDecoder;
};
} // namespace CRYPT
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/rtl/cipher.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "cipher.h"
CipherARCFOUR::CipherARCFOUR()
: m_direction(rtl_Cipher_DirectionInvalid)
{
}
CipherARCFOUR::rtlCipherError CipherARCFOUR::Init(CipherARCFOUR::rtlCipherDirection Direction, const BYTE *pKeyData, const size_t nKeyLen, const BYTE *pArgData, const size_t nArgLen)
{
if (pKeyData == NULL)
{
return rtl_Cipher_E_Argument;
}
if (Direction != rtl_Cipher_DirectionInvalid)
{
m_direction = Direction;
}
else
{
return rtl_Cipher_E_Direction;
}
unsigned int K[CIPHER_CBLOCK_ARCFOUR];
unsigned int *L, *S;
unsigned int x, y, t;
size_t n, k;
S = &(m_context.m_S[0]);
/* Initialize S linearly. */
for (x = 0; x < CIPHER_CBLOCK_ARCFOUR; x++)
S[x] = x;
/* Initialize K with key, repeat key as necessary. */
for (L = K, n = CIPHER_CBLOCK_ARCFOUR; n > nKeyLen; n -= nKeyLen)
{
for (k = 0; k < nKeyLen; k++) L[k] = pKeyData[k];
L += nKeyLen;
}
for (k = 0; k < n; k++) L[k] = pKeyData[k];
/* Initialize S with K. */
for (x = 0, y = 0; x < CIPHER_CBLOCK_ARCFOUR; x++)
{
y = (y + S[x] + K[x]) % CIPHER_CBLOCK_ARCFOUR;
t = S[x], S[x] = S[y], S[y] = t; /* swap S[x] and S[y] */
}
/* Initialize counters X and Y. */
m_context.m_X = 0;
m_context.m_Y = 0;
return rtl_Cipher_E_None;
}
CipherARCFOUR::rtlCipherError CipherARCFOUR::Encode(const void *pvData, const size_t nDatLen, BYTE *pBuffer, const size_t nBufLen)
{
if (m_direction == rtl_Cipher_DirectionInvalid)
{
return rtl_Cipher_E_Direction;
}
return Update((const BYTE*)pvData, nDatLen, pBuffer, nBufLen);
}
CipherARCFOUR::rtlCipherError CipherARCFOUR::Decode(const void *pvData, const size_t nDatLen, BYTE *pBuffer, const size_t nBufLen)
{
if (m_direction == rtl_Cipher_DirectionInvalid)
{
return rtl_Cipher_E_Direction;
}
return Update((const BYTE*)pvData, nDatLen, pBuffer, nBufLen);
}
CipherARCFOUR::rtlCipherError CipherARCFOUR::Update(const BYTE *pData, const size_t nDatLen, BYTE *pBuffer, const size_t nBufLen)
{
register unsigned int *S;
register unsigned int x, y, t;
size_t k;
/* Check arguments. */
if ((pData == NULL) || (pBuffer == NULL))
return rtl_Cipher_E_Argument;
if (!((0 < nDatLen) && (nDatLen <= nBufLen)))
return rtl_Cipher_E_BufferSize;
/* Update. */
S = &(m_context.m_S[0]);
for (k = 0; k < nDatLen; k++)
{
/* Update counters X and Y. */
x = m_context.m_X;
y = m_context.m_Y;
x = (x + 1 ) % CIPHER_CBLOCK_ARCFOUR;
y = (y + S[x]) % CIPHER_CBLOCK_ARCFOUR;
m_context.m_X = x;
m_context.m_Y = y;
/* Swap S[x] and S[y]. */
t = S[x], S[x] = S[y], S[y] = t;
/* Evaluate next key byte S[t]. */
t = (S[x] + S[y]) % CIPHER_CBLOCK_ARCFOUR;
pBuffer[k] = pData[k] ^ ((BYTE)(S[t] & 0xff));
}
return rtl_Cipher_E_None;
}
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/rtl/cipher.h deleted 100644 → 0
View file @ 8013237e
#pragma once
class CipherARCFOUR
{
public:
typedef enum
{
rtl_Cipher_DirectionBoth,
rtl_Cipher_DirectionDecode,
rtl_Cipher_DirectionEncode,
rtl_Cipher_DirectionInvalid,
} rtlCipherDirection;
typedef enum
{
rtl_Cipher_E_None,
rtl_Cipher_E_Argument,
rtl_Cipher_E_Direction,
rtl_Cipher_E_BufferSize,
} rtlCipherError;
public:
CipherARCFOUR();
rtlCipherError Init(rtlCipherDirection Direction, const BYTE *pKeyData, const size_t nKeyLen, const BYTE *pArgData, const size_t nArgLen);
rtlCipherError Encode(const void *pData, const size_t nDatLen, BYTE *pBuffer, const size_t nBufLen);
rtlCipherError Decode(const void *pData, const size_t nDatLen, BYTE *pBuffer, const size_t nBufLen);
private:
rtlCipherError Update(const BYTE *pData, const size_t nDatLen, BYTE *pBuffer, const size_t nBufLen);
private:
static const unsigned int CIPHER_CBLOCK_ARCFOUR = 256;
typedef struct
{
unsigned int m_S[CIPHER_CBLOCK_ARCFOUR];
unsigned int m_X, m_Y;
} CipherContext;
rtlCipherDirection m_direction;
CipherContext m_context;
};
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/rtl/digest.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "digest.h"
#define RTL_DIGEST_ROTL(a,n) (((a) << (n)) | ((a) >> (32 - (n))))
#define RTL_DIGEST_LTOC(l,c) \
(*((c)++) = (BYTE)(((l) ) & 0xff), \
*((c)++) = (BYTE)(((l) >> 8L) & 0xff), \
*((c)++) = (BYTE)(((l) >> 16L) & 0xff), \
*((c)++) = (BYTE)(((l) >> 24L) & 0xff))
#define F(x,y,z) ((((y) ^ (z)) & (x)) ^ (z))
#define G(x,y,z) ((((x) ^ (y)) & (z)) ^ (y))
#define H(x,y,z) ((x) ^ (y) ^ (z))
#define I(x,y,z) (((x) | (~(z))) ^ (y))
#define R0(a,b,c,d,k,s,t) { \
a += ((k) + (t) + F((b), (c), (d))); \
a = RTL_DIGEST_ROTL(a, s); \
a += b; }
#define R1(a,b,c,d,k,s,t) { \
a += ((k) + (t) + G((b), (c), (d))); \
a = RTL_DIGEST_ROTL(a, s); \
a += b; }
#define R2(a,b,c,d,k,s,t) { \
a += ((k) + (t) + H((b), (c), (d))); \
a = RTL_DIGEST_ROTL(a, s); \
a += b; }
#define R3(a,b,c,d,k,s,t) { \
a += ((k) + (t) + I((b), (c), (d))); \
a = RTL_DIGEST_ROTL(a, s); \
a += b; }
DigestMD5::DigestMD5()
{
InitContext();
}
void DigestMD5::InitContext()
{
memset(&m_context, 0, sizeof (DigestContextMD5));
m_context.m_nA = (DWORD)0x67452301L;
m_context.m_nB = (DWORD)0xefcdab89L;
m_context.m_nC = (DWORD)0x98badcfeL;
m_context.m_nD = (DWORD)0x10325476L;
}
void DigestMD5::UpdateContext()
{
register DWORD A, B, C, D;
register DWORD *X;
A = m_context.m_nA;
B = m_context.m_nB;
C = m_context.m_nC;
D = m_context.m_nD;
X = m_context.m_pData;
R0 (A, B, C, D, X[ 0], 7, 0xd76aa478L);
R0 (D, A, B, C, X[ 1], 12, 0xe8c7b756L);
R0 (C, D, A, B, X[ 2], 17, 0x242070dbL);
R0 (B, C, D, A, X[ 3], 22, 0xc1bdceeeL);
R0 (A, B, C, D, X[ 4], 7, 0xf57c0fafL);
R0 (D, A, B, C, X[ 5], 12, 0x4787c62aL);
R0 (C, D, A, B, X[ 6], 17, 0xa8304613L);
R0 (B, C, D, A, X[ 7], 22, 0xfd469501L);
R0 (A, B, C, D, X[ 8], 7, 0x698098d8L);
R0 (D, A, B, C, X[ 9], 12, 0x8b44f7afL);
R0 (C, D, A, B, X[10], 17, 0xffff5bb1L);
R0 (B, C, D, A, X[11], 22, 0x895cd7beL);
R0 (A, B, C, D, X[12], 7, 0x6b901122L);
R0 (D, A, B, C, X[13], 12, 0xfd987193L);
R0 (C, D, A, B, X[14], 17, 0xa679438eL);
R0 (B, C, D, A, X[15], 22, 0x49b40821L);
R1 (A, B, C, D, X[ 1], 5, 0xf61e2562L);
R1 (D, A, B, C, X[ 6], 9, 0xc040b340L);
R1 (C, D, A, B, X[11], 14, 0x265e5a51L);
R1 (B, C, D, A, X[ 0], 20, 0xe9b6c7aaL);
R1 (A, B, C, D, X[ 5], 5, 0xd62f105dL);
R1 (D, A, B, C, X[10], 9, 0x02441453L);
R1 (C, D, A, B, X[15], 14, 0xd8a1e681L);
R1 (B, C, D, A, X[ 4], 20, 0xe7d3fbc8L);
R1 (A, B, C, D, X[ 9], 5, 0x21e1cde6L);
R1 (D, A, B, C, X[14], 9, 0xc33707d6L);
R1 (C, D, A, B, X[ 3], 14, 0xf4d50d87L);
R1 (B, C, D, A, X[ 8], 20, 0x455a14edL);
R1 (A, B, C, D, X[13], 5, 0xa9e3e905L);
R1 (D, A, B, C, X[ 2], 9, 0xfcefa3f8L);
R1 (C, D, A, B, X[ 7], 14, 0x676f02d9L);
R1 (B, C, D, A, X[12], 20, 0x8d2a4c8aL);
R2 (A, B, C, D, X[ 5], 4, 0xfffa3942L);
R2 (D, A, B, C, X[ 8], 11, 0x8771f681L);
R2 (C, D, A, B, X[11], 16, 0x6d9d6122L);
R2 (B, C, D, A, X[14], 23, 0xfde5380cL);
R2 (A, B, C, D, X[ 1], 4, 0xa4beea44L);
R2 (D, A, B, C, X[ 4], 11, 0x4bdecfa9L);
R2 (C, D, A, B, X[ 7], 16, 0xf6bb4b60L);
R2 (B, C, D, A, X[10], 23, 0xbebfbc70L);
R2 (A, B, C, D, X[13], 4, 0x289b7ec6L);
R2 (D, A, B, C, X[ 0], 11, 0xeaa127faL);
R2 (C, D, A, B, X[ 3], 16, 0xd4ef3085L);
R2 (B, C, D, A, X[ 6], 23, 0x04881d05L);
R2 (A, B, C, D, X[ 9], 4, 0xd9d4d039L);
R2 (D, A, B, C, X[12], 11, 0xe6db99e5L);
R2 (C, D, A, B, X[15], 16, 0x1fa27cf8L);
R2 (B, C, D, A, X[ 2], 23, 0xc4ac5665L);
R3 (A, B, C, D, X[ 0], 6, 0xf4292244L);
R3 (D, A, B, C, X[ 7], 10, 0x432aff97L);
R3 (C, D, A, B, X[14], 15, 0xab9423a7L);
R3 (B, C, D, A, X[ 5], 21, 0xfc93a039L);
R3 (A, B, C, D, X[12], 6, 0x655b59c3L);
R3 (D, A, B, C, X[ 3], 10, 0x8f0ccc92L);
R3 (C, D, A, B, X[10], 15, 0xffeff47dL);
R3 (B, C, D, A, X[ 1], 21, 0x85845dd1L);
R3 (A, B, C, D, X[ 8], 6, 0x6fa87e4fL);
R3 (D, A, B, C, X[15], 10, 0xfe2ce6e0L);
R3 (C, D, A, B, X[ 6], 15, 0xa3014314L);
R3 (B, C, D, A, X[13], 21, 0x4e0811a1L);
R3 (A, B, C, D, X[ 4], 6, 0xf7537e82L);
R3 (D, A, B, C, X[11], 10, 0xbd3af235L);
R3 (C, D, A, B, X[ 2], 15, 0x2ad7d2bbL);
R3 (B, C, D, A, X[ 9], 21, 0xeb86d391L);
m_context.m_nA += A;
m_context.m_nB += B;
m_context.m_nC += C;
m_context.m_nD += D;
}
void DigestMD5::EndContext()
{
static const BYTE end[4] =
{
0x80, 0x00, 0x00, 0x00
};
register const BYTE *p = end;
register DWORD *X;
register int i;
X = m_context.m_pData;
i = (m_context.m_nDatLen >> 2);
switch (m_context.m_nDatLen & 0x03)
{
case 1: X[i] &= 0x000000ff; break;
case 2: X[i] &= 0x0000ffff; break;
case 3: X[i] &= 0x00ffffff; break;
}
switch (m_context.m_nDatLen & 0x03)
{
case 0: X[i] = ((DWORD)(*(p++))) << 0L;
case 1: X[i] |= ((DWORD)(*(p++))) << 8L;
case 2: X[i] |= ((DWORD)(*(p++))) << 16L;
case 3: X[i] |= ((DWORD)(*(p++))) << 24L;
}
i += 1;
if (i >= (DIGEST_LBLOCK_MD5 - 2))
{
for (; i < DIGEST_LBLOCK_MD5; i++)
X[i] = 0;
UpdateContext();
i = 0;
}
for (; i < (DIGEST_LBLOCK_MD5 - 2); i++)
X[i] = 0;
X[DIGEST_LBLOCK_MD5 - 2] = m_context.m_nL;
X[DIGEST_LBLOCK_MD5 - 1] = m_context.m_nH;
UpdateContext();
}
DigestMD5::rtlDigestError DigestMD5::Update(const void *pData, const DWORD nDatLen)
{
if (nDatLen == 0)
return rtl_Digest_E_None;
DWORD data_len_left = nDatLen;
DWORD len_calc_tmp;
len_calc_tmp = m_context.m_nL + (data_len_left << 3);
if (len_calc_tmp < m_context.m_nL) m_context.m_nH += 1;
m_context.m_nH += (data_len_left >> 29);
m_context.m_nL = len_calc_tmp;
const BYTE *d = (const BYTE *)pData;
if (m_context.m_nDatLen)
{
BYTE *p = (BYTE *)(m_context.m_pData) + m_context.m_nDatLen;
DWORD n = DIGEST_CBLOCK_MD5 - m_context.m_nDatLen;
if (data_len_left < n)
{
memcpy(p, d, data_len_left);
m_context.m_nDatLen += data_len_left;
return rtl_Digest_E_None;
}
memcpy (p, d, n);
d += n;
data_len_left -= n;
UpdateContext();
m_context.m_nDatLen = 0;
}
while (data_len_left >= DIGEST_CBLOCK_MD5)
{
memcpy (m_context.m_pData, d, DIGEST_CBLOCK_MD5);
d += DIGEST_CBLOCK_MD5;
data_len_left -= DIGEST_CBLOCK_MD5;
UpdateContext();
}
memcpy (m_context.m_pData, d, data_len_left);
m_context.m_nDatLen = data_len_left;
return rtl_Digest_E_None;
}
DigestMD5::rtlDigestError DigestMD5::Get(BYTE *pBuffer, const DWORD nBufLen)
{
BYTE *p = pBuffer;
if ((pBuffer == NULL))
return rtl_Digest_E_Argument;
if (!(RTL_DIGEST_LENGTH_MD5 <= nBufLen))
return rtl_Digest_E_BufferSize;
EndContext();
RTL_DIGEST_LTOC (m_context.m_nA, p);
RTL_DIGEST_LTOC (m_context.m_nB, p);
RTL_DIGEST_LTOC (m_context.m_nC, p);
RTL_DIGEST_LTOC (m_context.m_nD, p);
InitContext();
return rtl_Digest_E_None;
}
DigestMD5::rtlDigestError DigestMD5::Raw(BYTE *pBuffer, const DWORD nBufLen)
{
BYTE *p = pBuffer;
if (pBuffer == NULL)
return rtl_Digest_E_Argument;
if (!(RTL_DIGEST_LENGTH_MD5 <= nBufLen))
return rtl_Digest_E_BufferSize;
/* EndContext(); *//* not finalized */
RTL_DIGEST_LTOC (m_context.m_nA, p);
RTL_DIGEST_LTOC (m_context.m_nB, p);
RTL_DIGEST_LTOC (m_context.m_nC, p);
RTL_DIGEST_LTOC (m_context.m_nD, p);
InitContext();
return rtl_Digest_E_None;
}
ASCOfficeXlsFile/ASCWorksheetConverter/source/Crypt/rtl/digest.h deleted 100644 → 0
View file @ 8013237e
#pragma once
class DigestMD5
{
public:
typedef enum
{
rtl_Digest_E_None,
rtl_Digest_E_Argument,
rtl_Digest_E_BufferSize,
} rtlDigestError;
public:
DigestMD5();
rtlDigestError Update(const void *pData, const DWORD nDatLen);
rtlDigestError Get(BYTE *pBuffer, const DWORD nBufLen);
rtlDigestError Raw (BYTE *pBuffer, const DWORD nBufLen);
static const unsigned int RTL_DIGEST_LENGTH_MD5 = 16;
private:
void InitContext();
void UpdateContext();
void EndContext();
private:
static const unsigned int DIGEST_CBLOCK_MD5 = 64;
static const unsigned int DIGEST_LBLOCK_MD5 = 16;
typedef struct digestMD5_context_st
{
DWORD m_nDatLen;
DWORD m_pData[DIGEST_LBLOCK_MD5];
DWORD m_nA, m_nB, m_nC, m_nD;
DWORD m_nL, m_nH;
} DigestContextMD5;
DigestContextMD5 m_context;
};
ASCOfficeXlsFile/ASCWorksheetConverter/source/Document/Document.cpp deleted 100644 → 0
View file @ 8013237e
#include "stdafx.h"
#include "Document.h"
//#import <msxml6.dll>
std::map<_bstr_t, Document*> Document::all_documents;
Document::Document(const _bstr_t& root_name)
: xmlDoc(_T("Msxml2.DOMDocument.6.0"))
{
xmlDoc->setProperty(L"SelectionNamespaces", L"xmlns:xlsx='http://www.avs4you.ru/XLSXConverter/1.0/DirectoryStructure'");
newXMLDoc(L"root");
}
Document::~Document()
{
all_documents[guid_] = NULL;
}
MSXML2::IXMLDOMElementPtr Document::getRoot() const
{
return xmlDoc->GetdocumentElement(); // current root independent on its name
}
MSXML2::IXMLDOMDocument3Ptr Document::getDoc() const
{
return xmlDoc;
}
void Document::newXMLDoc(const _bstr_t& root_name)
{
if(!!guid_)
{
all_documents.erase(guid_);
}
GUID guid = {0};
CoCreateGuid(&guid);
guid_ = STR::guid2bstr(guid);
xmlDoc->loadXML(L"<?xml version=\"1.0\" encoding=\"utf-8\" ?> <" + root_name +
L" id=\"" + guid_ + L"\"/>"); // Initial tag;
all_documents[guid_] = this;
}
void Document::setDoc(MSXML2::IXMLDOMDocument3Ptr doc)
{
xmlDoc = doc;
}
const int Document::appendBinaryData(MSXML2::IXMLDOMElementPtr elem, const char * data, const size_t size)
{
boost::shared_array<char> buffer(new char[size]);
memcpy_s(buffer.get(), size, data, size);
return appendBinaryData(elem, buffer, size);
}
const int Document::appendBinaryData(MSXML2::IXMLDOMElementPtr elem, boost::shared_array<char>& pre_allocated_data, const size_t size)
{
_bstr_t name = elem->tagName;
Document* doc = findDocumentByXMLElement(elem);
if(!doc)
{
return -1;
}
doc->bin_data.push_back(std::pair<boost::shared_array<char>, size_t>(pre_allocated_data, size));
return doc->bin_data.size() - 1;
}
const std::pair<char*, size_t> Document::getBinaryData(const int index) const
{
if(index < 0 || static_cast<size_t>(index) > bin_data.size() - 1)
{
return std::pair<char*, size_t>(NULL, 0);
}
return std::pair<char*, size_t>(bin_data[index].first.get(), bin_data[index].second);
}
Document* Document::findDocumentByXMLElement(MSXML2::IXMLDOMElementPtr elem)
{
return all_documents[static_cast<_bstr_t>(elem->GetownerDocument()->GetdocumentElement()->getAttribute(L"id"))];
}
ASCOfficeXlsFile/ASCWorksheetConverter/source/Document/Document.h deleted 100644 → 0
View file @ 8013237e
#pragma once
class Document;
typedef boost::shared_ptr<Document> DocumentPtr;
class Document
{
public:
Document(const _bstr_t& root_name);
~Document();
MSXML2::IXMLDOMElementPtr getRoot() const;
MSXML2::IXMLDOMDocument3Ptr getDoc() const;
void newXMLDoc(const _bstr_t& root_name);
void setDoc(MSXML2::IXMLDOMDocument3Ptr doc);
static const int appendBinaryData(MSXML2::IXMLDOMElementPtr elem, const char * data, const size_t size);
static const int appendBinaryData(MSXML2::IXMLDOMElementPtr elem, boost::shared_array<char>& pre_allocated_data, const size_t size);
static Document* findDocumentByXMLElement(MSXML2::IXMLDOMElementPtr elem);
const std::pair<char*, size_t> getBinaryData(const int index) const;
private:
MSXML2::IXMLDOMDocument3Ptr xmlDoc;
std::vector<std::pair<boost::shared_array<char>, size_t> > bin_data;
_bstr_t guid_;
private:
static std::map<_bstr_t, Document*> all_documents;
};
ASCOfficeXlsFile/ASCWorksheetConverter/source/Document/EWSDocument.h deleted 100644 → 0
View file @ 8013237e
#pragma once
typedef enum {
ef_XLS,
ef_XLSX,
ef_ODS,
ef_SXC,
ef_XML,
ef_AUTO_DETECT,
ef_END
} EWS_FORMAT;
class Document;
namespace EWSCORE
{;
class EWSDocument
{
public:
EWSDocument();
~EWSDocument();
public:
bool loadFrom(const _bstr_t& from_filename, const EWS_FORMAT format);
bool saveTo(const _bstr_t& to_folder, const EWS_FORMAT format);
private:
Document* doc_;
};
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7