use sensible indentation

that always annoyed me

Change-Id: I0c439ddb00d78590b465cd47db6e60d1939bd9f7

4 files changed, 603 insertions, 599 deletions

diff --git a/i18npool/source/breakiterator/breakiteratorImpl.cxx b/i18npool/source/breakiterator/breakiteratorImpl.cxx
index 595c921d46b5..4235027feeca 100644
--- a/i18npool/source/breakiterator/breakiteratorImpl.cxx
+++ b/i18npool/source/breakiterator/breakiteratorImpl.cxx
@@ -39,10 +39,10 @@ BreakIteratorImpl::BreakIteratorImpl()
 
 BreakIteratorImpl::~BreakIteratorImpl()
 {
-        // Clear lookuptable
-        for (size_t l = 0; l < lookupTable.size(); l++)
-            delete lookupTable[l];
-        lookupTable.clear();
+    // Clear lookuptable
+    for (size_t l = 0; l < lookupTable.size(); l++)
+        delete lookupTable[l];
+    lookupTable.clear();
 }
 
 #define LBI getLocaleSpecificBreakIterator(rLocale)
@@ -51,75 +51,75 @@ sal_Int32 SAL_CALL BreakIteratorImpl::nextCharacters( const OUString& Text, sal_
         const Locale &rLocale, sal_Int16 nCharacterIteratorMode, sal_Int32 nCount, sal_Int32& nDone )
         throw(RuntimeException)
 {
-        if (nCount < 0) throw RuntimeException();
+    if (nCount < 0) throw RuntimeException();
 
-        return LBI->nextCharacters( Text, nStartPos, rLocale, nCharacterIteratorMode, nCount, nDone);
+    return LBI->nextCharacters( Text, nStartPos, rLocale, nCharacterIteratorMode, nCount, nDone);
 }
 
 sal_Int32 SAL_CALL BreakIteratorImpl::previousCharacters( const OUString& Text, sal_Int32 nStartPos,
         const Locale& rLocale, sal_Int16 nCharacterIteratorMode, sal_Int32 nCount, sal_Int32& nDone )
         throw(RuntimeException)
 {
-        if (nCount < 0) throw RuntimeException();
+    if (nCount < 0) throw RuntimeException();
 
-        return LBI->previousCharacters( Text, nStartPos, rLocale, nCharacterIteratorMode, nCount, nDone);
+    return LBI->previousCharacters( Text, nStartPos, rLocale, nCharacterIteratorMode, nCount, nDone);
 }
 
 #define isZWSP(c) (ch == 0x200B)
 
 static sal_Int32 skipSpace(const OUString& Text, sal_Int32 nPos, sal_Int32 len, sal_Int16 rWordType, sal_Bool bDirection)
 {
-        sal_uInt32 ch=0;
-        sal_Int32 pos=nPos;
-        switch (rWordType) {
-            case WordType::ANYWORD_IGNOREWHITESPACES:
-                if (bDirection)
-                    while (nPos < len && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, 1)) || isZWSP(ch))) nPos=pos;
-                else
-                    while (nPos > 0 && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, -1)) || isZWSP(ch))) nPos=pos;
+    sal_uInt32 ch=0;
+    sal_Int32 pos=nPos;
+    switch (rWordType) {
+        case WordType::ANYWORD_IGNOREWHITESPACES:
+            if (bDirection)
+                while (nPos < len && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, 1)) || isZWSP(ch))) nPos=pos;
+            else
+                while (nPos > 0 && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, -1)) || isZWSP(ch))) nPos=pos;
             break;
-            case WordType::DICTIONARY_WORD:
-                if (bDirection)
-                    while (nPos < len && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, 1)) || isZWSP(ch) ||
+        case WordType::DICTIONARY_WORD:
+            if (bDirection)
+                while (nPos < len && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, 1)) || isZWSP(ch) ||
                             ! (ch == 0x002E || u_isalnum(ch)))) nPos=pos;
-                else
-                    while (nPos > 0 && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, -1)) || isZWSP(ch) ||
+            else
+                while (nPos > 0 && (u_isWhitespace(ch = Text.iterateCodePoints(&pos, -1)) || isZWSP(ch) ||
                             ! (ch == 0x002E || u_isalnum(ch)))) nPos=pos;
             break;
-            case WordType::WORD_COUNT:
-                if (bDirection)
-                    while (nPos < len && (u_isUWhiteSpace(ch = Text.iterateCodePoints(&pos, 1)) || isZWSP(ch))) nPos=pos;
-                else
-                    while (nPos > 0 && (u_isUWhiteSpace(ch = Text.iterateCodePoints(&pos, -1)) || isZWSP(ch))) nPos=pos;
+        case WordType::WORD_COUNT:
+            if (bDirection)
+                while (nPos < len && (u_isUWhiteSpace(ch = Text.iterateCodePoints(&pos, 1)) || isZWSP(ch))) nPos=pos;
+            else
+                while (nPos > 0 && (u_isUWhiteSpace(ch = Text.iterateCodePoints(&pos, -1)) || isZWSP(ch))) nPos=pos;
             break;
