c_locale_win32.c

来自「stl的源码」· C语言 代码 · 共 1,787 行 · 第 1/4 页

{ return _Locale_common_default(buf); }

const char* _Locale_numeric_default(char * buf)
{ return _Locale_common_default(buf); }

const char* _Locale_time_default(char* buf)
{ return _Locale_common_default(buf); }

const char* _Locale_collate_default(char* buf)
{ return _Locale_common_default(buf); }

const char* _Locale_monetary_default(char* buf)
{ return _Locale_common_default(buf); }

const char* _Locale_messages_default(char* buf)
{ return _Locale_common_default(buf); }

char const* _Locale_ctype_name(const _Locale_ctype_t* ltype, char* buf) {
  char cp_buf[MAX_CP_LEN + 1];
  my_ltoa(ltype->cp, cp_buf);
  return __GetLocaleName(ltype->lc.id, cp_buf, buf);
}

char const* _Locale_numeric_name(const _Locale_numeric_t* lnum, char* buf)
{ return __GetLocaleName(lnum->lc.id, lnum->cp, buf); }

char const* _Locale_time_name(const _Locale_time_t* ltime, char* buf)
{ return __GetLocaleName(ltime->lc.id, ltime->cp, buf); }

char const* _Locale_collate_name(const _Locale_collate_t* lcol, char* buf)
{ return __GetLocaleName(lcol->lc.id, lcol->cp, buf); }

char const* _Locale_monetary_name(const _Locale_monetary_t* lmon, char* buf)
{ return __GetLocaleName(lmon->lc.id, lmon->cp, buf); }

char const* _Locale_messages_name(const struct _Locale_messages* lmes, char* buf) {
  _STLP_MARK_PARAMETER_AS_UNUSED(lmes)
  _STLP_MARK_PARAMETER_AS_UNUSED(buf)
  return NULL;
}

void _Locale_ctype_destroy(_Locale_ctype_t* ltype) {
  if (!ltype) return;

  free(ltype);
}

void _Locale_numeric_destroy(_Locale_numeric_t* lnum) {
  if (!lnum) return;

  if (lnum->grouping) free(lnum->grouping);
  free(lnum);
}

void _Locale_time_destroy(_Locale_time_t* ltime) {
  int i;
  if (!ltime) return;

  for (i = 0; i < 12; ++i) {
    if (ltime->month[i]) free(ltime->month[i]);
    if (ltime->abbrev_month[i]) free(ltime->abbrev_month[i]);
  }

  for (i = 0; i < 7; ++i) {
    if (ltime->dayofweek[i]) free(ltime->dayofweek[i]);
    if (ltime->abbrev_dayofweek[i]) free(ltime->abbrev_dayofweek[i]);
  }

  if (ltime->date_format) free(ltime->date_format);
  if (ltime->long_date_format) free(ltime->long_date_format);
  if (ltime->time_format) free(ltime->time_format);
  if (ltime->date_time_format) free(ltime->date_time_format);
  if (ltime->long_date_time_format) free(ltime->long_date_time_format);

  free(ltime);
}

void _Locale_collate_destroy(_Locale_collate_t* lcol) {
  if (!lcol) return;

  free(lcol);
}

void _Locale_monetary_destroy(_Locale_monetary_t* lmon) {
  if (!lmon) return;

  if (lmon->grouping) free(lmon->grouping);
  free(lmon);
}

void _Locale_messages_destroy(struct _Locale_messages* lmes)
{ _STLP_MARK_PARAMETER_AS_UNUSED(lmes) }

static char const* _Locale_extract_category_name(const char* name, const char* category, char* buf,
                                                 _Locale_lcid_t* hint, int *__err_code) {
  const char* cname = __Extract_locale_name(name, category, buf);
  if (cname == 0 || (cname[0] == 'C' && cname[1] == 0)) {
    return cname;
  }
  return __TranslateToSystem(cname, buf, hint, __err_code);
}

char const* _Locale_extract_ctype_name(const char* cname, char* buf,
                                       _Locale_lcid_t* hint, int *__err_code)
{ return _Locale_extract_category_name(cname, "LC_CTYPE", buf, hint, __err_code); }

char const* _Locale_extract_numeric_name(const char* cname, char* buf,
                                         _Locale_lcid_t* hint, int *__err_code)
{ return _Locale_extract_category_name(cname, "LC_NUMERIC", buf, hint, __err_code); }

char const* _Locale_extract_time_name(const char* cname, char* buf,
                                      _Locale_lcid_t* hint, int *__err_code)
{ return _Locale_extract_category_name(cname, "LC_TIME", buf, hint, __err_code); }

char const* _Locale_extract_collate_name(const char* cname, char* buf,
                                         _Locale_lcid_t* hint, int *__err_code)
{ return _Locale_extract_category_name(cname, "LC_COLLATE", buf, hint, __err_code); }

