c_locale_win32.c

来自「symbian 上的stl_port进过编译的。」· C语言 代码 · 共 1,983 行 · 第 1/5 页

        if (result == 0) return (size_t)-1;

        return 1;
      }
    }
    else {
      ((unsigned char*)shift_state)[1] = src;
      result = MultiByteToWideChar(l->cp, MB_PRECOMPOSED, (const char*)shift_state, 2, dst, 1);
      *shift_state = 0;
      if (result == 0) return (size_t)-1;

      return 1;
    }
  }

#if !defined (_STLP_NO_WCHAR_T)
  size_t _Locale_mbtowc(_Locale_ctype_t *ltype, wchar_t *to,
                        const char *from, size_t n, mbstate_t *shift_state) {
    CPINFO ci;
    int result;
    (void*)shift_state;
    GetCPInfo(ltype->cp, &ci);
    if (ci.MaxCharSize == 1) { /* Single byte encoding. */
      *shift_state = (mbstate_t)0;
      result = MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, from, 1, to, 1);
      if (result == 0) return (size_t)-1;
      return result;
    }
    else { /* Multi byte encoding. */
      size_t retval = 0, count = 0;
      while(n--) {
        retval = __mbtowc(ltype, to, *from, shift_state);
        if (retval == -2) { from++; count++; }
        else if (retval == -1) return -1;
        else return count+retval;
      }
      if (retval == -2) return (size_t)-2;

      return n;
    }
  }

  size_t _Locale_wctomb(_Locale_ctype_t *ltype, char *to, size_t n,
                        const wchar_t c, mbstate_t *shift_state) {
    int size = \
      WideCharToMultiByte(ltype->cp,  WC_COMPOSITECHECK | WC_SEPCHARS, &c, 1, NULL, 0, NULL, NULL);

    if ((size_t)size > n) return (size_t)-2;

    if (n > INT_MAX)
      /* Limiting the output buf size to INT_MAX seems like reasonable to transform a single wchar_t. */
      n = INT_MAX;

    size = \
      WideCharToMultiByte(ltype->cp,  WC_COMPOSITECHECK | WC_SEPCHARS, &c, 1, to, (int)n, NULL, NULL);

    if (size == 0) return (size_t)-1;

    (void*)shift_state;
    return (size_t)size;
  }
#endif

  size_t _Locale_unshift(_Locale_ctype_t *ltype, mbstate_t *st,
                         char *buf, size_t n, char **next) {
    (void*)ltype;
    if (*st == 0) {
      *next = buf;
      return 0;
    }
    else {
      if (n < 1) { *next = buf; return (size_t)-2; }

      *next = buf + 1;
      return 1;
    }
  }

#endif /*  _STLP_NO_MBSTATE_T */


#ifndef CSTR_EQUAL /* VC5SP3*/
#  define CSTR_EQUAL 2
#endif
#ifndef CSTR_LESS_THAN /* VC5SP3 */
#  define CSTR_LESS_THAN 1
#endif

  static DWORD max_DWORD = 0xffffffff;
  static DWORD trim_size_t_to_DWORD(size_t n) { return n < (size_t)max_DWORD ? (DWORD)n : max_DWORD; }

  /* Collate */
  /* This function takes care of the potential size_t DWORD different size. */
  static int _Locale_strcmp_auxA(_Locale_collate_t* lcol,
                                 const char* s1, size_t n1,
                                 const char* s2, size_t n2) {
    int result = CSTR_EQUAL;
    while (n1 > 0 || n2 > 0) {
      DWORD size1 = trim_size_t_to_DWORD(n1);
      DWORD size2 = trim_size_t_to_DWORD(n2);
      result = CompareStringA(lcol->lc.id, 0, s1, size1, s2, size2);
      if (result != CSTR_EQUAL)
        break;
      n1 -= size1;
      n2 -= size2;
    }
    return result;
  }

  int _Locale_strcmp(_Locale_collate_t* lcol,
                     const char* s1, size_t n1,
                     const char* s2, size_t n2) {
    int result;
    if (__GetDefaultCP(lcol->lc.id) == atoi(lcol->cp)) {
      result = _Locale_strcmp_auxA(lcol, s1, n1, s2, n2);
    }
    else {
      char *buf1, *buf2;
      size_t size1, size2;
      buf1 = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lc.id), s1, n1, &size1);
      buf2 = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lc.id), s2, n2, &size2);

      result = _Locale_strcmp_auxA(lcol, buf1, size1, buf2, size2);
      free(buf1); free(buf2);
    }
    return (result == CSTR_EQUAL) ? 0 : (result == CSTR_LESS_THAN) ? -1 : 1;
  }

