/* Chart miscellaneous C code. Copyright 2003, 2005, 2006 Kevin Ryde This file is part of Chart. Chart is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. Chart is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Chart; see the file COPYING. If not, write to the Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "config.h" #include #include #include #include #include #include #include /* for NULL */ #if HAVE_UNISTD_H #include #endif #if HAVE_ICONV #include #endif #if HAVE_MALLOC_H #include #endif /* TIOCGWINSZ is in termios.h according to linux kernel man pages */ #if HAVE_TERMIOS_H #include #endif /* TIOCGWINSZ is in sys/ioctl.h on glibc 2.3.5 */ #if HAVE_SYS_IOCTL_H #include #endif #include #include "gettext.h" #include "misc.h" /*---------------------------------------------------------------------------*/ /* fake iconv when not otherwise available */ #if ! HAVE_ICONV struct chart_iconv_t_data { char *from; /* strdup'ed */ char *to; /* strdup'ed */ }; typedef struct chart_iconv_t_data *iconv_t; #define ICONV_CONST #ifndef EILSEQ /* system without iconv probably doesn't have EILSEQ */ #define EILSEQ 12345 #endif static iconv_t iconv_open (const char *tocode, const char *fromcode) { iconv_t cd = malloc (sizeof (struct chart_iconv_t_data)); if (cd == NULL) { nomem: errno = ENOMEM; return (iconv_t) -1; } cd->from = strdup (fromcode); if (cd->from == NULL) { free (cd); goto nomem; } cd->to = strdup (tocode); if (cd->to == NULL) { free (cd->from); free (cd); goto nomem; } return cd; } static int iconv_close (iconv_t cd) { free (cd->from); free (cd->to); free (cd); return 0; } /* return non-zero if PART is a suffix of STR */ static int strsuffix (const char *part, const char *str) { size_t plen = strlen (part); size_t slen = strlen (str); return (slen >= plen && memcmp (str + slen - plen, part, plen) == 0); } static size_t iconv (iconv_t cd, char **inbuf, size_t *inleft, char **outbuf, size_t *outleft) { int c; int latin1, translit; if (inbuf == NULL) return 0; latin1 = (strcmp (cd->from, "ISO-8859-1") == 0); translit = strsuffix ("//TRANSLIT", cd->to); for (;;) { if (*inleft == 0) return 0; if (*outleft == 0) { errno = E2BIG; return (size_t) -1; } c = (int) (unsigned char) **inbuf; /* latin1 e-acute -> plain e, to support casablanca SOTA and SOTB names (that char is in an otherwise English page) */ if (latin1) { if (c == 0xE9) c = 'e'; } if (translit) { /* non-ASCII sequences translated to '?' no attempt is made to tell how many chars a non-ascii run is supposed to be, it just becomes a single '?' */ if (! isascii (c)) { while ((*inleft) > 1) { c = (int) (unsigned char) *((*inbuf)+1); /* next char */ if (isascii (c)) break; (*inbuf)++; (*inleft)--; } c = '?'; } } else { /* non-ASCII provokes EILSEQ */ if (! isascii (c)) { errno = EILSEQ; return (size_t) -1; } } **outbuf = c; (*inbuf)++; (*inleft)--; (*outbuf)++; (*outleft)--; } } #endif /* ! HAVE_ICONV */ /*---------------------------------------------------------------------------*/ /* iconv stuff */ /* return STR converted using CD if CLOSE_CD is non-zero then CD is closed when done (or error) FUNC is the originating function to report in an error */ static SCM chart_iconv (const char *func, iconv_t cd, SCM str, int close_cd) { ICONV_CONST char *in_str; char *in_buf, *out_buf, *out_ptr; size_t in_len, out_alloc, out_left; SCM out; if (! scm_is_string (str)) { if (close_cd) iconv_close (cd); scm_wrong_type_arg_msg(func, SCM_ARGn, str, "STRINGP"); } in_buf = scm_to_locale_stringn (str, &in_len); in_str = in_buf; out_alloc = 6 * in_len; out_buf = scm_malloc (out_alloc); out_ptr = out_buf; out_left = out_alloc; if (iconv (cd, &in_str, &in_len, &out_ptr, &out_left) == -1) { int err = errno; free (in_buf); free (out_buf); if (close_cd) iconv_close (cd); errno = err; scm_syserror (func); } out = scm_mem2string (out_buf, out_alloc - out_left); free (in_buf); free (out_buf); if (close_cd) { if (iconv_close (cd) != 0) scm_syserror (func); } return out; } /* open an iconv_t for charset conversion FROM to TO if cannot open then throw an error, reporting FUNC as the originator */ static iconv_t chart_iconv_open (const char *func, const char *to, const char *from) { iconv_t cd = iconv_open (to, from); if (cd == (iconv_t) -1) scm_syserror (func); return cd; } SCM_DEFINE (chart_iconv_charset_available_p, "iconv-charset-available?", 1, 0, 0, (SCM charset), "Return @code{#t} if @var{charset} is known to @code{iconv}, or\n" "@code{#f} if not. The test is that @var{charset} can be\n" "converted to UTF-8.") #define FUNC_NAME s_chart_iconv_charset_available_p { char *c_charset = scm_to_locale_string (charset); #if HAVE_ICONV { iconv_t cd = iconv_open ("UTF-8", c_charset); free (c_charset); if (cd == (iconv_t) -1) return SCM_BOOL_F; if (iconv_close (cd) != 0) SCM_SYSERROR; return SCM_BOOL_T; } #else { int cmp = strcmp (c_charset, "ASCII"); free (c_charset); if (cmp == 0) return SCM_BOOL_T; else return SCM_BOOL_F; } #endif } #undef FUNC_NAME SCM_DEFINE (chart_locale_to_utf8, "locale->utf8", 1, 0, 0, (SCM str), "Return @var{str} converted from locale encoding to UTF-8. An\n" "error is thrown if @var{str} has invalid bytes.") #define FUNC_NAME s_chart_locale_to_utf8 { static iconv_t locale_to_utf8 = (iconv_t) -1; const char * codeset; codeset = nl_langinfo (CODESET); if (strcmp (codeset, "UTF-8") == 0) return str; /* locale is already utf-8, no translation */ if (locale_to_utf8 == (iconv_t) -1) locale_to_utf8 = chart_iconv_open (FUNC_NAME, "UTF-8", nl_langinfo (CODESET)); else iconv (locale_to_utf8, NULL, NULL, NULL, NULL); return chart_iconv (FUNC_NAME, locale_to_utf8, str, 0); } #undef FUNC_NAME SCM_DEFINE (chart_charset_to_utf8, "charset->utf8", 2, 0, 0, (SCM charset, SCM str), "Return @var{str} converted from the given @var{charset} to\n" "UTF-8. @var{charset} is a string, the name of a charset. An\n" "error is thrown if @var{str} has invalid bytes.") #define FUNC_NAME s_chart_charset_to_utf8 { iconv_t cd; char *c_charset = scm_to_locale_string (charset); if (strcmp (c_charset, "UTF-8") == 0) { free (c_charset); return str; /* no conversion */ } cd = iconv_open ("UTF-8", c_charset); FREE_KEEP_ERRNO (c_charset); if (cd == (iconv_t) -1) SCM_SYSERROR; return chart_iconv (FUNC_NAME, cd, str, 1); } #undef FUNC_NAME static char * scm_strcatdup (const char *s, const char *t) { char *r = scm_malloc (strlen (s) + strlen (t) + 1); strcpy (r, s); return strcat (r, t); } SCM_DEFINE (chart_utf8_to_locale, "utf8->locale", 1, 0, 0, (SCM str), "Return @var{str} converted from UTF-8 into the locale encoding.\n" "\n" "Characters which don't exist in the locale charset are\n" "transliterated by @code{iconv} where possible, or are changed\n" "to question marks \"?\" otherwise.") #define FUNC_NAME s_chart_utf8_to_locale { static iconv_t utf8_to_locale = (iconv_t) -1; static iconv_t utf8_to_wchar = (iconv_t) -1; ICONV_CONST char *in_str; char *in_buf, *out_buf, *out_ptr; size_t in_len, out_alloc, out_left; SCM out; const char *codeset; codeset = nl_langinfo (CODESET); if (strcmp (codeset, "UTF-8") == 0) return str; /* locale is already utf-8, no translation */ if (utf8_to_locale == (iconv_t) -1) { const char *codeset = nl_langinfo (CODESET); char *locale_translit = scm_strcatdup (codeset, "//TRANSLIT"); utf8_to_locale = iconv_open (locale_translit, "UTF-8"); free (locale_translit); if (utf8_to_locale == (iconv_t) -1) utf8_to_locale = chart_iconv_open (FUNC_NAME, codeset, "UTF-8"); } else iconv (utf8_to_locale, NULL, NULL, NULL, NULL); in_buf = scm_to_locale_stringn (str, &in_len); in_str = in_buf; out_alloc = 4 * in_len; out_buf = scm_malloc (out_alloc); out_ptr = out_buf; out_left = out_alloc; if (iconv (utf8_to_locale, &in_str, &in_len, &out_ptr, &out_left) == -1) { if (errno != EILSEQ) { int old_errno; syserror: old_errno = errno; free (in_buf); free (out_buf); errno = old_errno; SCM_SYSERROR; } /* EILSEQ, input char unrepresentable in locale, show "?" */ /* create or reset wchart converter */ if (utf8_to_wchar == (iconv_t) -1) { utf8_to_wchar = iconv_open ("WCHAR_T", "UTF-8"); if (utf8_to_wchar == (iconv_t) -1) SCM_SYSERROR; } else iconv (utf8_to_wchar, NULL, NULL, NULL, NULL); for (;;) { wchar_t buf; char *bufptr = (char *) &buf; size_t buflen = sizeof(buf); size_t old_in_len = in_len; /* success if this is the last char of the input string E2BIG if there's more input check in_len has decreased before allowing E2BIG, must have converted something or we go into an infinite loop */ if (iconv (utf8_to_wchar, &in_str, &in_len, &bufptr, &buflen) == -1 && (errno != E2BIG || in_len == old_in_len)) goto syserror; *out_ptr++ = '?'; out_left--; /* convert rest of input, looping around for "_" on EILSEQ char */ if (iconv (utf8_to_locale, &in_str, &in_len, &out_ptr, &out_left) != -1) break; if (errno != EILSEQ) goto syserror; } } out = scm_mem2string (out_buf, out_alloc - out_left); free (in_buf); free (out_buf); return out; } #undef FUNC_NAME SCM_DEFINE (chart_utf8_validate, "utf8-validate", 1, 0, 0, (SCM str), "Check that @var{str} is a valid UTF-8 encoded string. Throw an\n" "error if it's not.\n" "\n" "If @code{iconv} is not available, this function does nothing.") #define FUNC_NAME s_chart_utf8_validate { #if HAVE_ICONV static iconv_t utf8_to_utf8 = (iconv_t) -1; ICONV_CONST char *in_str; char *in_buf, *out_buf, *out_ptr; size_t in_len, out_alloc, out_left; int ret, old_errno; if (utf8_to_utf8 == (iconv_t) -1) { utf8_to_utf8 = iconv_open ("UTF-8", "UTF-8"); if (utf8_to_utf8 == (iconv_t) -1) SCM_SYSERROR; } else iconv (utf8_to_utf8, NULL, NULL, NULL, NULL); in_buf = scm_to_locale_stringn (str, &in_len); in_str = in_buf; out_alloc = in_len; out_buf = scm_malloc (out_alloc); out_ptr = out_buf; out_left = out_alloc; ret = iconv (utf8_to_utf8, &in_str, &in_len, &out_ptr, &out_left); old_errno = errno; free (in_buf); free (out_buf); errno = old_errno; if (ret == -1) SCM_SYSERROR; #else SCM_VALIDATE_STRING (SCM_ARG1, str); #endif return SCM_UNSPECIFIED; } #undef FUNC_NAME /*---------------------------------------------------------------------------*/ /* locale info */ SCM_DEFINE (chart_mb_cur_max, "mb-cur-max", 0, 0, 0, (), "Return @code{MB_CUR_MAX}, the maximum number of bytes to encode\n" "a character in the current locale charset.") #define FUNC_NAME s_chart_locale_codeset { return scm_from_int (MB_CUR_MAX); } #undef FUNC_NAME SCM_DEFINE (chart_locale_codeset, "locale-codeset", 0, 0, 0, (), "Return the locale charset name (a string).") #define FUNC_NAME s_chart_locale_codeset { return scm_from_locale_string (nl_langinfo (CODESET)); } #undef FUNC_NAME SCM_DEFINE (chart_locale_d_fmt, "locale-d-fmt", 0, 0, 0, (), "Return the locale date format as a utf8 @code{strftime} format.") #define FUNC_NAME s_chart_locale_d_fmt { char *str = nl_langinfo (D_FMT); /* an empty string is not acceptable */ if (str[0] == '\0') str = "%x"; return chart_locale_to_utf8 (scm_from_locale_string (str)); } #undef FUNC_NAME SCM_DEFINE (chart_locale_decimal_point, "locale-decimal-point", 0, 0, 0, (), "Return the locale decimal point as a utf8 string.") #define FUNC_NAME s_chart_locale_decimal_point { char *str = localeconv()->decimal_point; /* an empty string is not acceptable */ if (str[0] == '\0') str = "."; return chart_locale_to_utf8 (scm_from_locale_string (str)); } #undef FUNC_NAME SCM_DEFINE (chart_locale_thousands_sep, "locale-thousands-sep", 0, 0, 0, (), "Return the locale thousands separator as a utf8 string. This\n" "is an empty string when no thousands separator should be shown.") #define FUNC_NAME s_chart_locale_thousands_sep { return chart_locale_to_utf8 (scm_from_locale_string (localeconv()->thousands_sep)); } #undef FUNC_NAME /*---------------------------------------------------------------------------*/ /* gettext made available in guile 1.6 */ #if ! HAVE_SCM_GETTEXT SCM_DEFINE (chart_gettext, "gettext", 1, 0, 0, (SCM str), "Return the translation of @var{str}.") #define FUNC_NAME s_chart_gettext { SCM_VALIDATE_STRING (SCM_ARG1, str); return scm_from_locale_string (gettext (SCM_STRING_CHARS (str))); } #undef FUNC_NAME SCM_DEFINE (chart_ngettext, "ngettext", 3, 0, 0, (SCM msg, SCM plural, SCM n), "Return the translation of @var{msg}/@var{plural} according to\n" "the integer @var{n}.") #define FUNC_NAME s_chart_ngettext { long nn; SCM_VALIDATE_STRING (SCM_ARG1, msg); SCM_VALIDATE_STRING (SCM_ARG2, plural); SCM_VALIDATE_INUM_COPY (SCM_ARG3, n, nn); return scm_from_locale_string (ngettext (SCM_STRING_CHARS (msg), SCM_STRING_CHARS (plural), nn)); } #undef FUNC_NAME SCM_DEFINE (chart_bindtextdomain, "bindtextdomain", 1, 1, 0, (SCM domain, SCM dir), "With just a @var{domain} argument, return the current directory\n" "searched for translations in that domain.\n" "\n" "With a @var{dir} argument, set the directory to search for\n" "translations in @var{domain}.") #define FUNC_NAME s_chart_bindtextdomain { const char *t; SCM_VALIDATE_STRING (SCM_ARG1, domain); if (SCM_UNBNDP (dir)) { t = bindtextdomain (SCM_STRING_CHARS (domain), NULL); return (t == NULL ? SCM_BOOL_F : scm_from_locale_string (t)); } else { SCM_VALIDATE_STRING (SCM_ARG2, dir); t = bindtextdomain (SCM_STRING_CHARS (domain), SCM_STRING_CHARS (dir)); if (t == NULL) SCM_SYSERROR; return scm_from_locale_string (t); } } #undef FUNC_NAME SCM_DEFINE (chart_bind_textdomain_codeset, "bind-textdomain-codeset", 1, 1, 0, (SCM domain, SCM codeset), "With just a @var{domain} argument, return the currrent codeset\n" "used for translations in that domain.\n" "\n" "With a @var{codeset} argument, set the codeset to use for\n" "translations in @var{domain}.") #define FUNC_NAME s_chart_bind_textdomain_codeset { const char *t; SCM_VALIDATE_STRING (SCM_ARG1, domain); if (SCM_UNBNDP (codeset)) { t = bind_textdomain_codeset (SCM_STRING_CHARS (domain), NULL); return (t == NULL ? SCM_BOOL_F : scm_from_locale_string (t)); } else { SCM_VALIDATE_STRING (SCM_ARG2, codeset); t = bind_textdomain_codeset (SCM_STRING_CHARS (domain), SCM_STRING_CHARS (codeset)); if (t == NULL) SCM_SYSERROR; return scm_from_locale_string (t); } } #undef FUNC_NAME SCM_DEFINE (chart_textdomain, "textdomain", 0, 1, 0, (SCM domain), "With no arguments, return the current default translation\n" "domain.\n" "\n" "With an argument, set the default translation domain to the\n" "string @var{domain}.") #define FUNC_NAME s_chart_textdomain { const char *t; if (SCM_UNBNDP (domain)) { t = textdomain (NULL); return (t == NULL ? SCM_BOOL_F : scm_from_locale_string (t)); } else { SCM_VALIDATE_STRING (SCM_ARG1, domain); t = textdomain (SCM_STRING_CHARS (domain)); if (t == NULL) SCM_SYSERROR; return scm_from_locale_string (t); } } #undef FUNC_NAME #endif /* HAVE_SCM_GETTEXT */ /*---------------------------------------------------------------------------*/ SCM_DEFINE (chart_output_port_width, "output-port-width", 0, 1, 0, (SCM port), "Return the number of columns of output available on @var{port},\n" "or 79 if it cannot be determined. @var{port} defaults to\n" "@code{current-output-port}.\n" "\n" "The width of a tty is obtained from @code{TIOCGWINSZ}, if that\n" "@code{ioctl} is available. For other ports only the default 79\n" "is returned.\n" "\n" "This function is slib compatible.") #define FUNC_NAME s_chart_output_port_width { if (SCM_UNBNDP (port)) port = scm_current_output_port (); SCM_VALIDATE_PORT (SCM_ARG1, port); /* A pseudo-tty under emacs has ws_col==0, give the default 79 in that case. */ #ifdef TIOCGWINSZ if (scm_is_true (scm_file_port_p (port))) { struct winsize w; if (ioctl (scm_to_int (scm_fileno (port)), TIOCGWINSZ, &w) == 0 && w.ws_col != 0) return scm_from_int (w.ws_col); } #endif return scm_from_int (79); } #undef FUNC_NAME #if ! HAVE_SCM_PRIMITIVE__EXIT SCM_DEFINE (chart_primitive__exit, "primitive-_exit", 1, 0, 0, (SCM status), "") #define FUNC_NAME s_chart_primitive__exit { _exit (SCM_UNBNDP (status) ? 0 : scm_to_int (status)); } #undef FUNC_NAME #endif SCM_DEFINE (chart_mallinfo_uordblks, "mallinfo-uordblks", 0, 0, 0, (), "") #define FUNC_NAME s_chart_output_port_width { #if HAVE_MALLINFO return scm_from_int (mallinfo().uordblks); #else return scm_from_int (0); #endif } #undef FUNC_NAME /*---------------------------------------------------------------------------*/ void chart_misc_init (void) { #ifndef SCM_MAGIC_SNARFER #include "misc.x" #endif }