sal/textenc/textcvt.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: textcvt.c,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "rtl/textcvt.h"
  32 #include "gettextencodingdata.h"
  33 #include "tenchelp.h"
  34
  35 /* ======================================================================= */
  36
  37 static sal_Size ImplDummyToUnicode( const sal_Char* pSrcBuf, sal_Size nSrcBytes,
  38                                     sal_Unicode* pDestBuf, sal_Size nDestChars,
  39                                     sal_uInt32 nFlags, sal_uInt32* pInfo,
  40                                     sal_Size* pSrcCvtBytes )
  41 {
  42     sal_Unicode*        pEndDestBuf;
  43     const sal_Char*     pEndSrcBuf;
  44
  45     if ( ((nFlags & RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MASK) == RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR) ||
  46          ((nFlags & RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_MASK) == RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR) )
  47     {
  48         *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR |
  49                   RTL_TEXTTOUNICODE_INFO_UNDEFINED |
  50                   RTL_TEXTTOUNICODE_INFO_MBUNDEFINED;
  51         return 0;
  52     }
  53
  54     *pInfo = 0;
  55     pEndDestBuf = pDestBuf+nDestChars;
  56     pEndSrcBuf  = pSrcBuf+nSrcBytes;
  57     while ( pSrcBuf < pEndSrcBuf )
  58     {
  59         if ( pDestBuf == pEndDestBuf )
  60         {
  61             *pInfo |= RTL_TEXTTOUNICODE_INFO_ERROR | RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL;
  62             break;
  63         }
  64
  65         *pDestBuf = (sal_Unicode)(sal_uChar)*pSrcBuf;
  66         pDestBuf++;
  67         pSrcBuf++;
  68     }
  69
  70     *pSrcCvtBytes = nSrcBytes - (pEndSrcBuf-pSrcBuf);
  71     return (nDestChars - (pEndDestBuf-pDestBuf));
  72 }
  73
  74 /* ----------------------------------------------------------------------- */
  75
  76 static sal_Size ImplUnicodeToDummy( const sal_Unicode* pSrcBuf, sal_Size nSrcChars,
  77                                     sal_Char* pDestBuf, sal_Size nDestBytes,
  78                                     sal_uInt32 nFlags, sal_uInt32* pInfo,
  79                                     sal_Size* pSrcCvtChars )
  80 {
  81     sal_Char*               pEndDestBuf;
  82     const sal_Unicode*      pEndSrcBuf;
  83
  84     if ( ((nFlags & RTL_UNICODETOTEXT_FLAGS_UNDEFINED_MASK) == RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR) )
  85     {
  86         *pInfo |= RTL_UNICODETOTEXT_INFO_ERROR |
  87                   RTL_UNICODETOTEXT_INFO_UNDEFINED;
  88         return 0;
  89     }
  90
  91     *pInfo = 0;
  92     pEndDestBuf = pDestBuf+nDestBytes;
  93     pEndSrcBuf  = pSrcBuf+nSrcChars;
  94     while ( pSrcBuf < pEndSrcBuf )
  95     {
  96         if ( pDestBuf == pEndDestBuf )
  97         {
  98             *pInfo |= RTL_UNICODETOTEXT_INFO_ERROR | RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL;
  99             break;
 100         }
 101
 102         *pDestBuf = (sal_Char)(sal_uChar)(*pSrcBuf & 0x00FF);
 103         pDestBuf++;
 104         pSrcBuf++;
 105     }
 106
 107     *pSrcCvtChars = nSrcChars - (pEndSrcBuf-pSrcBuf);
 108     return (nDestBytes - (pEndDestBuf-pDestBuf));
 109 }
 110
 111 /* ======================================================================= */
 112
 113 rtl_TextToUnicodeConverter SAL_CALL rtl_createTextToUnicodeConverter( rtl_TextEncoding eTextEncoding )
 114 {
 115     const ImplTextEncodingData* pData = Impl_getTextEncodingData( eTextEncoding );
 116     if ( pData )
 117         return (rtl_TextToUnicodeConverter) &pData->maConverter;
 118     else
 119         return 0;
 120 }
 121
 122 /* ----------------------------------------------------------------------- */
 123
 124 void SAL_CALL rtl_destroyTextToUnicodeConverter( rtl_TextToUnicodeConverter hContext )
 125 {
 126     (void) hContext; /* unused */
 127 }
 128
 129 /* ----------------------------------------------------------------------- */
 130
 131 rtl_TextToUnicodeContext SAL_CALL rtl_createTextToUnicodeContext( rtl_TextToUnicodeConverter hConverter )
 132 {
 133     const ImplTextConverter* pConverter = (const ImplTextConverter*)hConverter;
 134     if ( !pConverter )
 135         return 0;
 136     else if ( pConverter->mpCreateTextToUnicodeContext )
 137         return (rtl_TextToUnicodeContext)pConverter->mpCreateTextToUnicodeContext();
 138     else
 139         return (rtl_TextToUnicodeContext)1;
 140 }
 141
 142 /* ----------------------------------------------------------------------- */
 143
 144 void SAL_CALL rtl_destroyTextToUnicodeContext( rtl_TextToUnicodeConverter hConverter,
 145                                                rtl_TextToUnicodeContext hContext )
 146 {
 147     const ImplTextConverter* pConverter = (const ImplTextConverter*)hConverter;
 148     if ( pConverter && hContext && pConverter->mpDestroyTextToUnicodeContext )
 149         pConverter->mpDestroyTextToUnicodeContext( (void*)hContext );
 150 }
 151
 152 /* ----------------------------------------------------------------------- */
 153
 154 void SAL_CALL rtl_resetTextToUnicodeContext( rtl_TextToUnicodeConverter hConverter,
 155                                              rtl_TextToUnicodeContext hContext )
 156 {
 157     const ImplTextConverter* pConverter = (const ImplTextConverter*)hConverter;
 158     if ( pConverter && hContext && pConverter->mpResetTextToUnicodeContext )
 159         pConverter->mpResetTextToUnicodeContext( (void*)hContext );
 160 }
 161
 162 /* ----------------------------------------------------------------------- */
 163
 164 sal_Size SAL_CALL rtl_convertTextToUnicode( rtl_TextToUnicodeConverter hConverter,
 165                                             rtl_TextToUnicodeContext hContext,
 166                                             const sal_Char* pSrcBuf, sal_Size nSrcBytes,
 167                                             sal_Unicode* pDestBuf, sal_Size nDestChars,
 168                                             sal_uInt32 nFlags, sal_uInt32* pInfo,
 169                                             sal_Size* pSrcCvtBytes )
 170 {
 171     const ImplTextConverter* pConverter = (const ImplTextConverter*)hConverter;
 172
 173     /* Only temporaer, because we don't want die, if we don't have a
 174        converter, because not all converters are implemented yet */
 175     if ( !pConverter )
 176     {
 177         return ImplDummyToUnicode( pSrcBuf, nSrcBytes,
 178                                    pDestBuf, nDestChars,
 179                                    nFlags, pInfo, pSrcCvtBytes );
 180     }
 181
 182     return pConverter->mpConvertTextToUnicodeProc( pConverter->mpConvertData,
 183                                                    (void*)hContext,
 184                                                    pSrcBuf, nSrcBytes,
 185                                                    pDestBuf, nDestChars,
 186                                                    nFlags, pInfo,
 187                                                    pSrcCvtBytes );
 188 }
 189
 190 /* ======================================================================= */
 191
 192 rtl_UnicodeToTextConverter SAL_CALL rtl_createUnicodeToTextConverter( rtl_TextEncoding eTextEncoding )
 193 {
 194     const ImplTextEncodingData* pData = Impl_getTextEncodingData( eTextEncoding );
 195     if ( pData )
 196         return (rtl_TextToUnicodeConverter) &pData->maConverter;
 197     else
 198         return 0;
 199 }
 200
 201 /* ----------------------------------------------------------------------- */
 202
 203 void SAL_CALL rtl_destroyUnicodeToTextConverter( rtl_UnicodeToTextConverter hConverter )
 204 {
 205     (void) hConverter; /* unused */
 206 }
 207
 208 /* ----------------------------------------------------------------------- */
 209
 210 rtl_UnicodeToTextContext SAL_CALL rtl_createUnicodeToTextContext( rtl_UnicodeToTextConverter hConverter )
 211 {
 212     const ImplTextConverter* pConverter = (const ImplTextConverter*)hConverter;
 213     if ( !pConverter )
 214         return 0;
 215     else if ( pConverter->mpCreateUnicodeToTextContext )
 216         return (rtl_UnicodeToTextContext)pConverter->mpCreateUnicodeToTextContext();
 217     else
 218         return (rtl_UnicodeToTextContext)1;
 219 }
 220
 221 /* ----------------------------------------------------------------------- */
 222
 223 void SAL_CALL rtl_destroyUnicodeToTextContext( rtl_UnicodeToTextConverter hConverter,
 224                                                rtl_UnicodeToTextContext hContext )
 225 {
 226     const ImplTextConverter* pConverter = (const ImplTextConverter*)hConverter;
 227     if ( pConverter && hContext && pConverter->mpDestroyUnicodeToTextContext )
 228         pConverter->mpDestroyUnicodeToTextContext( (void*)hContext );
 229 }
 230
 231 /* ----------------------------------------------------------------------- */
 232
 233 void SAL_CALL rtl_resetUnicodeToTextContext( rtl_UnicodeToTextConverter hConverter,
 234                                              rtl_UnicodeToTextContext hContext )
 235 {
 236     const ImplTextConverter* pConverter = (const ImplTextConverter*)hConverter;
 237     if ( pConverter && hContext && pConverter->mpResetUnicodeToTextContext )
 238         pConverter->mpResetUnicodeToTextContext( (void*)hContext );
 239 }
 240
 241 /* ----------------------------------------------------------------------- */
 242
 243 sal_Size SAL_CALL rtl_convertUnicodeToText( rtl_UnicodeToTextConverter hConverter,
 244                                             rtl_UnicodeToTextContext hContext,
 245                                             const sal_Unicode* pSrcBuf, sal_Size nSrcChars,
 246                                             sal_Char* pDestBuf, sal_Size nDestBytes,
 247                                             sal_uInt32 nFlags, sal_uInt32* pInfo,
 248                                             sal_Size* pSrcCvtChars )
 249 {
 250     const ImplTextConverter* pConverter = (const ImplTextConverter*)hConverter;
 251
 252     /* Only temporaer, because we don't want die, if we don't have a
 253        converter, because not all converters are implemented yet */
 254     if ( !pConverter )
 255     {
 256         return ImplUnicodeToDummy( pSrcBuf, nSrcChars,
 257                                    pDestBuf, nDestBytes,
 258                                    nFlags, pInfo, pSrcCvtChars );
 259     }
 260
 261     return pConverter->mpConvertUnicodeToTextProc( pConverter->mpConvertData,
 262                                                    (void*)hContext,
 263                                                    pSrcBuf, nSrcChars,
 264                                                    pDestBuf, nDestBytes,
 265                                                    nFlags, pInfo,
 266                                                    pSrcCvtChars );
 267 }