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_glibc / c_locale_glibc.c next >
C/C++ Source or Header  |  2002-01-18  |  22KB  |  767 lines
  1. /*
  2.  * Copyright (c) 1999
  3.  * Silicon Graphics Computer Systems, Inc.
  4.  *
  5.  * Permission to use, copy, modify, distribute and sell this software
  6.  * and its documentation for any purpose is hereby granted without fee,
  7.  * provided that the above copyright notice appear in all copies and
  8.  * that both that copyright notice and this permission notice appear
  9.  * in supporting documentation.  Silicon Graphics makes no
  10.  * representations about the suitability of this software for any
  11.  * purpose.  It is provided "as is" without express or implied warranty.
  12.  */ 
  13.  
  14.  
  15. #include <stdlib.h>
  16. #include <string.h>
  17. #include <unistd.h>
  18. #ifdef _POSIX_MAPPED_FILES
  19. # include <sys/mman.h>
  20. #endif
  21.  
  22. #include <stl/c_locale.h>
  23. #include <limits.h>
  24. #include <wctype.h>
  25. /* #include <libc-lock.h> */
  26.  
  27. #include <locale.h>
  28. #include <argz.h>
  29. #include "gcc_localeinfo.h"
  30.  
  31. wint_t btowc(int c);
  32. int wctob (wint_t c);
  33.  
  34. size_t mbrtowc (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps);
  35. size_t wcrtomb (char *s, wchar_t wc, mbstate_t *ps);
  36. size_t mbrlen (const char* s, size_t n, mbstate_t *ps);
  37.  
  38. #include <nl_types.h>
  39.  
  40.  
  41. typedef struct _Locale_ctype    { 
  42.   const struct locale_data* gcc_data;
  43.   const int* __tolower;
  44.   const int* __toupper;
  45.   _Locale_mask_t* __class;
  46. } L_ctype_t;
  47.  
  48. typedef struct _Locale_numeric  { 
  49.   const struct locale_data* gcc_data;
  50. } L_numeric_t;
  51.  
  52. typedef struct _Locale_time     { 
  53.   const struct locale_data* gcc_data;
  54. } L_time_t;
  55.  
  56. typedef struct _Locale_collate  { 
  57.   const struct locale_data* gcc_data;
  58. } L_collate_t;
  59.  
  60. typedef struct _Locale_monetary { 
  61.   const struct locale_data* gcc_data;
  62. } L_monetary_t;
  63.  
  64. typedef struct _Locale_messages { 
  65.   const struct locale_data* gcc_data;
  66. } L_messages_t;
  67.  
  68. static char *
  69. _Locale_extract_name ( const char *cname, char *into, int category )
  70. {
  71.   int i = 0;
  72.   const char * end;
  73.   
  74.   if ( cname[0] != '/' )
  75.     return strcpy(into, cname); /* simple locale name */
  76.   
  77.   for ( i = 0; i <= category; i ++ ) {
  78.     while ( *cname != '\0' && *cname != '/' )
  79.       cname++;
  80.     if ( *cname == '\0' )
  81.       return into;
  82.     cname++;
  83.   }
  84.   
  85.   if ( *cname == '\0' )
  86.     return into;
  87.   
  88.   end = cname;
  89.   while ( *end != '\0' && *end != '/' )
  90.     end++;
  91.   
  92.   strncpy ( into, cname, end - cname );
  93.   into [ end - cname ] = '\0';
  94.   
  95.   return into;
  96. }
  97.  
  98. char* _Locale_name(const struct locale_data* gcc_data, 
  99.                   char* buf)
  100. {
  101.   if (!(gcc_data && gcc_data->name)) return 0;
  102.   strncpy(buf, gcc_data->name, _Locale_MAX_SIMPLE_NAME);
  103.   buf [ _Locale_MAX_SIMPLE_NAME - 1 ] = '\0';
  104.   return buf;
  105. }
  106.  
  107.  
  108. /* calls _nl_find_locale which is a function internal to the glibc
  109.     locale implementation that loads locale data in from the data
  110.     files.  The locale_data struct has information for all categories.
  111.     In the following implementation we use a locale_data struct for
  112.     each category for simplicity, though there is an obvious waste in
  113.     doing that.  */
  114. const struct locale_data *
  115. _Find_locale (char *locale_path, size_t locale_path_len,
  116.           int category, char **name)
  117. {
  118.   return __nl_find_locale(locale_path, locale_path_len, category, name);
  119. }
  120.  
  121.  
  122. static void
  123. _Remove_locale (int locale, struct locale_data *data)
  124. {
  125.   /* this should eventually call _nl_remove_locale() in glibc 2.1 */
  126. }
  127.  
  128. /* couldn't find where LOCALE_PATH was defined in glibc,
  129.    but this is the directory it is defined to -JGS */
  130. #define __LOCALE_PATH "/usr/share/locale"
  131.  
  132. const struct locale_data*
  133. _Category_create(const char * name, int category)
  134. {
  135.   /* JGS, where should this path come from? */
  136.   char* locpath_var;
  137.   char* locale_path = NULL;
  138.   size_t locale_path_len = 0;
  139.  
  140.   locpath_var = __secure_getenv("LOCPATH");
  141.   
  142.   if (locpath_var != NULL && locpath_var[0] != '\0')
  143.     if (argz_create_sep (locpath_var, ':',
  144.              &locale_path, &locale_path_len) != 0)
  145.       return NULL;
  146.   
  147.   if (argz_add_sep (&locale_path, &locale_path_len, __LOCALE_PATH, ':') != 0)
  148.     return NULL;
  149.  
  150.   return _Find_locale(locale_path, locale_path_len, 
  151.               category, (char**)&name);
  152. }
  153.  
  154.  
  155.  
  156. static const char* get_default_locale(char* buf) {
  157.   char* lang = getenv("LANG");
  158.   if (lang == NULL || lang[0] == '\0') {
  159.     buf[0] = '\0';
  160.     return NULL;
  161.   }
  162.   else {
  163.     strcpy(buf, lang);
  164.     return buf;
  165.   }
  166. }
  167.     
  168. const char* _Locale_ctype_default(char* buf) {
  169.   char fullname[_Locale_MAX_COMPOSITE_NAME];
  170.   if (get_default_locale(fullname) == NULL)
  171.     return NULL;
  172.   else
  173.     return _Locale_extract_ctype_name(fullname, buf);
  174. }
  175.  
  176. const char* _Locale_numeric_default(char* buf) {
  177.   char fullname[_Locale_MAX_COMPOSITE_NAME];
  178.   if (get_default_locale(fullname) == NULL)
  179.     return NULL;
  180.   else
  181.     return _Locale_extract_numeric_name(fullname, buf);
  182. }
  183.  
  184. const char* _Locale_time_default(char* buf) {
  185.   char fullname[_Locale_MAX_COMPOSITE_NAME];
  186.   if (get_default_locale(fullname) == NULL)
  187.     return NULL;
  188.   else
  189.     return _Locale_extract_time_name(fullname, buf);
  190. }
  191.  
  192. const char* _Locale_collate_default(char* buf)  {
  193.   char fullname[_Locale_MAX_COMPOSITE_NAME];
  194.   if (get_default_locale(fullname) == NULL)
  195.     return NULL;
  196.   else
  197.     return _Locale_extract_collate_name(fullname, buf);
  198. }
  199.  
  200. const char* _Locale_monetary_default(char* buf) {
  201.   char fullname[_Locale_MAX_COMPOSITE_NAME];
  202.   if (get_default_locale(fullname) == NULL)
  203.     return NULL;
  204.   else
  205.     return _Locale_extract_monetary_name(fullname, buf);
  206. }
  207.  
  208. const char* _Locale_messages_default(char* buf) {
  209.   char fullname[_Locale_MAX_COMPOSITE_NAME];
  210.   if (get_default_locale(fullname) == NULL)
  211.     return NULL;
  212.   else
  213.     return _Locale_extract_messages_name(fullname, buf);
  214. }
  215.  
  216.  
  217. /****** Numeric Category ******/
  218.  
  219. void*
  220. _Locale_numeric_create(const char * name) {
  221.   L_numeric_t*  lnum = (L_numeric_t*)malloc(sizeof(L_numeric_t));
  222.   lnum->gcc_data = _Category_create(name, LC_NUMERIC);
  223.   return (void*)lnum; 
  224. }
  225.  
  226.  
  227. char* _Locale_numeric_name(const void* lnum, 
  228.                       char* buf) {
  229.   return _Locale_name(((struct _Locale_ctype*)lnum)->gcc_data, buf);
  230. }
  231. void _Locale_numeric_destroy(void* lnum)   
  232. {
  233.   _Remove_locale(LC_NUMERIC, (struct locale_data *)((struct _Locale_ctype*)lnum)->gcc_data);
  234.   free(lnum);
  235. }
  236. char* _Locale_extract_numeric_name(const char* cname, char* buf) 
  237. {
  238.   return _Locale_extract_name(cname, buf, LC_NUMERIC);
  239. }
  240. char _Locale_decimal_point(struct _Locale_numeric* lnum)
  241. { 
  242.   return lnum->gcc_data->values[_NL_ITEM_INDEX(DECIMAL_POINT)].string[0]; 
  243. }
  244. char _Locale_thousands_sep(struct _Locale_numeric* lnum)
  245. { 
  246.   return lnum->gcc_data->values[_NL_ITEM_INDEX(THOUSANDS_SEP)].string[0]; 
  247. }
  248. const char* _Locale_grouping(struct _Locale_numeric * lnum) 
  249. {
  250.   return lnum->gcc_data->values[_NL_ITEM_INDEX(GROUPING)].string; 
  251. }
  252.  
  253. /* JGS: gcc/linux does not provide true/false names in their
  254.  * locale data files 
  255. */
  256.  
  257. static const char* __true_name = "true";
  258. static const char* __false_name = "false";
  259.  
  260. const char * _Locale_true(struct _Locale_numeric *l)  
  261. { return __true_name; }
  262. const char * _Locale_false(struct _Locale_numeric *l)
  263. { return __false_name; }
  264.  
  265.  
  266. /****** Monetary Category ******/
  267.  
  268. void* _Locale_monetary_create(const char* name) {
  269.   L_monetary_t* lmon = (L_monetary_t*)malloc(sizeof(L_monetary_t));
  270.   lmon->gcc_data = _Category_create(name, LC_MONETARY);
  271.   return lmon;
  272. }
  273.  
  274. char* _Locale_monetary_name(const void* lmon,
  275.                 char* buf) {
  276.   return _Locale_name(((struct _Locale_monetary*)lmon)->gcc_data, buf);
  277. }
  278.  
  279. void _Locale_monetary_destroy(void*lmon) {
  280.   _Remove_locale(LC_MONETARY, (struct locale_data *)((struct _Locale_monetary*)lmon)->gcc_data);
  281.   free(lmon);
  282. }
  283.  
  284. char* _Locale_extract_monetary_name(const char* cname, char* buf) {
  285.   return _Locale_extract_name(cname, buf, LC_MONETARY);
  286. }
  287.  
  288. const char* _Locale_int_curr_symbol(struct _Locale_monetary* lmon) {
  289.   return lmon->gcc_data->values[_NL_ITEM_INDEX(INT_CURR_SYMBOL)].string; 
  290. }
  291. const char* _Locale_currency_symbol(struct _Locale_monetary* lmon) {
  292.   return lmon->gcc_data->values[_NL_ITEM_INDEX(CURRENCY_SYMBOL)].string; 
  293. }
  294. char        _Locale_mon_decimal_point(struct _Locale_monetary* lmon) {
  295.   return lmon->gcc_data->values[_NL_ITEM_INDEX(MON_DECIMAL_POINT)].string[0]; 
  296. }
  297. char        _Locale_mon_thousands_sep(struct _Locale_monetary* lmon) {
  298.   return lmon->gcc_data->values[_NL_ITEM_INDEX(MON_THOUSANDS_SEP)].string[0]; 
  299. }
  300. const char* _Locale_mon_grouping(struct _Locale_monetary* lmon) {
  301.   return lmon->gcc_data->values[_NL_ITEM_INDEX(MON_GROUPING)].string; 
  302. }
  303. const char* _Locale_positive_sign(struct _Locale_monetary* lmon) {
  304.   return lmon->gcc_data->values[_NL_ITEM_INDEX(POSITIVE_SIGN)].string; 
  305. }
  306. const char* _Locale_negative_sign(struct _Locale_monetary* lmon) {
  307.   return lmon->gcc_data->values[_NL_ITEM_INDEX(NEGATIVE_SIGN)].string; 
  308. }
  309. char        _Locale_int_frac_digits(struct _Locale_monetary* lmon) {
  310.   return lmon->gcc_data->values[_NL_ITEM_INDEX(INT_FRAC_DIGITS)].string[0]; 
  311. }
  312. char        _Locale_frac_digits(struct _Locale_monetary* lmon) {
  313.   return lmon->gcc_data->values[_NL_ITEM_INDEX(FRAC_DIGITS)].string[0]; 
  314. }
  315. int         _Locale_p_cs_precedes(struct _Locale_monetary* lmon) {
  316.   return lmon->gcc_data->values[_NL_ITEM_INDEX(P_CS_PRECEDES)].word; 
  317. }
  318. int         _Locale_p_sep_by_space(struct _Locale_monetary* lmon) {
  319.   return lmon->gcc_data->values[_NL_ITEM_INDEX(P_SEP_BY_SPACE)].word; 
  320. }
  321. int         _Locale_p_sign_posn(struct _Locale_monetary* lmon) {
  322.   return lmon->gcc_data->values[_NL_ITEM_INDEX(P_SIGN_POSN)].word; 
  323. }
  324. int         _Locale_n_cs_precedes(struct _Locale_monetary* lmon) {
  325.   return lmon->gcc_data->values[_NL_ITEM_INDEX(N_CS_PRECEDES)].word; 
  326. }
  327. int          _Locale_n_sep_by_space(struct _Locale_monetary* lmon) {
  328.   return lmon->gcc_data->values[_NL_ITEM_INDEX(N_SEP_BY_SPACE)].word; 
  329. }
  330. int          _Locale_n_sign_posn(struct _Locale_monetary* lmon) {
  331.   return lmon->gcc_data->values[_NL_ITEM_INDEX(N_SIGN_POSN)].word; 
  332. }
  333.  
  334. /****** Time Category ******/
  335.  
  336. void* _Locale_time_create(const char * name) {
  337.   L_time_t*  ltime = (L_time_t*)malloc(sizeof(L_time_t));
  338.   ltime->gcc_data = _Category_create(name, LC_TIME);
  339.   return ltime; 
  340. }
  341.  
  342. char* _Locale_time_name(const void* ltime, 
  343.             char* buf) {
  344.   return _Locale_name(((struct _Locale_time*)ltime)->gcc_data, buf);
  345. }
  346. char* _Locale_extract_time_name(const char* cname, char* buf) {
  347.   return _Locale_extract_name(cname, buf, LC_TIME);
  348. }
  349. void _Locale_time_destroy(void* ltime) {
  350.   _Remove_locale(LC_TIME, (struct locale_data *)((struct _Locale_time*)ltime)->gcc_data);
  351.   free(ltime);
  352. }
  353. const char ** _Locale_full_monthname(struct _Locale_time *ltime) {
  354.   return (const char **)&(ltime->gcc_data->values[_NL_ITEM_INDEX(MON_1)]); 
  355. }
  356. const char ** _Locale_abbrev_monthname(struct _Locale_time *ltime) {
  357.   return (const char **)&(ltime->gcc_data->values[_NL_ITEM_INDEX(ABMON_1)]); 
  358. }
  359. const char ** _Locale_full_dayofweek(struct _Locale_time *ltime) {
  360.   return (const char **)&(ltime->gcc_data->values[_NL_ITEM_INDEX(DAY_1)]); 
  361. }
  362. const char ** _Locale_abbrev_dayofweek(struct _Locale_time *ltime) {
  363.   return (const char **)&(ltime->gcc_data->values[_NL_ITEM_INDEX(ABDAY_1)]); 
  364. }
  365. const char* _Locale_d_t_fmt(struct _Locale_time* ltime) {
  366.   return ltime->gcc_data->values[_NL_ITEM_INDEX(D_T_FMT)].string; 
  367. }
  368. const char* _Locale_long_d_t_fmt(struct _Locale_time* ltime) {
  369.   return ltime->gcc_data->values[_NL_ITEM_INDEX(D_T_FMT)].string; 
  370. }
  371. const char* _Locale_d_fmt(struct _Locale_time* ltime) 
  372. {
  373.   return ltime->gcc_data->values[_NL_ITEM_INDEX(D_FMT)].string; 
  374. }
  375. const char* _Locale_long_d_fmt(struct _Locale_time* ltime)
  376. {
  377.   return ltime->gcc_data->values[_NL_ITEM_INDEX(D_FMT)].string;
  378. }
  379. const char* _Locale_t_fmt(struct _Locale_time* ltime) {
  380.   return ltime->gcc_data->values[_NL_ITEM_INDEX(T_FMT)].string; 
  381. }
  382. const char* _Locale_am_str(struct _Locale_time* ltime) {
  383.   return ltime->gcc_data->values[_NL_ITEM_INDEX(AM_STR)].string; 
  384. }
  385. const char* _Locale_pm_str(struct _Locale_time* ltime) {
  386.   return ltime->gcc_data->values[_NL_ITEM_INDEX(PM_STR)].string; 
  387. }
  388. const char* _Locale_t_fmt_ampm(struct _Locale_time* ltime)
  389. {
  390.   return ltime->gcc_data->values[_NL_ITEM_INDEX(T_FMT_AMPM)].string; 
  391. }
  392.  
  393.  
  394. /****** Messages Category ******/
  395.  
  396. void* _Locale_messages_create(const char * name) {
  397.   L_messages_t*  lmsg = (L_messages_t*)malloc(sizeof(L_messages_t));
  398.   lmsg->gcc_data = _Category_create(name, LC_MESSAGES);
  399.   return lmsg; 
  400. }
  401.  
  402. char* _Locale_messages_name(const void* lmsg, char* buf) {
  403.   return _Locale_name(((struct _Locale_messages*)lmsg)->gcc_data, buf);
  404. }
  405.  
  406. void _Locale_messages_destroy(void* lmsg) {
  407.   _Remove_locale(LC_MESSAGES, (struct locale_data *)((struct _Locale_messages*)lmsg)->gcc_data);
  408.   free(lmsg);
  409. }
  410.  
  411. char* _Locale_extract_messages_name(const char* cname, char* buf) { 
  412.   return _Locale_extract_name(cname, buf, LC_MESSAGES);
  413. }
  414.  
  415.  
  416. /*
  417.   Could not find support for locale specific messages in glibc
  418.  
  419.   Also, this C locale interface should use a typedef for the catalog
  420.   instead of just an int. Currently I'm casting a void* (nl_catd)
  421.   back and forth to and int.
  422.  
  423.   -JGS
  424.  */
  425.  
  426. int _Locale_catopen(struct _Locale_messages*l, const char* cat_name) {
  427.   return (int)catopen(cat_name, 0); /*  JGS, don't know about the flag */
  428. }
  429. void _Locale_catclose(struct _Locale_messages*l, int catalog) {
  430.   catclose((nl_catd)catalog);
  431. }
  432. const char* _Locale_catgets(struct _Locale_messages*l, int catalog,
  433.                                        int set_num, int msg_num,
  434.                                        const char *dfault){
  435.   return catgets((nl_catd)catalog, set_num, msg_num, dfault);
  436. }
  437.  
  438.  
  439. /****** ctype Category ******/
  440.  
  441.  
  442. /*
  443.   gcc uses a different set of masks for wide characters than for
  444.   normal characters. However, the C++ standard requires there
  445.   to be only one set of masks for both. Therefore we must
  446.   translate the mask values from the wide characters to the 
  447.   mask values for the normal characters.  -JGS
  448.  */
  449. static _Locale_mask_t _Map_wchar_mask_to_char_mask(wctype_t m) {
  450.   _Locale_mask_t ret = 0;
  451.   if (m & _ISwcntrl)  ret |= _Locale_CNTRL;
  452.   if (m & _ISwupper)  ret |= _Locale_UPPER;
  453.   if (m & _ISwlower)  ret |= _Locale_LOWER;
  454.   if (m & _ISwdigit)  ret |= _Locale_DIGIT;
  455.   if (m & _ISwxdigit) ret |= _Locale_XDIGIT;
  456.   if (m & _ISwpunct)  ret |= _Locale_PUNCT;
  457.   if (m & _ISwspace)  ret |= _Locale_SPACE;
  458.   if (m & _ISwprint)  ret |= _Locale_PRINT;
  459.   if (m & _ISwalpha)  ret |= _Locale_ALPHA;
  460.   return ret;
  461. }
  462.  
  463.  
  464. void* _Locale_ctype_create(const char * name) {
  465.   const union locale_data_value *ctypes;
  466.   L_ctype_t* lctype;
  467.  
  468.   lctype = (L_ctype_t*)malloc(sizeof(L_ctype_t));
  469.   lctype->gcc_data = _Category_create(name, LC_CTYPE);
  470.   ctypes = lctype->gcc_data->values;
  471.  
  472.   lctype->__class = (_Locale_mask_t *)
  473.     (ctypes[_NL_ITEM_INDEX (_NL_CTYPE_CLASS)] .string) + 128;
  474. #if BYTE_ORDER == BIG_ENDIAN
  475.   lctype->__tolower = (const int *)
  476.     (ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOLOWER_EB)].string) + 128;
  477.   lctype->__toupper = (const int *)
  478.     (ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOUPPER_EB)].string) + 128;
  479. #elif BYTE_ORDER == LITTLE_ENDIAN
  480.   lctype->__tolower = (const int *)
  481.     (ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOLOWER_EL)].string) + 128;
  482.   lctype->__toupper = (const int *)
  483.     (ctypes[_NL_ITEM_INDEX (_NL_CTYPE_TOUPPER_EL)].string) + 128;
  484. #else
  485. #error bizarre byte order
  486. #endif
  487.   return lctype;
  488. }
  489. char* _Locale_ctype_name(const void* lctype,
  490.              char* buf) {
  491.   return _Locale_name(((struct _Locale_ctype*)lctype)->gcc_data, buf);
  492. }
  493. void _Locale_ctype_destroy(void* lctype) {
  494.   _Remove_locale(LC_CTYPE, (struct locale_data *)((struct _Locale_ctype*)lctype)->gcc_data);
  495.   free(lctype);
  496. }
  497. char* _Locale_extract_ctype_name(const char* cname, char* buf) {
  498.   return _Locale_extract_name(cname, buf, LC_CTYPE);
  499. }
  500. _Locale_mask_t* _Locale_ctype_table(struct _Locale_ctype* lctype) {
  501.   return lctype->__class; 
  502. }
  503. int _Locale_toupper(struct _Locale_ctype* lctype, int c) { 
  504.   return lctype->__toupper[c];
  505. }
  506. int _Locale_tolower(struct _Locale_ctype* lctype, int c) { 
  507.   return lctype->__tolower[c];
  508. }
  509.  
  510. /* Wide Character Functions */
  511.  
  512. static inline size_t
  513. cname_lookup (wint_t wc, const struct locale_data* loc)
  514. {
  515.   unsigned int *__nl_ctype_names;
  516.   unsigned int hash_size, hash_layers;
  517.   size_t result, cnt;
  518.  
  519. #if BYTE_ORDER == BIG_ENDIAN
  520.   __nl_ctype_names = (unsigned int*)loc->values[_NL_ITEM_INDEX(_NL_CTYPE_NAMES_EB)].string;
  521. #elif BYTE_ORDER == LITTLE_ENDIAN
  522.   __nl_ctype_names = (unsigned int*)loc->values[_NL_ITEM_INDEX(_NL_CTYPE_NAMES_EL)].string;
  523. #else
  524. #error bizarre byte order
  525. #endif
  526.  
  527.   hash_size = loc->values[_NL_ITEM_INDEX(_NL_CTYPE_HASH_SIZE)].word;
  528.   hash_layers = loc->values[_NL_ITEM_INDEX(_NL_CTYPE_HASH_LAYERS)].word;
  529.  
  530.   result = wc % hash_size;
  531.   for (cnt = 0; cnt < hash_layers; ++cnt) {
  532.     if (__nl_ctype_names[result] == wc)
  533.       break;
  534.     result += hash_size;
  535.   }
  536.   return cnt < hash_layers ? result : ~((size_t) 0);
  537. }
  538.  
  539.  
  540.  
  541.  
  542. _Locale_mask_t _Locale_wchar_ctype(struct _Locale_ctype* loc, wint_t wc) {
  543.   const struct locale_data* locale = loc->gcc_data;
  544.   const unsigned int *class32_b;
  545.   size_t idx;
  546.  
  547.   idx = cname_lookup (wc, locale);
  548.   if (idx == ~((size_t) 0))
  549.     return 0;
  550.  
  551.   class32_b = (u_int32_t *)
  552.     locale->values[_NL_ITEM_INDEX (_NL_CTYPE_CLASS32)].string;
  553.  
  554.   return _Map_wchar_mask_to_char_mask( class32_b[idx] );
  555. }
  556.  
  557.  
  558.  
  559. wint_t
  560. __towctrans_ld (wint_t wc, wctrans_t desc, const struct locale_data* locale)
  561. {
  562.   size_t idx;
  563.  
  564.   idx = cname_lookup (wc, locale);
  565.   if (idx == ~((size_t) 0))
  566.     /* Character is not known.  Default action is to simply return it.  */
  567.     return wc;
  568.  
  569.   return (wint_t) desc[idx];
  570. }
  571.  
  572. wint_t _Locale_wchar_tolower(struct _Locale_ctype* locale, wint_t wc) {
  573.   return __towctrans_ld (wc, (const unsigned int *)locale->__tolower, locale->gcc_data);
  574. }
  575. wint_t _Locale_wchar_toupper(struct _Locale_ctype* locale, wint_t wc) {
  576.   return __towctrans_ld (wc, (const unsigned int *)locale->__toupper, locale->gcc_data);
  577. }
  578.  
  579.  
  580. int _Locale_mb_cur_max (struct _Locale_ctype *lctype) { 
  581.   return lctype->gcc_data->values[_NL_ITEM_INDEX(_NL_CTYPE_MB_CUR_MAX)].word; 
  582. }
  583.  
  584. int _Locale_mb_cur_min (struct _Locale_ctype *l) { 
  585.   return 1;  /* JGS just a guess */
  586. }
  587.  
  588. int _Locale_is_stateless (struct _Locale_ctype *l) { return 1; }
  589.  
  590. wint_t _Locale_btowc(struct _Locale_ctype *l, int c) { 
  591.   return btowc(c);
  592. }
  593.  
  594. /*
  595.   glibc currently doesn't support locale dependent conversion,
  596.   which affects the following functions. When it does, then
  597.   these functions will need to change. Hopeully, the
  598.   just the calls to the glibc functions will need to be
  599.   replaced.
  600.   -JGS
  601.  */
  602.  
  603. int _Locale_wctob(struct _Locale_ctype *l, wint_t c) { 
  604.   return wctob(c);
  605. }
  606.  
  607. size_t _Locale_mbtowc(struct _Locale_ctype *l,
  608.                                  wchar_t *to,
  609.                                  const char *from, size_t n,
  610.                                  mbstate_t *shift_state)
  611. {
  612.   int ret;
  613.   if (to)
  614.     ret = mbrtowc(to, from, n, shift_state);
  615.   else
  616.     ret = mbrlen(from, n, shift_state);
  617.   return ret;
  618. }
  619.  
  620. size_t _Locale_wctomb(struct _Locale_ctype *l,
  621.               char *to, size_t n,
  622.               const wchar_t c,
  623.               mbstate_t *shift_state)
  624. {
  625.   char buf [MB_LEN_MAX];
  626.   int ret;
  627.   char* mb = buf;
  628.   ret = wcrtomb(mb, c, shift_state);
  629.  
  630.   if (ret > n)
  631.     return (size_t)-2;
  632.   else if (ret <= 0)
  633.     return ret;
  634.  
  635.   n = ret;
  636.   while (n--)
  637.     *to++ = *mb++;
  638.  
  639.   return ret;
  640. }
  641.  
  642. size_t _Locale_unshift(struct _Locale_ctype *l,
  643.                mbstate_t * st,
  644.                char *buf, size_t n, char **next) {
  645.   *next = buf; /* JGS stateless, so don't need to do anything? */
  646.   return 0;
  647. }
  648.  
  649.  
  650. /****** Collate Category ******/
  651.  
  652. void* _Locale_collate_create(const char * name) {
  653.   L_collate_t*  lcollate = (L_collate_t*)malloc(sizeof(L_collate_t));
  654.   lcollate->gcc_data = _Category_create(name, LC_COLLATE);
  655.   return lcollate; 
  656. }
  657.  
  658. char* _Locale_collate_name(const void* lcollate, char* buf) {
  659.   return _Locale_name(((struct _Locale_collate*)lcollate)->gcc_data, buf);
  660. }
  661.  
  662. void _Locale_collate_destroy(void* lcollate) {
  663.   _Remove_locale(LC_COLLATE, (struct locale_data *)((struct _Locale_collate*)lcollate)->gcc_data);
  664.   free(lcollate);
  665. }
  666.  
  667. char* _Locale_extract_collate_name(const char* cname, char* buf) {
  668.   return _Locale_extract_name(cname, buf, LC_COLLATE);
  669. }
  670.  
  671. /* copied from the IRIX version -JGS */
  672. char* _Locale_compose_name(char* buf,
  673.                const char* ctype, const char* numeric,
  674.                const char* time, const char* collate,
  675.                const char* monetary, const char* messages)
  676. {
  677.     if ( !strcmp ( ctype, numeric ) &&
  678.      !strcmp ( ctype, time ) &&
  679.      !strcmp ( ctype, collate ) &&
  680.      !strcmp ( ctype, monetary ) &&
  681.      !strcmp ( ctype, messages ) )
  682.     return strcpy ( buf, ctype );
  683.  
  684.     strcpy ( buf, "/" );
  685.     strcat ( buf, ctype );
  686.  
  687.     strcat ( buf, "/" );
  688.     strcat ( buf, numeric );
  689.  
  690.     strcat ( buf, "/" );
  691.     strcat ( buf, time );
  692.  
  693.     strcat ( buf, "/" );
  694.     strcat ( buf, collate );
  695.  
  696.     strcat ( buf, "/" );
  697.     strcat ( buf, monetary );
  698.  
  699.     strcat ( buf, "/" );
  700.     strcat ( buf, messages );
  701.  
  702.     return buf;
  703. }
  704.  
  705.  
  706.  
  707. /*
  708.   glibc doesn't have a locale specific strcmp
  709.   This doesn't ignore null chars the way it should
  710.  */
  711. int
  712. _Locale_strcmp(struct _Locale_collate * l,
  713.            const char *s1, size_t n1,
  714.            const char *s2, size_t n2)
  715. {
  716.   int ret;
  717.   int minN = n1 < n2 ? n1 : n2;
  718.   ret = strncmp(s1, s2, minN);
  719.   if (ret == 0) {
  720.     if (n1 < n2) return -1;
  721.     else if (n1 > n2) return 1;
  722.     else return 0;
  723.   } else
  724.     return ret;
  725. }
  726.  
  727.  
  728. int _Locale_strwcmp(struct _Locale_collate*l,
  729.             const wchar_t*s1, size_t n1,
  730.             const wchar_t*s2, size_t n2)
  731. {
  732.   int ret;
  733.   int minN = n1 < n2 ? n1 : n2;
  734.   ret = wcsncmp(s1, s2, minN);
  735.   if (ret == 0) {
  736.     if (n1 < n2) return -1;
  737.     else if (n1 > n2) return 1;
  738.     else return 0;
  739.   } else
  740.     return ret;
  741. }
  742.  
  743.  
  744.  
  745. size_t _Locale_strxfrm(struct _Locale_collate* lcollate,
  746.                char* dest, size_t destN, const char* src, size_t srcN)
  747. {
  748.   size_t n;
  749.   n = strxfrm(dest, src, destN);
  750.   if (n > destN)
  751.     return (size_t)-1;
  752.   dest[n] = 0;
  753.   return n;
  754. }
  755.  
  756. size_t _Locale_strwxfrm(struct _Locale_collate* lcollate,
  757.             wchar_t* dest, size_t destN, 
  758.             const wchar_t* src, size_t srcN)
  759. {
  760.   size_t n;
  761.   n = wcsxfrm(dest, src, destN);
  762.   if (n > destN)
  763.     return (size_t)-1;
  764.   dest[n] = 0;
  765.   return n;
  766. }
  767.