home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / stlpt453.zip / STLport-4.5.3 / src / c_locale_win32 / c_locale_win32.c
C/C++ Source or Header  |  2001-06-19  |  49KB  |  1,736 lines
  1. /*
  2.  * Copyright (c) 1999
  3.  * Silicon Graphics Computer Systems, Inc.
  4.  *
  5.  * Copyright (c) 1999
  6.  * Boris Fomitchev
  7.  *
  8.  * Written 2000
  9.  * Anton Lapach
  10.  *
  11.  * This material is provided "as is", with absolutely no warranty expressed
  12.  * or implied. Any use is at your own risk.
  13.  *
  14.  * Permission to use or copy this software for any purpose is hereby granted
  15.  * without fee, provided the above notices are retained on all copies.
  16.  * Permission to modify the code and to distribute modified code is granted,
  17.  * provided the above notices are retained, and a notice that the code was
  18.  * modified is included with the above copyright notice.
  19.  *
  20.  */
  21.  
  22. #include <windows.h>
  23. #include <limits.h>
  24. #if defined (_STLP_MSVC) || defined (__ICL) || defined (__BORLANDC__)
  25. # include <memory.h>
  26. #endif
  27. #include <string.h>
  28. #include <locale.h>
  29. #include <stdlib.h>
  30. #include <stdio.h>
  31.  
  32. #ifdef __cplusplus
  33. // _STLP_BEGIN_NAMESPACE
  34. extern "C" {
  35. #endif
  36.  
  37. /* Framework functions */
  38. /*
  39.   locale :: "lang[_country[.code_page]]"
  40.   | ".code_page"
  41.   | ""
  42.   | NULL
  43.  
  44. */
  45.  
  46. #ifndef _LEADBYTE
  47. /* multibyte leadbyte */
  48. #define _LEADBYTE       0x8000
  49. #endif
  50.  
  51. typedef struct _LOCALECONV
  52. {
  53.   const char* name;
  54.   const char* abbrev;
  55. } LOCALECONV;
  56.  
  57. #define MAX_LANG_LEN        64  /* max language name length */
  58. #define MAX_CTRY_LEN        64  /* max country name length */
  59. #define MAX_MODIFIER_LEN    0   /* max modifier name length - n/a */
  60. #define MAX_LC_LEN          (MAX_LANG_LEN+MAX_CTRY_LEN+MAX_MODIFIER_LEN+3)
  61.                                 /* max entire locale string length */
  62. #define MAX_CP_LEN          5   /* max code page name length */
  63.  
  64.  
  65. // Metrowerks has different define here
  66. #if !defined (LC_MAX)
  67. # if defined (LC_LAST)
  68. #  define LC_MAX LC_LAST
  69. # endif
  70. #endif
  71.  
  72. //  non-NLS language string table
  73. static LOCALECONV __rg_language[] =
  74. {
  75.   {"american",                    "ENU"},
  76.   {"american english",            "ENU"},
  77.   {"american-english",            "ENU"},
  78.   {"australian",                  "ENA"},
  79.   {"belgian",                     "NLB"},
  80.   {"canadian",                    "ENC"},
  81.   {"chh",                         "ZHH"},
  82.   {"chi",                         "ZHI"},
  83.   {"chinese",                     "CHS"},
  84.   {"chinese-hongkong",            "ZHH"},
  85.   {"chinese-simplified",          "CHS"},
  86.   {"chinese-singapore",           "ZHI"},
  87.   {"chinese-traditional",         "CHT"},
  88.   {"dutch-belgian",               "NLB"},
  89.   {"english-american",            "ENU"},
  90.   {"english-aus",                 "ENA"},
  91.   {"english-belize",              "ENL"},
  92.   {"english-can",                 "ENC"},
  93.   {"english-caribbean",           "ENB"},
  94.   {"english-ire",                 "ENI"},
  95.   {"english-jamaica",             "ENJ"},
  96.   {"english-nz",                  "ENZ"},
  97.   {"english-south africa",        "ENS"},
  98.   {"english-trinidad y tobago",   "ENT"},
  99.   {"english-uk",                  "ENG"},
  100.   {"english-us",                  "ENU"},
  101.   {"english-usa",                 "ENU"},
  102.   {"french-belgian",              "FRB"},
  103.   {"french-canadian",             "FRC"},
  104.   {"french-luxembourg",           "FRL"},
  105.   {"french-swiss",                "FRS"},
  106.   {"german-austrian",             "DEA"},
  107.   {"german-lichtenstein",         "DEC"},
  108.   {"german-luxembourg",           "DEL"},
  109.   {"german-swiss",                "DES"},
  110.   {"irish-english",               "ENI"},
  111.   {"italian-swiss",               "ITS"},
  112.   {"norwegian",                   "NOR"},
  113.   {"norwegian-bokmal",            "NOR"},
  114.   {"norwegian-nynorsk",           "NON"},
  115.   {"portuguese-brazilian",        "PTB"},
  116.   {"spanish-argentina",           "ESS"},
  117.   {"spanish-bolivia",             "ESB"},
  118.   {"spanish-chile",               "ESL"},
  119.   {"spanish-colombia",            "ESO"},
  120.   {"spanish-costa rica",          "ESC"},
  121.   {"spanish-dominican republic",  "ESD"},
  122.   {"spanish-ecuador",             "ESF"},
  123.   {"spanish-el salvador",         "ESE"},
  124.   {"spanish-guatemala",           "ESG"},
  125.   {"spanish-honduras",            "ESH"},
  126.   {"spanish-mexican",             "ESM"},
  127.   {"spanish-modern",              "ESN"},
  128.   {"spanish-nicaragua",           "ESI"},
  129.   {"spanish-panama",              "ESA"},
  130.   {"spanish-paraguay",            "ESZ"},
  131.   {"spanish-peru",                "ESR"},
  132.   {"spanish-puerto rico",         "ESU"},
  133.   {"spanish-uruguay",             "ESY"},
  134.   {"spanish-venezuela",           "ESV"},
  135.   {"swedish-finland",             "SVF"},
  136.   {"swiss",                       "DES"},
  137.   {"uk",                          "ENG"},
  138.   {"us",                          "ENU"},
  139.   {"usa",                         "ENU"}
  140. };
  141.  
  142. //  non-NLS country string table
  143. static LOCALECONV __rg_country[] =
  144. {
  145.   {"america",                     "USA"},
  146.   {"britain",                     "GBR"},
  147.   {"china",                       "CHN"},
  148.   {"czech",                       "CZE"},
  149.   {"england",                     "GBR"},
  150.   {"great britain",               "GBR"},
  151.   {"holland",                     "NLD"},
  152.   {"hong-kong",                   "HKG"},
  153.   {"new-zealand",                 "NZL"},
  154.   {"nz",                          "NZL"},
  155.   {"pr china",                    "CHN"},
  156.   {"pr-china",                    "CHN"},
  157.   {"puerto-rico",                 "PRI"},
  158.   {"slovak",                      "SVK"},
  159.   {"south africa",                "ZAF"},
  160.   {"south korea",                 "KOR"},
  161.   {"south-africa",                "ZAF"},
  162.   {"south-korea",                 "KOR"},
  163.   {"trinidad & tobago",           "TTO"},
  164.   {"uk",                          "GBR"},
  165.   {"united-kingdom",              "GBR"},
  166.   {"united-states",               "USA"},
  167.   {"us",                          "USA"},
  168. };
  169.  
  170. typedef struct _Locale_ctype {
  171.   LCID lcid;
  172.   UINT cp;
  173.   unsigned int ctable[257];
  174. } _Locale_ctype_t;
  175.  
  176. typedef struct _Locale_numeric    {
  177.   LCID lcid;
  178.   char cp[MAX_CP_LEN+1];
  179.   char decimal_point[4];
  180.   char thousands_sep[4];
  181.   char *grouping;
  182. } _Locale_numeric_t;
  183.  
  184. typedef struct _Locale_time    {
  185.   LCID lcid;
  186.   char cp[MAX_CP_LEN+1];
  187.   char *month[12];
  188.   char *abbrev_month[12];
  189.   char *dayofweek[7];
  190.   char *abbrev_dayofweek[7];
  191. } _Locale_time_t;
  192.  
  193. typedef struct _Locale_collate    {
  194.   LCID lcid;
  195.   char cp[MAX_CP_LEN+1];
  196. } _Locale_collate_t;
  197.  
  198. typedef struct _Locale_monetary    {
  199.   LCID lcid;
  200.   char cp[MAX_CP_LEN+1];
  201.   char decimal_point[4];
  202.   char thousands_sep[4];
  203.   char *grouping;
  204.   char int_curr_symbol[5]; // 3+1+1
  205.   char curr_symbol[6];
  206.   char negative_sign[5];
  207.   char positive_sign[5];
  208.   int frac_digits;
  209.   int int_frac_digits;
  210. } _Locale_monetary_t;
  211.  
  212. typedef struct _Locale_messages    {
  213.   LCID lcid;
  214.   char cp[MAX_CP_LEN+1];
  215. } _Locale_messages_t;
  216.  
  217. /* Internal function */
  218. static void __FixGrouping(char *grouping);
  219. static const char* __ConvertName(const char* lname, LOCALECONV* ConvTable, int TableSize);
  220. static int __ParseLocaleString(const char* lname, char* lang, char* ctry, char* page);
  221. static int __GetLCID(const char* lang, const char* ctry, LCID* lcid);
  222. static int __GetLCIDFromName(const char* lname, LCID* lcid, char *cp);
  223. static char* __GetLocaleName(LCID lcid, const char* cp, char* buf);
  224. static char* __Extract_locale_name(const char* loc, int category, char* buf);
  225. static char* __TranslateToSystem(const char* lname, char* buf);
  226. static void __ConvertFromACP(char* buf, int buf_size, const char* cp);
  227. static int __intGetACP(LCID lcid);
  228. static int __intGetOCP(LCID lcid);
  229. static int __GetDefaultCP(LCID lcid);
  230. static char* __ConvertToCP(int from_cp, int to_cp, const char *from, size_t size, size_t *ret_buf_size);
  231. static void my_ltoa(long __x, char* buf) ;
  232.  
  233. void my_ltoa(long __x, char* buf) 
  234. { 
  235.   char rbuf[64];
  236.   char* ptr = rbuf; 
  237.  
  238.   if (__x == 0)
  239.     *ptr++ = '0';
  240.   else {
  241.     for (; __x != 0; __x /= 10)
  242.       *ptr++ = (int)(__x % 10) + '0';
  243.   }
  244.   while(ptr > rbuf) *buf++ = *--ptr;
  245.   //psw
  246.   *buf = '\0';
  247. } 
  248.  
  249. # ifdef __cplusplus
  250. _STLP_BEGIN_NAMESPACE
  251. extern "C" {
  252. # endif
  253.  
  254.   void* _Locale_ctype_create(const char * name)
  255.   {
  256.     char cname[_Locale_MAX_SIMPLE_NAME];
  257.     char cp_name[MAX_CP_LEN+1];
  258.     int NativeCP;
  259.     unsigned char Buffer[256];
  260.     unsigned char *ptr;
  261.     unsigned short ctable[256];
  262.     CPINFO CPInfo;
  263.     int i;
  264.     wchar_t *wbuffer;
  265.     int BufferSize;
  266.  
  267.     _Locale_ctype_t *ltype=(_Locale_ctype_t*)malloc(sizeof(_Locale_ctype_t));
  268.     if(!ltype) return ltype;
  269.     memset(ltype, 0, sizeof(_Locale_ctype_t));
  270.  
  271.     __Extract_locale_name(name, LC_CTYPE, cname);
  272.  
  273.     if(__GetLCIDFromName(cname, <ype->lcid, cp_name)==-1)
  274.       { free(ltype); return NULL; }
  275.     ltype->cp = atoi(cp_name);
  276.  
  277.     NativeCP=__intGetACP(ltype->lcid);
  278.     if(NativeCP == 0)
  279.       NativeCP=__intGetOCP(ltype->lcid);
  280.  
  281.     /* Make table with all characters. */
  282.     for(i = 0; i < 256; i++) Buffer[i] = i;
  283.  
  284.     if(!GetCPInfo(NativeCP, &CPInfo)) { free(ltype); return NULL; }
  285.  
  286.     if(CPInfo.MaxCharSize > 1)
  287.       for(ptr=(unsigned char*)CPInfo.LeadByte; *ptr && *(ptr+1); ptr+=2)
  288.     for(i=*ptr; i <= *(ptr+1); i++) Buffer[i] = 0;
  289.  
  290.     if(NativeCP != ltype->cp)
  291.       {
  292.         OSVERSIONINFO ver_info;
  293.         ver_info.dwOSVersionInfoSize = sizeof(ver_info);
  294.         GetVersionEx(&ver_info);
  295.         if(ver_info.dwPlatformId == VER_PLATFORM_WIN32_NT)
  296.       {
  297.         // Convert character sequence to Unicode.
  298.         BufferSize = MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, (const char*)Buffer, 256, NULL, 0);
  299.         wbuffer = (wchar_t*)malloc(BufferSize*sizeof(wchar_t));
  300.         if(!MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, (const char*)Buffer, 256, wbuffer, BufferSize))
  301.           { free(wbuffer); free(ltype); return NULL; }
  302.  
  303.         GetStringTypeW(CT_CTYPE1, wbuffer, 256, ctable);
  304.  
  305.         for(i = 0; i < 256; ++i)
  306.           ltype->ctable[i+1]=(unsigned int)ctable[i];
  307.  
  308.         if(CPInfo.MaxCharSize > 1)
  309.           for(ptr=(unsigned char*)CPInfo.LeadByte; *ptr && *(ptr+1); ptr+=2)
  310.         for(i=*ptr; i <= *(ptr+1); i++) ltype->ctable[i+1] = _LEADBYTE;
  311.  
  312.         free(wbuffer);
  313.       }
  314.         else
  315.       {
  316.         unsigned char TargetBuffer[256];
  317.         GetStringTypeA(ltype->lcid, CT_CTYPE1, (const char*)Buffer, 256, ctable);
  318.  
  319.         // Convert character sequence to target code page.
  320.         BufferSize = MultiByteToWideChar(NativeCP, MB_PRECOMPOSED, (const char*)Buffer, 256, NULL, 0);
  321.         wbuffer = (wchar_t*)malloc(BufferSize*sizeof(wchar_t));
  322.         if(!MultiByteToWideChar(NativeCP, MB_PRECOMPOSED, (const char*)Buffer, 256, wbuffer, BufferSize))
  323.           { free(wbuffer); free(ltype); return NULL; }
  324.         if(!WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuffer, BufferSize, (char*)TargetBuffer, 256, NULL, FALSE))
  325.           { free(wbuffer); free(ltype); return NULL; }
  326.  
  327.         free(wbuffer);
  328.  
  329.         // Translate ctype table.
  330.         for(i = 0; i < 256; ++i)
  331.           {
  332.         if(!TargetBuffer[i]) continue;
  333.         ltype->ctable[TargetBuffer[i]+1] = ctable[i];
  334.           }
  335.         ltype->ctable[0] = 0; // EOF
  336.  
  337.         // Mark lead byte.
  338.         if(!GetCPInfo(ltype->cp, &CPInfo)) { free(ltype); return NULL; }
  339.         if(CPInfo.MaxCharSize > 1)
  340.           for(ptr=(unsigned char*)CPInfo.LeadByte; *ptr && *(ptr+1); ptr+=2)
  341.         for(i=*ptr; i <= *(ptr+1); i++) ltype->ctable[i+1] = _LEADBYTE;
  342.       }
  343.       }
  344.     else
  345.       {
  346.     GetStringTypeA(ltype->lcid, CT_CTYPE1, (const char*)Buffer, 256, ctable);
  347.     for(i = 0; i < 256; ++i)
  348.       ltype->ctable[i+1]=(unsigned int)ctable[i];
  349.  
  350.         if(CPInfo.MaxCharSize > 1)
  351.       for(ptr=(unsigned char*)CPInfo.LeadByte; *ptr && *(ptr+1); ptr+=2)
  352.         for(i=*ptr; i <= *(ptr+1); i++) ltype->ctable[i+1] = _LEADBYTE;
  353.       }
  354.     ltype->ctable[0] = 0; // EOF
  355.  
  356.     return ltype;
  357.   }
  358.  
  359.   void* _Locale_numeric_create(const char * name)
  360.   {
  361.     char *GroupingBuffer;
  362.     char cname[_Locale_MAX_SIMPLE_NAME];
  363.     int BufferSize;
  364.     _Locale_numeric_t *lnum=(_Locale_numeric_t*)malloc(sizeof(_Locale_numeric_t));
  365.     if(!lnum) return lnum; // MS normal behavior for 'new'
  366.  
  367.     __Extract_locale_name(name, LC_NUMERIC, cname);
  368.  
  369.     if(__GetLCIDFromName(cname, &lnum->lcid, lnum->cp)==-1)
  370.       { free(lnum); return NULL; }
  371.  
  372.     GetLocaleInfoA(lnum->lcid, LOCALE_SDECIMAL, lnum->decimal_point, 4);
  373.     __ConvertFromACP(lnum->decimal_point, 4, lnum->cp);
  374.     GetLocaleInfoA(lnum->lcid, LOCALE_STHOUSAND, lnum->thousands_sep, 4);
  375.     __ConvertFromACP(lnum->thousands_sep, 4, lnum->cp);
  376.  
  377.     BufferSize=GetLocaleInfoA(lnum->lcid, LOCALE_SGROUPING, NULL, 0);
  378.     GroupingBuffer=(char*)malloc(BufferSize);
  379.     if(!GroupingBuffer) { lnum->grouping=NULL; return lnum; }
  380.     GetLocaleInfoA(lnum->lcid, LOCALE_SGROUPING, GroupingBuffer, BufferSize);
  381.     __FixGrouping(GroupingBuffer);
  382.     lnum->grouping=GroupingBuffer;
  383.  
  384.     return lnum;
  385.   }
  386.  
  387.   void* _Locale_time_create(const char * name)
  388.   {
  389.     int size, month, dayofweek;
  390.     char cname[_Locale_MAX_SIMPLE_NAME];
  391.  
  392.     _Locale_time_t *ltime=(_Locale_time_t*)malloc(sizeof(_Locale_time_t));;
  393.     if(!ltime) return ltime;
  394.     memset(ltime, 0, sizeof(_Locale_time_t));
  395.  
  396.     __Extract_locale_name(name, LC_TIME, cname);
  397.  
  398.     if(__GetLCIDFromName(cname, <ime->lcid, ltime->cp)==-1)
  399.       { free(ltime); return NULL; }
  400.  
  401.     for(month=LOCALE_SMONTHNAME1; month<=LOCALE_SMONTHNAME12; month++) // Small hack :-)
  402.       {
  403.     size=GetLocaleInfoA(ltime->lcid, month, NULL, 0);
  404.         ltime->month[month-LOCALE_SMONTHNAME1]=(char*)malloc(size);
  405.         if(!ltime->month[month-LOCALE_SMONTHNAME1]) { _Locale_time_destroy(ltime); return NULL; }
  406.     GetLocaleInfoA(ltime->lcid, month, ltime->month[month-LOCALE_SMONTHNAME1], size);
  407.         __ConvertFromACP(ltime->month[month-LOCALE_SMONTHNAME1], size, ltime->cp);
  408.       }
  409.  
  410.     for(month=LOCALE_SABBREVMONTHNAME1; month<=LOCALE_SABBREVMONTHNAME12; month++)
  411.       {
  412.     size=GetLocaleInfoA(ltime->lcid, month, NULL, 0);
  413.     ltime->abbrev_month[month-LOCALE_SABBREVMONTHNAME1]=(char*)malloc(size);
  414.     if(!ltime->abbrev_month[month-LOCALE_SABBREVMONTHNAME1]) { _Locale_time_destroy(ltime); return NULL; }
  415.     GetLocaleInfoA(ltime->lcid, month, ltime->abbrev_month[month-LOCALE_SABBREVMONTHNAME1], size);
  416.     __ConvertFromACP(ltime->abbrev_month[month-LOCALE_SABBREVMONTHNAME1], size, ltime->cp);
  417.       }
  418.  
  419.     for(dayofweek=LOCALE_SDAYNAME1; dayofweek<=LOCALE_SDAYNAME7; dayofweek++)
  420.       {
  421.     int dayindex= ( dayofweek != LOCALE_SDAYNAME7 ) ?
  422.       dayofweek-LOCALE_SDAYNAME1+1 : 0;
  423.     size=GetLocaleInfoA(ltime->lcid, dayofweek, NULL, 0);
  424.     ltime->dayofweek[dayindex]=(char*)malloc(size);
  425.     if(!ltime->dayofweek[dayindex] ) { _Locale_time_destroy(ltime); return NULL; }
  426.     GetLocaleInfoA(ltime->lcid, dayofweek, ltime->dayofweek[dayindex], size);
  427.     __ConvertFromACP(ltime->dayofweek[dayindex], size, ltime->cp);
  428.       }
  429.  
  430.     for(dayofweek=LOCALE_SABBREVDAYNAME1; dayofweek<=LOCALE_SABBREVDAYNAME7; dayofweek++)
  431.       {
  432.     int dayindex= ( dayofweek != LOCALE_SABBREVDAYNAME7 ) ?
  433.       dayofweek-LOCALE_SABBREVDAYNAME1+1 : 0;
  434.     size=GetLocaleInfoA(ltime->lcid, dayofweek, NULL, 0);
  435.     ltime->abbrev_dayofweek[dayindex]=(char*)malloc(size);
  436.     if(!ltime->abbrev_dayofweek[dayindex]) { _Locale_time_destroy(ltime); return NULL; }
  437.     GetLocaleInfoA(ltime->lcid, dayofweek, ltime->abbrev_dayofweek[dayindex], size);
  438.     __ConvertFromACP(ltime->abbrev_dayofweek[dayindex], size, ltime->cp);
  439.       }
  440.  
  441.     return ltime;
  442.   }
  443.  
  444.   void* _Locale_collate_create(const char * name)
  445.   {
  446.     char cname[_Locale_MAX_SIMPLE_NAME];
  447.  
  448.     _Locale_collate_t *lcol=(_Locale_collate_t*)malloc(sizeof(_Locale_collate_t));
  449.     if(!lcol) return lcol;
  450.     memset(lcol, 0, sizeof(_Locale_collate_t));
  451.  
  452.     __Extract_locale_name(name, LC_COLLATE, cname);
  453.  
  454.     if(__GetLCIDFromName(cname, &lcol->lcid, lcol->cp)==-1)
  455.       { free(lcol); return NULL; }
  456.  
  457.     return lcol;
  458.   }
  459.  
  460.   void* _Locale_monetary_create(const char * name)
  461.   {
  462.     char cname[_Locale_MAX_SIMPLE_NAME];
  463.     char *GroupingBuffer;
  464.     int BufferSize;
  465.     char FracDigits[3];
  466.  
  467.     _Locale_monetary_t *lmon=(_Locale_monetary_t*)malloc(sizeof(_Locale_monetary_t));
  468.     if(!lmon) return lmon;
  469.     memset(lmon, 0, sizeof(_Locale_monetary_t));
  470.  
  471.     __Extract_locale_name(name, LC_MONETARY, cname);
  472.  
  473.     if(__GetLCIDFromName(cname, &lmon->lcid, lmon->cp)==-1)
  474.       { free(lmon); return NULL; }
  475.  
  476.     // Extract information about monetary system
  477.     GetLocaleInfoA(lmon->lcid, LOCALE_SDECIMAL, lmon->decimal_point, 4);
  478.     __ConvertFromACP(lmon->decimal_point, 4, lmon->cp);
  479.     GetLocaleInfoA(lmon->lcid, LOCALE_STHOUSAND, lmon->thousands_sep, 4);
  480.     __ConvertFromACP(lmon->thousands_sep, 4, lmon->cp);
  481.  
  482.     BufferSize=GetLocaleInfoA(lmon->lcid, LOCALE_SGROUPING, NULL, 0);
  483.     GroupingBuffer=(char*)malloc(BufferSize);
  484.     if(!GroupingBuffer) { lmon->grouping=NULL; return lmon; }
  485.     GetLocaleInfoA(lmon->lcid, LOCALE_SGROUPING, GroupingBuffer, BufferSize);
  486.     __FixGrouping(GroupingBuffer);
  487.     lmon->grouping=GroupingBuffer;
  488.  
  489.     GetLocaleInfoA(lmon->lcid, LOCALE_SCURRENCY, lmon->curr_symbol, 6);
  490.     __ConvertFromACP(lmon->curr_symbol, 6, lmon->cp);
  491.  
  492.     GetLocaleInfoA(lmon->lcid, LOCALE_SNEGATIVESIGN, lmon->negative_sign, 5);
  493.     __ConvertFromACP(lmon->negative_sign, 5, lmon->cp);
  494.  
  495.     GetLocaleInfoA(lmon->lcid, LOCALE_SPOSITIVESIGN, lmon->positive_sign, 5);
  496.     __ConvertFromACP(lmon->positive_sign, 5, lmon->cp);
  497.  
  498.     GetLocaleInfoA(lmon->lcid, LOCALE_ICURRDIGITS, FracDigits, 3);
  499.     lmon->frac_digits=atoi(FracDigits);
  500.  
  501.     GetLocaleInfoA(lmon->lcid, LOCALE_IINTLCURRDIGITS, FracDigits, 3);
  502.     lmon->int_frac_digits=atoi(FracDigits);
  503.  
  504.     GetLocaleInfoA(lmon->lcid, LOCALE_SINTLSYMBOL, lmon->int_curr_symbol, 5);
  505.  
  506.     return lmon;
  507.   }
  508.  
  509.   void* _Locale_messages_create(const char *name)
  510.   {
  511.     _Locale_messages_t *lmes=(_Locale_messages_t*)malloc(sizeof(_Locale_messages_t));
  512.     if(!lmes) return lmes;
  513.     memset(lmes, 0, sizeof(_Locale_messages_t));
  514.  
  515.     return lmes;
  516.   }
  517.  
  518.   const char* _Locale_common_default(char* buf)
  519.   {
  520.     char cp[MAX_CP_LEN+1];
  521.     int CodePage=__intGetACP(LOCALE_USER_DEFAULT);
  522.     if(!CodePage) CodePage=__intGetOCP(LOCALE_USER_DEFAULT);
  523.     my_ltoa(CodePage, cp);
  524.     return __GetLocaleName(LOCALE_USER_DEFAULT, cp, buf);
  525.   }
  526.  
  527.   const char* _Locale_ctype_default(char* buf)
  528.   {
  529.     return  _Locale_common_default(buf);
  530.   }
  531.  
  532.   const char* _Locale_numeric_default(char * buf)
  533.   {
  534.     return  _Locale_common_default(buf);
  535.   }
  536.  
  537.   const char* _Locale_time_default(char* buf)
  538.   {
  539.     return  _Locale_common_default(buf);
  540.   }
  541.  
  542.   const char* _Locale_collate_default(char* buf)
  543.   {
  544.     return  _Locale_common_default(buf);
  545.   }
  546.  
  547.   const char* _Locale_monetary_default(char* buf)
  548.   {
  549.     return  _Locale_common_default(buf);
  550.   }
  551.  
  552.   const char* _Locale_messages_default(char* buf)
  553.   {
  554.     return  _Locale_common_default(buf);
  555.   }
  556.  
  557.   char* _Locale_ctype_name(const void* loc, char* buf)
  558.   {
  559.     char cp_buf[MAX_CP_LEN+1];
  560.     _Locale_ctype_t* ltype=(_Locale_ctype_t*)loc;
  561.     my_ltoa(ltype->cp, cp_buf);
  562.     return __GetLocaleName(ltype->lcid, cp_buf, buf);
  563.   }
  564.  
  565.   char* _Locale_numeric_name(const void* loc, char* buf)
  566.   {
  567.     _Locale_numeric_t* lnum=(_Locale_numeric_t*)loc;
  568.     return __GetLocaleName(lnum->lcid, lnum->cp, buf);
  569.   }
  570.  
  571.   char* _Locale_time_name(const void* loc, char* buf)
  572.   {
  573.     _Locale_time_t* ltime=(_Locale_time_t*)loc;
  574.     return __GetLocaleName(ltime->lcid, ltime->cp, buf);
  575.   }
  576.  
  577.   char* _Locale_collate_name(const void* loc, char* buf)
  578.   {
  579.     _Locale_collate_t* lcol=(_Locale_collate_t*)loc;
  580.     return __GetLocaleName(lcol->lcid, lcol->cp, buf);
  581.   }
  582.  
  583.   char* _Locale_monetary_name(const void* loc, char* buf)
  584.   {
  585.     _Locale_monetary_t* lmon=(_Locale_monetary_t*)loc;
  586.     return __GetLocaleName(lmon->lcid, lmon->cp, buf);
  587.   }
  588.  
  589.   char* _Locale_messages_name(const void* loc, char* buf)
  590.   {
  591.     _Locale_messages_t* lmes=(_Locale_messages_t*)loc;
  592.     return __GetLocaleName(lmes->lcid, lmes->cp, buf);
  593.   }
  594.  
  595.   void _Locale_ctype_destroy(void* loc)
  596.   {
  597.     _Locale_ctype_t *ltype=(_Locale_ctype_t*)loc;
  598.     if(!ltype) return;
  599.  
  600.     free(ltype);
  601.   }
  602.  
  603.   void _Locale_numeric_destroy(void* loc)
  604.   {
  605.     _Locale_numeric_t *lnum=(_Locale_numeric_t *)loc;
  606.     if(!lnum) return;
  607.  
  608.     if(lnum->grouping) free(lnum->grouping);
  609.     free(lnum);
  610.   }
  611.  
  612.   void _Locale_time_destroy(void* loc)
  613.   {
  614.     int i;
  615.     _Locale_time_t* ltime=(_Locale_time_t*)loc;
  616.     if(!ltime) return;
  617.  
  618.     for(i=0; i<12; i++)
  619.       {
  620.         if(ltime->month[i]) free(ltime->month[i]);
  621.         if(ltime->abbrev_month[i]) free(ltime->abbrev_month[i]);
  622.       }
  623.  
  624.     for(i=0; i<7; i++)
  625.       {
  626.         if(ltime->dayofweek[i]) free(ltime->dayofweek[i]);
  627.         if(ltime->abbrev_dayofweek[i]) free(ltime->abbrev_dayofweek[i]);
  628.       }
  629.  
  630.     free(ltime);
  631.   }
  632.  
  633.   void _Locale_collate_destroy(void* loc)
  634.   {
  635.     _Locale_collate_t* lcol=(_Locale_collate_t*)loc;
  636.     if(!lcol) return;
  637.  
  638.     free(lcol);
  639.   }
  640.  
  641.   void _Locale_monetary_destroy(void* loc)
  642.   {
  643.     struct _Locale_monetary *lmon=(struct _Locale_monetary *)loc;
  644.     if(!lmon) return;
  645.  
  646.     if(lmon->grouping) free(lmon->grouping);
  647.     free(lmon);
  648.   }
  649.  
  650.   void _Locale_messages_destroy(void* loc)
  651.   {
  652.     _Locale_messages_t* lmes=(_Locale_messages_t*)loc;
  653.     if(!lmes) return;
  654.  
  655.     free(lmes);
  656.   }
  657.  
  658.   char* _Locale_extract_ctype_name(const char* cname, char* buf) 
  659.   {
  660.     char lname[_Locale_MAX_SIMPLE_NAME];
  661.     __Extract_locale_name(cname, LC_CTYPE, lname);
  662.     if(lname[0] == 'C' && lname[1] == 0) return strcpy(buf, lname);
  663.     return __TranslateToSystem(lname, buf);
  664.   }
  665.  
  666.   char* _Locale_extract_numeric_name(const char* cname, char* buf) 
  667.   {
  668.     char lname[_Locale_MAX_SIMPLE_NAME];
  669.     __Extract_locale_name(cname, LC_NUMERIC, lname);
  670.     if(lname[0] == 'C' && lname[1] == 0) return strcpy(buf, lname);
  671.     return __TranslateToSystem(lname, buf);
  672.   }
  673.  
  674.   char* _Locale_extract_time_name(const char* cname, char* buf) 
  675.   {
  676.     char lname[_Locale_MAX_SIMPLE_NAME];
  677.     __Extract_locale_name(cname, LC_TIME, lname);
  678.     if(lname[0] == 'C' && lname[1] == 0) return strcpy(buf, lname);
  679.     return __TranslateToSystem(lname, buf);
  680.   }
  681.  
  682.   char* _Locale_extract_collate_name(const char* cname, char* buf) 
  683.   {
  684.     char lname[_Locale_MAX_SIMPLE_NAME];
  685.     __Extract_locale_name(cname, LC_COLLATE, lname);
  686.     if(lname[0] == 'C' && lname[1] == 0) return strcpy(buf, lname);
  687.     return __TranslateToSystem(lname, buf);
  688.   }
  689.  
  690.   char* _Locale_extract_monetary_name(const char* cname, char* buf) 
  691.   {
  692.     char lname[_Locale_MAX_SIMPLE_NAME];
  693.     __Extract_locale_name(cname, LC_MONETARY, lname);
  694.     if(lname[0] == 'C' && lname[1] == 0) return strcpy(buf, lname);
  695.     return __TranslateToSystem(lname, buf);
  696.   }
  697.  
  698.   char* _Locale_extract_messages_name(const char* cname, char* buf) 
  699.   {
  700.     if(cname[0] == 'L' && cname[1] == 'C' && cname[2] == '_')
  701.       return strcpy(buf, "C");
  702.     return strcpy(buf, cname);
  703.   }
  704.  
  705.   char* _Locale_compose_name(char* buf,
  706.                  const char* _ctype, const char* numeric,
  707.                  const char* time, const char* _collate,
  708.                  const char* monetary, const char* messages)
  709.   {
  710.     if(!strcmp(_ctype, numeric) &&\
  711.        !strcmp(_ctype, time) &&\
  712.        !strcmp(_ctype, _collate) &&\
  713.        !strcmp(_ctype, monetary) &&\
  714.        !strcmp(_ctype, messages))
  715.       return strcpy(buf, _ctype);
  716.  
  717.     strcpy(buf, "LC_CTYPE="); strcat(buf, _ctype); strcat(buf, ";");
  718.     strcat(buf, "LC_TIME="); strcat(buf, time); strcat(buf, ";");
  719.     strcat(buf, "LC_NUMERIC="); strcat(buf, numeric); strcat(buf, ";");
  720.     strcat(buf, "LC_COLLATE="); strcat(buf, _collate); strcat(buf, ";");
  721.     strcat(buf, "LC_MONETARY="); strcat(buf, monetary); strcat(buf, ";");
  722.     strcat(buf, "LC_MESSAGES="); strcat(buf, messages); strcat(buf, ";");
  723.  
  724.     return buf;
  725.   }
  726.  
  727.   /* ctype */
  728.  
  729.   _Locale_mask_t* _Locale_ctype_table(struct _Locale_ctype* ltype)
  730.   {
  731.     return (_Locale_mask_t*)ltype->ctable;
  732.   }
  733.  
  734.   int _Locale_toupper(struct _Locale_ctype* ltype, int c)
  735.   {
  736.     char buf[2], out_buf[2];;
  737.     buf[0] = (char)c; buf[1] = 0;
  738.     if(__GetDefaultCP(ltype->lcid) == ltype->cp)
  739.       {
  740.     LCMapStringA(ltype->lcid, LCMAP_LINGUISTIC_CASING | LCMAP_UPPERCASE, buf, 2, out_buf, 2);
  741.     return out_buf[0];
  742.       }
  743.     else
  744.       {
  745.     wchar_t wbuf[2];
  746.         MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, buf, 2, wbuf, 2);
  747.     WideCharToMultiByte(__GetDefaultCP(ltype->lcid), WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, buf, 2, NULL, FALSE);
  748.  
  749.     LCMapStringA(ltype->lcid, LCMAP_LINGUISTIC_CASING | LCMAP_UPPERCASE, buf, 2, out_buf, 2);
  750.  
  751.         MultiByteToWideChar(__GetDefaultCP(ltype->lcid), MB_PRECOMPOSED, out_buf, 2, wbuf, 2);
  752.     WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, out_buf, 2, NULL, FALSE);
  753.     return out_buf[0];
  754.       }
  755.   }
  756.  
  757.   int _Locale_tolower(struct _Locale_ctype* ltype, int c)
  758.   {
  759.     char buf[2], out_buf[2];;
  760.     buf[0] = (char)c; buf[1] = 0;
  761.     if(__GetDefaultCP(ltype->lcid) == ltype->cp)
  762.       {
  763.     LCMapStringA(ltype->lcid, LCMAP_LINGUISTIC_CASING | LCMAP_LOWERCASE, buf, 2, out_buf, 2);
  764.     return out_buf[0];
  765.       }
  766.     else
  767.       {
  768.     wchar_t wbuf[2];
  769.         MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, buf, 2, wbuf, 2);
  770.     WideCharToMultiByte(__GetDefaultCP(ltype->lcid), WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, buf, 2, NULL, FALSE);
  771.  
  772.     LCMapStringA(ltype->lcid, LCMAP_LINGUISTIC_CASING | LCMAP_LOWERCASE, buf, 2, out_buf, 2);
  773.  
  774.         MultiByteToWideChar(__GetDefaultCP(ltype->lcid), MB_PRECOMPOSED, out_buf, 2, wbuf, 2);
  775.     WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, out_buf, 2, NULL, FALSE);
  776.     return out_buf[0];
  777.       }
  778.   }
  779.  
  780. # ifndef _STLP_NO_WCHAR_T
  781.   _Locale_mask_t _Locale_wchar_ctype(struct _Locale_ctype* ltype, wint_t c)
  782.   {
  783.     wchar_t buf[2];
  784.     WORD out[2];
  785.     buf[0] = c; buf[1] = 0;
  786.     GetStringTypeW(CT_CTYPE1, buf, -1, out);
  787.  
  788.     return (_Locale_mask_t)out[0];
  789.     //    ltype;
  790.   }
  791.  
  792.   wint_t _Locale_wchar_tolower(struct _Locale_ctype* ltype, wint_t c)
  793.   {
  794.     wint_t res;
  795.  
  796.     LCMapStringW(ltype->lcid, LCMAP_LOWERCASE, &c, 1, &res, 1);
  797.     return res;
  798.   }
  799.  
  800.   wint_t _Locale_wchar_toupper(struct _Locale_ctype* ltype, wint_t c)
  801.   {
  802.     wint_t res;
  803.  
  804.     LCMapStringW(ltype->lcid, LCMAP_UPPERCASE, &c, 1, &res, 1);
  805.     return res;
  806.   }
  807. # endif
  808.  
  809. # ifndef _STLP_NO_MBSTATE_T
  810.  
  811.   int _Locale_mb_cur_max (struct _Locale_ctype * ltype)
  812.   {
  813.     CPINFO CPInfo;
  814.     if(!GetCPInfo(ltype->cp, &CPInfo)) return 0;
  815.     return CPInfo.MaxCharSize;
  816.   }
  817.  
  818.   int _Locale_mb_cur_min (struct _Locale_ctype *dummy)
  819.   { return 1; }
  820.  
  821.   int _Locale_is_stateless (struct _Locale_ctype * ltype)
  822.   {
  823.     CPINFO CPInfo;
  824.     GetCPInfo(ltype->cp, &CPInfo);
  825.     return (CPInfo.MaxCharSize == 1) ? 1 : 0;
  826.   }
  827.  
  828.   wint_t _Locale_btowc(struct _Locale_ctype * ltype, int c)
  829.   {
  830.     wchar_t wc;
  831.     if(c == EOF) return WEOF;
  832.  
  833.     MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, (char*)&c, 1, &wc, 1);
  834.  
  835.     return (wint_t)wc;
  836.   }
  837.  
  838.   int _Locale_wctob(struct _Locale_ctype * ltype, wint_t wc)
  839.   {
  840.     char c;
  841.  
  842.     if(WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_DEFAULTCHAR, (wchar_t*)&wc, 1, &c, 1, NULL, NULL) == 0)
  843.       return WEOF; // Not single byte or error conversion.
  844.  
  845.     return (int)c;
  846.   }
  847.  
  848.   static int __isleadbyte(int c, unsigned int *ctable)
  849.   {
  850.     return (ctable[(unsigned char)(c)] & _LEADBYTE);
  851.   }
  852.  
  853.   static size_t __mbtowc(struct _Locale_ctype *l, wchar_t *dst, char src, mbstate_t *shift_state)
  854.   {
  855.     int result;
  856.  
  857.     if(*shift_state == 0)
  858.       {
  859.     if(__isleadbyte(src, l->ctable))
  860.       {
  861.         ((unsigned char*)shift_state)[0] = src;
  862.         return (size_t)-2;
  863.       }
  864.     else
  865.       {
  866.         result = MultiByteToWideChar(l->cp, MB_PRECOMPOSED, &src, 1, dst, 1);
  867.         if(result == 0) return (size_t)-1;
  868.  
  869.         return 1;
  870.       }
  871.       }
  872.     else
  873.       {
  874.     ((unsigned char*)shift_state)[1] = src;
  875.     result = MultiByteToWideChar(l->cp, MB_PRECOMPOSED, (const char*)shift_state, 2, dst, 1);
  876.     *shift_state = 0;
  877.     if(result == 0) return (size_t)-1;
  878.  
  879.     return 1;
  880.       }
  881.   }
  882.  
  883.   size_t _Locale_mbtowc(struct _Locale_ctype *ltype,
  884.             wchar_t *to,
  885.             const char *from, size_t n,
  886.             mbstate_t *shift_state)
  887.   {
  888.     CPINFO ci;
  889.     int result;
  890.  
  891.     GetCPInfo(ltype->cp, &ci);
  892.     if(ci.MaxCharSize == 1) // Single byte encoding.
  893.       {
  894.     *shift_state = (mbstate_t)0;
  895.     result = MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, from, 1, to, 1);
  896.     if(result == 0) return (size_t)-1;
  897.     return result;
  898.       }
  899.     else // Multi byte encoding.
  900.       {
  901.         size_t retval, count = 0;
  902.         while(n--)
  903.       {
  904.         retval = __mbtowc(ltype, to, *from, shift_state);
  905.         if(retval == -2) { from++; count++; }
  906.         else if(retval == -1) return -1;
  907.         else return count+retval;
  908.       }
  909.         if(retval == -2) return (size_t)-2;
  910.  
  911.         return n;
  912.       }
  913.   }
  914.  
  915.   size_t _Locale_wctomb(struct _Locale_ctype *ltype,
  916.             char *to, size_t n,
  917.             const wchar_t c,
  918.             mbstate_t *shift_state)
  919.   {
  920.     int size = \
  921.       WideCharToMultiByte(ltype->cp,  WC_COMPOSITECHECK | WC_SEPCHARS, &c, 1, NULL, 0, NULL, NULL);
  922.  
  923.     if(size > n) return (size_t)-2;
  924.  
  925.     size = \
  926.       WideCharToMultiByte(ltype->cp,  WC_COMPOSITECHECK | WC_SEPCHARS, &c, 1, to, n, NULL, NULL);
  927.  
  928.     if(size == 0) return (size_t)-1;
  929.  
  930.     return (size_t)size;
  931.   }
  932.  
  933.   size_t _Locale_unshift(struct _Locale_ctype *ltype,
  934.              mbstate_t *st,
  935.              char *buf, size_t n, char **next)
  936.   {
  937.     if(*st == 0)
  938.       {
  939.     *next = buf;
  940.     return 0;
  941.       }
  942.     else
  943.       {
  944.     if(n < 1) { *next = buf; return (size_t)-2; }
  945.  
  946.     *next = buf + 1;
  947.     return 1;
  948.       }
  949.   }
  950.  
  951. # endif /*  _STLP_NO_MBSTATE_T */
  952.  
  953.  
  954. # ifndef CSTR_EQUAL /* VC5SP3*/
  955. # define CSTR_EQUAL 2
  956. # endif
  957. # ifndef CSTR_LESS_THAN /* VC5SP3 */
  958. # define CSTR_LESS_THAN 1
  959. # endif
  960.  
  961.   /* Collate */
  962.   int _Locale_strcmp(struct _Locale_collate* lcol,
  963.              const char* s1, size_t n1,
  964.              const char* s2, size_t n2)
  965.   {
  966.     int result;
  967.     if(__GetDefaultCP(lcol->lcid) == atoi(lcol->cp))
  968.       {
  969.     result=CompareStringA(lcol->lcid, 0, s1, n1, s2, n2);
  970.       }
  971.     else
  972.       {
  973.     char *buf1, *buf2;
  974.     size_t size1, size2;
  975.     buf1 = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lcid), s1, n1, &size1);
  976.     buf2 = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lcid), s2, n2, &size2);
  977.  
  978.     result=CompareStringA(lcol->lcid, 0, buf1, size1, buf2, size2);
  979.     free(buf1); free(buf2);
  980.       }
  981.     return (result == CSTR_EQUAL) ? 0 : (result == CSTR_LESS_THAN) ? -1 : 1;
  982.   }
  983.  
  984. # ifndef _STLP_NO_WCHAR_T
  985.  
  986.   int _Locale_strwcmp(struct _Locale_collate* lcol,
  987.               const wchar_t* s1, size_t n1,
  988.               const wchar_t* s2, size_t n2)
  989.   {
  990.     int result;
  991.     result=CompareStringW(lcol->lcid, 0, s1, n1, s2, n2);
  992.     return (result == CSTR_EQUAL) ? 0 : (result == CSTR_LESS_THAN) ? -1 : 1;
  993.   }
  994.  
  995. # endif
  996.  
  997.   size_t _Locale_strxfrm(struct _Locale_collate* lcol,
  998.              char* dst, size_t dst_size,
  999.              const char* src, size_t src_size)
  1000.   {
  1001.     if(__GetDefaultCP(lcol->lcid) == atoi(lcol->cp))
  1002.       return LCMapStringA(lcol->lcid, LCMAP_SORTKEY, src, src_size, dst, dst_size);
  1003.     else
  1004.       {
  1005.     int result;
  1006.     char *buf;
  1007.     size_t size;
  1008.     buf = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lcid), src, src_size, &size);
  1009.  
  1010.     result=LCMapStringA(lcol->lcid, LCMAP_SORTKEY, buf, size, dst, dst_size);
  1011.     free(buf);
  1012.     return result;
  1013.       }
  1014.   }
  1015.  
  1016. # ifndef _STLP_NO_WCHAR_T
  1017.  
  1018.   size_t _Locale_strwxfrm(struct _Locale_collate* lcol,
  1019.                           wchar_t* dst, size_t dst_size,
  1020.                           const wchar_t* src, size_t src_size)
  1021.   {
  1022.     return LCMapStringW(lcol->lcid, LCMAP_SORTKEY, src, src_size, dst, dst_size);
  1023.   }
  1024.  
  1025. # endif
  1026.  
  1027.   /* Numeric */
  1028.  
  1029.   static const char* __true_name="true";
  1030.   static const char* __false_name="false";
  1031.  
  1032.   char _Locale_decimal_point(struct _Locale_numeric* lnum)
  1033.   {
  1034.     return lnum->decimal_point[0];
  1035.   }
  1036.  
  1037.   char _Locale_thousands_sep(struct _Locale_numeric* lnum)
  1038.   {
  1039.     return lnum->thousands_sep[0];
  1040.   }
  1041.  
  1042.   const char* _Locale_grouping(struct _Locale_numeric * lnum)
  1043.   {
  1044.     if(!lnum->grouping) return "";
  1045.     else return lnum->grouping;
  1046.   }
  1047.  
  1048.   const char * _Locale_true(struct _Locale_numeric * lnum)
  1049.   {
  1050.     return __true_name; // NT does't provide information about this
  1051.   }
  1052.  
  1053.   const char * _Locale_false(struct _Locale_numeric * lnum)
  1054.   {
  1055.     return __false_name; // NT does't provide information about this
  1056.   }
  1057.  
  1058.  
  1059.   /* Monetary */
  1060.  
  1061.   const char* _Locale_int_curr_symbol(struct _Locale_monetary * lmon)
  1062.   {
  1063.     return lmon->int_curr_symbol;
  1064.   }
  1065.  
  1066.   const char* _Locale_currency_symbol(struct _Locale_monetary * lmon)
  1067.   {
  1068.     return lmon->curr_symbol;
  1069.   }
  1070.  
  1071.   char        _Locale_mon_decimal_point(struct _Locale_monetary * lmon)
  1072.   {
  1073.     return lmon->decimal_point[0];
  1074.   }
  1075.  
  1076.   char        _Locale_mon_thousands_sep(struct _Locale_monetary * lmon)
  1077.   {
  1078.     return lmon->thousands_sep[0];
  1079.   }
  1080.  
  1081.   const char* _Locale_mon_grouping(struct _Locale_monetary * lmon)
  1082.   {
  1083.     if(!lmon->grouping) return "";
  1084.     else return lmon->grouping;
  1085.   }
  1086.  
  1087.   const char* _Locale_positive_sign(struct _Locale_monetary * lmon)
  1088.   {
  1089.     return lmon->positive_sign;
  1090.   }
  1091.  
  1092.   const char* _Locale_negative_sign(struct _Locale_monetary * lmon)
  1093.   {
  1094.     return lmon->negative_sign;
  1095.   }
  1096.  
  1097.   char        _Locale_int_frac_digits(struct _Locale_monetary * lmon)
  1098.   {
  1099.     return (char)lmon->int_frac_digits;
  1100.   }
  1101.  
  1102.   char        _Locale_frac_digits(struct _Locale_monetary * lmon)
  1103.   {
  1104.     return (char)lmon->frac_digits;
  1105.   }
  1106.  
  1107.   int         _Locale_p_cs_precedes(struct _Locale_monetary * lmon)
  1108.   {
  1109.     char loc_data[2];
  1110.     GetLocaleInfoA(lmon->lcid, LOCALE_IPOSSYMPRECEDES, loc_data, 2);
  1111.     if(loc_data[0]=='0') return 0;
  1112.     else if(loc_data[0]=='1') return 1;
  1113.     else return -1;
  1114.   }
  1115.  
  1116.   int         _Locale_p_sep_by_space(struct _Locale_monetary * lmon)
  1117.   {
  1118.     char loc_data[2];
  1119.     GetLocaleInfoA(lmon->lcid, LOCALE_IPOSSEPBYSPACE, loc_data, 2);
  1120.     if(loc_data[0]=='0') return 0;
  1121.     else if(loc_data[0]=='1') return 1;
  1122.     else return -1;
  1123.   }
  1124.  
  1125.   int         _Locale_p_sign_posn(struct _Locale_monetary * lmon)
  1126.   {
  1127.     char loc_data[2];
  1128.     GetLocaleInfoA(lmon->lcid, LOCALE_IPOSSIGNPOSN, loc_data, 2);
  1129.     return atoi(loc_data);
  1130.   }
  1131.  
  1132.   int         _Locale_n_cs_precedes(struct _Locale_monetary * lmon)
  1133.   {
  1134.     char loc_data[2];
  1135.     GetLocaleInfoA(lmon->lcid, LOCALE_INEGSYMPRECEDES, loc_data, 2);
  1136.     if(loc_data[0]=='0') return 0;
  1137.     else if(loc_data[0]=='1') return 1;
  1138.     else return -1;
  1139.   }
  1140.  
  1141.   int          _Locale_n_sep_by_space(struct _Locale_monetary * lmon)
  1142.   {
  1143.     char loc_data[2];
  1144.     GetLocaleInfoA(lmon->lcid, LOCALE_INEGSEPBYSPACE, loc_data, 2);
  1145.     if(loc_data[0]=='0') return 0;
  1146.     else if(loc_data[0]=='1') return 1;
  1147.     else return -1;
  1148.   }
  1149.  
  1150.   int          _Locale_n_sign_posn(struct _Locale_monetary * lmon)
  1151.   {
  1152.     char loc_data[2];
  1153.     GetLocaleInfoA(lmon->lcid, LOCALE_INEGSIGNPOSN, loc_data, 2);
  1154.     return atoi(loc_data);
  1155.   }
  1156.  
  1157.  
  1158.   /* Time */
  1159.   const char ** _Locale_full_monthname(struct _Locale_time * ltime)
  1160.   {
  1161.     return (const char**)ltime->month;
  1162.   }
  1163.  
  1164.   const char ** _Locale_abbrev_monthname(struct _Locale_time * ltime)
  1165.   {
  1166.     return (const char**)ltime->abbrev_month;
  1167.   }
  1168.  
  1169.   const char ** _Locale_full_dayofweek(struct _Locale_time * ltime)
  1170.   {
  1171.     return (const char**)ltime->dayofweek;
  1172.   }
  1173.  
  1174.   const char ** _Locale_abbrev_dayofweek(struct _Locale_time * ltime)
  1175.   {
  1176.     return (const char**)ltime->abbrev_dayofweek;
  1177.   }
  1178.  
  1179.   const char* _Locale_d_t_fmt(struct _Locale_time* ltime)
  1180.   {
  1181.     // NT doesn't provide this information, and must simulate.
  1182.     static char buffer[MAX_PATH];
  1183.     strcpy(buffer, _Locale_d_fmt(ltime));
  1184.     strcat(buffer, " ");
  1185.     strcat(buffer, _Locale_t_fmt(ltime));
  1186.     return buffer;
  1187.   }
  1188.  
  1189.   const char* _Locale_long_d_t_fmt(struct _Locale_time* ltime)
  1190.   {
  1191.     // NT doesn't provide this information, and must simulate.
  1192.     static char buffer[MAX_PATH];
  1193.     strcpy(buffer, _Locale_long_d_fmt(ltime));
  1194.     strcat(buffer, " ");
  1195.     strcat(buffer, _Locale_t_fmt(ltime));
  1196.     return buffer;
  1197.   }
  1198.  
  1199.   const char* __ConvertDate(const char* NTTime)
  1200.   {
  1201.     static char ansi_date_fmt[MAX_PATH]; // Hack
  1202.     const char *cur_char;
  1203.     char *cur_output;
  1204.  
  1205.     // Correct time format.
  1206.     cur_char=NTTime;
  1207.     cur_output=ansi_date_fmt;
  1208.     while(*cur_char)
  1209.       {
  1210.         switch(*cur_char)
  1211.       {
  1212.       case 'd':
  1213.             {
  1214.           if(*(cur_char+1)=='d')
  1215.                 {
  1216.           if(*(cur_char+2)=='d')
  1217.             {
  1218.               if(*(cur_char+3)=='d')
  1219.             { *(cur_output++)='%'; *(cur_output++)='A';  cur_char+=3; }
  1220.               else
  1221.             { *(cur_output++)='%'; *(cur_output++)='a';  cur_char+=2; }
  1222.             }
  1223.           else
  1224.             { *(cur_output++)='%'; *(cur_output++)='d';  cur_char++; }
  1225.                 }
  1226.           else
  1227.         { *(cur_output++)='%'; *(cur_output++)='#'; *(cur_output++)='d'; }
  1228.             }
  1229.             break;
  1230.  
  1231.       case 'M':
  1232.             {
  1233.           if(*(cur_char+1)=='M')
  1234.                 {
  1235.           if(*(cur_char+2)=='M')
  1236.             {
  1237.               if(*(cur_char+3)=='M')
  1238.             { *(cur_output++)='%'; *(cur_output++)='B';  cur_char+=3; }
  1239.               else
  1240.             { *(cur_output++)='%'; *(cur_output++)='b';  cur_char+=2; }
  1241.             }
  1242.           else
  1243.             { *(cur_output++)='%'; *(cur_output++)='m';  cur_char++; }
  1244.                 }
  1245.           else
  1246.         { *(cur_output++)='%'; *(cur_output++)='#'; *(cur_output++)='m'; }
  1247.             }
  1248.             break;
  1249.  
  1250.       case 'y':
  1251.             {
  1252.           if(*(cur_char+1)=='y')
  1253.                 {
  1254.           if(*(cur_char+2)=='y' && *(cur_char+3)=='y')
  1255.             { *(cur_output++)='%'; *(cur_output++)='Y';  cur_char+=3; }
  1256.           else
  1257.             { *(cur_output++)='%'; *(cur_output++)='y';  cur_char++; }
  1258.                 }
  1259.           else
  1260.         { *(cur_output++)='%'; *(cur_output++)='#'; *(cur_output++)='y'; }
  1261.             }
  1262.             break;
  1263.  
  1264.       case '%':
  1265.         {
  1266.           *(cur_output++)='%'; *(cur_output++)='%';
  1267.             }
  1268.             break;
  1269.  
  1270.       case '\'':
  1271.         {
  1272.           cur_char++;
  1273.           while(*cur_char!='\'' && *cur_char!=0) *cur_output++=*cur_char++;
  1274.         }
  1275.         break;
  1276.  
  1277.       default:
  1278.         {
  1279.           *(cur_output++)=*cur_char;
  1280.             }
  1281.             break;
  1282.       }
  1283.         if(*cur_char==0) break;
  1284.         cur_char++;
  1285.       }
  1286.  
  1287.     *cur_output=0;
  1288.     return ansi_date_fmt;
  1289.   }
  1290.  
  1291.   const char* _Locale_d_fmt(struct _Locale_time* ltime)
  1292.   {
  1293.     static char date_fmt[80];
  1294.     GetLocaleInfoA(ltime->lcid, LOCALE_SSHORTDATE, date_fmt, MAX_PATH);
  1295.     __ConvertFromACP(date_fmt, 80, ltime->cp);
  1296.  
  1297.     return __ConvertDate(date_fmt);
  1298.   }
  1299.  
  1300.   const char* _Locale_long_d_fmt(struct _Locale_time* ltime)
  1301.   {
  1302.     static char date_fmt[80];
  1303.     GetLocaleInfoA(ltime->lcid, LOCALE_SLONGDATE, date_fmt, MAX_PATH);
  1304.     __ConvertFromACP(date_fmt, 80, ltime->cp);
  1305.  
  1306.     return __ConvertDate(date_fmt);
  1307.   }
  1308.  
  1309.   const char* _Locale_t_fmt(struct _Locale_time* ltime)
  1310.   {
  1311.     char time_fmt[80];
  1312.     static char ansi_time_fmt[MAX_PATH]; // Hack
  1313.     char *cur_char, *cur_output;
  1314.     GetLocaleInfoA(ltime->lcid, LOCALE_STIMEFORMAT, time_fmt, MAX_PATH);
  1315.     __ConvertFromACP(time_fmt, 80, ltime->cp);
  1316.  
  1317.     // Correct time format.
  1318.     cur_char=time_fmt;
  1319.     cur_output=ansi_time_fmt;
  1320.     while(*cur_char)
  1321.       {
  1322.         switch(*cur_char)
  1323.       {
  1324.       case 'h':
  1325.             {
  1326.           if(*(cur_char+1)=='h')
  1327.         { *(cur_output++)='%'; *(cur_output++)='I';  cur_char++; }
  1328.           else
  1329.         { *(cur_output++)='%'; *(cur_output++)='#'; *(cur_output++)='I'; }
  1330.             }
  1331.             break;
  1332.  
  1333.       case 'H':
  1334.         if(*(cur_char+1)=='H')
  1335.           { *(cur_output++)='%'; *(cur_output++)='H'; cur_char++; }
  1336.         else
  1337.           { *(cur_output++)='%'; *(cur_output++)='#'; *(cur_output++)='H'; }
  1338.         break;
  1339.  
  1340.       case 'm':
  1341.             {
  1342.           if(*(cur_char+1)=='m')
  1343.         { *(cur_output++)='%'; *(cur_output++)='M';  cur_char++; }
  1344.           else
  1345.         { *(cur_output++)='%'; *(cur_output++)='#'; *(cur_output++)='M'; }
  1346.             }
  1347.             break;
  1348.  
  1349.       case 's':
  1350.             {
  1351.           if(*(cur_char+1)=='s')
  1352.         { *(cur_output++)='%'; *(cur_output++)='S';  cur_char++; }
  1353.           else
  1354.         { *(cur_output++)='%'; *(cur_output++)='#'; *(cur_output++)='S'; }
  1355.             }
  1356.             break;
  1357.  
  1358.       case 't':
  1359.             {
  1360.           if(*(cur_char+1)=='t')
  1361.         cur_char++;
  1362.  
  1363.           *(cur_output++)='%'; *(cur_output++)='p';
  1364.             }
  1365.             break;
  1366.  
  1367.       case '%':
  1368.         {
  1369.           *(cur_output++)='%'; *(cur_output++)='%';
  1370.             }
  1371.             break;
  1372.  
  1373.       case '\'':
  1374.         {
  1375.           cur_char++;
  1376.           while(*cur_char!='\'' && *cur_char!=0) *cur_output++=*cur_char++;
  1377.         }
  1378.         break;
  1379.  
  1380.       default:
  1381.         {
  1382.           *(cur_output++)=*cur_char;
  1383.             }
  1384.             break;
  1385.       }
  1386.         if(*cur_char==0) break;
  1387.         cur_char++;
  1388.       }
  1389.  
  1390.     *cur_output=0;
  1391.     return ansi_time_fmt;
  1392.   }
  1393.  
  1394.   const char* _Locale_am_str(struct _Locale_time* ltime)
  1395.   {
  1396.     static char buffer[9];
  1397.     GetLocaleInfoA(ltime->lcid, LOCALE_S1159, buffer, 9);
  1398.     __ConvertFromACP(buffer, 9, ltime->cp);
  1399.     return buffer;
  1400.   }
  1401.  
  1402.   const char* _Locale_pm_str(struct _Locale_time* ltime)
  1403.   {
  1404.     static char buffer[9];
  1405.     GetLocaleInfoA(ltime->lcid, LOCALE_S2359, buffer, 9);
  1406.     __ConvertFromACP(buffer, 9, ltime->cp);
  1407.     return buffer;
  1408.   }
  1409.  
  1410.   const char* _Locale_t_fmt_ampm(struct _Locale_time* ltime)
  1411.   {
  1412.     char time_sep[4];
  1413.     static char buffer[17];
  1414.     GetLocaleInfoA(ltime->lcid, LOCALE_STIME, time_sep, 4);
  1415.     __ConvertFromACP(time_sep, 4, ltime->cp);
  1416.     strcpy(buffer, "%H"); strcat(buffer, time_sep);
  1417.     strcat(buffer, "%M"); strcat(buffer, time_sep);
  1418.     strcat(buffer, "%S %p");
  1419.     return buffer;
  1420.   }
  1421.  
  1422.   /* Messages */
  1423.  
  1424.   int _Locale_catopen(struct _Locale_messages* __DUMMY_PAR1, const char* __DUMMY_PAR)
  1425.   { return -1; }
  1426.   void _Locale_catclose(struct _Locale_messages* __DUMMY_PAR1, int __DUMMY_PAR) {}
  1427.   const char* _Locale_catgets(struct _Locale_messages* __DUMMY_PAR1, int __DUMMY_PAR2,
  1428.                   int __DUMMY_PAR3, int __DUMMY_PAR4,
  1429.                   const char *dfault)
  1430.   { return dfault; }
  1431.  
  1432. #ifdef __cplusplus    
  1433. } /* extern C */
  1434. _STLP_END_NAMESPACE
  1435. #endif
  1436.  
  1437. void __FixGrouping(char *grouping)
  1438. {
  1439.   /* This converts NT version which uses '0' instead of 0, etc ; to ANSI */
  1440.   while (*grouping) {
  1441.     if (*grouping >= '0' && *grouping <= '9') {
  1442.       *grouping = *grouping - '0'; 
  1443.       grouping++;
  1444.     } else if (*grouping == ';') {
  1445.       char *tmp = grouping;
  1446.       /* remove ':' */
  1447.       for (tmp = grouping; *tmp; tmp++)
  1448.         *tmp = *(tmp+1);
  1449.     } else
  1450.       grouping++;
  1451.   } 
  1452. }
  1453.  
  1454. const char* __ConvertName(const char* lname, LOCALECONV* ConvTable, int TableSize)
  1455. {
  1456.   int     i;
  1457.   int     cmp = 1;
  1458.   int     low = 0;
  1459.   int        high=TableSize-1;
  1460.  
  1461.   //  typical binary search - do until no more to search or match
  1462.   while (low <= high)
  1463.     {
  1464.       i = (low + high) / 2;
  1465.  
  1466.       if ((cmp=lstrcmpiA(lname, (*(ConvTable + i)).name))==0)
  1467.     return (*(ConvTable + i)).abbrev;
  1468.       else if (cmp < 0)
  1469.     high = i - 1;
  1470.       else
  1471.     low = i + 1;
  1472.     }
  1473.   return lname;
  1474. }
  1475.  
  1476. int __ParseLocaleString(const char* lname, char* lang, char* ctry,
  1477. char* page)
  1478. {
  1479.   int param=0;
  1480.   size_t len=0;
  1481.   char ch=lname[0];
  1482.  
  1483.   if(ch==0)
  1484.      return 0;
  1485.     
  1486.   else if(ch=='.') // Only code page provided
  1487.     {
  1488.       if(strlen(lname+1)>MAX_CP_LEN) return -1; // CP number too long
  1489.       strcpy(page, lname+1);
  1490.       lang[0] = 0; ctry[0] = 0;  //necessary? calling function does this too
  1491.       return 0;
  1492.     }
  1493.  
  1494.   while (ch!=0) // Parse string
  1495.     {
  1496.       len=strcspn(lname, "_.,"); // ',' for compability with POSIX
  1497.  
  1498.       ch=lname[len];
  1499.       if((param==0) && (len<MAX_LANG_LEN))
  1500.         {
  1501.           if (ch!='.') // hence '_', ',' or '/0'
  1502.                 strncpy(lang, lname, len);
  1503.           else  // no ctry, read lang and skip ctry on next pass
  1504.             {
  1505.               ctry[0]=0;  
  1506.               strncpy(lang, lname, len);
  1507.               param++;    
  1508.              }
  1509.          }
  1510.       else if(param==1 && len<MAX_CTRY_LEN && ch!='_')
  1511.             strncpy(ctry, lname, len);
  1512.       else if(param==2 && len<MAX_CP_LEN && (ch==0 || ch==','))
  1513.             strncpy(page, lname, len);
  1514.       else
  1515.         return -1;
  1516.       if(ch==',') break; // Modifier found. In NT not used.
  1517.       param++;
  1518.       lname+=(len+1);
  1519.     }
  1520.   return 0;
  1521. }
  1522.  
  1523. /* Data necesary for find LCID*/
  1524. static int __FindFlag;
  1525. static LCID __FndLCID;
  1526. static const char* __FndLang;
  1527. static const char* __FndCtry;
  1528.  
  1529. static LCID LocaleFromHex(const char* locale)
  1530. {
  1531.   unsigned long result=0;
  1532.   int digit;
  1533.   while(*locale)
  1534.     {
  1535.       result<<=4;
  1536.       digit=(*locale>='0' && *locale<='9')? *locale-'0':
  1537.     (*locale>='A' && *locale<='F')?(*locale-'A')+10:(*locale-'a')+10;
  1538.       result+=digit;
  1539.       locale++;
  1540.     }
  1541.   return (LCID)result;
  1542. }
  1543.  
  1544. static BOOL CALLBACK EnumLocalesProcA(LPSTR locale)
  1545. {
  1546.   LCID lcid=LocaleFromHex(locale);
  1547.   int LangFlag=0, CtryFlag=!__FndCtry;
  1548.   static char Lang[MAX_LANG_LEN], Ctry[MAX_CTRY_LEN];
  1549.  
  1550.   GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE, Lang, MAX_LANG_LEN);
  1551.   if(lstrcmpiA(Lang, __FndLang)!=0)
  1552.     {
  1553.       GetLocaleInfoA(lcid, LOCALE_SABBREVLANGNAME, Lang, MAX_LANG_LEN);
  1554.       if(lstrcmpiA(Lang, __FndLang)==0) LangFlag=1;
  1555.     }
  1556.   else LangFlag=1;
  1557.  
  1558.   if(__FndCtry)
  1559.     {
  1560.       GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY, Ctry, MAX_CTRY_LEN);
  1561.       if(lstrcmpiA(Ctry, __FndCtry)!=0)
  1562.     {
  1563.       GetLocaleInfoA(lcid, LOCALE_SABBREVCTRYNAME, Ctry, MAX_CTRY_LEN);
  1564.       if(lstrcmpiA(Ctry, __FndCtry)==0) CtryFlag=1;
  1565.     }
  1566.       else CtryFlag=1;
  1567.     }
  1568.  
  1569.   if(LangFlag && CtryFlag)
  1570.     {
  1571.       __FindFlag=1;
  1572.       __FndLCID=lcid;
  1573.       return FALSE;
  1574.     }
  1575.  
  1576.   return TRUE;
  1577. }
  1578.  
  1579. int __GetLCID(const char* lang, const char* ctry, LCID* lcid)
  1580. {
  1581.   __FindFlag=0;
  1582.   __FndLang=lang;
  1583.   __FndCtry=ctry;
  1584.   EnumSystemLocalesA(EnumLocalesProcA, LCID_INSTALLED);
  1585.  
  1586.   if(__FindFlag==0) return -1;
  1587.  
  1588.   *lcid=__FndLCID;
  1589.   return 0;
  1590. }
  1591.  
  1592. int __GetLCIDFromName(const char* lname, LCID* lcid, char* cp)
  1593. {
  1594.   char lang[MAX_LANG_LEN+1], ctry[MAX_CTRY_LEN+1], page[MAX_CP_LEN+1];
  1595.   int result = 0;
  1596.   if(lname==NULL || lname[0]==0)
  1597.     {
  1598.       *lcid=LOCALE_USER_DEFAULT;
  1599.       return 0;
  1600.     }
  1601.  
  1602.   memset(lang, 0, MAX_LANG_LEN+1);
  1603.   memset(ctry, 0, MAX_CTRY_LEN+1);
  1604.   memset(page, 0, MAX_CP_LEN+1);
  1605.   if(__ParseLocaleString(lname, lang, ctry, page)==-1) return -1;
  1606.  
  1607.   if(lang[0] == 0 && ctry[0] == 0)
  1608.     *lcid = LOCALE_USER_DEFAULT; // Only code page given.
  1609.   else
  1610.     {
  1611.       if(ctry[0] == 0)
  1612.     result = __GetLCID(__ConvertName(lang, __rg_language, sizeof(__rg_language)/sizeof(LOCALECONV)), NULL, lcid);
  1613.       else
  1614.     result = __GetLCID(
  1615.                __ConvertName(lang, __rg_language, sizeof(__rg_language)/sizeof(LOCALECONV)),
  1616.                __ConvertName(ctry, __rg_country, sizeof(__rg_country)/sizeof(LOCALECONV)),
  1617.                lcid);
  1618.     }
  1619.  
  1620.   if(result==0)
  1621.     {
  1622.       // Handling code page
  1623.       if(lstrcmpiA(page, "ACP")==0 || page[0]==0)
  1624.     my_ltoa(__intGetACP(*lcid), cp);
  1625.       else if(lstrcmpiA(page, "OCP")==0)
  1626.     my_ltoa(__intGetOCP(*lcid), cp);
  1627.       else strncpy(cp, page, 5);
  1628.     }
  1629.   return result;
  1630. }
  1631.  
  1632. char* __GetLocaleName(LCID lcid, const char* cp, char* buf)
  1633. {
  1634.   char lang[MAX_LANG_LEN+1], ctry[MAX_CTRY_LEN+1];
  1635.   GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE, lang, MAX_LANG_LEN);
  1636.   GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY, ctry, MAX_CTRY_LEN);
  1637.   strcpy(buf, lang); strcat(buf, "_");
  1638.   strcat(buf, ctry); strcat(buf, ".");
  1639.   return strcat(buf, cp);
  1640. }
  1641.  
  1642. static const char* __loc_categories[]=
  1643. {
  1644.   "LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MONETARY", "LC_NUMERIC", "LC_TIME"
  1645.     };
  1646.  
  1647. char* __Extract_locale_name(const char* loc, int category, char* buf)
  1648. {
  1649.   char *expr;
  1650.   size_t len_name;
  1651.   buf[0] = 0;
  1652.   if(category < LC_ALL || category > LC_MAX) return NULL;
  1653.  
  1654.   if(loc[0]=='L' && loc[1]=='C' && loc[2]=='_')
  1655.     {
  1656.       expr=strstr((char*)loc, __loc_categories[category]);
  1657.       if(expr==NULL) return NULL; // Category not found.
  1658.       expr=strchr(expr, '=');
  1659.       if(expr==NULL) return NULL;
  1660.       expr++;
  1661.       len_name=strcspn(expr, ";");
  1662.       len_name=len_name>_Locale_MAX_SIMPLE_NAME?\
  1663.     _Locale_MAX_SIMPLE_NAME:len_name;
  1664.       strncpy(buf, expr, len_name);        buf[len_name]=0;
  1665.       return buf;
  1666.     }
  1667.   else
  1668.     return strncpy(buf, loc, _Locale_MAX_SIMPLE_NAME);
  1669. }
  1670.  
  1671. char* __TranslateToSystem(const char* lname, char* buf)
  1672. {
  1673.   LCID lcid;
  1674.   char cp[MAX_CP_LEN+1];
  1675.   if(__GetLCIDFromName(lname, &lcid, cp)!=0) return NULL;
  1676.  
  1677.   return __GetLocaleName(lcid, cp, buf);
  1678. }
  1679.  
  1680. void __ConvertFromACP(char* buf, int buf_size, const char* cp)
  1681. {
  1682.   wchar_t *Buffer;
  1683.   int BufferSize=MultiByteToWideChar(CP_ACP, 0, buf, -1, NULL, 0);
  1684.   Buffer=(wchar_t*)malloc(sizeof(wchar_t)*(BufferSize+1));
  1685.   MultiByteToWideChar(CP_ACP, 0, buf, -1, Buffer, BufferSize);
  1686.   WideCharToMultiByte(atoi(cp), 0, Buffer, -1, buf, buf_size, NULL, NULL);
  1687.   free(Buffer);
  1688. }
  1689.  
  1690. /* Return 0 if ANSI code page not used */
  1691. int __intGetACP(LCID lcid)
  1692. {
  1693.   char cp[6];
  1694.   GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, cp, 6);
  1695.   return atoi(cp);
  1696. }
  1697.  
  1698. /* Return 1 if OEM code page not used */
  1699. int __intGetOCP(LCID lcid)
  1700. {
  1701.   char cp[6];
  1702.   GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE, cp, 6);
  1703.   return atoi(cp);
  1704. }
  1705.  
  1706. int __GetDefaultCP(LCID lcid)
  1707. {
  1708.   int cp = __intGetACP(lcid);
  1709.   if(cp == 0) return __intGetOCP(lcid);
  1710.   else return cp;
  1711. }
  1712.  
  1713. char* __ConvertToCP(int from_cp, int to_cp, const char *from, size_t size, size_t *ret_buf_size)
  1714. {
  1715.   int wbuffer_size, buffer_size;
  1716.   wchar_t *wbuffer;
  1717.   char* buffer;
  1718.  
  1719.   wbuffer_size = MultiByteToWideChar(from_cp, MB_PRECOMPOSED, from, size, NULL, 0);
  1720.   wbuffer = (wchar_t*)malloc(sizeof(wchar_t)*wbuffer_size);
  1721.   MultiByteToWideChar(from_cp, MB_PRECOMPOSED, from, size, wbuffer, wbuffer_size);
  1722.  
  1723.   buffer_size = WideCharToMultiByte(to_cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuffer, wbuffer_size, NULL, 0, NULL, FALSE);
  1724.   buffer = (char*)malloc(buffer_size);
  1725.   WideCharToMultiByte(to_cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuffer, wbuffer_size, buffer, buffer_size, NULL, FALSE);
  1726.  
  1727.   free(wbuffer);
  1728.   *ret_buf_size = buffer_size;
  1729.   return buffer;
  1730. }
  1731.  
  1732. #ifdef __cplusplus
  1733. }
  1734. // _STLP_END_NAMESPACE
  1735. #endif
  1736.