/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1996, by Sun Microsystems, Inc. * All rights reserved. */ /* * ISO/IEC 9899: 1990/Add.3: 1993 (E): Wide character header file * * Copyright 1992, 1993 by Mortice Kern Systems Inc. All rights reserved. * * $Header: /rd/h/rcs/m_wchar.h 1.51 1995/09/20 19:17:54 ant Exp $ * */ #ifndef __M_M_WCHAR_H__ #define __M_M_WCHAR_H__ 1 /* * m_wchar.h: * configuration file for multi-byte vs. single byte enablement */ #include #include #include /* Fetch MB_LEN_MAX */ #ifdef M_I18N_LOCKING_SHIFT extern char *m_strsanitize (char *); #else #define m_strsanitize(str) (str) #endif /* M_I18N_LOCKING_SHIFT */ #ifdef M_I18N_MB # ifndef MB_LEN_MAX # error M_I18N_MB defined; but the local system does not support multibyte # endif /* MB_LEN_MAX */ #define MB_BEGIN if (MB_CUR_MAX > 1) { #define MB_ELSE } else { #define MB_END } #define M_MB_L(s) L##s #ifndef _WUCHAR_T #define _WUCHAR_T /* a typedef to allow single byte distinction between char and uchar * in MKS environment */ typedef wchar_t wuchar_t; #endif /*_WUCHAR_T*/ extern wint_t m_escapewc(wchar_t **); extern int m_fputmbs(FILE* fp, char *mbs, int wid, int prec, int ljust); extern int m_fgetws (wchar_t *, size_t, FILE *); extern FILE *m_fwopen (wchar_t *, char *); extern wchar_t *m_wcsdup (const wchar_t *); extern wchar_t *m_mbstowcsdup (const char *s); extern char *m_wcstombsdup (const wchar_t *w); extern char *m_mbschr (const char *, int); extern char *m_mbsrchr (const char *, int); extern char *m_mbspbrk (const char *, const char *); extern wchar_t *m_wcsset (wchar_t *, wchar_t, size_t); extern int iswabsname (wchar_t *); #define m_smalls(s) (s) #define wctomb_init() wctomb(NULL,0) #else /* !M_I18N_MB */ /* include here, * We must include the multibyte function prototypes (in ) before * redefining the prototype function names below. * * AND including DOES NOT cause a problem with wchar_t. * * ANSI says that the typedef of wchar_t should be defined in stdlib.h. * Thus, the prototypes in stdlib.h are declared using stdlib's definition * of wchar_t. */ #include /* DO NOT MOVE THIS include - THIS must be first */ #undef m_escapewc #undef m_fgetws #undef m_fwopen #undef m_wcsdup #undef m_mbstowcsdup #undef m_wcstombsdup #undef m_mbschr #undef m_mbsrchr #undef m_mbspbrk #undef m_wcsset #undef iswabsname #undef m_fputmbs #define m_escapewc m_escapec #define m_fgetws m_fgets #define m_fwopen fopen #define m_wcsdup strdup #define m_mbstowcsdup strdup #define m_wcstombsdup strdup #define m_mbschr strchr #define m_mbsrchr strrchr #define m_mbspbrk strpbrk #define m_wcsset memset #define iswabsname(s) isabsname(s) #define m_fputmbs(fp, str, wid, prec, ljust) \ fprintf((fp), (ljust) ? "%-*.*s" : "%*.*s", wid, prec, str) #define MB_BEGIN if (0) { #define MB_ELSE } else { #define MB_END } #define M_MB_L(s) s /* * Types and Macros */ #undef WEOF #undef wint_t #undef wuchar_t #undef wchar_t #define WEOF EOF #define wchar_t char /* ensures we never use the wchar_t typedef */ #define wint_t int /* type as large as either wchar_t or WEOF */ #define wuchar_t unsigned char /* Force override of typedef */ /* * Must define _WCHAR_T, _WINT_T and _WUCHAR_T to avoid typedefs collisions * in other system headers. * Most systems do something like this: * #ifndef _WCHAR_T * #define _WCHAR_T * typedef unsigned short wchar_t * #endif * in their system headers to avoid multiple declarations of wchar_t */ #undef _WCHAR_T #undef _WINT_T #undef _WUCHAR_T #define _WCHAR_T #define _WINT_T #define _WUCHAR_T /* * Input/Output */ #undef fgetwc #undef getwc #undef getwchar #undef fputwc #undef putwc #undef putwchar #undef fputws #undef puts #undef fgetwx #undef getws #undef ungetwc #undef fwprintf #undef fwscanf #undef wprintf #undef wscanf #undef swscanf #undef vfwprintf #undef vwprintf #undef vswprintf #define fgetwc fgetc #define getwc getc #define getwchar getchar #define fputwc fputc #define putwc putc #define putwchar putchar #define fputws fputs #define fgetws fgets #define getws gets #define ungetwc ungetc #define fwprintf fprintf #define fwscanf fscanf #define wprintf printf #define wscanf scanf #define swscanf sscanf #define vfwprintf vfprintf #define vwprintf vprintf /* NOTE: * In single byte mode, both swprintf() and vswprintf() are converted to * similar, but NOT IDENTICAL, functions that have slightly different * semantics. * The 2nd argument to both these routines (e.g the size_t arg) * is not used in the singlebyte environment since sprintf() and vsprintf() * do not support this argument. * One has to be careful when using this routine to not depend on * the enforcement/safety of this 2nd argument. * * swprintf() is converted to m_swprintf(), which is a C function * (because it can use a variable number of args), * which is implemented as a call to vsprint() * vswprintf() is converted to vsprintf() * */ #define swprintf m_swprintf #define vswprintf(w,n,f,v) vsprintf((char*)w,(const char*)f, v) #ifndef m_smalls extern wchar_t *m_smalls (const wchar_t *); #endif /*m_smalls*/ /* * General Utilities */ #undef wcstod #undef wcstol #undef wcstoul #undef wctomb_init #define wcstod strtod #define wcstol strtol #define wcstoul strtoul #define wctomb_init() (0) /* No state dependency for nonmultibyte. */ /* * Wide string handling */ #undef wcscpy #undef wcsncpy #undef wcscat #undef wcsncat #undef wcscoll #undef wcscmp #undef wcsncmp #undef wcsxfrm #undef wcschr #undef wcscspn #undef wcspbrk #undef wcsrchr #undef wcsspn #undef wcsstr #undef wcstok #undef wcslen #undef wcswidth #undef wcwidth #define wcscpy strcpy #define wcsncpy strncpy #define wcscat strcat #define wcsncat strncat #define wcscoll strcoll #define wcscmp strcmp #define wcsncmp strncmp #define wcsxfrm strxfrm #define wcschr strchr #define wcscspn strcspn #define wcspbrk strpbrk #define wcsrchr strrchr #define wcsspn strspn #define wcsstr strstr #define wcstok(x, y, z) strtok(x, y) #define wcslen strlen #define wcswidth(s1, n) strlen(s1) /* Need a strnlen? */ #define wcwidth(c) 1 /* * Date and time */ #undef wcsftime #define wcsftime strftime /* * Extended Multibyte functions */ #undef wctob #undef sisinit #define wctob(c) ((int) (wint_t) (c)) #define sisinit(p) (1) /* Always in initial state */ /* * Define prototypes for singlebyte equivalents of multibyte functions. * We have to use macros to map them to other function names, so that * they do not conflict with the prototypes from that may have * used a different definition of wchar_t. The restartable functions are * mapped to their non-restartable counterparts, since there is no state * information to be preserved. */ #undef mblen #undef mbrlen #undef mbtowc #undef mbrtowc #undef wctomb #undef wcrtomb #undef mbstowcs #undef mbsrtowcs #undef wcstombs #undef wcsrtombs #define mblen(s, n) m_sb_mblen(s, n) #define mbrlen(s, n, ps) m_sb_mblen(s, n) #define mbtowc(pwc, s, n) m_sb_mbtowc(pwc, s, n) #define mbrtowc(pwc, s, n, ps) m_sb_mbtowc(pwc, s, n) #define wctomb(s, wc) m_sb_wctomb(s, wc) #define wcrtomb(s, wc, ps) m_sb_wctomb(s, wc) #define mbstowcs(pwcs, s, n) m_sb_mbstowcs(pwcs, s, n) #define mbsrtowcs(pwcs, s, n, ps) m_sb_mbstowcs(pwcs, s, n) #define wcstombs(s, pwcs, n) m_sb_wcstombs(s, pwcs, n) #define wcsrtombs(s, pwcs, n, ps) m_sb_wcstombs(s, pwcs, n) extern int m_sb_mblen(const char *s, size_t n); extern int m_sb_mbtowc(wchar_t *pwc, const char *s, size_t n); extern int m_sb_wctomb(char *s, wchar_t wc); extern size_t m_sb_mbstowcs(wchar_t *pwcs, const char *s, size_t n); extern size_t m_sb_wcstombs(char *s, const wchar_t *pwcs, size_t n); /* * convert definitions from */ #undef iswalnum #undef iswalpha #undef iswcntrl #undef iswdigit #undef iswgraph #undef iswlower #undef iswprint #undef iswpunct #undef iswspace #undef iswupper #undef iswxdigit #undef iswblank #undef towlower #undef towupper #define iswalnum(c) isalnum(c) #define iswalpha(c) isalpha(c) #define iswcntrl(c) iscntrl(c) #define iswdigit(c) isdigit(c) #define iswgraph(c) isgraph(c) #define iswlower(c) islower(c) #define iswprint(c) isprint(c) #define iswpunct(c) ispunct(c) #define iswspace(c) isspace(c) #define iswupper(c) isupper(c) #define iswxdigit(c) isxdigit(c) #define iswblank(c) isblank(c) #define towlower(c) tolower(c) #define towupper(c) toupper(c) /* * Note: MKS libc/gen/iswctype.c contains the system independent version * of wctype() and iswctype(). * * In single byte mode, we can't use the names wctype() and iswctype(). * These may have been defined in the system's headers (e.g ) * using the system definition of wint_t and wctype_t. * BUT we have just changed the meaning of wint_t above, to an 'int' * which may not be the same size as wint_t. * Thus, we rename them so that we don't get any prototype conflicts */ #undef wctype #undef iswctype #define wctype _m_wctype #define iswctype _m_iswctype extern wctype_t wctype(const char *property); extern int iswctype(wint_t wc, wctype_t desc); /* * .2 Functions */ #include #undef fnwwmatch #undef fnwnmatch #define fnwwmatch fnmatch #define fnwnmatch fnmatch #include #undef regwcomp #undef regwexec #undef regwdosub #undef regwdosuba #undef regwmatch_t #define regwcomp regcomp #define regwexec regexec #define regwdosub regdosub #define regwdosuba regdosuba #define regwmatch_t regmatch_t #endif /* M_I18N_MB */ /* * prototypes that are common to both SingleByte and MultiByte */ extern int m_mbswidth (const char *, size_t); extern int m_mbsrwidth (const char *, size_t, mbstate_t *); #endif /*__M_M_WCHAR_H__*/