1 | /* |
2 | * TEST SUITE FOR MB/WC FUNCTIONS IN C LIBRARY |
3 | * |
4 | * FILE: tst_types.h |
5 | * |
6 | * Definitions of data types for each test function |
7 | */ |
8 | |
9 | |
10 | #ifndef TST_TYPES_H |
11 | #define TST_TYPES_H |
12 | |
13 | #include <stdio.h> |
14 | #include <wchar.h> |
15 | #include <wctype.h> |
16 | #include "tst_funcs.h" |
17 | #include "tgn_funcdef.h" |
18 | |
19 | #define MBSSIZE 24 |
20 | #define WCSSIZE 12 |
21 | #define MONFMTSIZE 16 |
22 | #define MONSIZE 64 |
23 | #define USE_MBCURMAX 99 /* well, but ... */ |
24 | #define TST_DBL_EPS 2.22153e-16 |
25 | #define WCSTOK_SEQNUM 3 |
26 | #define MBLEN_SEQNUM 3 |
27 | #define MBTOWC_SEQNUM 3 |
28 | #define MBSTOWCS_SEQNUM 3 |
29 | #define WCTOMB_SEQNUM 3 |
30 | #define WCSTOMBS_SEQNUM 3 |
31 | #define MBRLEN_SEQNUM 3 |
32 | #define MBRTOWC_SEQNUM 3 |
33 | #define MBSRTOWCS_SEQNUM 3 |
34 | #define WCRTOMB_SEQNUM 3 |
35 | #define WCSRTOMBS_SEQNUM 3 |
36 | |
37 | /* Maximum numbers of test in one of the _loc arrays. */ |
38 | #define MAX_LOC_TEST 300 |
39 | |
40 | |
41 | /*----------------------------------------------------------------------*/ |
42 | /* FUNCTION */ |
43 | /*----------------------------------------------------------------------*/ |
44 | |
45 | typedef struct |
46 | { |
47 | char *func_str; |
48 | int func_id; |
49 | } |
50 | TST_FID; |
51 | |
52 | typedef struct |
53 | { |
54 | int func_id; |
55 | const char *locale; |
56 | } |
57 | TST_HEAD; |
58 | |
59 | typedef struct |
60 | { |
61 | TST_HEAD *head; |
62 | } |
63 | TST_FUNCS; |
64 | |
65 | |
66 | /*----------------------------------------------------------------------*/ |
67 | /* ISW*: int isw* (wchar_t wc) */ |
68 | /*----------------------------------------------------------------------*/ |
69 | |
70 | TST_ISW_STRUCT (ALNUM, alnum); |
71 | TST_ISW_STRUCT (ALPHA, alpha); |
72 | TST_ISW_STRUCT (CNTRL, cntrl); |
73 | TST_ISW_STRUCT (DIGIT, digit); |
74 | TST_ISW_STRUCT (GRAPH, graph); |
75 | TST_ISW_STRUCT (LOWER, lower); |
76 | TST_ISW_STRUCT (PRINT, print); |
77 | TST_ISW_STRUCT (PUNCT, punct); |
78 | TST_ISW_STRUCT (SPACE, space); |
79 | TST_ISW_STRUCT (UPPER, upper); |
80 | TST_ISW_STRUCT (XDIGIT, xdigit); |
81 | |
82 | typedef struct |
83 | { |
84 | wint_t wc; |
85 | const char *ts; |
86 | } |
87 | TIN_ISWCTYPE_REC; |
88 | |
89 | typedef |
90 | TEX_ERRET_REC (int) |
91 | TEX_ISWCTYPE_REC; |
92 | TMD_RECHEAD (ISWCTYPE); |
93 | |
94 | |
95 | /*----------------------------------------------------------------------*/ |
96 | /* MBLEN: int mblen (const char *s, size_t n) */ |
97 | /*----------------------------------------------------------------------*/ |
98 | |
99 | typedef struct |
100 | { |
101 | char s_flg; |
102 | char s[MBSSIZE]; |
103 | size_t n; |
104 | } |
105 | TIN_MBLEN_REC; |
106 | |
107 | typedef TEX_ERRET_REC (int) TEX_MBLEN_REC; |
108 | TMD_RECHEAD (MBLEN); |
109 | |
110 | |
111 | /*----------------------------------------------------------------------*/ |
112 | /* MBRLEN: size_t mbrlen (const char *s, size_t n, mbstate_t *ps) */ |
113 | /*----------------------------------------------------------------------*/ |
114 | |
115 | typedef struct |
116 | { |
117 | struct |
118 | { |
119 | int s_flg; |
120 | char s[MBSSIZE]; |
121 | size_t n; |
122 | int t_flg; |
123 | int t_init; |
124 | } |
125 | seq[MBRLEN_SEQNUM]; |
126 | } |
127 | TIN_MBRLEN_REC; |
128 | |
129 | typedef TEX_ERRET_REC_SEQ (size_t, MBRLEN_SEQNUM) TEX_MBRLEN_REC; |
130 | TMD_RECHEAD (MBRLEN); |
131 | |
132 | |
133 | /*----------------------------------------------------------------------*/ |
134 | /* MBRTOWC: size_t mbrtowc (wchar_t *pwc, const char *s, size_t n, */ |
135 | /* mbstate_t *ps) */ |
136 | /*----------------------------------------------------------------------*/ |
137 | |
138 | typedef struct |
139 | { |
140 | struct |
141 | { |
142 | int w_flg; |
143 | int s_flg; |
144 | char s[MBSSIZE]; |
145 | size_t n; |
146 | int t_flg; |
147 | int t_init; |
148 | } |
149 | seq[MBRTOWC_SEQNUM]; |
150 | } |
151 | TIN_MBRTOWC_REC; |
152 | |
153 | typedef struct |
154 | { |
155 | struct |
156 | { |
157 | TMD_ERRET (size_t); |
158 | wchar_t wc; |
159 | } |
160 | seq[MBRTOWC_SEQNUM]; |
161 | } |
162 | TEX_MBRTOWC_REC; |
163 | |
164 | TMD_RECHEAD (MBRTOWC); |
165 | |
166 | |
167 | /*----------------------------------------------------------------------*/ |
168 | /* MBSRTOWCS: size_t mbsrtowcs (wchar_t *ws, const char **s, size_t n, */ |
169 | /* mbstate_t *ps ) */ |
170 | /*----------------------------------------------------------------------*/ |
171 | |
172 | typedef struct |
173 | { |
174 | struct |
175 | { |
176 | int w_flg; |
177 | char s[MBSSIZE]; |
178 | size_t n; |
179 | int t_flg; |
180 | int t_init; |
181 | } |
182 | seq[MBSRTOWCS_SEQNUM]; |
183 | } |
184 | TIN_MBSRTOWCS_REC; |
185 | |
186 | typedef struct |
187 | { |
188 | struct |
189 | { |
190 | TMD_ERRET (size_t); |
191 | wchar_t ws[WCSSIZE]; |
192 | } |
193 | seq[MBSRTOWCS_SEQNUM]; |
194 | } |
195 | TEX_MBSRTOWCS_REC; |
196 | |
197 | TMD_RECHEAD (MBSRTOWCS); |
198 | |
199 | |
200 | /*----------------------------------------------------------------------*/ |
201 | /* MBSTOWCS: size_t mbstowcs (wchar_t *ws, const char *s, size_t n) */ |
202 | /*----------------------------------------------------------------------*/ |
203 | |
204 | typedef struct |
205 | { |
206 | struct |
207 | { |
208 | int w_flg; |
209 | int s_flg; |
210 | const char *s; |
211 | size_t n; |
212 | } |
213 | seq[MBSTOWCS_SEQNUM]; |
214 | } |
215 | TIN_MBSTOWCS_REC; |
216 | |
217 | typedef TEX_MBSRTOWCS_REC TEX_MBSTOWCS_REC; |
218 | /* MBSRTOWCS_SEQNUM == MBSTOWCS_SEQNUM */ |
219 | TMD_RECHEAD (MBSTOWCS); |
220 | |
221 | |
222 | /*----------------------------------------------------------------------*/ |
223 | /* MBTOWC: int mbtowc (wchar_t *wc, const char *s, size_t n) */ |
224 | /*----------------------------------------------------------------------*/ |
225 | |
226 | typedef TIN_MBSTOWCS_REC TIN_MBTOWC_REC; |
227 | /* MBTOWC_SEQNUM == MBSTOWCS_SEQNUM */ |
228 | |
229 | typedef struct |
230 | { |
231 | struct |
232 | { |
233 | TMD_ERRET (int); |
234 | wchar_t wc; |
235 | } |
236 | seq[MBTOWC_SEQNUM]; |
237 | } |
238 | TEX_MBTOWC_REC; |
239 | |
240 | TMD_RECHEAD (MBTOWC); |
241 | |
242 | |
243 | /*----------------------------------------------------------------------*/ |
244 | /* STRCOLL: int strcoll (const char *s1, const char *s2) */ |
245 | /*----------------------------------------------------------------------*/ |
246 | |
247 | typedef struct |
248 | { |
249 | char s1[MBSSIZE]; |
250 | char s2[MBSSIZE]; |
251 | } |
252 | TIN_STRCOLL_REC; |
253 | |
254 | typedef TEX_ERRET_REC (int) TEX_STRCOLL_REC; |
255 | TMD_RECHEAD (STRCOLL); |
256 | |
257 | |
258 | /*----------------------------------------------------------------------*/ |
259 | /* STRFMON: size_t strfmon (char *buf, size_t nbytes, */ |
260 | /* const char *fmt, ... ) */ |
261 | /*----------------------------------------------------------------------*/ |
262 | |
263 | typedef struct |
264 | { |
265 | int nbytes; |
266 | char fmt[MONFMTSIZE]; |
267 | double val; |
268 | } |
269 | TIN_STRFMON_REC; |
270 | |
271 | typedef struct |
272 | { |
273 | TMD_ERRET (size_t); |
274 | char mon[MONSIZE]; |
275 | } |
276 | TEX_STRFMON_REC; |
277 | |
278 | TMD_RECHEAD (STRFMON); |
279 | |
280 | |
281 | /*----------------------------------------------------------------------*/ |
282 | /* STRXFRM: size_t strxfrm (char *s1, const char *s2, size_t n) */ |
283 | /*----------------------------------------------------------------------*/ |
284 | |
285 | typedef struct |
286 | { |
287 | char org1[MBSSIZE]; |
288 | char org2[MBSSIZE]; |
289 | size_t n1, n2; |
290 | } |
291 | TIN_STRXFRM_REC; |
292 | |
293 | typedef TEX_ERRET_REC (size_t) TEX_STRXFRM_REC; /* only for org2[] */ |
294 | TMD_RECHEAD (STRXFRM); |
295 | |
296 | |
297 | /*----------------------------------------------------------------------*/ |
298 | /* SWSCANF: int swscanf (const wchar_t *ws, const wchar_t *fmt, ...) */ |
299 | /*----------------------------------------------------------------------*/ |
300 | |
301 | typedef struct |
302 | { |
303 | wchar_t ws[WCSSIZE * 3]; |
304 | wchar_t fmt[WCSSIZE * 3]; |
305 | int wch; |
306 | } |
307 | TIN_SWSCANF_REC; |
308 | |
309 | typedef struct |
310 | { |
311 | TMD_ERRET (int); |
312 | int val_int; /* %d */ |
313 | unsigned val_uns; /* %u */ |
314 | float val_flt; /* %f */ |
315 | int val_c; /* %c */ |
316 | char val_s[MBSSIZE * 2]; /* %s */ |
317 | wchar_t val_S[WCSSIZE * 2]; /* %lc, %ls, %C, %S */ |
318 | } |
319 | TEX_SWSCANF_REC; |
320 | |
321 | TMD_RECHEAD (SWSCANF); |
322 | |
323 | |
324 | /*----------------------------------------------------------------------*/ |
325 | /* TOWCTRANS: wint_t towctrans (wint_t wc, wctrans_t desc) */ |
326 | /*----------------------------------------------------------------------*/ |
327 | |
328 | typedef TIN_ISWCTYPE_REC TIN_TOWCTRANS_REC; |
329 | typedef TEX_ERRET_REC (wint_t) TEX_TOWCTRANS_REC; |
330 | TMD_RECHEAD (TOWCTRANS); |
331 | |
332 | |
333 | /*----------------------------------------------------------------------*/ |
334 | /* TOW*ER: wint_t tow*er (wint_t wc) */ |
335 | /*----------------------------------------------------------------------*/ |
336 | |
337 | TST_TOW_STRUCT (LOWER, lower); |
338 | TST_TOW_STRUCT (UPPER, upper); |
339 | |
340 | |
341 | /*----------------------------------------------------------------------*/ |
342 | /* WCRTOMB: wchar_t wcrtomb (char *s, wchar_t wc, mbstate_t *ps) */ |
343 | /*----------------------------------------------------------------------*/ |
344 | |
345 | typedef struct |
346 | { |
347 | int s_flg; |
348 | wchar_t wc; |
349 | int t_flg; |
350 | int t_init; |
351 | } |
352 | TIN_WCRTOMB_REC; |
353 | |
354 | typedef struct |
355 | { |
356 | TMD_ERRET (wchar_t); |
357 | char s[MBSSIZE]; |
358 | } |
359 | TEX_WCRTOMB_REC; |
360 | |
361 | TMD_RECHEAD (WCRTOMB); |
362 | |
363 | |
364 | /*----------------------------------------------------------------------*/ |
365 | /* WCSCAT: wchar_t *wcscat (wchar_t *ws1, wchar_t *ws2) */ |
366 | /*----------------------------------------------------------------------*/ |
367 | |
368 | typedef struct |
369 | { |
370 | wchar_t ws1[WCSSIZE]; |
371 | wchar_t ws2[WCSSIZE]; |
372 | } |
373 | TIN_WCSCAT_REC; |
374 | |
375 | typedef struct |
376 | { |
377 | TMD_ERRET (wchar_t *); |
378 | wchar_t ws[WCSSIZE]; |
379 | } |
380 | TEX_WCSCAT_REC; |
381 | |
382 | TMD_RECHEAD (WCSCAT); |
383 | |
384 | |
385 | /*----------------------------------------------------------------------*/ |
386 | /* WCSCHR: wchar_t *wcschr (wchar_t *ws, wchar_t wc); */ |
387 | /*----------------------------------------------------------------------*/ |
388 | |
389 | typedef struct |
390 | { |
391 | wchar_t ws[WCSSIZE]; |
392 | wchar_t wc; |
393 | } |
394 | TIN_WCSCHR_REC; |
395 | |
396 | typedef TEX_ERRET_REC (wchar_t *) TEX_WCSCHR_REC; |
397 | TMD_RECHEAD (WCSCHR); |
398 | |
399 | |
400 | /*----------------------------------------------------------------------*/ |
401 | /* WCSCMP: int wcscmp (const wchar_t *ws1, const wchar_t *ws2) */ |
402 | /*----------------------------------------------------------------------*/ |
403 | |
404 | typedef TIN_WCSCAT_REC TIN_WCSCMP_REC; |
405 | typedef TEX_ERRET_REC (int) TEX_WCSCMP_REC; |
406 | TMD_RECHEAD (WCSCMP); |
407 | |
408 | |
409 | /*----------------------------------------------------------------------*/ |
410 | /* WCSCOLL: int wcscoll (const wchar_t *ws1, const wchar_t *ws2) */ |
411 | /*----------------------------------------------------------------------*/ |
412 | |
413 | typedef TIN_WCSCMP_REC TIN_WCSCOLL_REC; |
414 | typedef struct |
415 | { |
416 | TMD_ERRET (int); |
417 | int cmp_flg; |
418 | } |
419 | TEX_WCSCOLL_REC; |
420 | TMD_RECHEAD (WCSCOLL); |
421 | |
422 | |
423 | /*----------------------------------------------------------------------*/ |
424 | /* WCSCPY: wchar_t *wcscpy (wchar_t *ws1, const wchar_t *ws2) */ |
425 | /*----------------------------------------------------------------------*/ |
426 | |
427 | typedef struct |
428 | { |
429 | wchar_t ws[WCSSIZE]; /* ws2: original string */ |
430 | } |
431 | TIN_WCSCPY_REC; |
432 | |
433 | typedef TEX_WCSCAT_REC TEX_WCSCPY_REC; |
434 | TMD_RECHEAD (WCSCPY); |
435 | |
436 | |
437 | /*----------------------------------------------------------------------*/ |
438 | /* WCSCSPN: size_t wcscspn (const wchar_t *ws1, const wchar_t *ws2) */ |
439 | /*----------------------------------------------------------------------*/ |
440 | |
441 | typedef TIN_WCSCAT_REC TIN_WCSCSPN_REC; |
442 | typedef TEX_ERRET_REC (size_t) TEX_WCSCSPN_REC; |
443 | TMD_RECHEAD (WCSCSPN); |
444 | |
445 | |
446 | /*----------------------------------------------------------------------*/ |
447 | /* WCSLEN: size_t wcslen (const wchar_t *ws) */ |
448 | /*----------------------------------------------------------------------*/ |
449 | |
450 | typedef TIN_WCSCPY_REC TIN_WCSLEN_REC; |
451 | typedef TEX_ERRET_REC (size_t) TEX_WCSLEN_REC; |
452 | TMD_RECHEAD (WCSLEN); |
453 | |
454 | |
455 | /*----------------------------------------------------------------------*/ |
456 | /* WCSNCAT: wchar_t *wcsncat (wchar_t *ws1, const wchar_t *ws2, */ |
457 | /* size_t n) */ |
458 | /*----------------------------------------------------------------------*/ |
459 | |
460 | typedef struct |
461 | { |
462 | wchar_t ws1[WCSSIZE]; |
463 | wchar_t ws2[WCSSIZE]; |
464 | size_t n; |
465 | } |
466 | TIN_WCSNCAT_REC; |
467 | |
468 | typedef TEX_WCSCAT_REC TEX_WCSNCAT_REC; |
469 | TMD_RECHEAD (WCSNCAT); |
470 | |
471 | |
472 | /*----------------------------------------------------------------------*/ |
473 | /* WCSNCMP: int *wcsncmp (const wchar_t *ws1, const wchar_t *ws2, */ |
474 | /* size_t n) */ |
475 | /*----------------------------------------------------------------------*/ |
476 | |
477 | typedef TIN_WCSNCAT_REC TIN_WCSNCMP_REC; |
478 | typedef TEX_ERRET_REC (int) TEX_WCSNCMP_REC; |
479 | TMD_RECHEAD (WCSNCMP); |
480 | |
481 | |
482 | /*----------------------------------------------------------------------*/ |
483 | /* WCSNCPY: wchar_t *wcsncpy (wchar_t *ws1, const wchar_t *ws2, */ |
484 | /* size_t n) */ |
485 | /*----------------------------------------------------------------------*/ |
486 | |
487 | typedef struct |
488 | { |
489 | wchar_t ws[WCSSIZE]; /* ws2: original string */ |
490 | size_t n; |
491 | } |
492 | TIN_WCSNCPY_REC; |
493 | |
494 | typedef TEX_WCSCPY_REC TEX_WCSNCPY_REC; |
495 | TMD_RECHEAD (WCSNCPY); |
496 | |
497 | |
498 | /*----------------------------------------------------------------------*/ |
499 | /* WCSPBRK: wchar_t *wcspbrk (const wchar_t *ws1, const wchar_t *ws2) */ |
500 | /*----------------------------------------------------------------------*/ |
501 | |
502 | typedef TIN_WCSCSPN_REC TIN_WCSPBRK_REC; |
503 | |
504 | typedef struct |
505 | { |
506 | TMD_ERRET (wchar_t *); |
507 | wchar_t wc; |
508 | } |
509 | TEX_WCSPBRK_REC; |
510 | |
511 | TMD_RECHEAD (WCSPBRK); |
512 | |
513 | |
514 | /*----------------------------------------------------------------------*/ |
515 | /* WCSRTOMBS: size_t wcsrtombs (char *s, const wchar_t **ws, size_t n, */ |
516 | /* mbstate_t *ps) */ |
517 | /*----------------------------------------------------------------------*/ |
518 | |
519 | typedef struct |
520 | { |
521 | int s_flg; |
522 | int w_flg; /* don't need this */ |
523 | wchar_t ws[WCSSIZE]; |
524 | size_t n; |
525 | int t_flg; |
526 | int t_init; |
527 | } |
528 | TIN_WCSRTOMBS_REC; |
529 | |
530 | typedef struct |
531 | { |
532 | TMD_ERRET (size_t); |
533 | char s[MBSSIZE]; |
534 | } |
535 | TEX_WCSRTOMBS_REC; |
536 | |
537 | TMD_RECHEAD (WCSRTOMBS); |
538 | |
539 | |
540 | /*----------------------------------------------------------------------*/ |
541 | /* WCSSPN: size_t wcsspn (const wchar_t *ws1, const wchar_t *ws2) */ |
542 | /*----------------------------------------------------------------------*/ |
543 | |
544 | typedef TIN_WCSCSPN_REC TIN_WCSSPN_REC; |
545 | typedef TEX_WCSCSPN_REC TEX_WCSSPN_REC; |
546 | TMD_RECHEAD (WCSSPN); |
547 | |
548 | |
549 | /*----------------------------------------------------------------------*/ |
550 | /* WCSSTR: wchar_t *wcsstr (const wchar_t *ws1, const wchar_t *ws2) */ |
551 | /*----------------------------------------------------------------------*/ |
552 | |
553 | typedef TIN_WCSCSPN_REC TIN_WCSSTR_REC; |
554 | typedef TEX_ERRET_REC (wchar_t *) TEX_WCSSTR_REC; |
555 | TMD_RECHEAD (WCSSTR); |
556 | |
557 | |
558 | /*----------------------------------------------------------------------*/ |
559 | /* WCSTOD: double wcstod (const wchar_t *np, wchar_t **endp) */ |
560 | /*----------------------------------------------------------------------*/ |
561 | |
562 | typedef struct |
563 | { |
564 | wchar_t np[WCSSIZE]; |
565 | } |
566 | TIN_WCSTOD_REC; |
567 | |
568 | typedef struct |
569 | { |
570 | TMD_ERRET (double); |
571 | double val; |
572 | wchar_t fwc; |
573 | } |
574 | TEX_WCSTOD_REC; |
575 | |
576 | TMD_RECHEAD (WCSTOD); |
577 | |
578 | |
579 | /*----------------------------------------------------------------------*/ |
580 | /* WCSTOK: wchar_t *wcstok (wchar_t *ws, const wchar_t *dlm, */ |
581 | /* wchar_t **pt) */ |
582 | /*----------------------------------------------------------------------*/ |
583 | |
584 | typedef struct |
585 | { |
586 | struct |
587 | { |
588 | int w_flg; |
589 | wchar_t ws[WCSSIZE]; |
590 | wchar_t dt[WCSSIZE]; /* delimiter */ |
591 | } |
592 | seq[WCSTOK_SEQNUM]; |
593 | } |
594 | TIN_WCSTOK_REC; |
595 | |
596 | typedef struct |
597 | { |
598 | struct |
599 | { |
600 | TMD_ERRET (wchar_t *); |
601 | wchar_t ws[WCSSIZE]; |
602 | } |
603 | seq[WCSTOK_SEQNUM]; |
604 | } |
605 | TEX_WCSTOK_REC; |
606 | |
607 | TMD_RECHEAD (WCSTOK); |
608 | |
609 | |
610 | /*----------------------------------------------------------------------*/ |
611 | /* WCSTOMBS: size_t wcstombs (char s, const wchar_t *ws, size_t n) */ |
612 | /*----------------------------------------------------------------------*/ |
613 | |
614 | typedef struct |
615 | { |
616 | int s_flg; |
617 | int w_flg; /* currently we don't need it. */ |
618 | wchar_t ws[WCSSIZE]; |
619 | size_t n; |
620 | } |
621 | TIN_WCSTOMBS_REC; |
622 | |
623 | typedef struct |
624 | { |
625 | TMD_ERRET (size_t); |
626 | char s[MBSSIZE]; |
627 | } |
628 | TEX_WCSTOMBS_REC; |
629 | |
630 | TMD_RECHEAD (WCSTOMBS); |
631 | |
632 | |
633 | /*----------------------------------------------------------------------*/ |
634 | /* WCSWIDTH: int wcswidth (const wchar_t *ws, size_t n) */ |
635 | /*----------------------------------------------------------------------*/ |
636 | |
637 | typedef TIN_WCSNCPY_REC TIN_WCSWIDTH_REC; |
638 | typedef TEX_ERRET_REC (int) TEX_WCSWIDTH_REC; |
639 | TMD_RECHEAD (WCSWIDTH); |
640 | |
641 | |
642 | /*----------------------------------------------------------------------*/ |
643 | /* WCSXFRM: size_t wcsxfrm (wchar_t *ws1, const wchar_t *ws2, size_t n)*/ |
644 | /*----------------------------------------------------------------------*/ |
645 | |
646 | typedef struct |
647 | { |
648 | wchar_t org1[WCSSIZE]; |
649 | wchar_t org2[WCSSIZE]; |
650 | int n1, n2; |
651 | } |
652 | TIN_WCSXFRM_REC; |
653 | |
654 | typedef TEX_ERRET_REC (size_t) TEX_WCSXFRM_REC; /* only for org2[] */ |
655 | TMD_RECHEAD (WCSXFRM); |
656 | |
657 | |
658 | /*----------------------------------------------------------------------*/ |
659 | /* WCTOB: int wctob (wint_t wc) */ |
660 | /*----------------------------------------------------------------------*/ |
661 | |
662 | typedef struct |
663 | { |
664 | wint_t wc; |
665 | } |
666 | TIN_WCTOB_REC; |
667 | |
668 | typedef TEX_ERRET_REC (int) TEX_WCTOB_REC; |
669 | TMD_RECHEAD (WCTOB); |
670 | |
671 | |
672 | /*----------------------------------------------------------------------*/ |
673 | /* WCTOMB: int wctomb (char *s, wchar_t wc) */ |
674 | /*----------------------------------------------------------------------*/ |
675 | |
676 | typedef struct |
677 | { |
678 | int s_flg; |
679 | wchar_t wc; |
680 | } |
681 | TIN_WCTOMB_REC; |
682 | |
683 | typedef struct |
684 | { |
685 | TMD_ERRET (int); |
686 | char s[MBSSIZE]; |
687 | } |
688 | TEX_WCTOMB_REC; |
689 | |
690 | TMD_RECHEAD (WCTOMB); |
691 | |
692 | |
693 | /*----------------------------------------------------------------------*/ |
694 | /* WCTRANS: wctrans_t wctrans (const char *charclass) */ |
695 | /*----------------------------------------------------------------------*/ |
696 | |
697 | typedef struct |
698 | { |
699 | char class[MBSSIZE]; |
700 | } |
701 | TIN_WCTRANS_REC; |
702 | |
703 | typedef TEX_ERRET_REC (wctrans_t) TEX_WCTRANS_REC; |
704 | TMD_RECHEAD (WCTRANS); |
705 | |
706 | |
707 | /*----------------------------------------------------------------------*/ |
708 | /* WCTYPE: wctype_t wctype (const char *class) */ |
709 | /*----------------------------------------------------------------------*/ |
710 | |
711 | typedef TIN_WCTRANS_REC TIN_WCTYPE_REC; |
712 | typedef TEX_ERRET_REC (wctype_t) TEX_WCTYPE_REC; |
713 | TMD_RECHEAD (WCTYPE); |
714 | |
715 | |
716 | /*----------------------------------------------------------------------*/ |
717 | /* WCWIDTH: int wcwidth (wchar_t wc) */ |
718 | /*----------------------------------------------------------------------*/ |
719 | |
720 | typedef struct |
721 | { |
722 | wchar_t wc; |
723 | } |
724 | TIN_WCWIDTH_REC; |
725 | |
726 | typedef TEX_ERRET_REC (int) TEX_WCWIDTH_REC; |
727 | TMD_RECHEAD (WCWIDTH); |
728 | |
729 | #endif /* TST_TYPES_H */ |
730 | |