[Libreoffice-commits] core.git: sax/source solenv/clang-format
dante (via logerrit)
logerrit at kemper.freedesktop.org
Wed Dec 30 06:46:47 UTC 2020
sax/source/expatwrap/saxwriter.cxx | 663 +++++++++++++++++--------------------
solenv/clang-format/excludelist | 1
2 files changed, 313 insertions(+), 351 deletions(-)
New commits:
commit cda385ac10ac0deb46c2c04e6d1b4d9f05555c26
Author: dante <dante19031999 at gmail.com>
AuthorDate: Mon Dec 28 21:19:43 2020 +0100
Commit: Noel Grandin <noel.grandin at collabora.co.uk>
CommitDate: Wed Dec 30 07:46:05 2020 +0100
Clang-format saxwriter
Change-Id: I4793d81e2ba3405b9ed07a2c5547572ed7e0bee6
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108425
Tested-by: Noel Grandin <noel.grandin at collabora.co.uk>
Reviewed-by: Noel Grandin <noel.grandin at collabora.co.uk>
diff --git a/sax/source/expatwrap/saxwriter.cxx b/sax/source/expatwrap/saxwriter.cxx
index 03ca1f765d82..f6a58b0bb4cb 100644
--- a/sax/source/expatwrap/saxwriter.cxx
+++ b/sax/source/expatwrap/saxwriter.cxx
@@ -64,8 +64,8 @@ using namespace ::com::sun::star::io;
*
*****/
-namespace {
-
+namespace
+{
enum SaxInvalidCharacterError
{
SAX_NONE,
@@ -92,13 +92,13 @@ public:
#endif
private:
- Reference< XOutputStream > m_out;
- Sequence < sal_Int8 > m_Sequence;
- sal_Int8* mp_Sequence;
+ Reference<XOutputStream> m_out;
+ Sequence<sal_Int8> m_Sequence;
+ sal_Int8* mp_Sequence;
- sal_Int32 nLastLineFeedPos; // is negative after writing a sequence
- sal_uInt32 nCurrentPos;
- bool m_bStartElementFinished;
+ sal_Int32 nLastLineFeedPos; // is negative after writing a sequence
+ sal_uInt32 nCurrentPos;
+ bool m_bStartElementFinished;
std::vector<ReplacementPair> m_Replacements;
@@ -109,19 +109,16 @@ private:
// so the sequence has to write out and reset rPos to 0
// writes sequence only on overflow, sequence could be full on the end (rPos == SEQUENCESIZE)
/// @throws SAXException
- void AddBytes(sal_Int8* pTarget, sal_uInt32& rPos,
- const sal_Int8* pBytes, sal_uInt32 nBytesCount);
+ void AddBytes(sal_Int8* pTarget, sal_uInt32& rPos, const sal_Int8* pBytes,
+ sal_uInt32 nBytesCount);
/// @throws SAXException
- bool convertToXML(const sal_Unicode * pStr,
- sal_Int32 nStrLen,
- bool bDoNormalization,
- bool bNormalizeWhitespace,
- sal_Int8 *pTarget,
- sal_uInt32& rPos);
+ bool convertToXML(const sal_Unicode* pStr, sal_Int32 nStrLen, bool bDoNormalization,
+ bool bNormalizeWhitespace, sal_Int8* pTarget, sal_uInt32& rPos);
/// @throws SAXException
void FinishStartElement();
+
public:
- explicit SaxWriterHelper(Reference< XOutputStream > const & m_TempOut)
+ explicit SaxWriterHelper(Reference<XOutputStream> const& m_TempOut)
: m_out(m_TempOut)
, m_Sequence(SEQUENCESIZE)
, mp_Sequence(nullptr)
@@ -141,39 +138,41 @@ public:
/// @throws SAXException
void insertIndentation(sal_uInt32 m_nLevel);
-// returns whether it works correct or invalid characters were in the string
-// If there are invalid characters in the string it returns sal_False.
-// Than the calling method has to throw the needed Exception.
+ // returns whether it works correct or invalid characters were in the string
+ // If there are invalid characters in the string it returns sal_False.
+ // Than the calling method has to throw the needed Exception.
/// @throws SAXException
- bool writeString(const OUString& rWriteOutString,
- bool bDoNormalization,
- bool bNormalizeWhitespace);
+ bool writeString(const OUString& rWriteOutString, bool bDoNormalization,
+ bool bNormalizeWhitespace);
sal_uInt32 GetLastColumnCount() const throw()
- { return static_cast<sal_uInt32>(nCurrentPos - nLastLineFeedPos); }
+ {
+ return static_cast<sal_uInt32>(nCurrentPos - nLastLineFeedPos);
+ }
/// @throws SAXException
void startDocument();
-// returns whether it works correct or invalid characters were in the strings
-// If there are invalid characters in one of the strings it returns sal_False.
-// Than the calling method has to throw the needed Exception.
+ // returns whether it works correct or invalid characters were in the strings
+ // If there are invalid characters in one of the strings it returns sal_False.
+ // Than the calling method has to throw the needed Exception.
/// @throws SAXException
- SaxInvalidCharacterError startElement(const OUString& rName, const Reference< XAttributeList >& xAttribs);
+ SaxInvalidCharacterError startElement(const OUString& rName,
+ const Reference<XAttributeList>& xAttribs);
/// @throws SAXException
bool FinishEmptyElement();
-// returns whether it works correct or invalid characters were in the string
-// If there are invalid characters in the string it returns sal_False.
-// Than the calling method has to throw the needed Exception.
+ // returns whether it works correct or invalid characters were in the string
+ // If there are invalid characters in the string it returns sal_False.
+ // Than the calling method has to throw the needed Exception.
/// @throws SAXException
bool endElement(const OUString& rName);
/// @throws SAXException
void endDocument();
-// returns whether it works correct or invalid characters were in the strings
-// If there are invalid characters in the string it returns sal_False.
-// Than the calling method has to throw the needed Exception.
+ // returns whether it works correct or invalid characters were in the strings
+ // If there are invalid characters in the string it returns sal_False.
+ // Than the calling method has to throw the needed Exception.
/// @throws SAXException
bool processingInstruction(const OUString& rTarget, const OUString& rData);
/// @throws SAXException
@@ -181,9 +180,9 @@ public:
/// @throws SAXException
void endCDATA();
-// returns whether it works correct or invalid characters were in the strings
-// If there are invalid characters in the string it returns sal_False.
-// Than the calling method has to throw the needed Exception.
+ // returns whether it works correct or invalid characters were in the strings
+ // If there are invalid characters in the string it returns sal_False.
+ // Than the calling method has to throw the needed Exception.
/// @throws SAXException
bool comment(const OUString& rComment);
@@ -192,26 +191,26 @@ public:
// Use custom entity names
void setCustomEntityNames(
- const ::css::uno::Sequence<::css::beans::Pair<::rtl::OUString, ::rtl::OUString>>& replacements);
+ const ::css::uno::Sequence<::css::beans::Pair<::rtl::OUString, ::rtl::OUString>>&
+ replacements);
};
-const bool g_bValidCharsBelow32[32] =
-{
-// 0 1 2 3 4 5 6 7
- false,false,false,false,false,false,false,false, //0
- false,true, true, false,false,true, false,false, //8
- false,false,false,false,false,false,false,false, //16
- false,false,false,false,false,false,false,false
+const bool g_bValidCharsBelow32[32] = {
+ // clang-format off
+// 0 1 2 3 4 5 6 7
+ false, false, false, false, false, false, false, false, //0
+ false, true, true, false, false, true, false, false, //8
+ false, false, false, false, false, false, false, false, //16
+ false, false, false, false, false, false, false, false
+ // clang-format on
};
bool IsInvalidChar(const sal_Unicode aChar)
{
bool bRet(false);
// check first for the most common characters
- if( aChar < 32 || aChar >= 0xd800 )
- bRet = ( (aChar < 32 && ! g_bValidCharsBelow32[aChar]) ||
- aChar == 0xffff ||
- aChar == 0xfffe );
+ if (aChar < 32 || aChar >= 0xd800)
+ bRet = ((aChar < 32 && !g_bValidCharsBelow32[aChar]) || aChar == 0xffff || aChar == 0xfffe);
return bRet;
}
@@ -223,26 +222,23 @@ sal_uInt32 SaxWriterHelper::writeSequence()
{
try
{
- m_out->writeBytes( m_Sequence );
+ m_out->writeBytes(m_Sequence);
}
- catch (const IOException &)
+ catch (const IOException&)
{
css::uno::Any anyEx = cppu::getCaughtException();
- throw SAXException(
- "IO exception during writing",
- Reference< XInterface > (),
- anyEx );
+ throw SAXException("IO exception during writing", Reference<XInterface>(), anyEx);
}
nLastLineFeedPos -= SEQUENCESIZE;
return 0;
}
-void SaxWriterHelper::AddBytes(sal_Int8* pTarget, sal_uInt32& rPos,
- const sal_Int8* pBytes, sal_uInt32 nBytesCount)
+void SaxWriterHelper::AddBytes(sal_Int8* pTarget, sal_uInt32& rPos, const sal_Int8* pBytes,
+ sal_uInt32 nBytesCount)
{
OSL_ENSURE((rPos + nBytesCount) > SEQUENCESIZE, "wrong use of AddBytesMethod");
sal_uInt32 nCount(SEQUENCESIZE - rPos);
- memcpy( &(pTarget[rPos]) , pBytes, nCount);
+ memcpy(&(pTarget[rPos]), pBytes, nCount);
OSL_ENSURE(rPos + nCount == SEQUENCESIZE, "the position should be the at the end");
@@ -250,7 +246,7 @@ void SaxWriterHelper::AddBytes(sal_Int8* pTarget, sal_uInt32& rPos,
sal_uInt32 nRestCount(nBytesCount - nCount);
if ((rPos + nRestCount) <= SEQUENCESIZE)
{
- memcpy( &(pTarget[rPos]), &pBytes[nCount], nRestCount);
+ memcpy(&(pTarget[rPos]), &pBytes[nCount], nRestCount);
rPos += nRestCount;
}
else
@@ -277,34 +273,31 @@ void SaxWriterHelper::setCustomEntityNames(
must call calcXMLByteLength on the same string, to ensure,
that there is enough memory for converting.
*/
-bool SaxWriterHelper::convertToXML( const sal_Unicode * pStr,
- sal_Int32 nStrLen,
- bool bDoNormalization,
- bool bNormalizeWhitespace,
- sal_Int8 *pTarget,
- sal_uInt32& rPos )
+bool SaxWriterHelper::convertToXML(const sal_Unicode* pStr, sal_Int32 nStrLen,
+ bool bDoNormalization, bool bNormalizeWhitespace,
+ sal_Int8* pTarget, sal_uInt32& rPos)
{
bool bRet(true);
sal_uInt32 nSurrogate = 0;
- for( sal_Int32 i = 0 ; i < nStrLen ; i ++ )
+ for (sal_Int32 i = 0; i < nStrLen; i++)
{
sal_uInt16 c = pStr[i];
if (IsInvalidChar(c))
bRet = false;
- else if( (c >= 0x0001) && (c <= 0x007F) )
+ else if ((c >= 0x0001) && (c <= 0x007F))
{
- if( bDoNormalization )
+ if (bDoNormalization)
{
- switch( c )
+ switch (c)
{
- case '&': // resemble to &
+ case '&': // resemble to &
{
if ((rPos + 5) > SEQUENCESIZE)
- AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const *>("&"), 5);
+ AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const*>("&"), 5);
else
{
- memcpy( &(pTarget[rPos]) , "&", 5 );
+ memcpy(&(pTarget[rPos]), "&", 5);
rPos += 5;
}
}
@@ -312,67 +305,68 @@ bool SaxWriterHelper::convertToXML( const sal_Unicode * pStr,
case '<':
{
if ((rPos + 4) > SEQUENCESIZE)
- AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const *>("<"), 4);
+ AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const*>("<"), 4);
else
{
- memcpy( &(pTarget[rPos]) , "<" , 4 );
- rPos += 4; // <
+ memcpy(&(pTarget[rPos]), "<", 4);
+ rPos += 4; // <
}
}
break;
case '>':
{
if ((rPos + 4) > SEQUENCESIZE)
- AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const *>(">"), 4);
+ AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const*>(">"), 4);
else
{
- memcpy( &(pTarget[rPos]) , ">" , 4 );
- rPos += 4; // >
+ memcpy(&(pTarget[rPos]), ">", 4);
+ rPos += 4; // >
}
}
break;
case '\'':
{
if ((rPos + 6) > SEQUENCESIZE)
- AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const *>("'"), 6);
+ AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const*>("'"), 6);
else
{
- memcpy( &(pTarget[rPos]) , "'" , 6 );
- rPos += 6; // '
+ memcpy(&(pTarget[rPos]), "'", 6);
+ rPos += 6; // '
}
}
break;
case '"':
{
if ((rPos + 6) > SEQUENCESIZE)
- AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const *>("""), 6);
+ AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const*>("""), 6);
else
{
- memcpy( &(pTarget[rPos]) , """ , 6 );
- rPos += 6; // "
+ memcpy(&(pTarget[rPos]), """, 6);
+ rPos += 6; // "
}
}
break;
case 13:
{
if ((rPos + 6) > SEQUENCESIZE)
- AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const *>("
"), 6);
+ AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const*>("
"), 6);
else
{
- memcpy( &(pTarget[rPos]) , "
" , 6 );
+ memcpy(&(pTarget[rPos]), "
", 6);
rPos += 6;
}
}
break;
case LINEFEED:
{
- if( bNormalizeWhitespace )
+ if (bNormalizeWhitespace)
{
if ((rPos + 6) > SEQUENCESIZE)
- AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const *>("
"), 6);
+ AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const*>("
"),
+ 6);
else
{
- memcpy( &(pTarget[rPos]) , "
" , 6 );
+ memcpy(&(pTarget[rPos]), "
", 6);
rPos += 6;
}
}
@@ -380,33 +374,34 @@ bool SaxWriterHelper::convertToXML( const sal_Unicode * pStr,
{
pTarget[rPos] = LINEFEED;
nLastLineFeedPos = rPos;
- rPos ++;
+ rPos++;
}
}
break;
case 9:
{
- if( bNormalizeWhitespace )
+ if (bNormalizeWhitespace)
{
if ((rPos + 6) > SEQUENCESIZE)
- AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const *>("	"), 6);
+ AddBytes(pTarget, rPos, reinterpret_cast<sal_Int8 const*>("	"),
+ 6);
else
{
- memcpy( &(pTarget[rPos]) , "	" , 6 );
+ memcpy(&(pTarget[rPos]), "	", 6);
rPos += 6;
}
}
else
{
pTarget[rPos] = 9;
- rPos ++;
+ rPos++;
}
}
break;
default:
{
pTarget[rPos] = static_cast<sal_Int8>(c);
- rPos ++;
+ rPos++;
}
break;
}
@@ -416,79 +411,79 @@ bool SaxWriterHelper::convertToXML( const sal_Unicode * pStr,
pTarget[rPos] = static_cast<sal_Int8>(c);
if (static_cast<sal_Int8>(c) == LINEFEED)
nLastLineFeedPos = rPos;
- rPos ++;
+ rPos++;
}
}
- else if( c >= 0xd800 && c < 0xdc00 )
+ else if (c >= 0xd800 && c < 0xdc00)
{
// 1. surrogate: save (until 2. surrogate)
- OSL_ENSURE( nSurrogate == 0, "left-over Unicode surrogate" );
- nSurrogate = ( ( c & 0x03ff ) + 0x0040 );
+ OSL_ENSURE(nSurrogate == 0, "left-over Unicode surrogate");
+ nSurrogate = ((c & 0x03ff) + 0x0040);
}
- else if( c >= 0xdc00 && c < 0xe000 )
+ else if (c >= 0xdc00 && c < 0xe000)
{
// 2. surrogate: write as UTF-8
- OSL_ENSURE( nSurrogate != 0, "lone 2nd Unicode surrogate" );
+ OSL_ENSURE(nSurrogate != 0, "lone 2nd Unicode surrogate");
- nSurrogate = ( nSurrogate << 10 ) | ( c & 0x03ff );
- if( rtl::isUnicodeScalarValue(nSurrogate) && nSurrogate >= 0x00010000 )
+ nSurrogate = (nSurrogate << 10) | (c & 0x03ff);
+ if (rtl::isUnicodeScalarValue(nSurrogate) && nSurrogate >= 0x00010000)
{
sal_Int8 aBytes[] = { sal_Int8(0xF0 | ((nSurrogate >> 18) & 0x0F)),
sal_Int8(0x80 | ((nSurrogate >> 12) & 0x3F)),
- sal_Int8(0x80 | ((nSurrogate >> 6) & 0x3F)),
- sal_Int8(0x80 | ((nSurrogate >> 0) & 0x3F)) };
+ sal_Int8(0x80 | ((nSurrogate >> 6) & 0x3F)),
+ sal_Int8(0x80 | ((nSurrogate >> 0) & 0x3F)) };
if ((rPos + 4) > SEQUENCESIZE)
AddBytes(pTarget, rPos, aBytes, 4);
else
{
pTarget[rPos] = aBytes[0];
- rPos ++;
+ rPos++;
pTarget[rPos] = aBytes[1];
- rPos ++;
+ rPos++;
pTarget[rPos] = aBytes[2];
- rPos ++;
+ rPos++;
pTarget[rPos] = aBytes[3];
- rPos ++;
+ rPos++;
}
}
else
{
- OSL_FAIL( "illegal Unicode character" );
+ OSL_FAIL("illegal Unicode character");
bRet = false;
}
// reset surrogate
nSurrogate = 0;
}
- else if( c > 0x07FF )
+ else if (c > 0x07FF)
{
- sal_Int8 aBytes[] = { sal_Int8(0xE0 | ((c >> 12) & 0x0F)),
- sal_Int8(0x80 | ((c >> 6) & 0x3F)),
- sal_Int8(0x80 | ((c >> 0) & 0x3F)) };
+ sal_Int8 aBytes[]
+ = { sal_Int8(0xE0 | ((c >> 12) & 0x0F)), sal_Int8(0x80 | ((c >> 6) & 0x3F)),
+ sal_Int8(0x80 | ((c >> 0) & 0x3F)) };
if ((rPos + 3) > SEQUENCESIZE)
AddBytes(pTarget, rPos, aBytes, 3);
else
{
pTarget[rPos] = aBytes[0];
- rPos ++;
+ rPos++;
pTarget[rPos] = aBytes[1];
- rPos ++;
+ rPos++;
pTarget[rPos] = aBytes[2];
- rPos ++;
+ rPos++;
}
}
else
{
- sal_Int8 aBytes[] = { sal_Int8(0xC0 | ((c >> 6) & 0x1F)),
- sal_Int8(0x80 | ((c >> 0) & 0x3F)) };
+ sal_Int8 aBytes[]
+ = { sal_Int8(0xC0 | ((c >> 6) & 0x1F)), sal_Int8(0x80 | ((c >> 0) & 0x3F)) };
if ((rPos + 2) > SEQUENCESIZE)
AddBytes(pTarget, rPos, aBytes, 2);
else
{
pTarget[rPos] = aBytes[0];
- rPos ++;
+ rPos++;
pTarget[rPos] = aBytes[1];
- rPos ++;
+ rPos++;
}
}
OSL_ENSURE(rPos <= SEQUENCESIZE, "not reset current position");
@@ -496,9 +491,9 @@ bool SaxWriterHelper::convertToXML( const sal_Unicode * pStr,
rPos = writeSequence();
// reset left-over surrogate
- if( ( nSurrogate != 0 ) && ( c < 0xd800 || c >= 0xdc00 ) )
+ if ((nSurrogate != 0) && (c < 0xd800 || c >= 0xdc00))
{
- OSL_ENSURE( nSurrogate != 0, "left-over Unicode surrogate" );
+ OSL_ENSURE(nSurrogate != 0, "left-over Unicode surrogate");
nSurrogate = 0;
bRet = false;
}
@@ -528,7 +523,7 @@ void SaxWriterHelper::insertIndentation(sal_uInt32 m_nLevel)
mp_Sequence[nCurrentPos] = LINEFEED;
nLastLineFeedPos = nCurrentPos;
nCurrentPos++;
- memset( &(mp_Sequence[nCurrentPos]) , 32 , m_nLevel );
+ memset(&(mp_Sequence[nCurrentPos]), 32, m_nLevel);
nCurrentPos += m_nLevel;
if (nCurrentPos == SEQUENCESIZE)
nCurrentPos = writeSequence();
@@ -538,7 +533,7 @@ void SaxWriterHelper::insertIndentation(sal_uInt32 m_nLevel)
sal_uInt32 nCount(m_nLevel + 1);
std::unique_ptr<sal_Int8[]> pBytes(new sal_Int8[nCount]);
pBytes[0] = LINEFEED;
- memset( &(pBytes[1]), 32, m_nLevel );
+ memset(&(pBytes[1]), 32, m_nLevel);
AddBytes(mp_Sequence, nCurrentPos, pBytes.get(), nCount);
pBytes.reset();
nLastLineFeedPos = nCurrentPos - nCount;
@@ -556,31 +551,26 @@ void SaxWriterHelper::insertIndentation(sal_uInt32 m_nLevel)
}
}
-bool SaxWriterHelper::writeString( const OUString& rWriteOutString,
- bool bDoNormalization,
- bool bNormalizeWhitespace )
+bool SaxWriterHelper::writeString(const OUString& rWriteOutString, bool bDoNormalization,
+ bool bNormalizeWhitespace)
{
FinishStartElement();
- return convertToXML(rWriteOutString.getStr(),
- rWriteOutString.getLength(),
- bDoNormalization,
- bNormalizeWhitespace,
- mp_Sequence,
- nCurrentPos);
+ return convertToXML(rWriteOutString.getStr(), rWriteOutString.getLength(), bDoNormalization,
+ bNormalizeWhitespace, mp_Sequence, nCurrentPos);
}
void SaxWriterHelper::startDocument()
{
const char pc[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
- const int nLen = strlen( pc );
+ const int nLen = strlen(pc);
if ((nCurrentPos + nLen) <= SEQUENCESIZE)
{
- memcpy( mp_Sequence, pc , nLen );
+ memcpy(mp_Sequence, pc, nLen);
nCurrentPos += nLen;
}
else
{
- AddBytes(mp_Sequence, nCurrentPos, reinterpret_cast<sal_Int8 const *>(pc), nLen);
+ AddBytes(mp_Sequence, nCurrentPos, reinterpret_cast<sal_Int8 const*>(pc), nLen);
}
OSL_ENSURE(nCurrentPos <= SEQUENCESIZE, "not reset current position");
if (nCurrentPos == SEQUENCESIZE)
@@ -592,16 +582,13 @@ void SaxWriterHelper::startDocument()
}
#ifndef NDEBUG
-bool inrange(sal_Unicode c, sal_Unicode start, sal_Unicode end)
-{
- return c >= start && c <= end;
-}
+bool inrange(sal_Unicode c, sal_Unicode start, sal_Unicode end) { return c >= start && c <= end; }
#endif
void CheckValidName(OUString const& rName)
{
#ifdef NDEBUG
- (void) rName;
+ (void)rName;
#else
assert(!rName.isEmpty());
bool hasColon(false);
@@ -615,14 +602,14 @@ void CheckValidName(OUString const& rName)
assert(!hasColon && "only one colon allowed");
hasColon = true;
}
- else if (!rtl::isAsciiAlphanumeric(c) && c != '_' && c != '-' && c != '.' &&
- !inrange(c, 0x00C0, 0x00D6) && !inrange(c, 0x00D8, 0x00F6) &&
- !inrange(c, 0x00F8, 0x02FF) && !inrange(c, 0x0370, 0x037D) &&
- !inrange(c, 0x037F, 0x1FFF) && !inrange(c, 0x200C, 0x200D) &&
- !inrange(c, 0x2070, 0x218F) && !inrange(c, 0x2C00, 0x2FEF) &&
- !inrange(c, 0x3001, 0xD7FF) && !inrange(c, 0xF900, 0xFDCF) &&
- !inrange(c, 0xFDF0, 0xFFFD) && c != 0x00B7 &&
- !inrange(c, 0x0300, 0x036F) && !inrange(c, 0x203F, 0x2040))
+ else if (!rtl::isAsciiAlphanumeric(c) && c != '_' && c != '-' && c != '.'
+ && !inrange(c, 0x00C0, 0x00D6) && !inrange(c, 0x00D8, 0x00F6)
+ && !inrange(c, 0x00F8, 0x02FF) && !inrange(c, 0x0370, 0x037D)
+ && !inrange(c, 0x037F, 0x1FFF) && !inrange(c, 0x200C, 0x200D)
+ && !inrange(c, 0x2070, 0x218F) && !inrange(c, 0x2C00, 0x2FEF)
+ && !inrange(c, 0x3001, 0xD7FF) && !inrange(c, 0xF900, 0xFDCF)
+ && !inrange(c, 0xFDF0, 0xFFFD) && c != 0x00B7 && !inrange(c, 0x0300, 0x036F)
+ && !inrange(c, 0x203F, 0x2040))
{
// https://www.w3.org/TR/xml11/#NT-NameChar
// (currently we don't warn about invalid start chars)
@@ -633,7 +620,8 @@ void CheckValidName(OUString const& rName)
#endif
}
-SaxInvalidCharacterError SaxWriterHelper::startElement(const OUString& rName, const Reference< XAttributeList >& xAttribs)
+SaxInvalidCharacterError SaxWriterHelper::startElement(const OUString& rName,
+ const Reference<XAttributeList>& xAttribs)
{
FinishStartElement();
@@ -653,7 +641,7 @@ SaxInvalidCharacterError SaxWriterHelper::startElement(const OUString& rName, co
eRet = SAX_ERROR;
sal_Int16 nAttribCount = xAttribs.is() ? xAttribs->getLength() : 0;
- for(sal_Int16 i = 0 ; i < nAttribCount ; i++ )
+ for (sal_Int16 i = 0; i < nAttribCount; i++)
{
mp_Sequence[nCurrentPos] = ' ';
nCurrentPos++;
@@ -679,8 +667,7 @@ SaxInvalidCharacterError SaxWriterHelper::startElement(const OUString& rName, co
if (nCurrentPos == SEQUENCESIZE)
nCurrentPos = writeSequence();
- if (!writeString(xAttribs->getValueByIndex( i ), true, true) &&
- eRet != SAX_ERROR)
+ if (!writeString(xAttribs->getValueByIndex(i), true, true) && eRet != SAX_ERROR)
eRet = SAX_WARNING;
mp_Sequence[nCurrentPos] = '"';
@@ -689,9 +676,9 @@ SaxInvalidCharacterError SaxWriterHelper::startElement(const OUString& rName, co
nCurrentPos = writeSequence();
}
- m_bStartElementFinished = false; // because the '>' character is not added,
- // because it is possible, that the "/>"
- // characters have to add
+ m_bStartElementFinished = false; // because the '>' character is not added,
+ // because it is possible, that the "/>"
+ // characters have to add
return eRet;
}
@@ -728,7 +715,7 @@ bool SaxWriterHelper::endElement(const OUString& rName)
nCurrentPos = writeSequence();
CheckValidName(rName);
- bool bRet(writeString( rName, false, false));
+ bool bRet(writeString(rName, false, false));
mp_Sequence[nCurrentPos] = '>';
nCurrentPos++;
@@ -773,14 +760,14 @@ bool SaxWriterHelper::processingInstruction(const OUString& rTarget, const OUStr
if (nCurrentPos == SEQUENCESIZE)
nCurrentPos = writeSequence();
- bool bRet(writeString( rTarget, false, false ));
+ bool bRet(writeString(rTarget, false, false));
mp_Sequence[nCurrentPos] = ' ';
nCurrentPos++;
if (nCurrentPos == SEQUENCESIZE)
nCurrentPos = writeSequence();
- if (!writeString( rData, false, false ))
+ if (!writeString(rData, false, false))
bRet = false;
mp_Sequence[nCurrentPos] = '?';
@@ -800,11 +787,11 @@ void SaxWriterHelper::startCDATA()
FinishStartElement();
if ((nCurrentPos + 9) <= SEQUENCESIZE)
{
- memcpy( &(mp_Sequence[nCurrentPos]), "<![CDATA[" , 9 );
+ memcpy(&(mp_Sequence[nCurrentPos]), "<![CDATA[", 9);
nCurrentPos += 9;
}
else
- AddBytes(mp_Sequence, nCurrentPos, reinterpret_cast<sal_Int8 const *>("<![CDATA["), 9);
+ AddBytes(mp_Sequence, nCurrentPos, reinterpret_cast<sal_Int8 const*>("<![CDATA["), 9);
if (nCurrentPos == SEQUENCESIZE)
nCurrentPos = writeSequence();
}
@@ -814,11 +801,11 @@ void SaxWriterHelper::endCDATA()
FinishStartElement();
if ((nCurrentPos + 3) <= SEQUENCESIZE)
{
- memcpy( &(mp_Sequence[nCurrentPos]), "]]>" , 3 );
+ memcpy(&(mp_Sequence[nCurrentPos]), "]]>", 3);
nCurrentPos += 3;
}
else
- AddBytes(mp_Sequence, nCurrentPos, reinterpret_cast<sal_Int8 const *>("]]>"), 3);
+ AddBytes(mp_Sequence, nCurrentPos, reinterpret_cast<sal_Int8 const*>("]]>"), 3);
if (nCurrentPos == SEQUENCESIZE)
nCurrentPos = writeSequence();
}
@@ -843,7 +830,7 @@ bool SaxWriterHelper::comment(const OUString& rComment)
if (nCurrentPos == SEQUENCESIZE)
nCurrentPos = writeSequence();
- bool bRet(writeString( rComment, false, false));
+ bool bRet(writeString(rComment, false, false));
mp_Sequence[nCurrentPos] = '-';
nCurrentPos++;
@@ -861,71 +848,69 @@ bool SaxWriterHelper::comment(const OUString& rComment)
return bRet;
}
-sal_Int32 calcXMLByteLength( const OUString& rStr,
- bool bDoNormalization,
- bool bNormalizeWhitespace )
+sal_Int32 calcXMLByteLength(const OUString& rStr, bool bDoNormalization, bool bNormalizeWhitespace)
{
sal_Int32 nOutputLength = 0;
sal_uInt32 nSurrogate = 0;
- const sal_Unicode *pStr = rStr.getStr();
+ const sal_Unicode* pStr = rStr.getStr();
sal_Int32 nStrLen = rStr.getLength();
- for( sal_Int32 i = 0 ; i < nStrLen ; i++ )
+ for (sal_Int32 i = 0; i < nStrLen; i++)
{
sal_uInt16 c = pStr[i];
- if( !IsInvalidChar(c) && (c >= 0x0001) && (c <= 0x007F) )
+ if (!IsInvalidChar(c) && (c >= 0x0001) && (c <= 0x007F))
{
- if( bDoNormalization )
+ if (bDoNormalization)
{
- switch( c )
+ switch (c)
{
- case '&': // resemble to &
- nOutputLength +=5;
- break;
- case '<': // <
- case '>': // >
- nOutputLength +=4;
- break;
- case '\'': // '
- case '"': // "
- case 13: // 
- nOutputLength += 6;
- break;
-
- case 10: // 

- case 9: // 	
- if( bNormalizeWhitespace )
- {
+ case '&': // resemble to &
+ nOutputLength += 5;
+ break;
+ case '<': // <
+ case '>': // >
+ nOutputLength += 4;
+ break;
+ case '\'': // '
+ case '"': // "
+ case 13: // 
nOutputLength += 6;
- }
- else
- {
- nOutputLength ++;
- }
- break;
- default:
- nOutputLength ++;
+ break;
+
+ case 10: // 

+ case 9: // 	
+ if (bNormalizeWhitespace)
+ {
+ nOutputLength += 6;
+ }
+ else
+ {
+ nOutputLength++;
+ }
+ break;
+ default:
+ nOutputLength++;
}
}
else
{
- nOutputLength ++;
+ nOutputLength++;
}
}
- else if( c >= 0xd800 && c < 0xdc00 )
+ else if (c >= 0xd800 && c < 0xdc00)
{
// save surrogate
- nSurrogate = ( ( c & 0x03ff ) + 0x0040 );
+ nSurrogate = ((c & 0x03ff) + 0x0040);
}
- else if( c >= 0xdc00 && c < 0xe000 )
+ else if (c >= 0xdc00 && c < 0xe000)
{
// 2. surrogate: write as UTF-8 (if range is OK
- nSurrogate = ( nSurrogate << 10 ) | ( c & 0x03ff );
- if( rtl::isUnicodeScalarValue(nSurrogate) && nSurrogate >= 0x00010000 )
+ nSurrogate = (nSurrogate << 10) | (c & 0x03ff);
+ if (rtl::isUnicodeScalarValue(nSurrogate) && nSurrogate >= 0x00010000)
nOutputLength += 4;
nSurrogate = 0;
}
- else if( c > 0x07FF )
+ else if (c > 0x07FF)
{
nOutputLength += 3;
}
@@ -935,7 +920,7 @@ sal_Int32 calcXMLByteLength( const OUString& rStr,
}
// surrogate processing
- if( ( nSurrogate != 0 ) && ( c < 0xd800 || c >= 0xdc00 ) )
+ if ((nSurrogate != 0) && (c < 0xd800 || c >= 0xdc00))
nSurrogate = 0;
}
@@ -944,24 +929,22 @@ sal_Int32 calcXMLByteLength( const OUString& rStr,
/** returns position of first ascii 10 within the string, -1 when no 10 in string.
*/
-sal_Int32 getFirstLineBreak( const OUString & str ) throw ()
+sal_Int32 getFirstLineBreak(const OUString& str) throw()
{
- const sal_Unicode *pSource = str.getStr();
- sal_Int32 nLen = str.getLength();
+ const sal_Unicode* pSource = str.getStr();
+ sal_Int32 nLen = str.getLength();
- for( int n = 0; n < nLen ; n ++ )
+ for (int n = 0; n < nLen; n++)
{
- if( LINEFEED == pSource[n] ) {
+ if (LINEFEED == pSource[n])
+ {
return n;
}
}
return -1;
}
-class SAXWriter :
- public WeakImplHelper<
- XWriter,
- XServiceInfo >
+class SAXWriter : public WeakImplHelper<XWriter, XServiceInfo>
{
public:
SAXWriter()
@@ -974,17 +957,17 @@ public:
}
public: // XActiveDataSource
- virtual void SAL_CALL setOutputStream(const Reference< XOutputStream > & aStream) override
+ virtual void SAL_CALL setOutputStream(const Reference<XOutputStream>& aStream) override
{
try
{
// temporary: set same stream again to clear buffer
- if ( m_out == aStream && m_pSaxWriterHelper && m_bDocStarted )
+ if (m_out == aStream && m_pSaxWriterHelper && m_bDocStarted)
m_pSaxWriterHelper->clearBuffer();
else
{
m_out = aStream;
- m_pSaxWriterHelper.reset( new SaxWriterHelper(m_out) );
+ m_pSaxWriterHelper.reset(new SaxWriterHelper(m_out));
m_bDocStarted = false;
m_nLevel = 0;
m_bIsCDATA = false;
@@ -993,15 +976,10 @@ public: // XActiveDataSource
catch (const SAXException& e)
{
throw css::lang::WrappedTargetRuntimeException(
- e.Message,
- static_cast < OWeakObject * > ( this ),
- e.WrappedException);
+ e.Message, static_cast<OWeakObject*>(this), e.WrappedException);
}
}
- virtual Reference< XOutputStream > SAL_CALL getOutputStream() override
- {
- return m_out;
- }
+ virtual Reference<XOutputStream> SAL_CALL getOutputStream() override { return m_out; }
public: // XDocumentHandler
virtual void SAL_CALL startDocument() override;
@@ -1009,7 +987,7 @@ public: // XDocumentHandler
virtual void SAL_CALL endDocument() override;
virtual void SAL_CALL startElement(const OUString& aName,
- const Reference< XAttributeList > & xAttribs) override;
+ const Reference<XAttributeList>& xAttribs) override;
virtual void SAL_CALL endElement(const OUString& aName) override;
@@ -1018,10 +996,10 @@ public: // XDocumentHandler
virtual void SAL_CALL ignorableWhitespace(const OUString& aWhitespaces) override;
virtual void SAL_CALL processingInstruction(const OUString& aTarget,
const OUString& aData) override;
- virtual void SAL_CALL setDocumentLocator(const Reference< XLocator > & xLocator) override;
+ virtual void SAL_CALL setDocumentLocator(const Reference<XLocator>& xLocator) override;
virtual void SAL_CALL setCustomEntityNames(
- const ::css::uno::Sequence<::css::beans::Pair<::rtl::OUString, ::rtl::OUString>>& replacements)
- override;
+ const ::css::uno::Sequence<::css::beans::Pair<::rtl::OUString, ::rtl::OUString>>&
+ replacements) override;
public: // XExtendedDocumentHandler
virtual void SAL_CALL startCDATA() override;
@@ -1031,15 +1009,15 @@ public: // XExtendedDocumentHandler
virtual void SAL_CALL allowLineBreak() override;
public: // XServiceInfo
- OUString SAL_CALL getImplementationName() override;
- Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
- sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
+ OUString SAL_CALL getImplementationName() override;
+ Sequence<OUString> SAL_CALL getSupportedServiceNames() override;
+ sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
private:
- sal_Int32 getIndentPrefixLength( sal_Int32 nFirstLineBreakOccurrence ) throw();
+ sal_Int32 getIndentPrefixLength(sal_Int32 nFirstLineBreakOccurrence) throw();
- Reference< XOutputStream > m_out;
- std::unique_ptr<SaxWriterHelper> m_pSaxWriterHelper;
+ Reference<XOutputStream> m_out;
+ std::unique_ptr<SaxWriterHelper> m_pSaxWriterHelper;
// Status information
bool m_bDocStarted : 1;
@@ -1049,14 +1027,15 @@ private:
sal_Int32 m_nLevel;
};
-sal_Int32 SAXWriter::getIndentPrefixLength( sal_Int32 nFirstLineBreakOccurrence ) throw()
+sal_Int32 SAXWriter::getIndentPrefixLength(sal_Int32 nFirstLineBreakOccurrence) throw()
{
- sal_Int32 nLength =-1;
+ sal_Int32 nLength = -1;
if (m_pSaxWriterHelper)
{
- if ( m_bForceLineBreak ||
- (m_bAllowLineBreak &&
- ((nFirstLineBreakOccurrence + m_pSaxWriterHelper->GetLastColumnCount()) > MAXCOLUMNCOUNT)) )
+ if (m_bForceLineBreak
+ || (m_bAllowLineBreak
+ && ((nFirstLineBreakOccurrence + m_pSaxWriterHelper->GetLastColumnCount())
+ > MAXCOLUMNCOUNT)))
nLength = m_nLevel;
}
m_bForceLineBreak = false;
@@ -1064,16 +1043,10 @@ sal_Int32 SAXWriter::getIndentPrefixLength( sal_Int32 nFirstLineBreakOccurrence
return nLength;
}
-bool isFirstCharWhitespace( const sal_Unicode *p ) throw()
-{
- return *p == ' ';
-}
+bool isFirstCharWhitespace(const sal_Unicode* p) throw() { return *p == ' '; }
// XServiceInfo
-OUString SAXWriter::getImplementationName()
-{
- return "com.sun.star.extensions.xml.sax.Writer";
-}
+OUString SAXWriter::getImplementationName() { return "com.sun.star.extensions.xml.sax.Writer"; }
// XServiceInfo
sal_Bool SAXWriter::supportsService(const OUString& ServiceName)
@@ -1082,62 +1055,57 @@ sal_Bool SAXWriter::supportsService(const OUString& ServiceName)
}
// XServiceInfo
-Sequence< OUString > SAXWriter::getSupportedServiceNames()
+Sequence<OUString> SAXWriter::getSupportedServiceNames()
{
return { "com.sun.star.xml.sax.Writer" };
}
void SAXWriter::startDocument()
{
- if( m_bDocStarted || ! m_out.is() || !m_pSaxWriterHelper ) {
+ if (m_bDocStarted || !m_out.is() || !m_pSaxWriterHelper)
+ {
throw SAXException();
}
m_bDocStarted = true;
m_pSaxWriterHelper->startDocument();
}
-
void SAXWriter::endDocument()
{
- if( ! m_bDocStarted )
+ if (!m_bDocStarted)
{
- throw SAXException(
- "endDocument called before startDocument",
- Reference< XInterface >() , Any() );
+ throw SAXException("endDocument called before startDocument", Reference<XInterface>(),
+ Any());
}
- if( m_nLevel ) {
- throw SAXException(
- "unexpected end of document",
- Reference< XInterface >() , Any() );
+ if (m_nLevel)
+ {
+ throw SAXException("unexpected end of document", Reference<XInterface>(), Any());
}
m_pSaxWriterHelper->endDocument();
try
{
m_out->closeOutput();
}
- catch (const IOException &)
+ catch (const IOException&)
{
css::uno::Any anyEx = cppu::getCaughtException();
- throw SAXException(
- "IO exception during closing the IO Stream",
- Reference< XInterface > (),
- anyEx );
+ throw SAXException("IO exception during closing the IO Stream", Reference<XInterface>(),
+ anyEx);
}
}
-
-void SAXWriter::startElement(const OUString& aName, const Reference< XAttributeList >& xAttribs)
+void SAXWriter::startElement(const OUString& aName, const Reference<XAttributeList>& xAttribs)
{
- if( ! m_bDocStarted )
+ if (!m_bDocStarted)
{
SAXException except;
except.Message = "startElement called before startDocument";
throw except;
}
- if( m_bIsCDATA )
+ if (m_bIsCDATA)
{
SAXException except;
- except.Message = "startElement call not allowed with CDATA sections";
+ except.Message = "startElement call not allowed with CDATA sections";
throw except;
}
@@ -1146,34 +1114,35 @@ void SAXWriter::startElement(const OUString& aName, const Reference< XAttributeL
{
sal_Int32 nAttribCount = xAttribs.is() ? xAttribs->getLength() : 0;
- nLength ++; // "<"
- nLength += calcXMLByteLength( aName, false, false ); // the tag name
+ nLength++; // "<"
+ nLength += calcXMLByteLength(aName, false, false); // the tag name
sal_Int16 n;
- for( n = 0 ; n < static_cast<sal_Int16>(nAttribCount) ; n ++ ) {
- nLength ++; // " "
- OUString tmp = xAttribs->getNameByIndex( n );
+ for (n = 0; n < static_cast<sal_Int16>(nAttribCount); n++)
+ {
+ nLength++; // " "
+ OUString tmp = xAttribs->getNameByIndex(n);
- nLength += calcXMLByteLength( tmp, false, false );
+ nLength += calcXMLByteLength(tmp, false, false);
nLength += 2; // ="
- tmp = xAttribs->getValueByIndex( n );
+ tmp = xAttribs->getValueByIndex(n);
- nLength += calcXMLByteLength( tmp, true, true );
+ nLength += calcXMLByteLength(tmp, true, true);
nLength += 1; // "
}
- nLength ++; // '>'
+ nLength++; // '>'
}
// Is there a new indentation necessary ?
- sal_Int32 nPrefix(getIndentPrefixLength( nLength ));
+ sal_Int32 nPrefix(getIndentPrefixLength(nLength));
// write into sequence
- if( nPrefix >= 0 )
- m_pSaxWriterHelper->insertIndentation( nPrefix );
+ if (nPrefix >= 0)
+ m_pSaxWriterHelper->insertIndentation(nPrefix);
SaxInvalidCharacterError eRet(m_pSaxWriterHelper->startElement(aName, xAttribs));
@@ -1195,12 +1164,14 @@ void SAXWriter::startElement(const OUString& aName, const Reference< XAttributeL
void SAXWriter::endElement(const OUString& aName)
{
- if( ! m_bDocStarted ) {
- throw SAXException ();
+ if (!m_bDocStarted)
+ {
+ throw SAXException();
}
- m_nLevel --;
+ m_nLevel--;
- if( m_nLevel < 0 ) {
+ if (m_nLevel < 0)
+ {
throw SAXException();
}
bool bRet(true);
@@ -1213,18 +1184,18 @@ void SAXWriter::endElement(const OUString& aName)
m_pSaxWriterHelper->m_DebugStartedElements.pop();
#endif
- if( m_pSaxWriterHelper->FinishEmptyElement() )
+ if (m_pSaxWriterHelper->FinishEmptyElement())
m_bForceLineBreak = false;
else
{
// only ascii chars allowed
sal_Int32 nLength(0);
if (m_bAllowLineBreak)
- nLength = 3 + calcXMLByteLength( aName, false, false );
- sal_Int32 nPrefix = getIndentPrefixLength( nLength );
+ nLength = 3 + calcXMLByteLength(aName, false, false);
+ sal_Int32 nPrefix = getIndentPrefixLength(nLength);
- if( nPrefix >= 0 )
- m_pSaxWriterHelper->insertIndentation( nPrefix );
+ if (nPrefix >= 0)
+ m_pSaxWriterHelper->insertIndentation(nPrefix);
bRet = m_pSaxWriterHelper->endElement(aName);
}
@@ -1239,7 +1210,7 @@ void SAXWriter::endElement(const OUString& aName)
void SAXWriter::characters(const OUString& aChars)
{
- if( ! m_bDocStarted )
+ if (!m_bDocStarted)
{
SAXException except;
except.Message = "characters method called before startDocument";
@@ -1247,10 +1218,10 @@ void SAXWriter::characters(const OUString& aChars)
}
bool bThrowException(false);
- if( !aChars.isEmpty() )
+ if (!aChars.isEmpty())
{
- if( m_bIsCDATA )
- bThrowException = !m_pSaxWriterHelper->writeString( aChars, false, false );
+ if (m_bIsCDATA)
+ bThrowException = !m_pSaxWriterHelper->writeString(aChars, false, false);
else
{
// Note : nFirstLineBreakOccurrence is not exact, because we don't know, how
@@ -1260,24 +1231,24 @@ void SAXWriter::characters(const OUString& aChars)
sal_Int32 nIndentPrefix(-1);
if (m_bAllowLineBreak)
{
- sal_Int32 nFirstLineBreakOccurrence = getFirstLineBreak( aChars );
+ sal_Int32 nFirstLineBreakOccurrence = getFirstLineBreak(aChars);
- nLength = calcXMLByteLength( aChars, ! m_bIsCDATA , false );
+ nLength = calcXMLByteLength(aChars, !m_bIsCDATA, false);
nIndentPrefix = getIndentPrefixLength(
- nFirstLineBreakOccurrence >= 0 ? nFirstLineBreakOccurrence : nLength );
+ nFirstLineBreakOccurrence >= 0 ? nFirstLineBreakOccurrence : nLength);
}
else
nIndentPrefix = getIndentPrefixLength(nLength);
// insert indentation
- if( nIndentPrefix >= 0 )
+ if (nIndentPrefix >= 0)
{
- if( isFirstCharWhitespace( aChars.getStr() ) )
- m_pSaxWriterHelper->insertIndentation( nIndentPrefix - 1 );
+ if (isFirstCharWhitespace(aChars.getStr()))
+ m_pSaxWriterHelper->insertIndentation(nIndentPrefix - 1);
else
- m_pSaxWriterHelper->insertIndentation( nIndentPrefix );
+ m_pSaxWriterHelper->insertIndentation(nIndentPrefix);
}
- bThrowException = !m_pSaxWriterHelper->writeString(aChars, true , false);
+ bThrowException = !m_pSaxWriterHelper->writeString(aChars, true, false);
}
}
if (bThrowException)
@@ -1288,12 +1259,11 @@ void SAXWriter::characters(const OUString& aChars)
}
}
-
void SAXWriter::ignorableWhitespace(const OUString&)
{
- if( ! m_bDocStarted )
+ if (!m_bDocStarted)
{
- throw SAXException ();
+ throw SAXException();
}
m_bForceLineBreak = true;
@@ -1301,7 +1271,7 @@ void SAXWriter::ignorableWhitespace(const OUString&)
void SAXWriter::processingInstruction(const OUString& aTarget, const OUString& aData)
{
- if( ! m_bDocStarted || m_bIsCDATA )
+ if (!m_bDocStarted || m_bIsCDATA)
{
throw SAXException();
}
@@ -1309,20 +1279,20 @@ void SAXWriter::processingInstruction(const OUString& aTarget, const OUString& a
sal_Int32 nLength(0);
if (m_bAllowLineBreak)
{
- nLength = 2; // "<?"
- nLength += calcXMLByteLength( aTarget, false, false );
+ nLength = 2; // "<?"
+ nLength += calcXMLByteLength(aTarget, false, false);
- nLength += 1; // " "
+ nLength += 1; // " "
- nLength += calcXMLByteLength( aData, false, false );
+ nLength += calcXMLByteLength(aData, false, false);
nLength += 2; // "?>"
}
- sal_Int32 nPrefix = getIndentPrefixLength( nLength );
+ sal_Int32 nPrefix = getIndentPrefixLength(nLength);
- if( nPrefix >= 0 )
- m_pSaxWriterHelper->insertIndentation( nPrefix );
+ if (nPrefix >= 0)
+ m_pSaxWriterHelper->insertIndentation(nPrefix);
if (!m_pSaxWriterHelper->processingInstruction(aTarget, aData))
{
@@ -1332,11 +1302,7 @@ void SAXWriter::processingInstruction(const OUString& aTarget, const OUString& a
}
}
-
-void SAXWriter::setDocumentLocator(const Reference< XLocator >&)
-{
-
-}
+void SAXWriter::setDocumentLocator(const Reference<XLocator>&) {}
void SAXWriter::setCustomEntityNames(
const ::css::uno::Sequence<::css::beans::Pair<::rtl::OUString, ::rtl::OUString>>& replacements)
@@ -1346,14 +1312,14 @@ void SAXWriter::setCustomEntityNames(
void SAXWriter::startCDATA()
{
- if( ! m_bDocStarted || m_bIsCDATA)
+ if (!m_bDocStarted || m_bIsCDATA)
{
- throw SAXException ();
+ throw SAXException();
}
- sal_Int32 nPrefix = getIndentPrefixLength( 9 );
- if( nPrefix >= 0 )
- m_pSaxWriterHelper->insertIndentation( nPrefix );
+ sal_Int32 nPrefix = getIndentPrefixLength(9);
+ if (nPrefix >= 0)
+ m_pSaxWriterHelper->insertIndentation(nPrefix);
m_pSaxWriterHelper->startCDATA();
@@ -1362,26 +1328,25 @@ void SAXWriter::startCDATA()
void SAXWriter::endCDATA()
{
- if( ! m_bDocStarted || ! m_bIsCDATA)
+ if (!m_bDocStarted || !m_bIsCDATA)
{
SAXException except;
except.Message = "endCDATA was called without startCDATA";
throw except;
}
- sal_Int32 nPrefix = getIndentPrefixLength( 3 );
- if( nPrefix >= 0 )
- m_pSaxWriterHelper->insertIndentation( nPrefix );
+ sal_Int32 nPrefix = getIndentPrefixLength(3);
+ if (nPrefix >= 0)
+ m_pSaxWriterHelper->insertIndentation(nPrefix);
m_pSaxWriterHelper->endCDATA();
m_bIsCDATA = false;
}
-
void SAXWriter::comment(const OUString& sComment)
{
- if( ! m_bDocStarted || m_bIsCDATA )
+ if (!m_bDocStarted || m_bIsCDATA)
{
throw SAXException();
}
@@ -1390,14 +1355,14 @@ void SAXWriter::comment(const OUString& sComment)
if (m_bAllowLineBreak)
{
nLength = 4; // "<!--"
- nLength += calcXMLByteLength( sComment, false, false);
+ nLength += calcXMLByteLength(sComment, false, false);
nLength += 3;
}
- sal_Int32 nPrefix = getIndentPrefixLength( nLength );
- if( nPrefix >= 0 )
- m_pSaxWriterHelper->insertIndentation( nPrefix );
+ sal_Int32 nPrefix = getIndentPrefixLength(nLength);
+ if (nPrefix >= 0)
+ m_pSaxWriterHelper->insertIndentation(nPrefix);
if (!m_pSaxWriterHelper->comment(sComment))
{
@@ -1407,10 +1372,10 @@ void SAXWriter::comment(const OUString& sComment)
}
}
-
-void SAXWriter::allowLineBreak( )
+void SAXWriter::allowLineBreak()
{
- if( ! m_bDocStarted || m_bAllowLineBreak ) {
+ if (!m_bDocStarted || m_bAllowLineBreak)
+ {
throw SAXException();
}
@@ -1419,28 +1384,27 @@ void SAXWriter::allowLineBreak( )
void SAXWriter::unknown(const OUString& sString)
{
-
- if( ! m_bDocStarted )
+ if (!m_bDocStarted)
{
- throw SAXException ();
+ throw SAXException();
}
- if( m_bIsCDATA )
+ if (m_bIsCDATA)
{
throw SAXException();
}
- if( sString.startsWith( "<?xml" ) )
+ if (sString.startsWith("<?xml"))
return;
sal_Int32 nLength(0);
if (m_bAllowLineBreak)
- nLength = calcXMLByteLength( sString, false, false );
+ nLength = calcXMLByteLength(sString, false, false);
- sal_Int32 nPrefix = getIndentPrefixLength( nLength );
- if( nPrefix >= 0 )
- m_pSaxWriterHelper->insertIndentation( nPrefix );
+ sal_Int32 nPrefix = getIndentPrefixLength(nLength);
+ if (nPrefix >= 0)
+ m_pSaxWriterHelper->insertIndentation(nPrefix);
- if (!m_pSaxWriterHelper->writeString( sString, false, false))
+ if (!m_pSaxWriterHelper->writeString(sString, false, false))
{
SAXException except;
except.Message = "Invalid character during XML-Export";
@@ -1450,10 +1414,9 @@ void SAXWriter::unknown(const OUString& sString)
} // namespace
-extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
-com_sun_star_extensions_xml_sax_Writer_get_implementation(
- css::uno::XComponentContext *,
- css::uno::Sequence<css::uno::Any> const &)
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+com_sun_star_extensions_xml_sax_Writer_get_implementation(css::uno::XComponentContext*,
+ css::uno::Sequence<css::uno::Any> const&)
{
return cppu::acquire(new SAXWriter);
}
diff --git a/solenv/clang-format/excludelist b/solenv/clang-format/excludelist
index 6d9404c26b93..32fc5a9e7f3e 100644
--- a/solenv/clang-format/excludelist
+++ b/solenv/clang-format/excludelist
@@ -7902,7 +7902,6 @@ sax/qa/cppunit/parser.cxx
sax/qa/cppunit/test_converter.cxx
sax/qa/cppunit/xmlimport.cxx
sax/source/expatwrap/sax_expat.cxx
-sax/source/expatwrap/saxwriter.cxx
sax/source/expatwrap/xml2utf.cxx
sax/source/fastparser/fastparser.cxx
sax/source/fastparser/legacyfastparser.cxx
More information about the Libreoffice-commits
mailing list