c_locale.h

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

int _Locale_mb_cur_min (struct _Locale_ctype *);
/*
 * Returns the number of bytes of the shortest allowed multibyte
 * character in the current encoding.
 */

int _Locale_is_stateless (struct _Locale_ctype *);
/*
 * Returns 1 if the current multibyte encoding is stateless
 * and does not require the use of an mbstate_t value.
 */

# ifndef _STLP_NO_WCHAR_T
wint_t _Locale_btowc(struct _Locale_ctype *, int);
int _Locale_wctob(struct _Locale_ctype *, wint_t);

/*
 * Just like btowc and wctob, from 4.6.5.1 of the C standard, Normative
 * Addendum 1.  (And just like widen/narrow, from clause 22 of the C++
 * standard.)
 */

size_t _Locale_mbtowc(struct _Locale_ctype *,
                      wchar_t *,
                      const char *, size_t,
                      mbstate_t *);

/*
 * Almost identical to mbrtowc, from 4.6.5.3.2 of NA1.  The only
 * important difference is that mbrtowc treats null wide characters
 * as special, and we don't.  Specifically: examines the characters
 * in [from, from + n), extracts a single wide character, and stores
 * it in *to.  Modifies shift_state if appropriate.  The return value,
 * which is always positive, is the number of characters extracted from
 * the input sequence.  Return value is (size_t) -1 if there was an
 * encoding error in the input sequence, and (size_t) -2 if
 * [from, from + n) is correct but not complete.  None of the pointer
 * arguments may be null pointers.
 */

size_t _Locale_wctomb(struct _Locale_ctype *,
                      char *, size_t,
                      const wchar_t,
                      mbstate_t *);

/*
 * Again, very similar to wcrtomb.  The differences are that (1) it
 * doesn't treat null characters as special; and (2) it stores at most
 * n characters.  Converts c to a multibyte sequence, stores that
 * sequence in the array 'to', and returns the length of the sequence.
 * Modifies shift_state if appropriate.  The return value is (size_t) -1
 * if c is not a valid wide character, and (size_t) -2 if the length of
 * the multibyte character sequence is greater than n.
 */
# endif

size_t _Locale_unshift(struct _Locale_ctype *,
                       mbstate_t *,
                       char *, size_t, char **);

/*
 * Inserts whatever characters are necessary to restore st to an
 * initial shift state.  Sets *next to buf + m, where m is the number
 * of characters inserted.  (0 <= m <= n.)  Returns m to indicate
 * success, (size_t) -1 to indicate error, (size_t) -2 to indicate
 * partial success (more than n characters needed).  For success or partial
 * success, sets *next to buf + m.
 */

# endif /*  _STLP_NO_MBSTATE_T */

/*
 * FUNCTIONS THAT USE COLLATE
 */

int _Locale_strcmp(struct _Locale_collate *,
                   const char *, size_t,
                   const char *, size_t);
# ifndef _STLP_NO_WCHAR_T
int _Locale_strwcmp(struct _Locale_collate *,
                    const wchar_t *, size_t,
                    const wchar_t *, size_t);
# endif
/*
 * Compares the two sequences [s1, s1 + n1) and [s2, s2 + n2).  Neither
 * sequence is assumed to be null-terminated, and null characters
 * aren't special.  If the two sequences are the same up through
 * min(n1, n2), then the sequence that compares less is whichever one
 * is shorter.
 */

size_t _Locale_strxfrm(struct _Locale_collate *,
                       char *, size_t,
                       const char *, size_t);

# ifndef _STLP_NO_WCHAR_T
size_t _Locale_strwxfrm(struct _Locale_collate *,
                        wchar_t *, size_t,
                        const wchar_t *, size_t);
# endif

/*
 * Creates a transformed version of the string [s2, s2 + n2).  The
 * string may contain embedded null characters; nulls aren't special.
 * The transformed string begins at s1, and contains at most n1
 * characters.  The return value is the length of the transformed
 * string.  If the return value is greater than n1 then this is an
 * error condition: it indicates that there wasn't enough space.  In
 * that case, the contents of [s1, s1 + n1) is unspecified.
*/