#if !defined (_STLP_NO_WCHAR_T)
  /* This function takes care of the potential size_t DWORD different size. */
  static int _Locale_strcmp_auxW(_Locale_collate_t* lcol,
                                 const wchar_t* s1, size_t n1,
                                 const wchar_t* s2, size_t n2) {
    int result = CSTR_EQUAL;
    while (n1 > 0 || n2 > 0) {
      DWORD size1 = trim_size_t_to_DWORD(n1);
      DWORD size2 = trim_size_t_to_DWORD(n2);
      result = CompareStringW(lcol->lc.id, 0, s1, size1, s2, size2);
      if (result != CSTR_EQUAL)
        break;
      n1 -= size1;
      n2 -= size2;
    }
    return result;
  }

  int _Locale_strwcmp(_Locale_collate_t* lcol,
                      const wchar_t* s1, size_t n1,
                      const wchar_t* s2, size_t n2) {
    int result;
    result = _Locale_strcmp_auxW(lcol, s1, n1, s2, n2);
    return (result == CSTR_EQUAL) ? 0 : (result == CSTR_LESS_THAN) ? -1 : 1;
  }
#endif

  size_t _Locale_strxfrm(_Locale_collate_t* lcol,
                         char* dst, size_t dst_size,
                         const char* src, size_t src_size) {
    int result;

    /* The Windows API do not support transformation of very long strings (src_size > INT_MAX)
     * In this case the result will just be the input string:
     */
    if (src_size > INT_MAX) {
      if (dst != 0) {
        _STLP_STRNCPY(dst, dst_size, src, src_size);
      }
      return src_size;
    }
    if (dst_size > INT_MAX) {
      /* now that we know that src_size <= INT_MAX we can safely decrease dst_size to INT_MAX. */
      dst_size = INT_MAX;
    }

    if (__GetDefaultCP(lcol->lc.id) == atoi(lcol->cp))
      result = LCMapStringA(lcol->lc.id, LCMAP_SORTKEY, src, (int)src_size, dst, (int)dst_size);
    else {
      char *buf;
      size_t size;
      buf = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lc.id), src, src_size, &size);

      result = LCMapStringA(lcol->lc.id, LCMAP_SORTKEY, buf, (int)size, dst, (int)dst_size);
      free(buf);
    }
    return result != 0 ? result - 1 : 0;
  }

#if !defined (_STLP_NO_WCHAR_T)
  size_t _Locale_strwxfrm(_Locale_collate_t* lcol,
                          wchar_t* dst, size_t dst_size,
                          const wchar_t* src, size_t src_size) {
    int result;

    /* see _Locale_strxfrm: */
    if (src_size > INT_MAX) {
      if (dst != 0) {
        _STLP_WCSNCPY(dst, dst_size, src, src_size);
      }
      return src_size;
    }
    if (dst_size > INT_MAX) {
      dst_size = INT_MAX;
    }
    result = LCMapStringW(lcol->lc.id, LCMAP_SORTKEY, src, (int)src_size, dst, (int)dst_size);
    return result != 0 ? result - 1 : 0;
  }
