The Tor Browser: intl/uconv/tests/convperf.cpp@b8a032363ba2

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     5 #include <windows.h>

     6 #include <winnls.h>

     8 #include "nscore.h"

     9 #include "nsString.h"

    10 #include "nsIServiceManager.h"

    11 #include "nsICharsetConverterManager.h"

    12 #include "nsIUnicodeEncoder.h"

    13 #include "nsIUnicodeDecoder.h"

    15 #include <stdio.h>

    16 #include <string.h>

    17 #include <stdlib.h>

    18 void usage()

    19 {

    20   printf(

    21 "convperf -f fromcode -t tocode [file]\n"

    22   );

    23 }

    24 int fromcodeind = 0;

    25 int tocodeind = 0;

    26 FILE* infile = 0;

    27 #define INBUFSIZE (1024*16)

    28 #define MEDBUFSIZE (1024*16*2)

    29 #define OUTBUFSIZE (1024*16*8)

    30 char inbuffer[INBUFSIZE];

    31 char outbuffer[OUTBUFSIZE];

    32 char16_t  medbuffer[MEDBUFSIZE];

    33 nsIUnicodeEncoder* encoder = nullptr;

    34 nsIUnicodeDecoder* decoder = nullptr;

    35 UINT incp = 932;

    36 UINT outcp = 932;

    38 void memcpyDecode(const char* src, int32_t srclen, char* dest)

    39 {

    40    ::memcpy(dest, src, srclen);

    41 }

    42 void memcpyEncode(const char* src, int32_t srclen, char* dest)

    43 {

    44    ::memcpy(dest, src, srclen);

    45 }

    47 void WideDecode(const char* src,

    48               int32_t srclen, char16_t *dest, int32_t *destLen)

    49 {

    50    const char* end = src+srclen ;

    51    while(src < end)

    52      *dest++ = (char16_t) *src++;

    53    *destLen = srclen;

    54 }

    55 void NarrowEncode(const char16_t *src,

    56               int32_t srclen, char* dest, int32_t* destLen)

    57 {

    58    const char16_t* end = src+srclen ;

    59    while(src < end)

    60      *dest++ = (char) *src++;

    61    *destLen = srclen;

    62 }

    63 void msDecode(UINT cp, const char* src,

    64               int32_t srclen, char16_t *dest, int32_t *destLen)

    65 {

    66    *destLen = ::MultiByteToWideChar(cp, 0,src, srclen, (LPWSTR)dest, *destLen);

    67    if(*destLen <= 0)

    68       fprintf(stderr, "problem in ::MultiByteToWideChar\n");

    69 }

    70 void msEncode(UINT cp, const char16_t *src,

    71               int32_t srcLen, char* dest, int32_t* destLen)

    72 {

    73    *destLen = ::WideCharToMultiByte(cp, 0, src, srcLen, (LPSTR)dest, *destLen,

    74                 (LPCSTR)" ", FALSE);

    75    if(*destLen <= 0)

    76       fprintf(stderr, "problem in ::WideCharToMultiByte\n");

    77 }

    79 int main(int argc, const char** argv)

    80 {

    81    nsresult res;

    82    nsCOMPtr<nsICharsetConverterManager> ccMain =

    83       do_GetService(NS_CHARSETCONVERTERMANAGER_CONTRACTID, &res);

    84    if(NS_FAILED(res))

    85    {

    86 	 fprintf(stderr, "Cannot get Character Converter Manager %x\n", res);

    87    }

    88    int i;

    89    if(argc > 5)

    90    {

    91      for(i =0; i < argc; i++)

    92      {

    93        if(strcmp(argv[i], "-f") == 0)

    94        {

    95              tocodeind = i+1;

    96              res = ccMain->GetUnicodeDecoder(argv[tocodeind], &decoder);

    97              if(NS_FAILED(res)) {

    98 	     	fprintf(stderr, "Cannot get Unicode decoder %s %x\n",

    99 			argv[tocodeind],res);

   100   		return -1;

   101 	     }

   103        }

   104        if(strcmp(argv[i], "-t") == 0)

   105        {

   106              fromcodeind = i+1;

   107              res = ccMain->GetUnicodeEncoderRaw(argv[fromcodeind], &encoder);

   108              if(NS_FAILED(res)) {

   109 	     	fprintf(stderr, "Cannot get Unicode encoder %s %x\n",

   110 			argv[fromcodeind],res);

   111   		return -1;

   112 	     }

   113        }

   114      }

   115      if(argc == 6)

   116      {

   117         infile = fopen(argv[5], "rb");

   118         if (!infile)

   119         {

   120            usage();

   121            fprintf(stderr,"cannot open file %s\n", argv[5]);

   122            return -1;

   123         }

   124      }

   125      else

   126      {

   127         infile = stdin;

   128      }

   130      int32_t insize,medsize,outsize;

   131      while((insize=fread(inbuffer, 1,INBUFSIZE,infile)) > 0)

   132      {

   133         medsize=MEDBUFSIZE;

   135 	res = decoder->Convert(inbuffer,&insize, medbuffer, &medsize);

   136         if(NS_FAILED(res)) {

   137             fprintf(stderr, "failed in decoder->Convert %x\n",res);

   138 	    return -1;

   139 	}

   140         outsize = OUTBUFSIZE;

   141 	res = encoder->Convert(medbuffer, &medsize, outbuffer,&outsize);

   142         if(NS_FAILED(res)) {

   143             fprintf(stderr, "failed in encoder->Convert %x\n",res);

   144 	    return -1;

   145 	}

   146         fwrite(outbuffer, 1, outsize, stdout);

   148         memcpyDecode(inbuffer, insize, outbuffer);

   150         memcpyEncode(inbuffer, insize, outbuffer);

   152         medsize = MEDBUFSIZE;

   153         msDecode(incp, inbuffer, insize, medbuffer, &medsize);

   155         outsize = OUTBUFSIZE;

   156         msEncode(outcp, medbuffer, medsize, outbuffer, &outsize);

   158         medsize = MEDBUFSIZE;

   159         WideDecode( inbuffer, insize, medbuffer, &medsize);

   161         outsize = OUTBUFSIZE;

   162         NarrowEncode( medbuffer, medsize, outbuffer, &outsize);

   163      }

   165      fclose(infile);

   166      fclose(stdout);

   167      fprintf(stderr, "Done!\n");

   168      return 0;

   169    }

   170    usage();

   171    return -1;

   172 }

The Tor Browser / file revision