From 87ec82321011e2237563e7a272e58fe3317dd1f1 Mon Sep 17 00:00:00 2001 From: Christoph Willing Date: Mon, 19 Nov 2018 12:51:06 +1000 Subject: office/LibreOffice: Support new mdds, liborcus Signed-off-by: Christoph Willing --- office/LibreOffice/0001-Update-mdds-to-1.4.1.patch | 693 ++++++++++++++++++ .../LibreOffice/0001-Update-orcus-to-0.14.0.patch | 801 +++++++++++++++++++++ office/LibreOffice/LibreOffice.SlackBuild | 16 +- office/LibreOffice/LibreOffice.info | 4 +- 4 files changed, 1506 insertions(+), 8 deletions(-) create mode 100644 office/LibreOffice/0001-Update-mdds-to-1.4.1.patch create mode 100644 office/LibreOffice/0001-Update-orcus-to-0.14.0.patch (limited to 'office') diff --git a/office/LibreOffice/0001-Update-mdds-to-1.4.1.patch b/office/LibreOffice/0001-Update-mdds-to-1.4.1.patch new file mode 100644 index 0000000000..dc7fcce3af --- /dev/null +++ b/office/LibreOffice/0001-Update-mdds-to-1.4.1.patch @@ -0,0 +1,693 @@ +From 3debd23d47d1fcbef76033c739a0b7003824d4ca Mon Sep 17 00:00:00 2001 +From: Noel Grandin +Date: Sat, 11 Aug 2018 13:25:09 +0200 +Subject: [PATCH] Update mdds to 1.4.1 + +loplugin:constantparam + +Reviewed-on: https://gerrit.libreoffice.org/58875 +Tested-by: Jenkins +Reviewed-by: Noel Grandin +(cherry picked from commit bb6f2b12e8f0bbc99a5ca93141d35fd40b043e55) + +Update mdds to 1.4.1. + +The largest change in 1.4.x relevant to the calc code is that the +multi_type_matrix::walk() methods now take a copy of the function +object rather than a reference, to allow for it to take an inline +lambda function. Instead, it does return a instance of the input +function object, similar to how std::for_each() behaves. + +In case the function object contains a large data member, try to +make it a moveable so that it will get moved rather than copied +when going through one of the walk() methods. + +Reviewed-on: https://gerrit.libreoffice.org/59584 +Tested-by: Jenkins +Reviewed-by: Kohei Yoshida +(cherry picked from commit 51f73f35ea61dd81dd3194af50394b98ff1bf8e9) + +mdds 1.4.1 is now a minimum requirement. + +Reviewed-on: https://gerrit.libreoffice.org/59614 +Tested-by: Jenkins +Reviewed-by: Kohei Yoshida +(cherry picked from commit 4d1f735fcf064b18ef2848cc1f5a2a0616b0b33d) + +fd08fc4a2ed75039e5292a35ff08726e0126c77f +647bcfbdd8e0417990ed93b25c1bca00f60df709 + +Change-Id: I676a8408e97cc8134009f764736cad68513c89ad +--- + configure.ac | 2 +- + download.lst | 4 +- + external/mdds/UnpackedTarball_mdds.mk | 3 - + external/mdds/c++17.patch | 22 --- + sc/inc/scmatrix.hxx | 6 +- + sc/source/core/tool/interpr3.cxx | 4 +- + sc/source/core/tool/scmatrix.cxx | 208 +++++++++++++++++++------- + 7 files changed, 161 insertions(+), 88 deletions(-) + delete mode 100644 external/mdds/c++17.patch + +diff --git a/configure.ac b/configure.ac +index 735ebf2e360a..3ff574a3f24f 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -8883,7 +8883,7 @@ AC_SUBST(SYSTEM_BOOST) + dnl =================================================================== + dnl Check for system mdds + dnl =================================================================== +-libo_CHECK_SYSTEM_MODULE([mdds], [MDDS], [mdds-1.2 >= 1.2.3], ["-I${WORKDIR}/UnpackedTarball/mdds/include"]) ++libo_CHECK_SYSTEM_MODULE([mdds], [MDDS], [mdds-1.4 >= 1.4.1], ["-I${WORKDIR}/UnpackedTarball/mdds/include"]) + + dnl =================================================================== + dnl Check for system glm +diff --git a/download.lst b/download.lst +index c40bece90e26..d4c145a0cfc9 100644 +--- a/download.lst ++++ b/download.lst +@@ -166,8 +166,8 @@ export LXML_SHA256SUM := 940caef1ec7c78e0c34b0f6b94fe42d0f2022915ffc78643d28538a + export LXML_TARBALL := lxml-4.1.1.tgz + export MARIADB_CONNECTOR_C_SHA256SUM := fd2f751dea049c1907735eb236aeace1d811d6a8218118b00bbaa9b84dc5cd60 + export MARIADB_CONNECTOR_C_TARBALL := a233181e03d3c307668b4c722d881661-mariadb_client-2.0.0-src.tar.gz +-export MDDS_SHA256SUM := dcb8cd2425567a5a5ec164afea475bce57784bca3e352ad4cbdd3d1a7e08e5a1 +-export MDDS_TARBALL := mdds-1.3.1.tar.bz2 ++export MDDS_SHA256SUM := 9ac690c37f5f06dc88551405d5daf9d9ad25edf65aae6325b59e905c2ba444c3 ++export MDDS_TARBALL := mdds-1.4.1.tar.bz2 + export MDNSRESPONDER_SHA256SUM := 4737cb51378377e11d0edb7bcdd1bec79cbdaa7b27ea09c13e3006e58f8d92c0 + export MDNSRESPONDER_TARBALL := mDNSResponder-576.30.4.tar.gz + export MSPUB_SHA256SUM := ef36c1a1aabb2ba3b0bedaaafe717bf4480be2ba8de6f3894be5fd3702b013ba +diff --git a/external/mdds/UnpackedTarball_mdds.mk b/external/mdds/UnpackedTarball_mdds.mk +index 4f6db6b24e7b..c015f4c13f5a 100644 +--- a/external/mdds/UnpackedTarball_mdds.mk ++++ b/external/mdds/UnpackedTarball_mdds.mk +@@ -13,10 +13,7 @@ $(eval $(call gb_UnpackedTarball_set_tarball,mdds,$(MDDS_TARBALL))) + + $(eval $(call gb_UnpackedTarball_set_patchlevel,mdds,0)) + +-# c++17.patch upstreamed as "Remove some +-# unnecessary uses of obsolete std::unary_function": + $(eval $(call gb_UnpackedTarball_add_patches,mdds,\ +- external/mdds/c++17.patch \ + )) + + # vim: set noet sw=4 ts=4: +diff --git a/external/mdds/c++17.patch b/external/mdds/c++17.patch +deleted file mode 100644 +index d96910f34e68..000000000000 +--- a/external/mdds/c++17.patch ++++ /dev/null +@@ -1,22 +0,0 @@ +---- include/mdds/multi_type_matrix.hpp +-+++ include/mdds/multi_type_matrix.hpp +-@@ -149,7 +149,7 @@ +- +- private: +- template +-- struct walk_func : std::unary_function +-+ struct walk_func +- { +- _Func& m_func; +- walk_func(_Func& func) : m_func(func) {} +---- include/mdds/multi_type_vector.hpp +-+++ include/mdds/multi_type_vector.hpp +-@@ -139,7 +139,7 @@ +- block& operator=(block); +- }; +- +-- struct element_block_deleter : public std::unary_function +-+ struct element_block_deleter +- { +- void operator() (const element_block_type* p) +- { +diff --git a/sc/inc/scmatrix.hxx b/sc/inc/scmatrix.hxx +index 9be335fbc06b..b1bc5e0e3047 100644 +--- a/sc/inc/scmatrix.hxx ++++ b/sc/inc/scmatrix.hxx +@@ -399,7 +399,7 @@ public: + virtual void DivOp(bool bFlag, double fVal, ScMatrix& rMat) = 0; + virtual void PowOp(bool bFlag, double fVal, ScMatrix& rMat) = 0; + +- virtual std::vector Collect(bool bTextAsZero, const std::vector>& aOp) = 0; ++ virtual std::vector Collect(const std::vector>& aOp) = 0; + + virtual void ExecuteOperation(const std::pair& rStartPos, const std::pair& rEndPos, + DoubleOpFunction aDoubleFunc, BoolOpFunction aBoolFunc, StringOpFunction aStringFunc, +@@ -617,7 +617,7 @@ public: + virtual void DivOp(bool bFlag, double fVal, ScMatrix& rMat) override; + virtual void PowOp(bool bFlag, double fVal, ScMatrix& rMat) override; + +- virtual std::vector Collect(bool bTextAsZero, const std::vector>& aOp) override; ++ virtual std::vector Collect(const std::vector>& aOp) override; + + virtual void ExecuteOperation(const std::pair& rStartPos, const std::pair& rEndPos, + DoubleOpFunction aDoubleFunc, BoolOpFunction aBoolFunc, StringOpFunction aStringFunc, +@@ -837,7 +837,7 @@ public: + virtual void DivOp(bool bFlag, double fVal, ScMatrix& rMat) override; + virtual void PowOp(bool bFlag, double fVal, ScMatrix& rMat) override; + +- virtual std::vector Collect(bool bTextAsZero, const std::vector>& aOp) override; ++ virtual std::vector Collect(const std::vector>& aOp) override; + + virtual void ExecuteOperation(const std::pair& rStartPos, const std::pair& rEndPos, + DoubleOpFunction aDoubleFunc, BoolOpFunction aBoolFunc, StringOpFunction aStringFunc, +diff --git a/sc/source/core/tool/interpr3.cxx b/sc/source/core/tool/interpr3.cxx +index 28e8cd9a9c48..88c0d8353783 100644 +--- a/sc/source/core/tool/interpr3.cxx ++++ b/sc/source/core/tool/interpr3.cxx +@@ -2745,12 +2745,12 @@ void ScInterpreter::ScFTest() + aOp.emplace_back(new sc::op::Op(0.0, [](double& rAccum, double fVal){rAccum += fVal;})); + aOp.emplace_back(new sc::op::Op(0.0, [](double& rAccum, double fVal){rAccum += fVal * fVal;})); + +- auto aVal1 = pMat1->Collect(false, aOp); ++ auto aVal1 = pMat1->Collect(aOp); + fSum1 = aVal1[0].mfFirst + aVal1[0].mfRest; + fSumSqr1 = aVal1[1].mfFirst + aVal1[1].mfRest; + fCount1 = aVal1[2].mnCount; + +- auto aVal2 = pMat2->Collect(false, aOp); ++ auto aVal2 = pMat2->Collect(aOp); + fSum2 = aVal2[0].mfFirst + aVal2[0].mfRest; + fSumSqr2 = aVal2[1].mfFirst + aVal2[1].mfRest; + fCount2 = aVal2[2].mnCount; +diff --git a/sc/source/core/tool/scmatrix.cxx b/sc/source/core/tool/scmatrix.cxx +index 7f8c8767e917..7dadec9f0b57 100644 +--- a/sc/source/core/tool/scmatrix.cxx ++++ b/sc/source/core/tool/scmatrix.cxx +@@ -160,6 +160,12 @@ public: + maNewMatValues.reserve(nRow*nCol); + } + ++ CompareMatrixElemFunc( const CompareMatrixElemFunc& ) = delete; ++ CompareMatrixElemFunc& operator= ( const CompareMatrixElemFunc& ) = delete; ++ ++ CompareMatrixElemFunc( CompareMatrixElemFunc&& ) = default; ++ CompareMatrixElemFunc& operator= ( CompareMatrixElemFunc&& ) = default; ++ + void operator() (const MatrixImplType::element_block_node_type& node) + { + switch (node.type) +@@ -323,7 +329,7 @@ public: + const ScFullMatrix::EmptyOpFunction& aEmptyFunc) const; + + template +- std::vector ApplyCollectOperation(bool bTextAsZero, const std::vector>& aOp); ++ std::vector ApplyCollectOperation(const std::vector>& aOp); + + void MatConcat(SCSIZE nMaxCol, SCSIZE nMaxRow, const ScMatrixRef& xMat1, const ScMatrixRef& xMat2, + SvNumberFormatter& rFormatter, svl::SharedStringPool& rPool); +@@ -979,7 +985,7 @@ void ScMatrixImpl::CompareEqual() + { + MatrixImplType::size_pair_type aSize = maMat.size(); + CompareMatrixElemFunc aFunc(aSize.row, aSize.column); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + aFunc.swap(maMat); + } + +@@ -987,7 +993,7 @@ void ScMatrixImpl::CompareNotEqual() + { + MatrixImplType::size_pair_type aSize = maMat.size(); + CompareMatrixElemFunc aFunc(aSize.row, aSize.column); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + aFunc.swap(maMat); + } + +@@ -995,7 +1001,7 @@ void ScMatrixImpl::CompareLess() + { + MatrixImplType::size_pair_type aSize = maMat.size(); + CompareMatrixElemFunc aFunc(aSize.row, aSize.column); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + aFunc.swap(maMat); + } + +@@ -1003,7 +1009,7 @@ void ScMatrixImpl::CompareGreater() + { + MatrixImplType::size_pair_type aSize = maMat.size(); + CompareMatrixElemFunc aFunc(aSize.row, aSize.column); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + aFunc.swap(maMat); + } + +@@ -1011,7 +1017,7 @@ void ScMatrixImpl::CompareLessEqual() + { + MatrixImplType::size_pair_type aSize = maMat.size(); + CompareMatrixElemFunc aFunc(aSize.row, aSize.column); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + aFunc.swap(maMat); + } + +@@ -1019,7 +1025,7 @@ void ScMatrixImpl::CompareGreaterEqual() + { + MatrixImplType::size_pair_type aSize = maMat.size(); + CompareMatrixElemFunc aFunc(aSize.row, aSize.column); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + aFunc.swap(maMat); + } + +@@ -1174,21 +1180,34 @@ public: + template + class WalkElementBlocksMultipleValues + { +- const std::vector>& maOp; ++ const std::vector>* mpOp; + std::vector maRes; + bool mbFirst:1; +- bool mbTextAsZero:1; + public: +- WalkElementBlocksMultipleValues(bool bTextAsZero, const std::vector>& aOp) : +- maOp(aOp), mbFirst(true), mbTextAsZero(bTextAsZero) ++ WalkElementBlocksMultipleValues(const std::vector>& aOp) : ++ mpOp(&aOp), mbFirst(true) + { +- for (const auto& rpOp : maOp) ++ for (const auto& rpOp : *mpOp) + { + maRes.emplace_back(rpOp->mInitVal, rpOp->mInitVal, 0); + } + maRes.emplace_back(0.0, 0.0, 0); // count + } + ++ WalkElementBlocksMultipleValues( const WalkElementBlocksMultipleValues& ) = delete; ++ WalkElementBlocksMultipleValues& operator= ( const WalkElementBlocksMultipleValues& ) = delete; ++ ++ WalkElementBlocksMultipleValues( WalkElementBlocksMultipleValues&& r ) : ++ mpOp(r.mpOp), maRes(std::move(r.maRes)), mbFirst(r.mbFirst) {} ++ ++ WalkElementBlocksMultipleValues& operator= ( WalkElementBlocksMultipleValues&& r ) ++ { ++ mpOp = r.mpOp; ++ maRes = std::move(r.maRes); ++ mbFirst = r.mbFirst; ++ return *this; ++ } ++ + const std::vector& getResult() const { return maRes; } + + void operator() (const MatrixImplType::element_block_node_type& node) +@@ -1205,17 +1224,17 @@ public: + { + if (mbFirst) + { +- for (auto i = 0u; i < maOp.size(); ++i) ++ for (auto i = 0u; i < mpOp->size(); ++i) + { +- (*maOp[i])(maRes[i].mfFirst, *it); ++ (*(*mpOp)[i])(maRes[i].mfFirst, *it); + } + mbFirst = false; + } + else + { +- for (auto i = 0u; i < maOp.size(); ++i) ++ for (auto i = 0u; i < mpOp->size(); ++i) + { +- (*maOp[i])(maRes[i].mfRest, *it); ++ (*(*mpOp)[i])(maRes[i].mfRest, *it); + } + } + } +@@ -1232,17 +1251,17 @@ public: + { + if (mbFirst) + { +- for (auto i = 0u; i < maOp.size(); ++i) ++ for (auto i = 0u; i < mpOp->size(); ++i) + { +- (*maOp[i])(maRes[i].mfFirst, *it); ++ (*(*mpOp)[i])(maRes[i].mfFirst, *it); + } + mbFirst = false; + } + else + { +- for (auto i = 0u; i < maOp.size(); ++i) ++ for (auto i = 0u; i < mpOp->size(); ++i) + { +- (*maOp[i])(maRes[i].mfRest, *it); ++ (*(*mpOp)[i])(maRes[i].mfRest, *it); + } + } + } +@@ -1250,9 +1269,6 @@ public: + } + break; + case mdds::mtm::element_string: +- if (mbTextAsZero) +- maRes.back().mnCount += node.size; +- break; + case mdds::mtm::element_empty: + default: + ; +@@ -1310,8 +1326,8 @@ template + class WalkAndMatchElements + { + Type maMatchValue; +- const size_t mnStartIndex; +- const size_t mnStopIndex; ++ size_t mnStartIndex; ++ size_t mnStopIndex; + size_t mnResult; + size_t mnIndex; + +@@ -1669,6 +1685,24 @@ public: + maResValues.reserve(nResSize); + } + ++ CompareMatrixFunc( const CompareMatrixFunc& ) = delete; ++ CompareMatrixFunc& operator= ( const CompareMatrixFunc& ) = delete; ++ ++ CompareMatrixFunc( CompareMatrixFunc&& r ) : ++ mrComp(r.mrComp), ++ mnMatPos(r.mnMatPos), ++ mpOptions(r.mpOptions), ++ maResValues(std::move(r.maResValues)) {} ++ ++ CompareMatrixFunc& operator= ( CompareMatrixFunc&& r ) ++ { ++ mrComp = r.mrComp; ++ mnMatPos = r.mnMatPos; ++ mpOptions = r.mpOptions; ++ maResValues = std::move(r.maResValues); ++ return *this; ++ } ++ + void operator() (const MatrixImplType::element_block_node_type& node) + { + sc::Compare::Cell& rCell = mrComp.maCells[mnMatPos]; +@@ -1777,6 +1811,24 @@ public: + maResValues.reserve(nResSize); + } + ++ CompareMatrixToNumericFunc( const CompareMatrixToNumericFunc& ) = delete; ++ CompareMatrixToNumericFunc& operator= ( const CompareMatrixToNumericFunc& ) = delete; ++ ++ CompareMatrixToNumericFunc( CompareMatrixToNumericFunc&& r ) : ++ mrComp(r.mrComp), ++ mfRightValue(r.mfRightValue), ++ mpOptions(r.mpOptions), ++ maResValues(std::move(r.maResValues)) {} ++ ++ CompareMatrixToNumericFunc& operator= ( CompareMatrixToNumericFunc&& r ) ++ { ++ mrComp = r.mrComp; ++ mfRightValue = r.mfRightValue; ++ mpOptions = r.mpOptions; ++ maResValues = std::move(r.maResValues); ++ return *this; ++ } ++ + void operator() (const MatrixImplType::element_block_node_type& node) + { + sc::Compare::Cell& rCell = mrComp.maCells[0]; +@@ -1840,6 +1892,17 @@ class ToDoubleArray + double mfNaN; + bool mbEmptyAsZero; + ++ void moveArray( ToDoubleArray& r ) ++ { ++ // Re-create the iterator from the new array after the array has been ++ // moved, to ensure that the iterator points to a valid array ++ // position. ++ size_t n = std::distance(r.maArray.begin(), r.miPos); ++ maArray = std::move(r.maArray); ++ miPos = maArray.begin(); ++ std::advance(miPos, n); ++ } ++ + public: + ToDoubleArray( size_t nSize, bool bEmptyAsZero ) : + maArray(nSize, 0.0), miPos(maArray.begin()), mbEmptyAsZero(bEmptyAsZero) +@@ -1847,6 +1910,23 @@ public: + mfNaN = CreateDoubleError( FormulaError::ElementNaN); + } + ++ ToDoubleArray( const ToDoubleArray& ) = delete; ++ ToDoubleArray& operator= ( const ToDoubleArray& ) = delete; ++ ++ ToDoubleArray( ToDoubleArray&& r ) : ++ mfNaN(r.mfNaN), mbEmptyAsZero(r.mbEmptyAsZero) ++ { ++ moveArray(r); ++ } ++ ++ ToDoubleArray& operator= ( ToDoubleArray&& r ) ++ { ++ mfNaN = r.mfNaN; ++ mbEmptyAsZero = r.mbEmptyAsZero; ++ moveArray(r); ++ return *this; ++ } ++ + void operator() (const MatrixImplType::element_block_node_type& node) + { + using namespace mdds::mtv; +@@ -1917,6 +1997,12 @@ public: + mfNaN = CreateDoubleError( FormulaError::ElementNaN); + } + ++ MergeDoubleArrayFunc( const MergeDoubleArrayFunc& ) = delete; ++ MergeDoubleArrayFunc& operator= ( const MergeDoubleArrayFunc& ) = delete; ++ ++ MergeDoubleArrayFunc( MergeDoubleArrayFunc&& ) = default; ++ MergeDoubleArrayFunc& operator= ( MergeDoubleArrayFunc&& ) = default; ++ + void operator() (const MatrixImplType::element_block_node_type& node) + { + using namespace mdds::mtv; +@@ -1982,7 +2068,7 @@ template + ScMatrix::IterateResult GetValueWithCount(bool bTextAsZero, const MatrixImplType& maMat) + { + WalkElementBlocks aFunc(bTextAsZero); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(aFunc); + return aFunc.getResult(); + } + +@@ -2006,49 +2092,49 @@ ScMatrix::IterateResult ScMatrixImpl::Product(bool bTextAsZero) const + size_t ScMatrixImpl::Count(bool bCountStrings, bool bCountErrors) const + { + CountElements aFunc(bCountStrings, bCountErrors); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(aFunc); + return aFunc.getCount(); + } + + size_t ScMatrixImpl::MatchDoubleInColumns(double fValue, size_t nCol1, size_t nCol2) const + { + WalkAndMatchElements aFunc(fValue, maMat.size(), nCol1, nCol2); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(aFunc); + return aFunc.getMatching(); + } + + size_t ScMatrixImpl::MatchStringInColumns(const svl::SharedString& rStr, size_t nCol1, size_t nCol2) const + { + WalkAndMatchElements aFunc(rStr, maMat.size(), nCol1, nCol2); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(aFunc); + return aFunc.getMatching(); + } + + double ScMatrixImpl::GetMaxValue( bool bTextAsZero ) const + { + CalcMaxMinValue aFunc(bTextAsZero); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(aFunc); + return aFunc.getValue(); + } + + double ScMatrixImpl::GetMinValue( bool bTextAsZero ) const + { + CalcMaxMinValue aFunc(bTextAsZero); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(aFunc); + return aFunc.getValue(); + } + + double ScMatrixImpl::GetGcd() const + { + CalcGcdLcm aFunc; +- maMat.walk(aFunc); ++ aFunc = maMat.walk(aFunc); + return aFunc.getResult(); + } + + double ScMatrixImpl::GetLcm() const + { + CalcGcdLcm aFunc; +- maMat.walk(aFunc); ++ aFunc = maMat.walk(aFunc); + return aFunc.getResult(); + } + +@@ -2065,7 +2151,7 @@ ScMatrixRef ScMatrixImpl::CompareMatrix( + // function object that has much less branching for much better + // performance. + CompareMatrixToNumericFunc aFunc(nSize, rComp, rComp.maCells[1].mfValue, pOptions); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + + // We assume the result matrix has the same dimension as this matrix. + const std::vector& rResVal = aFunc.getValues(); +@@ -2077,7 +2163,7 @@ ScMatrixRef ScMatrixImpl::CompareMatrix( + } + + CompareMatrixFunc aFunc(nSize, rComp, nMatPos, pOptions); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + + // We assume the result matrix has the same dimension as this matrix. + const std::vector& rResVal = aFunc.getValues(); +@@ -2091,7 +2177,7 @@ void ScMatrixImpl::GetDoubleArray( std::vector& rArray, bool bEmptyAsZer + { + MatrixImplType::size_pair_type aSize = maMat.size(); + ToDoubleArray aFunc(aSize.row*aSize.column, bEmptyAsZero); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + aFunc.swap(rArray); + } + +@@ -2107,7 +2193,7 @@ void ScMatrixImpl::MergeDoubleArray( std::vector& rArray, ScFullMatrix:: + case ScFullMatrix::Mul: + { + MergeDoubleArrayFunc aFunc(rArray); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(std::move(aFunc)); + } + break; + default: +@@ -2329,16 +2415,26 @@ struct MatrixOpWrapper + private: + MatrixImplType& mrMat; + MatrixImplType::position_type pos; +- T maOp; ++ const T* mpOp; + + public: +- MatrixOpWrapper(MatrixImplType& rMat, T const & aOp): ++ MatrixOpWrapper(MatrixImplType& rMat, const T& aOp): + mrMat(rMat), + pos(rMat.position(0,0)), +- maOp(aOp) ++ mpOp(&aOp) + { + } + ++ MatrixOpWrapper( const MatrixOpWrapper& r ) : mrMat(r.mrMat), pos(r.pos), mpOp(r.mpOp) {} ++ ++ MatrixOpWrapper& operator= ( const MatrixOpWrapper& r ) ++ { ++ mrMat = r.mrMat; ++ pos = r.pos; ++ mpOp = r.mpOp; ++ return *this; ++ } ++ + void operator()(const MatrixImplType::element_block_node_type& node) + { + switch (node.type) +@@ -2349,7 +2445,7 @@ public: + + block_type::const_iterator it = block_type::begin(*node.data); + block_type::const_iterator itEnd = block_type::end(*node.data); +- MatrixIteratorWrapper aFunc(it, itEnd, maOp); ++ MatrixIteratorWrapper aFunc(it, itEnd, *mpOp); + pos = mrMat.set(pos,aFunc.begin(), aFunc.end()); + } + break; +@@ -2360,7 +2456,7 @@ public: + block_type::const_iterator it = block_type::begin(*node.data); + block_type::const_iterator itEnd = block_type::end(*node.data); + +- MatrixIteratorWrapper aFunc(it, itEnd, maOp); ++ MatrixIteratorWrapper aFunc(it, itEnd, *mpOp); + pos = mrMat.set(pos, aFunc.begin(), aFunc.end()); + } + break; +@@ -2371,17 +2467,17 @@ public: + block_type::const_iterator it = block_type::begin(*node.data); + block_type::const_iterator itEnd = block_type::end(*node.data); + +- MatrixIteratorWrapper aFunc(it, itEnd, maOp); ++ MatrixIteratorWrapper aFunc(it, itEnd, *mpOp); + pos = mrMat.set(pos, aFunc.begin(), aFunc.end()); + } + break; + case mdds::mtm::element_empty: + { +- if (maOp.useFunctionForEmpty()) ++ if (mpOp->useFunctionForEmpty()) + { + std::vector aVec(node.size); + MatrixIteratorWrapper, T, typename T::number_value_type> +- aFunc(aVec.begin(), aVec.end(), maOp); ++ aFunc(aVec.begin(), aVec.end(), *mpOp); + pos = mrMat.set(pos, aFunc.begin(), aFunc.end()); + } + } +@@ -2397,14 +2493,14 @@ template + void ScMatrixImpl::ApplyOperation(T aOp, ScMatrixImpl& rMat) + { + MatrixOpWrapper aFunc(rMat.maMat, aOp); +- maMat.walk(aFunc); ++ aFunc = maMat.walk(aFunc); + } + + template +-std::vector ScMatrixImpl::ApplyCollectOperation(bool bTextAsZero, const std::vector>& aOp) ++std::vector ScMatrixImpl::ApplyCollectOperation(const std::vector>& aOp) + { +- WalkElementBlocksMultipleValues aFunc(bTextAsZero, aOp); +- maMat.walk(aFunc); ++ WalkElementBlocksMultipleValues aFunc(aOp); ++ aFunc = maMat.walk(std::move(aFunc)); + return aFunc.getResult(); + } + +@@ -2544,8 +2640,10 @@ void ScMatrixImpl::ExecuteOperation(const std::pair& rStartPos, + { + WalkElementBlockOperation aFunc(maMat.size().row, + aDoubleFunc, aBoolFunc, aStringFunc, aEmptyFunc); +- maMat.walk(aFunc, MatrixImplType::size_pair_type(rStartPos.first, rStartPos.second), +- MatrixImplType::size_pair_type(rEndPos.first, rEndPos.second)); ++ aFunc = maMat.walk( ++ aFunc, ++ MatrixImplType::size_pair_type(rStartPos.first, rStartPos.second), ++ MatrixImplType::size_pair_type(rEndPos.first, rEndPos.second)); + } + + #if DEBUG_MATRIX +@@ -3452,9 +3550,9 @@ void ScFullMatrix::ExecuteOperation(const std::pair& rStartPos, + pImpl->ExecuteOperation(rStartPos, rEndPos, aDoubleFunc, aBoolFunc, aStringFunc, aEmptyFunc); + } + +-std::vector ScFullMatrix::Collect(bool bTextAsZero, const std::vector>& aOp) ++std::vector ScFullMatrix::Collect(const std::vector>& aOp) + { +- return pImpl->ApplyCollectOperation(bTextAsZero, aOp); ++ return pImpl->ApplyCollectOperation(aOp); + } + + ScFullMatrix& ScFullMatrix::operator+= ( const ScFullMatrix& r ) +@@ -4216,10 +4314,10 @@ void ScVectorRefMatrix::PowOp(bool bFlag, double fVal, ScMatrix& rMat) + mpFullMatrix->PowOp(bFlag, fVal, rMat); + } + +-std::vector ScVectorRefMatrix::Collect(bool bTextAsZero, const std::vector>& aOp) ++std::vector ScVectorRefMatrix::Collect(const std::vector>& aOp) + { + ensureFullMatrix(); +- return mpFullMatrix->Collect(bTextAsZero, aOp); ++ return mpFullMatrix->Collect(aOp); + } + + void ScVectorRefMatrix::ExecuteOperation(const std::pair& rStartPos, +-- +2.17.1 + diff --git a/office/LibreOffice/0001-Update-orcus-to-0.14.0.patch b/office/LibreOffice/0001-Update-orcus-to-0.14.0.patch new file mode 100644 index 0000000000..2480f48b7a --- /dev/null +++ b/office/LibreOffice/0001-Update-orcus-to-0.14.0.patch @@ -0,0 +1,801 @@ +From 1d0727a104d76210814f41c1169df318e40c9d80 Mon Sep 17 00:00:00 2001 +From: Kohei Yoshida +Date: Mon, 27 Aug 2018 11:06:17 -0400 +Subject: [PATCH] Update orcus to 0.14.0. + +And make all necessary adjustments for the new version of orcus. + +Change-Id: I0dc207162a3ddfaad6da198a3d13b65f530757d5 +Reviewed-on: https://gerrit.libreoffice.org/59884 +Tested-by: Jenkins +Reviewed-by: Kohei Yoshida +--- + RepositoryExternal.mk | 4 +- + configure.ac | 2 +- + download.lst | 4 +- + .../0001-Missing-header-for-std-tolower.patch | 24 ++ + external/liborcus/ExternalPackage_liborcus.mk | 8 +- + external/liborcus/ExternalProject_liborcus.mk | 4 +- + external/liborcus/Library_orcus.mk | 2 + + external/liborcus/UnpackedTarball_liborcus.mk | 1 + + external/liborcus/gcc9.patch.0 | 3 +- + sc/source/filter/inc/orcusinterface.hxx | 107 ++++-- + sc/source/filter/orcus/interface.cxx | 322 +++++++++++++----- + sc/source/filter/orcus/xmlcontext.cxx | 5 +- + 12 files changed, 360 insertions(+), 126 deletions(-) + create mode 100644 external/liborcus/0001-Missing-header-for-std-tolower.patch + +diff --git a/RepositoryExternal.mk b/RepositoryExternal.mk +index cec79cc105e8..f172765a84f8 100644 +--- a/RepositoryExternal.mk ++++ b/RepositoryExternal.mk +@@ -3295,7 +3295,7 @@ $(call gb_LinkTarget_set_include,$(1),\ + ) + + $(call gb_LinkTarget_add_libs,$(1),\ +- -L$(call gb_UnpackedTarball_get_dir,liborcus)/src/liborcus/.libs -lorcus-0.13 \ ++ -L$(call gb_UnpackedTarball_get_dir,liborcus)/src/liborcus/.libs -lorcus-0.14 \ + ) + + $(if $(SYSTEM_BOOST), \ +@@ -3314,7 +3314,7 @@ $(call gb_LinkTarget_set_include,$(1),\ + ) + + $(call gb_LinkTarget_add_libs,$(1),\ +- -L$(call gb_UnpackedTarball_get_dir,liborcus)/src/parser/.libs -lorcus-parser-0.13 \ ++ -L$(call gb_UnpackedTarball_get_dir,liborcus)/src/parser/.libs -lorcus-parser-0.14 \ + ) + + endef +diff --git a/configure.ac b/configure.ac +index 3c9e5dc5e908..a60a3e72689f 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -9196,7 +9196,7 @@ AC_SUBST(ENABLE_FUZZERS) + dnl =================================================================== + dnl Orcus + dnl =================================================================== +-libo_CHECK_SYSTEM_MODULE([orcus],[ORCUS],[liborcus-0.13 >= 0.13.3]) ++libo_CHECK_SYSTEM_MODULE([orcus],[ORCUS],[liborcus-0.14 >= 0.14.0]) + if test "$with_system_orcus" != "yes"; then + if test "$SYSTEM_BOOST" = "TRUE"; then + # =========================================================== +diff --git a/download.lst b/download.lst +index 1ed75b36f3b3..3532e2be3aa3 100644 +--- a/download.lst ++++ b/download.lst +@@ -194,8 +194,8 @@ export OPENLDAP_SHA256SUM := cdd6cffdebcd95161a73305ec13fc7a78e9707b46ca9f84fb89 + export OPENLDAP_TARBALL := openldap-2.4.45.tgz + export OPENSSL_SHA256SUM := 50a98e07b1a89eb8f6a99477f262df71c6fa7bef77df4dc83025a2845c827d00 + export OPENSSL_TARBALL := openssl-1.0.2p.tar.gz +-export ORCUS_SHA256SUM := bc01b1b3e9091416f498840d3c19a1aa2704b448100e7f6b80eefe88aab06d5b +-export ORCUS_TARBALL := liborcus-0.13.4.tar.gz ++export ORCUS_SHA256SUM := 7bcfac3f4f490540292cfc87d3fde7b47eafa8450afa1e1a2c181d8293dcd4ef ++export ORCUS_TARBALL := liborcus-0.14.0.tar.gz + export OWNCLOUD_ANDROID_LIB_SHA256SUM := b18b3e3ef7fae6a79b62f2bb43cc47a5346b6330f6a383dc4be34439aca5e9fb + export OWNCLOUD_ANDROID_LIB_TARBALL := owncloud-android-library-0.9.4-no-binary-deps.tar.gz + export PAGEMAKER_SHA256SUM := 66adacd705a7d19895e08eac46d1e851332adf2e736c566bef1164e7a442519d +diff --git a/external/liborcus/0001-Missing-header-for-std-tolower.patch b/external/liborcus/0001-Missing-header-for-std-tolower.patch +new file mode 100644 +index 000000000000..2e00be92a872 +--- /dev/null ++++ b/external/liborcus/0001-Missing-header-for-std-tolower.patch +@@ -0,0 +1,24 @@ ++From 3a6bb93a382b4d5f1463ee3fdd54cab7048ff996 Mon Sep 17 00:00:00 2001 ++From: Kohei Yoshida ++Date: Fri, 31 Aug 2018 16:07:06 -0400 ++Subject: [PATCH] Missing header for std::tolower. ++ ++--- ++ src/parser/sax_token_parser.cpp | 1 + ++ 1 file changed, 1 insertion(+) ++ ++diff --git a/src/parser/sax_token_parser.cpp b/src/parser/sax_token_parser.cpp ++index 9790b498..44ba5844 100644 ++--- a/src/parser/sax_token_parser.cpp +++++ b/src/parser/sax_token_parser.cpp ++@@ -9,6 +9,7 @@ ++ #include "orcus/tokens.hpp" ++ ++ #include +++#include ++ ++ namespace orcus { ++ ++-- ++2.17.1 ++ +diff --git a/external/liborcus/ExternalPackage_liborcus.mk b/external/liborcus/ExternalPackage_liborcus.mk +index 32382b7d89a1..ffa0b38bea19 100644 +--- a/external/liborcus/ExternalPackage_liborcus.mk ++++ b/external/liborcus/ExternalPackage_liborcus.mk +@@ -12,11 +12,11 @@ $(eval $(call gb_ExternalPackage_ExternalPackage,liborcus,liborcus)) + $(eval $(call gb_ExternalPackage_use_external_project,liborcus,liborcus)) + + ifeq ($(OS),MACOSX) +-$(eval $(call gb_ExternalPackage_add_file,liborcus,$(LIBO_LIB_FOLDER)/liborcus-0.13.0.dylib,src/liborcus/.libs/liborcus-0.13.0.dylib)) +-$(eval $(call gb_ExternalPackage_add_file,liborcus,$(LIBO_LIB_FOLDER)/liborcus-parser-0.13.0.dylib,src/parser/.libs/liborcus-parser-0.13.0.dylib)) ++$(eval $(call gb_ExternalPackage_add_file,liborcus,$(LIBO_LIB_FOLDER)/liborcus-0.14.0.dylib,src/liborcus/.libs/liborcus-0.14.0.dylib)) ++$(eval $(call gb_ExternalPackage_add_file,liborcus,$(LIBO_LIB_FOLDER)/liborcus-parser-0.14.0.dylib,src/parser/.libs/liborcus-parser-0.14.0.dylib)) + else ifeq ($(DISABLE_DYNLOADING),) +-$(eval $(call gb_ExternalPackage_add_file,liborcus,$(LIBO_LIB_FOLDER)/liborcus-0.13.so.0,src/liborcus/.libs/liborcus-0.13.so.0.0.0)) +-$(eval $(call gb_ExternalPackage_add_file,liborcus,$(LIBO_LIB_FOLDER)/liborcus-parser-0.13.so.0,src/parser/.libs/liborcus-parser-0.13.so.0.0.0)) ++$(eval $(call gb_ExternalPackage_add_file,liborcus,$(LIBO_LIB_FOLDER)/liborcus-0.14.so.0,src/liborcus/.libs/liborcus-0.14.so.0.0.0)) ++$(eval $(call gb_ExternalPackage_add_file,liborcus,$(LIBO_LIB_FOLDER)/liborcus-parser-0.14.so.0,src/parser/.libs/liborcus-parser-0.14.so.0.0.0)) + endif + + # vim: set noet sw=4 ts=4: +diff --git a/external/liborcus/ExternalProject_liborcus.mk b/external/liborcus/ExternalProject_liborcus.mk +index 928c78e3a267..1aa591228f40 100644 +--- a/external/liborcus/ExternalProject_liborcus.mk ++++ b/external/liborcus/ExternalProject_liborcus.mk +@@ -114,8 +114,8 @@ $(call gb_ExternalProject_get_state_target,liborcus,build) : + $(MAKE) \ + $(if $(filter MACOSX,$(OS)),\ + && $(PERL) $(SRCDIR)/solenv/bin/macosx-change-install-names.pl shl OOO \ +- $(EXTERNAL_WORKDIR)/src/liborcus/.libs/liborcus-0.13.0.dylib \ +- $(EXTERNAL_WORKDIR)/src/parser/.libs/liborcus-parser-0.13.0.dylib \ ++ $(EXTERNAL_WORKDIR)/src/liborcus/.libs/liborcus-0.14.0.dylib \ ++ $(EXTERNAL_WORKDIR)/src/parser/.libs/liborcus-parser-0.14.0.dylib \ + ) \ + ) + +diff --git a/external/liborcus/Library_orcus.mk b/external/liborcus/Library_orcus.mk +index 6457ec4afc0c..1f026c425244 100644 +--- a/external/liborcus/Library_orcus.mk ++++ b/external/liborcus/Library_orcus.mk +@@ -55,6 +55,7 @@ $(eval $(call gb_Library_add_generated_exception_objects,orcus,\ + UnpackedTarball/liborcus/src/liborcus/detection_result \ + UnpackedTarball/liborcus/src/liborcus/dom_tree \ + UnpackedTarball/liborcus/src/liborcus/format_detection \ ++ UnpackedTarball/liborcus/src/liborcus/formula_result \ + UnpackedTarball/liborcus/src/liborcus/global \ + UnpackedTarball/liborcus/src/liborcus/gnumeric_cell_context \ + UnpackedTarball/liborcus/src/liborcus/gnumeric_context \ +@@ -96,6 +97,7 @@ $(eval $(call gb_Library_add_generated_exception_objects,orcus,\ + UnpackedTarball/liborcus/src/liborcus/orcus_xlsx \ + UnpackedTarball/liborcus/src/liborcus/orcus_xml \ + UnpackedTarball/liborcus/src/liborcus/session_context \ ++ UnpackedTarball/liborcus/src/liborcus/spreadsheet_iface_util \ + UnpackedTarball/liborcus/src/liborcus/spreadsheet_interface \ + UnpackedTarball/liborcus/src/liborcus/spreadsheet_types \ + UnpackedTarball/liborcus/src/liborcus/string_helper \ +diff --git a/external/liborcus/UnpackedTarball_liborcus.mk b/external/liborcus/UnpackedTarball_liborcus.mk +index 215bd4b8cc15..f637cc73db46 100644 +--- a/external/liborcus/UnpackedTarball_liborcus.mk ++++ b/external/liborcus/UnpackedTarball_liborcus.mk +@@ -19,5 +19,6 @@ $(eval $(call gb_UnpackedTarball_add_patches,liborcus,\ + external/liborcus/0001-workaround-a-linking-problem-on-windows.patch \ + external/liborcus/rpath.patch.0 \ ++ external/liborcus/0001-Missing-header-for-std-tolower.patch \ + )) + + ifeq ($(OS),WNT) +diff --git a/sc/source/filter/inc/orcusinterface.hxx b/sc/source/filter/inc/orcusinterface.hxx +index 028fb4126f01..dce0d5b0a64e 100644 +--- a/sc/source/filter/inc/orcusinterface.hxx ++++ b/sc/source/filter/inc/orcusinterface.hxx +@@ -54,6 +54,7 @@ public: + ScOrcusGlobalSettings(ScDocumentImport& rDoc); + + virtual void set_origin_date(int year, int month, int day) override; ++ virtual void set_character_set(orcus::character_set_t cs) override; + + virtual void set_default_formula_grammar(orcus::spreadsheet::formula_grammar_t grammar) override; + virtual orcus::spreadsheet::formula_grammar_t get_default_formula_grammar() const override; +@@ -181,7 +182,7 @@ public: + + virtual ~ScOrcusAutoFilter() override; + +- virtual void set_range(const char* p_ref, size_t n_ref) override; ++ virtual void set_range(const orcus::spreadsheet::range_t& range) override; + + virtual void set_column(orcus::spreadsheet::col_t col) override; + +@@ -214,22 +215,95 @@ public: + virtual void set_merge_cell_range(const orcus::spreadsheet::range_t& range) override; + }; + ++class ScOrcusSheet; ++ ++class ScOrcusFormula : public orcus::spreadsheet::iface::import_formula ++{ ++ enum class ResultType { NotSet, String, Value, Empty }; ++ ++ friend class ScOrcusSheet; ++ ++ ScOrcusSheet& mrSheet; ++ ++ SCCOL mnCol; ++ SCROW mnRow; ++ OUString maFormula; ++ formula::FormulaGrammar::Grammar meGrammar; ++ size_t mnSharedFormulaIndex; ++ bool mbShared; ++ ++ ResultType meResType; ++ size_t mnResult; // result string index. ++ double mfResult; ++ ++ void reset(); ++ ++public: ++ ScOrcusFormula( ScOrcusSheet& rSheet ); ++ virtual ~ScOrcusFormula() override; ++ ++ virtual void set_position(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col) override; ++ virtual void set_formula(orcus::spreadsheet::formula_grammar_t grammar, const char* p, size_t n) override; ++ virtual void set_shared_formula_index(size_t index) override; ++ virtual void set_result_value(double value) override; ++ virtual void set_result_string(size_t sindex) override; ++ virtual void set_result_empty() override; ++ virtual void set_result_bool(bool value) override; ++ virtual void commit() override; ++}; ++ ++class ScOrcusArrayFormula : public orcus::spreadsheet::iface::import_array_formula ++{ ++ friend class ScOrcusSheet; ++ ++ ScOrcusSheet& mrSheet; ++ ++ SCCOL mnCol; ++ SCROW mnRow; ++ uint32_t mnColRange; ++ uint32_t mnRowRange; ++ OUString maFormula; ++ formula::FormulaGrammar::Grammar meGrammar; ++ ++ void reset(); ++ ++public: ++ ScOrcusArrayFormula( ScOrcusSheet& rSheet ); ++ virtual ~ScOrcusArrayFormula() override; ++ ++ virtual void set_range(const orcus::spreadsheet::range_t& range) override; ++ virtual void set_formula(orcus::spreadsheet::formula_grammar_t grammar, const char* p, size_t n) override; ++ virtual void set_result_value(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, double value) override; ++ virtual void set_result_string(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, size_t sindex) override; ++ virtual void set_result_empty(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col) override; ++ virtual void set_result_bool(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, bool value) override; ++ virtual void commit() override; ++}; ++ + class ScOrcusSheet : public orcus::spreadsheet::iface::import_sheet + { ++ friend class ScOrcusFormula; ++ friend class ScOrcusArrayFormula; ++ + ScDocumentImport& mrDoc; + SCTAB mnTab; + ScOrcusFactory& mrFactory; + ScOrcusStyles& mrStyles; + sc::SharedFormulaGroups maFormulaGroups; ++ + ScOrcusAutoFilter maAutoFilter; + ScOrcusSheetProperties maProperties; + ScOrcusConditionalFormat maConditionalFormat; + ScOrcusNamedExpression maNamedExpressions; ++ ScOrcusFormula maFormula; ++ ScOrcusArrayFormula maArrayFormula; + + int mnCellCount; + + void cellInserted(); + ++ ScDocumentImport& getDoc(); ++ + public: + ScOrcusSheet(ScDocumentImport& rDoc, SCTAB nTab, ScOrcusFactory& rFactory); + +@@ -238,6 +312,8 @@ public: + virtual orcus::spreadsheet::iface::import_sheet_properties* get_sheet_properties() override; + virtual orcus::spreadsheet::iface::import_conditional_format* get_conditional_format() override; + virtual orcus::spreadsheet::iface::import_named_expression* get_named_expression() override; ++ virtual orcus::spreadsheet::iface::import_formula* get_formula() override; ++ virtual orcus::spreadsheet::iface::import_array_formula* get_array_formula() override; + + // Orcus import interface + virtual void set_auto(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, const char* p, size_t n) override; +@@ -251,33 +327,13 @@ public: + virtual void set_format(orcus::spreadsheet::row_t row_start, orcus::spreadsheet::col_t col_start, + orcus::spreadsheet::row_t row_end, orcus::spreadsheet::col_t col_end, size_t xf_index) override; + +- virtual void set_formula(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, orcus::spreadsheet::formula_grammar_t grammar, const char* p, size_t n) override; +- virtual void set_formula_result(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, const char* p, size_t n) override; +- virtual void set_formula_result(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, double val) override; +- +- virtual void set_shared_formula( +- orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, orcus::spreadsheet::formula_grammar_t grammar, size_t sindex, +- const char* p_formula, size_t n_formula) override; +- +- virtual void set_shared_formula( +- orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, orcus::spreadsheet::formula_grammar_t grammar, size_t sindex, +- const char* p_formula, size_t n_formula, const char* p_range, size_t n_range) override; +- +- virtual void set_shared_formula(orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, size_t sindex) override; +- +- virtual void set_array_formula( +- orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, orcus::spreadsheet::formula_grammar_t grammar, +- const char* p, size_t n, orcus::spreadsheet::row_t array_rows, orcus::spreadsheet::col_t array_cols) override; +- +- virtual void set_array_formula( +- orcus::spreadsheet::row_t row, orcus::spreadsheet::col_t col, orcus::spreadsheet::formula_grammar_t grammar, +- const char* p, size_t n, const char* p_range, size_t n_range) override; +- + virtual orcus::spreadsheet::range_size_t get_sheet_size() const override; + + SCTAB getIndex() const { return mnTab; } + + const sc::SharedFormulaGroups& getSharedFormulaGroups() const; ++ sc::SharedFormulaGroups& getSharedFormulaGroups(); ++ ScOrcusFactory& getFactory(); + }; + + class ScOrcusStyles : public orcus::spreadsheet::iface::import_styles +@@ -312,7 +368,7 @@ private: + + struct fill + { +- OUString maPattern; ++ orcus::spreadsheet::fill_pattern_t mePattern; + Color maFgColor; + Color maBgColor; + +@@ -446,7 +502,7 @@ public: + // fill + + virtual void set_fill_count(size_t n) override; +- virtual void set_fill_pattern_type(const char* s, size_t n) override; ++ virtual void set_fill_pattern_type(orcus::spreadsheet::fill_pattern_t fp) override; + virtual void set_fill_fg_color(orcus::spreadsheet::color_elem_t alpha, orcus::spreadsheet::color_elem_t red, orcus::spreadsheet::color_elem_t green, orcus::spreadsheet::color_elem_t blue) override; + virtual void set_fill_bg_color(orcus::spreadsheet::color_elem_t alpha, orcus::spreadsheet::color_elem_t red, orcus::spreadsheet::color_elem_t green, orcus::spreadsheet::color_elem_t blue) override; + virtual size_t commit_fill() override; +@@ -580,6 +636,7 @@ public: + + size_t appendString(const OUString& rStr); + size_t addString(const OUString& rStr); ++ const OUString* getString(size_t nIndex) const; + + void pushCellStoreAutoToken( const ScAddress& rPos, const OUString& rVal ); + void pushCellStoreToken( const ScAddress& rPos, uint32_t nStrIndex ); +diff --git a/sc/source/filter/orcus/interface.cxx b/sc/source/filter/orcus/interface.cxx +index dcf3e83d7eae..7b8425d3007d 100644 +--- a/sc/source/filter/orcus/interface.cxx ++++ b/sc/source/filter/orcus/interface.cxx +@@ -101,6 +101,11 @@ void ScOrcusGlobalSettings::set_origin_date(int year, int month, int day) + mrDoc.setOriginDate(year, month, day); + } + ++void ScOrcusGlobalSettings::set_character_set(orcus::character_set_t /*cs*/) ++{ ++ // TODO ++} ++ + void ScOrcusGlobalSettings::set_default_formula_grammar(os::formula_grammar_t grammar) + { + meCalcGrammar = getCalcGrammarFromOrcus(grammar); +@@ -463,6 +468,11 @@ size_t ScOrcusFactory::addString(const OUString& rStr) + return appendString(rStr); + } + ++const OUString* ScOrcusFactory::getString(size_t nIndex) const ++{ ++ return nIndex < maStrings.size() ? &maStrings[nIndex] : nullptr; ++} ++ + void ScOrcusFactory::pushCellStoreAutoToken( const ScAddress& rPos, const OUString& rVal ) + { + maCellStoreTokens.emplace_back(rPos, CellStoreToken::Type::Auto); +@@ -816,10 +826,197 @@ ScOrcusSheet::ScOrcusSheet(ScDocumentImport& rDoc, SCTAB nTab, ScOrcusFactory& r + maProperties(mnTab, mrDoc), + maConditionalFormat(mnTab, rDoc.getDoc()), + maNamedExpressions(rDoc, rFactory.getGlobalSettings(), nTab), ++ maFormula(*this), ++ maArrayFormula(*this), + mnCellCount(0) + { + } + ++void ScOrcusFormula::reset() ++{ ++ mnCol = -1; ++ mnRow = -1; ++ maFormula.clear(); ++ meGrammar = formula::FormulaGrammar::GRAM_UNSPECIFIED; ++ mnSharedFormulaIndex = 0; ++ mbShared = false; ++ meResType = ResultType::NotSet; ++ mnResult = 0; ++ mfResult = 0.0; ++} ++ ++ScOrcusFormula::ScOrcusFormula( ScOrcusSheet& rSheet ) : ++ mrSheet(rSheet), ++ mnCol(-1), ++ mnRow(-1), ++ meGrammar(formula::FormulaGrammar::GRAM_UNSPECIFIED), ++ mnSharedFormulaIndex(0), ++ mbShared(false), ++ meResType(ResultType::NotSet), ++ mnResult(0), ++ mfResult(0.0) {} ++ ++ScOrcusFormula::~ScOrcusFormula() {} ++ ++void ScOrcusFormula::set_position(os::row_t row, os::col_t col) ++{ ++ mnCol = col; ++ mnRow = row; ++} ++ ++void ScOrcusFormula::set_formula(os::formula_grammar_t grammar, const char* p, size_t n) ++{ ++ maFormula = OUString(p, n, RTL_TEXTENCODING_UTF8); ++ meGrammar = getCalcGrammarFromOrcus(grammar); ++} ++ ++void ScOrcusFormula::set_shared_formula_index(size_t index) ++{ ++ mnSharedFormulaIndex = index; ++ mbShared = true; ++} ++ ++void ScOrcusFormula::set_result_value(double value) ++{ ++ meResType = ResultType::Value; ++ mfResult = value; ++} ++ ++void ScOrcusFormula::set_result_string(size_t sindex) ++{ ++ meResType = ResultType::String; ++ mnResult = sindex; ++} ++ ++void ScOrcusFormula::set_result_empty() ++{ ++ meResType = ResultType::Empty; ++} ++ ++void ScOrcusFormula::set_result_bool(bool value) ++{ ++ meResType = ResultType::Value; ++ mfResult = value ? 1.0 : 0.0; ++} ++ ++void ScOrcusFormula::commit() ++{ ++ ScOrcusFactory& rFactory = mrSheet.getFactory(); ++ sc::SharedFormulaGroups& rGroups = mrSheet.getSharedFormulaGroups(); ++ ScAddress aPos(mnCol, mnRow, mrSheet.getIndex()); ++ ++ if (mbShared) ++ { ++ if (maFormula.isEmpty()) ++ { ++ // shared formula that references existing formula token. ++ const ScTokenArray* pArray = rGroups.get(mnSharedFormulaIndex); ++ if (!pArray) ++ return; ++ } ++ else ++ { ++ // topmost shared formula with new formula token. ++ ++ // Compile the formula expression into tokens. ++ ScCompiler aComp(&mrSheet.getDoc().getDoc(), aPos, meGrammar); ++ ScTokenArray* pArray = aComp.CompileString(maFormula); ++ if (!pArray) ++ // Tokenization failed. ++ return; ++ ++ rGroups.set(mnSharedFormulaIndex, pArray); ++ } ++ rFactory.pushSharedFormulaToken(aPos, mnSharedFormulaIndex); ++ } ++ else ++ { ++ // non-shared formula ++ rFactory.pushCellStoreToken(aPos, maFormula, meGrammar); ++ } ++ ++ switch (meResType) ++ { ++ case ResultType::String: ++ { ++ const OUString* pStr = rFactory.getString(mnResult); ++ if (pStr) ++ rFactory.pushFormulaResult(aPos, *pStr); ++ break; ++ } ++ case ResultType::Value: ++ rFactory.pushFormulaResult(aPos, mfResult); ++ break; ++ default: ++ ; ++ } ++ ++ mrSheet.cellInserted(); ++} ++ ++void ScOrcusArrayFormula::reset() ++{ ++ mnCol = -1; ++ mnRow = -1; ++ mnColRange = 0; ++ mnRowRange = 0; ++ ++ maFormula.clear(); ++ meGrammar = formula::FormulaGrammar::GRAM_UNSPECIFIED; ++} ++ ++ScOrcusArrayFormula::ScOrcusArrayFormula( ScOrcusSheet& rSheet ) : ++ mrSheet(rSheet), ++ mnCol(-1), ++ mnRow(-1), ++ mnColRange(0), ++ mnRowRange(0), ++ meGrammar(formula::FormulaGrammar::GRAM_UNSPECIFIED) {} ++ ++ScOrcusArrayFormula::~ScOrcusArrayFormula() {} ++ ++void ScOrcusArrayFormula::set_range(const os::range_t& range) ++{ ++ mnCol = range.first.column; ++ mnRow = range.first.row; ++ ++ mnColRange = range.last.column - range.first.column + 1; ++ mnRowRange = range.last.row - range.first.column + 1; ++} ++ ++void ScOrcusArrayFormula::set_formula(os::formula_grammar_t grammar, const char* p, size_t n) ++{ ++ meGrammar = getCalcGrammarFromOrcus(grammar); ++ maFormula = OUString(p, n, RTL_TEXTENCODING_UTF8); ++} ++ ++void ScOrcusArrayFormula::set_result_value(os::row_t /*row*/, os::col_t /*col*/, double /*value*/) ++{ ++ // TODO : implement result cache for matrix ++} ++ ++void ScOrcusArrayFormula::set_result_string(os::row_t /*row*/, os::col_t /*col*/, size_t /*sindex*/) ++{ ++ // TODO : implement result cache for matrix ++} ++ ++void ScOrcusArrayFormula::set_result_empty(os::row_t /*row*/, os::col_t /*col*/) ++{ ++ // TODO : implement result cache for matrix ++} ++ ++void ScOrcusArrayFormula::set_result_bool(os::row_t /*row*/, os::col_t /*col*/, bool /*value*/) ++{ ++ // TODO : implement result cache for matrix ++} ++ ++void ScOrcusArrayFormula::commit() ++{ ++ ScAddress aPos(mnCol, mnRow, mrSheet.getIndex()); ++ mrSheet.getFactory().pushMatrixFormulaToken(aPos, maFormula, meGrammar, mnRowRange, mnColRange); ++ mrSheet.cellInserted(); ++} ++ + void ScOrcusSheet::cellInserted() + { + ++mnCellCount; +@@ -830,6 +1027,11 @@ void ScOrcusSheet::cellInserted() + } + } + ++ScDocumentImport& ScOrcusSheet::getDoc() ++{ ++ return mrDoc; ++} ++ + os::iface::import_auto_filter* ScOrcusSheet::get_auto_filter() + { + return &maAutoFilter; +@@ -855,6 +1057,18 @@ os::iface::import_named_expression* ScOrcusSheet::get_named_expression() + return &maNamedExpressions; + } + ++os::iface::import_formula* ScOrcusSheet::get_formula() ++{ ++ maFormula.reset(); ++ return &maFormula; ++} ++ ++os::iface::import_array_formula* ScOrcusSheet::get_array_formula() ++{ ++ maArrayFormula.reset(); ++ return &maArrayFormula; ++} ++ + void ScOrcusSheet::set_auto(os::row_t row, os::col_t col, const char* p, size_t n) + { + OUString aVal(p, n, RTL_TEXTENCODING_UTF8); +@@ -921,83 +1135,6 @@ void ScOrcusSheet::set_format(os::row_t row_start, os::col_t col_start, + mrDoc.getDoc().ApplyPatternAreaTab(col_start, row_start, col_end, row_end, mnTab, aPattern); + } + +-void ScOrcusSheet::set_formula( +- os::row_t row, os::col_t col, os::formula_grammar_t grammar, const char* p, size_t n) +-{ +- OUString aFormula(p, n, RTL_TEXTENCODING_UTF8); +- mrFactory.pushCellStoreToken( +- ScAddress(col, row, mnTab), aFormula, getCalcGrammarFromOrcus(grammar)); +- cellInserted(); +-} +- +-void ScOrcusSheet::set_formula_result(os::row_t row, os::col_t col, const char* p, size_t n) +-{ +- OUString aResult( p, n, RTL_TEXTENCODING_UTF8); +- mrFactory.pushFormulaResult(ScAddress(col, row, mnTab), aResult); +-} +- +-void ScOrcusSheet::set_formula_result(os::row_t row, os::col_t col, double val) +-{ +- mrFactory.pushFormulaResult(ScAddress(col, row, mnTab), val); +-} +- +-void ScOrcusSheet::set_shared_formula( +- os::row_t row, os::col_t col, os::formula_grammar_t grammar, size_t sindex, +- const char* p_formula, size_t n_formula) +-{ +- ScAddress aPos(col, row, mnTab); +- OUString aFormula(p_formula, n_formula, RTL_TEXTENCODING_UTF8); +- formula::FormulaGrammar::Grammar eGram = getCalcGrammarFromOrcus(grammar); +- +- // Compile the formula expression into tokens. +- ScCompiler aComp(&mrDoc.getDoc(), aPos, eGram); +- ScTokenArray* pArray = aComp.CompileString(aFormula); +- if (!pArray) +- // Tokenization failed. +- return; +- +- maFormulaGroups.set(sindex, pArray); +- +- mrFactory.pushSharedFormulaToken(aPos, sindex); +- cellInserted(); +-} +- +-void ScOrcusSheet::set_shared_formula( +- os::row_t row, os::col_t col, os::formula_grammar_t grammar, size_t sindex, +- const char* p_formula, size_t n_formula, const char* /*p_range*/, size_t /*n_range*/) +-{ +- set_shared_formula(row, col, grammar, sindex, p_formula, n_formula); +-} +- +-void ScOrcusSheet::set_shared_formula(os::row_t row, os::col_t col, size_t sindex) +-{ +- ScAddress aPos(col, row, mnTab); +- +- const ScTokenArray* pArray = maFormulaGroups.get(sindex); +- if (!pArray) +- return; +- +- mrFactory.pushSharedFormulaToken(aPos, sindex); +- cellInserted(); +-} +- +-void ScOrcusSheet::set_array_formula( +- os::row_t row, os::col_t col, os::formula_grammar_t grammar, +- const char* p, size_t n, os::row_t array_rows, os::col_t array_cols) +-{ +- OUString aFormula(p, n, RTL_TEXTENCODING_UTF8); +- formula::FormulaGrammar::Grammar eGrammar = getCalcGrammarFromOrcus(grammar); +- +- ScAddress aPos(col, row, mnTab); +- mrFactory.pushMatrixFormulaToken(aPos, aFormula, eGrammar, array_rows, array_cols); +-} +- +-void ScOrcusSheet::set_array_formula( +- os::row_t /*row*/, os::col_t /*col*/, os::formula_grammar_t /*grammar*/, +- const char* /*p*/, size_t /*n*/, const char* /*p_range*/, size_t /*n_range*/) +-{ +-} +- + orcus::spreadsheet::range_size_t ScOrcusSheet::get_sheet_size() const + { + orcus::spreadsheet::range_size_t ret; +@@ -1012,6 +1149,16 @@ const sc::SharedFormulaGroups& ScOrcusSheet::getSharedFormulaGroups() const + return maFormulaGroups; + } + ++sc::SharedFormulaGroups& ScOrcusSheet::getSharedFormulaGroups() ++{ ++ return maFormulaGroups; ++} ++ ++ScOrcusFactory& ScOrcusSheet::getFactory() ++{ ++ return mrFactory; ++} ++ + ScOrcusSharedStrings::ScOrcusSharedStrings(ScOrcusFactory& rFactory) : + mrFactory(rFactory) {} + +@@ -1087,7 +1234,7 @@ ScOrcusStyles::font::font(): + } + + ScOrcusStyles::fill::fill(): +- maPattern(""), ++ mePattern(orcus::spreadsheet::fill_pattern_t::none), + maFgColor(COL_WHITE), + maBgColor(COL_WHITE), + mbHasFillAttr(false) +@@ -1143,13 +1290,13 @@ void ScOrcusStyles::font::applyToItemSet(SfxItemSet& rSet) const + + void ScOrcusStyles::fill::applyToItemSet(SfxItemSet& rSet) const + { +- if (maPattern.equalsIgnoreAsciiCase("none")) ++ if (mePattern == orcus::spreadsheet::fill_pattern_t::none) + { + SAL_INFO("sc.orcus.style", "no fill style"); + return; + } + +- if (maPattern.equalsIgnoreAsciiCase("solid")) ++ if (mePattern == orcus::spreadsheet::fill_pattern_t::solid) + rSet.Put(SvxBrushItem(maFgColor, ATTR_BACKGROUND)); + } + +@@ -1575,10 +1722,9 @@ void ScOrcusStyles::set_fill_count(size_t /*n*/) + // needed at all? + } + +-void ScOrcusStyles::set_fill_pattern_type(const char* s, size_t n) ++void ScOrcusStyles::set_fill_pattern_type(orcus::spreadsheet::fill_pattern_t fp) + { +- maCurrentFill.maPattern = OUString(s, n, RTL_TEXTENCODING_UTF8); +- maCurrentFill.mbHasFillAttr = true; ++ maCurrentFill.mePattern = fp; + } + + void ScOrcusStyles::set_fill_fg_color( +@@ -1962,12 +2108,12 @@ ScOrcusAutoFilter::~ScOrcusAutoFilter() + { + } + +-void ScOrcusAutoFilter::set_range(const char* p_ref, size_t n_ref) ++void ScOrcusAutoFilter::set_range(const orcus::spreadsheet::range_t& range) + { +- OUString aRange(p_ref, n_ref, RTL_TEXTENCODING_UTF8); +- SAL_INFO("sc.orcus.autofilter", "set_range: " << aRange); +- +- maRange.Parse(aRange); ++ maRange.aStart.SetRow(range.first.row); ++ maRange.aStart.SetCol(range.first.column); ++ maRange.aEnd.SetRow(range.last.row); ++ maRange.aEnd.SetCol(range.last.column); + } + + void ScOrcusAutoFilter::set_column(orcus::spreadsheet::col_t col) +diff --git a/sc/source/filter/orcus/xmlcontext.cxx b/sc/source/filter/orcus/xmlcontext.cxx +index e47b862c2138..5494ddefc434 100644 +--- a/sc/source/filter/orcus/xmlcontext.cxx ++++ b/sc/source/filter/orcus/xmlcontext.cxx +@@ -24,6 +24,7 @@ + #include + #include + #include ++#include + + #include + #include +@@ -289,7 +290,9 @@ void ScOrcusXMLContextImpl::importXML(const ScOrcusImportXMLParam& rParam) + } + } + +- filter.read_file(path); ++ std::string content = orcus::load_file_content(path); ++ filter.read_stream(content.data(), content.size()); ++ + aFactory.finalize(); + } + catch (const std::exception&) +-- +2.17.1 + diff --git a/office/LibreOffice/LibreOffice.SlackBuild b/office/LibreOffice/LibreOffice.SlackBuild index a13ada40e1..1df7c946bf 100644 --- a/office/LibreOffice/LibreOffice.SlackBuild +++ b/office/LibreOffice/LibreOffice.SlackBuild @@ -28,7 +28,7 @@ PRGNAM=LibreOffice SRCNAM=libreoffice VERSION=${VERSION:-6.1.3.2} SHORT_VERSION=${VERSION%.*.*} -BUILD=${BUILD:-1} +BUILD=${BUILD:-2} TAG=${TAG:-_SBo} PACKAGER=${PACKAGER:-"AnonymousCoward"} @@ -70,8 +70,12 @@ rm -rf $SRCNAM-$VERSION tar xvf $CWD/$SRCNAM-$VERSION.tar.xz cd $SRCNAM-$VERSION +# Required for updates to mdds, liborcus (needs autogen.sh) +patch -p1 < $CWD/0001-Update-mdds-to-1.4.1.patch +patch -p1 < $CWD/0001-Update-orcus-to-0.14.0.patch + if [ "$HAVE_SRCS_TARBALL" = "1" ]; then - tar xvf $CWD/$SRCNAM-${VERSION}-srcs.tar.xz + tar xvf $CWD/$SRCNAM-${VERSION}-srcs_2.tar.xz fi chown -R root:root . @@ -122,7 +126,7 @@ if pkg-config --exists libfreehand-0.1 ; then libfreehand="--with-system-libfree if pkg-config --exists libmspub-0.1 ; then libmspub="--with-system-libmspub" ; else libmspub="" ; fi if pkg-config --exists libmwaw-0.3 ; then libmwaw="--with-system-libmwaw" ; else libmwaw="" ; fi if pkg-config --exists libnumbertext ; then libnumbertext="--with-system-libnumbertext" ; else libnumbertext="" ; fi -if pkg-config --exists liborcus-0.13 ; then liborcus="--with-system-orcus" ; else liborcus="" ; fi +if pkg-config --exists liborcus-0.14 ; then liborcus="--with-system-orcus" ; else liborcus="" ; fi if pkg-config --exists libpagemaker-0.0 ; then libpagemaker="--with-system-libpagemaker" ; else libpagemaker="" ; fi if pkg-config --exists libqxp-0.0 ; then libqxp="--with-system-libqxp" ; else libqxp="" ; fi if pkg-config --exists libstaroffice-0.0 ; then libstaroffice="--with-system-libstaroffice" ; else libstaroffice="" ; fi @@ -132,7 +136,7 @@ if pkg-config --exists libzmf-0.0 ; then libzmf="--with-system-libzmf" ; else li if pkg-config --exists libpq ; then postgresql="--with-system-postgresql" ; else postgresql="" ; fi if pkg-config --exists libucpp ; then ucpp="--with-system-ucpp" ; else ucpp="" ; fi if test -e /usr/include/lpsolve ; then lpsolve="--with-system-lpsolve" ; else lpsolve="" ; fi -if pkg-config --exists mdds-1.2 ; then mdds="--with-system-mdds" ; else mdds="" ; fi +if pkg-config --exists mdds-1.4 ; then mdds="--with-system-mdds" ; else mdds="" ; fi if test -e /usr/include/mysql_connection.h ; then mysql="--with-system-mysql-cppconn" ; else mysql="" ; fi if pkg-config --exists mythes ; then mythes="--with-system-mythes" ; else mythes="" ; fi if test -x /usr/bin/odbc_config ; then odbc="--with-system-odbc" ; else odbc="" ; fi @@ -161,7 +165,7 @@ extwikipub="--enable-ext-wiki-publisher"; [ "${EXTWIKIPUB:-no}" != "yes" ] & extnlpsolver="--enable-ext-nlpsolver"; [ "${EXTNLPSOLVER:-yes}" != "yes" ] && extnlpsolver="" extmariadb="--enable-ext-mariadb-connector"; [ "${EXTMARIADB:-yes}" != "yes" ] && extmariadb="" -./configure \ +./autogen.sh \ CFLAGS="$SLKCFLAGS" \ CXXFLAGS="$SLKCFLAGS" \ NSS_CFLAGS="$(pkg-config --cflags-only-I mozilla-nss)"\ @@ -266,7 +270,7 @@ extmariadb="--enable-ext-mariadb-connector"; [ "${EXTMARIADB:-yes}" != "yes" ] chmod a+x bin/unpack-sources if [ "$HAVE_SRCS_TARBALL" = "0" ]; then make fetch - tar cvf - external/tarballs | xz -c > $CWD/$SRCNAM-$VERSION-srcs.tar.xz + tar cvf - external/tarballs | xz -c > $CWD/$SRCNAM-$VERSION-srcs_2.tar.xz echo ; echo "Run build script again with HAVE_SRCS_TARBALL=1" exit 0 fi diff --git a/office/LibreOffice/LibreOffice.info b/office/LibreOffice/LibreOffice.info index a4b8a52c80..81dd47fe59 100644 --- a/office/LibreOffice/LibreOffice.info +++ b/office/LibreOffice/LibreOffice.info @@ -2,9 +2,9 @@ PRGNAM="LibreOffice" VERSION="6.1.3.2" HOMEPAGE="http://libreoffice.org" DOWNLOAD="http://download.documentfoundation.org/libreoffice/src/6.1.3/libreoffice-6.1.3.2.tar.xz \ - http://sourceforge.net/projects/slackbuildsdirectlinks/files/LibreOffice/libreoffice-6.1.3.2-srcs.tar.xz" + http://sourceforge.net/projects/slackbuildsdirectlinks/files/LibreOffice/libreoffice-6.1.3.2-srcs_2.tar.xz" MD5SUM="e53e729023440e8435a082b4f307b69b \ - 6c4eb80dfef22ba0b6f3c1c9cdc6dd8e" + 27dd5a89d83aea651874e1820dd0c268" DOWNLOAD_x86_64="" MD5SUM_x86_64="" REQUIRES="python3 openjdk apache-ant perl-Archive-Zip" -- cgit v1.2.3