-        }
-        return nPos;
+    }
+    return nPos;
 }
 
 Boundary SAL_CALL BreakIteratorImpl::nextWord( const OUString& Text, sal_Int32 nStartPos,
         const Locale& rLocale, sal_Int16 rWordType ) throw(RuntimeException)
 {
-        sal_Int32 len = Text.getLength();
-        if( nStartPos < 0 || len == 0 )
-            result.endPos = result.startPos = 0;
-        else if (nStartPos >= len)
-            result.endPos = result.startPos = len;
-        else {
-            result = LBI->nextWord(Text, nStartPos, rLocale, rWordType);
-
-            nStartPos = skipSpace(Text, result.startPos, len, rWordType, sal_True);
-
-            if ( nStartPos != result.startPos) {
-                if( nStartPos >= len )
-                    result.startPos = result.endPos = len;
-                else {
-                    result = LBI->getWordBoundary(Text, nStartPos, rLocale, rWordType, sal_True);
-                    // i88041: avoid startPos goes back to nStartPos when switching between Latin and CJK scripts
-                    if (result.startPos < nStartPos) result.startPos = nStartPos;
-                }
+    sal_Int32 len = Text.getLength();
+    if( nStartPos < 0 || len == 0 )
+        result.endPos = result.startPos = 0;
+    else if (nStartPos >= len)
+        result.endPos = result.startPos = len;
+    else {
+        result = LBI->nextWord(Text, nStartPos, rLocale, rWordType);
+
+        nStartPos = skipSpace(Text, result.startPos, len, rWordType, sal_True);
+
+        if ( nStartPos != result.startPos) {
+            if( nStartPos >= len )
+                result.startPos = result.endPos = len;
+            else {
+                result = LBI->getWordBoundary(Text, nStartPos, rLocale, rWordType, sal_True);
+                // i88041: avoid startPos goes back to nStartPos when switching between Latin and CJK scripts
+                if (result.startPos < nStartPos) result.startPos = nStartPos;
             }
         }
-        return result;
+    }
+    return result;
 }
 
 static inline sal_Bool SAL_CALL isCJK( const Locale& rLocale ) {
@@ -129,124 +129,124 @@ static inline sal_Bool SAL_CALL isCJK( const Locale& rLocale ) {
 Boundary SAL_CALL BreakIteratorImpl::previousWord( const OUString& Text, sal_Int32 nStartPos,
         const Locale& rLocale, sal_Int16 rWordType) throw(RuntimeException)
 {
-        sal_Int32 len = Text.getLength();
-        if( nStartPos <= 0 || len == 0 ) {
-            result.endPos = result.startPos = 0;
-            return result;
-        } else if (nStartPos > len) {
-            result.endPos = result.startPos = len;
-            return result;
-        }
+    sal_Int32 len = Text.getLength();
+    if( nStartPos <= 0 || len == 0 ) {
+        result.endPos = result.startPos = 0;
+        return result;
+    } else if (nStartPos > len) {
+        result.endPos = result.startPos = len;
+        return result;
+    }
 
-        sal_Int32 nPos = skipSpace(Text, nStartPos, len, rWordType, sal_False);
+    sal_Int32 nPos = skipSpace(Text, nStartPos, len, rWordType, sal_False);
 
-        // if some spaces are skiped, and the script type is Asian with no CJK rLocale, we have to return
-        // (nStartPos, -1) for caller to send correct rLocale for loading correct dictionary.
-        result.startPos = nPos;
-        if (nPos != nStartPos && nPos > 0 && !isCJK(rLocale) && getScriptClass(Text.iterateCodePoints(&nPos, -1)) == ScriptType::ASIAN) {
-            result.endPos = -1;
-            return result;
-        }
+    // if some spaces are skiped, and the script type is Asian with no CJK rLocale, we have to return
+    // (nStartPos, -1) for caller to send correct rLocale for loading correct dictionary.
+    result.startPos = nPos;
+    if (nPos != nStartPos && nPos > 0 && !isCJK(rLocale) && getScriptClass(Text.iterateCodePoints(&nPos, -1)) == ScriptType::ASIAN) {
+        result.endPos = -1;
+        return result;
+    }
 
-        return LBI->previousWord(Text, result.startPos, rLocale, rWordType);
+    return LBI->previousWord(Text, result.startPos, rLocale, rWordType);
 }
 
 
 Boundary SAL_CALL BreakIteratorImpl::getWordBoundary( const OUString& Text, sal_Int32 nPos, const Locale& rLocale,
         sal_Int16 rWordType, sal_Bool bDirection ) throw(RuntimeException)
 {
-        sal_Int32 len = Text.getLength();
-        if( nPos < 0 || len == 0 )
+    sal_Int32 len = Text.getLength();
+    if( nPos < 0 || len == 0 )
+        result.endPos = result.startPos = 0;
+    else if (nPos > len)
+        result.endPos = result.startPos = len;
+    else {
+        sal_Int32 next, prev;
+        next = skipSpace(Text, nPos, len, rWordType, sal_True);
+        prev = skipSpace(Text, nPos, len, rWordType, sal_False);
+        if (prev == 0 && next == len) {
+            result.endPos = result.startPos = nPos;
+        } else if (prev == 0 && ! bDirection) {
             result.endPos = result.startPos = 0;
-        else if (nPos > len)
+        } else if (next == len && bDirection) {
             result.endPos = result.startPos = len;
-        else {
-            sal_Int32 next, prev;
-            next = skipSpace(Text, nPos, len, rWordType, sal_True);
-            prev = skipSpace(Text, nPos, len, rWordType, sal_False);
-            if (prev == 0 && next == len) {
-                result.endPos = result.startPos = nPos;
-            } else if (prev == 0 && ! bDirection) {
-                result.endPos = result.startPos = 0;
-            } else if (next == len && bDirection) {
-                result.endPos = result.startPos = len;
-            } else {
-                if (next != prev) {
-                    if (next == nPos && next != len)
-                        bDirection = sal_True;
-                    else if (prev == nPos && prev != 0)
-                        bDirection = sal_False;
-                    else
-                        nPos = bDirection ? next : prev;
-                }
-                result = LBI->getWordBoundary(Text, nPos, rLocale, rWordType, bDirection);
+        } else {
+            if (next != prev) {
+                if (next == nPos && next != len)
+                    bDirection = sal_True;
+                else if (prev == nPos && prev != 0)
+                    bDirection = sal_False;
+                else
+                    nPos = bDirection ? next : prev;
             }
+            result = LBI->getWordBoundary(Text, nPos, rLocale, rWordType, bDirection);
         }
-        return result;
+    }
+    return result;
 }
 
 sal_Bool SAL_CALL BreakIteratorImpl::isBeginWord( const OUString& Text, sal_Int32 nPos,
         const Locale& rLocale, sal_Int16 rWordType ) throw(RuntimeException)
 {
-        sal_Int32 len = Text.getLength();
+    sal_Int32 len = Text.getLength();
 
-        if (nPos < 0 || nPos >= len) return sal_False;
+    if (nPos < 0 || nPos >= len) return sal_False;
 
-        sal_Int32 tmp = skipSpace(Text, nPos, len, rWordType, sal_True);
+    sal_Int32 tmp = skipSpace(Text, nPos, len, rWordType, sal_True);
 
-        if (tmp != nPos) return sal_False;
+    if (tmp != nPos) return sal_False;
 
-        result = getWordBoundary(Text, nPos, rLocale, rWordType, sal_True);
+    result = getWordBoundary(Text, nPos, rLocale, rWordType, sal_True);
 
-        return result.startPos == nPos;
+    return result.startPos == nPos;
 }
 
 sal_Bool SAL_CALL BreakIteratorImpl::isEndWord( const OUString& Text, sal_Int32 nPos,
         const Locale& rLocale, sal_Int16 rWordType ) throw(RuntimeException)
 {
-        sal_Int32 len = Text.getLength();
+    sal_Int32 len = Text.getLength();
 
-        if (nPos <= 0 || nPos > len) return sal_False;
+    if (nPos <= 0 || nPos > len) return sal_False;
 
-        sal_Int32 tmp = skipSpace(Text, nPos, len, rWordType, sal_False);
+    sal_Int32 tmp = skipSpace(Text, nPos, len, rWordType, sal_False);
 
-        if (tmp != nPos) return sal_False;
+    if (tmp != nPos) return sal_False;
 
-        result = getWordBoundary(Text, nPos, rLocale, rWordType, sal_False);
+    result = getWordBoundary(Text, nPos, rLocale, rWordType, sal_False);
 
-        return result.endPos == nPos;
+    return result.endPos == nPos;
 }
 
 sal_Int32 SAL_CALL BreakIteratorImpl::beginOfSentence( const OUString& Text, sal_Int32 nStartPos,
         const Locale &rLocale ) throw(RuntimeException)
 {
-        if (nStartPos < 0 || nStartPos > Text.getLength())
-            return -1;
-        if (Text.isEmpty()) return 0;
-        return LBI->beginOfSentence(Text, nStartPos, rLocale);
+    if (nStartPos < 0 || nStartPos > Text.getLength())
+        return -1;
+    if (Text.isEmpty()) return 0;
+    return LBI->beginOfSentence(Text, nStartPos, rLocale);
 }
 
 sal_Int32 SAL_CALL BreakIteratorImpl::endOfSentence( const OUString& Text, sal_Int32 nStartPos,
         const Locale &rLocale ) throw(RuntimeException)
 {
-        if (nStartPos < 0 || nStartPos > Text.getLength())
-            return -1;
-        if (Text.isEmpty()) return 0;
-        return LBI->endOfSentence(Text, nStartPos, rLocale);
+    if (nStartPos < 0 || nStartPos > Text.getLength())
+        return -1;
+    if (Text.isEmpty()) return 0;
+    return LBI->endOfSentence(Text, nStartPos, rLocale);
 }
 
 LineBreakResults SAL_CALL BreakIteratorImpl::getLineBreak( const OUString& Text, sal_Int32 nStartPos,
         const Locale& rLocale, sal_Int32 nMinBreakPos, const LineBreakHyphenationOptions& hOptions,
         const LineBreakUserOptions& bOptions ) throw(RuntimeException)
 {
-        return LBI->getLineBreak(Text, nStartPos, rLocale, nMinBreakPos, hOptions, bOptions);
+    return LBI->getLineBreak(Text, nStartPos, rLocale, nMinBreakPos, hOptions, bOptions);
 }
 
 sal_Int16 SAL_CALL BreakIteratorImpl::getScriptType( const OUString& Text, sal_Int32 nPos )
         throw(RuntimeException)
 {
-        return (nPos < 0 || nPos >= Text.getLength()) ? ScriptType::WEAK :
-                            getScriptClass(Text.iterateCodePoints(&nPos, 0));
+    return (nPos < 0 || nPos >= Text.getLength()) ? ScriptType::WEAK :
+        getScriptClass(Text.iterateCodePoints(&nPos, 0));
 }
 
 
@@ -280,122 +280,122 @@ static sal_Int32 SAL_CALL iterateCodePoints(const OUString& Text, sal_Int32 &nSt
 sal_Int32 SAL_CALL BreakIteratorImpl::beginOfScript( const OUString& Text,
         sal_Int32 nStartPos, sal_Int16 ScriptType ) throw(RuntimeException)
 {
-        if (nStartPos < 0 || nStartPos >= Text.getLength())
-            return -1;
+    if (nStartPos < 0 || nStartPos >= Text.getLength())
+        return -1;
 
-        if(ScriptType != getScriptClass(Text.iterateCodePoints(&nStartPos, 0)))
-            return -1;
+    if(ScriptType != getScriptClass(Text.iterateCodePoints(&nStartPos, 0)))
+        return -1;
 
+    if (nStartPos == 0) return 0;
+    sal_uInt32 ch=0;
+    while (iterateCodePoints(Text, nStartPos, -1, ch) >= 0 && ScriptType == getScriptClass(ch)) {
         if (nStartPos == 0) return 0;
-        sal_uInt32 ch=0;
-        while (iterateCodePoints(Text, nStartPos, -1, ch) >= 0 && ScriptType == getScriptClass(ch)) {
-            if (nStartPos == 0) return 0;
-        }
+    }
 
-        return  iterateCodePoints(Text, nStartPos, 1, ch);
+    return  iterateCodePoints(Text, nStartPos, 1, ch);
 }
 
 sal_Int32 SAL_CALL BreakIteratorImpl::endOfScript( const OUString& Text,
         sal_Int32 nStartPos, sal_Int16 ScriptType ) throw(RuntimeException)
 {
-        if (nStartPos < 0 || nStartPos >= Text.getLength())
-            return -1;
+    if (nStartPos < 0 || nStartPos >= Text.getLength())
+        return -1;
 
-        if(ScriptType != getScriptClass(Text.iterateCodePoints(&nStartPos, 0)))
-            return -1;
+    if(ScriptType != getScriptClass(Text.iterateCodePoints(&nStartPos, 0)))
+        return -1;
 
-        sal_Int32 strLen = Text.getLength();
-        sal_uInt32 ch=0;
-        while(iterateCodePoints(Text, nStartPos, 1, ch) < strLen ) {
-            sal_Int16 currentCharScriptType = getScriptClass(ch);
-            if(ScriptType != currentCharScriptType && currentCharScriptType != ScriptType::WEAK)
-                break;
-        }
-        return  nStartPos;
+    sal_Int32 strLen = Text.getLength();
+    sal_uInt32 ch=0;
+    while(iterateCodePoints(Text, nStartPos, 1, ch) < strLen ) {
+        sal_Int16 currentCharScriptType = getScriptClass(ch);
+        if(ScriptType != currentCharScriptType && currentCharScriptType != ScriptType::WEAK)
+            break;
+    }
+    return  nStartPos;
 }
 
 sal_Int32  SAL_CALL BreakIteratorImpl::previousScript( const OUString& Text,
         sal_Int32 nStartPos, sal_Int16 ScriptType ) throw(RuntimeException)
 {
-        if (nStartPos < 0)
-            return -1;
-        if (nStartPos > Text.getLength())
-            nStartPos = Text.getLength();
+    if (nStartPos < 0)
+        return -1;
+    if (nStartPos > Text.getLength())
+        nStartPos = Text.getLength();
 
-        sal_Int16 numberOfChange = (ScriptType == getScriptClass(Text.iterateCodePoints(&nStartPos, 0))) ? 3 : 2;
+    sal_Int16 numberOfChange = (ScriptType == getScriptClass(Text.iterateCodePoints(&nStartPos, 0))) ? 3 : 2;
 
-        sal_uInt32 ch=0;
-        while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, -1, ch) >= 0) {
-            if ((((numberOfChange % 2) == 0) ^ (ScriptType != getScriptClass(ch))))
+    sal_uInt32 ch=0;
+    while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, -1, ch) >= 0) {
+        if ((((numberOfChange % 2) == 0) ^ (ScriptType != getScriptClass(ch))))
+            numberOfChange--;
+        else if (nStartPos == 0) {
+            if (numberOfChange > 0)
                 numberOfChange--;
-            else if (nStartPos == 0) {
-                if (numberOfChange > 0)
-                    numberOfChange--;
-                if (nStartPos > 0)
-                    Text.iterateCodePoints(&nStartPos, -1);
-                else
-                    return -1;
-            }
+            if (nStartPos > 0)
+                Text.iterateCodePoints(&nStartPos, -1);
+            else
+                return -1;
         }
-        return numberOfChange == 0 ? iterateCodePoints(Text, nStartPos, 1, ch) : -1;
+    }
+    return numberOfChange == 0 ? iterateCodePoints(Text, nStartPos, 1, ch) : -1;
 }
 
 sal_Int32 SAL_CALL BreakIteratorImpl::nextScript( const OUString& Text, sal_Int32 nStartPos,
         sal_Int16 ScriptType ) throw(RuntimeException)
 
 {
-        if (nStartPos < 0)
-            nStartPos = 0;
-        sal_Int32 strLen = Text.getLength();
-        if (nStartPos > strLen)
-            return -1;
+    if (nStartPos < 0)
+        nStartPos = 0;
+    sal_Int32 strLen = Text.getLength();
+    if (nStartPos > strLen)
+        return -1;
 
-        sal_Int16 numberOfChange = (ScriptType == getScriptClass(Text.iterateCodePoints(&nStartPos, 0))) ? 2 : 1;
+    sal_Int16 numberOfChange = (ScriptType == getScriptClass(Text.iterateCodePoints(&nStartPos, 0))) ? 2 : 1;
 
-        sal_uInt32 ch=0;
-        while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, 1, ch) < strLen) {
-            sal_Int16 currentCharScriptType = getScriptClass(ch);
-            if ((numberOfChange == 1) ? (ScriptType == currentCharScriptType) :
-                    (ScriptType != currentCharScriptType && currentCharScriptType != ScriptType::WEAK))
-                numberOfChange--;
-        }
-        return numberOfChange == 0 ? nStartPos : -1;
+    sal_uInt32 ch=0;
+    while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, 1, ch) < strLen) {
+        sal_Int16 currentCharScriptType = getScriptClass(ch);
+        if ((numberOfChange == 1) ? (ScriptType == currentCharScriptType) :
+                (ScriptType != currentCharScriptType && currentCharScriptType != ScriptType::WEAK))
+            numberOfChange--;
+    }
+    return numberOfChange == 0 ? nStartPos : -1;
 }
 
 sal_Int32 SAL_CALL BreakIteratorImpl::beginOfCharBlock( const OUString& Text, sal_Int32 nStartPos,
         const Locale& /*rLocale*/, sal_Int16 CharType ) throw(RuntimeException)
 {
-        if (CharType == CharType::ANY_CHAR) return 0;
-        if (nStartPos < 0 || nStartPos >= Text.getLength()) return -1;
-        if (CharType != (sal_Int16)u_charType( Text.iterateCodePoints(&nStartPos, 0))) return -1;
+    if (CharType == CharType::ANY_CHAR) return 0;
+    if (nStartPos < 0 || nStartPos >= Text.getLength()) return -1;
+    if (CharType != (sal_Int16)u_charType( Text.iterateCodePoints(&nStartPos, 0))) return -1;
 
-        sal_Int32 nPos=nStartPos;
-        while(nStartPos > 0 && CharType == (sal_Int16)u_charType(Text.iterateCodePoints(&nPos, -1))) { nStartPos=nPos; }
-        return nStartPos; // begin of char block is inclusive
+    sal_Int32 nPos=nStartPos;
+    while(nStartPos > 0 && CharType == (sal_Int16)u_charType(Text.iterateCodePoints(&nPos, -1))) { nStartPos=nPos; }
+    return nStartPos; // begin of char block is inclusive
 }
 
 sal_Int32 SAL_CALL BreakIteratorImpl::endOfCharBlock( const OUString& Text, sal_Int32 nStartPos,
         const Locale& /*rLocale*/, sal_Int16 CharType ) throw(RuntimeException)
 {
-        sal_Int32 strLen = Text.getLength();
+    sal_Int32 strLen = Text.getLength();
 
-        if (CharType == CharType::ANY_CHAR) return strLen; // end of char block is exclusive
-        if (nStartPos < 0 || nStartPos >= strLen) return -1;
-        if (CharType != (sal_Int16)u_charType(Text.iterateCodePoints(&nStartPos, 0))) return -1;
+    if (CharType == CharType::ANY_CHAR) return strLen; // end of char block is exclusive
+    if (nStartPos < 0 || nStartPos >= strLen) return -1;
+    if (CharType != (sal_Int16)u_charType(Text.iterateCodePoints(&nStartPos, 0))) return -1;
 
-        sal_uInt32 ch=0;
-        while(iterateCodePoints(Text, nStartPos, 1, ch) < strLen && CharType == (sal_Int16)u_charType(ch)) {}
-        return nStartPos; // end of char block is exclusive
+    sal_uInt32 ch=0;
+    while(iterateCodePoints(Text, nStartPos, 1, ch) < strLen && CharType == (sal_Int16)u_charType(ch)) {}
+    return nStartPos; // end of char block is exclusive
 }
 
 sal_Int32 SAL_CALL BreakIteratorImpl::nextCharBlock( const OUString& Text, sal_Int32 nStartPos,
         const Locale& /*rLocale*/, sal_Int16 CharType ) throw(RuntimeException)
 {
-        if (CharType == CharType::ANY_CHAR) return -1;
-        if (nStartPos < 0 || nStartPos >= Text.getLength()) return -1;
+    if (CharType == CharType::ANY_CHAR) return -1;
+    if (nStartPos < 0 || nStartPos >= Text.getLength()) return -1;
 
-        sal_Int16 numberOfChange = (CharType == (sal_Int16)u_charType(Text.iterateCodePoints(&nStartPos, 0))) ? 2 : 1;
-        sal_Int32 strLen = Text.getLength();
+    sal_Int16 numberOfChange = (CharType == (sal_Int16)u_charType(Text.iterateCodePoints(&nStartPos, 0))) ? 2 : 1;
+    sal_Int32 strLen = Text.getLength();
 
     sal_uInt32 ch=0;
     while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, 1, ch) < strLen) {
@@ -408,21 +408,21 @@ sal_Int32 SAL_CALL BreakIteratorImpl::nextCharBlock( const OUString& Text, sal_I
 sal_Int32 SAL_CALL BreakIteratorImpl::previousCharBlock( const OUString& Text, sal_Int32 nStartPos,
         const Locale& /*rLocale*/, sal_Int16 CharType ) throw(RuntimeException)
 {
-        if(CharType == CharType::ANY_CHAR) return -1;
-        if (nStartPos < 0 || nStartPos >= Text.getLength()) return -1;
+    if(CharType == CharType::ANY_CHAR) return -1;
+    if (nStartPos < 0 || nStartPos >= Text.getLength()) return -1;
 
-        sal_Int16 numberOfChange = (CharType == (sal_Int16)u_charType(Text.iterateCodePoints(&nStartPos, 0))) ? 3 : 2;
+    sal_Int16 numberOfChange = (CharType == (sal_Int16)u_charType(Text.iterateCodePoints(&nStartPos, 0))) ? 3 : 2;
 
-        sal_uInt32 ch=0;
-        while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, -1, ch) >= 0) {
-            if (((numberOfChange % 2) == 0) ^ (CharType != (sal_Int16)u_charType(ch)))
-                numberOfChange--;
-            if (nStartPos == 0 && numberOfChange > 0) {
-                numberOfChange--;
-                if (numberOfChange == 0) return nStartPos;
-            }
+    sal_uInt32 ch=0;
+    while (numberOfChange > 0 && iterateCodePoints(Text, nStartPos, -1, ch) >= 0) {
+        if (((numberOfChange % 2) == 0) ^ (CharType != (sal_Int16)u_charType(ch)))
+            numberOfChange--;
+        if (nStartPos == 0 && numberOfChange > 0) {
+            numberOfChange--;
+            if (numberOfChange == 0) return nStartPos;
         }
-        return numberOfChange == 0 ? iterateCodePoints(Text, nStartPos, 1, ch) : -1;
+    }
+    return numberOfChange == 0 ? iterateCodePoints(Text, nStartPos, 1, ch) : -1;
 }
 
 
@@ -430,88 +430,88 @@ sal_Int32 SAL_CALL BreakIteratorImpl::previousCharBlock( const OUString& Text, s
 sal_Int16 SAL_CALL BreakIteratorImpl::getWordType( const OUString& /*Text*/,
         sal_Int32 /*nPos*/, const Locale& /*rLocale*/ ) throw(RuntimeException)
 {
-        return 0;
+    return 0;
 }
 
 namespace
 {
-    sal_Int16 getScriptClassByUAX24Script(sal_uInt32 currentChar)
-    {
-        int32_t script = u_getIntPropertyValue(currentChar, UCHAR_SCRIPT);
-        return unicode::getScriptClassFromUScriptCode(static_cast<UScriptCode>(script));
-    }
+sal_Int16 getScriptClassByUAX24Script(sal_uInt32 currentChar)
+{
+    int32_t script = u_getIntPropertyValue(currentChar, UCHAR_SCRIPT);
+    return unicode::getScriptClassFromUScriptCode(static_cast<UScriptCode>(script));
+}
 
-    struct UBlock2Script
-    {
-        UBlockCode from;
-        UBlockCode to;
-        sal_Int16 script;
-    };
+struct UBlock2Script
+{
+    UBlockCode from;
+    UBlockCode to;
+    sal_Int16 script;
+};
 
-    static const UBlock2Script scriptList[] =
-    {
-        {UBLOCK_NO_BLOCK, UBLOCK_NO_BLOCK, ScriptType::WEAK},
-        {UBLOCK_BASIC_LATIN, UBLOCK_ARMENIAN, ScriptType::LATIN},
-        {UBLOCK_HEBREW, UBLOCK_MYANMAR, ScriptType::COMPLEX},
-        {UBLOCK_GEORGIAN, UBLOCK_GEORGIAN, ScriptType::LATIN},
-        {UBLOCK_HANGUL_JAMO, UBLOCK_HANGUL_JAMO, ScriptType::ASIAN},
-        {UBLOCK_ETHIOPIC, UBLOCK_ETHIOPIC, ScriptType::COMPLEX},
-        {UBLOCK_CHEROKEE, UBLOCK_RUNIC, ScriptType::LATIN},
-        {UBLOCK_KHMER, UBLOCK_MONGOLIAN, ScriptType::COMPLEX},
-        {UBLOCK_LATIN_EXTENDED_ADDITIONAL, UBLOCK_GREEK_EXTENDED, ScriptType::LATIN},
-        {UBLOCK_NUMBER_FORMS, UBLOCK_NUMBER_FORMS, ScriptType::WEAK},
-        {UBLOCK_CJK_RADICALS_SUPPLEMENT, UBLOCK_HANGUL_SYLLABLES, ScriptType::ASIAN},
-        {UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS, UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS, ScriptType::ASIAN},
-        {UBLOCK_ARABIC_PRESENTATION_FORMS_A, UBLOCK_ARABIC_PRESENTATION_FORMS_A, ScriptType::COMPLEX},
-        {UBLOCK_CJK_COMPATIBILITY_FORMS, UBLOCK_CJK_COMPATIBILITY_FORMS, ScriptType::ASIAN},
-        {UBLOCK_ARABIC_PRESENTATION_FORMS_B, UBLOCK_ARABIC_PRESENTATION_FORMS_B, ScriptType::COMPLEX},
-        {UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS, UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS, ScriptType::ASIAN},
-        {UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B, UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT, ScriptType::ASIAN},
-        {UBLOCK_CJK_STROKES, UBLOCK_CJK_STROKES, ScriptType::ASIAN},
-        {UBLOCK_LATIN_EXTENDED_C, UBLOCK_LATIN_EXTENDED_D, ScriptType::LATIN}
-    };
-
-    #define scriptListCount SAL_N_ELEMENTS(scriptList)
-
-    //always sets rScriptType
-    //
-    //returns true for characters historically explicitly assigned to
-    //latin/weak/asian
-    //
-    //returns false for characters that historically implicitly assigned to
-    //weak as unknown
-    bool getCompatibilityScriptClassByBlock(sal_uInt32 currentChar, sal_Int16 &rScriptType)
+static const UBlock2Script scriptList[] =
+{
+    {UBLOCK_NO_BLOCK, UBLOCK_NO_BLOCK, ScriptType::WEAK},
+    {UBLOCK_BASIC_LATIN, UBLOCK_ARMENIAN, ScriptType::LATIN},
+    {UBLOCK_HEBREW, UBLOCK_MYANMAR, ScriptType::COMPLEX},
+    {UBLOCK_GEORGIAN, UBLOCK_GEORGIAN, ScriptType::LATIN},
+    {UBLOCK_HANGUL_JAMO, UBLOCK_HANGUL_JAMO, ScriptType::ASIAN},
+    {UBLOCK_ETHIOPIC, UBLOCK_ETHIOPIC, ScriptType::COMPLEX},
+    {UBLOCK_CHEROKEE, UBLOCK_RUNIC, ScriptType::LATIN},
+    {UBLOCK_KHMER, UBLOCK_MONGOLIAN, ScriptType::COMPLEX},
+    {UBLOCK_LATIN_EXTENDED_ADDITIONAL, UBLOCK_GREEK_EXTENDED, ScriptType::LATIN},
+    {UBLOCK_NUMBER_FORMS, UBLOCK_NUMBER_FORMS, ScriptType::WEAK},
+    {UBLOCK_CJK_RADICALS_SUPPLEMENT, UBLOCK_HANGUL_SYLLABLES, ScriptType::ASIAN},
+    {UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS, UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS, ScriptType::ASIAN},
+    {UBLOCK_ARABIC_PRESENTATION_FORMS_A, UBLOCK_ARABIC_PRESENTATION_FORMS_A, ScriptType::COMPLEX},
+    {UBLOCK_CJK_COMPATIBILITY_FORMS, UBLOCK_CJK_COMPATIBILITY_FORMS, ScriptType::ASIAN},
+    {UBLOCK_ARABIC_PRESENTATION_FORMS_B, UBLOCK_ARABIC_PRESENTATION_FORMS_B, ScriptType::COMPLEX},
+    {UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS, UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS, ScriptType::ASIAN},
+    {UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B, UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT, ScriptType::ASIAN},
+    {UBLOCK_CJK_STROKES, UBLOCK_CJK_STROKES, ScriptType::ASIAN},
+    {UBLOCK_LATIN_EXTENDED_C, UBLOCK_LATIN_EXTENDED_D, ScriptType::LATIN}
+};
+
+#define scriptListCount SAL_N_ELEMENTS(scriptList)
+
+//always sets rScriptType
+//
+//returns true for characters historically explicitly assigned to
+//latin/weak/asian
+//
+//returns false for characters that historically implicitly assigned to
+//weak as unknown
+bool getCompatibilityScriptClassByBlock(sal_uInt32 currentChar, sal_Int16 &rScriptType)
+{
+    bool bKnown = true;
+    //handle specific characters always as weak:
+    //  0x01 - this breaks a word
+    //  0x02 - this can be inside a word
+    //  0x20 & 0xA0 - Bug 102975, declare western space and non-break space as WEAK char.
+    if( 0x01 == currentChar || 0x02 == currentChar || 0x20 == currentChar || 0xA0 == currentChar)
+        rScriptType = ScriptType::WEAK;
+    // workaround for Coptic
+    else if ( 0x2C80 <= currentChar && 0x2CE3 >= currentChar)
+        rScriptType = ScriptType::LATIN;
+    else
     {
-        bool bKnown = true;
-        //handle specific characters always as weak:
-        //  0x01 - this breaks a word
-        //  0x02 - this can be inside a word
-        //  0x20 & 0xA0 - Bug 102975, declare western space and non-break space as WEAK char.
-        if( 0x01 == currentChar || 0x02 == currentChar || 0x20 == currentChar || 0xA0 == currentChar)
-            rScriptType = ScriptType::WEAK;
-        // workaround for Coptic
-        else if ( 0x2C80 <= currentChar && 0x2CE3 >= currentChar)
-            rScriptType = ScriptType::LATIN;
+        UBlockCode block=ublock_getCode(currentChar);
+        size_t i = 0;
+        while (i < scriptListCount)
+        {
+            if (block <= scriptList[i].to)
+                break;
+            ++i;
+        }
+        if (i < scriptListCount && block >= scriptList[i].from)
+            rScriptType = scriptList[i].script;
         else
         {
-            UBlockCode block=ublock_getCode(currentChar);
-            size_t i = 0;
-            while (i < scriptListCount)
-            {
-                if (block <= scriptList[i].to)
-                    break;
-                ++i;
-            }
-            if (i < scriptListCount && block >= scriptList[i].from)
-                rScriptType = scriptList[i].script;
-            else
-            {
-                rScriptType = ScriptType::WEAK;
-                bKnown = false;
-            }
+            rScriptType = ScriptType::WEAK;
+            bKnown = false;
         }
-        return bKnown;
     }
+    return bKnown;
+}
 }
 
 sal_Int16  BreakIteratorImpl::getScriptClass(sal_uInt32 currentChar)
@@ -536,73 +536,73 @@ static inline sal_Bool operator == (const Locale& l1, const Locale& l2) {
 
 sal_Bool SAL_CALL BreakIteratorImpl::createLocaleSpecificBreakIterator(const OUString& aLocaleName) throw( RuntimeException )
 {
-        // to share service between same Language but different Country code, like zh_CN and zh_TW
-        for (size_t l = 0; l < lookupTable.size(); l++) {
-            lookupTableItem *listItem = lookupTable[l];
-            if (aLocaleName == listItem->aLocale.Language) {
-                xBI = listItem->xBI;
-                return sal_True;
-            }
+    // to share service between same Language but different Country code, like zh_CN and zh_TW
+    for (size_t l = 0; l < lookupTable.size(); l++) {
+        lookupTableItem *listItem = lookupTable[l];
+        if (aLocaleName == listItem->aLocale.Language) {
+            xBI = listItem->xBI;
+            return sal_True;
         }
+    }
 
-        Reference < uno::XInterface > xI = m_xContext->getServiceManager()->createInstanceWithContext(
+    Reference < uno::XInterface > xI = m_xContext->getServiceManager()->createInstanceWithContext(
             OUString("com.sun.star.i18n.BreakIterator_") + aLocaleName, m_xContext);
 
-        if ( xI.is() ) {
-            xBI.set(xI, UNO_QUERY);
-            if (xBI.is()) {
-                lookupTable.push_back(new lookupTableItem(Locale(aLocaleName, aLocaleName, aLocaleName), xBI));
-                return sal_True;
-            }
+    if ( xI.is() ) {
+        xBI.set(xI, UNO_QUERY);
+        if (xBI.is()) {
+            lookupTable.push_back(new lookupTableItem(Locale(aLocaleName, aLocaleName, aLocaleName), xBI));
+            return sal_True;
         }
-        return sal_False;
+    }
+    return sal_False;
 }
 
 Reference < XBreakIterator > SAL_CALL
 BreakIteratorImpl::getLocaleSpecificBreakIterator(const Locale& rLocale) throw (RuntimeException)
 {
-        if (xBI.is() && rLocale == aLocale)
-            return xBI;
-        else if (m_xContext.is()) {
-            aLocale = rLocale;
-
-            for (size_t i = 0; i < lookupTable.size(); i++) {
-                lookupTableItem *listItem = lookupTable[i];
-                if (rLocale == listItem->aLocale)
-                    return xBI = listItem->xBI;
-            }
+    if (xBI.is() && rLocale == aLocale)
+        return xBI;
+    else if (m_xContext.is()) {
+        aLocale = rLocale;
+
+        for (size_t i = 0; i < lookupTable.size(); i++) {
+            lookupTableItem *listItem = lookupTable[i];
+            if (rLocale == listItem->aLocale)
+                return xBI = listItem->xBI;
+        }
 
-            sal_Unicode under = (sal_Unicode)'_';
+        sal_Unicode under = (sal_Unicode)'_';
 
-            sal_Int32 l = rLocale.Language.getLength();
-            sal_Int32 c = rLocale.Country.getLength();
-            sal_Int32 v = rLocale.Variant.getLength();
-            OUStringBuffer aBuf(l+c+v+3);
+        sal_Int32 l = rLocale.Language.getLength();
+        sal_Int32 c = rLocale.Country.getLength();
+        sal_Int32 v = rLocale.Variant.getLength();
+        OUStringBuffer aBuf(l+c+v+3);
 
-            if ((l > 0 && c > 0 && v > 0 &&
+        if ((l > 0 && c > 0 && v > 0 &&
                     // load service with name <base>_<lang>_<country>_<varian>
                     createLocaleSpecificBreakIterator(aBuf.append(rLocale.Language).append(under).append(
-                                    rLocale.Country).append(under).append(rLocale.Variant).makeStringAndClear())) ||
+                            rLocale.Country).append(under).append(rLocale.Variant).makeStringAndClear())) ||
                 (l > 0 && c > 0 &&
-                    // load service with name <base>_<lang>_<country>
-                    createLocaleSpecificBreakIterator(aBuf.append(rLocale.Language).append(under).append(
-                                    rLocale.Country).makeStringAndClear())) ||
+                 // load service with name <base>_<lang>_<country>
+                 createLocaleSpecificBreakIterator(aBuf.append(rLocale.Language).append(under).append(
+                         rLocale.Country).makeStringAndClear())) ||
                 (l > 0 && c > 0 && rLocale.Language.compareToAscii("zh") == 0 &&
-                                    (rLocale.Country.compareToAscii("HK") == 0 ||
-                                    rLocale.Country.compareToAscii("MO") == 0) &&
-                    // if the country code is HK or MO, one more step to try TW.
-                    createLocaleSpecificBreakIterator(aBuf.append(rLocale.Language).append(under).appendAscii(
-                                    "TW").makeStringAndClear())) ||
+                 (rLocale.Country.compareToAscii("HK") == 0 ||
+                  rLocale.Country.compareToAscii("MO") == 0) &&
+                 // if the country code is HK or MO, one more step to try TW.
+                 createLocaleSpecificBreakIterator(aBuf.append(rLocale.Language).append(under).appendAscii(
+                         "TW").makeStringAndClear())) ||
                 (l > 0 &&
-                    // load service with name <base>_<lang>
-                    createLocaleSpecificBreakIterator(rLocale.Language)) ||
-                    // load default service with name <base>_Unicode
-                    createLocaleSpecificBreakIterator(OUString("Unicode"))) {
-                lookupTable.push_back( new lookupTableItem(aLocale, xBI) );
-                return xBI;
-            }
+                 // load service with name <base>_<lang>
+                 createLocaleSpecificBreakIterator(rLocale.Language)) ||
+                // load default service with name <base>_Unicode
+                createLocaleSpecificBreakIterator(OUString("Unicode"))) {
+            lookupTable.push_back( new lookupTableItem(aLocale, xBI) );
+            return xBI;
         }
-        throw RuntimeException();
+    }
+    throw RuntimeException();
 }
 
 const sal_Char cBreakIterator[] = "com.sun.star.i18n.BreakIterator";
@@ -610,21 +610,21 @@ const sal_Char cBreakIterator[] = "com.sun.star.i18n.BreakIterator";
 OUString SAL_CALL
 BreakIteratorImpl::getImplementationName(void) throw( RuntimeException )
 {
-        return OUString::createFromAscii(cBreakIterator);
+    return OUString::createFromAscii(cBreakIterator);
 }
 
 sal_Bool SAL_CALL
 BreakIteratorImpl::supportsService(const OUString& rServiceName) throw( RuntimeException )
 {
-        return !rServiceName.compareToAscii(cBreakIterator);
+    return !rServiceName.compareToAscii(cBreakIterator);
 }
 
 Sequence< OUString > SAL_CALL
 BreakIteratorImpl::getSupportedServiceNames(void) throw( RuntimeException )
 {
-        Sequence< OUString > aRet(1);
-        aRet[0] = OUString::createFromAscii(cBreakIterator);
-        return aRet;
+    Sequence< OUString > aRet(1);
+    aRet[0] = OUString::createFromAscii(cBreakIterator);
+    return aRet;
 }
 
 } } } }
