730 lines
16 KiB
C
730 lines
16 KiB
C
/*
|
|
* TEST SUITE FOR MB/WC FUNCTIONS IN C LIBRARY
|
|
*
|
|
* FILE: tst_types.h
|
|
*
|
|
* Definitions of data types for each test function
|
|
*/
|
|
|
|
|
|
#ifndef TST_TYPES_H
|
|
#define TST_TYPES_H
|
|
|
|
#include <stdio.h>
|
|
#include <wchar.h>
|
|
#include <wctype.h>
|
|
#include "tst_funcs.h"
|
|
#include "tgn_funcdef.h"
|
|
|
|
#define MBSSIZE 24
|
|
#define WCSSIZE 12
|
|
#define MONFMTSIZE 16
|
|
#define MONSIZE 64
|
|
#define USE_MBCURMAX 99 /* well, but ... */
|
|
#define TST_DBL_EPS 2.22153e-16
|
|
#define WCSTOK_SEQNUM 3
|
|
#define MBLEN_SEQNUM 3
|
|
#define MBTOWC_SEQNUM 3
|
|
#define MBSTOWCS_SEQNUM 3
|
|
#define WCTOMB_SEQNUM 3
|
|
#define WCSTOMBS_SEQNUM 3
|
|
#define MBRLEN_SEQNUM 3
|
|
#define MBRTOWC_SEQNUM 3
|
|
#define MBSRTOWCS_SEQNUM 3
|
|
#define WCRTOMB_SEQNUM 3
|
|
#define WCSRTOMBS_SEQNUM 3
|
|
|
|
/* Maximum numbers of test in one of the _loc arrays. */
|
|
#define MAX_LOC_TEST 300
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* FUNCTION */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
char *func_str;
|
|
int func_id;
|
|
}
|
|
TST_FID;
|
|
|
|
typedef struct
|
|
{
|
|
int func_id;
|
|
const char *locale;
|
|
}
|
|
TST_HEAD;
|
|
|
|
typedef struct
|
|
{
|
|
TST_HEAD *head;
|
|
}
|
|
TST_FUNCS;
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* ISW*: int isw* (wchar_t wc) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
TST_ISW_STRUCT (ALNUM, alnum);
|
|
TST_ISW_STRUCT (ALPHA, alpha);
|
|
TST_ISW_STRUCT (CNTRL, cntrl);
|
|
TST_ISW_STRUCT (DIGIT, digit);
|
|
TST_ISW_STRUCT (GRAPH, graph);
|
|
TST_ISW_STRUCT (LOWER, lower);
|
|
TST_ISW_STRUCT (PRINT, print);
|
|
TST_ISW_STRUCT (PUNCT, punct);
|
|
TST_ISW_STRUCT (SPACE, space);
|
|
TST_ISW_STRUCT (UPPER, upper);
|
|
TST_ISW_STRUCT (XDIGIT, xdigit);
|
|
|
|
typedef struct
|
|
{
|
|
wint_t wc;
|
|
const char *ts;
|
|
}
|
|
TIN_ISWCTYPE_REC;
|
|
|
|
typedef
|
|
TEX_ERRET_REC (int)
|
|
TEX_ISWCTYPE_REC;
|
|
TMD_RECHEAD (ISWCTYPE);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* MBLEN: int mblen (const char *s, size_t n) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
char s_flg;
|
|
char s[MBSSIZE];
|
|
size_t n;
|
|
}
|
|
TIN_MBLEN_REC;
|
|
|
|
typedef TEX_ERRET_REC (int) TEX_MBLEN_REC;
|
|
TMD_RECHEAD (MBLEN);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* MBRLEN: size_t mbrlen (const char *s, size_t n, mbstate_t *ps) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
int s_flg;
|
|
char s[MBSSIZE];
|
|
size_t n;
|
|
int t_flg;
|
|
int t_init;
|
|
}
|
|
seq[WCSTOK_SEQNUM];
|
|
}
|
|
TIN_MBRLEN_REC;
|
|
|
|
typedef TEX_ERRET_REC_SEQ (size_t, MBRLEN_SEQNUM) TEX_MBRLEN_REC;
|
|
TMD_RECHEAD (MBRLEN);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* MBRTOWC: size_t mbrtowc (wchar_t *pwc, const char *s, size_t n, */
|
|
/* mbstate_t *ps) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
int w_flg;
|
|
int s_flg;
|
|
char s[MBSSIZE];
|
|
size_t n;
|
|
int t_flg;
|
|
int t_init;
|
|
}
|
|
seq[MBRTOWC_SEQNUM];
|
|
}
|
|
TIN_MBRTOWC_REC;
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
TMD_ERRET (size_t);
|
|
wchar_t wc;
|
|
}
|
|
seq[MBRTOWC_SEQNUM];
|
|
}
|
|
TEX_MBRTOWC_REC;
|
|
|
|
TMD_RECHEAD (MBRTOWC);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* MBSRTOWCS: size_t mbsrtowcs (wchar_t *ws, const char **s, size_t n, */
|
|
/* mbstate_t *ps ) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
int w_flg;
|
|
char s[MBSSIZE];
|
|
size_t n;
|
|
int t_flg;
|
|
int t_init;
|
|
}
|
|
seq[MBSRTOWCS_SEQNUM];
|
|
}
|
|
TIN_MBSRTOWCS_REC;
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
TMD_ERRET (size_t);
|
|
wchar_t ws[WCSSIZE];
|
|
}
|
|
seq[MBSRTOWCS_SEQNUM];
|
|
}
|
|
TEX_MBSRTOWCS_REC;
|
|
|
|
TMD_RECHEAD (MBSRTOWCS);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* MBSTOWCS: size_t mbstowcs (wchar_t *ws, const char *s, size_t n) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
int w_flg;
|
|
int s_flg;
|
|
const char *s;
|
|
size_t n;
|
|
}
|
|
seq[MBSTOWCS_SEQNUM];
|
|
}
|
|
TIN_MBSTOWCS_REC;
|
|
|
|
typedef TEX_MBSRTOWCS_REC TEX_MBSTOWCS_REC;
|
|
/* MBSRTOWCS_SEQNUM == MBSTOWCS_SEQNUM */
|
|
TMD_RECHEAD (MBSTOWCS);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* MBTOWC: int mbtowc (wchar_t *wc, const char *s, size_t n) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_MBSTOWCS_REC TIN_MBTOWC_REC;
|
|
/* MBTOWC_SEQNUM == MBSTOWCS_SEQNUM */
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
TMD_ERRET (int);
|
|
wchar_t wc;
|
|
}
|
|
seq[MBTOWC_SEQNUM];
|
|
}
|
|
TEX_MBTOWC_REC;
|
|
|
|
TMD_RECHEAD (MBTOWC);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* STRCOLL: int strcoll (const char *s1, const char *s2) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
char s1[MBSSIZE];
|
|
char s2[MBSSIZE];
|
|
}
|
|
TIN_STRCOLL_REC;
|
|
|
|
typedef TEX_ERRET_REC (int) TEX_STRCOLL_REC;
|
|
TMD_RECHEAD (STRCOLL);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* STRFMON: size_t strfmon (char *buf, size_t nbytes, */
|
|
/* const char *fmt, ... ) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
int nbytes;
|
|
char fmt[MONFMTSIZE];
|
|
double val;
|
|
}
|
|
TIN_STRFMON_REC;
|
|
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (size_t);
|
|
char mon[MONSIZE];
|
|
}
|
|
TEX_STRFMON_REC;
|
|
|
|
TMD_RECHEAD (STRFMON);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* STRXFRM: size_t strxfrm (char *s1, const char *s2, size_t n) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
char org1[MBSSIZE];
|
|
char org2[MBSSIZE];
|
|
size_t n1, n2;
|
|
}
|
|
TIN_STRXFRM_REC;
|
|
|
|
typedef TEX_ERRET_REC (size_t) TEX_STRXFRM_REC; /* only for org2[] */
|
|
TMD_RECHEAD (STRXFRM);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* SWSCANF: int swscanf (const wchar_t *ws, const wchar_t *fmt, ...) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wchar_t ws[WCSSIZE * 3];
|
|
wchar_t fmt[WCSSIZE * 3];
|
|
int wch;
|
|
}
|
|
TIN_SWSCANF_REC;
|
|
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (int);
|
|
int val_int; /* %d */
|
|
unsigned val_uns; /* %u */
|
|
float val_flt; /* %f */
|
|
int val_c; /* %c */
|
|
char val_s[MBSSIZE * 2]; /* %s */
|
|
wchar_t val_S[WCSSIZE * 2]; /* %lc, %ls, %C, %S */
|
|
}
|
|
TEX_SWSCANF_REC;
|
|
|
|
TMD_RECHEAD (SWSCANF);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* TOWCTRANS: wint_t towctrans (wint_t wc, wctrans_t desc) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_ISWCTYPE_REC TIN_TOWCTRANS_REC;
|
|
typedef TEX_ERRET_REC (wint_t) TEX_TOWCTRANS_REC;
|
|
TMD_RECHEAD (TOWCTRANS);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* TOW*ER: wint_t tow*er (wint_t wc) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
TST_TOW_STRUCT (LOWER, lower);
|
|
TST_TOW_STRUCT (UPPER, upper);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCRTOMB: wchar_t wcrtomb (char *s, wchar_t wc, mbstate_t *ps) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
int s_flg;
|
|
wchar_t wc;
|
|
int t_flg;
|
|
int t_init;
|
|
}
|
|
TIN_WCRTOMB_REC;
|
|
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (wchar_t);
|
|
char s[MBSSIZE];
|
|
}
|
|
TEX_WCRTOMB_REC;
|
|
|
|
TMD_RECHEAD (WCRTOMB);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSCAT: wchar_t *wcscat (wchar_t *ws1, wchar_t *ws2) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wchar_t ws1[WCSSIZE];
|
|
wchar_t ws2[WCSSIZE];
|
|
}
|
|
TIN_WCSCAT_REC;
|
|
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (wchar_t *);
|
|
wchar_t ws[WCSSIZE];
|
|
}
|
|
TEX_WCSCAT_REC;
|
|
|
|
TMD_RECHEAD (WCSCAT);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSCHR: wchar_t *wcschr (wchar_t *ws, wchar_t wc); */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wchar_t ws[WCSSIZE];
|
|
wchar_t wc;
|
|
}
|
|
TIN_WCSCHR_REC;
|
|
|
|
typedef TEX_ERRET_REC (wchar_t *) TEX_WCSCHR_REC;
|
|
TMD_RECHEAD (WCSCHR);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSCMP: int wcscmp (const wchar_t *ws1, const wchar_t *ws2) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCSCAT_REC TIN_WCSCMP_REC;
|
|
typedef TEX_ERRET_REC (int) TEX_WCSCMP_REC;
|
|
TMD_RECHEAD (WCSCMP);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSCOLL: int wcscoll (const wchar_t *ws1, const wchar_t *ws2) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCSCMP_REC TIN_WCSCOLL_REC;
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (int);
|
|
int cmp_flg;
|
|
}
|
|
TEX_WCSCOLL_REC;
|
|
TMD_RECHEAD (WCSCOLL);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSCPY: wchar_t *wcscpy (wchar_t *ws1, const wchar_t *ws2) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wchar_t ws[WCSSIZE]; /* ws2: original string */
|
|
}
|
|
TIN_WCSCPY_REC;
|
|
|
|
typedef TEX_WCSCAT_REC TEX_WCSCPY_REC;
|
|
TMD_RECHEAD (WCSCPY);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSCSPN: size_t wcscspn (const wchar_t *ws1, const wchar_t *ws2) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCSCAT_REC TIN_WCSCSPN_REC;
|
|
typedef TEX_ERRET_REC (size_t) TEX_WCSCSPN_REC;
|
|
TMD_RECHEAD (WCSCSPN);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSLEN: size_t wcslen (const wchar_t *ws) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCSCPY_REC TIN_WCSLEN_REC;
|
|
typedef TEX_ERRET_REC (size_t) TEX_WCSLEN_REC;
|
|
TMD_RECHEAD (WCSLEN);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSNCAT: wchar_t *wcsncat (wchar_t *ws1, const wchar_t *ws2, */
|
|
/* size_t n) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wchar_t ws1[WCSSIZE];
|
|
wchar_t ws2[WCSSIZE];
|
|
size_t n;
|
|
}
|
|
TIN_WCSNCAT_REC;
|
|
|
|
typedef TEX_WCSCAT_REC TEX_WCSNCAT_REC;
|
|
TMD_RECHEAD (WCSNCAT);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSNCMP: int *wcsncmp (const wchar_t *ws1, const wchar_t *ws2, */
|
|
/* size_t n) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCSNCAT_REC TIN_WCSNCMP_REC;
|
|
typedef TEX_ERRET_REC (int) TEX_WCSNCMP_REC;
|
|
TMD_RECHEAD (WCSNCMP);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSNCPY: wchar_t *wcsncpy (wchar_t *ws1, const wchar_t *ws2, */
|
|
/* size_t n) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wchar_t ws[WCSSIZE]; /* ws2: original string */
|
|
size_t n;
|
|
}
|
|
TIN_WCSNCPY_REC;
|
|
|
|
typedef TEX_WCSCPY_REC TEX_WCSNCPY_REC;
|
|
TMD_RECHEAD (WCSNCPY);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSPBRK: wchar_t *wcspbrk (const wchar_t *ws1, const wchar_t *ws2) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCSCSPN_REC TIN_WCSPBRK_REC;
|
|
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (wchar_t *);
|
|
wchar_t wc;
|
|
}
|
|
TEX_WCSPBRK_REC;
|
|
|
|
TMD_RECHEAD (WCSPBRK);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSRTOMBS: size_t wcsrtombs (char *s, const wchar_t **ws, size_t n, */
|
|
/* mbstate_t *ps) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
int s_flg;
|
|
int w_flg; /* don't need this */
|
|
wchar_t ws[WCSSIZE];
|
|
size_t n;
|
|
int t_flg;
|
|
int t_init;
|
|
}
|
|
TIN_WCSRTOMBS_REC;
|
|
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (size_t);
|
|
char s[MBSSIZE];
|
|
}
|
|
TEX_WCSRTOMBS_REC;
|
|
|
|
TMD_RECHEAD (WCSRTOMBS);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSSPN: size_t wcsspn (const wchar_t *ws1, const wchar_t *ws2) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCSCSPN_REC TIN_WCSSPN_REC;
|
|
typedef TEX_WCSCSPN_REC TEX_WCSSPN_REC;
|
|
TMD_RECHEAD (WCSSPN);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSSTR: wchar_t *wcsstr (const wchar_t *ws1, const wchar_t *ws2) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCSCSPN_REC TIN_WCSSTR_REC;
|
|
typedef TEX_ERRET_REC (wchar_t *) TEX_WCSSTR_REC;
|
|
TMD_RECHEAD (WCSSTR);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSTOD: double wcstod (const wchar_t *np, wchar_t **endp) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wchar_t np[WCSSIZE];
|
|
}
|
|
TIN_WCSTOD_REC;
|
|
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (double);
|
|
double val;
|
|
wchar_t fwc;
|
|
}
|
|
TEX_WCSTOD_REC;
|
|
|
|
TMD_RECHEAD (WCSTOD);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSTOK: wchar_t *wcstok (wchar_t *ws, const wchar_t *dlm, */
|
|
/* wchar_t **pt) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
int w_flg;
|
|
wchar_t ws[WCSSIZE];
|
|
wchar_t dt[WCSSIZE]; /* delimiter */
|
|
}
|
|
seq[WCSTOK_SEQNUM];
|
|
}
|
|
TIN_WCSTOK_REC;
|
|
|
|
typedef struct
|
|
{
|
|
struct
|
|
{
|
|
TMD_ERRET (wchar_t *);
|
|
wchar_t ws[WCSSIZE];
|
|
}
|
|
seq[WCSTOK_SEQNUM];
|
|
}
|
|
TEX_WCSTOK_REC;
|
|
|
|
TMD_RECHEAD (WCSTOK);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSTOMBS: size_t wcstombs (char s, const wchar_t *ws, size_t n) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
int s_flg;
|
|
int w_flg; /* currently we don't need it. */
|
|
wchar_t ws[WCSSIZE];
|
|
size_t n;
|
|
}
|
|
TIN_WCSTOMBS_REC;
|
|
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (size_t);
|
|
char s[MBSSIZE];
|
|
}
|
|
TEX_WCSTOMBS_REC;
|
|
|
|
TMD_RECHEAD (WCSTOMBS);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSWIDTH: int wcswidth (const wchar_t *ws, size_t n) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCSNCPY_REC TIN_WCSWIDTH_REC;
|
|
typedef TEX_ERRET_REC (int) TEX_WCSWIDTH_REC;
|
|
TMD_RECHEAD (WCSWIDTH);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCSXFRM: size_t wcsxfrm (wchar_t *ws1, const wchar_t *ws2, size_t n)*/
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wchar_t org1[WCSSIZE];
|
|
wchar_t org2[WCSSIZE];
|
|
int n1, n2;
|
|
}
|
|
TIN_WCSXFRM_REC;
|
|
|
|
typedef TEX_ERRET_REC (size_t) TEX_WCSXFRM_REC; /* only for org2[] */
|
|
TMD_RECHEAD (WCSXFRM);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCTOB: int wctob (wint_t wc) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wint_t wc;
|
|
}
|
|
TIN_WCTOB_REC;
|
|
|
|
typedef TEX_ERRET_REC (int) TEX_WCTOB_REC;
|
|
TMD_RECHEAD (WCTOB);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCTOMB: int wctomb (char *s, wchar_t wc) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
int s_flg;
|
|
wchar_t wc;
|
|
}
|
|
TIN_WCTOMB_REC;
|
|
|
|
typedef struct
|
|
{
|
|
TMD_ERRET (int);
|
|
char s[MBSSIZE];
|
|
}
|
|
TEX_WCTOMB_REC;
|
|
|
|
TMD_RECHEAD (WCTOMB);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCTRANS: wctrans_t wctrans (const char *charclass) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
char class[MBSSIZE];
|
|
}
|
|
TIN_WCTRANS_REC;
|
|
|
|
typedef TEX_ERRET_REC (wctrans_t) TEX_WCTRANS_REC;
|
|
TMD_RECHEAD (WCTRANS);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCTYPE: wctype_t wctype (const char *class) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef TIN_WCTRANS_REC TIN_WCTYPE_REC;
|
|
typedef TEX_ERRET_REC (wctype_t) TEX_WCTYPE_REC;
|
|
TMD_RECHEAD (WCTYPE);
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* WCWIDTH: int wcwidth (wchar_t wc) */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
typedef struct
|
|
{
|
|
wchar_t wc;
|
|
}
|
|
TIN_WCWIDTH_REC;
|
|
|
|
typedef TEX_ERRET_REC (int) TEX_WCWIDTH_REC;
|
|
TMD_RECHEAD (WCWIDTH);
|
|
|
|
#endif /* TST_TYPES_H */
|