#endif

  /* Numeric */

  static const char* __true_name = "true";
  static const char* __false_name = "false";

  char _Locale_decimal_point(_Locale_numeric_t* lnum) {
    return lnum->decimal_point[0];
  }

  char _Locale_thousands_sep(_Locale_numeric_t* lnum) {
    return lnum->thousands_sep[0];
  }

  const char* _Locale_grouping(_Locale_numeric_t * lnum) {
    if (!lnum->grouping) return "";
    else return lnum->grouping;
  }

  const char * _Locale_true(_Locale_numeric_t * lnum) {
    (void*)lnum;
    return __true_name; /* NT does't provide information about this */
  }

  const char * _Locale_false(_Locale_numeric_t * lnum) {
    (void*)lnum;
    return __false_name; /* NT does't provide information about this */
  }


  /* Monetary */
  const char* _Locale_int_curr_symbol(_Locale_monetary_t * lmon)
  { return lmon->int_curr_symbol; }

  const char* _Locale_currency_symbol(_Locale_monetary_t * lmon)
  { return lmon->curr_symbol; }

  char _Locale_mon_decimal_point(_Locale_monetary_t * lmon)
  { return lmon->decimal_point[0]; }

  char _Locale_mon_thousands_sep(_Locale_monetary_t * lmon)
  { return lmon->thousands_sep[0]; }

  const char* _Locale_mon_grouping(_Locale_monetary_t * lmon) {
    if (!lmon->grouping) return "";
    else return lmon->grouping;
  }

  const char* _Locale_positive_sign(_Locale_monetary_t * lmon)
  { return lmon->positive_sign; }

  const char* _Locale_negative_sign(_Locale_monetary_t * lmon)
  { return lmon->negative_sign; }

  char _Locale_int_frac_digits(_Locale_monetary_t * lmon)
  { return (char)lmon->int_frac_digits; }

  char _Locale_frac_digits(_Locale_monetary_t * lmon)
  { return (char)lmon->frac_digits; }

  int _Locale_p_cs_precedes(_Locale_monetary_t * lmon) {
    char loc_data[2];
    GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSYMPRECEDES, loc_data, 2);
    if (loc_data[0] == '0') return 0;
    else if (loc_data[0] == '1') return 1;
    else return -1;
  }

  int _Locale_p_sep_by_space(_Locale_monetary_t * lmon) {
    char loc_data[2];
    GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSEPBYSPACE, loc_data, 2);
    if (loc_data[0] == '0') return 0;
    else if (loc_data[0] == '1') return 1;
    else return -1;
  }

  int _Locale_p_sign_posn(_Locale_monetary_t * lmon) {
    char loc_data[2];
    GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSIGNPOSN, loc_data, 2);
    return atoi(loc_data);
  }

  int _Locale_n_cs_precedes(_Locale_monetary_t * lmon) {
    char loc_data[2];
    GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSYMPRECEDES, loc_data, 2);
    if (loc_data[0] == '0') return 0;
    else if (loc_data[0] == '1') return 1;
    else return -1;
  }

  int _Locale_n_sep_by_space(_Locale_monetary_t * lmon) {
    char loc_data[2];
    GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSEPBYSPACE, loc_data, 2);
    if (loc_data[0] == '0') return 0;
    else if (loc_data[0] == '1') return 1;
    else return -1;
  }

  int _Locale_n_sign_posn(_Locale_monetary_t * lmon) {
    char loc_data[2];
    GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSIGNPOSN, loc_data, 2);
    return atoi(loc_data);
  }


  /* Time */
  const char * _Locale_full_monthname(_Locale_time_t * ltime, int month) {
    const char **names = (const char**)ltime->month;
    return names[month];
  }

  const char * _Locale_abbrev_monthname(_Locale_time_t * ltime, int month) {
    const char **names = (const char**)ltime->abbrev_month;
    return names[month];
  }

  const char * _Locale_full_dayofweek(_Locale_time_t * ltime, int day) {
    const char **names = (const char**)ltime->dayofweek;
    return names[day];
  }

  const char * _Locale_abbrev_dayofweek(_Locale_time_t * ltime, int day) {
    const char **names = (const char**)ltime->abbrev_dayofweek;
    return names[day];
  }

const char* _Locale_d_t_fmt(_Locale_time_t* ltime)
{ return ltime->date_time_format; }

const char* _Locale_long_d_t_fmt(_Locale_time_t* ltime)
{ return ltime->long_date_time_format; }

const char* _Locale_d_fmt(_Locale_time_t* ltime)
{ return ltime->date_format; }

const char* _Locale_long_d_fmt(_Locale_time_t* ltime)
{ return ltime->long_date_format; }

const char* _Locale_t_fmt(_Locale_time_t* ltime)
{ return ltime->time_format; }

const char* _Locale_am_str(_Locale_time_t* ltime)
{ return ltime->am; }

const char* _Locale_pm_str(_Locale_time_t* ltime)
{ return ltime->pm; }


  /* Messages */

  int _Locale_catopen(_Locale_messages_t* __DUMMY_PAR1, const char* __DUMMY_PAR) {
    (void*)__DUMMY_PAR1;
    (void*)__DUMMY_PAR;
    return -1;
  }
  void _Locale_catclose(_Locale_messages_t* __DUMMY_PAR1, int __DUMMY_PAR) {
    (void*)__DUMMY_PAR1;
    (void*)&__DUMMY_PAR;
  }
  const char* _Locale_catgets(_Locale_messages_t* __DUMMY_PAR1, int __DUMMY_PAR2,
                              int __DUMMY_PAR3, int __DUMMY_PAR4,
                              const char *dfault) {
    (void*)__DUMMY_PAR1;
    (void*)&__DUMMY_PAR2;
    (void*)&__DUMMY_PAR3;
    (void*)&__DUMMY_PAR4;
    return dfault;
  }

#ifdef __cplusplus
} /* extern C */
_STLP_END_NAMESPACE
#endif

void __FixGrouping(char *grouping) {
  /* This converts NT version which uses '0' instead of 0, etc ; to ANSI */
  while (*grouping) {
    if (*grouping >= '0' && *grouping <= '9') {
      *grouping = *grouping - '0';
      ++grouping;
    }
    else if (*grouping == ';') {
      /* remove ';' */
      char *tmp = grouping;
      for (; *tmp; ++tmp)
        *tmp = *(tmp + 1);
    }
    else
      ++grouping;
  }