diff --git a/i18npool/source/breakiterator/breakiterator_cjk.cxx b/i18npool/source/breakiterator/breakiterator_cjk.cxx
index 28f263157510..9ff6a40a7c5d 100644
--- a/i18npool/source/breakiterator/breakiterator_cjk.cxx
+++ b/i18npool/source/breakiterator/breakiterator_cjk.cxx
@@ -37,41 +37,41 @@ BreakIterator_CJK::BreakIterator_CJK() :
     dict( NULL ),
     hangingCharacters()
 {
-        cBreakIterator = "com.sun.star.i18n.BreakIterator_CJK";
+    cBreakIterator = "com.sun.star.i18n.BreakIterator_CJK";
 }
 
 Boundary SAL_CALL
 BreakIterator_CJK::previousWord(const OUString& text, sal_Int32 anyPos,
         const lang::Locale& nLocale, sal_Int16 wordType) throw(RuntimeException)
 {
-        if (dict) {
-            result = dict->previousWord(text, anyPos, wordType);
-            // #109813# for non-CJK, single character word, fallback to ICU breakiterator.
-            if (result.endPos - result.startPos != 1 ||
-                    getScriptType(text, result.startPos) == ScriptType::ASIAN)
-                return result;
-            result = BreakIterator_Unicode::getWordBoundary(text, result.startPos, nLocale, wordType, true);
-            if (result.endPos < anyPos)
-                return result;
-        }
-        return BreakIterator_Unicode::previousWord(text, anyPos, nLocale, wordType);
+    if (dict) {
+        result = dict->previousWord(text, anyPos, wordType);
+        // #109813# for non-CJK, single character word, fallback to ICU breakiterator.
+        if (result.endPos - result.startPos != 1 ||
+                getScriptType(text, result.startPos) == ScriptType::ASIAN)
+            return result;
+        result = BreakIterator_Unicode::getWordBoundary(text, result.startPos, nLocale, wordType, true);
+        if (result.endPos < anyPos)
+            return result;
+    }
+    return BreakIterator_Unicode::previousWord(text, anyPos, nLocale, wordType);
 }
 
 Boundary SAL_CALL
 BreakIterator_CJK::nextWord(const OUString& text, sal_Int32 anyPos,
         const lang::Locale& nLocale, sal_Int16 wordType) throw(RuntimeException)
 {
-        if (dict) {
-            result = dict->nextWord(text, anyPos, wordType);
-            // #109813# for non-CJK, single character word, fallback to ICU breakiterator.
-            if (result.endPos - result.startPos != 1 ||
-                    getScriptType(text, result.startPos) == ScriptType::ASIAN)
-                return result;
-            result = BreakIterator_Unicode::getWordBoundary(text, result.startPos, nLocale, wordType, true);
-            if (result.startPos > anyPos)
-                return result;
-        }
-        return BreakIterator_Unicode::nextWord(text, anyPos, nLocale, wordType);
+    if (dict) {
+        result = dict->nextWord(text, anyPos, wordType);
+        // #109813# for non-CJK, single character word, fallback to ICU breakiterator.
+        if (result.endPos - result.startPos != 1 ||
+                getScriptType(text, result.startPos) == ScriptType::ASIAN)
+            return result;
+        result = BreakIterator_Unicode::getWordBoundary(text, result.startPos, nLocale, wordType, true);
+        if (result.startPos > anyPos)
+            return result;
+    }
+    return BreakIterator_Unicode::nextWord(text, anyPos, nLocale, wordType);
 }
 
 Boundary SAL_CALL
