| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| #include "XMLConverter.hxx" |
| #include <com/sun/star/util/DateTime.hpp> |
| #include <tools/datetime.hxx> |
| #include <xmloff/xmltoken.hxx> |
| #include <xmloff/xmluconv.hxx> |
| #include "rangelst.hxx" |
| #include "rangeutl.hxx" |
| #include "docuno.hxx" |
| #include "convuno.hxx" |
| #include "document.hxx" |
| #include "ftools.hxx" |
| |
| using ::rtl::OUString; |
| using ::rtl::OUStringBuffer; |
| using namespace ::com::sun::star; |
| using namespace xmloff::token; |
| |
| |
| //___________________________________________________________________ |
| |
| ScDocument* ScXMLConverter::GetScDocument( uno::Reference< frame::XModel > xModel ) |
| { |
| if (xModel.is()) |
| { |
| ScModelObj* pDocObj = ScModelObj::getImplementation( xModel ); |
| return pDocObj ? pDocObj->GetDocument() : NULL; |
| } |
| return NULL; |
| } |
| |
| |
| //___________________________________________________________________ |
| sheet::GeneralFunction ScXMLConverter::GetFunctionFromString( const OUString& sFunction ) |
| { |
| if( IsXMLToken(sFunction, XML_SUM ) ) |
| return sheet::GeneralFunction_SUM; |
| if( IsXMLToken(sFunction, XML_AUTO ) ) |
| return sheet::GeneralFunction_AUTO; |
| if( IsXMLToken(sFunction, XML_COUNT ) ) |
| return sheet::GeneralFunction_COUNT; |
| if( IsXMLToken(sFunction, XML_COUNTNUMS ) ) |
| return sheet::GeneralFunction_COUNTNUMS; |
| if( IsXMLToken(sFunction, XML_PRODUCT ) ) |
| return sheet::GeneralFunction_PRODUCT; |
| if( IsXMLToken(sFunction, XML_AVERAGE ) ) |
| return sheet::GeneralFunction_AVERAGE; |
| if( IsXMLToken(sFunction, XML_MAX ) ) |
| return sheet::GeneralFunction_MAX; |
| if( IsXMLToken(sFunction, XML_MIN ) ) |
| return sheet::GeneralFunction_MIN; |
| if( IsXMLToken(sFunction, XML_STDEV ) ) |
| return sheet::GeneralFunction_STDEV; |
| if( IsXMLToken(sFunction, XML_STDEVP ) ) |
| return sheet::GeneralFunction_STDEVP; |
| if( IsXMLToken(sFunction, XML_VAR ) ) |
| return sheet::GeneralFunction_VAR; |
| if( IsXMLToken(sFunction, XML_VARP ) ) |
| return sheet::GeneralFunction_VARP; |
| return sheet::GeneralFunction_NONE; |
| } |
| |
| ScSubTotalFunc ScXMLConverter::GetSubTotalFuncFromString( const OUString& sFunction ) |
| { |
| if( IsXMLToken(sFunction, XML_SUM ) ) |
| return SUBTOTAL_FUNC_SUM; |
| if( IsXMLToken(sFunction, XML_COUNT ) ) |
| return SUBTOTAL_FUNC_CNT; |
| if( IsXMLToken(sFunction, XML_COUNTNUMS ) ) |
| return SUBTOTAL_FUNC_CNT2; |
| if( IsXMLToken(sFunction, XML_PRODUCT ) ) |
| return SUBTOTAL_FUNC_PROD; |
| if( IsXMLToken(sFunction, XML_AVERAGE ) ) |
| return SUBTOTAL_FUNC_AVE; |
| if( IsXMLToken(sFunction, XML_MAX ) ) |
| return SUBTOTAL_FUNC_MAX; |
| if( IsXMLToken(sFunction, XML_MIN ) ) |
| return SUBTOTAL_FUNC_MIN; |
| if( IsXMLToken(sFunction, XML_STDEV ) ) |
| return SUBTOTAL_FUNC_STD; |
| if( IsXMLToken(sFunction, XML_STDEVP ) ) |
| return SUBTOTAL_FUNC_STDP; |
| if( IsXMLToken(sFunction, XML_VAR ) ) |
| return SUBTOTAL_FUNC_VAR; |
| if( IsXMLToken(sFunction, XML_VARP ) ) |
| return SUBTOTAL_FUNC_VARP; |
| return SUBTOTAL_FUNC_NONE; |
| } |
| |
| |
| //___________________________________________________________________ |
| |
| void ScXMLConverter::GetStringFromFunction( |
| OUString& rString, |
| const sheet::GeneralFunction eFunction, |
| sal_Bool bAppendStr ) |
| { |
| OUString sFuncStr; |
| switch( eFunction ) |
| { |
| case sheet::GeneralFunction_AUTO: sFuncStr = GetXMLToken( XML_AUTO ); break; |
| case sheet::GeneralFunction_AVERAGE: sFuncStr = GetXMLToken( XML_AVERAGE ); break; |
| case sheet::GeneralFunction_COUNT: sFuncStr = GetXMLToken( XML_COUNT ); break; |
| case sheet::GeneralFunction_COUNTNUMS: sFuncStr = GetXMLToken( XML_COUNTNUMS ); break; |
| case sheet::GeneralFunction_MAX: sFuncStr = GetXMLToken( XML_MAX ); break; |
| case sheet::GeneralFunction_MIN: sFuncStr = GetXMLToken( XML_MIN ); break; |
| case sheet::GeneralFunction_NONE: sFuncStr = GetXMLToken( XML_NONE ); break; |
| case sheet::GeneralFunction_PRODUCT: sFuncStr = GetXMLToken( XML_PRODUCT ); break; |
| case sheet::GeneralFunction_STDEV: sFuncStr = GetXMLToken( XML_STDEV ); break; |
| case sheet::GeneralFunction_STDEVP: sFuncStr = GetXMLToken( XML_STDEVP ); break; |
| case sheet::GeneralFunction_SUM: sFuncStr = GetXMLToken( XML_SUM ); break; |
| case sheet::GeneralFunction_VAR: sFuncStr = GetXMLToken( XML_VAR ); break; |
| case sheet::GeneralFunction_VARP: sFuncStr = GetXMLToken( XML_VARP ); break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| ScRangeStringConverter::AssignString( rString, sFuncStr, bAppendStr ); |
| } |
| |
| void ScXMLConverter::GetStringFromFunction( |
| OUString& rString, |
| const ScSubTotalFunc eFunction, |
| sal_Bool bAppendStr ) |
| { |
| OUString sFuncStr; |
| switch( eFunction ) |
| { |
| case SUBTOTAL_FUNC_AVE: sFuncStr = GetXMLToken( XML_AVERAGE ); break; |
| case SUBTOTAL_FUNC_CNT: sFuncStr = GetXMLToken( XML_COUNT ); break; |
| case SUBTOTAL_FUNC_CNT2: sFuncStr = GetXMLToken( XML_COUNTNUMS ); break; |
| case SUBTOTAL_FUNC_MAX: sFuncStr = GetXMLToken( XML_MAX ); break; |
| case SUBTOTAL_FUNC_MIN: sFuncStr = GetXMLToken( XML_MIN ); break; |
| case SUBTOTAL_FUNC_NONE: sFuncStr = GetXMLToken( XML_NONE ); break; |
| case SUBTOTAL_FUNC_PROD: sFuncStr = GetXMLToken( XML_PRODUCT ); break; |
| case SUBTOTAL_FUNC_STD: sFuncStr = GetXMLToken( XML_STDEV ); break; |
| case SUBTOTAL_FUNC_STDP: sFuncStr = GetXMLToken( XML_STDEVP ); break; |
| case SUBTOTAL_FUNC_SUM: sFuncStr = GetXMLToken( XML_SUM ); break; |
| case SUBTOTAL_FUNC_VAR: sFuncStr = GetXMLToken( XML_VAR ); break; |
| case SUBTOTAL_FUNC_VARP: sFuncStr = GetXMLToken( XML_VARP ); break; |
| } |
| ScRangeStringConverter::AssignString( rString, sFuncStr, bAppendStr ); |
| } |
| |
| |
| //___________________________________________________________________ |
| |
| sheet::DataPilotFieldOrientation ScXMLConverter::GetOrientationFromString( |
| const OUString& rString ) |
| { |
| if( IsXMLToken(rString, XML_COLUMN ) ) |
| return sheet::DataPilotFieldOrientation_COLUMN; |
| if( IsXMLToken(rString, XML_ROW ) ) |
| return sheet::DataPilotFieldOrientation_ROW; |
| if( IsXMLToken(rString, XML_PAGE ) ) |
| return sheet::DataPilotFieldOrientation_PAGE; |
| if( IsXMLToken(rString, XML_DATA ) ) |
| return sheet::DataPilotFieldOrientation_DATA; |
| return sheet::DataPilotFieldOrientation_HIDDEN; |
| } |
| |
| |
| //___________________________________________________________________ |
| |
| void ScXMLConverter::GetStringFromOrientation( |
| OUString& rString, |
| const sheet::DataPilotFieldOrientation eOrientation, |
| sal_Bool bAppendStr ) |
| { |
| OUString sOrientStr; |
| switch( eOrientation ) |
| { |
| case sheet::DataPilotFieldOrientation_HIDDEN: |
| sOrientStr = GetXMLToken( XML_HIDDEN ); |
| break; |
| case sheet::DataPilotFieldOrientation_COLUMN: |
| sOrientStr = GetXMLToken( XML_COLUMN ); |
| break; |
| case sheet::DataPilotFieldOrientation_ROW: |
| sOrientStr = GetXMLToken( XML_ROW ); |
| break; |
| case sheet::DataPilotFieldOrientation_PAGE: |
| sOrientStr = GetXMLToken( XML_PAGE ); |
| break; |
| case sheet::DataPilotFieldOrientation_DATA: |
| sOrientStr = GetXMLToken( XML_DATA ); |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| ScRangeStringConverter::AssignString( rString, sOrientStr, bAppendStr ); |
| } |
| |
| |
| //___________________________________________________________________ |
| |
| ScDetectiveObjType ScXMLConverter::GetDetObjTypeFromString( const OUString& rString ) |
| { |
| if( IsXMLToken(rString, XML_FROM_SAME_TABLE ) ) |
| return SC_DETOBJ_ARROW; |
| if( IsXMLToken(rString, XML_FROM_ANOTHER_TABLE ) ) |
| return SC_DETOBJ_FROMOTHERTAB; |
| if( IsXMLToken(rString, XML_TO_ANOTHER_TABLE ) ) |
| return SC_DETOBJ_TOOTHERTAB; |
| return SC_DETOBJ_NONE; |
| } |
| |
| sal_Bool ScXMLConverter::GetDetOpTypeFromString( ScDetOpType& rDetOpType, const OUString& rString ) |
| { |
| if( IsXMLToken(rString, XML_TRACE_DEPENDENTS ) ) |
| rDetOpType = SCDETOP_ADDSUCC; |
| else if( IsXMLToken(rString, XML_TRACE_PRECEDENTS ) ) |
| rDetOpType = SCDETOP_ADDPRED; |
| else if( IsXMLToken(rString, XML_TRACE_ERRORS ) ) |
| rDetOpType = SCDETOP_ADDERROR; |
| else if( IsXMLToken(rString, XML_REMOVE_DEPENDENTS ) ) |
| rDetOpType = SCDETOP_DELSUCC; |
| else if( IsXMLToken(rString, XML_REMOVE_PRECEDENTS ) ) |
| rDetOpType = SCDETOP_DELPRED; |
| else |
| return sal_False; |
| return sal_True; |
| } |
| |
| |
| //___________________________________________________________________ |
| |
| void ScXMLConverter::GetStringFromDetObjType( |
| OUString& rString, |
| const ScDetectiveObjType eObjType, |
| sal_Bool bAppendStr ) |
| { |
| OUString sTypeStr; |
| switch( eObjType ) |
| { |
| case SC_DETOBJ_ARROW: |
| sTypeStr = GetXMLToken( XML_FROM_SAME_TABLE ); |
| break; |
| case SC_DETOBJ_FROMOTHERTAB: |
| sTypeStr = GetXMLToken( XML_FROM_ANOTHER_TABLE ); |
| break; |
| case SC_DETOBJ_TOOTHERTAB: |
| sTypeStr = GetXMLToken( XML_TO_ANOTHER_TABLE ); |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| ScRangeStringConverter::AssignString( rString, sTypeStr, bAppendStr ); |
| } |
| |
| void ScXMLConverter::GetStringFromDetOpType( |
| OUString& rString, |
| const ScDetOpType eOpType, |
| sal_Bool bAppendStr ) |
| { |
| OUString sTypeStr; |
| switch( eOpType ) |
| { |
| case SCDETOP_ADDSUCC: |
| sTypeStr = GetXMLToken( XML_TRACE_DEPENDENTS ); |
| break; |
| case SCDETOP_ADDPRED: |
| sTypeStr = GetXMLToken( XML_TRACE_PRECEDENTS ); |
| break; |
| case SCDETOP_ADDERROR: |
| sTypeStr = GetXMLToken( XML_TRACE_ERRORS ); |
| break; |
| case SCDETOP_DELSUCC: |
| sTypeStr = GetXMLToken( XML_REMOVE_DEPENDENTS ); |
| break; |
| case SCDETOP_DELPRED: |
| sTypeStr = GetXMLToken( XML_REMOVE_PRECEDENTS ); |
| break; |
| } |
| ScRangeStringConverter::AssignString( rString, sTypeStr, bAppendStr ); |
| } |
| |
| |
| //___________________________________________________________________ |
| |
| void ScXMLConverter::ParseFormula(OUString& sFormula, const sal_Bool bIsFormula) |
| { |
| OUStringBuffer sBuffer(sFormula.getLength()); |
| sal_Bool bInQuotationMarks(sal_False); |
| sal_Bool bInDoubleQuotationMarks(sal_False); |
| sal_Int16 nCountBraces(0); |
| sal_Unicode chPrevious('='); |
| for (sal_Int32 i = 0; i < sFormula.getLength(); ++i) |
| { |
| if (sFormula[i] == '\'' && !bInDoubleQuotationMarks && |
| chPrevious != '\\') |
| bInQuotationMarks = !bInQuotationMarks; |
| else if (sFormula[i] == '"' && !bInQuotationMarks) |
| bInDoubleQuotationMarks = !bInDoubleQuotationMarks; |
| if (bInQuotationMarks || bInDoubleQuotationMarks) |
| sBuffer.append(sFormula[i]); |
| else if (sFormula[i] == '[') |
| ++nCountBraces; |
| else if (sFormula[i] == ']') |
| nCountBraces--; |
| else if ((sFormula[i] != '.') || |
| ((nCountBraces == 0) && bIsFormula) || |
| !((chPrevious == '[') || (chPrevious == ':') || (chPrevious == ' ') || (chPrevious == '='))) |
| sBuffer.append(sFormula[i]); |
| chPrevious = sFormula[i]; |
| } |
| |
| DBG_ASSERT(nCountBraces == 0, "there are some braces still open"); |
| sFormula = sBuffer.makeStringAndClear(); |
| } |
| |
| |
| //_____________________________________________________________________ |
| |
| void ScXMLConverter::ConvertDateTimeToString(const DateTime& aDateTime, rtl::OUStringBuffer& sDate) |
| { |
| util::DateTime aAPIDateTime; |
| ConvertCoreToAPIDateTime(aDateTime, aAPIDateTime); |
| SvXMLUnitConverter::convertDateTime(sDate, aAPIDateTime); |
| } |
| |
| //UNUSED2008-05 void ScXMLConverter::ConvertStringToDateTime(const rtl::OUString& sDate, DateTime& aDateTime, SvXMLUnitConverter* /* pUnitConverter */) |
| //UNUSED2008-05 { |
| //UNUSED2008-05 com::sun::star::util::DateTime aAPIDateTime; |
| //UNUSED2008-05 SvXMLUnitConverter::convertDateTime(aAPIDateTime, sDate); |
| //UNUSED2008-05 ConvertAPIToCoreDateTime(aAPIDateTime, aDateTime); |
| //UNUSED2008-05 } |
| |
| void ScXMLConverter::ConvertCoreToAPIDateTime(const DateTime& aDateTime, util::DateTime& rDateTime) |
| { |
| rDateTime.Year = aDateTime.GetYear(); |
| rDateTime.Month = aDateTime.GetMonth(); |
| rDateTime.Day = aDateTime.GetDay(); |
| rDateTime.Hours = aDateTime.GetHour(); |
| rDateTime.Minutes = aDateTime.GetMin(); |
| rDateTime.Seconds = aDateTime.GetSec(); |
| rDateTime.HundredthSeconds = aDateTime.Get100Sec(); |
| } |
| |
| void ScXMLConverter::ConvertAPIToCoreDateTime(const util::DateTime& aDateTime, DateTime& rDateTime) |
| { |
| Date aDate(aDateTime.Day, aDateTime.Month, aDateTime.Year); |
| Time aTime(aDateTime.Hours, aDateTime.Minutes, aDateTime.Seconds, aDateTime.HundredthSeconds); |
| DateTime aTempDateTime (aDate, aTime); |
| rDateTime = aTempDateTime; |
| } |
| |
| // ============================================================================ |
| |
| namespace { |
| |
| /** Enumerates different types of condition tokens. */ |
| enum ScXMLConditionTokenType |
| { |
| XML_COND_TYPE_KEYWORD, /// Simple keyword without parentheses, e.g. 'and'. |
| XML_COND_TYPE_COMPARISON, /// Comparison rule, e.g. 'cell-content()<=2'. |
| XML_COND_TYPE_FUNCTION0, /// Function without parameters, e.g. 'cell-content-is-whole-number()'. |
| XML_COND_TYPE_FUNCTION1, /// Function with 1 parameter, e.g. 'is-true-formula(1+1=2)'. |
| XML_COND_TYPE_FUNCTION2 /// Function with 2 parameters, e.g. 'cell-content-is-between(1,2)'. |
| }; |
| |
| struct ScXMLConditionInfo |
| { |
| ScXMLConditionToken meToken; |
| ScXMLConditionTokenType meType; |
| sheet::ValidationType meValidation; |
| sheet::ConditionOperator meOperator; |
| const sal_Char* mpcIdentifier; |
| sal_Int32 mnIdentLength; |
| }; |
| |
| static const ScXMLConditionInfo spConditionInfos[] = |
| { |
| { XML_COND_AND, XML_COND_TYPE_KEYWORD, sheet::ValidationType_ANY, sheet::ConditionOperator_NONE, RTL_CONSTASCII_STRINGPARAM( "and" ) }, |
| { XML_COND_CELLCONTENT, XML_COND_TYPE_COMPARISON, sheet::ValidationType_ANY, sheet::ConditionOperator_NONE, RTL_CONSTASCII_STRINGPARAM( "cell-content" ) }, |
| { XML_COND_ISBETWEEN, XML_COND_TYPE_FUNCTION2, sheet::ValidationType_ANY, sheet::ConditionOperator_BETWEEN, RTL_CONSTASCII_STRINGPARAM( "cell-content-is-between" ) }, |
| { XML_COND_ISNOTBETWEEN, XML_COND_TYPE_FUNCTION2, sheet::ValidationType_ANY, sheet::ConditionOperator_NOT_BETWEEN, RTL_CONSTASCII_STRINGPARAM( "cell-content-is-not-between" ) }, |
| { XML_COND_ISWHOLENUMBER, XML_COND_TYPE_FUNCTION0, sheet::ValidationType_WHOLE, sheet::ConditionOperator_NONE, RTL_CONSTASCII_STRINGPARAM( "cell-content-is-whole-number" ) }, |
| { XML_COND_ISDECIMALNUMBER, XML_COND_TYPE_FUNCTION0, sheet::ValidationType_DECIMAL, sheet::ConditionOperator_NONE, RTL_CONSTASCII_STRINGPARAM( "cell-content-is-decimal-number" ) }, |
| { XML_COND_ISDATE, XML_COND_TYPE_FUNCTION0, sheet::ValidationType_DATE, sheet::ConditionOperator_NONE, RTL_CONSTASCII_STRINGPARAM( "cell-content-is-date" ) }, |
| { XML_COND_ISTIME, XML_COND_TYPE_FUNCTION0, sheet::ValidationType_TIME, sheet::ConditionOperator_NONE, RTL_CONSTASCII_STRINGPARAM( "cell-content-is-time" ) }, |
| { XML_COND_ISINLIST, XML_COND_TYPE_FUNCTION1, sheet::ValidationType_LIST, sheet::ConditionOperator_EQUAL, RTL_CONSTASCII_STRINGPARAM( "cell-content-is-in-list" ) }, |
| { XML_COND_TEXTLENGTH, XML_COND_TYPE_COMPARISON, sheet::ValidationType_TEXT_LEN, sheet::ConditionOperator_NONE, RTL_CONSTASCII_STRINGPARAM( "cell-content-text-length" ) }, |
| { XML_COND_TEXTLENGTH_ISBETWEEN, XML_COND_TYPE_FUNCTION2, sheet::ValidationType_TEXT_LEN, sheet::ConditionOperator_BETWEEN, RTL_CONSTASCII_STRINGPARAM( "cell-content-text-length-is-between" ) }, |
| { XML_COND_TEXTLENGTH_ISNOTBETWEEN, XML_COND_TYPE_FUNCTION2, sheet::ValidationType_TEXT_LEN, sheet::ConditionOperator_NOT_BETWEEN, RTL_CONSTASCII_STRINGPARAM( "cell-content-text-length-is-not-between" ) }, |
| { XML_COND_ISTRUEFORMULA, XML_COND_TYPE_FUNCTION1, sheet::ValidationType_CUSTOM, sheet::ConditionOperator_FORMULA, RTL_CONSTASCII_STRINGPARAM( "is-true-formula" ) } |
| }; |
| |
| void lclSkipWhitespace( const sal_Unicode*& rpcString, const sal_Unicode* pcEnd ) |
| { |
| while( (rpcString < pcEnd) && (*rpcString <= ' ') ) ++rpcString; |
| } |
| |
| const ScXMLConditionInfo* lclGetConditionInfo( const sal_Unicode*& rpcString, const sal_Unicode* pcEnd ) |
| { |
| lclSkipWhitespace( rpcString, pcEnd ); |
| /* Search the end of an identifier name; assuming that valid identifiers |
| consist of [a-z-] only. */ |
| const sal_Unicode* pcIdStart = rpcString; |
| while( (rpcString < pcEnd) && (((*rpcString >= 'a') && (*rpcString <= 'z')) || (*rpcString == '-')) ) ++rpcString; |
| sal_Int32 nLength = static_cast< sal_Int32 >( rpcString - pcIdStart ); |
| |
| // search the table for an entry |
| if( nLength > 0 ) |
| for( const ScXMLConditionInfo* pInfo = spConditionInfos; pInfo < STATIC_ARRAY_END( spConditionInfos ); ++pInfo ) |
| if( (nLength == pInfo->mnIdentLength) && (::rtl_ustr_ascii_shortenedCompare_WithLength( pcIdStart, nLength, pInfo->mpcIdentifier, nLength ) == 0) ) |
| return pInfo; |
| |
| return 0; |
| } |
| |
| sheet::ConditionOperator lclGetConditionOperator( const sal_Unicode*& rpcString, const sal_Unicode* pcEnd ) |
| { |
| // check for double-char operators |
| if( (rpcString + 1 < pcEnd) && (rpcString[ 1 ] == '=') ) |
| { |
| sheet::ConditionOperator eOperator = sheet::ConditionOperator_NONE; |
| switch( *rpcString ) |
| { |
| case '!': eOperator = sheet::ConditionOperator_NOT_EQUAL; break; |
| case '<': eOperator = sheet::ConditionOperator_LESS_EQUAL; break; |
| case '>': eOperator = sheet::ConditionOperator_GREATER_EQUAL; break; |
| } |
| if( eOperator != sheet::ConditionOperator_NONE ) |
| { |
| rpcString += 2; |
| return eOperator; |
| } |
| } |
| |
| // check for single-char operators |
| if( rpcString < pcEnd ) |
| { |
| sheet::ConditionOperator eOperator = sheet::ConditionOperator_NONE; |
| switch( *rpcString ) |
| { |
| case '=': eOperator = sheet::ConditionOperator_EQUAL; break; |
| case '<': eOperator = sheet::ConditionOperator_LESS; break; |
| case '>': eOperator = sheet::ConditionOperator_GREATER; break; |
| } |
| if( eOperator != sheet::ConditionOperator_NONE ) |
| { |
| ++rpcString; |
| return eOperator; |
| } |
| } |
| |
| return sheet::ConditionOperator_NONE; |
| } |
| |
| /** Skips a literal string in a formula expression. |
| |
| @param rpcString |
| (in-out) On call, must point to the first character of the string |
| following the leading string delimiter character. On return, points to |
| the trailing string delimiter character if existing, otherwise to |
| pcEnd. |
| |
| @param pcEnd |
| The end of the string to parse. |
| |
| @param cQuoteChar |
| The string delimiter character enclosing the string. |
| */ |
| void lclSkipExpressionString( const sal_Unicode*& rpcString, const sal_Unicode* pcEnd, sal_Unicode cQuoteChar ) |
| { |
| if( rpcString < pcEnd ) |
| { |
| sal_Int32 nLength = static_cast< sal_Int32 >( pcEnd - rpcString ); |
| sal_Int32 nNextQuote = ::rtl_ustr_indexOfChar_WithLength( rpcString, nLength, cQuoteChar ); |
| if( nNextQuote >= 0 ) |
| rpcString += nNextQuote; |
| else |
| rpcString = pcEnd; |
| } |
| } |
| |
| /** Skips a formula expression. Processes embedded parentheses, braces, and |
| literal strings. |
| |
| @param rpcString |
| (in-out) On call, must point to the first character of the expression. |
| On return, points to the passed end character if existing, otherwise to |
| pcEnd. |
| |
| @param pcEnd |
| The end of the string to parse. |
| |
| @param cEndChar |
| The termination character following the expression. |
| */ |
| void lclSkipExpression( const sal_Unicode*& rpcString, const sal_Unicode* pcEnd, sal_Unicode cEndChar ) |
| { |
| while( rpcString < pcEnd ) |
| { |
| if( *rpcString == cEndChar ) |
| return; |
| switch( *rpcString ) |
| { |
| case '(': lclSkipExpression( ++rpcString, pcEnd, ')' ); break; |
| case '{': lclSkipExpression( ++rpcString, pcEnd, '}' ); break; |
| case '"': lclSkipExpressionString( ++rpcString, pcEnd, '"' ); break; |
| case '\'': lclSkipExpressionString( ++rpcString, pcEnd, '\'' ); break; |
| } |
| if( rpcString < pcEnd ) ++rpcString; |
| } |
| } |
| |
| /** Extracts a formula expression. Processes embedded parentheses, braces, and |
| literal strings. |
| |
| @param rpcString |
| (in-out) On call, must point to the first character of the expression. |
| On return, points *behind* the passed end character if existing, |
| otherwise to pcEnd. |
| |
| @param pcEnd |
| The end of the string to parse. |
| |
| @param cEndChar |
| The termination character following the expression. |
| */ |
| OUString lclGetExpression( const sal_Unicode*& rpcString, const sal_Unicode* pcEnd, sal_Unicode cEndChar ) |
| { |
| OUString aExp; |
| const sal_Unicode* pcExpStart = rpcString; |
| lclSkipExpression( rpcString, pcEnd, cEndChar ); |
| if( rpcString < pcEnd ) |
| { |
| aExp = OUString( pcExpStart, static_cast< sal_Int32 >( rpcString - pcExpStart ) ).trim(); |
| ++rpcString; |
| } |
| return aExp; |
| } |
| |
| /** Tries to skip an empty pair of parentheses (which may contain whitespace |
| characters). |
| |
| @return |
| True on success, rpcString points behind the closing parentheses then. |
| */ |
| bool lclSkipEmptyParentheses( const sal_Unicode*& rpcString, const sal_Unicode* pcEnd ) |
| { |
| if( (rpcString < pcEnd) && (*rpcString == '(') ) |
| { |
| lclSkipWhitespace( ++rpcString, pcEnd ); |
| if( (rpcString < pcEnd) && (*rpcString == ')') ) |
| { |
| ++rpcString; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| } // namespace |
| |
| // ---------------------------------------------------------------------------- |
| |
| /*static*/ void ScXMLConditionHelper::parseCondition( |
| ScXMLConditionParseResult& rParseResult, const OUString& rAttribute, sal_Int32 nStartIndex ) |
| { |
| rParseResult.meToken = XML_COND_INVALID; |
| if( (nStartIndex < 0) || (nStartIndex >= rAttribute.getLength()) ) return; |
| |
| // try to find an identifier |
| const sal_Unicode* pcBegin = rAttribute.getStr(); |
| const sal_Unicode* pcString = pcBegin + nStartIndex; |
| const sal_Unicode* pcEnd = pcBegin + rAttribute.getLength(); |
| if( const ScXMLConditionInfo* pCondInfo = lclGetConditionInfo( pcString, pcEnd ) ) |
| { |
| // insert default values into parse result (may be changed below) |
| rParseResult.meValidation = pCondInfo->meValidation; |
| rParseResult.meOperator = pCondInfo->meOperator; |
| // continue parsing dependent on token type |
| switch( pCondInfo->meType ) |
| { |
| case XML_COND_TYPE_KEYWORD: |
| // nothing specific has to follow, success |
| rParseResult.meToken = pCondInfo->meToken; |
| break; |
| |
| case XML_COND_TYPE_COMPARISON: |
| // format is <condition>()<operator><expression> |
| if( lclSkipEmptyParentheses( pcString, pcEnd ) ) |
| { |
| rParseResult.meOperator = lclGetConditionOperator( pcString, pcEnd ); |
| if( rParseResult.meOperator != sheet::ConditionOperator_NONE ) |
| { |
| lclSkipWhitespace( pcString, pcEnd ); |
| if( pcString < pcEnd ) |
| { |
| rParseResult.meToken = pCondInfo->meToken; |
| // comparison must be at end of attribute, remaining text is the formula |
| rParseResult.maOperand1 = OUString( pcString, static_cast< sal_Int32 >( pcEnd - pcString ) ); |
| } |
| } |
| } |
| break; |
| |
| case XML_COND_TYPE_FUNCTION0: |
| // format is <condition>() |
| if( lclSkipEmptyParentheses( pcString, pcEnd ) ) |
| rParseResult.meToken = pCondInfo->meToken; |
| break; |
| |
| case XML_COND_TYPE_FUNCTION1: |
| // format is <condition>(<expression>) |
| if( (pcString < pcEnd) && (*pcString == '(') ) |
| { |
| rParseResult.maOperand1 = lclGetExpression( ++pcString, pcEnd, ')' ); |
| if( rParseResult.maOperand1.getLength() > 0 ) |
| rParseResult.meToken = pCondInfo->meToken; |
| } |
| break; |
| |
| case XML_COND_TYPE_FUNCTION2: |
| // format is <condition>(<expression1>,<expression2>) |
| if( (pcString < pcEnd) && (*pcString == '(') ) |
| { |
| rParseResult.maOperand1 = lclGetExpression( ++pcString, pcEnd, ',' ); |
| if( rParseResult.maOperand1.getLength() > 0 ) |
| { |
| rParseResult.maOperand2 = lclGetExpression( pcString, pcEnd, ')' ); |
| if( rParseResult.maOperand2.getLength() > 0 ) |
| rParseResult.meToken = pCondInfo->meToken; |
| } |
| } |
| break; |
| } |
| rParseResult.mnEndIndex = static_cast< sal_Int32 >( pcString - pcBegin ); |
| } |
| } |
| |
| // ============================================================================ |
| |
