c_locale_win32.c

使用QT为linux 下的mplayer写的一个新的gui

    if (c == EOF) return WEOF;

    MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, (char*)&c, 1, &wc, 1);

    return (wint_t)wc;
  }

  int _Locale_wctob(_Locale_ctype_t * ltype, wint_t wc) {
    char c;

    if (WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_DEFAULTCHAR, (wchar_t*)&wc, 1, &c, 1, NULL, NULL) == 0)
      return WEOF; /* Not single byte or error conversion. */

    return (int)c;
  }

  static int __isleadbyte(int c, unsigned int *ctable) {
    return (ctable[(unsigned char)(c)] & _LEADBYTE);
  }

  static size_t __mbtowc(_Locale_ctype_t *l, wchar_t *dst, char src, mbstate_t *shift_state) {
    int result;

    if (*shift_state == 0) {
      if (__isleadbyte(src, l->ctable)) {
        ((unsigned char*)shift_state)[0] = src;
        return (size_t)-2;
      }
      else {
        result = MultiByteToWideChar(l->cp, MB_PRECOMPOSED, &src, 1, dst, 1);
        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 */