/*
 * FUNCTIONS THAT USE NUMERIC
 */

/*
 * Equivalent to the first three fields in struct lconv.  (C standard,
 * section 7.4.)
 */
char _Locale_decimal_point(struct _Locale_numeric *);
char _Locale_thousands_sep(struct _Locale_numeric *);
const char * _Locale_grouping(struct _Locale_numeric *);


/*
 * Return "true" and "false" in English locales, and something
 * appropriate in non-English locales.
 */
const char * _Locale_true(struct _Locale_numeric *);
const char * _Locale_false(struct _Locale_numeric *);


/*
 * FUNCTIONS THAT USE MONETARY
 */

/*
 * Return the obvious fields of struct lconv.
 */
const char * _Locale_int_curr_symbol(struct _Locale_monetary *);
const char * _Locale_currency_symbol(struct _Locale_monetary *);
char         _Locale_mon_decimal_point(struct _Locale_monetary *);
char         _Locale_mon_thousands_sep(struct _Locale_monetary *);
const char * _Locale_mon_grouping(struct _Locale_monetary *);
const char * _Locale_positive_sign(struct _Locale_monetary *);
const char * _Locale_negative_sign(struct _Locale_monetary *);
char         _Locale_int_frac_digits(struct _Locale_monetary *);
char         _Locale_frac_digits(struct _Locale_monetary *);
int          _Locale_p_cs_precedes(struct _Locale_monetary *);
int          _Locale_p_sep_by_space(struct _Locale_monetary *);
int          _Locale_p_sign_posn(struct _Locale_monetary *);
int          _Locale_n_cs_precedes(struct _Locale_monetary *);
int          _Locale_n_sep_by_space(struct _Locale_monetary *);
int          _Locale_n_sign_posn(struct _Locale_monetary *);


/*
 * FUNCTIONS THAT USE TIME
 */

/*
 * month is in the range [0, 12).
 */
const char * _Locale_full_monthname(struct _Locale_time *, int);
const char * _Locale_abbrev_monthname(struct _Locale_time *, int);


/*
 * day is in the range [0, 7).  Sunday is 0.
 */
const char * _Locale_full_dayofweek(struct _Locale_time *, int);
const char * _Locale_abbrev_dayofweek(struct _Locale_time *, int);


const char * _Locale_d_t_fmt(struct _Locale_time *);
const char * _Locale_d_fmt(struct _Locale_time *);
const char * _Locale_t_fmt(struct _Locale_time *);
const char * _Locale_long_d_t_fmt(struct _Locale_time*);
const char * _Locale_long_d_fmt(struct _Locale_time*);

const char * _Locale_am_str(struct _Locale_time *);
const char * _Locale_pm_str(struct _Locale_time *);
const char * _Locale_t_fmt_ampm(struct _Locale_time *);


/*
 * FUNCTIONS THAT USE MESSAGES
 */

# ifdef _STLP_REAL_LOCALE_IMPLEMENTED
#  if defined (WIN32) || defined (_WIN32)
typedef int nl_catd_type;
#  elif defined (_STLP_USE_GLIBC) && !defined (__CYGWIN__)
typedef nl_catd nl_catd_type;
#  else
typedef int nl_catd_type;
#  endif
# else
typedef int nl_catd_type;
# endif /* _STLP_REAL_LOCALE_IMPLEMENTED */


/*
 * Very similar to catopen, except that it uses the given message
 * category to determine which catalog to open.
 */
nl_catd_type _Locale_catopen(struct _Locale_messages*, const char*);

/* Complementary to _Locale_catopen.
 * The catalog must be a value that was returned by a previous call
 * to _Locale_catopen.
 */
void _Locale_catclose(struct _Locale_messages*, nl_catd_type);

/*
 * Returns a string, identified by a set index and a message index,
 * from an opened message catalog.  Returns the supplied default if
 * no such string exists.
 */
const char * _Locale_catgets(struct _Locale_messages *, nl_catd_type,
                             int, int,const char *);

#ifdef __cplusplus
}
#endif

#endif /* _STLP_C_LOCALE_IMPL_H */