Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
ichrcnv.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 78k
Category:

Windows Kernel

Development Platform:

Visual C++

ichrcnv.cpp：Code Content
  1. #include "private.h"
  2. #include "detcbase.h"
  3. #include "codepage.h"
  4. #include "detcjpn.h"
  5. #include "detckrn.h"
  6. #include "fechrcnv.h"
  7. #include "ichrcnv.h"
  8. #include "cpdetect.h"
  11. #define CONV_UU     12
  12. #define CONV_UUW    10
  13. #define CONV_UUWI   9
  14. #define CONV_UW     6
  15. #define CONV_UWI    5
  16. #define CONV_WI     3
  18. #define MAX_CHAR_SIZE   4
  20. #define MAPUSERDEF(x) (((x) == 50000) ? 1252 : (x))
  21. #define CONVERT_IS_VALIDCODEPAGE(x) (((x) == CP_USER_DEFINED) ? TRUE: IsValidCodePage(x))
  22. #define CONV_CHK_NLS 0x00000001
  24. struct ENCODINGINFO
  25. {
  26.     DWORD       dwEncoding;
  27.     DWORD       dwCodePage;
  28.     BYTE        bTypeUUIW;
  29.     CP_STATE    nCP_State ;                 // whether this is a valid windows codepage  ?
  30.     DWORD       dwFlags;                    // give us more flexibilities to handle different encodings differently
  31. };
  33. static WCHAR UniocdeSignature = { 0xFFFE } ;
  35. /*
  36.     Bit 4 (16) - Unicode <-> Internet Encoding
  37.     Bit 3 (8) - UTF8, UTF7
  38.     Bit 2 (4) - Unicode
  39.     Bit 1 (2) - Windows CodePage
  40.     Bit 0 (1) - Internet Encoding
  42.      P.S. if bit 4 is set, it means it should convert between Unicode and Internet
  43.      Encoding directly, no intermediate step - Windows CodePage
  44. */
  46. // these codepages including Unicode need special convertor
  47. static struct ENCODINGINFO aEncodingInfo[] =
  48. {
  50.     {  CP_JPN_SJ,            932,       0x02,   INVALID_CP,     0 }, // W-Japanese Shift JIS
  51.     {  CP_CHN_GB,            936,       0x02,   INVALID_CP,     0 }, // W-Simplified Chinese
  52.     {  CP_KOR_5601,          949,       0x02,   INVALID_CP,     0 }, // W-Krean Unified Hangul
  53.     {  CP_TWN,               950,       0x02,   INVALID_CP,     0 }, // W-Traditional Chinese
  54.     {  CP_UCS_2,               0,       0x04,   INVALID_CP,     0 }, // U-Unicode 
  55.     {  CP_UCS_2_BE,            0,       0x04,   INVALID_CP,     0 }, // U-Unicode Big Endian
  56.     {  CP_1252,             1252,       0x02,   INVALID_CP,     0 }, // W-Latin 1
  57.     {  CP_20127,            1252,       0x11,   INVALID_CP,     CONV_CHK_NLS }, // US ASCII
  58.     {  CP_ISO_8859_1,       1252,       0x11,   INVALID_CP,     CONV_CHK_NLS }, // I-ISO 8859-1 Latin 1 
  59.     {  CP_ISO_8859_15,      1252,       0x11,   INVALID_CP,     CONV_CHK_NLS }, // I-ISO 8859-1 Latin 1 
  60.     {  CP_AUTO,             1252,       0x01,   INVALID_CP,     0 }, // General auto detect 
  61.     {  CP_ISO_2022_JP,       932,       0x01,   INVALID_CP,     0 }, // I-ISO 2022-JP No Halfwidth Katakana 
  62.     {  CP_ISO_2022_JP_ESC,   932,       0x01,   INVALID_CP,     0 }, // I-ISO 2022-JP w/esc Halfwidth Katakana 
  63.     {  CP_ISO_2022_JP_SIO,   932,       0x01,   INVALID_CP,     0 }, // I-ISO 2022-JP w/sio Halfwidth Katakana 
  64.     {  CP_ISO_2022_KR,       949,       0x01,   INVALID_CP,     0 }, // I-ISO 2022-KR
  65.     {  CP_ISO_2022_TW,       950,       0x01,   INVALID_CP,     0 }, // I-ISO 2022-TW
  66.     {  CP_ISO_2022_CH,       936,       0x01,   INVALID_CP,     0 }, // I-ISO 2022-CH
  67.     {  CP_JP_AUTO,           932,       0x01,   INVALID_CP,     0 }, // JP auto detect 
  68.     {  CP_CHS_AUTO,          936,       0x01,   INVALID_CP,     0 }, // Simplified Chinese auto detect 
  69.     {  CP_KR_AUTO,           949,       0x01,   INVALID_CP,     0 }, // KR auto detect 
  70.     {  CP_CHT_AUTO,          950,       0x01,   INVALID_CP,     0 }, // Traditional Chinese auto detect 
  71.     {  CP_CYRILLIC_AUTO,    1251,       0x01,   INVALID_CP,     0 }, // Cyrillic auto detect 
  72.     {  CP_GREEK_AUTO,       1253,       0x01,   INVALID_CP,     0 }, // Greek auto detect 
  73.     {  CP_ARABIC_AUTO,      1256,       0x01,   INVALID_CP,     0 }, // Arabic auto detect 
  74.     {  CP_EUC_JP,            932,       0x01,   INVALID_CP,     0 }, // EUC Japanese 
  75.     {  CP_EUC_CH,            936,       0x01,   INVALID_CP,     0 }, // EUC Chinese 
  76.     {  CP_EUC_KR,            949,       0x01,   INVALID_CP,     0 }, // EUC Korean
  77.     {  CP_EUC_TW,            950,       0x01,   INVALID_CP,     0 }, // EUC Taiwanese 
  78.     {  CP_CHN_HZ,            936,       0x01,   INVALID_CP,     0 }, // Simplify Chinese HZ-GB 
  79.     {  CP_UTF_7,               0,       0x08,   INVALID_CP,     0 }, // U-UTF7 
  80.     {  CP_UTF_8,               0,       0x08,   INVALID_CP,     0 }, // U-UTF8 
  81. };
  84. // HTML name entity table for Latin-1 Supplement - from 0x00A0-0x00FF
  86. #define NAME_ENTITY_OFFSET  0x00A0
  87. #define NAME_ENTITY_MAX     0x00FF
  88. #define NAME_ENTITY_ENTRY   96
  90. static CHAR *g_lpstrNameEntity[NAME_ENTITY_ENTRY] =
  91. {
  92.     "&nbsp;",   // "&#160;" -- no-break space = non-breaking space,
  93.     "&iexcl;",  // "&#161;" -- inverted exclamation mark, U+00A1 ISOnum -->
  94.     "&cent;",   // "&#162;" -- cent sign, U+00A2 ISOnum -->
  95.     "&pound;",  // "&#163;" -- pound sign, U+00A3 ISOnum -->
  96.     "&curren;", // "&#164;" -- currency sign, U+00A4 ISOnum -->
  97.     "&yen;",    // "&#165;" -- yen sign = yuan sign, U+00A5 ISOnum -->
  98.     "&brvbar;", // "&#166;" -- broken bar = broken vertical bar,
  99.     "&sect;",   // "&#167;" -- section sign, U+00A7 ISOnum -->
  100.     "&uml;",    // "&#168;" -- diaeresis = spacing diaeresis,
  101.     "&copy;",   // "&#169;" -- copyright sign, U+00A9 ISOnum -->
  102.     "&ordf;",   // "&#170;" -- feminine ordinal indicator, U+00AA ISOnum -->
  103.     "&laquo;",  // "&#171;" -- left-pointing double angle quotation mark
  104.     "&not;",    // "&#172;" -- not sign = discretionary hyphen,
  105.     "&shy;",    // "&#173;" -- soft hyphen = discretionary hyphen,
  106.     "&reg;",    // "&#174;" -- registered sign = registered trade mark sign,
  107.     "&macr;",   // "&#175;" -- macron = spacing macron = overline
  108.     "&deg;",    // "&#176;" -- degree sign, U+00B0 ISOnum -->
  109.     "&plusmn;", // "&#177;" -- plus-minus sign = plus-or-minus sign,
  110.     "&sup2;",   // "&#178;" -- superscript two = superscript digit two
  111.     "&sup3;",   // "&#179;" -- superscript three = superscript digit three
  112.     "&acute;",  // "&#180;" -- acute accent = spacing acute,
  113.     "&micro;",  // "&#181;" -- micro sign, U+00B5 ISOnum -->
  114.     "&para;",   // "&#182;" -- pilcrow sign = paragraph sign,
  115.     "&middot;", // "&#183;" -- middle dot = Georgian comma
  116.     "&cedil;",  // "&#184;" -- cedilla = spacing cedilla, U+00B8 ISOdia -->
  117.     "&sup1;",   // "&#185;" -- superscript one = superscript digit one,
  118.     "&ordm;",   // "&#186;" -- masculine ordinal indicator,
  119.     "&raquo;",  // "&#187;" -- right-pointing double angle quotation mark
  120.     "&frac14;", // "&#188;" -- vulgar fraction one quarter
  121.     "&frac12;", // "&#189;" -- vulgar fraction one half
  122.     "&frac34;", // "&#190;" -- vulgar fraction three quarters
  123.     "&iquest;", // "&#191;" -- inverted question mark
  124.     "&Agrave;", // "&#192;" -- latin capital letter A with grave
  125.     "&Aacute;", // "&#193;" -- latin capital letter A with acute,
  126.     "&Acirc;",  // "&#194;" -- latin capital letter A with circumflex,
  127.     "&Atilde;", // "&#195;" -- latin capital letter A with tilde,
  128.     "&Auml;",   // "&#196;" -- latin capital letter A with diaeresis,
  129.     "&Aring;",  // "&#197;" -- latin capital letter A with ring above
  130.     "&AElig;",  // "&#198;" -- latin capital letter AE
  131.     "&Ccedil;", // "&#199;" -- latin capital letter C with cedilla,
  132.     "&Egrave;", // "&#200;" -- latin capital letter E with grave,
  133.     "&Eacute;", // "&#201;" -- latin capital letter E with acute,
  134.     "&Ecirc;",  // "&#202;" -- latin capital letter E with circumflex,
  135.     "&Euml;",   // "&#203;" -- latin capital letter E with diaeresis,
  136.     "&Igrave;", // "&#204;" -- latin capital letter I with grave,
  137.     "&Iacute;", // "&#205;" -- latin capital letter I with acute,
  138.     "&Icirc;",  // "&#206;" -- latin capital letter I with circumflex,
  139.     "&Iuml;",   // "&#207;" -- latin capital letter I with diaeresis,
  140.     "&ETH;",    // "&#208;" -- latin capital letter ETH, U+00D0 ISOlat1 -->
  141.     "&Ntilde;", // "&#209;" -- latin capital letter N with tilde,
  142.     "&Ograve;", // "&#210;" -- latin capital letter O with grave,
  143.     "&Oacute;", // "&#211;" -- latin capital letter O with acute,
  144.     "&Ocirc;",  // "&#212;" -- latin capital letter O with circumflex,
  145.     "&Otilde;", // "&#213;" -- latin capital letter O with tilde,
  146.     "&Ouml;",   // "&#214;" -- latin capital letter O with diaeresis,
  147.     "&times;",  // "&#215;" -- multiplication sign, U+00D7 ISOnum -->
  148.     "&Oslash;", // "&#216;" -- latin capital letter O with stroke
  149.     "&Ugrave;", // "&#217;" -- latin capital letter U with grave,
  150.     "&Uacute;", // "&#218;" -- latin capital letter U with acute,
  151.     "&Ucirc;",  // "&#219;" -- latin capital letter U with circumflex,
  152.     "&Uuml;",   // "&#220;" -- latin capital letter U with diaeresis,
  153.     "&Yacute;", // "&#221;" -- latin capital letter Y with acute,
  154.     "&THORN;",  // "&#222;" -- latin capital letter THORN,
  155.     "&szlig;",  // "&#223;" -- latin small letter sharp s = ess-zed,
  156.     "&agrave;", // "&#224;" -- latin small letter a with grave
  157.     "&aacute;", // "&#225;" -- latin small letter a with acute,
  158.     "&acirc;",  // "&#226;" -- latin small letter a with circumflex,
  159.     "&atilde;", // "&#227;" -- latin small letter a with tilde,
  160.     "&auml;",   // "&#228;" -- latin small letter a with diaeresis,
  161.     "&aring;",  // "&#229;" -- latin small letter a with ring above
  162.     "&aelig;",  // "&#230;" -- latin small letter ae
  163.     "&ccedil;", // "&#231;" -- latin small letter c with cedilla,
  164.     "&egrave;", // "&#232;" -- latin small letter e with grave,
  165.     "&eacute;", // "&#233;" -- latin small letter e with acute,
  166.     "&ecirc;",  // "&#234;" -- latin small letter e with circumflex,
  167.     "&euml;",   // "&#235;" -- latin small letter e with diaeresis,
  168.     "&igrave;", // "&#236;" -- latin small letter i with grave,
  169.     "&iacute;", // "&#237;" -- latin small letter i with acute,
  170.     "&icirc;",  // "&#238;" -- latin small letter i with circumflex,
  171.     "&iuml;",   // "&#239;" -- latin small letter i with diaeresis,
  172.     "&eth;",    // "&#240;" -- latin small letter eth, U+00F0 ISOlat1 -->
  173.     "&ntilde;", // "&#241;" -- latin small letter n with tilde,
  174.     "&ograve;", // "&#242;" -- latin small letter o with grave,
  175.     "&oacute;", // "&#243;" -- latin small letter o with acute,
  176.     "&ocirc;",  // "&#244;" -- latin small letter o with circumflex,
  177.     "&otilde;", // "&#245;" -- latin small letter o with tilde,
  178.     "&ouml;",   // "&#246;" -- latin small letter o with diaeresis,
  179.     "&divide;", // "&#247;" -- division sign, U+00F7 ISOnum -->
  180.     "&oslash;", // "&#248;" -- latin small letter o with stroke,
  181.     "&ugrave;", // "&#249;" -- latin small letter u with grave,
  182.     "&uacute;", // "&#250;" -- latin small letter u with acute,
  183.     "&ucirc;",  // "&#251;" -- latin small letter u with circumflex,
  184.     "&uuml;",   // "&#252;" -- latin small letter u with diaeresis,
  185.     "&yacute;", // "&#253;" -- latin small letter y with acute,
  186.     "&thorn;",  // "&#254;" -- latin small letter thorn with,
  187.     "&yuml;",   // "&#255;" -- latin small letter y with diaeresis,
  188. };
  191. #ifdef MORE_NAME_ENTITY   // in case we decide to do more name entity latter
  192. // Additional HTML 4.0 name entity table for CP 1252 extension character set
  193. #define CP1252EXT_BASE  (UINT)0x0080
  194. #define CP1252EXT_MAX   (UINT)0x009F
  195. #define NONUNI          0xFFFF
  196. #define UNDEFCHAR       "???????"
  197. #define CP1252EXT_NCR_SIZE  7
  199. struct NAME_ENTITY_EXT
  200. {
  201.     UWORD     uwUniCode;
  202.     LPCTSTR   lpszNameEntity;
  203. };
  205. static struct NAME_ENTITY_EXT aNameEntityExt[] =
  206. {
  207. //      UniCode  NCR_Enty          Name_Enty        CP1252Ext  Comment
  208.     {   0x20AC,  "&#8364;"  },  // "&euro;"    },  // &#128;  #EURO SIGN
  209. //  {   NONUNI,  UNDEFCHAR  },  // "&;"        },  // &#129;  #UNDEFINED
  210.     {   0x201A,  "&#8218;"  },  // "&sbquo;"   },  // &#130;  #SINGLE LOW-9 QUOTATION MARK
  211.     {   0x0192,  "&#0402;"  },  // "&fnof;"    },  // &#131;  #LATIN SMALL LETTER F WITH HOOK
  212.     {   0x201E,  "&#8222;"  },  // "&bdquo;"   },  // &#132;  #DOUBLE LOW-9 QUOTATION MARK
  213.     {   0x2026,  "&#8230;"  },  // "&hellip;"  },  // &#133;  #HORIZONTAL ELLIPSIS
  214.     {   0x2020,  "&#8224;"  },  // "&dagger;"  },  // &#134;  #DAGGER
  215.     {   0x2021,  "&#8225;"  },  // "&Dagger;"  },  // &#135;  #DOUBLE DAGGER
  216.     {   0x02C6,  "&#0710;"  },  // "&circ;"    },  // &#136;  #MODIFIER LETTER CIRCUMFLEX ACCENT
  217.     {   0x2030,  "&#8240;"  },  // "&permil;"  },  // &#137;  #PER MILLE SIGN
  218.     {   0x0160,  "&#0352;"  },  // "&Scaron;"  },  // &#138;  #LATIN CAPITAL LETTER S WITH CARON
  219.     {   0x2039,  "&#8249;"  },  // "&lsaquo;"  },  // &#139;  #SINGLE LEFT-POINTING ANGLE QUOTATION MARK
  220.     {   0x0152,  "&#0338;"  },  // "&OElig;"   },  // &#140;  #LATIN CAPITAL LIGATURE OE
  221. //  {   NONUNI,  UNDEFCHAR  },  // "&;"        },  // &#141;  #UNDEFINED
  222.     {   0x017D,  "&#0381;"  },  // "&;"        },  // &#142;  #LATIN CAPITAL LETTER Z WITH CARON, ***no name entity defined in HTML 4.0***
  223. //  {   NONUNI,  UNDEFCHAR  },  // "&;"        },  // &#143;  #UNDEFINED
  224. //  {   NONUNI,  UNDEFCHAR  },  // "&;"        },  // &#144;  #UNDEFINED
  225.     {   0x2018,  "&#8216;"  },  // "&lsquo;"   },  // &#145;  #LEFT SINGLE QUOTATION MARK
  226.     {   0x2019,  "&#8217;"  },  // "&rsquo;"   },  // &#146;  #RIGHT SINGLE QUOTATION MARK
  227.     {   0x201C,  "&#8220;"  },  // "&ldquo;"   },  // &#147;  #LEFT DOUBLE QUOTATION MARK
  228.     {   0x201D,  "&#8221;"  },  // "&rdquo;"   },  // &#148;  #RIGHT DOUBLE QUOTATION MARK
  229.     {   0x2022,  "&#8226;"  },  // "&bull;"    },  // &#149;  #BULLET
  230.     {   0x2013,  "&#8211;"  },  // "&ndash;"   },  // &#150;  #EN DASH
  231.     {   0x2014,  "&#8212;"  },  // "&mdash;"   },  // &#151;  #EM DASH
  232.     {   0x20DC,  "&#0732;"  },  // "&tilde;"   },  // &#152;  #SMALL TILDE
  233.     {   0x2122,  "&#8482;"  },  // "&trade;"   },  // &#153;  #TRADE MARK SIGN
  234.     {   0x0161,  "&#0353;"  },  // "&scaron;"  },  // &#154;  #LATIN SMALL LETTER S WITH CARON
  235.     {   0x203A,  "&#8250;"  },  // "&rsaquo;"  },  // &#155;  #SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
  236.     {   0x0153,  "&#0339;"  },  // "&oelig;"   },  // &#156;  #LATIN SMALL LIGATURE OE
  237. //  {   NONUNI,  UNDEFCHAR  },  // "&;"        },  // &#157;  #UNDEFINED
  238.     {   0x017E,  "&#0382;"  },  // "&;"        },  // &#158;  #LATIN SMALL LETTER Z WITH CARON, ***no name entity defined in HTML 4.0***
  239.     {   0x0178,  "&#0376;"  },  // "&Yuml;"    },  // &#159;  #LATIN CAPITAL LETTER Y WITH DIAERESIS
  240. };
  241. #endif
  244. HRESULT WINAPI DoConvertINetString(LPDWORD lpdwMode, BOOL fInbound, UINT uCodePage, int nCodeSet, LPCSTR lpSrcStr, LPINT lpnSrcSize, LPSTR lpDestStr, int cchDest, LPINT lpnSize);
  247. /******************************************************************************
  248. *****************************   U T I L I T I E S   ***************************
  249. ******************************************************************************/
  250. void DataByteSwap(LPSTR DataBuf, int len )
  251. {
  252.     int i ;
  253.     UCHAR tmpData ;
  255.     if ( len )
  256.         for ( i = 0 ; i < len-1 ; i+=2 )
  257.         {
  258.             tmpData = DataBuf[i] ;
  259.             DataBuf[i] = DataBuf[i+1] ;
  260.             DataBuf[i+1] = tmpData ;
  261.         }
  263.     return ;
  264. }
  266. void CheckUnicodeDataType(DWORD dwDstEncoding, LPSTR DataBuf, int len )
  267. {
  268.     
  269.     if ( DataBuf && len )
  270.     {
  271.         if ( dwDstEncoding == CP_UCS_2_BE )
  272.             DataByteSwap(DataBuf,len);
  273.     }
  274.     return ;
  275. }
  277. /******************************************************************************
  278. ******************   C O N V E R T   I N E T   S T R I N G   ******************
  279. ******************************************************************************/
  280. HRESULT CICharConverter::UnicodeToMultiByteEncoding(DWORD dwDstEncoding, LPCSTR lpSrcStr, LPINT lpnSrcSize,
  281.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  282. {
  284.     int nBuffSize = 0, i ;
  285.     BOOL UseDefChar = FALSE ;
  286.     LPSTR lpDefFallBack = NULL ;
  287.     UCHAR DefaultCharBuff[3]; // possible DBCS + null    
  288.     HRESULT hr = E_FAIL;
  289.     int _nDstSize = *lpnDstSize;    
  291.     if ( _dwUnicodeEncoding == CP_UCS_2_BE && _cvt_count == 0 )
  292.     {
  293.        if ( _lpUnicodeStr = (LPSTR)LocalAlloc(LPTR, *lpnSrcSize ) )
  294.        {
  295.           MoveMemory(_lpUnicodeStr, lpSrcStr, *lpnSrcSize ) ;
  296.           lpSrcStr = _lpUnicodeStr ;
  297.        }
  298.        else
  299.        {
  300.           hr = E_OUTOFMEMORY;
  301.           goto EXIT;
  302.        }
  303.     }
  305.     CheckUnicodeDataType(_dwUnicodeEncoding, (LPSTR) lpSrcStr, *lpnSrcSize);
  307.     if ( *lpnSrcSize )
  308.         nBuffSize = *lpnSrcSize / sizeof(WCHAR);
  310.     // We force to use MLang NO_BEST_FIT_CHAR check on ISCII encoding since system don't accept default chars
  311.     if (IS_ISCII_CP(dwDstEncoding) && (dwFlag & MLCONVCHARF_USEDEFCHAR))
  312.         dwFlag |= MLCONVCHARF_NOBESTFITCHARS;
  314.     if ( lpFallBack && ( dwFlag & MLCONVCHARF_USEDEFCHAR ))
  315.     {
  316.         // only take SBCS, no DBCS character
  317.         if ( 1 == WideCharToMultiByte(MAPUSERDEF(dwDstEncoding), 0,
  318.                                (LPCWSTR)lpFallBack, 1,
  319.                                (LPSTR)DefaultCharBuff, sizeof(DefaultCharBuff), NULL, NULL ))
  320.             lpDefFallBack = (LPSTR) DefaultCharBuff;        
  321.     }
  323.     if(!(*lpnDstSize = WideCharToMultiByte(MAPUSERDEF(dwDstEncoding), 0,
  324.                                            (LPCWSTR)lpSrcStr, nBuffSize,
  325.                                            lpDstStr, *lpnDstSize, IS_ISCII_CP(dwDstEncoding)? NULL:(LPCSTR)lpDefFallBack, IS_ISCII_CP(dwDstEncoding)? NULL:&UseDefChar)))
  326.     {
  327.         hr = E_FAIL;
  328.         goto EXIT;
  329.     }
  331.     if ( !_cvt_count ) // save SrcSize if it is the first time conversion
  332.         _nSrcSize = nBuffSize * sizeof(WCHAR);
  334.     if (*lpnDstSize)
  335.     {
  336.         if (dwFlag & ( MLCONVCHARF_NCR_ENTITIZE | MLCONVCHARF_NAME_ENTITIZE | MLCONVCHARF_NOBESTFITCHARS ))
  337.         {
  338.             char    *lpDstStrTmp = lpDstStr;
  339.             WCHAR   *lpwStrTmp = NULL;
  340.             WCHAR   *lpwStrTmpSave = NULL;
  341.             char    *lpDstStrTmp2 = NULL;
  342.             char    *lpDstStrTmp2Save = NULL;
  343.             int     cCount, ConvCount = 0, nCount = 0;
  344.             WCHAR   *lpwSrcStrTmp = (WCHAR *)lpSrcStr;
  345.             int     *lpBCharOffset = NULL;
  346.             int     *lpBCharOffsetSave = NULL;
  348.             if (!(lpwStrTmpSave = lpwStrTmp = (WCHAR *)LocalAlloc(LPTR, _nSrcSize)))
  349.             {
  350.                 hr = E_OUTOFMEMORY;
  351.                 goto ENTITIZE_DONE;
  352.             }
  354.             // Make sure we have real converted buffer to check BEST_FIT_CHAR and DEFAULT_CHAR
  355.             if (!_nDstSize)
  356.             {
  357.                 lpDstStrTmp2Save = lpDstStrTmp2 = (char *)LocalAlloc(LPTR, *lpnDstSize);
  358.                 if (lpDstStrTmp2)
  359.                 {
  360.                     WideCharToMultiByte(MAPUSERDEF(dwDstEncoding), 0,
  361.                                (LPCWSTR)lpSrcStr, nBuffSize,
  362.                                lpDstStrTmp2, *lpnDstSize, NULL, NULL );
  363.                 }
  364.                 else
  365.                 {
  366.                     hr = E_OUTOFMEMORY;
  367.                     goto ENTITIZE_DONE;
  368.                 }
  369.             }
  371. //BUGBUG: dest. buffer size is too big
  372.             if (nBuffSize == 
  373.                 MultiByteToWideChar(MAPUSERDEF(dwDstEncoding), 0, _nDstSize? lpDstStr : lpDstStrTmp2, *lpnDstSize, lpwStrTmp, _nSrcSize))
  374.             {
  375.                 // Pre scan to get number of best fit chars.
  376.                 for (i=0; i<nBuffSize; i++)
  377.                 {
  378.                     // make special case for ?(yen sign) in Shift-JIS
  379.                     if (*lpwStrTmp++ != *lpwSrcStrTmp++)
  380.                     {
  381.                         if ((dwDstEncoding == CP_JPN_SJ) && (*(lpwSrcStrTmp - 1) == 0x00A5))
  382.                             *(lpwStrTmp - 1) = 0x00A5;
  383.                         else
  384.                             nCount ++;
  385.                     }
  386.                 }
  388.                 lpwSrcStrTmp -= nBuffSize;
  389.                 lpwStrTmp -= nBuffSize;
  391.                 if (nCount)
  392.                 {
  393.                     int j = 0;
  395.                     if (!(dwFlag & ( MLCONVCHARF_NCR_ENTITIZE | MLCONVCHARF_NAME_ENTITIZE | MLCONVCHARF_USEDEFCHAR)))
  396.                     {
  397.                         hr = E_FAIL;
  398.                         goto ENTITIZE_DONE;
  399.                     }
  401.                     if (!(lpBCharOffsetSave = lpBCharOffset = (int *) LocalAlloc(LPTR, nCount*sizeof(int))))
  402.                     {
  403.                         hr = E_OUTOFMEMORY;
  404.                         goto ENTITIZE_DONE;
  405.                     }
  407.                     // Record the offset position of each best fit char.
  408.                     for (i=0; i<nBuffSize; i++)
  409.                     {
  410.                         if (*lpwStrTmp++ != *lpwSrcStrTmp++)
  411.                         {
  412.                             *lpBCharOffset = i-j;
  413.                             lpBCharOffset++;
  414.                             j = i+1;
  415.                         }
  416.                     }
  418.                     lpBCharOffset -= nCount;
  419.                     lpwSrcStrTmp -= nBuffSize;
  420.                     lpwStrTmp -= nBuffSize;
  422.                     for (i=0; i<nCount; i++)
  423.                     {
  424.                         BOOL bIsSurrogatePair = FALSE;
  426.                         if (*lpBCharOffset)
  427.                         {
  428. //BUGBUG: dest. buffer size is too big
  429.                             cCount = WideCharToMultiByte(MAPUSERDEF(dwDstEncoding), 0,
  430.                                    (LPCWSTR)lpwSrcStrTmp, *lpBCharOffset,
  431.                                    lpDstStrTmp,  _nDstSize ? (*lpBCharOffset)*2 : 0, NULL, NULL );
  433.                             ConvCount += cCount;
  434.                             if (_nDstSize)
  435.                             {
  436.                                 lpDstStrTmp += cCount;
  437.                             }
  438.                             lpwSrcStrTmp += *lpBCharOffset;
  439.                         }
  441.                         BOOL fConverted = FALSE;
  443.                         // check if unconvertable character falls in NAME ENTITY area
  444.                         if (dwFlag & MLCONVCHARF_NAME_ENTITIZE)
  445.                         {
  446.                             // for beta2, make assmption that name entity implys NCR.
  447.                             dwFlag |= MLCONVCHARF_NCR_ENTITIZE;
  449. #ifdef MORE_NAME_ENTITY   // in case we decide do more name entity latter
  450.                             BOOL      fDoNEnty = FALSE;
  451.                             LPCTSTR   lpszNEnty = NULL;
  453.                             // check if character is in the Latin-1 Supplement range
  454.                             if ((*lpwSrcStrTmp >= NAME_ENTITY_OFFSET) && (*lpwSrcStrTmp <= NAME_ENTITY_MAX ))
  455.                             {
  456.                                 fDoNEnty = TRUE;
  457.                                 lpszNEnty = g_lpstrNameEntity[(*lpwSrcStrTmp) - NAME_ENTITY_OFFSET];
  458.                             }
  460.                             // check if character is in the additional name entity table for CP 1252 extension
  461.                             if (!fDoNEnty)
  462.                             {
  463.                                 for (int idx = 0; idx < ARRAYSIZE(aNameEntityExt); idx++)
  464.                                     if (*lpwSrcStrTmp == aNameEntityExt[idx].uwUniCode)
  465.                                     {
  466.                                         fDoNEnty = TRUE;
  467.                                         lpszNEnty = aNameEntityExt[idx].lpszNameEntity;
  468.                                         break;
  469.                                     }
  470.                             }
  472.                             if (fDoNEnty)
  473.                             {
  474.                                 cCount = lstrlenA(lpszNEnty);
  475.                                 if (_nDstSize)
  476.                                 {
  477.                                     CopyMemory(lpDstStrTmp, lpszNEnty, cCount);
  478.                                     lpDstStrTmp += cCount ;
  479.                                 }
  481.                                 ConvCount += cCount;
  482.                                 fConverted = TRUE;
  483.                             }
  484. #else
  485.                             // check if character is in the Latin-1 Supplement range
  486.                             if ((*lpwSrcStrTmp >= NAME_ENTITY_OFFSET)
  487.                                 && (*lpwSrcStrTmp < ARRAYSIZE(g_lpstrNameEntity)+NAME_ENTITY_OFFSET))
  488.                                 
  489.                             {
  490.                                 LPCTSTR   lpszNEnty = NULL;
  492.                                 if (!(lpszNEnty = g_lpstrNameEntity[(*lpwSrcStrTmp) - NAME_ENTITY_OFFSET]))
  493.                                 {
  494. #ifdef DEBUG
  495.                                     AssertMsg((BOOL)FALSE, "Name entity table broken"); 
  496. #endif
  497.                                     hr = E_FAIL;
  498.                                     goto ENTITIZE_DONE;
  499.                                 }
  501.                                     cCount = lstrlenA(lpszNEnty);
  502.                                     if (_nDstSize)
  503.                                     {
  504.                                         CopyMemory(lpDstStrTmp, lpszNEnty, cCount);
  505.                                         lpDstStrTmp += cCount ;
  506.                                     }
  507.                                 
  508.                                 ConvCount += cCount;
  509.                                 fConverted = TRUE;
  510.                             }
  511. #endif
  512.                         }
  514.                         // check if NCR requested
  515.                         if ((!fConverted) && (dwFlag & MLCONVCHARF_NCR_ENTITIZE))
  516.                         {
  517.                             if ((nCount-i >= 2) &&
  518.                                 (*lpwSrcStrTmp >= 0xD800 && *lpwSrcStrTmp <= 0xDBFF) &&
  519.                                 (*(lpwSrcStrTmp+1) >= 0xDC00 && *(lpwSrcStrTmp+1) <= 0xDFFF))
  520.                                 bIsSurrogatePair = TRUE;
  521.                             else
  522.                                 bIsSurrogatePair = FALSE;
  523.                           
  524.                             if (_nDstSize)
  525.                             {
  526.                                 lpDstStrTmp[0] = '&' ;
  527.                                 lpDstStrTmp[1] = '#' ;
  528.                                 lpDstStrTmp += 2 ;
  529.                                 // If it is a Unicode surrogates pair, we convert it to real Unicode value
  530.                                 if (bIsSurrogatePair)
  531.                                 {
  532.                                     DWORD dwUnicode = ((*lpwSrcStrTmp - 0xD800) << 10) + *(lpwSrcStrTmp+1) - 0xDC00 + 0x10000;
  533.                                     _ultoa( dwUnicode, (char*)lpDstStrTmp, 10);
  534.                                 }
  535.                                 else
  536.                                     _ultoa( *lpwSrcStrTmp, (char*)lpDstStrTmp, 10);
  537.                                 cCount = lstrlenA(lpDstStrTmp);
  538.                                 lpDstStrTmp += cCount;
  539.                                 ConvCount += cCount;
  540.                                 *(lpDstStrTmp++) = ';' ;
  541.                             }
  542.                             else
  543.                             {
  544.                                 char szTmpString[10];
  545.                                 if (bIsSurrogatePair)
  546.                                 {
  547.                                     DWORD dwUnicode = ((*lpwSrcStrTmp - 0xD800) << 10) + *(lpwSrcStrTmp+1) - 0xDC00 + 0x10000;
  548.                                     _ultoa( dwUnicode, szTmpString, 10);
  549.                                 }
  550.                                 else
  551.                                     _ultoa( *lpwSrcStrTmp, szTmpString, 10);
  552.                                 ConvCount += lstrlenA(szTmpString);
  553.                             }
  554.                         
  555.                             fConverted = TRUE;
  556.                             ConvCount += 3;                    
  557.                         }
  559.                         // handle MLCONVCHARF_USEDEFCHAR here - less priority and default method
  560.                         if (!fConverted)
  561.                         {
  562.                             if (_nDstSize)
  563.                             {
  564.                                 *lpDstStrTmp = lpDefFallBack ? *lpDefFallBack : '?';
  565.                                 lpDstStrTmp++;
  566.                             }
  568.                             ConvCount++;
  569.                             if (!UseDefChar)
  570.                                 UseDefChar = TRUE;
  571.                         }
  573.                         lpBCharOffset++;
  574.                         lpwSrcStrTmp++;
  575.                         // Skip next character if it is a Unicode surrogates pair
  576.                         if (bIsSurrogatePair)
  577.                         {
  578.                             lpBCharOffset++;
  579.                             lpwSrcStrTmp++;
  580.                             i++;
  581.                         }
  582.                     }
  583.                     lpBCharOffset -= nCount ;
  584.                 }
  586.                 int nRemain = (*lpnSrcSize - (int)((char*)lpwSrcStrTmp - (char *)lpSrcStr))/sizeof(WCHAR);
  588. //BUGBUG: dest. buffer size is too big
  589.                 ConvCount += WideCharToMultiByte(MAPUSERDEF(dwDstEncoding), 0,
  590.                                    (LPCWSTR)lpwSrcStrTmp, nRemain,
  591.                                    lpDstStrTmp, _nDstSize ? nRemain*2 : 0, NULL, NULL );
  593.                 *lpnDstSize = ConvCount ;
  595.                 hr = S_OK;
  596.             } 
  597.             else
  598.             {
  599.                 hr = E_FAIL;
  600.             }
  602. ENTITIZE_DONE:
  603.             if (lpwStrTmpSave)
  604.                 LocalFree(lpwStrTmpSave);
  605.             if (lpDstStrTmp2Save)
  606.                 LocalFree(lpDstStrTmp2Save);
  607.             if (lpBCharOffsetSave)
  608.                 LocalFree(lpBCharOffsetSave);
  609.         }
  610.         else
  611.         {
  612.             hr = S_OK;
  613.         }       
  615.         if (S_OK == hr && UseDefChar)
  616.             hr = S_FALSE;
  617.     }
  618.     else
  619.     {
  620.         hr = E_FAIL;
  621.     }
  623. EXIT:
  624.     return hr;
  625. }
  627. HRESULT CICharConverter::UTF78ToUnicode(LPDWORD lpdwMode, LPCSTR lpSrcStr, LPINT lpnSrcSize,
  628.     LPSTR lpDstStr, LPINT lpnDstSize)
  629. {
  630.     HRESULT hr ;
  632.     hr = DoConvertINetString(lpdwMode, TRUE, CP_UCS_2, _dwUTFEncoding, lpSrcStr, lpnSrcSize, lpDstStr, *lpnDstSize, lpnDstSize);
  634.     if ( !_cvt_count ) // save SrcSize if it is the first time conversion
  635.         _nSrcSize = *lpnSrcSize ;
  637.     CheckUnicodeDataType(_dwUnicodeEncoding, lpDstStr, *lpnDstSize);
  639.     return hr ;
  640. }
  642. HRESULT CICharConverter::UnicodeToUTF78(LPDWORD lpdwMode, LPCSTR lpSrcStr, LPINT lpnSrcSize,
  643.     LPSTR lpDstStr, LPINT lpnDstSize)
  644. {
  645.     HRESULT hr ;
  647.     if ( _dwUnicodeEncoding == CP_UCS_2_BE && _cvt_count == 0 )
  648.     {
  649.        if ( _lpUnicodeStr = (LPSTR)LocalAlloc(LPTR, *lpnSrcSize ) )
  650.        {
  651.           MoveMemory(_lpUnicodeStr, lpSrcStr, *lpnSrcSize ) ;
  652.           lpSrcStr = _lpUnicodeStr ;
  653.        }
  654.        else
  655.         return E_OUTOFMEMORY ;
  656.     }
  658.     CheckUnicodeDataType(_dwUnicodeEncoding, (LPSTR) lpSrcStr, *lpnSrcSize);
  660.     hr = DoConvertINetString(lpdwMode, FALSE, CP_UCS_2, _dwUTFEncoding, lpSrcStr, lpnSrcSize, lpDstStr, *lpnDstSize, lpnDstSize);
  661.     if ( !_cvt_count ) // save SrcSize if it is the first time conversion
  662.         _nSrcSize = *lpnSrcSize ;
  665.     return hr ;
  666. }
  668. HRESULT CICharConverter::UnicodeToWindowsCodePage(LPCSTR lpSrcStr, LPINT lpnSrcSize,
  669.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  670. {
  671.     HRESULT hr ;
  673.     hr = UnicodeToMultiByteEncoding(_dwWinCodePage,lpSrcStr,lpnSrcSize,lpDstStr,lpnDstSize,dwFlag,lpFallBack);
  675.     return hr ;
  676. }
  678. HRESULT CICharConverter::UnicodeToInternetEncoding(LPCSTR lpSrcStr, LPINT lpnSrcSize,
  679.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  680. {
  681.     HRESULT hr ;
  683.     hr = UnicodeToMultiByteEncoding(_dwInternetEncoding,lpSrcStr,lpnSrcSize,lpDstStr,lpnDstSize,dwFlag,lpFallBack);
  685.     return hr ;
  686. }
  688. HRESULT CICharConverter::InternetEncodingToUnicode(LPCSTR lpSrcStr, LPINT lpnSrcSize,
  689.     LPSTR lpDstStr, LPINT lpnDstSize)
  690. {
  691.     int cch = 0 ;
  692.     int cb = *lpnSrcSize;
  694.     if ( !_cvt_count )
  695.     {
  696.         // If we have a multibyte character encoding, we are at risk of splitting
  697.         // some characters at the read boundary.  We must Make sure we have a
  698.         // discrete number of characters first.
  700.         UINT uMax = MAX_CHAR_SIZE ;
  701.         cb++; // pre-increment
  702.         do
  703.         {
  704.             cch = MultiByteToWideChar( MAPUSERDEF(_dwInternetEncoding),
  705.                                         MB_ERR_INVALID_CHARS | MB_PRECOMPOSED,
  706.                                         lpSrcStr, --cb,
  707.                                         NULL, 0 );
  708.             --uMax;
  709.         } while (!cch && uMax && cb);
  710.     }
  712.     if ( cb == (*lpnSrcSize - MAX_CHAR_SIZE +1 ))  // if conversion problem isn't at the end of the string
  713.         cb = *lpnSrcSize ; // restore orginal value
  715.     *lpnDstSize = MultiByteToWideChar( MAPUSERDEF(_dwInternetEncoding), 0,
  716.                                lpSrcStr, cb,
  717.                                (LPWSTR)lpDstStr, *lpnDstSize/sizeof(WCHAR) );
  718.     *lpnDstSize = *lpnDstSize * sizeof(WCHAR);
  719.     if ( !_cvt_count ) // save SrcSize if it is the first time conversion
  720.         _nSrcSize = cb ;
  722.     CheckUnicodeDataType(_dwUnicodeEncoding, lpDstStr, *lpnDstSize);
  724.     if (*lpnDstSize==0 && cb)
  725.         return E_FAIL ;
  726.     else
  727.         return S_OK ;
  728. }
  730. HRESULT CICharConverter::WindowsCodePageToUnicode(LPCSTR lpSrcStr, LPINT lpnSrcSize,
  731.     LPSTR lpDstStr, LPINT lpnDstSize)
  732. {
  734.     int cch = 0 ;
  735.     int cb = *lpnSrcSize;
  737.     if ( !_cvt_count )
  738.     {
  739.         UINT uMax = MAX_CHAR_SIZE ;
  740.         cb++; // pre-increment
  741.         do
  742.         {
  743.             cch = MultiByteToWideChar( MAPUSERDEF(_dwWinCodePage),
  744.                                         MB_ERR_INVALID_CHARS | MB_PRECOMPOSED,
  745.                                         lpSrcStr, --cb,
  746.                                         NULL, 0 );
  747.             --uMax;
  748.         } while (!cch && uMax && cb);
  749.     }
  751.     if ( cb == (*lpnSrcSize - MAX_CHAR_SIZE +1 ))  // if conversion problem isn't at the end of the string
  752.         cb = *lpnSrcSize ; // restore orginal value
  754.     *lpnDstSize = MultiByteToWideChar( MAPUSERDEF(_dwWinCodePage), 0,
  755.                                lpSrcStr, cb,
  756.                                (LPWSTR)lpDstStr, *lpnDstSize/sizeof(WCHAR) );
  757.     *lpnDstSize = *lpnDstSize * sizeof(WCHAR);
  758.     if ( !_cvt_count ) // save SrcSize if it is the first time conversion
  759.         _nSrcSize = cb ;
  761.     CheckUnicodeDataType(_dwUnicodeEncoding, lpDstStr, *lpnDstSize);
  763.     if (*lpnDstSize==0 && cb)
  764.         return E_FAIL ;
  765.     else
  766.         return S_OK ;
  767. }
  769. HRESULT CICharConverter::WindowsCodePageToInternetEncoding(LPDWORD lpdwMode, LPCSTR lpSrcStr, LPINT lpnSrcSize,
  770.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  771. {
  772.     HRESULT hr ;
  774.     // check if the conversion should go through Unicode indirectly
  775.     if ( _dwConvertType & 0x10 )
  776.         hr = WindowsCodePageToInternetEncodingWrap(lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize, dwFlag, lpFallBack);
  777.     else
  778.     {
  780.         hr = DoConvertINetString(lpdwMode, FALSE, _dwWinCodePage, _dwInternetEncoding, lpSrcStr, lpnSrcSize, lpDstStr, *lpnDstSize, lpnDstSize);
  782.         if ( !_cvt_count ) // save SrcSize if it is the first time conversion
  783.             _nSrcSize = *lpnSrcSize ;
  784.     }
  785.     return hr ;
  786. }
  788. HRESULT CICharConverter::InternetEncodingToWindowsCodePage(LPDWORD lpdwMode, LPCSTR lpSrcStr, LPINT lpnSrcSize,
  789.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  790. {
  791.     HRESULT hr ;
  793.     // check if the conversion should go through Unicode indirectly
  794.     if ( _dwConvertType & 0x10 )
  795.         hr = InternetEncodingToWindowsCodePageWrap(lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize, dwFlag, lpFallBack);
  796.     else
  797.     {
  798.         hr = DoConvertINetString(lpdwMode, TRUE, _dwWinCodePage, _dwInternetEncoding, lpSrcStr, lpnSrcSize, lpDstStr, *lpnDstSize, lpnDstSize);
  800.         if ( !_cvt_count ) // save SrcSize if it is the first time conversion
  801.             _nSrcSize = *lpnSrcSize ;
  802.     }
  803.     return hr ;
  804. }
  806. HRESULT CICharConverter::WindowsCodePageToInternetEncodingWrap(LPCSTR lpSrcStr, LPINT lpnSrcSize,
  807.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  808. {
  809.     int nBuffSize = 0 ;
  810.     int cb = *lpnSrcSize;
  811.     UINT uMax = MAX_CHAR_SIZE ;
  812.     BOOL UseDefChar = FALSE ;
  813.     HRESULT hr = S_OK;
  815.     if ( !_cvt_count )
  816.     {
  817.         cb++; // pre-increment
  818.         do
  819.         {
  820.             nBuffSize = MultiByteToWideChar( MAPUSERDEF(_dwWinCodePage),
  821.                                         MB_ERR_INVALID_CHARS | MB_PRECOMPOSED,
  822.                                         lpSrcStr, --cb,
  823.                                         NULL, 0 );
  824.             --uMax;
  825.         } while (!nBuffSize && uMax && cb);
  826.     }
  828.     if ( cb == (*lpnSrcSize - MAX_CHAR_SIZE +1 ))  // if conversion problem isn't at the end of the string
  829.         cb = *lpnSrcSize ; // restore orginal value
  831.     if (!nBuffSize)  // in case there are illeage characters
  832.         nBuffSize = cb ;
  834.     if ( _lpInterm1Str = (LPSTR) LocalAlloc(LPTR, (nBuffSize * sizeof(WCHAR))))
  835.     {
  836.         nBuffSize = MultiByteToWideChar(MAPUSERDEF(_dwWinCodePage), 0,
  837.                         lpSrcStr, cb, (LPWSTR)_lpInterm1Str, nBuffSize );
  839.         int iSrcSizeTmp = nBuffSize * sizeof(WCHAR);
  840.         hr = UnicodeToMultiByteEncoding(MAPUSERDEF(_dwInternetEncoding), (LPCSTR)_lpInterm1Str, &iSrcSizeTmp,
  841.                                         lpDstStr, lpnDstSize, dwFlag, lpFallBack);
  842. //        *lpnDstSize = WideCharToMultiByte( MAPUSERDEF(_dwInternetEncoding), 0,
  843. //                        (LPCWSTR)_lpInterm1Str, nBuffSize, lpDstStr, *lpnDstSize, NULL, &UseDefChar );
  845.         if ( !_cvt_count ) // save SrcSize if it is the first time conversion
  846.             _nSrcSize = cb ;
  847.     }
  848.     else        
  849.         hr = E_FAIL;
  851.     if (hr == S_OK)
  852.     {
  853.         if (*lpnDstSize==0 && cb)
  854.             hr = E_FAIL ;
  855.         else 
  856.         {
  857.             if ( UseDefChar )
  858.                 return S_FALSE ;
  859.             else
  860.                 return S_OK ;
  861.         }
  862.     }
  864.     return hr;
  865. }
  867. HRESULT CICharConverter::InternetEncodingToWindowsCodePageWrap(LPCSTR lpSrcStr, LPINT lpnSrcSize,
  868.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  869. {
  871.     int nBuffSize = 0 ;
  872.     int cb = *lpnSrcSize;
  873.     UINT uMax = MAX_CHAR_SIZE ;
  874.     BOOL UseDefChar = FALSE ;
  875.     HRESULT hr = S_OK;
  877.     if ( !_cvt_count )
  878.     {
  879.         cb++; // pre-increment
  880.         do
  881.         {
  882.             nBuffSize = MultiByteToWideChar( MAPUSERDEF(_dwInternetEncoding),
  883.                                         MB_ERR_INVALID_CHARS | MB_PRECOMPOSED,
  884.                                         lpSrcStr, --cb,
  885.                                         NULL, 0 );
  886.             --uMax;
  887.         } while (!nBuffSize && uMax && cb);
  888.     }
  890.     if ( cb == (*lpnSrcSize - MAX_CHAR_SIZE +1 ))  // if conversion problem isn't at the end of the string
  891.         cb = *lpnSrcSize ; // restore orginal value
  893.     if (!nBuffSize)  // in case there are illeage characters
  894.         nBuffSize = cb ;
  896.     if ( _lpInterm1Str = (LPSTR) LocalAlloc(LPTR,nBuffSize * sizeof (WCHAR) ))
  897.     {
  898.         nBuffSize = MultiByteToWideChar( MAPUSERDEF(_dwInternetEncoding), 0,
  899.                         lpSrcStr, cb, (LPWSTR)_lpInterm1Str, nBuffSize );
  901.         int iSrcSizeTmp = nBuffSize * sizeof(WCHAR);
  902.         hr = UnicodeToMultiByteEncoding(MAPUSERDEF(_dwWinCodePage), (LPCSTR)_lpInterm1Str, &iSrcSizeTmp,
  903.                                         lpDstStr, lpnDstSize, dwFlag, lpFallBack);
  904. //        *lpnDstSize = WideCharToMultiByte( MAPUSERDEF(_dwWinCodePage), 0,
  905. //                        (LPCWSTR)_lpInterm1Str, nBuffSize, lpDstStr, *lpnDstSize, NULL, &UseDefChar );
  907.         if ( !_cvt_count ) // save SrcSize if it is the first time conversion
  908.             _nSrcSize = cb ;
  909.     }
  910.     else
  911.         hr = E_FAIL;
  913.     if (hr == S_OK)
  914.     {
  915.         if (*lpnDstSize==0 && cb)
  916.             hr = E_FAIL ;
  917.         else 
  918.         {
  919.             if ( UseDefChar )
  920.                 return S_FALSE ;
  921.             else
  922.                 return S_OK ;
  923.         }
  924.     }
  926.     return hr;
  927. }
  929. HRESULT CICharConverter::ConvertIWUU(LPDWORD lpdwMode, LPCSTR lpSrcStr, LPINT lpnSrcSize,
  930.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  931. {
  932.     int nBuffSize = 0 ;
  933.     HRESULT hr = S_OK ;
  934.     HRESULT hrWarnings = S_OK ;
  936.     // InternetEncodingToWindowsCodePage
  937.     if ( _dwConvertType % 2 && _dwConvertType < 21 ) /* start from Internet Encoding */
  938.     {
  939.         if ( _dwConvertType == 5 || _dwConvertType == 9 ) /* use interm buffer */
  940.         {
  941.             hr = InternetEncodingToWindowsCodePage(lpdwMode, lpSrcStr, lpnSrcSize, NULL, &nBuffSize, dwFlag, lpFallBack);
  942.             if ( _lpInterm1Str = (LPSTR) LocalAlloc(LPTR,nBuffSize) )
  943.             {
  944.                 hr = InternetEncodingToWindowsCodePage(lpdwMode, lpSrcStr, lpnSrcSize, _lpInterm1Str, &nBuffSize, dwFlag, lpFallBack);
  945.                 lpSrcStr = _lpInterm1Str ;
  946.                 *lpnSrcSize = nBuffSize ;
  947.             }
  948.             else
  949.                 goto fail ;
  950.         }
  951.         else
  952.             hr = InternetEncodingToWindowsCodePage(lpdwMode, lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize, dwFlag, lpFallBack);
  953.         _cvt_count ++ ;
  954.     }
  956.     if ( hr != S_OK )
  957.         hrWarnings = hr ;
  958.         
  959.     // WindowsCodePageToUnicode or InternetEncodingToUnicode
  960.     if ( _dwConvertType == 21 || _dwConvertType == 25 )
  961.     {
  962.         if ( _dwConvertType == 21 )
  963.             hr = InternetEncodingToUnicode(lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize);
  964.         else // _dwConvertType == 25 
  965.         {
  966.             hr = InternetEncodingToUnicode(lpSrcStr, lpnSrcSize, NULL, &nBuffSize);
  967.             if ( _lpInterm1Str= (LPSTR)LocalAlloc(LPTR, nBuffSize) )
  968.             {
  969.                 hr = InternetEncodingToUnicode(lpSrcStr, lpnSrcSize, _lpInterm1Str, &nBuffSize);
  970.                 lpSrcStr = _lpInterm1Str ;
  971.                 *lpnSrcSize = nBuffSize ;
  972.             }
  973.             else
  974.                 goto fail ;
  975.         }
  976.         _cvt_count ++ ;
  977.     }
  978.     else if ( _dwConvertType >= 4 && _dwConvertType <= 10 )
  979.     {
  980.         if ( _dwConvertType > 8 )
  981.         {
  982.             nBuffSize = 0 ;
  983.             hr = WindowsCodePageToUnicode(lpSrcStr, lpnSrcSize, NULL, &nBuffSize);
  984.             if ( _cvt_count )
  985.             {
  986.                 if ( _lpInterm2Str= (LPSTR)LocalAlloc(LPTR, nBuffSize) )
  987.                 {
  988.                     hr = WindowsCodePageToUnicode(lpSrcStr, lpnSrcSize, _lpInterm2Str, &nBuffSize);
  989.                     lpSrcStr = _lpInterm2Str ;
  990.                     *lpnSrcSize = nBuffSize ;
  991.                 }
  992.                 else
  993.                     goto fail ;
  995.             }
  996.             else
  997.             {
  998.                 if ( _lpInterm1Str= (LPSTR)LocalAlloc(LPTR, nBuffSize) )
  999.                 {
  1000.                     hr = WindowsCodePageToUnicode(lpSrcStr, lpnSrcSize, _lpInterm1Str, &nBuffSize);
  1001.                     lpSrcStr = _lpInterm1Str ;
  1002.                     *lpnSrcSize = nBuffSize ;
  1003.                 }
  1004.                 else
  1005.                     goto fail ;
  1006.             }
  1007.         }
  1008.         else
  1009.             hr = WindowsCodePageToUnicode(lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize);
  1010.         _cvt_count ++ ;
  1011.     }
  1013.     if ( hr != S_OK )
  1014.         hrWarnings = hr ;
  1016.     // UnicodeToUTF78
  1017.     if ( _dwConvertType & 0x08 )
  1018. #ifndef UNIX
  1019.         hr = UnicodeToUTF78(lpdwMode, lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize);
  1020. #else
  1021.         {
  1022.         /* we now hack the lpSrcStr to be the same as 2 byte Unicode so mlang
  1023.          * lowlevel code can work right.
  1024.          */
  1025.         LPWSTR lpwSrcStr = (LPWSTR)lpSrcStr;
  1026.         INT tmpSize = *lpnSrcSize/sizeof(WCHAR);
  1027.         UCHAR *pTmp = new UCHAR[(tmpSize+1)*2];
  1028.         if(pTmp) {
  1029.             for(int i = 0; i < tmpSize; i++) {
  1030.                 pTmp[i*2] = *lpwSrcStr++;
  1031.                 pTmp[i*2+1] = 0x00;
  1032.             }
  1033.             pTmp[i*2] = pTmp[i*2+1] = 0x00;
  1034.             tmpSize *= 2;
  1035.             hr = UnicodeToUTF78(lpdwMode, (LPCSTR)pTmp, &tmpSize, lpDstStr, lpnDstSize);
  1036.         }
  1037.         else
  1038.             hr = E_FAIL;
  1039.         delete [] pTmp;
  1040.         }
  1041. #endif /* UNIX */
  1043.     return ( hr == S_OK ? hrWarnings : hr ) ;
  1045. fail :
  1046.     return E_FAIL ;
  1047. }
  1049. HRESULT CICharConverter::ConvertUUWI(LPDWORD lpdwMode, LPCSTR lpSrcStr, LPINT lpnSrcSize,
  1050.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  1051. {
  1052.     int nBuffSize = 0 ;
  1053.     HRESULT hr = S_OK ;
  1054.     HRESULT hrWarnings = S_OK ;
  1056.     // UTF78ToUnicode
  1057.     if ( _dwConvertType & 0x08 )
  1058.     {
  1059.         if ( _dwConvertType == 12 ) /* convert UTF78 -> Unicode only */
  1060.             hr = UTF78ToUnicode(lpdwMode, lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize);
  1061.         else /* use interm buffer, type = 10 or 9 */
  1062.         {
  1063.             hr = UTF78ToUnicode(lpdwMode, lpSrcStr, lpnSrcSize, NULL, &nBuffSize);
  1064.             if ( _lpInterm1Str= (LPSTR)LocalAlloc(LPTR, nBuffSize) )
  1065.             {
  1066.                 hr = UTF78ToUnicode(lpdwMode, lpSrcStr, lpnSrcSize, _lpInterm1Str, &nBuffSize);
  1067.                 lpSrcStr = _lpInterm1Str ;
  1068.                 *lpnSrcSize = nBuffSize ;
  1069.             }
  1070.             else
  1071.                 goto fail ;
  1072.         }
  1073.         _cvt_count ++ ;
  1074.     }
  1076.     if ( hr != S_OK )
  1077.         hrWarnings = hr ;
  1079.     // UnicodeToWindowsCodePage or UnicodeToInternetEncoding
  1080.     if ( _dwConvertType == 21 || _dwConvertType == 25 )
  1081.     {
  1082.         hr = UnicodeToInternetEncoding(lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize, dwFlag, lpFallBack);
  1083.         _cvt_count ++ ;
  1084.     }
  1085.     else if ( _dwConvertType >= 4 && _dwConvertType <= 10 )
  1086.     {
  1087.         if ( _dwConvertType % 2 ) /* use interm buffer */
  1088.         {
  1089.             nBuffSize = 0 ;
  1090.             hr = UnicodeToWindowsCodePage(lpSrcStr, lpnSrcSize, NULL, &nBuffSize, dwFlag, lpFallBack);
  1091.             if ( _cvt_count )
  1092.             {
  1093.                 if ( _lpInterm2Str= (LPSTR)LocalAlloc(LPTR, nBuffSize) )
  1094.                 {
  1095.                     hr = UnicodeToWindowsCodePage(lpSrcStr, lpnSrcSize, _lpInterm2Str, &nBuffSize, dwFlag, lpFallBack);
  1096.                     lpSrcStr = _lpInterm2Str ;
  1097.                     *lpnSrcSize = nBuffSize ;
  1098.                 }
  1099.                 else
  1100.                     goto fail ;
  1101.             }
  1102.             else
  1103.             {
  1104.                 if ( _lpInterm1Str= (LPSTR)LocalAlloc(LPTR, nBuffSize) )
  1105.                 {
  1106.                     hr = UnicodeToWindowsCodePage(lpSrcStr, lpnSrcSize, _lpInterm1Str, &nBuffSize, dwFlag, lpFallBack);
  1107.                     lpSrcStr = _lpInterm1Str ;
  1108.                     *lpnSrcSize = nBuffSize ;
  1109.                 }
  1110.                 else
  1111.                     goto fail ;
  1112.             }
  1113.         }
  1114.         else
  1115.             hr = UnicodeToWindowsCodePage(lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize, dwFlag, lpFallBack);
  1116.         _cvt_count ++ ;
  1117.     }
  1119.     if ( hr != S_OK )
  1120.         hrWarnings = hr ;
  1122.     // WindowsCodePageToInternetEncoding
  1123.     if ( _dwConvertType % 2 && _dwConvertType < 21 )
  1124.         hr = WindowsCodePageToInternetEncoding(lpdwMode, lpSrcStr, lpnSrcSize, lpDstStr, lpnDstSize, dwFlag, lpFallBack);
  1126.     return ( hr == S_OK ? hrWarnings : hr ) ;
  1128. fail :
  1129.     return E_FAIL ;
  1130. }
  1132. #if 0
  1133. struct CODEPAGEINFO
  1134. {
  1135.     UINT        uCodePage ;
  1136.     CP_STATE    nCP_State ;    // whether this is a valid windows codepage  ?
  1137. };
  1139. // ValidCodepageInfo is used to cache whether a codepage is a vaild code
  1140. // It uses circular-FIFO cache algorithm
  1141. #define MAX_CP_CACHE    32
  1142. static int cp_cache_count = 0 ;
  1143. static int cp_cache_ptr = 0 ;
  1144. static struct CODEPAGEINFO ValidCodepageInfo[MAX_CP_CACHE];
  1146. // ValidCodepageInfo is used to cache whether a codepage is a vaild codepage
  1147. // It uses circular-FIFO cache algorithm
  1149. BOOL CheckIsValidCodePage (UINT uCodePage)
  1150. {
  1151.     if ( uCodePage == 50000 ) // User defined
  1152.         return TRUE ;
  1154.     int i ;
  1155.     BOOL bRet ;
  1157.     for ( i = 0 ; i < cp_cache_count ; i++ )
  1158.     {
  1159.         if ( uCodePage == ValidCodepageInfo[i].uCodePage )
  1160.         {
  1161.             if ( ValidCodepageInfo[i].nCP_State == VALID_CP )
  1162.                 return TRUE ;
  1163.             else
  1164.                 return FALSE ;
  1165.         }
  1166.     }
  1168.     // not found, call IsValidCodePage and cache the return value
  1169.     bRet = IsValidCodePage(uCodePage);
  1171.     EnterCriticalSection(&g_cs);
  1172.     ValidCodepageInfo[cp_cache_ptr].uCodePage = uCodePage ;
  1173.     if (bRet)
  1174.         ValidCodepageInfo[cp_cache_ptr].nCP_State = VALID_CP ;
  1175.     else
  1176.         ValidCodepageInfo[cp_cache_ptr].nCP_State = INVALID_CP ;
  1177.     if ( cp_cache_count < MAX_CP_CACHE )
  1178.         cp_cache_count++ ;
  1179.     cp_cache_ptr = ( ++cp_cache_ptr ) % MAX_CP_CACHE ;
  1180.     LeaveCriticalSection(&g_cs);
  1182.     return bRet ;
  1183. }
  1184. #endif
  1186. /*
  1187.     Conversion Flag:
  1189.     Bit 7 - Convert Direction.
  1191.     Bit 4 (16) - Unicode <-> Internet Encoding
  1192.     Bit 3 (8) - UTF8, UTF7
  1193.     Bit 2 (4) - Unicode
  1194.     Bit 1 (2) - Windows CodePage
  1195.     Bit 0 (1) - Internet Encoding
  1197.     12, 6, 3 (19) - one step convert
  1198.     10, 5 (21)  - two steps convert
  1199.     9 (25) - three steps convert
  1201. */
  1203. int GetWindowsEncodingIndex(DWORD dwEncoding)
  1204. {
  1205.     int nr = sizeof (aEncodingInfo) / sizeof(ENCODINGINFO) ;
  1206.     int i, half = nr / 2, index = -1 ;
  1208.     if (aEncodingInfo[half].dwEncoding > dwEncoding )
  1209.     {
  1210.         for ( i = 0 ; i < half ; i++ )
  1211.             if (aEncodingInfo[i].dwEncoding == dwEncoding )
  1212.                 index = i ;
  1214.     }
  1215.     else if (aEncodingInfo[half].dwEncoding < dwEncoding )
  1216.     {
  1217.         for ( i = half + 1 ; i < nr ; i++ )
  1218.             if (aEncodingInfo[i].dwEncoding == dwEncoding )
  1219.                 index = i ;
  1220.     }
  1221.     else
  1222.         index = half ;
  1224.     if (index>=0) // found
  1225.     {
  1226.         if ( aEncodingInfo[index].nCP_State != VALID_CP &&
  1227.                 aEncodingInfo[index].dwCodePage )
  1228.         {
  1230.             if ( aEncodingInfo[index].dwCodePage == 50000 || IsValidCodePage(aEncodingInfo[index].dwCodePage ) ) // 50000 means user defined
  1231.                 aEncodingInfo[index].nCP_State = VALID_CP ;
  1232.             else
  1233.                 aEncodingInfo[index].nCP_State = INVALID_CP ;
  1235.             if ((aEncodingInfo[index].nCP_State == VALID_CP) &&
  1236.                 (aEncodingInfo[index].dwFlags & CONV_CHK_NLS) &&
  1237.                 !IsValidCodePage(aEncodingInfo[index].dwEncoding))
  1238.                 aEncodingInfo[index].nCP_State = INVALID_CP ;
  1239.         }
  1240.     }
  1242.     return index ;
  1243. }
  1245. HRESULT CICharConverter::ConvertSetup(DWORD dwSrcEncoding, DWORD dwDstEncoding)
  1246. {
  1247.     DWORD SrcFlag = 0, DstFlag = 0 ;
  1248.     int index, unknown = 0 ;
  1250.     /* check source & destination encoding type */
  1251.     index = GetWindowsEncodingIndex(dwSrcEncoding);
  1252.     if ( index >=0 )
  1253.     {
  1254.         SrcFlag = (DWORD) aEncodingInfo[index].bTypeUUIW ;
  1255.         if ( aEncodingInfo[index].dwCodePage )
  1256.         {
  1257.             _dwWinCodePage = (DWORD) aEncodingInfo[index].dwCodePage ;
  1258.             if (aEncodingInfo[index].nCP_State == INVALID_CP )
  1259.                 goto fail ;
  1260.         }
  1261.         if ( SrcFlag & 0x08 )
  1262.             _dwUTFEncoding = dwSrcEncoding ;
  1263.         if ( SrcFlag & 0x01 )
  1264.             _dwInternetEncoding = dwSrcEncoding ;
  1265.         if ( SrcFlag & 0x04 )
  1266.             _dwUnicodeEncoding = dwSrcEncoding ;
  1267.     }
  1268.     // assume it is a unknown Window Codepage
  1269.     else
  1270.     {
  1271.         if ( !CONVERT_IS_VALIDCODEPAGE(dwSrcEncoding))
  1272.             goto fail ;
  1274.         SrcFlag = 0x02 ;
  1275.         _dwWinCodePage = dwSrcEncoding ;
  1277.         unknown ++ ;
  1278.     }
  1280.     index = GetWindowsEncodingIndex(dwDstEncoding);
  1281.     if ( index >=0 )
  1282.     {
  1283.         // check if two codepages are compatiable
  1284.         if ( _dwWinCodePage && aEncodingInfo[index].dwCodePage )
  1285.         {
  1286.             if (_dwWinCodePage != (DWORD) aEncodingInfo[index].dwCodePage )
  1287.                 goto fail ;
  1288.         }
  1289.         DstFlag = (DWORD) aEncodingInfo[index].bTypeUUIW ;
  1290.         if ( aEncodingInfo[index].dwCodePage )
  1291.         {
  1292.             _dwWinCodePage = (DWORD) aEncodingInfo[index].dwCodePage ;
  1293.             if (aEncodingInfo[index].nCP_State == INVALID_CP )
  1294.                 goto fail ;
  1295.         }
  1296.         if ( DstFlag & 0x08 )
  1297.             _dwUTFEncoding = dwDstEncoding ;
  1298.         if ( DstFlag & 0x01 )
  1299.             _dwInternetEncoding = dwDstEncoding ;
  1300.         if ( DstFlag & 0x04 )
  1301.             _dwUnicodeEncoding = dwDstEncoding ;
  1302.     }
  1303.     // 1) First time unknown, assume it is a unknown Window Codepage
  1304.     //    the conversion become UTF78 <-> Unicode <-> Window Codepage
  1305.     // 2) Second time unknown, assume it is a unknown Internet Encoding
  1306.     //    the conversion become Windows Codepage <-> Unicode <-> Internet Encoding
  1307.     else
  1308.     {
  1309.         if ( !CONVERT_IS_VALIDCODEPAGE(dwDstEncoding))
  1310.             goto fail ;
  1312.         if ( unknown == 0 )
  1313.         {
  1314.             if ( _dwWinCodePage )
  1315.             {
  1316.                 if (_dwWinCodePage != dwDstEncoding )
  1317.                     goto fail ;
  1318.             }
  1320.             DstFlag = 0x02 ;
  1321.             _dwWinCodePage = dwDstEncoding ;
  1322.         }
  1323.         else
  1324.         {
  1325.             DstFlag = 0x11 ;
  1326.             _dwInternetEncoding = dwDstEncoding ;
  1327.         }
  1328.     }
  1330.     if ( !SrcFlag | !DstFlag )
  1331.         goto fail ;
  1333.     if ( SrcFlag == DstFlag && dwSrcEncoding != dwDstEncoding && ( 4 != SrcFlag ))
  1334.         goto fail ;
  1336.     _dwConvertType = SrcFlag | DstFlag ;
  1338.     _bConvertDirt = ( SrcFlag & 0x0f ) > ( DstFlag & 0x0f )  ;
  1340.     // if code convertor has been allocated, deallocate it
  1341.     if (_hcins)
  1342.     {
  1343.         delete _hcins ;
  1344.         _hcins = NULL ;
  1345.     }
  1347.     return S_OK ;
  1349. fail :
  1350.     return S_FALSE ;
  1351. }
  1354. HRESULT CICharConverter::DoCodeConvert(LPDWORD lpdwMode, LPCSTR lpSrcStr, LPINT lpnSrcSize,
  1355.     LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  1356. {
  1357.     HRESULT hr = S_OK ;
  1359.     if ( 4 == _dwConvertType ) // CP_UCS_2 <-> CP_UCS_2_BE 
  1360.     {
  1361.         if (!lpDstStr)
  1362.         {   
  1363.             _nSrcSize = *lpnDstSize = *lpnSrcSize ;
  1364.         }
  1365.         else
  1366.         {
  1367.             int nSize = min(*lpnDstSize,*lpnSrcSize);
  1369.             _nSrcSize = *lpnSrcSize ;
  1370.             if ( lpDstStr && nSize > 0 )
  1371.             {
  1372.                 MoveMemory(lpDstStr, lpSrcStr, nSize );
  1373.                 DataByteSwap(lpDstStr, nSize );
  1374.                 _nSrcSize = nSize ;
  1375.                 *lpnDstSize = nSize ;
  1376.             }
  1377.         }
  1378.     }
  1379.     else if ( _bConvertDirt )
  1380.         hr = ConvertUUWI(lpdwMode, lpSrcStr,lpnSrcSize,lpDstStr,lpnDstSize, dwFlag, lpFallBack);
  1381.     else
  1382.         hr = ConvertIWUU(lpdwMode, lpSrcStr,lpnSrcSize,lpDstStr,lpnDstSize, dwFlag, lpFallBack);
  1384.     return hr ;
  1385. }
  1387. BOOL CICharConverter::ConvertCleanUp()
  1388. {
  1389.     if (_lpInterm1Str)
  1390.     {
  1391.          LocalFree(_lpInterm1Str);
  1392.          _lpInterm1Str = NULL ;
  1393.     }
  1394.     if (_lpInterm2Str)
  1395.     {
  1396.          LocalFree(_lpInterm2Str);
  1397.          _lpInterm2Str = NULL ;
  1398.     }
  1399.     if (_lpUnicodeStr)
  1400.     {
  1401.          LocalFree(_lpUnicodeStr);
  1402.          _lpUnicodeStr = NULL ;
  1403.     }
  1404.     _cvt_count = 0 ;
  1405.     _nSrcSize = 0 ;
  1407.     return TRUE ;
  1408. }
  1410. CICharConverter::CICharConverter()
  1411. {
  1412.     _lpInterm1Str = NULL ;
  1413.     _lpInterm2Str = NULL ;
  1414.     _lpUnicodeStr = NULL ;
  1415.     _hcins = NULL ;
  1416.     _cvt_count = 0 ;
  1417.     _dwWinCodePage = 0;
  1418.     _dwInternetEncoding = 0;
  1419.     _dwUTFEncoding = 0;
  1420.     _dwUnicodeEncoding = 0;
  1421.     _dwConvertType = 0;
  1422.     _nSrcSize = 0 ;
  1423.     _hcins_dst = 0 ;
  1425.     return ;
  1426. }
  1428. CICharConverter::CICharConverter(DWORD dwFlag, WCHAR *lpFallBack)
  1429. {
  1430.     _lpInterm1Str = NULL ;
  1431.     _lpInterm2Str = NULL ;
  1432.     _lpUnicodeStr = NULL ;
  1433.     _hcins = NULL ;
  1434.     _cvt_count = 0 ;
  1435.     _dwWinCodePage = 0;
  1436.     _dwInternetEncoding = 0;
  1437.     _dwUTFEncoding = 0;
  1438.     _dwUnicodeEncoding = 0;
  1439.     _dwConvertType = 0;
  1440.     _nSrcSize = 0 ;
  1441.     _hcins_dst = 0 ;
  1442.     _dwFlag = dwFlag;
  1443.     _lpFallBack = lpFallBack;
  1445.     return ;
  1446. }
  1449. CICharConverter::~CICharConverter()
  1450. {
  1451.     if (_lpInterm1Str)
  1452.     {
  1453.          LocalFree(_lpInterm1Str);
  1454.          _lpInterm1Str = NULL ;
  1455.     }
  1456.     if (_lpInterm2Str)
  1457.     {
  1458.          LocalFree(_lpInterm2Str);
  1459.          _lpInterm2Str = NULL ;
  1460.     }
  1461.     if (_lpUnicodeStr)
  1462.     {
  1463.          LocalFree(_lpUnicodeStr);
  1464.          _lpUnicodeStr = NULL ;
  1465.     }
  1466.     if (_hcins)
  1467.     {
  1468.         delete _hcins ;
  1469.         _hcins = NULL ;
  1470.     }
  1471. }
  1473. CICharConverter::CICharConverter(DWORD dwSrcEncoding, DWORD dwDstEncoding)
  1474. {
  1475.     _lpInterm1Str = NULL ;
  1476.     _lpInterm2Str = NULL ;
  1477.     _lpUnicodeStr = NULL ;
  1478.     _hcins = NULL ;
  1479.     _cvt_count = 0 ;
  1480.     _dwWinCodePage = 0;
  1481.     _dwInternetEncoding = 0;
  1482.     _dwUTFEncoding = 0;
  1483.     _dwUnicodeEncoding = 0;
  1484.     _dwConvertType = 0;
  1485.     _nSrcSize = 0 ;
  1486.     _hcins_dst = 0 ;
  1487.     
  1488.     ConvertSetup(dwSrcEncoding,dwDstEncoding);
  1489.     return ;
  1490. }
  1492. HRESULT WINAPI IsConvertINetStringAvailable(DWORD dwSrcEncoding, DWORD dwDstEncoding)
  1493. {
  1494.     HRESULT hr;
  1495.     CICharConverter * INetConvert = new CICharConverter ;
  1497.     if (!INetConvert)
  1498.         return E_OUTOFMEMORY;
  1500.     hr = INetConvert->ConvertSetup(dwSrcEncoding, dwDstEncoding);
  1501.     delete INetConvert;
  1503.     return hr ;
  1504. }
  1506. #define DETECTION_BUFFER_NUM    3
  1508. // BUGBUG (weiwu)
  1509. // In CP_AUTO and detection result is UTF7 case, private converter might use high word of *lpdwMode to store internal data, but we need 
  1510. // to use it to notify Trident the detection result, currently, we're bias to returning correct detection result.
  1511. // After IE5 release, we have to re-prototype conversion object and resovle this issue
  1512. HRESULT WINAPI ConvertINetStringEx(LPDWORD lpdwMode, DWORD dwSrcEncoding, DWORD dwDstEncoding, LPCSTR lpSrcStr, LPINT lpnSrcSize, LPSTR lpDstStr, LPINT lpnDstSize, DWORD dwFlag, WCHAR *lpFallBack)
  1513. {
  1514.     CICharConverter * INetConvert;
  1515.     int nSrcSize;
  1516.     int nDstSize;
  1517.     DWORD   dwMode = 0 ;
  1518.     // dwDetectResult 
  1519.     // CP_UNDEFINED :Fail to detect
  1520.     //      0       :Not a auto-detect scenario
  1521.     // Others       :Detected encoding
  1522.     DWORD   dwDetectResult = CP_UNDEFINED;
  1523.     HRESULT hr ;
  1525.     if(lpnSrcSize)
  1526.     {
  1527.         nSrcSize = *lpnSrcSize;
  1528.     }
  1529.     else
  1530.         nSrcSize = -1;
  1532.     if ( lpSrcStr && nSrcSize == -1 ) // Get length of lpSrcStr if not given, assuming lpSrcStr is a zero terminate string.
  1533.     {
  1534.         if ( dwSrcEncoding == CP_UCS_2 )
  1535.             nSrcSize = (lstrlenW((WCHAR*)lpSrcStr) << 1) ;
  1536.         else
  1537.             nSrcSize = lstrlenA(lpSrcStr) ;
  1538.     }
  1540.     if (!nSrcSize)
  1541.     {
  1542.         if (lpnDstSize)
  1543.            *lpnDstSize = 0;
  1544.         return S_OK;
  1545.     }
  1547.     INetConvert = new CICharConverter(dwFlag, lpFallBack) ;    
  1549.     if (!INetConvert)
  1550.         return E_OUTOFMEMORY;
  1552.     // ASSERT(CP_AUTO != dwDstEncoding);
  1554.     // if null specified at dst buffer we'll get the size of required buffer.
  1555.     if(!lpDstStr)
  1556.         nDstSize = 0;
  1557.     else if (lpnDstSize)
  1558.         nDstSize = *lpnDstSize;
  1559.     else 
  1560.         nDstSize = 0;
  1562.     if (lpdwMode)
  1563.         dwMode = *lpdwMode ;
  1565.     // In real world, clients uses 28591 as 1252, 28599 as 1254, 
  1566.     // To correctly convert those extended characters to Unicode,
  1567.     // We internally replace it with 1252 
  1568.     if (dwDstEncoding == CP_UCS_2 || dwDstEncoding == CP_UCS_2_BE)
  1569.     {
  1570.         if ((dwSrcEncoding == CP_ISO_8859_1) && _IsValidCodePage(CP_1252))
  1571.             dwSrcEncoding = CP_1252;
  1573.         if ((dwSrcEncoding == CP_ISO_8859_9) && _IsValidCodePage(CP_1254))
  1574.             dwSrcEncoding = CP_1254;
  1575.     }
  1577.     if ((dwDstEncoding == CP_1252) && (dwSrcEncoding == CP_ISO_8859_1))
  1578.     {
  1579.         dwSrcEncoding = CP_1252;
  1580.     }
  1582.     if ((dwDstEncoding == CP_1254) && (dwSrcEncoding == CP_ISO_8859_9))
  1583.     {
  1584.         dwSrcEncoding = CP_1254;
  1585.     }
  1588.     if ( dwSrcEncoding == CP_JP_AUTO ) // Auto Detection for Japan
  1589.     {
  1590.         CIncdJapanese DetectJapan;
  1591.         UINT uiCodePage ;
  1593.         uiCodePage = ( dwMode >> 16 ) & 0xffff ;
  1594.         if ( uiCodePage )
  1595.         {
  1596.             dwSrcEncoding = uiCodePage ;
  1597.             dwDetectResult = 0;
  1598.         }
  1599.         else
  1600.         {
  1601.             dwSrcEncoding = DetectJapan.DetectStringA(lpSrcStr, *lpnSrcSize);
  1602.             // if dwSrcEncoding is zero means there is an ambiguity, we don't return
  1603.             // the detected codepage to caller, instead we defaut its codepage internally
  1604.             // to SJIS
  1605.             if (dwSrcEncoding)
  1606.             {
  1607.                 dwDetectResult = dwSrcEncoding << 16 ;
  1608.             }
  1609.             else
  1610.                 dwSrcEncoding = CP_JPN_SJ;
  1611.         }
  1612.     }
  1613.     // BUGBUG: bug #43190, we auto-detect again for euc-kr page because IMN ver 1.0
  1614.     // mislabel an ISO-KR page as a ks_c_5601-1987 page. This is the only way 
  1615.     // we can fix that stupid mistake. 
  1616.     else if ( dwSrcEncoding == CP_KR_AUTO || dwSrcEncoding == CP_KOR_5601 ||
  1617.         dwSrcEncoding == CP_EUC_KR )
  1618.     {
  1619.         CIncdKorean DetectKorean;
  1620.         UINT uiCodePage ;
  1622.         uiCodePage = ( dwMode >> 16 ) & 0xffff ;
  1623.         if ( uiCodePage )
  1624.         {
  1625.             dwSrcEncoding = uiCodePage ;
  1626.             dwDetectResult = 0;
  1627.         }
  1628.         else
  1629.         {
  1630.             dwSrcEncoding = DetectKorean.DetectStringA(lpSrcStr, *lpnSrcSize);
  1631.             if (dwSrcEncoding)
  1632.             {
  1633.                 dwDetectResult = dwSrcEncoding << 16 ;
  1634.             }
  1635.             else
  1636.                 dwSrcEncoding = CP_KOR_5601;
  1637.         }
  1639.     }
  1640.     else if ( dwSrcEncoding == CP_AUTO ) // General Auto Detection for all code pages
  1641.     {
  1642.         nSrcSize = DETECTION_MAX_LEN < *lpnSrcSize ?  DETECTION_MAX_LEN : *lpnSrcSize;
  1643.         int nScores = DETECTION_BUFFER_NUM;
  1644.         DetectEncodingInfo Encoding[DETECTION_BUFFER_NUM];
  1645.         UINT uiCodePage ;
  1648.         uiCodePage = ( dwMode >> 16 ) & 0xffff ;
  1649.         if ( uiCodePage )
  1650.         {
  1651.             dwSrcEncoding = uiCodePage ;
  1652.             dwDetectResult = 0;
  1653.         }
  1654.         else
  1655.         {
  1656.             dwSrcEncoding = GetACP();
  1657.             if ( S_OK == _DetectInputCodepage(MLDETECTCP_HTML, CP_AUTO, (char *)lpSrcStr, &nSrcSize, &Encoding[0], &nScores))
  1658.             {
  1659.                 MIMECPINFO cpInfo;
  1661.                 if (Encoding[0].nCodePage == CP_20127)
  1662.                     Encoding[0].nCodePage = dwSrcEncoding;
  1664.                 if (NULL != g_pMimeDatabase)
  1665.                 {
  1666.                     if (SUCCEEDED(g_pMimeDatabase->GetCodePageInfo(Encoding[0].nCodePage, 0x409, &cpInfo)) && 
  1667.                         (cpInfo.dwFlags & MIMECONTF_VALID))
  1668.                     {
  1669.                         dwSrcEncoding = Encoding[0].nCodePage;     
  1670.                         dwDetectResult = dwSrcEncoding << 16 ;  
  1671.                     }
  1672.                 }
  1673.             }
  1675.             // If we failed in general detection and system locale is Jpn, we try harder 
  1676.             // with our Japanese detection engine
  1677.             if (dwSrcEncoding == CP_JPN_SJ && dwDetectResult == CP_UNDEFINED)
  1678.             {
  1679.                 CIncdJapanese DetectJapan;
  1680.                 DWORD dwSrcEncodingJpn = DetectJapan.DetectStringA(lpSrcStr, *lpnSrcSize);
  1681.                 if (dwSrcEncodingJpn)
  1682.                 {
  1683.                     // We only change conversion encoding without returnning this result to browser 
  1684.                     // if it is in the middle of detection, this is to prevent other encodings been mis-detected as Jpn encodings.
  1685.                     dwSrcEncoding = dwSrcEncodingJpn;   
  1686.                     
  1687.                     // Set search range for end tag as 10 bytes
  1688.                     if (*lpnSrcSize >= 10)
  1689.                     {
  1690.                         char szTmpStr[11] = {0};
  1691.                         char *lpTmpStr = szTmpStr;
  1692.                         MLStrCpyN(szTmpStr, (char *)&lpSrcStr[*lpnSrcSize-10], 10);                        
  1694.                         //ToLower
  1695.                         while(*lpTmpStr)
  1696.                         {
  1697.                             if (*lpTmpStr >= 'A' && *lpTmpStr <= 'W')
  1698.                                 *lpTmpStr += 0x20;
  1699.                             lpTmpStr++;
  1700.                         }
  1702.                         // If end of page, return this result
  1703.                         if (MLStrStr(szTmpStr, "</html>"))
  1704.                             dwDetectResult = dwSrcEncoding << 16 ;  
  1705.                     }
  1707.                 }
  1708.             }
  1709.             //aEncodingInfo[GetWindowsEncodingIndex(CP_AUTO)].dwCodePage = dwSrcEncoding;         
  1710.         }     
  1711.     }
  1712.     else
  1713.     {
  1714.         // Not a auto-detect scenario
  1715.         dwDetectResult = 0;
  1716.     }
  1718.     if ( S_OK == ( hr = INetConvert->ConvertSetup(dwSrcEncoding,dwDstEncoding )))
  1719.     {
  1720.        if ( dwSrcEncoding != dwDstEncoding )
  1721.        {
  1722.             // if high word of dwMode is CP_UTF_7, it must be detection result, don't pass it to UTF7 converter
  1723.             if ( dwSrcEncoding == CP_UTF_7 && (dwMode >> 16) == CP_UTF_7)
  1724.                 dwMode &= 0xFFFF;
  1725.             // ASSERT(!((IS_ENCODED_ENCODING(dwSrcEncoding) || IS_ENCODED_ENCODING(dwDstEncoding)) && (NULL == lpdwMode)));
  1726.             hr = INetConvert->DoCodeConvert(&dwMode, lpSrcStr, &nSrcSize, lpDstStr, &nDstSize, dwFlag, lpFallBack);
  1728.             // return the number of bytes processed for the source. 
  1729.             if (lpnSrcSize)
  1730.                 *lpnSrcSize = INetConvert->_nSrcSize ;
  1731.             INetConvert->ConvertCleanUp();
  1732.        }
  1733.        else
  1734.        {
  1735.             int nSize, i ;
  1736.             hr = S_OK ;
  1737.             BOOL bLeadByte = FALSE ;
  1739.             // only check for windows codepage
  1740.             if ( INetConvert->_dwConvertType == 02 && lpSrcStr )
  1741.             { 
  1742.                 for ( i=0; i<nSrcSize; i++)
  1743.                 {
  1744.                    if (bLeadByte)
  1745.                        bLeadByte = FALSE ;
  1746.                    else if (IsDBCSLeadByteEx(dwSrcEncoding,lpSrcStr[i]))
  1747.                        bLeadByte = TRUE ;
  1748.                 }
  1749.                 if (bLeadByte)
  1750.                     nSrcSize-- ;
  1751.             }
  1752.             // set input size
  1753.             if (lpnSrcSize)
  1754.                 *lpnSrcSize = nSrcSize ;
  1755.             // set output size and copy if we need to
  1756.             if (lpDstStr && *lpnDstSize)
  1757.             {
  1758.                 nSize = min(*lpnDstSize,nSrcSize);
  1759.                 MoveMemory(lpDstStr, lpSrcStr, nSize);
  1760.                 nDstSize = nSize ;
  1761.             }
  1762.             else
  1763.                 nDstSize = nSrcSize ;
  1764.        }
  1765.     }
  1766.     else
  1767.             nDstSize = 0 ;
  1769.     delete INetConvert;
  1771.     // return the number of bytes copied for the destination,
  1772.     if (lpnDstSize)
  1773.         *lpnDstSize = nDstSize;
  1775.     if (lpdwMode && lpDstStr)
  1776.     {        
  1777.         if (dwDetectResult)                     // CP_AUTO conversion
  1778.         {
  1779.             dwMode &= 0xFFFF;                   // Clear HIGHWORD in case private converter set it
  1780.             // If we have detection result, return it in HIGHWORD
  1781.             // BUGBUG: in the case of UTF7 conversion, private converter might use high word to store internal data,
  1782.             // this will conflict with our logic of returning detection result in high word, it is a design flaw, 
  1783.             // currently, we ignore conversion setting and give detection result more priority
  1784.             if (dwDetectResult != CP_UNDEFINED) 
  1785.                 dwMode |= dwDetectResult;
  1786.         }
  1787.         *lpdwMode = dwMode ;
  1788.     }
  1790.     return hr ;
  1791. }
  1793. HRESULT WINAPI ConvertINetReset(void)
  1794. {
  1795.     // BUGBUG: We will remove this API soon.
  1796.     return S_OK ;
  1797. }
  1799. HRESULT WINAPI ConvertINetMultiByteToUnicodeEx(LPDWORD lpdwMode, DWORD dwEncoding, LPCSTR lpSrcStr, LPINT lpnMultiCharCount, LPWSTR lpDstStr, LPINT lpnWideCharCount, DWORD dwFlag, WCHAR *lpFallBack)
  1800. {
  1801.     HRESULT hr ;
  1802.     int nByteCountSize = 0;
  1804.     if (lpnWideCharCount)
  1805.     {
  1806.         nByteCountSize = *lpnWideCharCount * sizeof(WCHAR);
  1807.     }
  1809. #ifdef UNIX
  1810.    int saved_nByteCountSize = nByteCountSize;
  1811. #endif /* UNIX */
  1813.     hr = ConvertINetStringEx(lpdwMode,dwEncoding, CP_UCS_2, lpSrcStr, lpnMultiCharCount, (LPSTR)lpDstStr, &nByteCountSize, dwFlag, lpFallBack) ;
  1815. #ifdef UNIX
  1816.     if(dwEncoding == 1200 || dwEncoding == 65000 || dwEncoding == 65001 ||
  1817.        (dwEncoding == 50001 && !_IsValidCodePage(dwEncoding)) )
  1818.     {
  1819.         /*
  1820.          * On unix we need to convert the little endian mode 2 byte unicode
  1821.          * format to unix mode 4 byte wChars.
  1822.          */
  1823.         if(lpDstStr && (saved_nByteCountSize < (nByteCountSize/2)*sizeof(WCHAR)))
  1824.             hr = E_FAIL;
  1825.         else
  1826.         {
  1827.             /*
  1828.              * Use a temporary array to do the 2byte -> 4byte conversion
  1829.              */
  1830.             LPSTR pTmp = (LPSTR) lpDstStr;
  1831.             LPWSTR pw4 = NULL;
  1833.             if(pTmp) /* allocate only if we have a lpDstStr */
  1834.                 pw4 = new WCHAR[nByteCountSize/2];
  1835.             if(pw4)
  1836.             {
  1837.                 int i = 0;
  1838.                 LPWSTR pw4Tmp = pw4;
  1839.                 for(; i < nByteCountSize/2; i++)
  1840.                     *pw4Tmp++ = (UCHAR)pTmp[i*2];
  1841.                 pw4Tmp = pw4;
  1842.                 for(i = 0; i < nByteCountSize/2; i++)
  1843.                     *lpDstStr++ = *pw4Tmp++;
  1844.             }
  1845.             if(!pw4 && pTmp) /* if lpDstStr and allocate fails bail out */
  1846.                 hr = E_FAIL;
  1847.             delete [] pw4;
  1848.         }
  1849.         nByteCountSize *= 2; // Expand twice as we have 4 byte wchars.
  1850.     }
  1851. #endif
  1852.     *lpnWideCharCount = nByteCountSize / sizeof(WCHAR);
  1854.     return hr ;
  1855. }
  1858. HRESULT WINAPI ConvertINetUnicodeToMultiByteEx(LPDWORD lpdwMode, DWORD dwEncoding, LPCWSTR lpSrcStr, LPINT lpnWideCharCount, LPSTR lpDstStr, LPINT lpnMultiCharCount, DWORD dwFlag, WCHAR *lpFallBack)
  1859. {
  1860.     HRESULT hr ;
  1861.     int nByteCountSize=-1;
  1863.     if(lpnWideCharCount && *lpnWideCharCount != -1) 
  1864.         nByteCountSize = *lpnWideCharCount * sizeof(WCHAR);
  1866.     hr = ConvertINetStringEx(lpdwMode,CP_UCS_2, dwEncoding, (LPCSTR) lpSrcStr, &nByteCountSize, lpDstStr, lpnMultiCharCount, dwFlag, lpFallBack);
  1868. #ifdef UNIX
  1869.     if(dwEncoding == 1200 || dwEncoding == 65000 || dwEncoding == 65001) {
  1870.         nByteCountSize *= 2; // Expand twice as we have 4 byte wchars.
  1871.     }
  1872. #endif /* UNIX */
  1874.     if (lpnWideCharCount)
  1875.         *lpnWideCharCount = nByteCountSize / sizeof(WCHAR);
  1877.     return hr ;
  1878. }
  1880. HRESULT WINAPI ConvertINetString(LPDWORD lpdwMode, DWORD dwSrcEncoding, DWORD dwDstEncoding, LPCSTR lpSrcStr, LPINT lpnSrcSize, LPSTR lpDstStr, LPINT lpnDstSize)
  1881. {
  1882.     HRESULT hr ;
  1884.     hr = ConvertINetStringEx(lpdwMode,dwSrcEncoding,dwDstEncoding,lpSrcStr,lpnSrcSize,lpDstStr,lpnDstSize, 0, NULL);
  1886.     return hr ;
  1887. }
  1889. HRESULT WINAPI ConvertINetUnicodeToMultiByte(LPDWORD lpdwMode, DWORD dwEncoding, LPCWSTR lpSrcStr, LPINT lpnWideCharCount, LPSTR lpDstStr, LPINT lpnMultiCharCount)
  1890. {
  1891.     HRESULT hr ;
  1892.     DWORD dwFlag = 0 ;
  1894.     if ( lpdwMode )
  1895.         dwFlag |= ( *lpdwMode & 0x00008000 ) ? MLCONVCHARF_ENTITIZE : 0 ;
  1897.     hr = ConvertINetUnicodeToMultiByteEx(lpdwMode,dwEncoding,lpSrcStr,lpnWideCharCount,lpDstStr,lpnMultiCharCount,dwFlag,NULL);
  1899.     return hr ;
  1900. }
  1902. HRESULT WINAPI ConvertINetMultiByteToUnicode(LPDWORD lpdwMode, DWORD dwEncoding, LPCSTR lpSrcStr, LPINT lpnMultiCharCount, LPWSTR lpDstStr, LPINT lpnWideCharCount)
  1903. {
  1904.     HRESULT hr ;
  1906.     hr = ConvertINetMultiByteToUnicodeEx(lpdwMode,dwEncoding,lpSrcStr,lpnMultiCharCount,lpDstStr,lpnWideCharCount, 0, NULL);
  1908.     return hr ;
  1909. }
  1911. #define STR_BUFFER_SIZE 2048
  1913. HRESULT _ConvertINetStringInIStream(CICharConverter * INetConvert, LPDWORD lpdwMode, DWORD dwSrcEncoding, DWORD dwDstEncoding, IStream *pstmIn, IStream *pstmOut, DWORD dwFlag, WCHAR *lpFallBack)
  1914. {
  1915.     DWORD   dwMode, dwModeTemp ;
  1916.     HRESULT hr= S_OK, hrWarnings=S_OK;
  1917.     LPSTR lpstrIn = NULL, lpstrOut = NULL; 
  1918.     ULONG nSrcSize, nSrcUsed, nSrcLeft, nDstSize, _nDstSize, nOutBuffSize ;
  1920.     if (lpdwMode)
  1921.         dwMode = *lpdwMode ;
  1923.     // allocate a temp input buffer - 2K in size
  1924.     if ( (lpstrIn = (LPSTR) LocalAlloc(LPTR, STR_BUFFER_SIZE )) == NULL )
  1925.     {
  1926.         hrWarnings = E_OUTOFMEMORY ;
  1927.         goto exit;
  1928.     }
  1930.     if ( (lpstrOut = (LPSTR) LocalAlloc(LPTR, STR_BUFFER_SIZE * 2 )) == NULL )
  1931.     {
  1932.         hrWarnings = E_OUTOFMEMORY ;
  1933.         goto exit;
  1934.     }
  1936.     nOutBuffSize = STR_BUFFER_SIZE * 2 ;
  1937.     nSrcLeft = 0 ;
  1939.     // In real world, clients uses 28591 as 1252, 28599 as 1254, 
  1940.     // To correctly convert those extended characters to Unicode,
  1941.     // We internally replace it with 1252 
  1942.     if (dwDstEncoding == CP_UCS_2 || dwDstEncoding == CP_UCS_2_BE)
  1943.     {
  1944.         if ((dwSrcEncoding == CP_ISO_8859_1) && _IsValidCodePage(CP_1252))
  1945.             dwSrcEncoding = CP_1252;
  1947.         if ((dwSrcEncoding == CP_ISO_8859_9) && _IsValidCodePage(CP_1254))
  1948.             dwSrcEncoding = CP_1254;
  1949.     }
  1951.     if ((dwDstEncoding == CP_1252) && (dwSrcEncoding == CP_ISO_8859_1))
  1952.     {
  1953.         dwSrcEncoding = CP_1252;
  1954.     }
  1956.     if ((dwDstEncoding == CP_1254) && (dwSrcEncoding == CP_ISO_8859_9))
  1957.     {
  1958.         dwSrcEncoding = CP_1254;
  1959.     }
  1962.     if ( dwSrcEncoding == CP_JP_AUTO ) // Auto Detection for Japan
  1963.     {
  1964.         CIncdJapanese DetectJapan;
  1965.         UINT uiCodePage ;
  1966.         LARGE_INTEGER   li;
  1968.         uiCodePage = ( dwMode >> 16 ) & 0xffff ;
  1969.         if ( uiCodePage )
  1970.             dwSrcEncoding = uiCodePage ;
  1971.         else
  1972.         {
  1973.             LISet32(li, 0);
  1975.             hr = pstmIn->Read(lpstrIn, STR_BUFFER_SIZE , &nSrcSize);
  1976.             if (S_OK != hr)
  1977.                 hrWarnings = hr;
  1978.             hr = pstmIn->Seek(li,STREAM_SEEK_SET, NULL);
  1979.             if (S_OK != hr)
  1980.                 hrWarnings = hr;
  1982.             dwSrcEncoding = DetectJapan.DetectStringA(lpstrIn, nSrcSize);
  1983.             // if dwSrcEncoding is zero means there is an ambiguity, we don't return
  1984.             // the detected codepage to caller, instead we defaut its codepage internally
  1985.             // to SJIS
  1986.             if (dwSrcEncoding)
  1987.             {
  1988.                 dwMode &= 0x0000ffff ;
  1989.                 dwMode |= dwSrcEncoding << 16 ; 
  1990.             }
  1991.             else
  1992.                 dwSrcEncoding = CP_JPN_SJ;
  1993.         }
  1994.     }
  1995.     // BUGBUG: bug #43190, we auto-detect again for euc-kr page because IMN ver 1.0
  1996.     // mislabel an ISO-KR page as a ks_c_5601-1987 page. This is the only way 
  1997.     // we can fix that stupid mistake. 
  1998.     else if ( dwSrcEncoding == CP_KR_AUTO || dwSrcEncoding == CP_KOR_5601 ||
  1999.         dwSrcEncoding == CP_EUC_KR )
  2000.     {
  2001.         CIncdKorean DetectKorean;
  2002.         UINT uiCodePage ;
  2003.         LARGE_INTEGER   li;
  2005.         uiCodePage = ( dwMode >> 16 ) & 0xffff ;
  2006.         if ( uiCodePage )
  2007.             dwSrcEncoding = uiCodePage ;
  2008.         else
  2009.         {
  2010.             LISet32(li, 0);
  2011.             
  2012.             hr = pstmIn->Read(lpstrIn, STR_BUFFER_SIZE, &nSrcSize);
  2013.             if (S_OK != hr)
  2014.                 hrWarnings = hr;
  2015.             hr = pstmIn->Seek(li,STREAM_SEEK_SET, NULL);
  2016.             if (S_OK != hr)
  2017.                 hrWarnings = hr;
  2018.             dwSrcEncoding = DetectKorean.DetectStringA(lpstrIn, nSrcSize);
  2019.             if (dwSrcEncoding)
  2020.             {
  2021.                 dwMode &= 0x0000ffff ;
  2022.                 dwMode |= dwSrcEncoding << 16 ; 
  2023.             }
  2024.             else
  2025.                 dwSrcEncoding = CP_KOR_5601;
  2026.         }
  2027.     }
  2028.     else if ( dwSrcEncoding == CP_AUTO ) // General Auto Detection for all code pages
  2029.     {
  2030.         INT nScores = 1;
  2031.         DWORD dwSrcEncoding ;
  2032.         DetectEncodingInfo Encoding;
  2033.         UINT uiCodePage ;
  2034.         LARGE_INTEGER   li;
  2036.         uiCodePage = ( dwMode >> 16 ) & 0xffff ;
  2037.         if ( uiCodePage )
  2038.             dwSrcEncoding = uiCodePage ;
  2039.         else
  2040.         {
  2041.             LISet32(li, 0);
  2043.             hr = pstmIn->Read(lpstrIn, STR_BUFFER_SIZE , &nSrcSize);
  2044.             if (S_OK != hr)
  2045.                 hrWarnings = hr;
  2046.             hr = pstmIn->Seek(li,STREAM_SEEK_SET, NULL);
  2047.             if (S_OK != hr)
  2048.                 hrWarnings = hr;
  2050.             if (DETECTION_MAX_LEN < nSrcSize)
  2051.                 nSrcSize =  DETECTION_MAX_LEN;
  2053.             if ( S_OK == _DetectInputCodepage(MLDETECTCP_HTML, 1252, lpstrIn, (int *)&nSrcSize, &Encoding, &nScores))
  2054.             {
  2055.                 dwSrcEncoding = Encoding.nCodePage;
  2056.                 dwMode &= 0x0000ffff ;
  2057.                 dwMode |= dwSrcEncoding << 16 ; 
  2058.             }
  2059.             else
  2060.             {
  2061.                 dwSrcEncoding = CP_ACP;
  2062.             }
  2063.             aEncodingInfo[GetWindowsEncodingIndex(CP_AUTO)].dwCodePage = dwSrcEncoding;
  2064.         }
  2065.     }
  2067.     if ( S_OK == ( hr = INetConvert->ConvertSetup(dwSrcEncoding,dwDstEncoding )))
  2068.     {
  2069.         // Loop for ever
  2070.         while(1)
  2071.         {
  2072.             // Read a buffer
  2073.             hr = pstmIn->Read(&lpstrIn[nSrcLeft], STR_BUFFER_SIZE-nSrcLeft, &nSrcSize);
  2074.             if (S_OK != hr)
  2075.                 hrWarnings = hr;
  2077.             // Done
  2078.             if (0 == nSrcSize)
  2079.                 break;
  2081.             nSrcSize += nSrcLeft ;
  2082.             nSrcUsed = nSrcSize ;
  2083.             dwModeTemp = dwMode ;
  2084.             nDstSize = 0 ;
  2086.             // get the size of output buffer
  2087.             hr = INetConvert->DoCodeConvert(&dwModeTemp, (LPCSTR)lpstrIn, (LPINT)&nSrcUsed, NULL, (LPINT)&nDstSize, dwFlag, lpFallBack);
  2088.             if (S_OK != hr)
  2089.                 hrWarnings = hr;
  2091.             // Reallocate output buffer if so
  2092.             if ( nDstSize > nOutBuffSize )
  2093.             {
  2094.                 LPSTR psz = (LPSTR) LocalReAlloc(lpstrOut, nDstSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
  2095.                 if (psz == NULL)
  2096.                 {
  2097.                     hrWarnings = E_OUTOFMEMORY ;
  2098.                     goto exit;
  2099.                 }
  2100.                 lpstrOut = psz;
  2101.                 nOutBuffSize = nDstSize ;
  2102.             }
  2103.             _nDstSize = nDstSize;
  2105.             // Due to multi_stage conversion, this is the actual size is used
  2106.             nSrcUsed = INetConvert->_nSrcSize ;
  2107.             nSrcLeft = nSrcSize - nSrcUsed ;
  2109. #if 0
  2110.             // restore Src size
  2111.             nSrcUsed = nSrcSize ;
  2112. #endif
  2113.             // do conversion
  2114.             hr = INetConvert->DoCodeConvert(&dwMode, (LPCSTR)lpstrIn, (LPINT)&nSrcUsed, lpstrOut, (LPINT)&_nDstSize, dwFlag, lpFallBack);
  2115.             if (S_OK != hr)
  2116.                 hrWarnings = hr;
  2118.             // Write It
  2119.             hr = pstmOut->Write(lpstrOut, nDstSize, &nDstSize);
  2120.             if (S_OK != hr)
  2121.                 hrWarnings = hr;
  2123.             if (nSrcLeft )
  2124.                 MoveMemory(lpstrIn, &lpstrIn[nSrcSize-nSrcLeft],nSrcLeft);
  2126.             INetConvert->ConvertCleanUp();
  2127.         }
  2128.     }
  2130.     if (nSrcLeft )
  2131.     {
  2132.         LARGE_INTEGER   li;
  2134.         LISet32(li, -(LONG)nSrcLeft );
  2135.         hr = pstmIn->Seek(li,STREAM_SEEK_CUR, NULL);
  2136.     }
  2138.     if (lpdwMode)
  2139.         *lpdwMode = dwMode ;
  2141. exit :
  2142.     if (lpstrIn)
  2143.         LocalFree(lpstrIn);
  2144.     if (lpstrOut)
  2145.         LocalFree(lpstrOut);
  2147.     // Done
  2148.     return (hr == S_OK) ? hrWarnings : hr;
  2149. }
  2152. HRESULT WINAPI ConvertINetStringInIStream(LPDWORD lpdwMode, DWORD dwSrcEncoding, DWORD dwDstEncoding, IStream *pstmIn, IStream *pstmOut, DWORD dwFlag, WCHAR *lpFallBack)
  2153. {
  2154.     HRESULT hr;
  2155.     CICharConverter * INetConvert = new CICharConverter(dwFlag, lpFallBack) ;
  2157.     if (!INetConvert)
  2158.         return E_OUTOFMEMORY;
  2160.     hr = _ConvertINetStringInIStream(INetConvert,lpdwMode,dwSrcEncoding,dwDstEncoding,pstmIn,pstmOut,dwFlag,lpFallBack);
  2162.     delete INetConvert;
  2164.     return hr ;
  2165. }