char const* _Locale_extract_monetary_name(const char* cname, char* buf,
                                          _Locale_lcid_t* hint, int *__err_code)
{ return _Locale_extract_category_name(cname, "LC_MONETARY", buf, hint, __err_code); }

char const* _Locale_extract_messages_name(const char* cname, char* buf,
                                          _Locale_lcid_t* hint, int *__err_code) {
  if (cname[0] == 'L' && cname[1] == 'C' && cname[2] == '_') {
    return _C_name;
  }
  if (cname[0] == 'C' && cname[1] == 0) {
    return _C_name;
  }
  return __TranslateToSystem(cname, buf, hint, __err_code);
}

/* ctype */

const _Locale_mask_t* _Locale_ctype_table(_Locale_ctype_t* ltype) {
  _STLP_STATIC_ASSERT(sizeof(_Locale_mask_t) == sizeof(ltype->ctable[0]))
  return (const _Locale_mask_t*)ltype->ctable;
}

int _Locale_toupper(_Locale_ctype_t* ltype, int c) {
  char buf[2], out_buf[2];
  buf[0] = (char)c; buf[1] = 0;
  if ((UINT)__GetDefaultCP(ltype->lc.id) == ltype->cp) {
    LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_UPPERCASE, buf, 2, out_buf, 2);
    return out_buf[0];
  }
  else {
    wchar_t wbuf[2];
    MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, buf, 2, wbuf, 2);
    WideCharToMultiByte(__GetDefaultCP(ltype->lc.id), WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, buf, 2, NULL, FALSE);

    LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_UPPERCASE, buf, 2, out_buf, 2);

    MultiByteToWideChar(__GetDefaultCP(ltype->lc.id), MB_PRECOMPOSED, out_buf, 2, wbuf, 2);
    WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, out_buf, 2, NULL, FALSE);
    return out_buf[0];
  }
}

int _Locale_tolower(_Locale_ctype_t* ltype, int c) {
  char buf[2], out_buf[2];
  buf[0] = (char)c; buf[1] = 0;
  if ((UINT)__GetDefaultCP(ltype->lc.id) == ltype->cp) {
    LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_LOWERCASE, buf, 2, out_buf, 2);
    return out_buf[0];
  }
  else {
    wchar_t wbuf[2];
    MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, buf, 2, wbuf, 2);
    WideCharToMultiByte(__GetDefaultCP(ltype->lc.id), WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, buf, 2, NULL, FALSE);

    LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_LOWERCASE, buf, 2, out_buf, 2);

    MultiByteToWideChar(__GetDefaultCP(ltype->lc.id), MB_PRECOMPOSED, out_buf, 2, wbuf, 2);
    WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, out_buf, 2, NULL, FALSE);
    return out_buf[0];
  }
}

#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;
}

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;
}

/* 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) {
  _STLP_MARK_PARAMETER_AS_UNUSED(lnum)
  return __true_name; /* NT does't provide information about this */
}

const char * _Locale_false(_Locale_numeric_t * lnum) {
  _STLP_MARK_PARAMETER_AS_UNUSED(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];
  if (lmon->lc.id != INVARIANT_LCID) {
    GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSIGNPOSN, loc_data, 2);
    return atoi(loc_data);
  }
  else {
    return CHAR_MAX;
  }
}

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];
  if (lmon->lc.id != INVARIANT_LCID) {
    GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSIGNPOSN, loc_data, 2);
    return atoi(loc_data);
  }
  else {
    return CHAR_MAX;
  }
}

/* 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 */
nl_catd_type _Locale_catopen(struct _Locale_messages* lmes, const char* cat_name) {
  _STLP_MARK_PARAMETER_AS_UNUSED(lmes)
  _STLP_MARK_PARAMETER_AS_UNUSED(cat_name)
  return -1;
}
void _Locale_catclose(struct _Locale_messages* lmes, nl_catd_type cat) {
  _STLP_MARK_PARAMETER_AS_UNUSED(lmes)
  _STLP_MARK_PARAMETER_AS_UNUSED(&cat)
}
const char* _Locale_catgets(struct _Locale_messages* lmes, nl_catd_type cat,
                            int setid, int msgid, const char *dfault) {
  _STLP_MARK_PARAMETER_AS_UNUSED(lmes)
  _STLP_MARK_PARAMETER_AS_UNUSED(&cat)
  _STLP_MARK_PARAMETER_AS_UNUSED(&setid)
  _STLP_MARK_PARAMETER_AS_UNUSED(&msgid)
  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 */
  char *g = grouping;
  char building_group = 0;
  char repeat_last = 0;
  /* Check there is a grouping info otherwise we would add a useless CHAR_MAX */
  if (*g) {
    for (; *g; ++g) {
      if (*g > '0' && *g <= '9') {
        if (!building_group) {
          *grouping = *g - '0';
          building_group = 1;
        }