LCOV - app.info - intl/uconv/src/nsScriptableUConv.cpp

LCOV - code coverage report
| Current view: | directory - intl/uconv/src - nsScriptableUConv.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 132 | 106 | 80.3 %
| Date: | 2012-04-21 | Functions: | 19 | 17 | 89.5 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* ***** BEGIN LICENSE BLOCK *****
           3                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           4                 :  *
           5                 :  * The contents of this file are subject to the Mozilla Public License Version
           6                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           7                 :  * the License. You may obtain a copy of the License at
           8                 :  * http://www.mozilla.org/MPL/
           9                 :  *
          10                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          11                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          12                 :  * for the specific language governing rights and limitations under the
          13                 :  * License.
          14                 :  *
          15                 :  * The Original Code is Mozilla Communicator client code.
          16                 :  *
          17                 :  * The Initial Developer of the Original Code is
          18                 :  * Netscape Communications Corporation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 1998
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *   Makoto Kato <m_kato@ga2.so-net.ne.jp >
          24                 :  *   Ryoichi Furukawa <oliver@1000cp.com>
          25                 :  *
          26                 :  * Alternatively, the contents of this file may be used under the terms of
          27                 :  * either of the GNU General Public License Version 2 or later (the "GPL"),
          28                 :  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          30                 :  * of those above. If you wish to allow use of your version of this file only
          31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          32                 :  * use your version of this file under the terms of the MPL, indicate your
          33                 :  * decision by deleting the provisions above and replace them with the notice
          34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          35                 :  * the provisions above, a recipient may use your version of this file under
          36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          37                 :  *
          38                 :  * ***** END LICENSE BLOCK ***** */
          39                 :
          40                 : #include "nsAtomicRefcnt.h"
          41                 : #include "nsString.h"
          42                 : #include "nsReadableUtils.h"
          43                 : #include "nsIServiceManager.h"
          44                 : #include "nsICharsetConverterManager.h"
          45                 : #include "nsIScriptableUConv.h"
          46                 : #include "nsScriptableUConv.h"
          47                 : #include "nsIStringStream.h"
          48                 : #include "nsCRT.h"
          49                 : #include "nsComponentManagerUtils.h"
          50                 :
          51                 : static PRInt32          gInstanceCount = 0;
          52                 :
          53                 : /* Implementation file */
          54           12947 : NS_IMPL_ISUPPORTS1(nsScriptableUnicodeConverter, nsIScriptableUnicodeConverter)
          55                 :
          56             611 : nsScriptableUnicodeConverter::nsScriptableUnicodeConverter()
          57             611 : : mIsInternal(false)
          58                 : {
          59             611 :   PR_ATOMIC_INCREMENT(&gInstanceCount);
          60             611 : }
          61                 :
          62            1833 : nsScriptableUnicodeConverter::~nsScriptableUnicodeConverter()
          63                 : {
          64             611 :   PR_ATOMIC_DECREMENT(&gInstanceCount);
          65            2444 : }
          66                 :
          67                 : nsresult
          68            3989 : nsScriptableUnicodeConverter::ConvertFromUnicodeWithLength(const nsAString& aSrc,
          69                 :                                                            PRInt32* aOutLen,
          70                 :                                                            char **_retval)
          71                 : {
          72            3989 :   if (!mEncoder)
          73               0 :     return NS_ERROR_FAILURE;
          74                 :
          75            3989 :   nsresult rv = NS_OK;
          76            3989 :   PRInt32 inLength = aSrc.Length();
          77            7978 :   const nsAFlatString& flatSrc = PromiseFlatString(aSrc);
          78            3989 :   rv = mEncoder->GetMaxLength(flatSrc.get(), inLength, aOutLen);
          79            3989 :   if (NS_SUCCEEDED(rv)) {
          80            3989 :     *_retval = (char*)moz_malloc(*aOutLen+1);
          81            3989 :     if (!*_retval)
          82               0 :       return NS_ERROR_OUT_OF_MEMORY;
          83                 :
          84            3989 :     rv = mEncoder->Convert(flatSrc.get(), &inLength, *_retval, aOutLen);
          85            3989 :     if (NS_SUCCEEDED(rv))
          86                 :     {
          87            3989 :       (*_retval)[*aOutLen] = '\0';
          88            3989 :       return NS_OK;
          89                 :     }
          90               0 :     moz_free(*_retval);
          91                 :   }
          92               0 :   *_retval = nsnull;
          93               0 :   return NS_ERROR_FAILURE;
          94                 : }
          95                 :
          96                 : /* ACString ConvertFromUnicode (in AString src); */
          97                 : NS_IMETHODIMP
          98            3150 : nsScriptableUnicodeConverter::ConvertFromUnicode(const nsAString& aSrc,
          99                 :                                                  nsACString& _retval)
         100                 : {
         101                 :   PRInt32 len;
         102                 :   char* str;
         103            3150 :   nsresult rv = ConvertFromUnicodeWithLength(aSrc, &len, &str);
         104            3150 :   if (NS_SUCCEEDED(rv)) {
         105                 :     // No Adopt on nsACString :(
         106            3150 :     _retval.Assign(str, len);
         107            3150 :     moz_free(str);
         108                 :   }
         109            3150 :   return rv;
         110                 : }
         111                 :
         112                 : nsresult
         113          606196 : nsScriptableUnicodeConverter::FinishWithLength(char **_retval, PRInt32* aLength)
         114                 : {
         115          606196 :   if (!mEncoder)
         116               0 :     return NS_ERROR_FAILURE;
         117                 :
         118          606196 :   PRInt32 finLength = 32;
         119                 :
         120          606196 :   *_retval = (char *)moz_malloc(finLength);
         121          606196 :   if (!*_retval)
         122               0 :     return NS_ERROR_OUT_OF_MEMORY;
         123                 :
         124          606196 :   nsresult rv = mEncoder->Finish(*_retval, &finLength);
         125          606196 :   if (NS_SUCCEEDED(rv))
         126          606196 :     *aLength = finLength;
         127                 :   else
         128               0 :     moz_free(*_retval);
         129                 :
         130          606196 :   return rv;
         131                 :
         132                 : }
         133                 :
         134                 : /* ACString Finish(); */
         135                 : NS_IMETHODIMP
         136          605357 : nsScriptableUnicodeConverter::Finish(nsACString& _retval)
         137                 : {
         138                 :   PRInt32 len;
         139                 :   char* str;
         140          605357 :   nsresult rv = FinishWithLength(&str, &len);
         141          605357 :   if (NS_SUCCEEDED(rv)) {
         142                 :     // No Adopt on nsACString :(
         143          605357 :     _retval.Assign(str, len);
         144          605357 :     moz_free(str);
         145                 :   }
         146          605357 :   return rv;
         147                 : }
         148                 :
         149                 : /* AString ConvertToUnicode (in ACString src); */
         150                 : NS_IMETHODIMP
         151          615576 : nsScriptableUnicodeConverter::ConvertToUnicode(const nsACString& aSrc, nsAString& _retval)
         152                 : {
         153          615576 :   nsACString::const_iterator i;
         154          615576 :   aSrc.BeginReading(i);
         155          615576 :   return ConvertFromByteArray(reinterpret_cast<const PRUint8*>(i.get()),
         156                 :                               aSrc.Length(),
         157         1231152 :                               _retval);
         158                 : }
         159                 :
         160                 : /* AString convertFromByteArray([const,array,size_is(aCount)] in octet aData,
         161                 :                                 in unsigned long aCount);
         162                 :  */
         163                 : NS_IMETHODIMP
         164          615576 : nsScriptableUnicodeConverter::ConvertFromByteArray(const PRUint8* aData,
         165                 :                                                    PRUint32 aCount,
         166                 :                                                    nsAString& _retval)
         167                 : {
         168          615576 :   if (!mDecoder)
         169               0 :     return NS_ERROR_FAILURE;
         170                 :
         171          615576 :   nsresult rv = NS_OK;
         172          615576 :   PRInt32 inLength = aCount;
         173                 :   PRInt32 outLength;
         174          615576 :   rv = mDecoder->GetMaxLength(reinterpret_cast<const char*>(aData),
         175          615576 :                               inLength, &outLength);
         176          615576 :   if (NS_SUCCEEDED(rv))
         177                 :   {
         178          615576 :     PRUnichar* buf = (PRUnichar*)moz_malloc((outLength+1)*sizeof(PRUnichar));
         179          615576 :     if (!buf)
         180               0 :       return NS_ERROR_OUT_OF_MEMORY;
         181                 :
         182          615576 :     rv = mDecoder->Convert(reinterpret_cast<const char*>(aData),
         183          615576 :                            &inLength, buf, &outLength);
         184          615576 :     if (NS_SUCCEEDED(rv))
         185                 :     {
         186          614924 :       buf[outLength] = 0;
         187          614924 :       _retval.Assign(buf, outLength);
         188                 :     }
         189          615576 :     moz_free(buf);
         190          615576 :     return rv;
         191                 :   }
         192               0 :   return NS_ERROR_FAILURE;
         193                 :
         194                 : }
         195                 :
         196                 : /* void convertToByteArray(in AString aString,
         197                 :                           [optional] out unsigned long aLen,
         198                 :                           [array, size_is(aLen),retval] out octet aData);
         199                 :  */
         200                 : NS_IMETHODIMP
         201             839 : nsScriptableUnicodeConverter::ConvertToByteArray(const nsAString& aString,
         202                 :                                                  PRUint32* aLen,
         203                 :                                                  PRUint8** _aData)
         204                 : {
         205                 :   char* data;
         206                 :   PRInt32 len;
         207             839 :   nsresult rv = ConvertFromUnicodeWithLength(aString, &len, &data);
         208             839 :   if (NS_FAILED(rv))
         209               0 :     return rv;
         210            1678 :   nsXPIDLCString str;
         211             839 :   str.Adopt(data, len); // NOTE: This uses the XPIDLCString as a byte array
         212                 :
         213             839 :   rv = FinishWithLength(&data, &len);
         214             839 :   if (NS_FAILED(rv))
         215               0 :     return rv;
         216                 :
         217             839 :   str.Append(data, len);
         218             839 :   moz_free(data);
         219                 :   // NOTE: this being a byte array, it needs no null termination
         220             839 :   *_aData = reinterpret_cast<PRUint8*>(moz_malloc(str.Length()));
         221             839 :   if (!*_aData)
         222               0 :     return NS_ERROR_OUT_OF_MEMORY;
         223             839 :   memcpy(*_aData, str.get(), str.Length());
         224             839 :   *aLen = str.Length();
         225             839 :   return NS_OK;
         226                 : }
         227                 :
         228                 : /* nsIInputStream convertToInputStream(in AString aString); */
         229                 : NS_IMETHODIMP
         230             302 : nsScriptableUnicodeConverter::ConvertToInputStream(const nsAString& aString,
         231                 :                                                    nsIInputStream** _retval)
         232                 : {
         233                 :   nsresult rv;
         234                 :   nsCOMPtr<nsIStringInputStream> inputStream =
         235             604 :     do_CreateInstance("@mozilla.org/io/string-input-stream;1", &rv);
         236             302 :   if (NS_FAILED(rv))
         237               0 :     return rv;
         238                 :
         239                 :   PRUint8* data;
         240                 :   PRUint32 dataLen;
         241             302 :   rv = ConvertToByteArray(aString, &dataLen, &data);
         242             302 :   if (NS_FAILED(rv))
         243               0 :     return rv;
         244                 :
         245             302 :   rv = inputStream->AdoptData(reinterpret_cast<char*>(data), dataLen);
         246             302 :   if (NS_FAILED(rv)) {
         247               0 :     moz_free(data);
         248               0 :     return rv;
         249                 :   }
         250                 :
         251             302 :   NS_ADDREF(*_retval = inputStream);
         252             302 :   return rv;
         253                 : }
         254                 :
         255                 : /* attribute string charset; */
         256                 : NS_IMETHODIMP
         257               0 : nsScriptableUnicodeConverter::GetCharset(char * *aCharset)
         258                 : {
         259               0 :   *aCharset = ToNewCString(mCharset);
         260               0 :   if (!*aCharset)
         261               0 :     return NS_ERROR_OUT_OF_MEMORY;
         262                 :
         263               0 :   return NS_OK;
         264                 : }
         265                 :
         266                 : NS_IMETHODIMP
         267            9936 : nsScriptableUnicodeConverter::SetCharset(const char * aCharset)
         268                 : {
         269            9936 :   mCharset.Assign(aCharset);
         270            9936 :   return InitConverter();
         271                 : }
         272                 :
         273                 : NS_IMETHODIMP
         274               0 : nsScriptableUnicodeConverter::GetIsInternal(bool *aIsInternal)
         275                 : {
         276               0 :   *aIsInternal = mIsInternal;
         277               0 :   return NS_OK;
         278                 : }
         279                 :
         280                 : NS_IMETHODIMP
         281               8 : nsScriptableUnicodeConverter::SetIsInternal(const bool aIsInternal)
         282                 : {
         283               8 :   mIsInternal = aIsInternal;
         284               8 :   return NS_OK;
         285                 : }
         286                 :
         287                 : nsresult
         288            9936 : nsScriptableUnicodeConverter::InitConverter()
         289                 : {
         290            9936 :   nsresult rv = NS_OK;
         291            9936 :   mEncoder = NULL ;
         292                 :
         293           19872 :   nsCOMPtr<nsICharsetConverterManager> ccm = do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &rv);
         294                 :
         295            9936 :   if (NS_SUCCEEDED( rv) && (nsnull != ccm)) {
         296                 :     // get charset atom due to getting unicode converter
         297                 :
         298                 :     // get an unicode converter
         299            9936 :     rv = ccm->GetUnicodeEncoder(mCharset.get(), getter_AddRefs(mEncoder));
         300            9936 :     if(NS_SUCCEEDED(rv)) {
         301            9932 :       rv = mEncoder->SetOutputErrorBehavior(nsIUnicodeEncoder::kOnError_Replace, nsnull, (PRUnichar)'?');
         302            9932 :       if(NS_SUCCEEDED(rv)) {
         303                 :         rv = mIsInternal ?
         304              18 :           ccm->GetUnicodeDecoderInternal(mCharset.get(),
         305            9968 :                                          getter_AddRefs(mDecoder)) :
         306            9914 :           ccm->GetUnicodeDecoder(mCharset.get(),
         307           19882 :                                  getter_AddRefs(mDecoder));
         308                 :       }
         309                 :     }
         310                 :   }
         311                 :
         312            9936 :   return rv ;
         313                 : }

Generated by: LCOV version 1.7