@@ -79,14 +79,14 @@ BreakIterator_CJK::getWordBoundary( const OUString& text, sal_Int32 anyPos,
         const lang::Locale& nLocale, sal_Int16 wordType, sal_Bool bDirection )
         throw(RuntimeException)
 {
-        if (dict) {
-            result = dict->getWordBoundary(text, anyPos, wordType, bDirection);
-            // #109813# for non-CJK, single character word, fallback to ICU breakiterator.
-            if (result.endPos - result.startPos != 1 ||
-                    getScriptType(text, result.startPos) == ScriptType::ASIAN)
-                return result;
-        }
-        return BreakIterator_Unicode::getWordBoundary(text, anyPos, nLocale, wordType, bDirection);
+    if (dict) {
+        result = dict->getWordBoundary(text, anyPos, wordType, bDirection);
+        // #109813# for non-CJK, single character word, fallback to ICU breakiterator.
+        if (result.endPos - result.startPos != 1 ||
+                getScriptType(text, result.startPos) == ScriptType::ASIAN)
+            return result;
+    }
+    return BreakIterator_Unicode::getWordBoundary(text, anyPos, nLocale, wordType, bDirection);
 }
 
 LineBreakResults SAL_CALL BreakIterator_CJK::getLineBreak(
@@ -95,22 +95,22 @@ LineBreakResults SAL_CALL BreakIterator_CJK::getLineBreak(
         const LineBreakHyphenationOptions& /*hOptions*/,
         const LineBreakUserOptions& bOptions ) throw(RuntimeException)
 {
-        LineBreakResults lbr;
-
-        if (bOptions.allowPunctuationOutsideMargin &&
-                hangingCharacters.indexOf(Text[nStartPos]) != -1 &&
-                (Text.iterateCodePoints( &nStartPos, 1), nStartPos == Text.getLength())) {
-            ; // do nothing
-        } else if (bOptions.applyForbiddenRules && 0 < nStartPos && nStartPos < Text.getLength()) {
-            while (nStartPos > 0 &&
-                    (bOptions.forbiddenBeginCharacters.indexOf(Text[nStartPos]) != -1 ||
-                    bOptions.forbiddenEndCharacters.indexOf(Text[nStartPos-1]) != -1))
-                Text.iterateCodePoints( &nStartPos, -1);
-        }
-
-        lbr.breakIndex = nStartPos;
-        lbr.breakType = BreakType::WORDBOUNDARY;
-        return lbr;
+    LineBreakResults lbr;
+
+    if (bOptions.allowPunctuationOutsideMargin &&
+            hangingCharacters.indexOf(Text[nStartPos]) != -1 &&
+            (Text.iterateCodePoints( &nStartPos, 1), nStartPos == Text.getLength())) {
+        ; // do nothing
+    } else if (bOptions.applyForbiddenRules && 0 < nStartPos && nStartPos < Text.getLength()) {
+        while (nStartPos > 0 &&
+                (bOptions.forbiddenBeginCharacters.indexOf(Text[nStartPos]) != -1 ||
+                 bOptions.forbiddenEndCharacters.indexOf(Text[nStartPos-1]) != -1))
+            Text.iterateCodePoints( &nStartPos, -1);
+    }
+
+    lbr.breakIndex = nStartPos;
+    lbr.breakType = BreakType::WORDBOUNDARY;
+    return lbr;
 }
 
 #define LOCALE(language, country) lang::Locale(OUString::createFromAscii(language), OUString::createFromAscii(country), OUString())
@@ -119,14 +119,14 @@ LineBreakResults SAL_CALL BreakIterator_CJK::getLineBreak(
 //      ----------------------------------------------------;
 BreakIterator_zh::BreakIterator_zh()
 {
-        dict = new xdictionary("zh");
-        hangingCharacters = LocaleDataImpl().getHangingCharacters(LOCALE("zh", "CN"));
-        cBreakIterator = "com.sun.star.i18n.BreakIterator_zh";
+    dict = new xdictionary("zh");
+    hangingCharacters = LocaleDataImpl().getHangingCharacters(LOCALE("zh", "CN"));
+    cBreakIterator = "com.sun.star.i18n.BreakIterator_zh";
 }
 
 BreakIterator_zh::~BreakIterator_zh()
 {
-        delete dict;
+    delete dict;
 }
 
 //      ----------------------------------------------------
@@ -134,14 +134,14 @@ BreakIterator_zh::~BreakIterator_zh()
 //      ----------------------------------------------------;
 BreakIterator_zh_TW::BreakIterator_zh_TW()
 {
-        dict = new xdictionary("zh");
-        hangingCharacters = LocaleDataImpl().getHangingCharacters(LOCALE("zh", "TW"));
-        cBreakIterator = "com.sun.star.i18n.BreakIterator_zh_TW";
+    dict = new xdictionary("zh");
+    hangingCharacters = LocaleDataImpl().getHangingCharacters(LOCALE("zh", "TW"));
+    cBreakIterator = "com.sun.star.i18n.BreakIterator_zh_TW";
 }
 
 BreakIterator_zh_TW::~BreakIterator_zh_TW()
 {
-        delete dict;
+    delete dict;
 }
 
 //      ----------------------------------------------------
@@ -149,15 +149,15 @@ BreakIterator_zh_TW::~BreakIterator_zh_TW()
 //      ----------------------------------------------------;
 BreakIterator_ja::BreakIterator_ja()
 {
-        dict = new xdictionary("ja");
-        dict->setJapaneseWordBreak();
-        hangingCharacters = LocaleDataImpl().getHangingCharacters(LOCALE("ja", "JP"));
-        cBreakIterator = "com.sun.star.i18n.BreakIterator_ja";
+    dict = new xdictionary("ja");
+    dict->setJapaneseWordBreak();
+    hangingCharacters = LocaleDataImpl().getHangingCharacters(LOCALE("ja", "JP"));
+    cBreakIterator = "com.sun.star.i18n.BreakIterator_ja";
 }
 
 BreakIterator_ja::~BreakIterator_ja()
 {
-        delete dict;
+    delete dict;
 }
 
 //      ----------------------------------------------------
@@ -165,8 +165,8 @@ BreakIterator_ja::~BreakIterator_ja()
 //      ----------------------------------------------------;
 BreakIterator_ko::BreakIterator_ko()
 {
-        hangingCharacters = LocaleDataImpl().getHangingCharacters(LOCALE("ko", "KR"));
-        cBreakIterator = "com.sun.star.i18n.BreakIterator_ko";
+    hangingCharacters = LocaleDataImpl().getHangingCharacters(LOCALE("ko", "KR"));
+    cBreakIterator = "com.sun.star.i18n.BreakIterator_ko";
 }
 
 BreakIterator_ko::~BreakIterator_ko()
diff --git a/i18npool/source/breakiterator/breakiterator_unicode.cxx b/i18npool/source/breakiterator/breakiterator_unicode.cxx
index 63ebe53e3df2..0e64343e476c 100644
--- a/i18npool/source/breakiterator/breakiterator_unicode.cxx
+++ b/i18npool/source/breakiterator/breakiterator_unicode.cxx
@@ -205,18 +205,18 @@ sal_Int32 SAL_CALL BreakIterator_Unicode::nextCharacters( const OUString& Text,
         sal_Int16 nCharacterIteratorMode, sal_Int32 nCount, sal_Int32& nDone )
         throw(uno::RuntimeException)
 {
-        if (nCharacterIteratorMode == CharacterIteratorMode::SKIPCELL ) { // for CELL mode
-            loadICUBreakIterator(rLocale, LOAD_CHARACTER_BREAKITERATOR, 0, "char", Text);
-            for (nDone = 0; nDone < nCount; nDone++) {
-                nStartPos = character.aBreakIterator->following(nStartPos);
-                if (nStartPos == BreakIterator::DONE)
-                    return Text.getLength();
-            }
-        } else { // for CHARACTER mode
-            for (nDone = 0; nDone < nCount && nStartPos < Text.getLength(); nDone++)
-                Text.iterateCodePoints(&nStartPos, 1);
+    if (nCharacterIteratorMode == CharacterIteratorMode::SKIPCELL ) { // for CELL mode
+        loadICUBreakIterator(rLocale, LOAD_CHARACTER_BREAKITERATOR, 0, "char", Text);
+        for (nDone = 0; nDone < nCount; nDone++) {
+            nStartPos = character.aBreakIterator->following(nStartPos);
+            if (nStartPos == BreakIterator::DONE)
+                return Text.getLength();
         }
-        return nStartPos;
+    } else { // for CHARACTER mode
+        for (nDone = 0; nDone < nCount && nStartPos < Text.getLength(); nDone++)
+            Text.iterateCodePoints(&nStartPos, 1);
+    }
+    return nStartPos;
 }
 
 sal_Int32 SAL_CALL BreakIterator_Unicode::previousCharacters( const OUString& Text,
@@ -224,131 +224,131 @@ sal_Int32 SAL_CALL BreakIterator_Unicode::previousCharacters( const OUString& Te
         sal_Int16 nCharacterIteratorMode, sal_Int32 nCount, sal_Int32& nDone )
         throw(uno::RuntimeException)
 {
-        if (nCharacterIteratorMode == CharacterIteratorMode::SKIPCELL ) { // for CELL mode
-            loadICUBreakIterator(rLocale, LOAD_CHARACTER_BREAKITERATOR, 0, "char", Text);
-            for (nDone = 0; nDone < nCount; nDone++) {
-                nStartPos = character.aBreakIterator->preceding(nStartPos);
-                if (nStartPos == BreakIterator::DONE)
-                    return 0;
-            }
-        } else { // for BS to delete one char and CHARACTER mode.
-            for (nDone = 0; nDone < nCount && nStartPos > 0; nDone++)
-                Text.iterateCodePoints(&nStartPos, -1);
+    if (nCharacterIteratorMode == CharacterIteratorMode::SKIPCELL ) { // for CELL mode
+        loadICUBreakIterator(rLocale, LOAD_CHARACTER_BREAKITERATOR, 0, "char", Text);
+        for (nDone = 0; nDone < nCount; nDone++) {
+            nStartPos = character.aBreakIterator->preceding(nStartPos);
+            if (nStartPos == BreakIterator::DONE)
+                return 0;
         }
-        return nStartPos;
+    } else { // for BS to delete one char and CHARACTER mode.
+        for (nDone = 0; nDone < nCount && nStartPos > 0; nDone++)
+            Text.iterateCodePoints(&nStartPos, -1);
+    }
+    return nStartPos;
 }
 
 
 Boundary SAL_CALL BreakIterator_Unicode::nextWord( const OUString& Text, sal_Int32 nStartPos,
     const lang::Locale& rLocale, sal_Int16 rWordType ) throw(uno::RuntimeException)
 {
-        loadICUBreakIterator(rLocale, LOAD_WORD_BREAKITERATOR, rWordType, NULL, Text);
+    loadICUBreakIterator(rLocale, LOAD_WORD_BREAKITERATOR, rWordType, NULL, Text);
 
-        result.startPos = icuBI->aBreakIterator->following(nStartPos);
-        if( result.startPos >= Text.getLength() || result.startPos == BreakIterator::DONE )
-            result.endPos = result.startPos;
-        else {
-            if ( (rWordType == WordType::ANYWORD_IGNOREWHITESPACES ||
+    result.startPos = icuBI->aBreakIterator->following(nStartPos);
+    if( result.startPos >= Text.getLength() || result.startPos == BreakIterator::DONE )
+        result.endPos = result.startPos;
+    else {
+        if ( (rWordType == WordType::ANYWORD_IGNOREWHITESPACES ||
                     rWordType == WordType::DICTIONARY_WORD ) &&
-                        u_isWhitespace(Text.iterateCodePoints(&result.startPos, 0)) )
-                result.startPos = icuBI->aBreakIterator->following(result.startPos);
+                u_isWhitespace(Text.iterateCodePoints(&result.startPos, 0)) )
+            result.startPos = icuBI->aBreakIterator->following(result.startPos);
 
-            result.endPos = icuBI->aBreakIterator->following(result.startPos);
-            if(result.endPos == BreakIterator::DONE)
-                result.endPos = result.startPos;
-        }
-        return result;
+        result.endPos = icuBI->aBreakIterator->following(result.startPos);
+        if(result.endPos == BreakIterator::DONE)
+            result.endPos = result.startPos;
+    }
+    return result;
 }
 
 
 Boundary SAL_CALL BreakIterator_Unicode::previousWord(const OUString& Text, sal_Int32 nStartPos,
         const lang::Locale& rLocale, sal_Int16 rWordType) throw(uno::RuntimeException)
 {
-        loadICUBreakIterator(rLocale, LOAD_WORD_BREAKITERATOR, rWordType, NULL, Text);
+    loadICUBreakIterator(rLocale, LOAD_WORD_BREAKITERATOR, rWordType, NULL, Text);
 
-        result.startPos = icuBI->aBreakIterator->preceding(nStartPos);
-        if( result.startPos < 0 || result.startPos == BreakIterator::DONE)
-            result.endPos = result.startPos;
-        else {
-            if ( (rWordType == WordType::ANYWORD_IGNOREWHITESPACES ||
+    result.startPos = icuBI->aBreakIterator->preceding(nStartPos);
+    if( result.startPos < 0 || result.startPos == BreakIterator::DONE)
+        result.endPos = result.startPos;
+    else {
+        if ( (rWordType == WordType::ANYWORD_IGNOREWHITESPACES ||
                     rWordType == WordType::DICTIONARY_WORD) &&
-                        u_isWhitespace(Text.iterateCodePoints(&result.startPos, 0)) )
-                result.startPos = icuBI->aBreakIterator->preceding(result.startPos);
+                u_isWhitespace(Text.iterateCodePoints(&result.startPos, 0)) )
+            result.startPos = icuBI->aBreakIterator->preceding(result.startPos);
 
-            result.endPos = icuBI->aBreakIterator->following(result.startPos);
-            if(result.endPos == BreakIterator::DONE)
-                result.endPos = result.startPos;
-        }
-        return result;
+        result.endPos = icuBI->aBreakIterator->following(result.startPos);
+        if(result.endPos == BreakIterator::DONE)
+            result.endPos = result.startPos;
+    }
+    return result;
 }
 
 
 Boundary SAL_CALL BreakIterator_Unicode::getWordBoundary( const OUString& Text, sal_Int32 nPos, const lang::Locale& rLocale,
         sal_Int16 rWordType, sal_Bool bDirection ) throw(uno::RuntimeException)
 {
-        loadICUBreakIterator(rLocale, LOAD_WORD_BREAKITERATOR, rWordType, NULL, Text);
-        sal_Int32 len = Text.getLength();
-
-        if(icuBI->aBreakIterator->isBoundary(nPos)) {
-            result.startPos = result.endPos = nPos;
-            if((bDirection || nPos == 0) && nPos < len) //forward
-                result.endPos = icuBI->aBreakIterator->following(nPos);
-            else
-                result.startPos = icuBI->aBreakIterator->preceding(nPos);
+    loadICUBreakIterator(rLocale, LOAD_WORD_BREAKITERATOR, rWordType, NULL, Text);
+    sal_Int32 len = Text.getLength();
+
+    if(icuBI->aBreakIterator->isBoundary(nPos)) {
+        result.startPos = result.endPos = nPos;
+        if((bDirection || nPos == 0) && nPos < len) //forward
+            result.endPos = icuBI->aBreakIterator->following(nPos);
+        else
+            result.startPos = icuBI->aBreakIterator->preceding(nPos);
+    } else {
+        if(nPos <= 0) {
+            result.startPos = 0;
+            result.endPos = len ? icuBI->aBreakIterator->following((sal_Int32)0) : 0;
+        } else if(nPos >= len) {
+            result.startPos = icuBI->aBreakIterator->preceding(len);
+            result.endPos = len;
         } else {
-            if(nPos <= 0) {
-                result.startPos = 0;
-                result.endPos = len ? icuBI->aBreakIterator->following((sal_Int32)0) : 0;
-            } else if(nPos >= len) {
-                result.startPos = icuBI->aBreakIterator->preceding(len);
-                result.endPos = len;
-            } else {
-                result.startPos = icuBI->aBreakIterator->preceding(nPos);
-                result.endPos = icuBI->aBreakIterator->following(nPos);
-            }
+            result.startPos = icuBI->aBreakIterator->preceding(nPos);
+            result.endPos = icuBI->aBreakIterator->following(nPos);
         }
-        if (result.startPos == BreakIterator::DONE)
-            result.startPos = result.endPos;
-        else if (result.endPos == BreakIterator::DONE)
-            result.endPos = result.startPos;
+    }
+    if (result.startPos == BreakIterator::DONE)
+        result.startPos = result.endPos;
+    else if (result.endPos == BreakIterator::DONE)
+        result.endPos = result.startPos;
 
-        return result;
+    return result;
 }
 
 
 sal_Int32 SAL_CALL BreakIterator_Unicode::beginOfSentence( const OUString& Text, sal_Int32 nStartPos,
         const lang::Locale &rLocale ) throw(uno::RuntimeException)
 {
-        loadICUBreakIterator(rLocale, LOAD_SENTENCE_BREAKITERATOR, 0, "sent", Text);
+    loadICUBreakIterator(rLocale, LOAD_SENTENCE_BREAKITERATOR, 0, "sent", Text);
 
-        sal_Int32 len = Text.getLength();
-        if (len > 0 && nStartPos == len)
-            Text.iterateCodePoints(&nStartPos, -1); // issue #i27703# treat end position as part of last sentence
-        if (!sentence.aBreakIterator->isBoundary(nStartPos))
-            nStartPos = sentence.aBreakIterator->preceding(nStartPos);
+    sal_Int32 len = Text.getLength();
+    if (len > 0 && nStartPos == len)
+        Text.iterateCodePoints(&nStartPos, -1); // issue #i27703# treat end position as part of last sentence
+    if (!sentence.aBreakIterator->isBoundary(nStartPos))
+        nStartPos = sentence.aBreakIterator->preceding(nStartPos);
 
-        // skip preceding space.
-        sal_uInt32 ch = Text.iterateCodePoints(&nStartPos, 1);
-        while (nStartPos < len && u_isWhitespace(ch)) ch = Text.iterateCodePoints(&nStartPos, 1);
-        Text.iterateCodePoints(&nStartPos, -1);
+    // skip preceding space.
+    sal_uInt32 ch = Text.iterateCodePoints(&nStartPos, 1);
+    while (nStartPos < len && u_isWhitespace(ch)) ch = Text.iterateCodePoints(&nStartPos, 1);
+    Text.iterateCodePoints(&nStartPos, -1);
 
-        return nStartPos;
+    return nStartPos;
 }
 
 sal_Int32 SAL_CALL BreakIterator_Unicode::endOfSentence( const OUString& Text, sal_Int32 nStartPos,
         const lang::Locale &rLocale ) throw(uno::RuntimeException)
 {
-        loadICUBreakIterator(rLocale, LOAD_SENTENCE_BREAKITERATOR, 0, "sent", Text);
+    loadICUBreakIterator(rLocale, LOAD_SENTENCE_BREAKITERATOR, 0, "sent", Text);
 
-        sal_Int32 len = Text.getLength();
-        if (len > 0 && nStartPos == len)
-            Text.iterateCodePoints(&nStartPos, -1); // issue #i27703# treat end position as part of last sentence
-        nStartPos = sentence.aBreakIterator->following(nStartPos);
+    sal_Int32 len = Text.getLength();
+    if (len > 0 && nStartPos == len)
+        Text.iterateCodePoints(&nStartPos, -1); // issue #i27703# treat end position as part of last sentence
+    nStartPos = sentence.aBreakIterator->following(nStartPos);
 
-        sal_Int32 nPos=nStartPos;
-        while (nPos > 0 && u_isWhitespace(Text.iterateCodePoints(&nPos, -1))) nStartPos=nPos;
+    sal_Int32 nPos=nStartPos;
+    while (nPos > 0 && u_isWhitespace(Text.iterateCodePoints(&nPos, -1))) nStartPos=nPos;
 
-        return nStartPos;
+    return nStartPos;
 }
 
 LineBreakResults SAL_CALL BreakIterator_Unicode::getLineBreak(
@@ -357,63 +357,63 @@ LineBreakResults SAL_CALL BreakIterator_Unicode::getLineBreak(
         const LineBreakHyphenationOptions& hOptions,
         const LineBreakUserOptions& /*rOptions*/ ) throw(uno::RuntimeException)
 {
-        LineBreakResults lbr;
+    LineBreakResults lbr;
 
-        if (nStartPos >= Text.getLength()) {
-            lbr.breakIndex = Text.getLength();
-            lbr.breakType = BreakType::WORDBOUNDARY;
-            return lbr;
-        }
+    if (nStartPos >= Text.getLength()) {
+        lbr.breakIndex = Text.getLength();
+        lbr.breakType = BreakType::WORDBOUNDARY;
+        return lbr;
+    }
 
-        loadICUBreakIterator(rLocale, LOAD_LINE_BREAKITERATOR, 0, lineRule, Text);
-
-        sal_Bool GlueSpace=sal_True;
-        while (GlueSpace) {
-            if (line.aBreakIterator->preceding(nStartPos + 1) == nStartPos) { //Line boundary break
-                lbr.breakIndex = nStartPos;
-                lbr.breakType = BreakType::WORDBOUNDARY;
-            } else if (hOptions.rHyphenator.is()) { //Hyphenation break
-                Boundary wBoundary = getWordBoundary( Text, nStartPos, rLocale,
-                                                WordType::DICTIONARY_WORD, false);
-                uno::Reference< linguistic2::XHyphenatedWord > aHyphenatedWord;
-                aHyphenatedWord = hOptions.rHyphenator->hyphenate(Text.copy(wBoundary.startPos,
-                    wBoundary.endPos - wBoundary.startPos), rLocale,
+    loadICUBreakIterator(rLocale, LOAD_LINE_BREAKITERATOR, 0, lineRule, Text);
+
+    sal_Bool GlueSpace=sal_True;
+    while (GlueSpace) {
+        if (line.aBreakIterator->preceding(nStartPos + 1) == nStartPos) { //Line boundary break
+            lbr.breakIndex = nStartPos;
+            lbr.breakType = BreakType::WORDBOUNDARY;
+        } else if (hOptions.rHyphenator.is()) { //Hyphenation break
+            Boundary wBoundary = getWordBoundary( Text, nStartPos, rLocale,
+                    WordType::DICTIONARY_WORD, false);
+            uno::Reference< linguistic2::XHyphenatedWord > aHyphenatedWord;
+            aHyphenatedWord = hOptions.rHyphenator->hyphenate(Text.copy(wBoundary.startPos,
+                        wBoundary.endPos - wBoundary.startPos), rLocale,
                     (sal_Int16) (hOptions.hyphenIndex - wBoundary.startPos), hOptions.aHyphenationOptions);
-                if (aHyphenatedWord.is()) {
-                    lbr.rHyphenatedWord = aHyphenatedWord;
-                    if(wBoundary.startPos + aHyphenatedWord->getHyphenationPos() + 1 < nMinBreakPos )
-                        lbr.breakIndex = -1;
-                    else
-                        lbr.breakIndex = wBoundary.startPos; //aHyphenatedWord->getHyphenationPos();
-                    lbr.breakType = BreakType::HYPHENATION;
-                } else {
-                    lbr.breakIndex = line.aBreakIterator->preceding(nStartPos);
-                    lbr.breakType = BreakType::WORDBOUNDARY;;
-                }
-            } else { //word boundary break
+            if (aHyphenatedWord.is()) {
+                lbr.rHyphenatedWord = aHyphenatedWord;
+                if(wBoundary.startPos + aHyphenatedWord->getHyphenationPos() + 1 < nMinBreakPos )
+                    lbr.breakIndex = -1;
+                else
+                    lbr.breakIndex = wBoundary.startPos; //aHyphenatedWord->getHyphenationPos();
+                lbr.breakType = BreakType::HYPHENATION;
+            } else {
                 lbr.breakIndex = line.aBreakIterator->preceding(nStartPos);
-                lbr.breakType = BreakType::WORDBOUNDARY;
+                lbr.breakType = BreakType::WORDBOUNDARY;;
             }
+        } else { //word boundary break
+            lbr.breakIndex = line.aBreakIterator->preceding(nStartPos);
+            lbr.breakType = BreakType::WORDBOUNDARY;
+        }
 
 #define WJ 0x2060   // Word Joiner
-            GlueSpace=sal_False;
-            if (lbr.breakType == BreakType::WORDBOUNDARY) {
-                nStartPos = lbr.breakIndex;
+        GlueSpace=sal_False;
+        if (lbr.breakType == BreakType::WORDBOUNDARY) {
+            nStartPos = lbr.breakIndex;
+            if (Text[nStartPos--] == WJ)
+                GlueSpace=sal_True;
+            while (nStartPos >= 0 &&
+                    (u_isWhitespace(Text.iterateCodePoints(&nStartPos, 0)) || Text[nStartPos] == WJ)) {
                 if (Text[nStartPos--] == WJ)
                     GlueSpace=sal_True;
-                while (nStartPos >= 0 &&
-                    (u_isWhitespace(Text.iterateCodePoints(&nStartPos, 0)) || Text[nStartPos] == WJ)) {
-                    if (Text[nStartPos--] == WJ)
-                        GlueSpace=sal_True;
-                }
-                if (GlueSpace && nStartPos < 0)  {
-                    lbr.breakIndex = 0;
-                    break;
-                }
+            }
+            if (GlueSpace && nStartPos < 0)  {
+                lbr.breakIndex = 0;
+                break;
             }
         }
+    }
 
-        return lbr;
+    return lbr;
 }
 
 
@@ -421,21 +421,21 @@ LineBreakResults SAL_CALL BreakIterator_Unicode::getLineBreak(
 OUString SAL_CALL
 BreakIterator_Unicode::getImplementationName(void) throw( uno::RuntimeException )
 {
-        return OUString::createFromAscii(cBreakIterator);
+    return OUString::createFromAscii(cBreakIterator);
 }
 
 sal_Bool SAL_CALL
 BreakIterator_Unicode::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
 {
-        return !rServiceName.compareToAscii(cBreakIterator);
+    return !rServiceName.compareToAscii(cBreakIterator);
 }
 
 uno::Sequence< OUString > SAL_CALL
 BreakIterator_Unicode::getSupportedServiceNames(void) throw( uno::RuntimeException )
 {
-        uno::Sequence< OUString > aRet(1);
-        aRet[0] = OUString::createFromAscii(cBreakIterator);
-        return aRet;
+    uno::Sequence< OUString > aRet(1);
+    aRet[0] = OUString::createFromAscii(cBreakIterator);
+    return aRet;
 }
 
 } } } }
diff --git a/i18npool/source/breakiterator/xdictionary.cxx b/i18npool/source/breakiterator/xdictionary.cxx
index cf22d6cbd3e4..1200535f38cf 100644
--- a/i18npool/source/breakiterator/xdictionary.cxx
+++ b/i18npool/source/breakiterator/xdictionary.cxx
@@ -83,61 +83,62 @@ xdictionary::xdictionary(const sal_Char *lang) :
     OUStringBuffer aBuf( strlen(lang) + 7 + 4 );    // mostly "*.dll" (with * == dict_zh)
 #endif
     aBuf.appendAscii( "dict_" ).appendAscii( lang ).appendAscii( SAL_DLLEXTENSION );
-        hModule = osl_loadModuleRelative( &thisModule, aBuf.makeStringAndClear().pData, SAL_LOADMODULE_DEFAULT );
-        if( hModule ) {
-            sal_IntPtr (*func)();
-            func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getExistMark").pData );
-            existMark = (sal_uInt8*) (*func)();
-            func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getIndex1").pData );
-            index1 = (sal_Int16*) (*func)();
-            func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getIndex2").pData );
-            index2 = (sal_Int32*) (*func)();
-            func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getLenArray").pData );
-            lenArray = (sal_Int32*) (*func)();
-            func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getDataArea").pData );
-            dataArea = (sal_Unicode*) (*func)();
-        }
-        else
-        {
-            existMark = NULL;
-            index1 = NULL;
-            index2 = NULL;
-            lenArray = NULL;
-            dataArea = NULL;
-        }
+    hModule = osl_loadModuleRelative( &thisModule, aBuf.makeStringAndClear().pData, SAL_LOADMODULE_DEFAULT );
+    if( hModule ) {
+        sal_IntPtr (*func)();
+        func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getExistMark").pData );
+        existMark = (sal_uInt8*) (*func)();
+        func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getIndex1").pData );
+        index1 = (sal_Int16*) (*func)();
+        func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getIndex2").pData );
+        index2 = (sal_Int32*) (*func)();
+        func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getLenArray").pData );
+        lenArray = (sal_Int32*) (*func)();
+        func = (sal_IntPtr(*)()) osl_getFunctionSymbol( hModule, OUString("getDataArea").pData );
+        dataArea = (sal_Unicode*) (*func)();
+    }
+    else
+    {
+        existMark = NULL;
+        index1 = NULL;
+        index2 = NULL;
+        lenArray = NULL;
+        dataArea = NULL;
+    }
 
 #else
-        if( strcmp( lang, "ja" ) == 0 ) {
-            existMark = getExistMark_ja();
-            index1 = getIndex1_ja();
-            index2 = getIndex2_ja();
-            lenArray = getLenArray_ja();
-            dataArea = getDataArea_ja();
-        }
-        else if( strcmp( lang, "zh" ) == 0 ) {
-            existMark = getExistMark_zh();
-            index1 = getIndex1_zh();
-            index2 = getIndex2_zh();
-            lenArray = getLenArray_zh();
-            dataArea = getDataArea_zh();
-        }
-        else
-        {
-            existMark = NULL;
-            index1 = NULL;
-            index2 = NULL;
-            lenArray = NULL;
-            dataArea = NULL;
-        }
+    if( strcmp( lang, "ja" ) == 0 ) {
+        existMark = getExistMark_ja();
+        index1 = getIndex1_ja();
+        index2 = getIndex2_ja();
+        lenArray = getLenArray_ja();
+        dataArea = getDataArea_ja();
+    }
+    else if( strcmp( lang, "zh" ) == 0 ) {
+        existMark = getExistMark_zh();
+        index1 = getIndex1_zh();
+        index2 = getIndex2_zh();
+        lenArray = getLenArray_zh();
+        dataArea = getDataArea_zh();
+    }
+    else
+    {
+        existMark = NULL;
+        index1 = NULL;
+        index2 = NULL;
+        lenArray = NULL;
+        dataArea = NULL;
+    }
 #endif
 
-        for (sal_Int32 i = 0; i < CACHE_MAX; i++)
-            cache[i].size = 0;
+    for (sal_Int32 i = 0; i < CACHE_MAX; i++)
+        cache[i].size = 0;
 
-        japaneseWordBreak = sal_False;
+    japaneseWordBreak = sal_False;
 }
 
-xdictionary::~xdictionary() {
+xdictionary::~xdictionary()
+{
 #ifndef DISABLE_DYNLOADING
         osl_unloadModule(hModule);
 #endif
@@ -151,46 +152,48 @@ xdictionary::~xdictionary() {
 
 void xdictionary::setJapaneseWordBreak()
 {
-        japaneseWordBreak = sal_True;
+    japaneseWordBreak = sal_True;
 }
 
-sal_Bool xdictionary::exists(const sal_uInt32 c) {
-        // 0x1FFF is the hardcoded limit in gendict for existMarks
-        sal_Bool exist = (existMark && ((c>>3) < 0x1FFF)) ? sal::static_int_cast<sal_Bool>((existMark[c>>3] & (1<<(c&0x07))) != 0) : sal_False;
-        if (!exist && japaneseWordBreak)
-            return BreakIteratorImpl::getScriptClass(c) == ScriptType::ASIAN;
-        else
-            return exist;
+sal_Bool xdictionary::exists(const sal_uInt32 c)
+{
+    // 0x1FFF is the hardcoded limit in gendict for existMarks
+    sal_Bool exist = (existMark && ((c>>3) < 0x1FFF)) ? sal::static_int_cast<sal_Bool>((existMark[c>>3] & (1<<(c&0x07))) != 0) : sal_False;
+    if (!exist && japaneseWordBreak)
+        return BreakIteratorImpl::getScriptClass(c) == ScriptType::ASIAN;
+    else
+        return exist;
 }
 
-sal_Int32 xdictionary::getLongestMatch(const sal_Unicode* str, sal_Int32 sLen) {
+sal_Int32 xdictionary::getLongestMatch(const sal_Unicode* str, sal_Int32 sLen)
+{
 
-        if ( !index1 ) return 0;
+    if ( !index1 ) return 0;
 
-        sal_Int16 idx = index1[str[0] >> 8];
+    sal_Int16 idx = index1[str[0] >> 8];
 
-        if (idx == 0xFF) return 0;
+    if (idx == 0xFF) return 0;
 
-        idx = (idx<<8) | (str[0]&0xff);
+    idx = (idx<<8) | (str[0]&0xff);
 
-        sal_uInt32 begin = index2[idx], end = index2[idx+1];
+    sal_uInt32 begin = index2[idx], end = index2[idx+1];
 
-        if (begin == 0) return 0;
+    if (begin == 0) return 0;
 
-        str++; sLen--; // first character is not stored in the dictionary
-        for (sal_uInt32 i = end; i > begin; i--) {
-            sal_Int32 len = lenArray[i] - lenArray[i - 1];
-            if (sLen >= len) {
-                const sal_Unicode *dstr = dataArea + lenArray[i-1];
-                sal_Int32 pos = 0;
+    str++; sLen--; // first character is not stored in the dictionary
+    for (sal_uInt32 i = end; i > begin; i--) {
+        sal_Int32 len = lenArray[i] - lenArray[i - 1];
+        if (sLen >= len) {
+            const sal_Unicode *dstr = dataArea + lenArray[i-1];
+            sal_Int32 pos = 0;
 
-                while (pos < len && dstr[pos] == str[pos]) { pos++; }
+            while (pos < len && dstr[pos] == str[pos]) { pos++; }
 
-                if (pos == len)
-                    return len + 1;
-            }
+            if (pos == len)
+                return len + 1;
         }
-        return 0;
+    }
+    return 0;
 }
 
 
@@ -210,14 +213,15 @@ WordBreakCache::WordBreakCache() :
  * Compare two unicode string,
  */
 
-sal_Bool WordBreakCache::equals(const sal_Unicode* str, Boundary& boundary) {
-        // Different length, different string.
-        if (length != boundary.endPos - boundary.startPos) return sal_False;
+sal_Bool WordBreakCache::equals(const sal_Unicode* str, Boundary& boundary)
+{
+    // Different length, different string.
+    if (length != boundary.endPos - boundary.startPos) return sal_False;
 
-        for (sal_Int32 i = 0; i < length; i++)
-            if (contents[i] != str[i + boundary.startPos]) return sal_False;
+    for (sal_Int32 i = 0; i < length; i++)
+        if (contents[i] != str[i + boundary.startPos]) return sal_False;
 
-        return sal_True;
+    return sal_True;
 }