URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/tags/gnu-src/newlib-1.18.0/newlib-1.18.0-or32-1.0rc2/newlib/libc/sys/linux/iconv
- from Rev 207 to Rev 520
- ↔ Reverse comparison
Rev 207 → Rev 520
/iconv_open.c
0,0 → 1,65
/* Get descriptor for character set conversion. |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. |
This file is part of the GNU C Library. |
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997. |
|
The GNU C Library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Lesser General Public |
License as published by the Free Software Foundation; either |
version 2.1 of the License, or (at your option) any later version. |
|
The GNU C Library 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 |
Lesser General Public License for more details. |
|
You should have received a copy of the GNU Lesser General Public |
License along with the GNU C Library; if not, write to the Free |
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
02111-1307 USA. */ |
|
#include <errno.h> |
#include <iconv.h> |
#include <stdlib.h> |
#include <string.h> |
|
#include <gconv_int.h> |
#include "gconv_charset.h" |
|
|
iconv_t |
iconv_open (const char *tocode, const char *fromcode) |
{ |
char *tocode_conv; |
char *fromcode_conv; |
size_t tocode_len; |
size_t fromcode_len; |
__gconv_t cd; |
int res; |
|
/* Normalize the name. We remove all characters beside alpha-numeric, |
'_', '-', '/', and '.'. */ |
tocode_len = strlen (tocode); |
tocode_conv = alloca (tocode_len + 3); |
strip (tocode_conv, tocode); |
tocode = tocode_conv[2] == '\0' ? upstr (tocode_conv, tocode) : tocode_conv; |
|
fromcode_len = strlen (fromcode); |
fromcode_conv = alloca (fromcode_len + 3); |
strip (fromcode_conv, fromcode); |
fromcode = (fromcode_conv[2] == '\0' |
? upstr (fromcode_conv, fromcode) : fromcode_conv); |
|
res = __gconv_open (tocode, fromcode, &cd, 0); |
|
if (__builtin_expect (res, __GCONV_OK) != __GCONV_OK) |
{ |
/* We must set the error number according to the specs. */ |
if (res == __GCONV_NOCONV || res == __GCONV_NODB) |
__set_errno (EINVAL); |
|
return (iconv_t) -1; |
} |
|
return (iconv_t) cd; |
} |
iconv_open.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_cache.c
===================================================================
--- gconv_cache.c (nonexistent)
+++ gconv_cache.c (revision 520)
@@ -0,0 +1,459 @@
+/* Cache handling for iconv modules.
+ Copyright (C) 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 2001.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+
+#include "hash-string.h"
+
+void *__gconv_cache;
+static size_t cache_size;
+static int cache_malloced;
+
+
+int
+internal_function
+__gconv_load_cache (void)
+{
+ int fd;
+ struct stat64 st;
+ struct gconvcache_header *header;
+
+ /* We cannot use the cache if the GCONV_PATH environment variable is
+ set. */
+ __gconv_path_envvar = getenv ("GCONV_PATH");
+ if (__gconv_path_envvar != NULL)
+ return -1;
+
+ /* See whether the cache file exists. */
+ fd = open (GCONV_MODULES_CACHE, O_RDONLY);
+ if (__builtin_expect (fd, 0) == -1)
+ /* Not available. */
+ return -1;
+
+#ifdef _POSIX_ASYNC_IO
+ /* Get information about the file. */
+ if (__builtin_expect (fstat64 (fd, &st), 0) < 0
+ /* We do not have to start looking at the file if it cannot contain
+ at least the cache header. */
+ || st.st_size < sizeof (struct gconvcache_header))
+ {
+#endif
+ close_and_exit:
+ close (fd);
+ return -1;
+#ifdef _POSIX_ASYNC_IO
+ }
+#endif
+
+ /* Make the file content available. */
+ cache_size = st.st_size;
+#ifdef _POSIX_MAPPED_FILES
+ __gconv_cache = mmap (NULL, cache_size, PROT_READ, MAP_SHARED, fd, 0);
+ if (__builtin_expect (__gconv_cache == MAP_FAILED, 0))
+#endif
+ {
+ size_t already_read;
+
+ __gconv_cache = malloc (cache_size);
+ if (__gconv_cache == NULL)
+ goto close_and_exit;
+
+ already_read = 0;
+ do
+ {
+ ssize_t n = read (fd, (char *) __gconv_cache + already_read,
+ cache_size - already_read);
+ if (__builtin_expect (n, 0) == -1)
+ {
+ free (__gconv_cache);
+ __gconv_cache = NULL;
+ goto close_and_exit;
+ }
+
+ already_read += n;
+ }
+ while (already_read < cache_size);
+
+ cache_malloced = 1;
+ }
+
+ /* We don't need the file descriptor anymore. */
+ close (fd);
+
+ /* Check the consistency. */
+ header = (struct gconvcache_header *) __gconv_cache;
+ if (__builtin_expect (header->magic, GCONVCACHE_MAGIC) != GCONVCACHE_MAGIC
+ || __builtin_expect (header->string_offset >= cache_size, 0)
+ || __builtin_expect (header->hash_offset >= cache_size, 0)
+ || __builtin_expect (header->hash_size == 0, 0)
+ || __builtin_expect ((header->hash_offset
+ + header->hash_size * sizeof (struct hash_entry))
+ > cache_size, 0)
+ || __builtin_expect (header->module_offset >= cache_size, 0)
+ || __builtin_expect (header->otherconv_offset > cache_size, 0))
+ {
+ if (cache_malloced)
+ {
+ free (__gconv_cache);
+ cache_malloced = 0;
+ }
+#ifdef _POSIX_MAPPED_FILES
+ else
+ __munmap (__gconv_cache, cache_size);
+#endif
+ __gconv_cache = NULL;
+
+ return -1;
+ }
+
+ /* That worked. */
+ return 0;
+}
+
+
+static int
+internal_function
+find_module_idx (const char *str, size_t *idxp)
+{
+ unsigned int idx;
+ unsigned int hval;
+ unsigned int hval2;
+ const struct gconvcache_header *header;
+ const char *strtab;
+ const struct hash_entry *hashtab;
+ unsigned int limit;
+
+ header = (const struct gconvcache_header *) __gconv_cache;
+ strtab = (char *) __gconv_cache + header->string_offset;
+ hashtab = (struct hash_entry *) ((char *) __gconv_cache
+ + header->hash_offset);
+
+ hval = hash_string (str);
+ idx = hval % header->hash_size;
+ hval2 = 1 + hval % (header->hash_size - 2);
+
+ limit = cache_size - header->string_offset;
+ while (hashtab[idx].string_offset != 0)
+ if (hashtab[idx].string_offset < limit
+ && strcmp (str, strtab + hashtab[idx].string_offset) == 0)
+ {
+ *idxp = hashtab[idx].module_idx;
+ return 0;
+ }
+ else
+ if ((idx += hval2) >= header->hash_size)
+ idx -= header->hash_size;
+
+ /* Nothing found. */
+ return -1;
+}
+
+
+#ifndef STATIC_GCONV
+static int
+internal_function
+find_module (const char *directory, const char *filename,
+ struct __gconv_step *result)
+{
+ size_t dirlen = strlen (directory);
+ size_t fnamelen = strlen (filename) + 1;
+ char fullname[dirlen + fnamelen];
+ int status = __GCONV_NOCONV;
+ char *tmp;
+
+ tmp = mempcpy (fullname, directory, dirlen);
+ tmp += dirlen;
+ memcpy (tmp, filename, fnamelen);
+
+ result->__shlib_handle = __gconv_find_shlib (fullname);
+ if (result->__shlib_handle != NULL)
+ {
+ status = __GCONV_OK;
+
+ result->__modname = NULL;
+ result->__fct = result->__shlib_handle->fct;
+ result->__init_fct = result->__shlib_handle->init_fct;
+ result->__end_fct = result->__shlib_handle->end_fct;
+
+ result->__data = NULL;
+ if (result->__init_fct != NULL)
+ status = result->__init_fct (result);
+ }
+
+ return status;
+}
+#endif
+
+
+int
+internal_function
+__gconv_compare_alias_cache (const char *name1, const char *name2, int *result)
+{
+ size_t name1_idx;
+ size_t name2_idx;
+
+ if (__gconv_cache == NULL)
+ return -1;
+
+ if (find_module_idx (name1, &name1_idx) != 0
+ || find_module_idx (name2, &name2_idx) != 0)
+ *result = strcmp (name1, name2);
+ else
+ *result = (int) (name1_idx - name2_idx);
+
+ return 0;
+}
+
+
+int
+internal_function
+__gconv_lookup_cache (const char *toset, const char *fromset,
+ struct __gconv_step **handle, size_t *nsteps, int flags)
+{
+ const struct gconvcache_header *header;
+ const char *strtab;
+ size_t fromidx;
+ size_t toidx;
+ const struct module_entry *modtab;
+ const struct module_entry *from_module;
+ const struct module_entry *to_module;
+ struct __gconv_step *result;
+
+ if (__gconv_cache == NULL)
+ /* We have no cache available. */
+ return __GCONV_NODB;
+
+ header = (const struct gconvcache_header *) __gconv_cache;
+ strtab = (char *) __gconv_cache + header->string_offset;
+ modtab = (const struct module_entry *) ((char *) __gconv_cache
+ + header->module_offset);
+
+ if (find_module_idx (fromset, &fromidx) != 0
+ || (header->module_offset + (fromidx + 1) * sizeof (struct module_entry)
+ > cache_size))
+ return __GCONV_NOCONV;
+ from_module = &modtab[fromidx];
+
+ if (find_module_idx (toset, &toidx) != 0
+ || (header->module_offset + (toidx + 1) * sizeof (struct module_entry)
+ > cache_size))
+ return __GCONV_NOCONV;
+ to_module = &modtab[toidx];
+
+ /* Avoid copy-only transformations if the user requests. */
+ if (__builtin_expect (flags & GCONV_AVOID_NOCONV, 0) && fromidx == toidx)
+ return __GCONV_NOCONV;
+
+ /* If there are special conversions available examine them first. */
+ if (fromidx != 0 && toidx != 0
+ && __builtin_expect (from_module->extra_offset, 0) != 0)
+ {
+ /* Search through the list to see whether there is a module
+ matching the destination character set. */
+ const struct extra_entry *extra;
+
+ /* Note the -1. This is due to the offset added in iconvconfig.
+ See there for more explanations. */
+ extra = (const struct extra_entry *) ((char *) __gconv_cache
+ + header->otherconv_offset
+ + from_module->extra_offset - 1);
+ while (extra->module_cnt != 0
+ && extra->module[extra->module_cnt - 1].outname_offset != toidx)
+ extra = (const struct extra_entry *) ((char *) extra
+ + sizeof (struct extra_entry)
+ + (extra->module_cnt
+ * sizeof (struct extra_entry_module)));
+
+ if (extra->module_cnt != 0)
+ {
+ /* Use the extra module. First determine how many steps. */
+ char *fromname;
+ int idx;
+
+ *nsteps = extra->module_cnt;
+ *handle = result =
+ (struct __gconv_step *) malloc (extra->module_cnt
+ * sizeof (struct __gconv_step));
+ if (result == NULL)
+ return __GCONV_NOMEM;
+
+ fromname = (char *) strtab + from_module->canonname_offset;
+ idx = 0;
+ do
+ {
+ result[idx].__from_name = fromname;
+ fromname = result[idx].__to_name =
+ (char *) strtab + modtab[extra->module[idx].outname_offset].canonname_offset;
+
+ result[idx].__counter = 1;
+ result[idx].__data = NULL;
+
+#ifndef STATIC_GCONV
+ if (strtab[extra->module[idx].dir_offset] != '\0')
+ {
+ /* Load the module, return handle for it. */
+ int res;
+
+ res = find_module (strtab + extra->module[idx].dir_offset,
+ strtab + extra->module[idx].name_offset,
+ &result[idx]);
+ if (__builtin_expect (res, __GCONV_OK) != __GCONV_OK)
+ {
+ /* Something went wrong. */
+ free (result);
+ goto try_internal;
+ }
+ }
+ else
+#endif
+ /* It's a builtin transformation. */
+ __gconv_get_builtin_trans (strtab
+ + extra->module[idx].name_offset,
+ &result[idx]);
+
+ }
+ while (++idx < extra->module_cnt);
+
+ return __GCONV_OK;
+ }
+ }
+
+ try_internal:
+ /* See whether we can convert via the INTERNAL charset. */
+ if ((fromidx != 0 && __builtin_expect (from_module->fromname_offset, 1) == 0)
+ || (toidx != 0 && __builtin_expect (to_module->toname_offset, 1) == 0)
+ || (fromidx == 0 && toidx == 0))
+ /* Not possible. Nothing we can do. */
+ return __GCONV_NOCONV;
+
+ /* We will use up to two modules. Always allocate room for two. */
+ result = (struct __gconv_step *) malloc (2 * sizeof (struct __gconv_step));
+ if (result == NULL)
+ return __GCONV_NOMEM;
+
+ *handle = result;
+ *nsteps = 0;
+
+ /* Generate data structure for conversion to INTERNAL. */
+ if (fromidx != 0)
+ {
+ result[0].__from_name = (char *) strtab + from_module->canonname_offset;
+ result[0].__to_name = (char *) "INTERNAL";
+
+ result[0].__counter = 1;
+ result[0].__data = NULL;
+
+#ifndef STATIC_GCONV
+ if (strtab[from_module->todir_offset] != '\0')
+ {
+ /* Load the module, return handle for it. */
+ int res = find_module (strtab + from_module->todir_offset,
+ strtab + from_module->toname_offset,
+ &result[0]);
+ if (__builtin_expect (res, __GCONV_OK) != __GCONV_OK)
+ {
+ /* Something went wrong. */
+ free (result);
+ return res;
+ }
+ }
+ else
+#endif
+ /* It's a builtin transformation. */
+ __gconv_get_builtin_trans (strtab + from_module->toname_offset,
+ &result[0]);
+
+ ++*nsteps;
+ }
+
+ /* Generate data structure for conversion from INTERNAL. */
+ if (toidx != 0)
+ {
+ int idx = *nsteps;
+
+ result[idx].__from_name = (char *) "INTERNAL";
+ result[idx].__to_name = (char *) strtab + to_module->canonname_offset;
+
+ result[idx].__counter = 1;
+ result[idx].__data = NULL;
+
+#ifndef STATIC_GCONV
+ if (strtab[to_module->fromdir_offset] != '\0')
+ {
+ /* Load the module, return handle for it. */
+ int res = find_module (strtab + to_module->fromdir_offset,
+ strtab + to_module->fromname_offset,
+ &result[idx]);
+ if (__builtin_expect (res, __GCONV_OK) != __GCONV_OK)
+ {
+ /* Something went wrong. */
+ if (idx != 0)
+ __gconv_release_step (&result[0]);
+ free (result);
+ return res;
+ }
+ }
+ else
+#endif
+ /* It's a builtin transformation. */
+ __gconv_get_builtin_trans (strtab + to_module->fromname_offset,
+ &result[idx]);
+
+ ++*nsteps;
+ }
+
+ return __GCONV_OK;
+}
+
+
+/* Free memory allocated for the transformation record. */
+void
+internal_function
+__gconv_release_cache (struct __gconv_step *steps, size_t nsteps)
+{
+ if (__gconv_cache != NULL)
+ /* The only thing we have to deallocate is the record with the
+ steps. */
+ free (steps);
+}
+
+
+/* Free all resources if necessary. */
+static void __attribute__ ((unused))
+free_mem (void)
+{
+ if (cache_malloced)
+ free (__gconv_cache);
+#ifdef _POSIX_MAPPED_FILES
+ else
+ __munmap (__gconv_cache, cache_size);
+#endif
+}
+
+text_set_element (__libc_subfreeres, free_mem);
gconv_cache.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: loadinfo.h
===================================================================
--- loadinfo.h (nonexistent)
+++ loadinfo.h (revision 520)
@@ -0,0 +1,100 @@
+/* Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1996.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#ifndef _LOADINFO_H
+#define _LOADINFO_H 1
+
+#ifndef PARAMS
+# if __STDC__
+# define PARAMS(args) args
+# else
+# define PARAMS(args) ()
+# endif
+#endif
+
+#ifndef internal_function
+# define internal_function
+#endif
+
+/* Tell the compiler when a conditional or integer expression is
+ almost always true or almost always false. */
+#ifndef HAVE_BUILTIN_EXPECT
+# define __builtin_expect(expr, val) (expr)
+#endif
+
+/* Encoding of locale name parts. */
+#define CEN_REVISION 1
+#define CEN_SPONSOR 2
+#define CEN_SPECIAL 4
+#define XPG_NORM_CODESET 8
+#define XPG_CODESET 16
+#define TERRITORY 32
+#define CEN_AUDIENCE 64
+#define XPG_MODIFIER 128
+
+#define CEN_SPECIFIC (CEN_REVISION|CEN_SPONSOR|CEN_SPECIAL|CEN_AUDIENCE)
+#define XPG_SPECIFIC (XPG_CODESET|XPG_NORM_CODESET|XPG_MODIFIER)
+
+
+struct loaded_l10nfile
+{
+ const char *filename;
+ int decided;
+
+ const void *data;
+
+ struct loaded_l10nfile *next;
+ struct loaded_l10nfile *successor[1];
+};
+
+
+/* Normalize codeset name. There is no standard for the codeset
+ names. Normalization allows the user to use any of the common
+ names. The return value is dynamically allocated and has to be
+ freed by the caller. */
+extern const char *_nl_normalize_codeset PARAMS ((const char *codeset,
+ size_t name_len));
+
+extern struct loaded_l10nfile *
+_nl_make_l10nflist PARAMS ((struct loaded_l10nfile **l10nfile_list,
+ const char *dirlist, size_t dirlist_len, int mask,
+ const char *language, const char *territory,
+ const char *codeset,
+ const char *normalized_codeset,
+ const char *modifier, const char *special,
+ const char *sponsor, const char *revision,
+ const char *filename, int do_allocate));
+
+
+extern const char *_nl_expand_alias PARAMS ((const char *name));
+
+/* normalized_codeset is dynamically allocated and has to be freed by
+ the caller. */
+extern int _nl_explode_name PARAMS ((char *name, const char **language,
+ const char **modifier,
+ const char **territory,
+ const char **codeset,
+ const char **normalized_codeset,
+ const char **special,
+ const char **sponsor,
+ const char **revision));
+
+extern char *_nl_find_language PARAMS ((const char *name));
+
+#endif /* loadinfo.h */
loadinfo.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: Makefile.in
===================================================================
--- Makefile.in (nonexistent)
+++ Makefile.in (revision 520)
@@ -0,0 +1,595 @@
+# Makefile.in generated by automake 1.9.6 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005 Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = ..
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+DIST_COMMON = $(srcdir)/../../../../Makefile.shared \
+ $(srcdir)/Makefile.in $(srcdir)/Makefile.am
+subdir = iconv
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/../../../../libtool.m4 \
+ $(top_srcdir)/../../../../ltoptions.m4 \
+ $(top_srcdir)/../../../../ltsugar.m4 \
+ $(top_srcdir)/../../../../ltversion.m4 \
+ $(top_srcdir)/../../../../lt~obsolete.m4 \
+ $(top_srcdir)/../../../acinclude.m4 \
+ $(top_srcdir)/../../../confsubdir.m4 \
+ $(top_srcdir)/configure.in
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/../../../../mkinstalldirs
+CONFIG_CLEAN_FILES =
+LIBRARIES = $(noinst_LIBRARIES)
+ARFLAGS = cru
+lib_a_AR = $(AR) $(ARFLAGS)
+lib_a_LIBADD =
+am__objects_1 = lib_a-iconv_open.$(OBJEXT) lib_a-iconv.$(OBJEXT) \
+ lib_a-iconv_close.$(OBJEXT) lib_a-gconv_open.$(OBJEXT) \
+ lib_a-gconv.$(OBJEXT) lib_a-gconv_close.$(OBJEXT) \
+ lib_a-gconv_db.$(OBJEXT) lib_a-gconv_dl.$(OBJEXT) \
+ lib_a-gconv_conf.$(OBJEXT) lib_a-gconv_builtin.$(OBJEXT) \
+ lib_a-gconv_simple.$(OBJEXT) lib_a-gconv_trans.$(OBJEXT) \
+ lib_a-gconv_cache.$(OBJEXT)
+@USE_LIBTOOL_FALSE@am_lib_a_OBJECTS = $(am__objects_1)
+lib_a_OBJECTS = $(am_lib_a_OBJECTS)
+LTLIBRARIES = $(noinst_LTLIBRARIES)
+libiconv_la_LIBADD =
+am__objects_2 = libiconv_la-iconv_open.lo libiconv_la-iconv.lo \
+ libiconv_la-iconv_close.lo libiconv_la-gconv_open.lo \
+ libiconv_la-gconv.lo libiconv_la-gconv_close.lo \
+ libiconv_la-gconv_db.lo libiconv_la-gconv_dl.lo \
+ libiconv_la-gconv_conf.lo libiconv_la-gconv_builtin.lo \
+ libiconv_la-gconv_simple.lo libiconv_la-gconv_trans.lo \
+ libiconv_la-gconv_cache.lo
+@USE_LIBTOOL_TRUE@am_libiconv_la_OBJECTS = $(am__objects_2)
+libiconv_la_OBJECTS = $(am_libiconv_la_OBJECTS)
+@USE_LIBTOOL_TRUE@am_libiconv_la_rpath =
+DEFAULT_INCLUDES = -I. -I$(srcdir)
+depcomp =
+am__depfiles_maybe =
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) \
+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+ $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --tag=CC --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+ $(AM_LDFLAGS) $(LDFLAGS) -o $@
+SOURCES = $(lib_a_SOURCES) $(libiconv_la_SOURCES)
+DATA = $(noinst_DATA)
+ETAGS = etags
+CTAGS = ctags
+ACLOCAL = @ACLOCAL@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCAS = @CCAS@
+CCASFLAGS = @CCASFLAGS@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ELIX_LEVEL_0_FALSE = @ELIX_LEVEL_0_FALSE@
+ELIX_LEVEL_0_TRUE = @ELIX_LEVEL_0_TRUE@
+ELIX_LEVEL_1_FALSE = @ELIX_LEVEL_1_FALSE@
+ELIX_LEVEL_1_TRUE = @ELIX_LEVEL_1_TRUE@
+ELIX_LEVEL_2_FALSE = @ELIX_LEVEL_2_FALSE@
+ELIX_LEVEL_2_TRUE = @ELIX_LEVEL_2_TRUE@
+ELIX_LEVEL_3_FALSE = @ELIX_LEVEL_3_FALSE@
+ELIX_LEVEL_3_TRUE = @ELIX_LEVEL_3_TRUE@
+ELIX_LEVEL_4_FALSE = @ELIX_LEVEL_4_FALSE@
+ELIX_LEVEL_4_TRUE = @ELIX_LEVEL_4_TRUE@
+EXEEXT = @EXEEXT@
+EXTRA_SUBDIRS = @EXTRA_SUBDIRS@
+EXTRA_SUBLIBS = @EXTRA_SUBLIBS@
+FGREP = @FGREP@
+GREP = @GREP@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LINUX_MACH_LIB = @LINUX_MACH_LIB@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
+MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
+MAKEINFO = @MAKEINFO@
+MAY_SUPPLY_SYSCALLS_FALSE = @MAY_SUPPLY_SYSCALLS_FALSE@
+MAY_SUPPLY_SYSCALLS_TRUE = @MAY_SUPPLY_SYSCALLS_TRUE@
+NEWLIB_CFLAGS = @NEWLIB_CFLAGS@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+READELF = @READELF@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+USE_LIBTOOL_FALSE = @USE_LIBTOOL_FALSE@
+USE_LIBTOOL_TRUE = @USE_LIBTOOL_TRUE@
+VERSION = @VERSION@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_AS = @ac_ct_AS@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_DLLTOOL = @ac_ct_DLLTOOL@
+ac_ct_DSYMUTIL = @ac_ct_DSYMUTIL@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+ac_ct_LIPO = @ac_ct_LIPO@
+ac_ct_NMEDIT = @ac_ct_NMEDIT@
+ac_ct_OBJDUMP = @ac_ct_OBJDUMP@
+ac_ct_OTOOL = @ac_ct_OTOOL@
+ac_ct_OTOOL64 = @ac_ct_OTOOL64@
+ac_ct_RANLIB = @ac_ct_RANLIB@
+ac_ct_READELF = @ac_ct_READELF@
+ac_ct_STRIP = @ac_ct_STRIP@
+aext = @aext@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libm_machine_dir = @libm_machine_dir@
+localstatedir = @localstatedir@
+lpfx = @lpfx@
+lt_ECHO = @lt_ECHO@
+machine_dir = @machine_dir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+newlib_basedir = @newlib_basedir@
+oext = @oext@
+oldincludedir = @oldincludedir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+subdirs = @subdirs@
+sys_dir = @sys_dir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+AUTOMAKE_OPTIONS = cygnus
+INCLUDES = -DGCONV_DIR='"$(pkglibdir)"' -DGCONV_PATH='"$(pkglibdir)"' -I$(srcdir) -I$(srcdir)/.. $(NEWLIB_CFLAGS) $(CROSS_CFLAGS) $(TARGET_CFLAGS)
+LIB_SOURCES = \
+ iconv.h gconv.h \
+ iconv_open.c iconv.c iconv_close.c \
+ gconv_open.c gconv.c gconv_close.c \
+ gconv_db.c gconv_dl.c gconv_conf.c gconv_builtin.c \
+ gconv_simple.c gconv_trans.c gconv_cache.c
+
+libiconv_la_CFLAGS =
+libiconv_la_LDFLAGS = -Xcompiler -nostdlib
+@USE_LIBTOOL_TRUE@noinst_LTLIBRARIES = libiconv.la
+@USE_LIBTOOL_TRUE@libiconv_la_SOURCES = $(LIB_SOURCES)
+@USE_LIBTOOL_FALSE@noinst_DATA =
+@USE_LIBTOOL_TRUE@noinst_DATA = objectlist.awk.in
+@USE_LIBTOOL_FALSE@noinst_LIBRARIES = lib.a
+@USE_LIBTOOL_FALSE@lib_a_SOURCES = $(LIB_SOURCES)
+@USE_LIBTOOL_FALSE@lib_a_CFLAGS = $(AM_CFLAGS)
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(srcdir)/../../../../Makefile.shared $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
+ && exit 0; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --cygnus iconv/Makefile'; \
+ cd $(top_srcdir) && \
+ $(AUTOMAKE) --cygnus iconv/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+clean-noinstLIBRARIES:
+ -test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
+lib.a: $(lib_a_OBJECTS) $(lib_a_DEPENDENCIES)
+ -rm -f lib.a
+ $(lib_a_AR) lib.a $(lib_a_OBJECTS) $(lib_a_LIBADD)
+ $(RANLIB) lib.a
+
+clean-noinstLTLIBRARIES:
+ -test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
+ @list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
+ dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+ test "$$dir" != "$$p" || dir=.; \
+ echo "rm -f \"$${dir}/so_locations\""; \
+ rm -f "$${dir}/so_locations"; \
+ done
+libiconv.la: $(libiconv_la_OBJECTS) $(libiconv_la_DEPENDENCIES)
+ $(LINK) $(am_libiconv_la_rpath) $(libiconv_la_LDFLAGS) $(libiconv_la_OBJECTS) $(libiconv_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+ -rm -f *.$(OBJEXT)
+
+distclean-compile:
+ -rm -f *.tab.c
+
+.c.o:
+ $(COMPILE) -c $<
+
+.c.obj:
+ $(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+ $(LTCOMPILE) -c -o $@ $<
+
+lib_a-iconv_open.o: iconv_open.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-iconv_open.o `test -f 'iconv_open.c' || echo '$(srcdir)/'`iconv_open.c
+
+lib_a-iconv_open.obj: iconv_open.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-iconv_open.obj `if test -f 'iconv_open.c'; then $(CYGPATH_W) 'iconv_open.c'; else $(CYGPATH_W) '$(srcdir)/iconv_open.c'; fi`
+
+lib_a-iconv.o: iconv.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-iconv.o `test -f 'iconv.c' || echo '$(srcdir)/'`iconv.c
+
+lib_a-iconv.obj: iconv.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-iconv.obj `if test -f 'iconv.c'; then $(CYGPATH_W) 'iconv.c'; else $(CYGPATH_W) '$(srcdir)/iconv.c'; fi`
+
+lib_a-iconv_close.o: iconv_close.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-iconv_close.o `test -f 'iconv_close.c' || echo '$(srcdir)/'`iconv_close.c
+
+lib_a-iconv_close.obj: iconv_close.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-iconv_close.obj `if test -f 'iconv_close.c'; then $(CYGPATH_W) 'iconv_close.c'; else $(CYGPATH_W) '$(srcdir)/iconv_close.c'; fi`
+
+lib_a-gconv_open.o: gconv_open.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_open.o `test -f 'gconv_open.c' || echo '$(srcdir)/'`gconv_open.c
+
+lib_a-gconv_open.obj: gconv_open.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_open.obj `if test -f 'gconv_open.c'; then $(CYGPATH_W) 'gconv_open.c'; else $(CYGPATH_W) '$(srcdir)/gconv_open.c'; fi`
+
+lib_a-gconv.o: gconv.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv.o `test -f 'gconv.c' || echo '$(srcdir)/'`gconv.c
+
+lib_a-gconv.obj: gconv.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv.obj `if test -f 'gconv.c'; then $(CYGPATH_W) 'gconv.c'; else $(CYGPATH_W) '$(srcdir)/gconv.c'; fi`
+
+lib_a-gconv_close.o: gconv_close.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_close.o `test -f 'gconv_close.c' || echo '$(srcdir)/'`gconv_close.c
+
+lib_a-gconv_close.obj: gconv_close.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_close.obj `if test -f 'gconv_close.c'; then $(CYGPATH_W) 'gconv_close.c'; else $(CYGPATH_W) '$(srcdir)/gconv_close.c'; fi`
+
+lib_a-gconv_db.o: gconv_db.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_db.o `test -f 'gconv_db.c' || echo '$(srcdir)/'`gconv_db.c
+
+lib_a-gconv_db.obj: gconv_db.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_db.obj `if test -f 'gconv_db.c'; then $(CYGPATH_W) 'gconv_db.c'; else $(CYGPATH_W) '$(srcdir)/gconv_db.c'; fi`
+
+lib_a-gconv_dl.o: gconv_dl.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_dl.o `test -f 'gconv_dl.c' || echo '$(srcdir)/'`gconv_dl.c
+
+lib_a-gconv_dl.obj: gconv_dl.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_dl.obj `if test -f 'gconv_dl.c'; then $(CYGPATH_W) 'gconv_dl.c'; else $(CYGPATH_W) '$(srcdir)/gconv_dl.c'; fi`
+
+lib_a-gconv_conf.o: gconv_conf.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_conf.o `test -f 'gconv_conf.c' || echo '$(srcdir)/'`gconv_conf.c
+
+lib_a-gconv_conf.obj: gconv_conf.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_conf.obj `if test -f 'gconv_conf.c'; then $(CYGPATH_W) 'gconv_conf.c'; else $(CYGPATH_W) '$(srcdir)/gconv_conf.c'; fi`
+
+lib_a-gconv_builtin.o: gconv_builtin.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_builtin.o `test -f 'gconv_builtin.c' || echo '$(srcdir)/'`gconv_builtin.c
+
+lib_a-gconv_builtin.obj: gconv_builtin.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_builtin.obj `if test -f 'gconv_builtin.c'; then $(CYGPATH_W) 'gconv_builtin.c'; else $(CYGPATH_W) '$(srcdir)/gconv_builtin.c'; fi`
+
+lib_a-gconv_simple.o: gconv_simple.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_simple.o `test -f 'gconv_simple.c' || echo '$(srcdir)/'`gconv_simple.c
+
+lib_a-gconv_simple.obj: gconv_simple.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_simple.obj `if test -f 'gconv_simple.c'; then $(CYGPATH_W) 'gconv_simple.c'; else $(CYGPATH_W) '$(srcdir)/gconv_simple.c'; fi`
+
+lib_a-gconv_trans.o: gconv_trans.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_trans.o `test -f 'gconv_trans.c' || echo '$(srcdir)/'`gconv_trans.c
+
+lib_a-gconv_trans.obj: gconv_trans.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_trans.obj `if test -f 'gconv_trans.c'; then $(CYGPATH_W) 'gconv_trans.c'; else $(CYGPATH_W) '$(srcdir)/gconv_trans.c'; fi`
+
+lib_a-gconv_cache.o: gconv_cache.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_cache.o `test -f 'gconv_cache.c' || echo '$(srcdir)/'`gconv_cache.c
+
+lib_a-gconv_cache.obj: gconv_cache.c
+ $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-gconv_cache.obj `if test -f 'gconv_cache.c'; then $(CYGPATH_W) 'gconv_cache.c'; else $(CYGPATH_W) '$(srcdir)/gconv_cache.c'; fi`
+
+libiconv_la-iconv_open.lo: iconv_open.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-iconv_open.lo `test -f 'iconv_open.c' || echo '$(srcdir)/'`iconv_open.c
+
+libiconv_la-iconv.lo: iconv.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-iconv.lo `test -f 'iconv.c' || echo '$(srcdir)/'`iconv.c
+
+libiconv_la-iconv_close.lo: iconv_close.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-iconv_close.lo `test -f 'iconv_close.c' || echo '$(srcdir)/'`iconv_close.c
+
+libiconv_la-gconv_open.lo: gconv_open.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv_open.lo `test -f 'gconv_open.c' || echo '$(srcdir)/'`gconv_open.c
+
+libiconv_la-gconv.lo: gconv.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv.lo `test -f 'gconv.c' || echo '$(srcdir)/'`gconv.c
+
+libiconv_la-gconv_close.lo: gconv_close.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv_close.lo `test -f 'gconv_close.c' || echo '$(srcdir)/'`gconv_close.c
+
+libiconv_la-gconv_db.lo: gconv_db.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv_db.lo `test -f 'gconv_db.c' || echo '$(srcdir)/'`gconv_db.c
+
+libiconv_la-gconv_dl.lo: gconv_dl.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv_dl.lo `test -f 'gconv_dl.c' || echo '$(srcdir)/'`gconv_dl.c
+
+libiconv_la-gconv_conf.lo: gconv_conf.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv_conf.lo `test -f 'gconv_conf.c' || echo '$(srcdir)/'`gconv_conf.c
+
+libiconv_la-gconv_builtin.lo: gconv_builtin.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv_builtin.lo `test -f 'gconv_builtin.c' || echo '$(srcdir)/'`gconv_builtin.c
+
+libiconv_la-gconv_simple.lo: gconv_simple.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv_simple.lo `test -f 'gconv_simple.c' || echo '$(srcdir)/'`gconv_simple.c
+
+libiconv_la-gconv_trans.lo: gconv_trans.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv_trans.lo `test -f 'gconv_trans.c' || echo '$(srcdir)/'`gconv_trans.c
+
+libiconv_la-gconv_cache.lo: gconv_cache.c
+ $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libiconv_la_CFLAGS) $(CFLAGS) -c -o libiconv_la-gconv_cache.lo `test -f 'gconv_cache.c' || echo '$(srcdir)/'`gconv_cache.c
+
+mostlyclean-libtool:
+ -rm -f *.lo
+
+clean-libtool:
+ -rm -rf .libs _libs
+
+distclean-libtool:
+ -rm -f libtool
+uninstall-info-am:
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) ' { files[$$0] = 1; } \
+ END { for (i in files) print i; }'`; \
+ mkid -fID $$unique
+tags: TAGS
+
+TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
+ $(TAGS_FILES) $(LISP)
+ tags=; \
+ here=`pwd`; \
+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) ' { files[$$0] = 1; } \
+ END { for (i in files) print i; }'`; \
+ if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
+ test -n "$$unique" || unique=$$empty_fix; \
+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+ $$tags $$unique; \
+ fi
+ctags: CTAGS
+CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
+ $(TAGS_FILES) $(LISP)
+ tags=; \
+ here=`pwd`; \
+ list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+ unique=`for i in $$list; do \
+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+ done | \
+ $(AWK) ' { files[$$0] = 1; } \
+ END { for (i in files) print i; }'`; \
+ test -z "$(CTAGS_ARGS)$$tags$$unique" \
+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+ $$tags $$unique
+
+GTAGS:
+ here=`$(am__cd) $(top_builddir) && pwd` \
+ && cd $(top_srcdir) \
+ && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+check-am:
+check: check-am
+all-am: Makefile $(LIBRARIES) $(LTLIBRARIES) $(DATA)
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ `test -z '$(STRIP)' || \
+ echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-noinstLIBRARIES \
+ clean-noinstLTLIBRARIES mostlyclean-am
+
+distclean: distclean-am
+ -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+ distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-exec-am:
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am:
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+ clean-libtool clean-noinstLIBRARIES clean-noinstLTLIBRARIES \
+ ctags distclean distclean-compile distclean-generic \
+ distclean-libtool distclean-tags dvi dvi-am html html-am info \
+ info-am install install-am install-data install-data-am \
+ install-exec install-exec-am install-info install-info-am \
+ install-man install-strip installcheck installcheck-am \
+ installdirs maintainer-clean maintainer-clean-generic \
+ mostlyclean mostlyclean-compile mostlyclean-generic \
+ mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \
+ uninstall-am uninstall-info-am
+
+objectlist.awk.in: $(noinst_LTLIBRARIES)
+ -rm -f objectlist.awk.in
+ for i in `ls *.lo` ; \
+ do \
+ echo $$i `pwd`/$$i >> objectlist.awk.in ; \
+ done
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
Index: categories.def
===================================================================
--- categories.def (nonexistent)
+++ categories.def (revision 520)
@@ -0,0 +1,344 @@
+/* Definition of all available locale categories and their items. -*- C -*-
+ Copyright (C) 1995-2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+/* These definitions are used by the locale-related files in the C library
+ and the programs `localedef' and `locale'.
+
+ The general format of the descriptions is like this:
+
+ DEFINE_CATEGORY (ID, name, ( items ), setlocale-postload)
+
+ where items itself is an array of entries in the form
+
+ { ID, name, standard, value-type, min, max }
+
+ The usage of the load, check, output functions depends on the individual
+ program code which loads this file.
+
+ The various value types for the items are `string', `stringarray', `byte'
+ `bytearray', and `word'. These cover all possible values in the current
+ locale definitions. `min' and `max' can be individually used again. */
+
+#ifndef NO_POSTLOAD
+#define NO_POSTLOAD NULL
+#endif
+
+DEFINE_CATEGORY
+(
+ LC_COLLATE, "LC_COLLATE",
+ (
+ DEFINE_ELEMENT (_NL_COLLATE_NRULES, "collate-nrules", std, word)
+ DEFINE_ELEMENT (_NL_COLLATE_RULESETS, "collate-rulesets", std, string)
+ DEFINE_ELEMENT (_NL_COLLATE_TABLEMB, "collate-tablemb", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_WEIGHTMB, "collate-weightmb", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_EXTRAMB, "collate-extramb", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_INDIRECTMB, "collate-indirectmb", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_TABLEWC, "collate-tablewc", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_WEIGHTWC, "collate-weightwc", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_EXTRAWC, "collate-extrawc", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_INDIRECTWC, "collate-indirectwc", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_SYMB_HASH_SIZEMB, "collate-symb-hash-sizemb", std, word)
+ DEFINE_ELEMENT (_NL_COLLATE_SYMB_TABLEMB, "collate-symb-tablemb", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_SYMB_EXTRAMB, "collate-symb-extramb", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_COLLSEQMB, "collate-collseqmb", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_COLLSEQWC, "collate-collseqwc", std, wstring)
+ DEFINE_ELEMENT (_NL_COLLATE_CODESET, "collate-codeset", std, string)
+ ), NO_POSTLOAD)
+
+
+/* The actual definition of ctype is meaningless here. It is hard coded in
+ the code because it has to be handled very specially. Only the names of
+ the functions and the value types are important. */
+DEFINE_CATEGORY
+(
+ LC_CTYPE, "LC_CTYPE",
+ (
+ DEFINE_ELEMENT (_NL_CTYPE_CLASS, "ctype-class", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_TOUPPER, "ctype-toupper", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_TOLOWER, "ctype-tolower", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_CLASS32, "ctype-class32", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_CLASS_NAMES, "ctype-class-names", std, stringlist, 10, 32)
+ DEFINE_ELEMENT (_NL_CTYPE_MAP_NAMES, "ctype-map-names", std, stringlist, 2, 32)
+ DEFINE_ELEMENT (_NL_CTYPE_WIDTH, "ctype-width", std, bytearray)
+ DEFINE_ELEMENT (_NL_CTYPE_MB_CUR_MAX, "ctype-mb-cur-max", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_CODESET_NAME, "charmap", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_TOUPPER32, "ctype-toupper32", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_TOLOWER32, "ctype-tolower32", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_CLASS_OFFSET, "ctype-class-offset", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_MAP_OFFSET, "ctype-map-offset", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS_MB_LEN, "ctype-indigits_mb-len", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS0_MB, "ctype-indigits0_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS1_MB, "ctype-indigits1_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS2_MB, "ctype-indigits2_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS3_MB, "ctype-indigits3_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS4_MB, "ctype-indigits4_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS5_MB, "ctype-indigits5_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS6_MB, "ctype-indigits6_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS7_MB, "ctype-indigits7_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS8_MB, "ctype-indigits8_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS9_MB, "ctype-indigits9_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS_WC_LEN, "ctype-indigits_wc-len", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS0_WC, "ctype-indigits0_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS1_WC, "ctype-indigits1_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS2_WC, "ctype-indigits2_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS3_WC, "ctype-indigits3_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS4_WC, "ctype-indigits4_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS5_WC, "ctype-indigits5_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS6_WC, "ctype-indigits6_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS7_WC, "ctype-indigits7_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS8_WC, "ctype-indigits8_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_INDIGITS9_WC, "ctype-indigits9_wc", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT0_MB, "ctype-outdigit0_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT1_MB, "ctype-outdigit1_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT2_MB, "ctype-outdigit2_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT3_MB, "ctype-outdigit3_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT4_MB, "ctype-outdigit4_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT5_MB, "ctype-outdigit5_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT6_MB, "ctype-outdigit6_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT7_MB, "ctype-outdigit7_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT8_MB, "ctype-outdigit8_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT9_MB, "ctype-outdigit9_mb", std, string)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT0_WC, "ctype-outdigit0_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT1_WC, "ctype-outdigit1_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT2_WC, "ctype-outdigit2_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT3_WC, "ctype-outdigit3_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT4_WC, "ctype-outdigit4_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT5_WC, "ctype-outdigit5_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT6_WC, "ctype-outdigit6_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT7_WC, "ctype-outdigit7_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT8_WC, "ctype-outdigit8_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_OUTDIGIT9_WC, "ctype-outdigit9_wc", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_TRANSLIT_TAB_SIZE, "ctype-translit-tab-size", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_TRANSLIT_FROM_IDX, "ctype-translit-from-idx", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_TRANSLIT_FROM_TBL, "ctype-translit-from-tbl", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_TRANSLIT_TO_IDX, "ctype-translit-to-idx", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_TRANSLIT_TO_TBL, "ctype-translit-to-tbl", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN, "ctype-translit-default-missing-len", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_TRANSLIT_DEFAULT_MISSING, "ctype-translit-default-missing", std, wstring)
+ DEFINE_ELEMENT (_NL_CTYPE_TRANSLIT_IGNORE_LEN, "ctype-translit-ignore-len", std, word)
+ DEFINE_ELEMENT (_NL_CTYPE_TRANSLIT_IGNORE, "ctype-translit-ignore", std, string)
+ ), _nl_postload_ctype)
+
+
+DEFINE_CATEGORY
+(
+ LC_MONETARY, "LC_MONETARY",
+ (
+ DEFINE_ELEMENT (INT_CURR_SYMBOL, "int_curr_symbol", std, string)
+ DEFINE_ELEMENT (CURRENCY_SYMBOL, "currency_symbol", std, string)
+ DEFINE_ELEMENT (MON_DECIMAL_POINT, "mon_decimal_point", std, string)
+ DEFINE_ELEMENT (MON_THOUSANDS_SEP, "mon_thousands_sep", std, string)
+ DEFINE_ELEMENT (MON_GROUPING, "mon_grouping", std, bytearray)
+ DEFINE_ELEMENT (POSITIVE_SIGN, "positive_sign", std, string)
+ DEFINE_ELEMENT (NEGATIVE_SIGN, "negative_sign", std, string)
+ DEFINE_ELEMENT (INT_FRAC_DIGITS, "int_frac_digits", std, byte)
+ DEFINE_ELEMENT (FRAC_DIGITS, "frac_digits", std, byte)
+ DEFINE_ELEMENT (P_CS_PRECEDES, "p_cs_precedes", std, byte, 0, 1)
+ DEFINE_ELEMENT (P_SEP_BY_SPACE, "p_sep_by_space", std, byte, 0, 2)
+ DEFINE_ELEMENT (N_CS_PRECEDES, "n_cs_precedes", std, byte, 0, 1)
+ DEFINE_ELEMENT (N_SEP_BY_SPACE, "n_sep_by_space", std, byte, 0, 2)
+ DEFINE_ELEMENT (P_SIGN_POSN, "p_sign_posn", std, byte, 0, 4)
+ DEFINE_ELEMENT (N_SIGN_POSN, "n_sign_posn", std, byte, 0, 4)
+ DEFINE_ELEMENT (__INT_P_CS_PRECEDES, "int_p_cs_precedes", std, byte, 0, 1)
+ DEFINE_ELEMENT (__INT_P_SEP_BY_SPACE, "int_p_sep_by_space", std, byte, 0, 2)
+ DEFINE_ELEMENT (__INT_N_CS_PRECEDES, "int_n_cs_precedes", std, byte, 0, 1)
+ DEFINE_ELEMENT (__INT_N_SEP_BY_SPACE, "int_n_sep_by_space", std, byte, 0, 2)
+ DEFINE_ELEMENT (__INT_P_SIGN_POSN, "int_p_sign_posn", std, byte, 0, 4)
+ DEFINE_ELEMENT (__INT_N_SIGN_POSN, "int_n_sign_posn", std, byte, 0, 4)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_INT_CURR_SYMBOL, "duo_int_curr_symbol", std, string)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_CURRENCY_SYMBOL, "duo_currency_symbol", std, string)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_INT_FRAC_DIGITS, "duo_int_frac_digits", std, byte)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_FRAC_DIGITS, "duo_frac_digits", std, byte)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_P_CS_PRECEDES, "duo_p_cs_precedes", std, byte, 0, 1)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_P_SEP_BY_SPACE, "duo_p_sep_by_space", std, byte, 0, 2)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_N_CS_PRECEDES, "duo_n_cs_precedes", std, byte, 0, 1)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_N_SEP_BY_SPACE, "duo_n_sep_by_space", std, byte, 0, 2)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_INT_P_CS_PRECEDES, "duo_int_p_cs_precedes", std, byte, 0, 1)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_INT_P_SEP_BY_SPACE, "duo_int_p_sep_by_space", std, byte, 0, 2)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_INT_N_CS_PRECEDES, "duo_int_n_cs_precedes", std, byte, 0, 1)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_INT_N_SEP_BY_SPACE, "duo_int_n_sep_by_space", std, byte, 0, 2)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_P_SIGN_POSN, "duo_p_sign_posn", std, byte, 0, 4)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_N_SIGN_POSN, "duo_n_sign_posn", std, byte, 0, 4)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_INT_P_SIGN_POSN, "duo_int_p_sign_posn", std, byte, 0, 4)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_INT_N_SIGN_POSN, "duo_int_n_sign_posn", std, byte, 0, 4)
+ DEFINE_ELEMENT (_NL_MONETARY_UNO_VALID_FROM, "uno_valid_from", std, word)
+ DEFINE_ELEMENT (_NL_MONETARY_UNO_VALID_TO, "uno_valid_to", std, word)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_VALID_FROM, "duo_valid_from", std, word)
+ DEFINE_ELEMENT (_NL_MONETARY_DUO_VALID_TO, "duo_valid_to", std, word)
+ DEFINE_ELEMENT (_NL_MONETARY_CONVERSION_RATE, "conversion_rate", std, wordarray, 2, 2)
+ DEFINE_ELEMENT (_NL_MONETARY_DECIMAL_POINT_WC, "monetary-decimal-point-wc", std, word)
+ DEFINE_ELEMENT (_NL_MONETARY_THOUSANDS_SEP_WC, "monetary-thousands-sep-wc", std, word)
+ DEFINE_ELEMENT (_NL_MONETARY_CODESET, "monetary-codeset", std, string)
+ ), NO_POSTLOAD)
+
+
+DEFINE_CATEGORY
+(
+ LC_NUMERIC, "LC_NUMERIC",
+ (
+ DEFINE_ELEMENT (DECIMAL_POINT, "decimal_point", std, string)
+ DEFINE_ELEMENT (THOUSANDS_SEP, "thousands_sep", std, string)
+ DEFINE_ELEMENT (GROUPING, "grouping", std, bytearray)
+ DEFINE_ELEMENT (_NL_NUMERIC_DECIMAL_POINT_WC, "numeric-decimal-point-wc", std, word)
+ DEFINE_ELEMENT (_NL_NUMERIC_THOUSANDS_SEP_WC, "numeric-thousands-sep-wc", std, word)
+ DEFINE_ELEMENT (_NL_NUMERIC_CODESET, "numeric-codeset", std, string)
+
+ ), NO_POSTLOAD)
+
+
+DEFINE_CATEGORY
+(
+ LC_TIME, "LC_TIME",
+ (
+ DEFINE_ELEMENT (ABDAY_1, "abday", std, stringarray, 7, 7)
+ DEFINE_ELEMENT (DAY_1, "day", std, stringarray, 7, 7)
+ DEFINE_ELEMENT (ABMON_1, "abmon", std, stringarray, 12, 12)
+ DEFINE_ELEMENT (MON_1, "mon", std, stringarray, 12, 12)
+ DEFINE_ELEMENT (AM_STR, "am_pm", std, stringarray, 2, 2)
+ DEFINE_ELEMENT (D_T_FMT, "d_t_fmt", std, string)
+ DEFINE_ELEMENT (D_FMT, "d_fmt", std, string)
+ DEFINE_ELEMENT (T_FMT, "t_fmt", std, string)
+ DEFINE_ELEMENT (T_FMT_AMPM, "t_fmt_ampm", std, string)
+ DEFINE_ELEMENT (ERA, "era", opt, stringlist, 0, 100)
+ DEFINE_ELEMENT (ERA_YEAR, "era_year", opt, string)
+ DEFINE_ELEMENT (ERA_D_FMT, "era_d_fmt", opt, string)
+ DEFINE_ELEMENT (ALT_DIGITS, "alt_digits", opt, stringlist, 100, 100)
+ DEFINE_ELEMENT (ERA_D_T_FMT, "era_d_t_fmt", opt, string)
+ DEFINE_ELEMENT (ERA_T_FMT, "era_t_fmt", opt, string)
+ DEFINE_ELEMENT (_NL_TIME_ERA_NUM_ENTRIES, "time-era-num-entries", opt, word)
+ DEFINE_ELEMENT (_NL_TIME_ERA_ENTRIES, "time-era-entries", opt, string)
+ DEFINE_ELEMENT (_NL_WABDAY_1, "wide-abday", std, wstringarray, 7, 7)
+ DEFINE_ELEMENT (_NL_WDAY_1, "wide-day", std, wstringarray, 7, 7)
+ DEFINE_ELEMENT (_NL_WABMON_1, "wide-abmon", std, wstringarray, 12, 12)
+ DEFINE_ELEMENT (_NL_WMON_1, "wide-mon", std, wstringarray, 12, 12)
+ DEFINE_ELEMENT (_NL_WAM_STR, "wide-am_pm", std, wstringarray, 2, 2)
+ DEFINE_ELEMENT (_NL_WD_T_FMT, "wide-d_t_fmt", std, wstring)
+ DEFINE_ELEMENT (_NL_WD_FMT, "wide-d_fmt", std, wstring)
+ DEFINE_ELEMENT (_NL_WT_FMT, "wide-t_fmt", std, wstring)
+ DEFINE_ELEMENT (_NL_WT_FMT_AMPM, "wide-t_fmt_ampm", std, wstring)
+ DEFINE_ELEMENT (_NL_WERA_YEAR, "wide-era_year", opt, wstring)
+ DEFINE_ELEMENT (_NL_WERA_D_FMT, "wide-era_d_fmt", opt, wstring)
+ DEFINE_ELEMENT (_NL_WALT_DIGITS, "wide-alt_digits", opt, wstringlist, 1000, 100)
+ DEFINE_ELEMENT (_NL_WERA_D_T_FMT, "wide-era_d_t_fmt", opt, wstring)
+ DEFINE_ELEMENT (_NL_WERA_T_FMT, "wide-era_t_fmt", opt, wstring)
+ DEFINE_ELEMENT (_NL_TIME_WEEK_NDAYS, "week-ndays", std, byte)
+ DEFINE_ELEMENT (_NL_TIME_WEEK_1STDAY, "week-1stday", std, word)
+ DEFINE_ELEMENT (_NL_TIME_WEEK_1STWEEK, "week-1stweek", std, byte)
+ DEFINE_ELEMENT (_NL_TIME_FIRST_WEEKDAY, "first_weekday", std, byte)
+ DEFINE_ELEMENT (_NL_TIME_FIRST_WORKDAY, "first_workday", std, byte)
+ DEFINE_ELEMENT (_NL_TIME_CAL_DIRECTION, "cal_direction", std, byte)
+ DEFINE_ELEMENT (_NL_TIME_TIMEZONE, "timezone", std, string)
+ DEFINE_ELEMENT (_DATE_FMT, "date_fmt", opt, string)
+ DEFINE_ELEMENT (_NL_W_DATE_FMT, "wide-date_fmt", opt, wstring)
+ DEFINE_ELEMENT (_NL_TIME_CODESET, "time-codeset", std, string)
+ ), _nl_postload_time)
+
+
+DEFINE_CATEGORY
+(
+ LC_MESSAGES, "LC_MESSAGES",
+ (
+ DEFINE_ELEMENT (YESEXPR, "yesexpr", std, string)
+ DEFINE_ELEMENT (NOEXPR, "noexpr", std, string)
+ DEFINE_ELEMENT (YESSTR, "yesstr", opt, string)
+ DEFINE_ELEMENT (NOSTR, "nostr", opt, string)
+ DEFINE_ELEMENT (_NL_MESSAGES_CODESET, "messages-codeset", std, string)
+ ), NO_POSTLOAD)
+
+DEFINE_CATEGORY
+(
+ LC_PAPER, "LC_PAPER",
+ (
+ DEFINE_ELEMENT (_NL_PAPER_HEIGHT, "height", std, word)
+ DEFINE_ELEMENT (_NL_PAPER_WIDTH, "width", std, word)
+ DEFINE_ELEMENT (_NL_PAPER_CODESET, "paper-codeset", std, string)
+ ), NO_POSTLOAD)
+
+DEFINE_CATEGORY
+(
+ LC_NAME, "LC_NAME",
+ (
+ DEFINE_ELEMENT (_NL_NAME_NAME_FMT, "name_fmt", std, string)
+ DEFINE_ELEMENT (_NL_NAME_NAME_GEN, "name_gen", std, string)
+ DEFINE_ELEMENT (_NL_NAME_NAME_MR, "name_mr", std, string)
+ DEFINE_ELEMENT (_NL_NAME_NAME_MRS, "name_mrs", std, string)
+ DEFINE_ELEMENT (_NL_NAME_NAME_MISS, "name_miss", std, string)
+ DEFINE_ELEMENT (_NL_NAME_NAME_MS, "name_ms", std, string)
+ DEFINE_ELEMENT (_NL_NAME_CODESET, "name-codeset", std, string)
+ ), NO_POSTLOAD)
+
+DEFINE_CATEGORY
+(
+ LC_ADDRESS, "LC_ADDRESS",
+ (
+ DEFINE_ELEMENT (_NL_ADDRESS_POSTAL_FMT, "postal_fmt", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_COUNTRY_NAME, "country_name", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_COUNTRY_POST, "country_post", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_COUNTRY_AB2, "country_ab2", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_COUNTRY_AB3, "country_ab3", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_COUNTRY_CAR, "country_car", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_COUNTRY_NUM, "country_num", std, word)
+ DEFINE_ELEMENT (_NL_ADDRESS_COUNTRY_ISBN, "country_isbn", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_LANG_NAME, "lang_name", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_LANG_AB, "lang_ab", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_LANG_TERM, "lang_term", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_LANG_LIB, "lang_lib", std, string)
+ DEFINE_ELEMENT (_NL_ADDRESS_CODESET, "address-codeset", std, string)
+ ), NO_POSTLOAD)
+
+DEFINE_CATEGORY
+(
+ LC_TELEPHONE, "LC_TELEPHONE",
+ (
+ DEFINE_ELEMENT (_NL_TELEPHONE_TEL_INT_FMT, "tel_int_fmt", std, string)
+ DEFINE_ELEMENT (_NL_TELEPHONE_TEL_DOM_FMT, "tel_dom_fmt", std, string)
+ DEFINE_ELEMENT (_NL_TELEPHONE_INT_SELECT, "int_select", std, string)
+ DEFINE_ELEMENT (_NL_TELEPHONE_INT_PREFIX, "int_prefix", std, string)
+ DEFINE_ELEMENT (_NL_TELEPHONE_CODESET, "telephone-codeset", std, string)
+ ), NO_POSTLOAD)
+
+DEFINE_CATEGORY
+(
+ LC_MEASUREMENT, "LC_MEASUREMENT",
+ (
+ DEFINE_ELEMENT (_NL_MEASUREMENT_MEASUREMENT, "measurement", std, byte)
+ DEFINE_ELEMENT (_NL_MEASUREMENT_CODESET, "measurement-codeset", std, string)
+ ), NO_POSTLOAD)
+
+DEFINE_CATEGORY
+(
+ LC_IDENTIFICATION, "LC_IDENTIFICATION",
+ (
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_TITLE, "title", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_SOURCE, "source", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_ADDRESS, "address", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_CONTACT, "contact", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_EMAIL, "email", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_TEL, "tel", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_FAX, "fax", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_LANGUAGE, "language", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_TERRITORY, "territory", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_AUDIENCE, "audience", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_APPLICATION, "applcation", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_ABBREVIATION, "abbreviation", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_REVISION, "revision", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_DATE, "date", std, string)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_CATEGORY, "category", std, stringarray, 13, 13)
+ DEFINE_ELEMENT (_NL_IDENTIFICATION_CODESET, "identification-codeset", std, string)
+ ), NO_POSTLOAD)
Index: gconv_close.c
===================================================================
--- gconv_close.c (nonexistent)
+++ gconv_close.c (revision 520)
@@ -0,0 +1,65 @@
+/* Release any resource associated with given conversion descriptor.
+ Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+
+#include
+
+
+int
+internal_function
+__gconv_close (__gconv_t cd)
+{
+ struct __gconv_step *srunp;
+ struct __gconv_step_data *drunp;
+ size_t nsteps;
+
+ /* Free all resources by calling destructor functions and release
+ the implementations. */
+ srunp = cd->__steps;
+ nsteps = cd->__nsteps;
+ drunp = cd->__data;
+ do
+ {
+ struct __gconv_trans_data *transp;
+
+ transp = drunp->__trans;
+ while (transp != NULL)
+ {
+ struct __gconv_trans_data *curp = transp;
+ transp = transp->__next;
+
+ if (__builtin_expect (curp->__trans_end_fct != NULL, 0))
+ curp->__trans_end_fct (curp->__data);
+
+ free (curp);
+ }
+
+ if (!(drunp->__flags & __GCONV_IS_LAST) && drunp->__outbuf != NULL)
+ free (drunp->__outbuf);
+ }
+ while (!((drunp++)->__flags & __GCONV_IS_LAST));
+
+ /* Free the data allocated for the descriptor. */
+ free (cd);
+
+ /* Close the participating modules. */
+ return __gconv_close_transform (srunp, nsteps);
+}
gconv_close.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_builtin.c
===================================================================
--- gconv_builtin.c (nonexistent)
+++ gconv_builtin.c (revision 520)
@@ -0,0 +1,84 @@
+/* Table for builtin transformation mapping.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+
+#include
+
+#include
+
+
+static struct builtin_map
+{
+ const char *name;
+ __gconv_fct fct;
+
+ int min_needed_from;
+ int max_needed_from;
+ int min_needed_to;
+ int max_needed_to;
+
+} map[] =
+{
+#define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, MinF, MaxF, \
+ MinT, MaxT) \
+ { \
+ .name = Name, \
+ .fct = Fct, \
+ \
+ .min_needed_from = MinF, \
+ .max_needed_from = MaxF, \
+ .min_needed_to = MinT, \
+ .max_needed_to = MaxT \
+ },
+#define BUILTIN_ALIAS(From, To)
+
+#include
+};
+
+
+void
+internal_function
+__gconv_get_builtin_trans (const char *name, struct __gconv_step *step)
+{
+ size_t cnt;
+
+ for (cnt = 0; cnt < sizeof (map) / sizeof (map[0]); ++cnt)
+ if (strcmp (name, map[cnt].name) == 0)
+ break;
+
+ assert (cnt < sizeof (map) / sizeof (map[0]));
+
+ step->__fct = map[cnt].fct;
+ step->__init_fct = NULL;
+ step->__end_fct = NULL;
+ step->__shlib_handle = NULL;
+ step->__modname = NULL;
+
+ step->__min_needed_from = map[cnt].min_needed_from;
+ step->__max_needed_from = map[cnt].max_needed_from;
+ step->__min_needed_to = map[cnt].min_needed_to;
+ step->__max_needed_to = map[cnt].max_needed_to;
+
+ /* None of the builtin converters handles stateful encoding. */
+ step->__stateful = 0;
+}
gconv_builtin.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: iconv_close.c
===================================================================
--- iconv_close.c (nonexistent)
+++ iconv_close.c (revision 520)
@@ -0,0 +1,37 @@
+/* Release any resource associated with given conversion descriptor.
+ Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+
+#include
+
+
+int
+iconv_close (iconv_t cd)
+{
+ if (__builtin_expect (cd == (iconv_t *) -1L, 0))
+ {
+ __set_errno (EBADF);
+ return -1;
+ }
+
+ return __gconv_close ((__gconv_t) cd) ? -1 : 0;
+}
iconv_close.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_builtin.h
===================================================================
--- gconv_builtin.h (nonexistent)
+++ gconv_builtin.h (revision 520)
@@ -0,0 +1,115 @@
+/* Builtin transformations.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+BUILTIN_ALIAS ("UCS4//", "ISO-10646/UCS4/")
+BUILTIN_ALIAS ("UCS-4//", "ISO-10646/UCS4/")
+BUILTIN_ALIAS ("UCS-4BE//", "ISO-10646/UCS4/")
+BUILTIN_ALIAS ("CSUCS4//", "ISO-10646/UCS4/")
+BUILTIN_ALIAS ("ISO-10646//", "ISO-10646/UCS4/")
+BUILTIN_ALIAS ("10646-1:1993//", "ISO-10646/UCS4/")
+BUILTIN_ALIAS ("10646-1:1993/UCS4/", "ISO-10646/UCS4/")
+BUILTIN_ALIAS ("OSF00010104//", "ISO-10646/UCS4/") /* level 1 */
+BUILTIN_ALIAS ("OSF00010105//", "ISO-10646/UCS4/") /* level 2 */
+BUILTIN_ALIAS ("OSF00010106//", "ISO-10646/UCS4/") /* level 3 */
+
+BUILTIN_TRANSFORMATION ("INTERNAL", "ISO-10646/UCS4/", 1, "=INTERNAL->ucs4",
+ __gconv_transform_internal_ucs4, 4, 4, 4, 4)
+BUILTIN_TRANSFORMATION ("ISO-10646/UCS4/", "INTERNAL", 1, "=ucs4->INTERNAL",
+ __gconv_transform_ucs4_internal, 4, 4, 4, 4)
+
+BUILTIN_TRANSFORMATION ("INTERNAL", "UCS-4LE//", 1, "=INTERNAL->ucs4le",
+ __gconv_transform_internal_ucs4le, 4, 4, 4, 4)
+BUILTIN_TRANSFORMATION ("UCS-4LE//", "INTERNAL", 1, "=ucs4le->INTERNAL",
+ __gconv_transform_ucs4le_internal, 4, 4, 4, 4)
+
+BUILTIN_ALIAS ("WCHAR_T//", "INTERNAL")
+
+BUILTIN_ALIAS ("UTF8//", "ISO-10646/UTF8/")
+BUILTIN_ALIAS ("UTF-8//", "ISO-10646/UTF8/")
+BUILTIN_ALIAS ("ISO-IR-193//", "ISO-10646/UTF8/")
+BUILTIN_ALIAS ("OSF05010001//", "ISO-10646/UTF8/")
+BUILTIN_ALIAS ("ISO-10646/UTF-8/", "ISO-10646/UTF8/")
+
+BUILTIN_TRANSFORMATION ("INTERNAL", "ISO-10646/UTF8/", 1, "=INTERNAL->utf8",
+ __gconv_transform_internal_utf8, 4, 4, 1, 6)
+
+BUILTIN_TRANSFORMATION ("ISO-10646/UTF8/", "INTERNAL", 1, "=utf8->INTERNAL",
+ __gconv_transform_utf8_internal, 1, 6, 4, 4)
+
+BUILTIN_ALIAS ("UCS2//", "ISO-10646/UCS2/")
+BUILTIN_ALIAS ("UCS-2//", "ISO-10646/UCS2/")
+BUILTIN_ALIAS ("OSF00010100//", "ISO-10646/UCS2/") /* level 1 */
+BUILTIN_ALIAS ("OSF00010101//", "ISO-10646/UCS2/") /* level 2 */
+BUILTIN_ALIAS ("OSF00010102//", "ISO-10646/UCS2/") /* level 3 */
+
+BUILTIN_TRANSFORMATION ("ISO-10646/UCS2/", "INTERNAL", 1, "=ucs2->INTERNAL",
+ __gconv_transform_ucs2_internal, 2, 2, 4, 4)
+
+BUILTIN_TRANSFORMATION ("INTERNAL", "ISO-10646/UCS2/", 1, "=INTERNAL->ucs2",
+ __gconv_transform_internal_ucs2, 4, 4, 2, 2)
+
+
+BUILTIN_ALIAS ("ANSI_X3.4//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("ISO-IR-6//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("ANSI_X3.4-1986//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("ISO_646.IRV:1991//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("ASCII//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("ISO646-US//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("US-ASCII//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("US//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("IBM367//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("CP367//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("CSASCII//", "ANSI_X3.4-1968//")
+BUILTIN_ALIAS ("OSF00010020//", "ANSI_X3.4-1968//")
+
+BUILTIN_TRANSFORMATION ("ANSI_X3.4-1968//", "INTERNAL", 1, "=ascii->INTERNAL",
+ __gconv_transform_ascii_internal, 4, 4, 1, 1)
+
+BUILTIN_TRANSFORMATION ("INTERNAL", "ANSI_X3.4-1968//", 1, "=INTERNAL->ascii",
+ __gconv_transform_internal_ascii, 4, 4, 1, 1)
+
+
+#if BYTE_ORDER == BIG_ENDIAN
+BUILTIN_ALIAS ("UNICODEBIG//", "ISO-10646/UCS2/")
+BUILTIN_ALIAS ("UCS-2BE//", "ISO-10646/UCS2/")
+
+BUILTIN_ALIAS ("UCS-2LE//", "UNICODELITTLE//")
+
+BUILTIN_TRANSFORMATION ("UNICODELITTLE//", "INTERNAL", 1,
+ "=ucs2reverse->INTERNAL",
+ __gconv_transform_ucs2reverse_internal, 2, 2, 4, 4)
+
+BUILTIN_TRANSFORMATION ("INTERNAL", "UNICODELITTLE//", 1,
+ "=INTERNAL->ucs2reverse",
+ __gconv_transform_internal_ucs2reverse, 4, 4, 2, 2)
+#else
+BUILTIN_ALIAS ("UNICODELITTLE//", "ISO-10646/UCS2/")
+BUILTIN_ALIAS ("UCS-2LE//", "ISO-10646/UCS2/")
+
+BUILTIN_ALIAS ("UCS-2BE//", "UNICODEBIG//")
+
+BUILTIN_TRANSFORMATION ("UNICODEBIG//", "INTERNAL", 1,
+ "=ucs2reverse->INTERNAL",
+ __gconv_transform_ucs2reverse_internal, 2, 2, 4, 4)
+
+BUILTIN_TRANSFORMATION ("INTERNAL", "UNICODEBIG//", 1,
+ "=INTERNAL->ucs2reverse",
+ __gconv_transform_internal_ucs2reverse, 4, 4, 2, 2)
+#endif
gconv_builtin.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: loop.c
===================================================================
--- loop.c (nonexistent)
+++ loop.c (revision 520)
@@ -0,0 +1,450 @@
+/* Conversion loop frame work.
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1998.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+/* This file provides a frame for the reader loop in all conversion modules.
+ The actual code must (of course) be provided in the actual module source
+ code but certain actions can be written down generically, with some
+ customization options which are these:
+
+ MIN_NEEDED_INPUT minimal number of input bytes needed for the next
+ conversion.
+ MIN_NEEDED_OUTPUT minimal number of bytes produced by the next round
+ of conversion.
+
+ MAX_NEEDED_INPUT you guess it, this is the maximal number of input
+ bytes needed. It defaults to MIN_NEEDED_INPUT
+ MAX_NEEDED_OUTPUT likewise for output bytes.
+
+ LOOPFCT name of the function created. If not specified
+ the name is `loop' but this prevents the use
+ of multiple functions in the same file.
+
+ BODY this is supposed to expand to the body of the loop.
+ The user must provide this.
+
+ EXTRA_LOOP_DECLS extra arguments passed from converion loop call.
+
+ INIT_PARAMS code to define and initialize variables from params.
+ UPDATE_PARAMS code to store result in params.
+*/
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include /* For MIN. */
+#define __need_size_t
+#include
+
+
+/* We have to provide support for machines which are not able to handled
+ unaligned memory accesses. Some of the character encodings have
+ representations with a fixed width of 2 or 4 bytes. But if we cannot
+ access unaligned memory we still have to read byte-wise. */
+#undef FCTNAME2
+#if defined _STRING_ARCH_unaligned || !defined DEFINE_UNALIGNED
+/* We can handle unaligned memory access. */
+# define get16(addr) *((__const uint16_t *) (addr))
+# define get32(addr) *((__const uint32_t *) (addr))
+
+/* We need no special support for writing values either. */
+# define put16(addr, val) *((uint16_t *) (addr)) = (val)
+# define put32(addr, val) *((uint32_t *) (addr)) = (val)
+
+# define FCTNAME2(name) name
+#else
+/* Distinguish between big endian and little endian. */
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+# define get16(addr) \
+ (((__const unsigned char *) (addr))[1] << 8 \
+ | ((__const unsigned char *) (addr))[0])
+# define get32(addr) \
+ (((((__const unsigned char *) (addr))[3] << 8 \
+ | ((__const unsigned char *) (addr))[2]) << 8 \
+ | ((__const unsigned char *) (addr))[1]) << 8 \
+ | ((__const unsigned char *) (addr))[0])
+
+# define put16(addr, val) \
+ ({ uint16_t __val = (val); \
+ ((unsigned char *) (addr))[0] = __val; \
+ ((unsigned char *) (addr))[1] = __val >> 8; \
+ (void) 0; })
+# define put32(addr, val) \
+ ({ uint32_t __val = (val); \
+ ((unsigned char *) (addr))[0] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[1] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[2] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[3] = __val; \
+ (void) 0; })
+# else
+# define get16(addr) \
+ (((__const unsigned char *) (addr))[0] << 8 \
+ | ((__const unsigned char *) (addr))[1])
+# define get32(addr) \
+ (((((__const unsigned char *) (addr))[0] << 8 \
+ | ((__const unsigned char *) (addr))[1]) << 8 \
+ | ((__const unsigned char *) (addr))[2]) << 8 \
+ | ((__const unsigned char *) (addr))[3])
+
+# define put16(addr, val) \
+ ({ uint16_t __val = (val); \
+ ((unsigned char *) (addr))[1] = __val; \
+ ((unsigned char *) (addr))[0] = __val >> 8; \
+ (void) 0; })
+# define put32(addr, val) \
+ ({ uint32_t __val = (val); \
+ ((unsigned char *) (addr))[3] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[2] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[1] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[0] = __val; \
+ (void) 0; })
+# endif
+
+# define FCTNAME2(name) name##_unaligned
+#endif
+#define FCTNAME(name) FCTNAME2(name)
+
+
+/* We need at least one byte for the next round. */
+#ifndef MIN_NEEDED_INPUT
+# error "MIN_NEEDED_INPUT definition missing"
+#endif
+
+/* Let's see how many bytes we produce. */
+#ifndef MAX_NEEDED_INPUT
+# define MAX_NEEDED_INPUT MIN_NEEDED_INPUT
+#endif
+
+/* We produce at least one byte in the next round. */
+#ifndef MIN_NEEDED_OUTPUT
+# error "MIN_NEEDED_OUTPUT definition missing"
+#endif
+
+/* Let's see how many bytes we produce. */
+#ifndef MAX_NEEDED_OUTPUT
+# define MAX_NEEDED_OUTPUT MIN_NEEDED_OUTPUT
+#endif
+
+/* Default name for the function. */
+#ifndef LOOPFCT
+# define LOOPFCT loop
+#endif
+
+/* Make sure we have a loop body. */
+#ifndef BODY
+# error "Definition of BODY missing for function" LOOPFCT
+#endif
+
+
+/* If no arguments have to passed to the loop function define the macro
+ as empty. */
+#ifndef EXTRA_LOOP_DECLS
+# define EXTRA_LOOP_DECLS
+#endif
+
+
+/* To make it easier for the writers of the modules, we define a macro
+ to test whether we have to ignore errors. */
+#define ignore_errors_p() \
+ (irreversible != NULL && (flags & __GCONV_IGNORE_ERRORS))
+
+
+/* Error handling with transliteration/transcription function use and
+ ignoring of errors. Note that we cannot use the do while (0) trick
+ since `break' and `continue' must reach certain points. */
+#define STANDARD_ERR_HANDLER(Incr) \
+ { \
+ struct __gconv_trans_data *trans; \
+ \
+ result = __GCONV_ILLEGAL_INPUT; \
+ \
+ if (irreversible == NULL) \
+ /* This means we are in call from __gconv_transliterate. In this \
+ case we are not doing any error recovery outself. */ \
+ break; \
+ \
+ /* First try the transliteration methods. */ \
+ for (trans = step_data->__trans; trans != NULL; trans = trans->__next) \
+ { \
+ result = trans->__trans_fct (step, step_data, trans->__data, *inptrp, \
+ &inptr, inend, &outptr, irreversible); \
+ if (result != __GCONV_ILLEGAL_INPUT) \
+ break; \
+ } \
+ /* If any of them recognized the input continue with the loop. */ \
+ if (result != __GCONV_ILLEGAL_INPUT) \
+ continue; \
+ \
+ /* Next see whether we have to ignore the error. If not, stop. */ \
+ if (! ignore_errors_p ()) \
+ break; \
+ \
+ /* When we come here it means we ignore the character. */ \
+ ++*irreversible; \
+ inptr += Incr; \
+ continue; \
+ }
+
+
+/* Handling of Unicode 3.1 TAG characters. Unicode recommends
+ "If language codes are not relevant to the particular processing
+ operation, then they should be ignored."
+ This macro is usually called right before STANDARD_ERR_HANDLER (Incr). */
+#define UNICODE_TAG_HANDLER(Character, Incr) \
+ { \
+ /* TAG characters are those in the range U+E0000..U+E007F. */ \
+ if (((Character) >> 7) == (0xe0000 >> 7)) \
+ { \
+ inptr += Incr; \
+ continue; \
+ } \
+ }
+
+
+/* The function returns the status, as defined in gconv.h. */
+static inline int
+FCTNAME (LOOPFCT) (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp, const unsigned char *inend,
+ unsigned char **outptrp, const unsigned char *outend,
+ size_t *irreversible EXTRA_LOOP_DECLS)
+{
+#ifdef LOOP_NEED_STATE
+ mbstate_t *state = step_data->__statep;
+#endif
+#ifdef LOOP_NEED_FLAGS
+ int flags = step_data->__flags;
+#endif
+#ifdef LOOP_NEED_DATA
+ void *data = step->__data;
+#endif
+ int result = __GCONV_EMPTY_INPUT;
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+
+#ifdef INIT_PARAMS
+ INIT_PARAMS;
+#endif
+
+ while (inptr != inend)
+ {
+ /* `if' cases for MIN_NEEDED_OUTPUT ==/!= 1 is made to help the
+ compiler generating better code. They will be optimized away
+ since MIN_NEEDED_OUTPUT is always a constant. */
+ if ((MIN_NEEDED_OUTPUT != 1
+ && __builtin_expect (outptr + MIN_NEEDED_OUTPUT > outend, 0))
+ || (MIN_NEEDED_OUTPUT == 1
+ && __builtin_expect (outptr >= outend, 0)))
+ {
+ /* Overflow in the output buffer. */
+ result = __GCONV_FULL_OUTPUT;
+ break;
+ }
+ if (MIN_NEEDED_INPUT > 1
+ && __builtin_expect (inptr + MIN_NEEDED_INPUT > inend, 0))
+ {
+ /* We don't have enough input for another complete input
+ character. */
+ result = __GCONV_INCOMPLETE_INPUT;
+ break;
+ }
+
+ /* Here comes the body the user provides. It can stop with
+ RESULT set to GCONV_INCOMPLETE_INPUT (if the size of the
+ input characters vary in size), GCONV_ILLEGAL_INPUT, or
+ GCONV_FULL_OUTPUT (if the output characters vary in size). */
+ BODY
+ }
+
+ /* Update the pointers pointed to by the parameters. */
+ *inptrp = inptr;
+ *outptrp = outptr;
+#ifdef UPDATE_PARAMS
+ UPDATE_PARAMS;
+#endif
+
+ return result;
+}
+
+
+/* Include the file a second time to define the function to handle
+ unaligned access. */
+#if !defined DEFINE_UNALIGNED && !defined _STRING_ARCH_unaligned \
+ && MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \
+ && MIN_NEEDED_TO != 1 && MAX_NEEDED_TO % MIN_NEEDED_TO == 0
+# undef get16
+# undef get32
+# undef put16
+# undef put32
+# undef unaligned
+
+# define DEFINE_UNALIGNED
+# include "loop.c"
+# undef DEFINE_UNALIGNED
+#endif
+
+
+#if MAX_NEEDED_INPUT > 1
+# define SINGLE(fct) SINGLE2 (fct)
+# define SINGLE2(fct) fct##_single
+static inline int
+SINGLE(LOOPFCT) (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp, const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible EXTRA_LOOP_DECLS)
+{
+ mbstate_t *state = step_data->__statep;
+#ifdef LOOP_NEED_FLAGS
+ int flags = step_data->__flags;
+#endif
+#ifdef LOOP_NEED_DATA
+ void *data = step->__data;
+#endif
+ int result = __GCONV_OK;
+ unsigned char bytebuf[MAX_NEEDED_INPUT];
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+ size_t inlen;
+
+#ifdef INIT_PARAMS
+ INIT_PARAMS;
+#endif
+
+#ifdef UNPACK_BYTES
+ UNPACK_BYTES
+#else
+ /* Add the bytes from the state to the input buffer. */
+ for (inlen = 0; inlen < (size_t) (state->__count & 7); ++inlen)
+ bytebuf[inlen] = state->__value.__wchb[inlen];
+#endif
+
+ /* Are there enough bytes in the input buffer? */
+ if (__builtin_expect (inptr + (MIN_NEEDED_INPUT - inlen) > inend, 0))
+ {
+ *inptrp = inend;
+#ifdef STORE_REST
+ inptr = bytebuf;
+ inptrp = &inptr;
+ inend = &bytebuf[inlen];
+
+ STORE_REST
+#else
+ /* We don't have enough input for another complete input
+ character. */
+ while (inptr < inend)
+ state->__value.__wchb[inlen++] = *inptr++;
+#endif
+
+ return __GCONV_INCOMPLETE_INPUT;
+ }
+
+ /* Enough space in output buffer. */
+ if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
+ || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
+ /* Overflow in the output buffer. */
+ return __GCONV_FULL_OUTPUT;
+
+ /* Now add characters from the normal input buffer. */
+ do
+ bytebuf[inlen++] = *inptr++;
+ while (inlen < MAX_NEEDED_INPUT && inptr < inend);
+
+ inptr = bytebuf;
+ inend = &bytebuf[inlen];
+
+ do
+ {
+ BODY
+ }
+ while (0);
+
+ /* Now we either have produced an output character and consumed all the
+ bytes from the state and at least one more, or the character is still
+ incomplete, or we have some other error (like illegal input character,
+ no space in output buffer). */
+ if (__builtin_expect (inptr != bytebuf, 1))
+ {
+ /* We found a new character. */
+ assert (inptr - bytebuf > (state->__count & 7));
+
+ *inptrp += inptr - bytebuf - (state->__count & 7);
+ *outptrp = outptr;
+
+ result = __GCONV_OK;
+
+ /* Clear the state buffer. */
+ state->__count &= ~7;
+ }
+ else if (result == __GCONV_INCOMPLETE_INPUT)
+ {
+ /* This can only happen if we have less than MAX_NEEDED_INPUT bytes
+ available. */
+ assert (inend != &bytebuf[MAX_NEEDED_INPUT]);
+
+ *inptrp += inend - bytebuf - (state->__count & 7);
+#ifdef STORE_REST
+ inptrp = &inptr;
+
+ STORE_REST
+#else
+ /* We don't have enough input for another complete input
+ character. */
+ while (inptr < inend)
+ state->__value.__wchb[inlen++] = *inptr++;
+#endif
+ }
+
+ return result;
+}
+# undef SINGLE
+# undef SINGLE2
+#endif
+
+
+/* We remove the macro definitions so that we can include this file again
+ for the definition of another function. */
+#undef MIN_NEEDED_INPUT
+#undef MAX_NEEDED_INPUT
+#undef MIN_NEEDED_OUTPUT
+#undef MAX_NEEDED_OUTPUT
+#undef LOOPFCT
+#undef BODY
+#undef LOOPFCT
+#undef EXTRA_LOOP_DECLS
+#undef INIT_PARAMS
+#undef UPDATE_PARAMS
+#undef UNPACK_BYTES
+#undef LOOP_NEED_STATE
+#undef LOOP_NEED_FLAGS
+#undef LOOP_NEED_DATA
+#undef get16
+#undef get32
+#undef put16
+#undef put32
+#undef unaligned
loop.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: iconvconfig.h
===================================================================
--- iconvconfig.h (nonexistent)
+++ iconvconfig.h (revision 520)
@@ -0,0 +1,67 @@
+/* Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 2000.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include
+
+
+typedef uint16_t gidx_t;
+
+
+struct gconvcache_header
+{
+ uint32_t magic;
+ gidx_t string_offset;
+ gidx_t hash_offset;
+ gidx_t hash_size;
+ gidx_t module_offset;
+ gidx_t otherconv_offset;
+};
+
+struct hash_entry
+{
+ gidx_t string_offset;
+ gidx_t module_idx;
+};
+
+struct module_entry
+{
+ gidx_t canonname_offset;
+ gidx_t fromdir_offset;
+ gidx_t fromname_offset;
+ gidx_t todir_offset;
+ gidx_t toname_offset;
+ gidx_t extra_offset;
+};
+
+struct extra_entry
+{
+ gidx_t module_cnt;
+ struct extra_entry_module
+ {
+ gidx_t outname_offset;
+ gidx_t dir_offset;
+ gidx_t name_offset;
+ } module[0];
+};
+
+
+#define GCONVCACHE_MAGIC 0x20010324
+
+
+#define GCONV_MODULES_CACHE GCONV_DIR "/gconv-modules.cache"
iconvconfig.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: iconv_charmap.c
===================================================================
--- iconv_charmap.c (nonexistent)
+++ iconv_charmap.c (revision 520)
@@ -0,0 +1,563 @@
+/* Convert using charmaps and possibly iconv().
+ Copyright (C) 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 2001.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "iconv_prog.h"
+
+
+/* Prototypes for a few program-wide used functions. */
+extern void *xmalloc (size_t __n);
+extern void *xcalloc (size_t __n, size_t __s);
+
+
+struct convtable
+{
+ int term[256 / 8];
+ union
+ {
+ struct convtable *sub;
+ struct charseq *out;
+ } val[256];
+};
+
+
+static inline struct convtable *
+allocate_table (void)
+{
+ return (struct convtable *) xcalloc (1, sizeof (struct convtable));
+}
+
+
+static inline int
+is_term (struct convtable *tbl, unsigned int idx)
+{
+ return tbl->term[idx / 8] & (1 << (idx % 8));
+}
+
+
+static inline void
+clear_term (struct convtable *tbl, unsigned int idx)
+{
+ tbl->term[idx / 8] &= ~(1 << (idx % 8));
+}
+
+
+static inline void
+set_term (struct convtable *tbl, unsigned int idx)
+{
+ tbl->term[idx / 8] |= 1 << (idx % 8);
+}
+
+
+/* Generate the conversion table. */
+static struct convtable *use_from_charmap (struct charmap_t *from_charmap,
+ const char *to_code);
+static struct convtable *use_to_charmap (const char *from_code,
+ struct charmap_t *to_charmap);
+static struct convtable *use_both_charmaps (struct charmap_t *from_charmap,
+ struct charmap_t *to_charmap);
+
+/* Prototypes for the functions doing the actual work. */
+static int process_block (struct convtable *tbl, char *addr, size_t len,
+ FILE *output);
+static int process_fd (struct convtable *tbl, int fd, FILE *output);
+static int process_file (struct convtable *tbl, FILE *input, FILE *output);
+
+
+int
+charmap_conversion (const char *from_code, struct charmap_t *from_charmap,
+ const char *to_code, struct charmap_t *to_charmap,
+ int argc, int remaining, char *argv[], FILE *output)
+{
+ struct convtable *cvtbl;
+ int status = EXIT_SUCCESS;
+
+ /* We have three different cases to handle:
+
+ - both, from_charmap and to_charmap, are available. This means we
+ can assume that the symbolic names match and use them to create
+ the mapping.
+
+ - only from_charmap is available. In this case we can only hope that
+ the symbolic names used are of the form in which case we
+ can use a UCS4->"to_code" iconv() conversion for the second step.
+
+ - only to_charmap is available. This is similar, only that we would
+ use iconv() for the "to_code"->UCS4 conversion.
+
+ We first create a table which maps input bytes into output bytes.
+ Once this is done we can handle all three of the cases above
+ equally. */
+ if (from_charmap != NULL)
+ {
+ if (to_charmap == NULL)
+ cvtbl = use_from_charmap (from_charmap, to_code);
+ else
+ cvtbl = use_both_charmaps (from_charmap, to_charmap);
+ }
+ else
+ {
+ assert (to_charmap != NULL);
+ cvtbl = use_to_charmap (from_code, to_charmap);
+ }
+
+ /* If we couldn't generate a table stop now. */
+ if (cvtbl == NULL)
+ return EXIT_FAILURE;
+
+ /* We can now start the conversion. */
+ if (remaining == argc)
+ {
+ if (process_file (cvtbl, stdin, output) != 0)
+ status = EXIT_FAILURE;
+ }
+ else
+ do
+ {
+ struct stat st;
+ char *addr;
+ int fd;
+
+ if (verbose)
+ printf ("%s:\n", argv[remaining]);
+ if (strcmp (argv[remaining], "-") == 0)
+ fd = 0;
+ else
+ {
+ fd = open (argv[remaining], O_RDONLY);
+
+ if (fd == -1)
+ {
+ error (0, errno, _("cannot open input file `%s'"),
+ argv[remaining]);
+ status = EXIT_FAILURE;
+ continue;
+ }
+ }
+
+#ifdef _POSIX_MAPPED_FILES
+ /* We have possibilities for reading the input file. First try
+ to mmap() it since this will provide the fastest solution. */
+ if (fstat (fd, &st) == 0
+ && ((addr = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE,
+ fd, 0)) != MAP_FAILED))
+ {
+ /* Yes, we can use mmap(). The descriptor is not needed
+ anymore. */
+ if (close (fd) != 0)
+ error (EXIT_FAILURE, errno,
+ _("error while closing input `%s'"), argv[remaining]);
+
+ if (process_block (cvtbl, addr, st.st_size, output) < 0)
+ {
+ /* Something went wrong. */
+ status = EXIT_FAILURE;
+
+ /* We don't need the input data anymore. */
+ munmap ((void *) addr, st.st_size);
+
+ /* We cannot go on with producing output since it might
+ lead to problem because the last output might leave
+ the output stream in an undefined state. */
+ break;
+ }
+
+ /* We don't need the input data anymore. */
+ munmap ((void *) addr, st.st_size);
+ }
+ else
+#endif /* _POSIX_MAPPED_FILES */
+ {
+ /* Read the file in pieces. */
+ if (process_fd (cvtbl, fd, output) != 0)
+ {
+ /* Something went wrong. */
+ status = EXIT_FAILURE;
+
+ /* We don't need the input file anymore. */
+ close (fd);
+
+ /* We cannot go on with producing output since it might
+ lead to problem because the last output might leave
+ the output stream in an undefined state. */
+ break;
+ }
+
+ /* Now close the file. */
+ close (fd);
+ }
+ }
+ while (++remaining < argc);
+
+ /* All done. */
+ return status;
+}
+
+
+static void
+add_bytes (struct convtable *tbl, struct charseq *in, struct charseq *out)
+{
+ int n = 0;
+ unsigned int byte;
+
+ assert (in->nbytes > 0);
+
+ byte = ((unsigned char *) in->bytes)[n];
+ while (n + 1 < in->nbytes)
+ {
+ if (is_term (tbl, byte) || tbl->val[byte].sub == NULL)
+ {
+ /* Note that we simply ignore a definition for a byte sequence
+ which is also the prefix for a longer one. */
+ clear_term (tbl, byte);
+ tbl->val[byte].sub =
+ (struct convtable *) xcalloc (1, sizeof (struct convtable));
+ }
+
+ tbl = tbl->val[byte].sub;
+
+ byte = ((unsigned char *) in->bytes)[++n];
+ }
+
+ /* Only add the new sequence if there is none yet and the byte sequence
+ is not part of an even longer one. */
+ if (! is_term (tbl, byte) && tbl->val[byte].sub == NULL)
+ {
+ set_term (tbl, byte);
+ tbl->val[byte].out = out;
+ }
+}
+
+
+static struct convtable *
+use_from_charmap (struct charmap_t *from_charmap, const char *to_code)
+{
+ /* We iterate over all entries in the from_charmap and for those which
+ have a known UCS4 representation we use an iconv() call to determine
+ the mapping to the to_code charset. */
+ struct convtable *rettbl;
+ iconv_t cd;
+ void *ptr = NULL;
+ const void *key;
+ size_t keylen;
+ void *data;
+
+ cd = iconv_open (to_code, "WCHAR_T");
+ if (cd == (iconv_t) -1)
+ /* We cannot do anything. */
+ return NULL;
+
+ rettbl = allocate_table ();
+
+ while (iterate_table (&from_charmap->char_table, &ptr, &key, &keylen, &data)
+ >= 0)
+ {
+ struct charseq *in = (struct charseq *) data;
+
+ if (in->ucs4 != UNINITIALIZED_CHAR_VALUE)
+ {
+ /* There is a chance. Try the iconv module. */
+ wchar_t inbuf[1] = { in->ucs4 };
+ unsigned char outbuf[64];
+ char *inptr = (char *) inbuf;
+ size_t inlen = sizeof (inbuf);
+ char *outptr = (char *) outbuf;
+ size_t outlen = sizeof (outbuf);
+
+ (void) iconv (cd, &inptr, &inlen, &outptr, &outlen);
+
+ if (outptr != (char *) outbuf)
+ {
+ /* We got some output. Good, use it. */
+ struct charseq *newp;
+
+ outlen = sizeof (outbuf) - outlen;
+ assert ((char *) outbuf + outlen == outptr);
+
+ newp = (struct charseq *) xmalloc (sizeof (struct charseq)
+ + outlen);
+ newp->name = in->name;
+ newp->ucs4 = in->ucs4;
+ newp->nbytes = outlen;
+ memcpy (newp->bytes, outbuf, outlen);
+
+ add_bytes (rettbl, in, newp);
+ }
+
+ /* Clear any possible state left behind. */
+ (void) iconv (cd, NULL, NULL, NULL, NULL);
+ }
+ }
+
+ iconv_close (cd);
+
+ return rettbl;
+}
+
+
+static struct convtable *
+use_to_charmap (const char *from_code, struct charmap_t *to_charmap)
+{
+ /* We iterate over all entries in the to_charmap and for those which
+ have a known UCS4 representation we use an iconv() call to determine
+ the mapping to the from_code charset. */
+ struct convtable *rettbl;
+ iconv_t cd;
+ void *ptr = NULL;
+ const void *key;
+ size_t keylen;
+ void *data;
+
+ /* Note that the conversion we use here is the reverse direction. Without
+ exhaustive search we cannot figure out which input yields the UCS4
+ character we are looking for. Therefore we determine it the other
+ way round. */
+ cd = iconv_open (from_code, "WCHAR_T");
+ if (cd == (iconv_t) -1)
+ /* We cannot do anything. */
+ return NULL;
+
+ rettbl = allocate_table ();
+
+ while (iterate_table (&to_charmap->char_table, &ptr, &key, &keylen, &data)
+ >= 0)
+ {
+ struct charseq *out = (struct charseq *) data;
+
+ if (out->ucs4 != UNINITIALIZED_CHAR_VALUE)
+ {
+ /* There is a chance. Try the iconv module. */
+ wchar_t inbuf[1] = { out->ucs4 };
+ unsigned char outbuf[64];
+ char *inptr = (char *) inbuf;
+ size_t inlen = sizeof (inbuf);
+ char *outptr = (char *) outbuf;
+ size_t outlen = sizeof (outbuf);
+
+ (void) iconv (cd, &inptr, &inlen, &outptr, &outlen);
+
+ if (outptr != (char *) outbuf)
+ {
+ /* We got some output. Good, use it. */
+ struct charseq *newp;
+
+ outlen = sizeof (outbuf) - outlen;
+ assert ((char *) outbuf + outlen == outptr);
+
+ newp = (struct charseq *) xmalloc (sizeof (struct charseq)
+ + outlen);
+ newp->name = out->name;
+ newp->ucs4 = out->ucs4;
+ newp->nbytes = outlen;
+ memcpy (newp->bytes, outbuf, outlen);
+
+ add_bytes (rettbl, newp, out);
+ }
+
+ /* Clear any possible state left behind. */
+ (void) iconv (cd, NULL, NULL, NULL, NULL);
+ }
+ }
+
+ iconv_close (cd);
+
+ return rettbl;
+}
+
+
+static struct convtable *
+use_both_charmaps (struct charmap_t *from_charmap,
+ struct charmap_t *to_charmap)
+{
+ /* In this case we iterate over all the entries in the from_charmap,
+ determine the internal name, and find an appropriate entry in the
+ to_charmap (if it exists). */
+ struct convtable *rettbl = allocate_table ();
+ void *ptr = NULL;
+ const void *key;
+ size_t keylen;
+ void *data;
+
+ while (iterate_table (&from_charmap->char_table, &ptr, &key, &keylen, &data)
+ >= 0)
+ {
+ struct charseq *in = (struct charseq *) data;
+ struct charseq *out = charmap_find_value (to_charmap, key, keylen);
+
+ if (out != NULL)
+ add_bytes (rettbl, in, out);
+ }
+
+ return rettbl;
+}
+
+
+static int
+process_block (struct convtable *tbl, char *addr, size_t len, FILE *output)
+{
+ size_t n = 0;
+
+ while (n < len)
+ {
+ struct convtable *cur = tbl;
+ unsigned char *curp = (unsigned char *) addr;
+ unsigned int byte = *curp;
+ int cnt;
+ struct charseq *out;
+
+ while (! is_term (cur, byte))
+ if (cur->val[byte].sub == NULL)
+ {
+ /* This is a invalid sequence. Skip the first byte if we are
+ ignoring errors. Otherwise punt. */
+ if (! omit_invalid)
+ {
+ error (0, 0, _("illegal input sequence at position %Zd"), n);
+ return -1;
+ }
+
+ n -= curp - (unsigned char *) addr;
+
+ byte = *(curp = (unsigned char *) ++addr);
+ if (++n >= len)
+ /* All converted. */
+ return 0;
+
+ cur = tbl;
+ }
+ else
+ {
+ cur = cur->val[byte].sub;
+
+ if (++n >= len)
+ {
+ error (0, 0, _("\
+incomplete character or shift sequence at end of buffer"));
+ return -1;
+ }
+
+ byte = *++curp;
+ }
+
+ /* We found a final byte. Write the output bytes. */
+ out = cur->val[byte].out;
+ for (cnt = 0; cnt < out->nbytes; ++cnt)
+ fputc_unlocked (out->bytes[cnt], output);
+
+ addr = (char *) curp + 1;
+ ++n;
+ }
+
+ return 0;
+}
+
+
+static int
+process_fd (struct convtable *tbl, int fd, FILE *output)
+{
+ /* we have a problem with reading from a desriptor since we must not
+ provide the iconv() function an incomplete character or shift
+ sequence at the end of the buffer. Since we have to deal with
+ arbitrary encodings we must read the whole text in a buffer and
+ process it in one step. */
+ static char *inbuf = NULL;
+ static size_t maxlen = 0;
+ char *inptr = NULL;
+ size_t actlen = 0;
+
+ while (actlen < maxlen)
+ {
+ ssize_t n = read (fd, inptr, maxlen - actlen);
+
+ if (n == 0)
+ /* No more text to read. */
+ break;
+
+ if (n == -1)
+ {
+ /* Error while reading. */
+ error (0, errno, _("error while reading the input"));
+ return -1;
+ }
+
+ inptr += n;
+ actlen += n;
+ }
+
+ if (actlen == maxlen)
+ while (1)
+ {
+ ssize_t n;
+
+ /* Increase the buffer. */
+ maxlen += 32768;
+ inbuf = realloc (inbuf, maxlen);
+ if (inbuf == NULL)
+ error (0, errno, _("unable to allocate buffer for input"));
+ inptr = inbuf + actlen;
+
+ do
+ {
+ n = read (fd, inptr, maxlen - actlen);
+
+ if (n == 0)
+ /* No more text to read. */
+ break;
+
+ if (n == -1)
+ {
+ /* Error while reading. */
+ error (0, errno, _("error while reading the input"));
+ return -1;
+ }
+
+ inptr += n;
+ actlen += n;
+ }
+ while (actlen < maxlen);
+
+ if (n == 0)
+ /* Break again so we leave both loops. */
+ break;
+ }
+
+ /* Now we have all the input in the buffer. Process it in one run. */
+ return process_block (tbl, inbuf, actlen, output);
+}
+
+
+static int
+process_file (struct convtable *tbl, FILE *input, FILE *output)
+{
+ /* This should be safe since we use this function only for `stdin' and
+ we haven't read anything so far. */
+ return process_fd (tbl, fileno (input), output);
+}
iconv_charmap.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: dummy-repertoire.c
===================================================================
--- dummy-repertoire.c (nonexistent)
+++ dummy-repertoire.c (revision 520)
@@ -0,0 +1,37 @@
+/* Copyright (C) 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 2001.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+/* For iconv we don't have to handle repertoire maps. Provide dummy
+ definitions to allow the use of linereader.c unchanged. */
+#include
+
+
+uint32_t
+repertoire_find_value (const struct repertoire_t *repertoire, const char *name,
+ size_t len)
+{
+ return ILLEGAL_CHAR_VALUE;
+}
+
+
+const char *
+repertoire_find_symbol (const struct repertoire_t *repertoire, uint32_t ucs)
+{
+ return NULL;
+}
dummy-repertoire.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv.c
===================================================================
--- gconv.c (nonexistent)
+++ gconv.c (revision 520)
@@ -0,0 +1,73 @@
+/* Convert characters in input buffer using conversion descriptor to
+ output buffer.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+#include
+#include
+
+int
+internal_function
+__gconv (__gconv_t cd, const unsigned char **inbuf,
+ const unsigned char *inbufend, unsigned char **outbuf,
+ unsigned char *outbufend, size_t *irreversible)
+{
+ size_t last_step;
+ int result;
+
+ if (cd == (__gconv_t) -1L)
+ return __GCONV_ILLEGAL_DESCRIPTOR;
+
+ last_step = cd->__nsteps - 1;
+
+ assert (irreversible != NULL);
+ *irreversible = 0;
+
+ cd->__data[last_step].__outbuf = outbuf != NULL ? *outbuf : NULL;
+ cd->__data[last_step].__outbufend = outbufend;
+
+ if (inbuf == NULL || *inbuf == NULL)
+ /* We just flush. */
+ result = cd->__steps->__fct (cd->__steps, cd->__data, NULL, NULL, NULL,
+ irreversible,
+ cd->__data[last_step].__outbuf == NULL ? 2 : 1, 0);
+ else
+ {
+ const unsigned char *last_start;
+
+ assert (outbuf != NULL && *outbuf != NULL);
+
+ do
+ {
+ last_start = *inbuf;
+ result = cd->__steps->__fct (cd->__steps, cd->__data, inbuf, inbufend,
+ NULL, irreversible, 0, 0);
+ }
+ while (result == __GCONV_EMPTY_INPUT && last_start != *inbuf
+ && *inbuf + cd->__steps->__min_needed_from <= inbufend);
+ }
+
+ if (outbuf != NULL && *outbuf != NULL)
+ *outbuf = cd->__data[last_step].__outbuf;
+
+ return result;
+}
gconv.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: iconv.c
===================================================================
--- iconv.c (nonexistent)
+++ iconv.c (revision 520)
@@ -0,0 +1,96 @@
+/* Convert characters in input buffer using conversion descriptor to
+ output buffer.
+ Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include /* for NULL */
+#include
+#include
+
+#include
+
+#include
+
+
+size_t
+iconv (iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf,
+ size_t *outbytesleft)
+{
+ __gconv_t gcd = (__gconv_t) cd;
+ char *outstart = outbuf ? *outbuf : NULL;
+ size_t irreversible;
+ int result;
+
+ if (__builtin_expect (inbuf == NULL || *inbuf == NULL, 0))
+ {
+ if (outbuf == NULL || *outbuf == NULL)
+ result = __gconv (gcd, NULL, NULL, NULL, NULL, &irreversible);
+ else
+ result = __gconv (gcd, NULL, NULL, (unsigned char **) outbuf,
+ (unsigned char *) (outstart + *outbytesleft),
+ &irreversible);
+ }
+ else
+ {
+ const char *instart = *inbuf;
+
+ result = __gconv (gcd, (const unsigned char **) inbuf,
+ (const unsigned char *) (*inbuf + *inbytesleft),
+ (unsigned char **) outbuf,
+ (unsigned char *) (*outbuf + *outbytesleft),
+ &irreversible);
+
+ *inbytesleft -= *inbuf - instart;
+ }
+ if (outstart != NULL)
+ *outbytesleft -= *outbuf - outstart;
+
+ switch (__builtin_expect (result, __GCONV_OK))
+ {
+ case __GCONV_ILLEGAL_DESCRIPTOR:
+ __set_errno (EBADF);
+ irreversible = (size_t) -1L;
+ break;
+
+ case __GCONV_ILLEGAL_INPUT:
+ __set_errno (EILSEQ);
+ irreversible = (size_t) -1L;
+ break;
+
+ case __GCONV_FULL_OUTPUT:
+ __set_errno (E2BIG);
+ irreversible = (size_t) -1L;
+ break;
+
+ case __GCONV_INCOMPLETE_INPUT:
+ __set_errno (EINVAL);
+ irreversible = (size_t) -1L;
+ break;
+
+ case __GCONV_EMPTY_INPUT:
+ case __GCONV_OK:
+ /* Nothing. */
+ break;
+
+ default:
+ assert (!"Nothing like this should happen");
+ }
+
+ return irreversible;
+}
iconv.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: localeinfo.h
===================================================================
--- localeinfo.h (nonexistent)
+++ localeinfo.h (revision 520)
@@ -0,0 +1,209 @@
+/* Declarations for internal libc locale interfaces
+ Copyright (C) 1995, 96, 97, 98, 99,2000,2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#ifndef _LOCALEINFO_H
+#define _LOCALEINFO_H 1
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+/* This has to be changed whenever a new locale is defined. */
+#define __LC_LAST 13
+
+#include "loadinfo.h" /* For loaded_l10nfile definition. */
+
+/* Magic number at the beginning of a locale data file for CATEGORY. */
+#define LIMAGIC(category) ((unsigned int) (0x20000828 ^ (category)))
+
+/* Two special weight constants for the collation data. */
+#define IGNORE_CHAR 2
+
+/* We use a special value for the usage counter in `locale_data' to
+ signal that this data must never be removed anymore. */
+#define MAX_USAGE_COUNT (UINT_MAX - 1)
+#define UNDELETABLE UINT_MAX
+
+/* Structure describing locale data in core for a category. */
+struct locale_data
+{
+ const char *name;
+ const char *filedata; /* Region mapping the file data. */
+ off_t filesize; /* Size of the file (and the region). */
+ int mmaped; /* If nonzero the data is mmaped. */
+
+ unsigned int usage_count; /* Counter for users. */
+
+ int use_translit; /* Nonzero if the mb*towv*() and wc*tomb()
+ functions should use transliteration. */
+ const char *options; /* Extra options from the locale name,
+ not used in the path to the locale data. */
+
+ unsigned int nstrings; /* Number of strings below. */
+ union locale_data_value
+ {
+ const uint32_t *wstr;
+ const char *string;
+ unsigned int word;
+ }
+ values __flexarr; /* Items, usually pointers into `filedata'. */
+};
+
+/* We know three kinds of collation sorting rules. */
+enum coll_sort_rule
+{
+ illegal_0__,
+ sort_forward,
+ sort_backward,
+ illegal_3__,
+ sort_position,
+ sort_forward_position,
+ sort_backward_position,
+ sort_mask
+};
+
+/* We can map the types of the entries into a few categories. */
+enum value_type
+{
+ none,
+ string,
+ stringarray,
+ byte,
+ bytearray,
+ word,
+ stringlist,
+ wordarray,
+ wstring,
+ wstringarray,
+ wstringlist
+};
+
+
+/* Definitions for `era' information from LC_TIME. */
+#define ERA_NAME_FORMAT_MEMBERS 4
+#define ERA_M_NAME 0
+#define ERA_M_FORMAT 1
+#define ERA_W_NAME 2
+#define ERA_W_FORMAT 3
+
+
+/* Structure to access `era' information from LC_TIME. */
+struct era_entry
+{
+ uint32_t direction; /* Contains '+' or '-'. */
+ int32_t offset;
+ int32_t start_date[3];
+ int32_t stop_date[3];
+ const char *era_name;
+ const char *era_format;
+ const wchar_t *era_wname;
+ const wchar_t *era_wformat;
+ int absolute_direction;
+ /* absolute direction:
+ +1 indicates that year number is higher in the future. (like A.D.)
+ -1 indicates that year number is higher in the past. (like B.C.) */
+};
+
+
+/* LC_CTYPE specific:
+ Hardwired indices for standard wide character translation mappings. */
+enum
+{
+ __TOW_toupper = 0,
+ __TOW_tolower = 1
+};
+
+
+/* LC_CTYPE specific:
+ Access a wide character class with a single character index.
+ _ISCTYPE (c, desc) = iswctype (btowc (c), desc).
+ c must be an `unsigned char'. desc must be a nonzero wctype_t. */
+#define _ISCTYPE(c, desc) \
+ (((((const uint32_t *) (desc)) - 8)[(c) >> 5] >> ((c) & 0x1f)) & 1)
+
+
+/* For each category declare the variable for the current locale data. */
+#define DEFINE_CATEGORY(category, category_name, items, a) \
+extern struct locale_data *_nl_current_##category;
+#include "categories.def"
+#undef DEFINE_CATEGORY
+
+extern const char *const _nl_category_names[__LC_LAST];
+extern const size_t _nl_category_name_sizes[__LC_LAST];
+extern struct locale_data * *const _nl_current[__LC_LAST];
+
+/* Extract the current CATEGORY locale's string for ITEM. */
+#define _NL_CURRENT(category, item) \
+ (_nl_current_##category->values[_NL_ITEM_INDEX (item)].string)
+
+/* Extract the current CATEGORY locale's string for ITEM. */
+#define _NL_CURRENT_WSTR(category, item) \
+ ((wchar_t *) (_nl_current_##category->values[_NL_ITEM_INDEX (item)].wstr))
+
+/* Extract the current CATEGORY locale's word for ITEM. */
+#define _NL_CURRENT_WORD(category, item) \
+ (_nl_current_##category->values[_NL_ITEM_INDEX (item)].word)
+
+/* This is used in lc-CATEGORY.c to define _nl_current_CATEGORY. */
+#define _NL_CURRENT_DEFINE(category) \
+ extern struct locale_data _nl_C_##category; \
+ struct locale_data *_nl_current_##category = &_nl_C_##category
+
+/* Load the locale data for CATEGORY from the file specified by *NAME.
+ If *NAME is "", use environment variables as specified by POSIX,
+ and fill in *NAME with the actual name used. The directories
+ listed in LOCALE_PATH are searched for the locale files. */
+extern struct locale_data *_nl_find_locale (const char *locale_path,
+ size_t locale_path_len,
+ int category, const char **name);
+
+/* Try to load the file described by FILE. */
+extern void _nl_load_locale (struct loaded_l10nfile *file, int category);
+
+/* Free all resource. */
+extern void _nl_unload_locale (struct locale_data *locale);
+
+/* Free the locale and give back all memory if the usage count is one. */
+extern void _nl_remove_locale (int locale, struct locale_data *data);
+
+
+/* Return `era' entry which corresponds to TP. Used in strftime. */
+extern struct era_entry *_nl_get_era_entry (const struct tm *tp);
+
+/* Return `era' cnt'th entry . Used in strptime. */
+extern struct era_entry *_nl_select_era_entry (int cnt);
+
+/* Return `alt_digit' which corresponds to NUMBER. Used in strftime. */
+extern const char *_nl_get_alt_digit (unsigned int number);
+
+/* Similar, but now for wide characters. */
+extern const wchar_t *_nl_get_walt_digit (unsigned int number);
+
+/* Parse string as alternative digit and return numeric value. */
+extern int _nl_parse_alt_digit (const char **strp);
+
+/* Postload processing. */
+extern void _nl_postload_ctype (void);
+extern void _nl_postload_time (void);
+
+
+#endif /* localeinfo.h */
localeinfo.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_db.c
===================================================================
--- gconv_db.c (nonexistent)
+++ gconv_db.c (revision 520)
@@ -0,0 +1,803 @@
+/* Provide access to the collection of available transformation modules.
+ Copyright (C) 1997,98,99,2000,2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+#include
+
+
+/* Simple data structure for alias mapping. We have two names, `from'
+ and `to'. */
+void *__gconv_alias_db;
+
+/* Array with available modules. */
+struct gconv_module *__gconv_modules_db;
+
+/* We modify global data. */
+__LOCK_INIT(static, lock);
+
+
+/* Function for searching alias. */
+int
+__gconv_alias_compare (const void *p1, const void *p2)
+{
+ const struct gconv_alias *s1 = (const struct gconv_alias *) p1;
+ const struct gconv_alias *s2 = (const struct gconv_alias *) p2;
+ return strcmp (s1->fromname, s2->fromname);
+}
+
+
+/* To search for a derivation we create a list of intermediate steps.
+ Each element contains a pointer to the element which precedes it
+ in the derivation order. */
+struct derivation_step
+{
+ const char *result_set;
+ size_t result_set_len;
+ int cost_lo;
+ int cost_hi;
+ struct gconv_module *code;
+ struct derivation_step *last;
+ struct derivation_step *next;
+};
+
+#define NEW_STEP(result, hi, lo, module, last_mod) \
+ ({ struct derivation_step *newp = alloca (sizeof (struct derivation_step)); \
+ newp->result_set = result; \
+ newp->result_set_len = strlen (result); \
+ newp->cost_hi = hi; \
+ newp->cost_lo = lo; \
+ newp->code = module; \
+ newp->last = last_mod; \
+ newp->next = NULL; \
+ newp; })
+
+
+/* If a specific transformation is used more than once we should not need
+ to start looking for it again. Instead cache each successful result. */
+struct known_derivation
+{
+ const char *from;
+ const char *to;
+ struct __gconv_step *steps;
+ size_t nsteps;
+};
+
+/* Compare function for database of found derivations. */
+static int
+derivation_compare (const void *p1, const void *p2)
+{
+ const struct known_derivation *s1 = (const struct known_derivation *) p1;
+ const struct known_derivation *s2 = (const struct known_derivation *) p2;
+ int result;
+
+ result = strcmp (s1->from, s2->from);
+ if (result == 0)
+ result = strcmp (s1->to, s2->to);
+ return result;
+}
+
+/* The search tree for known derivations. */
+static void *known_derivations;
+
+/* Look up whether given transformation was already requested before. */
+static int
+internal_function
+derivation_lookup (const char *fromset, const char *toset,
+ struct __gconv_step **handle, size_t *nsteps)
+{
+ struct known_derivation key = { fromset, toset, NULL, 0 };
+ struct known_derivation **result;
+
+ result = tfind (&key, &known_derivations, derivation_compare);
+
+ if (result == NULL)
+ return __GCONV_NOCONV;
+
+ *handle = (*result)->steps;
+ *nsteps = (*result)->nsteps;
+
+ /* Please note that we return GCONV_OK even if the last search for
+ this transformation was unsuccessful. */
+ return __GCONV_OK;
+}
+
+/* Add new derivation to list of known ones. */
+static void
+internal_function
+add_derivation (const char *fromset, const char *toset,
+ struct __gconv_step *handle, size_t nsteps)
+{
+ struct known_derivation *new_deriv;
+ size_t fromset_len = strlen (fromset) + 1;
+ size_t toset_len = strlen (toset) + 1;
+
+ new_deriv = (struct known_derivation *)
+ malloc (sizeof (struct known_derivation) + fromset_len + toset_len);
+ if (new_deriv != NULL)
+ {
+ char *tmp;
+ new_deriv->from = (char *) (new_deriv + 1);
+ tmp = memcpy (new_deriv + 1, fromset, fromset_len);
+ tmp += fromset_len;
+
+ new_deriv->to = memcpy (tmp,
+ toset, toset_len);
+
+ new_deriv->steps = handle;
+ new_deriv->nsteps = nsteps;
+
+ if (tsearch (new_deriv, &known_derivations, derivation_compare)
+ == NULL)
+ /* There is some kind of memory allocation problem. */
+ free (new_deriv);
+ }
+ /* Please note that we don't complain if the allocation failed. This
+ is not tragically but in case we use the memory debugging facilities
+ not all memory will be freed. */
+}
+
+static void
+free_derivation (void *p)
+{
+ struct known_derivation *deriv = (struct known_derivation *) p;
+ size_t cnt;
+
+ for (cnt = 0; cnt < deriv->nsteps; ++cnt)
+ if (deriv->steps[cnt].__counter > 0
+ && deriv->steps[cnt].__end_fct != NULL)
+ deriv->steps[cnt].__end_fct (&deriv->steps[cnt]);
+
+ /* Free the name strings. */
+ free ((char *) deriv->steps[0].__from_name);
+ free ((char *) deriv->steps[deriv->nsteps - 1].__to_name);
+
+ free ((struct __gconv_step *) deriv->steps);
+ free (deriv);
+}
+
+
+/* Decrement the reference count for a single step in a steps array. */
+void
+internal_function
+__gconv_release_step (struct __gconv_step *step)
+{
+ if (--step->__counter == 0)
+ {
+ /* Call the destructor. */
+ if (step->__end_fct != NULL)
+ step->__end_fct (step);
+
+#ifndef STATIC_GCONV
+ /* Skip builtin modules; they are not reference counted. */
+ if (step->__shlib_handle != NULL)
+ {
+ /* Release the loaded module. */
+ __gconv_release_shlib (step->__shlib_handle);
+ step->__shlib_handle = NULL;
+ }
+#endif
+ }
+}
+
+static int
+internal_function
+gen_steps (struct derivation_step *best, const char *toset,
+ const char *fromset, struct __gconv_step **handle, size_t *nsteps)
+{
+ size_t step_cnt = 0;
+ struct __gconv_step *result;
+ struct derivation_step *current;
+ int status = __GCONV_NOMEM;
+
+ /* First determine number of steps. */
+ for (current = best; current->last != NULL; current = current->last)
+ ++step_cnt;
+
+ result = (struct __gconv_step *) malloc (sizeof (struct __gconv_step)
+ * step_cnt);
+ if (result != NULL)
+ {
+ int failed = 0;
+
+ status = __GCONV_OK;
+ *nsteps = step_cnt;
+ current = best;
+ while (step_cnt-- > 0)
+ {
+ result[step_cnt].__from_name = (step_cnt == 0
+ ? strdup (fromset)
+ : (char *)current->last->result_set);
+ result[step_cnt].__to_name = (step_cnt + 1 == *nsteps
+ ? strdup (current->result_set)
+ : result[step_cnt + 1].__from_name);
+
+ result[step_cnt].__counter = 1;
+ result[step_cnt].__data = NULL;
+
+#ifndef STATIC_GCONV
+ if (current->code->module_name[0] == '/')
+ {
+ /* Load the module, return handle for it. */
+ struct __gconv_loaded_object *shlib_handle =
+ __gconv_find_shlib (current->code->module_name);
+
+ if (shlib_handle == NULL)
+ {
+ failed = 1;
+ break;
+ }
+
+ result[step_cnt].__shlib_handle = shlib_handle;
+ result[step_cnt].__modname = shlib_handle->name;
+ result[step_cnt].__fct = shlib_handle->fct;
+ result[step_cnt].__init_fct = shlib_handle->init_fct;
+ result[step_cnt].__end_fct = shlib_handle->end_fct;
+
+ /* Call the init function. */
+ if (result[step_cnt].__init_fct != NULL)
+ {
+ status = result[step_cnt].__init_fct (&result[step_cnt]);
+
+ if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
+ {
+ failed = 1;
+ /* Make sure we unload this modules. */
+ --step_cnt;
+ result[step_cnt].__end_fct = NULL;
+ break;
+ }
+ }
+ }
+ else
+#endif
+ /* It's a builtin transformation. */
+ __gconv_get_builtin_trans (current->code->module_name,
+ &result[step_cnt]);
+
+ current = current->last;
+ }
+
+ if (__builtin_expect (failed, 0) != 0)
+ {
+ /* Something went wrong while initializing the modules. */
+ while (++step_cnt < *nsteps)
+ __gconv_release_step (&result[step_cnt]);
+ free (result);
+ *nsteps = 0;
+ *handle = NULL;
+ if (status == __GCONV_OK)
+ status = __GCONV_NOCONV;
+ }
+ else
+ *handle = result;
+ }
+ else
+ {
+ *nsteps = 0;
+ *handle = NULL;
+ }
+
+ return status;
+}
+
+
+#ifndef STATIC_GCONV
+static int
+internal_function
+increment_counter (struct __gconv_step *steps, size_t nsteps)
+{
+ /* Increment the user counter. */
+ size_t cnt = nsteps;
+ int result = __GCONV_OK;
+
+ while (cnt-- > 0)
+ {
+ struct __gconv_step *step = &steps[cnt];
+
+ if (step->__counter++ == 0)
+ {
+ /* Skip builtin modules. */
+ if (step->__modname != NULL)
+ {
+ /* Reopen a previously used module. */
+ step->__shlib_handle = __gconv_find_shlib (step->__modname);
+ if (step->__shlib_handle == NULL)
+ {
+ /* Oops, this is the second time we use this module
+ (after unloading) and this time loading failed!? */
+ --step->__counter;
+ while (++cnt < nsteps)
+ __gconv_release_step (&steps[cnt]);
+ result = __GCONV_NOCONV;
+ break;
+ }
+
+ /* The function addresses defined by the module may
+ have changed. */
+ step->__fct = step->__shlib_handle->fct;
+ step->__init_fct = step->__shlib_handle->init_fct;
+ step->__end_fct = step->__shlib_handle->end_fct;
+ }
+
+ if (step->__init_fct != NULL)
+ step->__init_fct (step);
+ }
+ }
+ return result;
+}
+#endif
+
+
+/* The main function: find a possible derivation from the `fromset' (either
+ the given name or the alias) to the `toset' (again with alias). */
+static int
+internal_function
+find_derivation (const char *toset, const char *toset_expand,
+ const char *fromset, const char *fromset_expand,
+ struct __gconv_step **handle, size_t *nsteps)
+{
+ struct derivation_step *first, *current, **lastp, *solution = NULL;
+ int best_cost_hi = INT_MAX;
+ int best_cost_lo = INT_MAX;
+ int result;
+
+ /* Look whether an earlier call to `find_derivation' has already
+ computed a possible derivation. If so, return it immediately. */
+ result = derivation_lookup (fromset_expand ?: fromset, toset_expand ?: toset,
+ handle, nsteps);
+ if (result == __GCONV_OK)
+ {
+#ifndef STATIC_GCONV
+ result = increment_counter (*handle, *nsteps);
+#endif
+ return result;
+ }
+
+ /* The task is to find a sequence of transformations, backed by the
+ existing modules - whether builtin or dynamically loadable -,
+ starting at `fromset' (or `fromset_expand') and ending at `toset'
+ (or `toset_expand'), and with minimal cost.
+
+ For computer scientists, this is a shortest path search in the
+ graph where the nodes are all possible charsets and the edges are
+ the transformations listed in __gconv_modules_db.
+
+ For now we use a simple algorithm with quadratic runtime behaviour.
+ A breadth-first search, starting at `fromset' and `fromset_expand'.
+ The list starting at `first' contains all nodes that have been
+ visited up to now, in the order in which they have been visited --
+ excluding the goal nodes `toset' and `toset_expand' which get
+ managed in the list starting at `solution'.
+ `current' walks through the list starting at `first' and looks
+ which nodes are reachable from the current node, adding them to
+ the end of the list [`first' or `solution' respectively] (if
+ they are visited the first time) or updating them in place (if
+ they have have already been visited).
+ In each node of either list, cost_lo and cost_hi contain the
+ minimum cost over any paths found up to now, starting at `fromset'
+ or `fromset_expand', ending at that node. best_cost_lo and
+ best_cost_hi represent the minimum over the elements of the
+ `solution' list. */
+
+ if (fromset_expand != NULL)
+ {
+ first = NEW_STEP (fromset_expand, 0, 0, NULL, NULL);
+ first->next = NEW_STEP (fromset, 0, 0, NULL, NULL);
+ lastp = &first->next->next;
+ }
+ else
+ {
+ first = NEW_STEP (fromset, 0, 0, NULL, NULL);
+ lastp = &first->next;
+ }
+
+ for (current = first; current != NULL; current = current->next)
+ {
+ /* Now match all the available module specifications against the
+ current charset name. If any of them matches check whether
+ we already have a derivation for this charset. If yes, use the
+ one with the lower costs. Otherwise add the new charset at the
+ end.
+
+ The module database is organized in a tree form which allows
+ searching for prefixes. So we search for the first entry with a
+ matching prefix and any other matching entry can be found from
+ this place. */
+ struct gconv_module *node;
+
+ /* Maybe it is not necessary anymore to look for a solution for
+ this entry since the cost is already as high (or higher) as
+ the cost for the best solution so far. */
+ if (current->cost_hi > best_cost_hi
+ || (current->cost_hi == best_cost_hi
+ && current->cost_lo >= best_cost_lo))
+ continue;
+
+ node = __gconv_modules_db;
+ while (node != NULL)
+ {
+ int cmpres = strcmp (current->result_set, node->from_string);
+ if (cmpres == 0)
+ {
+ /* Walk through the list of modules with this prefix and
+ try to match the name. */
+ struct gconv_module *runp;
+
+ /* Check all the modules with this prefix. */
+ runp = node;
+ do
+ {
+ const char *result_set = (strcmp (runp->to_string, "-") == 0
+ ? (toset_expand ?: toset)
+ : runp->to_string);
+ int cost_hi = runp->cost_hi + current->cost_hi;
+ int cost_lo = runp->cost_lo + current->cost_lo;
+ struct derivation_step *step;
+
+ /* We managed to find a derivation. First see whether
+ we have reached one of the goal nodes. */
+ if (strcmp (result_set, toset) == 0
+ || (toset_expand != NULL
+ && strcmp (result_set, toset_expand) == 0))
+ {
+ /* Append to the `solution' list if there
+ is no entry with this name. */
+ for (step = solution; step != NULL; step = step->next)
+ if (strcmp (result_set, step->result_set) == 0)
+ break;
+
+ if (step == NULL)
+ {
+ step = NEW_STEP (result_set,
+ cost_hi, cost_lo,
+ runp, current);
+ step->next = solution;
+ solution = step;
+ }
+ else if (step->cost_hi > cost_hi
+ || (step->cost_hi == cost_hi
+ && step->cost_lo > cost_lo))
+ {
+ /* A better path was found for the node,
+ on the `solution' list. */
+ step->code = runp;
+ step->last = current;
+ step->cost_hi = cost_hi;
+ step->cost_lo = cost_lo;
+ }
+
+ /* Update best_cost accordingly. */
+ if (cost_hi < best_cost_hi
+ || (cost_hi == best_cost_hi
+ && cost_lo < best_cost_lo))
+ {
+ best_cost_hi = cost_hi;
+ best_cost_lo = cost_lo;
+ }
+ }
+ else if (cost_hi < best_cost_hi
+ || (cost_hi == best_cost_hi
+ && cost_lo < best_cost_lo))
+ {
+ /* Append at the end of the `first' list if there
+ is no entry with this name. */
+ for (step = first; step != NULL; step = step->next)
+ if (strcmp (result_set, step->result_set) == 0)
+ break;
+
+ if (step == NULL)
+ {
+ *lastp = NEW_STEP (result_set,
+ cost_hi, cost_lo,
+ runp, current);
+ lastp = &(*lastp)->next;
+ }
+ else if (step->cost_hi > cost_hi
+ || (step->cost_hi == cost_hi
+ && step->cost_lo > cost_lo))
+ {
+ /* A better path was found for the node,
+ on the `first' list. */
+ step->code = runp;
+ step->last = current;
+
+ /* Update the cost for all steps. */
+ for (step = first; step != NULL;
+ step = step->next)
+ /* But don't update the start nodes. */
+ if (step->code != NULL)
+ {
+ struct derivation_step *back;
+ int hi, lo;
+
+ hi = step->code->cost_hi;
+ lo = step->code->cost_lo;
+
+ for (back = step->last; back->code != NULL;
+ back = back->last)
+ {
+ hi += back->code->cost_hi;
+ lo += back->code->cost_lo;
+ }
+
+ step->cost_hi = hi;
+ step->cost_lo = lo;
+ }
+
+ /* Likewise for the nodes on the solution list.
+ Also update best_cost accordingly. */
+ for (step = solution; step != NULL;
+ step = step->next)
+ {
+ step->cost_hi = (step->code->cost_hi
+ + step->last->cost_hi);
+ step->cost_lo = (step->code->cost_lo
+ + step->last->cost_lo);
+
+ if (step->cost_hi < best_cost_hi
+ || (step->cost_hi == best_cost_hi
+ && step->cost_lo < best_cost_lo))
+ {
+ best_cost_hi = step->cost_hi;
+ best_cost_lo = step->cost_lo;
+ }
+ }
+ }
+ }
+
+ runp = runp->same;
+ }
+ while (runp != NULL);
+
+ break;
+ }
+ else if (cmpres < 0)
+ node = node->left;
+ else
+ node = node->right;
+ }
+ }
+
+ if (solution != NULL)
+ {
+ /* We really found a way to do the transformation. */
+
+ /* Choose the best solution. This is easy because we know that
+ the solution list has at most length 2 (one for every possible
+ goal node). */
+ if (solution->next != NULL)
+ {
+ struct derivation_step *solution2 = solution->next;
+
+ if (solution2->cost_hi < solution->cost_hi
+ || (solution2->cost_hi == solution->cost_hi
+ && solution2->cost_lo < solution->cost_lo))
+ solution = solution2;
+ }
+
+ /* Now build a data structure describing the transformation steps. */
+ result = gen_steps (solution, toset_expand ?: toset,
+ fromset_expand ?: fromset, handle, nsteps);
+ }
+ else
+ {
+ /* We haven't found a transformation. Clear the result values. */
+ *handle = NULL;
+ *nsteps = 0;
+ }
+
+ /* Add result in any case to list of known derivations. */
+ add_derivation (fromset_expand ?: fromset, toset_expand ?: toset,
+ *handle, *nsteps);
+
+ return result;
+}
+
+
+/* Control of initialization. */
+__libc_once_define (static, once);
+
+
+static const char *
+do_lookup_alias (const char *name)
+{
+ struct gconv_alias key;
+ struct gconv_alias **found;
+
+ key.fromname = (char *) name;
+ found = tfind (&key, &__gconv_alias_db, __gconv_alias_compare);
+ return found != NULL ? (*found)->toname : NULL;
+}
+
+
+int
+internal_function
+__gconv_compare_alias (const char *name1, const char *name2)
+{
+ int result;
+
+ /* Ensure that the configuration data is read. */
+ __libc_once (once, __gconv_read_conf);
+
+ if (__gconv_compare_alias_cache (name1, name2, &result) != 0)
+ result = strcmp (do_lookup_alias (name1) ?: name1,
+ do_lookup_alias (name2) ?: name2);
+
+ return result;
+}
+
+
+int
+internal_function
+__gconv_find_transform (const char *toset, const char *fromset,
+ struct __gconv_step **handle, size_t *nsteps,
+ int flags)
+{
+ const char *fromset_expand;
+ const char *toset_expand;
+ int result;
+
+ /* Ensure that the configuration data is read. */
+ __libc_once (once, __gconv_read_conf);
+
+ /* Acquire the lock. */
+#ifdef HAVE_DD_LOCK
+ __lock_acquire(lock);
+#endif
+
+ result = __gconv_lookup_cache (toset, fromset, handle, nsteps, flags);
+ if (result != __GCONV_NODB)
+ {
+ /* We have a cache and could resolve the request, successful or not. */
+#ifdef HAVE_DD_LOCK
+ __lock_release(lock);
+#endif
+
+ return result;
+ }
+
+ /* If we don't have a module database return with an error. */
+ if (__gconv_modules_db == NULL)
+ {
+#ifdef HAVE_DD_LOCK
+ __lock_release(lock);
+#endif
+
+ return __GCONV_NOCONV;
+ }
+
+ /* See whether the names are aliases. */
+ fromset_expand = do_lookup_alias (fromset);
+ toset_expand = do_lookup_alias (toset);
+
+ if (__builtin_expect (flags & GCONV_AVOID_NOCONV, 0)
+ /* We are not supposed to create a pseudo transformation (means
+ copying) when the input and output character set are the same. */
+ && (strcmp (toset, fromset) == 0
+ || (toset_expand != NULL && strcmp (toset_expand, fromset) == 0)
+ || (fromset_expand != NULL
+ && (strcmp (toset, fromset_expand) == 0
+ || (toset_expand != NULL
+ && strcmp (toset_expand, fromset_expand) == 0)))))
+ {
+ /* Both character sets are the same. */
+#ifdef HAVE_DD_LOCK
+ __lock_release(lock);
+#endif
+
+ return __GCONV_NOCONV;
+ }
+
+ result = find_derivation (toset, toset_expand, fromset, fromset_expand,
+ handle, nsteps);
+
+ /* Release the lock. */
+#ifdef HAVE_DD_LOCK
+ __lock_release(lock);
+#endif
+
+
+ /* The following code is necessary since `find_derivation' will return
+ GCONV_OK even when no derivation was found but the same request
+ was processed before. I.e., negative results will also be cached. */
+ return (result == __GCONV_OK
+ ? (*handle == NULL ? __GCONV_NOCONV : __GCONV_OK)
+ : result);
+}
+
+
+/* Release the entries of the modules list. */
+int
+internal_function
+__gconv_close_transform (struct __gconv_step *steps, size_t nsteps)
+{
+ int result = __GCONV_OK;
+ size_t cnt;
+
+ /* Acquire the lock. */
+#ifdef HAVE_DD_LOCK
+ __lock_acquire(lock);
+#endif
+
+
+#ifndef STATIC_GCONV
+ cnt = nsteps;
+ while (cnt-- > 0)
+ __gconv_release_step (&steps[cnt]);
+#endif
+
+ /* If we use the cache we free a bit more since we don't keep any
+ transformation records around, they are cheap enough to
+ recreate. */
+ __gconv_release_cache (steps, nsteps);
+
+ /* Release the lock. */
+#ifdef HAVE_DD_LOCK
+ __lock_release(lock);
+#endif
+
+
+ return result;
+}
+
+
+/* Free the modules mentioned. */
+static void
+internal_function
+free_modules_db (struct gconv_module *node)
+{
+ if (node->left != NULL)
+ free_modules_db (node->left);
+ if (node->right != NULL)
+ free_modules_db (node->right);
+ do
+ {
+ struct gconv_module *act = node;
+ node = node->same;
+ if (act->module_name[0] == '/')
+ free (act);
+ }
+ while (node != NULL);
+}
+
+
+/* Free all resources if necessary. */
+static void __attribute__ ((unused))
+free_mem (void)
+{
+ if (__gconv_alias_db != NULL)
+ tdestroy (__gconv_alias_db, free);
+
+ if (__gconv_modules_db != NULL)
+ free_modules_db (__gconv_modules_db);
+
+ if (known_derivations != NULL)
+ tdestroy (known_derivations, free_derivation);
+}
+
+text_set_element (__libc_subfreeres, free_mem);
gconv_db.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_conf.c
===================================================================
--- gconv_conf.c (nonexistent)
+++ gconv_conf.c (revision 520)
@@ -0,0 +1,680 @@
+/* Handle configuration data.
+ Copyright (C) 1997,98,99,2000,2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+
+/* This is the default path where we look for module lists. */
+static const char default_gconv_path[] = GCONV_PATH;
+
+/* The path elements, as determined by the __gconv_get_path function.
+ All path elements end in a slash. */
+struct path_elem *__gconv_path_elem;
+/* Maximum length of a single path element in __gconv_path_elem. */
+size_t __gconv_max_path_elem_len;
+
+/* We use the following struct if we couldn't allocate memory. */
+static const struct path_elem empty_path_elem;
+
+/* Name of the file containing the module information in the directories
+ along the path. */
+static const char gconv_conf_filename[] = "gconv-modules";
+
+/* Filename extension for the modules. */
+#ifndef MODULE_EXT
+# define MODULE_EXT ".so"
+#endif
+static const char gconv_module_ext[] = MODULE_EXT;
+
+/* We have a few builtin transformations. */
+static struct gconv_module builtin_modules[] =
+{
+#define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, MinF, MaxF, \
+ MinT, MaxT) \
+ { \
+ from_string: From, \
+ to_string: To, \
+ cost_hi: Cost, \
+ cost_lo: INT_MAX, \
+ module_name: Name \
+ },
+#define BUILTIN_ALIAS(From, To)
+
+#include "gconv_builtin.h"
+};
+
+#undef BUILTIN_TRANSFORMATION
+#undef BUILTIN_ALIAS
+
+static const char *builtin_aliases[] =
+{
+#define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, MinF, MaxF, \
+ MinT, MaxT)
+#define BUILTIN_ALIAS(From, To) From " " To,
+
+#include "gconv_builtin.h"
+};
+
+#ifdef USE_IN_LIBIO
+# include
+# define __getdelim(line, len, c, fp) _IO_getdelim (line, len, c, fp)
+#endif
+
+
+/* Value of the GCONV_PATH environment variable. */
+const char *__gconv_path_envvar;
+
+
+/* Test whether there is already a matching module known. */
+static int
+internal_function
+detect_conflict (const char *alias)
+{
+ struct gconv_module *node = __gconv_modules_db;
+
+ while (node != NULL)
+ {
+ int cmpres = strcmp (alias, node->from_string);
+
+ if (cmpres == 0)
+ /* We have a conflict. */
+ return 1;
+ else if (cmpres < 0)
+ node = node->left;
+ else
+ node = node->right;
+ }
+
+ return node != NULL;
+}
+
+
+/* Add new alias. */
+static inline void
+add_alias (char *rp, void *modules)
+{
+ /* We now expect two more string. The strings are normalized
+ (converted to UPPER case) and strored in the alias database. */
+ struct gconv_alias *new_alias;
+ char *from, *to, *wp;
+ char old_locale[20], *old_locale_p;
+
+ /* Set locale to default C locale. */
+ old_locale_p = setlocale(LC_ALL, "C");
+ strncpy(old_locale, old_locale_p, 20);
+
+ while (isspace (*rp))
+ ++rp;
+ from = wp = rp;
+ while (*rp != '\0' && !isspace (*rp))
+ *wp++ = toupper (*rp++);
+ if (*rp == '\0')
+ {
+ setlocale(LC_ALL, old_locale);
+ /* There is no `to' string on the line. Ignore it. */
+ return;
+ }
+ *wp++ = '\0';
+ to = ++rp;
+ while (isspace (*rp))
+ ++rp;
+ while (*rp != '\0' && !isspace (*rp))
+ *wp++ = toupper (*rp++);
+ if (to == wp)
+ {
+ setlocale(LC_ALL, old_locale);
+ /* No `to' string, ignore the line. */
+ return;
+ }
+ *wp++ = '\0';
+
+ /* Test whether this alias conflicts with any available module. */
+ if (detect_conflict (from))
+ {
+ setlocale(LC_ALL, old_locale);
+ /* It does conflict, don't add the alias. */
+ return;
+ }
+
+ new_alias = (struct gconv_alias *) malloc (sizeof (struct gconv_alias) + (wp - from));
+ if (new_alias != NULL)
+ {
+ void **inserted;
+
+ new_alias->fromname = memcpy ((char *) new_alias
+ + sizeof (struct gconv_alias),
+ from, wp - from);
+ new_alias->toname = new_alias->fromname + (to - from);
+
+ inserted = (void **) tsearch (new_alias, &__gconv_alias_db,
+ __gconv_alias_compare);
+ if (inserted == NULL || *inserted != new_alias)
+ /* Something went wrong, free this entry. */
+ free (new_alias);
+ }
+ setlocale(LC_ALL, old_locale);
+}
+
+
+/* Insert a data structure for a new module in the search tree. */
+static inline void
+internal_function
+insert_module (struct gconv_module *newp, int tobefreed)
+{
+ struct gconv_module **rootp = &__gconv_modules_db;
+
+ while (*rootp != NULL)
+ {
+ struct gconv_module *root = *rootp;
+ int cmpres;
+
+ cmpres = strcmp (newp->from_string, root->from_string);
+ if (cmpres == 0)
+ {
+ /* Both strings are identical. Insert the string at the
+ end of the `same' list if it is not already there. */
+ while (strcmp (newp->from_string, root->from_string) != 0
+ || strcmp (newp->to_string, root->to_string) != 0)
+ {
+ rootp = &root->same;
+ root = *rootp;
+ if (root == NULL)
+ break;
+ }
+
+ if (root != NULL)
+ {
+ /* This is a no new conversion. But maybe the cost is
+ better. */
+ if (newp->cost_hi < root->cost_hi
+ || (newp->cost_hi == root->cost_hi
+ && newp->cost_lo < root->cost_lo))
+ {
+ newp->left = root->left;
+ newp->right = root->right;
+ newp->same = root->same;
+ *rootp = newp;
+
+ free (root);
+ }
+ else if (tobefreed)
+ free (newp);
+ return;
+ }
+
+ break;
+ }
+ else if (cmpres < 0)
+ rootp = &root->left;
+ else
+ rootp = &root->right;
+ }
+
+ /* Plug in the new node here. */
+ *rootp = newp;
+}
+
+
+/* Add new module. */
+static void
+internal_function
+add_module (char *rp, const char *directory, size_t dir_len, void **modules,
+ size_t *nmodules, int modcounter)
+{
+ /* We expect now
+ 1. `from' name
+ 2. `to' name
+ 3. filename of the module
+ 4. an optional cost value
+ */
+ struct gconv_alias fake_alias;
+ struct gconv_module *new_module;
+ char *from, *to, *module, *wp;
+ int need_ext;
+ int cost_hi;
+ char old_locale[20], *old_locale_p;
+ char *old;
+ size_t len;
+ char *new;
+
+ /* Set locale to default C locale. */
+ old_locale_p = setlocale(LC_ALL, "C");
+ strncpy(old_locale, old_locale_p, 20);
+
+ while (isspace (*rp))
+ ++rp;
+ from = rp;
+ while (*rp != '\0' && !isspace (*rp))
+ {
+ *rp = toupper (*rp);
+ ++rp;
+ }
+ if (*rp == '\0')
+ {
+ setlocale(LC_ALL, old_locale);
+ return;
+ }
+ *rp++ = '\0';
+ to = wp = rp;
+ while (isspace (*rp))
+ {
+ setlocale(LC_ALL, old_locale);
+ ++rp;
+ }
+ while (*rp != '\0' && !isspace (*rp))
+ *wp++ = toupper (*rp++);
+ if (*rp == '\0')
+ {
+ setlocale(LC_ALL, old_locale);
+ return;
+ }
+ *wp++ = '\0';
+ do
+ ++rp;
+ while (isspace (*rp));
+ module = wp;
+ while (*rp != '\0' && !isspace (*rp))
+ *wp++ = *rp++;
+ if (*rp == '\0')
+ {
+ /* There is no cost, use one by default. */
+ *wp++ = '\0';
+ cost_hi = 1;
+ }
+ else
+ {
+ /* There might be a cost value. */
+ char *endp;
+
+ *wp++ = '\0';
+ cost_hi = strtol (rp, &endp, 10);
+ if (rp == endp || cost_hi < 1)
+ /* No useful information. */
+ cost_hi = 1;
+ }
+
+ if (module[0] == '\0')
+ {
+ setlocale(LC_ALL, old_locale);
+ /* No module name given. */
+ return;
+ }
+ if (module[0] == '/')
+ dir_len = 0;
+
+ /* See whether we must add the ending. */
+ need_ext = 0;
+ if (wp - module < (ptrdiff_t) sizeof (gconv_module_ext)
+ || memcmp (wp - sizeof (gconv_module_ext), gconv_module_ext,
+ sizeof (gconv_module_ext)) != 0)
+ /* We must add the module extension. */
+ need_ext = sizeof (gconv_module_ext) - 1;
+
+ /* See whether we have already an alias with this name defined. */
+ old = from;
+ len = strnlen (old, to - from);
+ new = (char *) alloca (len + 1);
+ new[len] = '\0';
+ fake_alias.fromname = (char *) memcpy (new, old, len);
+
+ if (tfind (&fake_alias, &__gconv_alias_db, __gconv_alias_compare) != NULL)
+ {
+ setlocale(LC_ALL, old_locale);
+ /* This module duplicates an alias. */
+ return;
+ }
+
+ new_module = (struct gconv_module *) calloc (1,
+ sizeof (struct gconv_module)
+ + (wp - from)
+ + dir_len + need_ext);
+ if (new_module != NULL)
+ {
+ char *tmp;
+
+ new_module->from_string = tmp = (char *) (new_module + 1);
+ tmp = memcpy (tmp, from, to - from);
+ tmp += (to - from);
+
+ new_module->to_string = tmp;
+ tmp = memcpy (tmp, to, module - to);
+ tmp += (module - to);
+
+ new_module->cost_hi = cost_hi;
+ new_module->cost_lo = modcounter;
+
+ new_module->module_name = tmp;
+
+ if (dir_len != 0)
+ {
+ tmp = memcpy (tmp, directory, dir_len);
+ tmp += dir_len;
+ }
+
+ tmp = memcpy (tmp, module, wp - module);
+ tmp += (wp - module);
+
+ if (need_ext)
+ memcpy (tmp - 1, gconv_module_ext, sizeof (gconv_module_ext));
+
+ /* Now insert the new module data structure in our search tree. */
+ insert_module (new_module, 1);
+ }
+ setlocale(LC_ALL, old_locale);
+}
+
+
+/* Read the next configuration file. */
+static void
+internal_function
+read_conf_file (const char *filename, const char *directory, size_t dir_len,
+ void **modules, size_t *nmodules)
+{
+ FILE *fp = fopen (filename, "r");
+ char *line = NULL;
+ size_t line_len = 0;
+ static int modcounter;
+ char old_locale[20], *old_locale_p;
+
+ /* Don't complain if a file is not present or readable, simply silently
+ ignore it. */
+ if (fp == NULL)
+ return;
+
+ /* Set locale to default C locale. */
+ old_locale_p = setlocale(LC_ALL, "C");
+ strncpy(old_locale, old_locale_p, 20);
+
+ /* Process the known entries of the file. Comments start with `#' and
+ end with the end of the line. Empty lines are ignored. */
+ while (!feof (fp))
+ {
+ char *rp, *endp, *word;
+ ssize_t n = __getdelim (&line, &line_len, '\n', fp);
+ if (n < 0)
+ /* An error occurred. */
+ break;
+
+ rp = line;
+ /* Terminate the line (excluding comments or newline) by an NUL byte
+ to simplify the following code. */
+ endp = strchr (rp, '#');
+ if (endp != NULL)
+ *endp = '\0';
+ else
+ if (rp[n - 1] == '\n')
+ rp[n - 1] = '\0';
+
+ while (isspace (*rp))
+ ++rp;
+
+ /* If this is an empty line go on with the next one. */
+ if (rp == endp)
+ continue;
+
+ word = rp;
+ while (*rp != '\0' && !isspace (*rp))
+ ++rp;
+
+ if (rp - word == sizeof ("alias") - 1
+ && memcmp (word, "alias", sizeof ("alias") - 1) == 0)
+ add_alias (rp, *modules);
+ else if (rp - word == sizeof ("module") - 1
+ && memcmp (word, "module", sizeof ("module") - 1) == 0)
+ add_module (rp, directory, dir_len, modules, nmodules, modcounter++);
+ /* else */
+ /* Otherwise ignore the line. */
+ }
+
+ free (line);
+
+ fclose (fp);
+
+ setlocale(LC_ALL, old_locale);
+}
+
+
+/* Determine the directories we are looking for data in. */
+void
+__gconv_get_path (void)
+{
+ struct path_elem *result;
+ __LOCK_INIT(static, path_lock);
+
+#ifdef HAVE_DD_LOCK
+ __lock_acquire(path_lock);
+#endif
+
+ /* Make sure there wasn't a second thread doing it already. */
+ result = (struct path_elem *) __gconv_path_elem;
+ if (result == NULL)
+ {
+ /* Determine the complete path first. */
+ char *gconv_path;
+ size_t gconv_path_len;
+ char *elem;
+ char *oldp;
+ char *cp;
+ int nelems;
+ char *cwd;
+ size_t cwdlen;
+
+ if (__gconv_path_envvar == NULL)
+ {
+ char * old = default_gconv_path;
+ size_t len = strlen (old) + 1;
+ char *new = (char *) alloca (len);
+
+ /* No user-defined path. Make a modifiable copy of the
+ default path. */
+ gconv_path = (char *) memcpy (new, old, len);
+ gconv_path_len = sizeof (default_gconv_path);
+ cwd = NULL;
+ cwdlen = 0;
+ }
+ else
+ {
+ /* Append the default path to the user-defined path. */
+ size_t user_len = strlen (__gconv_path_envvar);
+ char *tmp;
+
+ gconv_path_len = user_len + 1 + sizeof (default_gconv_path);
+ gconv_path = alloca (gconv_path_len);
+ tmp = memcpy (gconv_path, __gconv_path_envvar,
+ user_len);
+ tmp += user_len;
+ memcpy (tmp, ":", 1);
+ tmp += 1;
+ memcpy (tmp,
+ default_gconv_path, sizeof (default_gconv_path));
+
+ cwd = getcwd (NULL, 0);
+ cwdlen = strlen (cwd);
+ }
+ assert (default_gconv_path[0] == '/');
+
+ /* In a first pass we calculate the number of elements. */
+ oldp = NULL;
+ cp = strchr (gconv_path, ':');
+ nelems = 1;
+ while (cp != NULL)
+ {
+ if (cp != oldp + 1)
+ ++nelems;
+ oldp = cp;
+ cp = strchr (cp + 1, ':');
+ }
+
+ /* Allocate the memory for the result. */
+ result = (struct path_elem *) malloc ((nelems + 1)
+ * sizeof (struct path_elem)
+ + gconv_path_len + nelems
+ + (nelems - 1) * (cwdlen + 1));
+ if (result != NULL)
+ {
+ char *strspace = (char *) &result[nelems + 1];
+ int n = 0;
+
+ /* Separate the individual parts. */
+ __gconv_max_path_elem_len = 0;
+ elem = strtok_r (gconv_path, ":", &gconv_path);
+ assert (elem != NULL);
+ do
+ {
+ result[n].name = strspace;
+ if (elem[0] != '/')
+ {
+ assert (cwd != NULL);
+ strspace = memcpy (strspace, cwd, cwdlen);
+ strspace += cwdlen;
+ *strspace++ = '/';
+ }
+ strspace = strcpy (strspace, elem);
+ while(*strspace != '\0') strspace++;
+
+ if (strspace[-1] != '/')
+ *strspace++ = '/';
+
+ result[n].len = strspace - result[n].name;
+ if (result[n].len > __gconv_max_path_elem_len)
+ __gconv_max_path_elem_len = result[n].len;
+
+ *strspace++ = '\0';
+ ++n;
+ }
+ while ((elem = strtok_r (NULL, ":", &gconv_path)) != NULL);
+
+ result[n].name = NULL;
+ result[n].len = 0;
+ }
+
+ __gconv_path_elem = result ?: (struct path_elem *) &empty_path_elem;
+
+ if (cwd != NULL)
+ free (cwd);
+ }
+
+#ifdef HAVE_DD_LOCK
+ __lock_release(path_lock);
+#endif
+}
+
+
+/* Read all configuration files found in the user-specified and the default
+ path. */
+void
+__gconv_read_conf (void)
+{
+ void *modules = NULL;
+ size_t nmodules = 0;
+ int save_errno = errno;
+ size_t cnt;
+ char *filename;
+ char *tmp;
+ const char *elem;
+ size_t elem_len;
+
+ /* First see whether we should use the cache. */
+ if (__gconv_load_cache () == 0)
+ {
+ /* Yes, we are done. */
+ __set_errno (save_errno);
+ return;
+ }
+
+#ifndef STATIC_GCONV
+ /* Find out where we have to look. */
+ if (__gconv_path_elem == NULL)
+ __gconv_get_path ();
+
+ for (cnt = 0; __gconv_path_elem[cnt].name != NULL; ++cnt)
+ {
+ elem = __gconv_path_elem[cnt].name;
+ elem_len = __gconv_path_elem[cnt].len;
+
+ /* No slash needs to be inserted between elem and gconv_conf_filename;
+ elem already ends in a slash. */
+ filename = alloca (elem_len + sizeof (gconv_conf_filename));
+ tmp = memcpy (filename, elem, elem_len);
+ tmp += elem_len;
+ memcpy (tmp, gconv_conf_filename, sizeof (gconv_conf_filename));
+
+ /* Read the next configuration file. */
+ read_conf_file (filename, elem, elem_len, &modules, &nmodules);
+ }
+#endif
+
+ /* Add the internal modules. */
+ for (cnt = 0; cnt < sizeof (builtin_modules) / sizeof (builtin_modules[0]);
+ ++cnt)
+ {
+ struct gconv_alias fake_alias;
+
+ fake_alias.fromname = (char *) builtin_modules[cnt].from_string;
+
+ if (tfind (&fake_alias, &__gconv_alias_db, __gconv_alias_compare)
+ != NULL)
+ /* It'll conflict so don't add it. */
+ continue;
+
+ insert_module (&builtin_modules[cnt], 0);
+ }
+
+ /* Add aliases for builtin conversions. */
+ cnt = sizeof (builtin_aliases) / sizeof (builtin_aliases[0]);
+ while (cnt > 0)
+ {
+ char * old = builtin_aliases[--cnt];
+ size_t len = strlen (old) + 1;
+ char *new = (char *) alloca (len);
+ char *copy = (char *) memcpy (new, old, len);
+
+ add_alias (copy, modules);
+ }
+
+ /* Restore the error number. */
+ __set_errno (save_errno);
+}
+
+
+
+/* Free all resources if necessary. */
+static void __attribute__ ((unused))
+free_mem (void)
+{
+ if (__gconv_path_elem != NULL && __gconv_path_elem != &empty_path_elem)
+ free ((void *) __gconv_path_elem);
+}
+
+text_set_element (__libc_subfreeres, free_mem);
gconv_conf.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_trans.c
===================================================================
--- gconv_trans.c (nonexistent)
+++ gconv_trans.c (revision 520)
@@ -0,0 +1,230 @@
+/* Transliteration using the locale's data.
+ Copyright (C) 2000 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 2000.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "gconv_int.h"
+#include "localeinfo.h"
+
+int
+__gconv_transliterate (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ void *trans_data __attribute__ ((unused)),
+ const unsigned char *inbufstart,
+ const unsigned char **inbufp,
+ const unsigned char *inbufend,
+ unsigned char **outbufstart, size_t *irreversible)
+{
+ return 0;
+}
+
+
+/* Structure to represent results of found (or not) transliteration
+ modules. */
+struct known_trans
+{
+ /* This structure must remain the first member. */
+ struct trans_struct info;
+
+ char *fname;
+ void *handle;
+ int open_count;
+};
+
+
+/* Tree with results of previous calls to __gconv_translit_find. */
+static void *search_tree;
+
+/* We modify global data. */
+__LOCK_INIT(static, lock);
+
+/* Compare two transliteration entries. */
+static int
+trans_compare (const void *p1, const void *p2)
+{
+ const struct known_trans *s1 = (const struct known_trans *) p1;
+ const struct known_trans *s2 = (const struct known_trans *) p2;
+
+ return strcmp (s1->info.name, s2->info.name);
+}
+
+
+/* Open (maybe reopen) the module named in the struct. Get the function
+ and data structure pointers we need. */
+static int
+open_translit (struct known_trans *trans)
+{
+ __gconv_trans_query_fct queryfct;
+
+ trans->handle = __libc_dlopen (trans->fname);
+ if (trans->handle == NULL)
+ /* Not available. */
+ return 1;
+
+ /* Find the required symbol. */
+ queryfct = __libc_dlsym (trans->handle, "gconv_trans_context");
+ if (queryfct == NULL)
+ {
+ /* We cannot live with that. */
+ close_and_out:
+ __libc_dlclose (trans->handle);
+ trans->handle = NULL;
+ return 1;
+ }
+
+ /* Get the context. */
+ if (queryfct (trans->info.name, &trans->info.csnames, &trans->info.ncsnames)
+ != 0)
+ goto close_and_out;
+
+ /* Of course we also have to have the actual function. */
+ trans->info.trans_fct = __libc_dlsym (trans->handle, "gconv_trans");
+ if (trans->info.trans_fct == NULL)
+ goto close_and_out;
+
+ /* Now the optional functions. */
+ trans->info.trans_init_fct =
+ __libc_dlsym (trans->handle, "gconv_trans_init");
+ trans->info.trans_context_fct =
+ __libc_dlsym (trans->handle, "gconv_trans_context");
+ trans->info.trans_end_fct =
+ __libc_dlsym (trans->handle, "gconv_trans_end");
+
+ trans->open_count = 1;
+
+ return 0;
+}
+
+
+int
+internal_function
+__gconv_translit_find (struct trans_struct *trans)
+{
+ struct known_trans **found;
+ const struct path_elem *runp;
+ int res = 1;
+
+ /* We have to have a name. */
+ assert (trans->name != NULL);
+
+ /* Acquire the lock. */
+#ifdef HAVE_DD_LOCK
+ __lock_acquire(lock);
+#endif
+
+ /* See whether we know this module already. */
+ found = tfind (trans, &search_tree, trans_compare);
+ if (found != NULL)
+ {
+ /* Is this module available? */
+ if ((*found)->handle != NULL)
+ {
+ /* Maybe we have to reopen the file. */
+ if ((*found)->handle != (void *) -1)
+ /* The object is not unloaded. */
+ res = 0;
+ else if (open_translit (*found) == 0)
+ {
+ /* Copy the data. */
+ *trans = (*found)->info;
+ (*found)->open_count++;
+ res = 0;
+ }
+ }
+ }
+ else
+ {
+ size_t name_len = strlen (trans->name) + 1;
+ int need_so = 0;
+ struct known_trans *newp;
+
+ /* We have to continue looking for the module. */
+ if (__gconv_path_elem == NULL)
+ __gconv_get_path ();
+
+ /* See whether we have to append .so. */
+ if (name_len <= 4 || memcmp (&trans->name[name_len - 4], ".so", 3) != 0)
+ need_so = 1;
+
+ /* Create a new entry. */
+ newp = (struct known_trans *) malloc (sizeof (struct known_trans)
+ + (__gconv_max_path_elem_len
+ + name_len + 3)
+ + name_len);
+ if (newp != NULL)
+ {
+ char *cp;
+
+ /* Clear the struct. */
+ memset (newp, '\0', sizeof (struct known_trans));
+
+ /* Store a copy of the module name. */
+ newp->info.name = cp = (char *) (newp + 1);
+ cp = memcpy (cp, trans->name, name_len);
+ cp += name_len;
+
+ newp->fname = cp;
+
+ /* Search in all the directories. */
+ for (runp = __gconv_path_elem; runp->name != NULL; ++runp)
+ {
+ strcpy ((char *) newp->fname, runp->name);
+ while(newp->fname != '\0') newp->fname++;
+
+ cp = memcpy (newp->fname,
+ trans->name, name_len);
+ cp += name_len;
+ if (need_so)
+ memcpy (cp, ".so", sizeof (".so"));
+
+ if (open_translit (newp) == 0)
+ {
+ /* We found a module. */
+ res = 0;
+ break;
+ }
+ }
+
+ if (res)
+ newp->fname = NULL;
+
+ /* In any case we'll add the entry to our search tree. */
+ if (tsearch (newp, &search_tree, trans_compare) == NULL)
+ {
+ /* Yickes, this should not happen. Unload the object. */
+ res = 1;
+ /* XXX unload here. */
+ }
+ }
+ }
+
+#ifdef HAVE_DD_LOCK
+ __lock_release(lock);
+#endif
+
+ return res;
+}
gconv_trans.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: iconv.h
===================================================================
--- iconv.h (nonexistent)
+++ iconv.h (revision 520)
@@ -0,0 +1,51 @@
+/* Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#ifndef _ICONV_H
+#define _ICONV_H 1
+
+#include
+#define __need_size_t
+#include
+
+
+__BEGIN_DECLS
+
+/* Identifier for conversion method from one codeset to another. */
+typedef void *iconv_t;
+
+
+/* Allocate descriptor for code conversion from codeset FROMCODE to
+ codeset TOCODE. */
+extern iconv_t iconv_open (__const char *__tocode, __const char *__fromcode)
+ __THROW;
+
+/* Convert at most *INBYTESLEFT bytes from *INBUF according to the
+ code conversion algorithm specified by CD and place up to
+ *OUTBYTESLEFT bytes in buffer at *OUTBUF. */
+extern size_t iconv (iconv_t __cd, char **__restrict __inbuf,
+ size_t *__restrict __inbytesleft,
+ char **__restrict __outbuf,
+ size_t *__restrict __outbytesleft);
+
+/* Free resources allocated for descriptor CD for code conversion. */
+extern int iconv_close (iconv_t __cd) __THROW;
+
+__END_DECLS
+
+#endif /* iconv.h */
iconv.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: skeleton.c
===================================================================
--- skeleton.c (nonexistent)
+++ skeleton.c (revision 520)
@@ -0,0 +1,696 @@
+/* Skeleton for a conversion module.
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1998.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+/* This file can be included to provide definitions of several things
+ many modules have in common. It can be customized using the following
+ macros:
+
+ DEFINE_INIT define the default initializer. This requires the
+ following symbol to be defined.
+
+ CHARSET_NAME string with official name of the coded character
+ set (in all-caps)
+
+ DEFINE_FINI define the default destructor function.
+
+ MIN_NEEDED_FROM minimal number of bytes needed for the from-charset.
+ MIN_NEEDED_TO likewise for the to-charset.
+
+ MAX_NEEDED_FROM maximal number of bytes needed for the from-charset.
+ This macro is optional, it defaults to MIN_NEEDED_FROM.
+ MAX_NEEDED_TO likewise for the to-charset.
+
+ DEFINE_DIRECTION_OBJECTS
+ two objects will be defined to be used when the
+ `gconv' function must only distinguish two
+ directions. This is implied by DEFINE_INIT.
+ If this macro is not defined the following
+ macro must be available.
+
+ FROM_DIRECTION this macro is supposed to return a value != 0
+ if we convert from the current character set,
+ otherwise it return 0.
+
+ EMIT_SHIFT_TO_INIT this symbol is optional. If it is defined it
+ defines some code which writes out a sequence
+ of characters which bring the current state into
+ the initial state.
+
+ FROM_LOOP name of the function implementing the conversion
+ from the current characters.
+ TO_LOOP likewise for the other direction
+
+ ONE_DIRECTION optional. If defined to 1, only one conversion
+ direction is defined instead of two. In this
+ case, FROM_DIRECTION should be defined to 1, and
+ FROM_LOOP and TO_LOOP should have the same value.
+
+ SAVE_RESET_STATE in case of an error we must reset the state for
+ the rerun so this macro must be defined for
+ stateful encodings. It takes an argument which
+ is nonzero when saving.
+
+ RESET_INPUT_BUFFER If the input character sets allow this the macro
+ can be defined to reset the input buffer pointers
+ to cover only those characters up to the error.
+
+ FUNCTION_NAME if not set the conversion function is named `gconv'.
+
+ PREPARE_LOOP optional code preparing the conversion loop. Can
+ contain variable definitions.
+ END_LOOP also optional, may be used to store information
+
+ EXTRA_LOOP_ARGS optional macro specifying extra arguments passed
+ to loop function.
+ */
+
+#include
+#include
+#include
+#define __need_size_t
+#define __need_NULL
+#include
+
+#include
+
+#ifndef STATIC_GCONV
+# include
+#endif
+
+# define DL_CALL_FCT(fct, args) fct args
+
+/* The direction objects. */
+#if DEFINE_DIRECTION_OBJECTS || DEFINE_INIT
+static int from_object;
+static int to_object;
+
+# ifndef FROM_DIRECTION
+# define FROM_DIRECTION (step->__data == &from_object)
+# endif
+#else
+# ifndef FROM_DIRECTION
+# error "FROM_DIRECTION must be provided if direction objects are not used"
+# endif
+#endif
+
+
+/* How many bytes are needed at most for the from-charset. */
+#ifndef MAX_NEEDED_FROM
+# define MAX_NEEDED_FROM MIN_NEEDED_FROM
+#endif
+
+/* Same for the to-charset. */
+#ifndef MAX_NEEDED_TO
+# define MAX_NEEDED_TO MIN_NEEDED_TO
+#endif
+
+
+/* Define macros which can access unaligned buffers. These macros are
+ supposed to be used only in code outside the inner loops. For the inner
+ loops we have other definitions which allow optimized access. */
+#ifdef _STRING_ARCH_unaligned
+/* We can handle unaligned memory access. */
+# define get16u(addr) *((__const uint16_t *) (addr))
+# define get32u(addr) *((__const uint32_t *) (addr))
+
+/* We need no special support for writing values either. */
+# define put16u(addr, val) *((uint16_t *) (addr)) = (val)
+# define put32u(addr, val) *((uint32_t *) (addr)) = (val)
+#else
+/* Distinguish between big endian and little endian. */
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+# define get16u(addr) \
+ (((__const unsigned char *) (addr))[1] << 8 \
+ | ((__const unsigned char *) (addr))[0])
+# define get32u(addr) \
+ (((((__const unsigned char *) (addr))[3] << 8 \
+ | ((__const unsigned char *) (addr))[2]) << 8 \
+ | ((__const unsigned char *) (addr))[1]) << 8 \
+ | ((__const unsigned char *) (addr))[0])
+
+# define put16u(addr, val) \
+ ({ uint16_t __val = (val); \
+ ((unsigned char *) (addr))[0] = __val; \
+ ((unsigned char *) (addr))[1] = __val >> 8; \
+ (void) 0; })
+# define put32u(addr, val) \
+ ({ uint32_t __val = (val); \
+ ((unsigned char *) (addr))[0] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[1] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[2] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[3] = __val; \
+ (void) 0; })
+# else
+# define get16u(addr) \
+ (((__const unsigned char *) (addr))[0] << 8 \
+ | ((__const unsigned char *) (addr))[1])
+# define get32u(addr) \
+ (((((__const unsigned char *) (addr))[0] << 8 \
+ | ((__const unsigned char *) (addr))[1]) << 8 \
+ | ((__const unsigned char *) (addr))[2]) << 8 \
+ | ((__const unsigned char *) (addr))[3])
+
+# define put16u(addr, val) \
+ ({ uint16_t __val = (val); \
+ ((unsigned char *) (addr))[1] = __val; \
+ ((unsigned char *) (addr))[0] = __val >> 8; \
+ (void) 0; })
+# define put32u(addr, val) \
+ ({ uint32_t __val = (val); \
+ ((unsigned char *) (addr))[3] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[2] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[1] = __val; \
+ __val >>= 8; \
+ ((unsigned char *) (addr))[0] = __val; \
+ (void) 0; })
+# endif
+#endif
+
+
+/* For conversions from a fixed width character set to another fixed width
+ character set we can define RESET_INPUT_BUFFER in a very fast way. */
+#if !defined RESET_INPUT_BUFFER && !defined SAVE_RESET_STATE
+# if MIN_NEEDED_FROM == MAX_NEEDED_FROM && MIN_NEEDED_TO == MAX_NEEDED_TO
+/* We have to use these `if's here since the compiler cannot know that
+ (outbuf - outerr) is always divisible by MIN_NEEDED_TO. */
+# define RESET_INPUT_BUFFER \
+ if (MIN_NEEDED_FROM % MIN_NEEDED_TO == 0) \
+ *inptrp -= (outbuf - outerr) * (MIN_NEEDED_FROM / MIN_NEEDED_TO); \
+ else if (MIN_NEEDED_TO % MIN_NEEDED_FROM == 0) \
+ *inptrp -= (outbuf - outerr) / (MIN_NEEDED_TO / MIN_NEEDED_FROM); \
+ else \
+ *inptrp -= ((outbuf - outerr) / MIN_NEEDED_TO) * MIN_NEEDED_FROM
+# endif
+#endif
+
+
+/* The default init function. It simply matches the name and initializes
+ the step data to point to one of the objects above. */
+#if DEFINE_INIT
+# ifndef CHARSET_NAME
+# error "CHARSET_NAME not defined"
+# endif
+
+extern int gconv_init (struct __gconv_step *step);
+int
+gconv_init (struct __gconv_step *step)
+{
+ /* Determine which direction. */
+ if (strcmp (step->__from_name, CHARSET_NAME) == 0)
+ {
+ step->__data = &from_object;
+
+ step->__min_needed_from = MIN_NEEDED_FROM;
+ step->__max_needed_from = MAX_NEEDED_FROM;
+ step->__min_needed_to = MIN_NEEDED_TO;
+ step->__max_needed_to = MAX_NEEDED_TO;
+ }
+ else if (__builtin_expect (strcmp (step->__to_name, CHARSET_NAME), 0) == 0)
+ {
+ step->__data = &to_object;
+
+ step->__min_needed_from = MIN_NEEDED_TO;
+ step->__max_needed_from = MAX_NEEDED_TO;
+ step->__min_needed_to = MIN_NEEDED_FROM;
+ step->__max_needed_to = MAX_NEEDED_FROM;
+ }
+ else
+ return __GCONV_NOCONV;
+
+#ifdef SAVE_RESET_STATE
+ step->__stateful = 1;
+#else
+ step->__stateful = 0;
+#endif
+
+ return __GCONV_OK;
+}
+#endif
+
+
+/* The default destructor function does nothing in the moment and so
+ we don't define it at all. But we still provide the macro just in
+ case we need it some day. */
+#if DEFINE_FINI
+#endif
+
+
+/* If no arguments have to passed to the loop function define the macro
+ as empty. */
+#ifndef EXTRA_LOOP_ARGS
+# define EXTRA_LOOP_ARGS
+#endif
+
+
+/* This is the actual conversion function. */
+#ifndef FUNCTION_NAME
+# define FUNCTION_NAME gconv
+#endif
+
+/* The macros are used to access the function to convert single characters. */
+#define SINGLE(fct) SINGLE2 (fct)
+#define SINGLE2(fct) fct##_single
+
+
+extern int FUNCTION_NAME (struct __gconv_step *step,
+ struct __gconv_step_data *data,
+ const unsigned char **inptrp,
+ const unsigned char *inend,
+ unsigned char **outbufstart, size_t *irreversible,
+ int do_flush, int consume_incomplete);
+int
+FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
+ const unsigned char **inptrp, const unsigned char *inend,
+ unsigned char **outbufstart, size_t *irreversible, int do_flush,
+ int consume_incomplete)
+{
+ struct __gconv_step *next_step = step + 1;
+ struct __gconv_step_data *next_data = data + 1;
+ __gconv_fct fct;
+ int status;
+
+ fct = (data->__flags & __GCONV_IS_LAST) ? NULL : next_step->__fct;
+
+ /* If the function is called with no input this means we have to reset
+ to the initial state. The possibly partly converted input is
+ dropped. */
+ if (__builtin_expect (do_flush, 0))
+ {
+ /* This should never happen during error handling. */
+ assert (outbufstart == NULL);
+
+ status = __GCONV_OK;
+
+#ifdef EMIT_SHIFT_TO_INIT
+ if (do_flush == 1)
+ {
+ /* We preserve the initial values of the pointer variables. */
+ unsigned char *outbuf = data->__outbuf;
+ unsigned char *outstart = outbuf;
+ unsigned char *outend = data->__outbufend;
+
+# ifdef PREPARE_LOOP
+ PREPARE_LOOP
+# endif
+
+# ifdef SAVE_RESET_STATE
+ SAVE_RESET_STATE (1);
+# endif
+
+ /* Emit the escape sequence to reset the state. */
+ EMIT_SHIFT_TO_INIT;
+
+ /* Call the steps down the chain if there are any but only if we
+ successfully emitted the escape sequence. This should only
+ fail if the output buffer is full. If the input is invalid
+ it should be discarded since the user wants to start from a
+ clean state. */
+ if (status == __GCONV_OK)
+ {
+ if (data->__flags & __GCONV_IS_LAST)
+ /* Store information about how many bytes are available. */
+ data->__outbuf = outbuf;
+ else
+ {
+ /* Write out all output which was produced. */
+ if (outbuf > outstart)
+ {
+ const unsigned char *outerr = outstart;
+ int result;
+
+ result = DL_CALL_FCT (fct, (next_step, next_data,
+ &outerr, outbuf, NULL,
+ irreversible, 0,
+ consume_incomplete));
+
+ if (result != __GCONV_EMPTY_INPUT)
+ {
+ if (__builtin_expect (outerr != outbuf, 0))
+ {
+ /* We have a problem. Undo the conversion. */
+ outbuf = outstart;
+
+ /* Restore the state. */
+# ifdef SAVE_RESET_STATE
+ SAVE_RESET_STATE (0);
+# endif
+ }
+
+ /* Change the status. */
+ status = result;
+ }
+ }
+
+ if (status == __GCONV_OK)
+ /* Now flush the remaining steps. */
+ status = DL_CALL_FCT (fct, (next_step, next_data, NULL,
+ NULL, NULL, irreversible, 1,
+ consume_incomplete));
+ }
+ }
+ }
+ else
+#endif
+ {
+ /* Clear the state object. There might be bytes in there from
+ previous calls with CONSUME_INCOMPLETE == 1. But don't emit
+ escape sequences. */
+ memset (data->__statep, '\0', sizeof (*data->__statep));
+
+ if (! (data->__flags & __GCONV_IS_LAST))
+ /* Now flush the remaining steps. */
+ status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
+ NULL, irreversible, do_flush,
+ consume_incomplete));
+ }
+ }
+ else
+ {
+ /* We preserve the initial values of the pointer variables. */
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outbuf = (__builtin_expect (outbufstart == NULL, 1)
+ ? data->__outbuf : *outbufstart);
+ unsigned char *outend = data->__outbufend;
+ unsigned char *outstart;
+ /* This variable is used to count the number of characters we
+ actually converted. */
+ size_t lirreversible = 0;
+ size_t *lirreversiblep = irreversible ? &lirreversible : NULL;
+#if defined _STRING_ARCH_unaligned \
+ || MIN_NEEDED_FROM == 1 || MAX_NEEDED_FROM % MIN_NEEDED_FROM != 0 \
+ || MIN_NEEDED_TO == 1 || MAX_NEEDED_TO % MIN_NEEDED_TO != 0
+# define unaligned 0
+#else
+ int unaligned;
+# define GEN_unaligned(name) GEN_unaligned2 (name)
+# define GEN_unaligned2(name) name##_unaligned
+#endif
+
+#ifdef PREPARE_LOOP
+ PREPARE_LOOP
+#endif
+
+#if MAX_NEEDED_FROM > 1 || MAX_NEEDED_TO > 1
+ /* If the function is used to implement the mb*towc*() or wc*tomb*()
+ functions we must test whether any bytes from the last call are
+ stored in the `state' object. */
+ if (((MAX_NEEDED_FROM > 1 && MAX_NEEDED_TO > 1)
+ || (MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
+ || (MAX_NEEDED_TO > 1 && !FROM_DIRECTION))
+ && consume_incomplete && (data->__statep->__count & 7) != 0)
+ {
+ /* Yep, we have some bytes left over. Process them now.
+ But this must not happen while we are called from an
+ error handler. */
+ assert (outbufstart == NULL);
+
+# if MAX_NEEDED_FROM > 1
+ if (MAX_NEEDED_TO == 1 || FROM_DIRECTION)
+ status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,
+ outend, lirreversiblep
+ EXTRA_LOOP_ARGS);
+# endif
+# if MAX_NEEDED_FROM > 1 && MAX_NEEDED_TO > 1 && !ONE_DIRECTION
+ else
+# endif
+# if MAX_NEEDED_TO > 1 && !ONE_DIRECTION
+ status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
+ outend, lirreversiblep EXTRA_LOOP_ARGS);
+# endif
+
+ if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
+ return status;
+ }
+#endif
+
+#if !defined _STRING_ARCH_unaligned \
+ && MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \
+ && MIN_NEEDED_TO != 1 && MAX_NEEDED_TO % MIN_NEEDED_TO == 0
+ /* The following assumes that encodings, which have a variable length
+ what might unalign a buffer even though it is a aligned in the
+ beginning, either don't have the minimal number of bytes as a divisor
+ of the maximum length or have a minimum length of 1. This is true
+ for all known and supported encodings. */
+ unaligned = ((FROM_DIRECTION
+ && ((uintptr_t) inptr % MIN_NEEDED_FROM != 0
+ || ((data->__flags & __GCONV_IS_LAST)
+ && (uintptr_t) outbuf % MIN_NEEDED_TO != 0)))
+ || (!FROM_DIRECTION
+ && (((data->__flags & __GCONV_IS_LAST)
+ && (uintptr_t) outbuf % MIN_NEEDED_FROM != 0)
+ || (uintptr_t) inptr % MIN_NEEDED_TO != 0)));
+#endif
+
+ while (1)
+ {
+ struct __gconv_trans_data *trans;
+
+ /* Remember the start value for this round. */
+ inptr = *inptrp;
+ /* The outbuf buffer is empty. */
+ outstart = outbuf;
+
+#ifdef SAVE_RESET_STATE
+ SAVE_RESET_STATE (1);
+#endif
+
+ if (__builtin_expect (!unaligned, 1))
+ {
+ if (FROM_DIRECTION)
+ /* Run the conversion loop. */
+ status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
+ lirreversiblep EXTRA_LOOP_ARGS);
+ else
+ /* Run the conversion loop. */
+ status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
+ lirreversiblep EXTRA_LOOP_ARGS);
+ }
+#if !defined _STRING_ARCH_unaligned \
+ && MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \
+ && MIN_NEEDED_TO != 1 && MAX_NEEDED_TO % MIN_NEEDED_TO == 0
+ else
+ {
+ if (FROM_DIRECTION)
+ /* Run the conversion loop. */
+ status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
+ &outbuf, outend,
+ lirreversiblep
+ EXTRA_LOOP_ARGS);
+ else
+ /* Run the conversion loop. */
+ status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
+ &outbuf, outend,
+ lirreversiblep
+ EXTRA_LOOP_ARGS);
+ }
+#endif
+
+ /* If we were called as part of an error handling module we
+ don't do anything else here. */
+ if (__builtin_expect (outbufstart != NULL, 0))
+ {
+ *outbufstart = outbuf;
+ return status;
+ }
+
+ /* Give the transliteration module the chance to store the
+ original text and the result in case it needs a context. */
+ for (trans = data->__trans; trans != NULL; trans = trans->__next)
+ if (trans->__trans_context_fct != NULL)
+ DL_CALL_FCT (trans->__trans_context_fct,
+ (trans->__data, inptr, *inptrp, outstart, outbuf));
+
+ /* We finished one use of the loops. */
+ ++data->__invocation_counter;
+
+ /* If this is the last step leave the loop, there is nothing
+ we can do. */
+ if (__builtin_expect (data->__flags & __GCONV_IS_LAST, 0))
+ {
+ /* Store information about how many bytes are available. */
+ data->__outbuf = outbuf;
+
+ /* Remember how many non-identical characters we
+ converted in a irreversible way. */
+ *irreversible += lirreversible;
+
+ break;
+ }
+
+ /* Write out all output which was produced. */
+ if (__builtin_expect (outbuf > outstart, 1))
+ {
+ const unsigned char *outerr = data->__outbuf;
+ int result;
+
+ result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
+ outbuf, NULL, irreversible, 0,
+ consume_incomplete));
+
+ if (result != __GCONV_EMPTY_INPUT)
+ {
+ if (__builtin_expect (outerr != outbuf, 0))
+ {
+#ifdef RESET_INPUT_BUFFER
+ RESET_INPUT_BUFFER;
+#else
+ /* We have a problem with the in on of the functions
+ below. Undo the conversion upto the error point. */
+ size_t nstatus;
+
+ /* Reload the pointers. */
+ *inptrp = inptr;
+ outbuf = outstart;
+
+ /* Restore the state. */
+# ifdef SAVE_RESET_STATE
+ SAVE_RESET_STATE (0);
+# endif
+
+ if (__builtin_expect (!unaligned, 1))
+ {
+ if (FROM_DIRECTION)
+ /* Run the conversion loop. */
+ nstatus = FROM_LOOP (step, data, inptrp, inend,
+ &outbuf, outerr,
+ lirreversiblep
+ EXTRA_LOOP_ARGS);
+ else
+ /* Run the conversion loop. */
+ nstatus = TO_LOOP (step, data, inptrp, inend,
+ &outbuf, outerr,
+ lirreversiblep
+ EXTRA_LOOP_ARGS);
+ }
+# if !defined _STRING_ARCH_unaligned \
+ && MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \
+ && MIN_NEEDED_TO != 1 && MAX_NEEDED_TO % MIN_NEEDED_TO == 0
+ else
+ {
+ if (FROM_DIRECTION)
+ /* Run the conversion loop. */
+ nstatus = GEN_unaligned (FROM_LOOP) (step, data,
+ inptrp, inend,
+ &outbuf,
+ outerr,
+ lirreversiblep
+ EXTRA_LOOP_ARGS);
+ else
+ /* Run the conversion loop. */
+ nstatus = GEN_unaligned (TO_LOOP) (step, data,
+ inptrp, inend,
+ &outbuf, outerr,
+ lirreversiblep
+ EXTRA_LOOP_ARGS);
+ }
+# endif
+
+ /* We must run out of output buffer space in this
+ rerun. */
+ assert (outbuf == outerr);
+ assert (nstatus == __GCONV_FULL_OUTPUT);
+
+ /* If we haven't consumed a single byte decrement
+ the invocation counter. */
+ if (__builtin_expect (outbuf == outstart, 0))
+ --data->__invocation_counter;
+#endif /* reset input buffer */
+ }
+
+ /* Change the status. */
+ status = result;
+ }
+ else
+ /* All the output is consumed, we can make another run
+ if everything was ok. */
+ if (status == __GCONV_FULL_OUTPUT)
+ {
+ status = __GCONV_OK;
+ outbuf = data->__outbuf;
+ }
+ }
+
+ if (status != __GCONV_OK)
+ break;
+
+ /* Reset the output buffer pointer for the next round. */
+ outbuf = data->__outbuf;
+ }
+
+#ifdef END_LOOP
+ END_LOOP
+#endif
+
+ /* If we are supposed to consume all character store now all of the
+ remaining characters in the `state' object. */
+#if MAX_NEEDED_FROM > 1 || MAX_NEEDED_TO > 1
+ if (((MAX_NEEDED_FROM > 1 && MAX_NEEDED_TO > 1)
+ || (MAX_NEEDED_FROM > 1 && FROM_DIRECTION)
+ || (MAX_NEEDED_TO > 1 && !FROM_DIRECTION))
+ && __builtin_expect (consume_incomplete, 0)
+ && status == __GCONV_INCOMPLETE_INPUT)
+ {
+# ifdef STORE_REST
+ mbstate_t *state = data->__statep;
+
+ STORE_REST
+# else
+ size_t cnt;
+
+ /* Make sure the remaining bytes fit into the state objects
+ buffer. */
+ assert (inend - *inptrp < 4);
+
+ for (cnt = 0; *inptrp < inend; ++cnt)
+ data->__statep->__value.__wchb[cnt] = *(*inptrp)++;
+ data->__statep->__count &= ~7;
+ data->__statep->__count |= cnt;
+# endif
+ }
+#endif
+ }
+
+ return status;
+}
+
+#undef DEFINE_INIT
+#undef CHARSET_NAME
+#undef DEFINE_FINI
+#undef MIN_NEEDED_FROM
+#undef MIN_NEEDED_TO
+#undef MAX_NEEDED_FROM
+#undef MAX_NEEDED_TO
+#undef DEFINE_DIRECTION_OBJECTS
+#undef FROM_DIRECTION
+#undef EMIT_SHIFT_TO_INIT
+#undef FROM_LOOP
+#undef TO_LOOP
+#undef SAVE_RESET_STATE
+#undef RESET_INPUT_BUFFER
+#undef FUNCTION_NAME
+#undef PREPARE_LOOP
+#undef END_LOOP
+#undef ONE_DIRECTION
+#undef STORE_REST
skeleton.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_simple.c
===================================================================
--- gconv_simple.c (nonexistent)
+++ gconv_simple.c (revision 520)
@@ -0,0 +1,1354 @@
+/* Simple transformations functions.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#define BUILTIN_ALIAS(s1, s2) /* nothing */
+#define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, MinF, MaxF, \
+ MinT, MaxT) \
+ extern int Fct (struct __gconv_step *, struct __gconv_step_data *, \
+ __const unsigned char **, __const unsigned char *, \
+ unsigned char **, size_t *, int, int);
+#include "gconv_builtin.h"
+
+
+#ifndef EILSEQ
+# define EILSEQ EINVAL
+#endif
+
+
+/* Transform from the internal, UCS4-like format, to UCS4. The
+ difference between the internal ucs4 format and the real UCS4
+ format is, if any, the endianess. The Unicode/ISO 10646 says that
+ unless some higher protocol specifies it differently, the byte
+ order is big endian.*/
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 4
+#define MIN_NEEDED_TO 4
+#define FROM_DIRECTION 1
+#define FROM_LOOP internal_ucs4_loop
+#define TO_LOOP internal_ucs4_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_internal_ucs4
+
+
+static inline int
+internal_ucs4_loop (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp, const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+ size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
+ int result;
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ /* Sigh, we have to do some real work. */
+ size_t cnt;
+
+ for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
+ {
+ *((uint32_t *) outptr) = bswap_32 (*(const uint32_t *) inptr);
+ outptr = (unsigned char *)((uint32_t *) outptr + 1);
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+#elif __BYTE_ORDER == __BIG_ENDIAN
+ /* Simply copy the data. */
+ *inptrp = inptr + n_convert * 4;
+ *outptrp = memcpy (outptr, inptr, n_convert * 4);
+ *outptrp += n_convert * 4;
+#else
+# error "This endianess is not supported."
+#endif
+
+ /* Determine the status. */
+ if (*inptrp == inend)
+ result = __GCONV_EMPTY_INPUT;
+ else if (*outptrp + 4 > outend)
+ result = __GCONV_FULL_OUTPUT;
+ else
+ result = __GCONV_INCOMPLETE_INPUT;
+
+ return result;
+}
+
+#ifndef _STRING_ARCH_unaligned
+static inline int
+internal_ucs4_loop_unaligned (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp,
+ const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+ size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
+ int result;
+
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ /* Sigh, we have to do some real work. */
+ size_t cnt;
+
+ for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4, outptr += 4)
+ {
+ outptr[0] = inptr[3];
+ outptr[1] = inptr[2];
+ outptr[2] = inptr[1];
+ outptr[3] = inptr[0];
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+# elif __BYTE_ORDER == __BIG_ENDIAN
+ /* Simply copy the data. */
+ *inptrp = inptr + n_convert * 4;
+ *outptrp = memcpy (outptr, inptr, n_convert * 4);
+ *outptrp += n_convert * 4;
+# else
+# error "This endianess is not supported."
+# endif
+
+ /* Determine the status. */
+ if (*inptrp == inend)
+ result = __GCONV_EMPTY_INPUT;
+ else if (*outptrp + 4 > outend)
+ result = __GCONV_FULL_OUTPUT;
+ else
+ result = __GCONV_INCOMPLETE_INPUT;
+
+ return result;
+}
+#endif
+
+
+static inline int
+internal_ucs4_loop_single (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp,
+ const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ mbstate_t *state = step_data->__statep;
+ size_t cnt = state->__count & 7;
+
+ while (*inptrp < inend && cnt < 4)
+ state->__value.__wchb[cnt++] = *(*inptrp)++;
+
+ if (__builtin_expect (cnt < 4, 0))
+ {
+ /* Still not enough bytes. Store the ones in the input buffer. */
+ state->__count &= ~7;
+ state->__count |= cnt;
+
+ return __GCONV_INCOMPLETE_INPUT;
+ }
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ (*outptrp)[0] = state->__value.__wchb[3];
+ (*outptrp)[1] = state->__value.__wchb[2];
+ (*outptrp)[2] = state->__value.__wchb[1];
+ (*outptrp)[3] = state->__value.__wchb[0];
+
+ *outptrp += 4;
+#elif __BYTE_ORDER == __BIG_ENDIAN
+ {
+ uint32_t **p = (uint32_t **)outptrp;
+ uint32_t *q = *p;
+ /* XXX unaligned */
+ *q = state->__value.__wch;
+ outptrp = (unsigned char *)(p + 1);
+ }
+#else
+# error "This endianess is not supported."
+#endif
+
+ /* Clear the state buffer. */
+ state->__count &= ~7;
+
+ return __GCONV_OK;
+}
+
+#include
+
+
+/* Transform from UCS4 to the internal, UCS4-like format. Unlike
+ for the other direction we have to check for correct values here. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 4
+#define MIN_NEEDED_TO 4
+#define FROM_DIRECTION 1
+#define FROM_LOOP ucs4_internal_loop
+#define TO_LOOP ucs4_internal_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_ucs4_internal
+
+
+static inline int
+ucs4_internal_loop (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp, const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ int flags = step_data->__flags;
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+ size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
+ int result;
+ size_t cnt;
+
+ for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
+ {
+ uint32_t inval;
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ inval = bswap_32 (*(const uint32_t *) inptr);
+#else
+ inval = *(const uint32_t *) inptr;
+#endif
+
+ if (__builtin_expect (inval > 0x7fffffff, 0))
+ {
+ /* The value is too large. We don't try transliteration here since
+ this is not an error because of the lack of possibilities to
+ represent the result. This is a genuine bug in the input since
+ UCS4 does not allow such values. */
+ if (irreversible == NULL)
+ /* We are transliterating, don't try to correct anything. */
+ return __GCONV_ILLEGAL_INPUT;
+
+ if (flags & __GCONV_IGNORE_ERRORS)
+ {
+ /* Just ignore this character. */
+ *irreversible = *irreversible + 1;
+ continue;
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+ return __GCONV_ILLEGAL_INPUT;
+ }
+
+ *((uint32_t *) outptr) = inval;
+ outptr = (unsigned char *) ((uint32_t *) outptr + 1);
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+
+ /* Determine the status. */
+ if (*inptrp == inend)
+ result = __GCONV_EMPTY_INPUT;
+ else if (*outptrp + 4 > outend)
+ result = __GCONV_FULL_OUTPUT;
+ else
+ result = __GCONV_INCOMPLETE_INPUT;
+
+ return result;
+}
+
+#ifndef _STRING_ARCH_unaligned
+static inline int
+ucs4_internal_loop_unaligned (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp,
+ const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ int flags = step_data->__flags;
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+ size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
+ int result;
+ size_t cnt;
+
+ for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
+ {
+ if (__builtin_expect (inptr[0] > 0x80, 0))
+ {
+ /* The value is too large. We don't try transliteration here since
+ this is not an error because of the lack of possibilities to
+ represent the result. This is a genuine bug in the input since
+ UCS4 does not allow such values. */
+ if (irreversible == NULL)
+ /* We are transliterating, don't try to correct anything. */
+ return __GCONV_ILLEGAL_INPUT;
+
+ if (flags & __GCONV_IGNORE_ERRORS)
+ {
+ /* Just ignore this character. */
+ *irreversible = *irreversible + 1;
+ continue;
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+ return __GCONV_ILLEGAL_INPUT;
+ }
+
+# if __BYTE_ORDER == __LITTLE_ENDIAN
+ outptr[3] = inptr[0];
+ outptr[2] = inptr[1];
+ outptr[1] = inptr[2];
+ outptr[0] = inptr[3];
+# else
+ outptr[0] = inptr[0];
+ outptr[1] = inptr[1];
+ outptr[2] = inptr[2];
+ outptr[3] = inptr[3];
+# endif
+ outptr += 4;
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+
+ /* Determine the status. */
+ if (*inptrp == inend)
+ result = __GCONV_EMPTY_INPUT;
+ else if (*outptrp + 4 > outend)
+ result = __GCONV_FULL_OUTPUT;
+ else
+ result = __GCONV_INCOMPLETE_INPUT;
+
+ return result;
+}
+#endif
+
+
+static inline int
+ucs4_internal_loop_single (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp,
+ const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ mbstate_t *state = step_data->__statep;
+ int flags = step_data->__flags;
+ size_t cnt = state->__count & 7;
+
+ while (*inptrp < inend && cnt < 4)
+ state->__value.__wchb[cnt++] = *(*inptrp)++;
+
+ if (__builtin_expect (cnt < 4, 0))
+ {
+ /* Still not enough bytes. Store the ones in the input buffer. */
+ state->__count &= ~7;
+ state->__count |= cnt;
+
+ return __GCONV_INCOMPLETE_INPUT;
+ }
+
+ if (__builtin_expect (((unsigned char *) state->__value.__wchb)[0] > 0x80,
+ 0))
+ {
+ /* The value is too large. We don't try transliteration here since
+ this is not an error because of the lack of possibilities to
+ represent the result. This is a genuine bug in the input since
+ UCS4 does not allow such values. */
+ if (!(flags & __GCONV_IGNORE_ERRORS))
+ {
+ *inptrp -= cnt - (state->__count & 7);
+ return __GCONV_ILLEGAL_INPUT;
+ }
+ }
+ else
+ {
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ (*outptrp)[0] = state->__value.__wchb[3];
+ (*outptrp)[1] = state->__value.__wchb[2];
+ (*outptrp)[2] = state->__value.__wchb[1];
+ (*outptrp)[3] = state->__value.__wchb[0];
+#elif __BYTE_ORDER == __BIG_ENDIAN
+ (*outptrp)[0] = state->__value.__wchb[0];
+ (*outptrp)[1] = state->__value.__wchb[1];
+ (*outptrp)[2] = state->__value.__wchb[2];
+ (*outptrp)[3] = state->__value.__wchb[3];
+#endif
+
+ *outptrp += 4;
+ }
+
+ /* Clear the state buffer. */
+ state->__count &= ~7;
+
+ return __GCONV_OK;
+}
+
+#include
+
+
+/* Similarly for the little endian form. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 4
+#define MIN_NEEDED_TO 4
+#define FROM_DIRECTION 1
+#define FROM_LOOP internal_ucs4le_loop
+#define TO_LOOP internal_ucs4le_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_internal_ucs4le
+
+
+static inline int
+internal_ucs4le_loop (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp, const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+ size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
+ int result;
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ /* Sigh, we have to do some real work. */
+ size_t cnt;
+
+ for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
+ *((uint32_t *) outptr)++ = bswap_32 (*(const uint32_t *) inptr);
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+#elif __BYTE_ORDER == __LITTLE_ENDIAN
+ /* Simply copy the data. */
+ *inptrp = inptr + n_convert * 4;
+ *outptrp = memcpy (outptr, inptr, n_convert * 4);
+ *outptrp += n_convert * 4;
+#else
+# error "This endianess is not supported."
+#endif
+
+ /* Determine the status. */
+ if (*inptrp == inend)
+ result = __GCONV_EMPTY_INPUT;
+ else if (*outptrp + 4 > outend)
+ result = __GCONV_FULL_OUTPUT;
+ else
+ result = __GCONV_INCOMPLETE_INPUT;
+
+ return result;
+}
+
+#ifndef _STRING_ARCH_unaligned
+static inline int
+internal_ucs4le_loop_unaligned (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp,
+ const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+ size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
+ int result;
+
+# if __BYTE_ORDER == __BIG_ENDIAN
+ /* Sigh, we have to do some real work. */
+ size_t cnt;
+
+ for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4, outptr += 4)
+ {
+ outptr[0] = inptr[3];
+ outptr[1] = inptr[2];
+ outptr[2] = inptr[1];
+ outptr[3] = inptr[0];
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+# elif __BYTE_ORDER == __LITTLE_ENDIAN
+ /* Simply copy the data. */
+ *inptrp = inptr + n_convert * 4;
+ *outptrp = memcpy (outptr, inptr, n_convert * 4);
+ *outptrp += n_convert * 4;
+# else
+# error "This endianess is not supported."
+# endif
+
+ /* Determine the status. */
+ if (*inptrp + 4 > inend)
+ result = __GCONV_EMPTY_INPUT;
+ else if (*outptrp + 4 > outend)
+ result = __GCONV_FULL_OUTPUT;
+ else
+ result = __GCONV_INCOMPLETE_INPUT;
+
+ return result;
+}
+#endif
+
+
+static inline int
+internal_ucs4le_loop_single (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp,
+ const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ mbstate_t *state = step_data->__statep;
+ size_t cnt = state->__count & 7;
+
+ while (*inptrp < inend && cnt < 4)
+ state->__value.__wchb[cnt++] = *(*inptrp)++;
+
+ if (__builtin_expect (cnt < 4, 0))
+ {
+ /* Still not enough bytes. Store the ones in the input buffer. */
+ state->__count &= ~7;
+ state->__count |= cnt;
+
+ return __GCONV_INCOMPLETE_INPUT;
+ }
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ (*outptrp)[0] = state->__value.__wchb[3];
+ (*outptrp)[1] = state->__value.__wchb[2];
+ (*outptrp)[2] = state->__value.__wchb[1];
+ (*outptrp)[3] = state->__value.__wchb[0];
+
+ *outptrp += 4;
+#else
+ {
+ /* XXX unaligned */
+ uint32_t **p = (uint32_t **)outptrp;
+ uint32_t *q = *p;
+ *q = state->__value.__wch;
+ outptrp = (unsigned char **)(p + 1);
+ }
+#endif
+
+ /* Clear the state buffer. */
+ state->__count &= ~7;
+
+ return __GCONV_OK;
+}
+
+#include
+
+
+/* And finally from UCS4-LE to the internal encoding. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 4
+#define MIN_NEEDED_TO 4
+#define FROM_DIRECTION 1
+#define FROM_LOOP ucs4le_internal_loop
+#define TO_LOOP ucs4le_internal_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_ucs4le_internal
+
+
+static inline int
+ucs4le_internal_loop (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp, const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ int flags = step_data->__flags;
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+ size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
+ int result;
+ size_t cnt;
+
+ for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
+ {
+ uint32_t inval;
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ inval = bswap_32 (*(const uint32_t *) inptr);
+#else
+ inval = *(const uint32_t *) inptr;
+#endif
+
+ if (__builtin_expect (inval > 0x7fffffff, 0))
+ {
+ /* The value is too large. We don't try transliteration here since
+ this is not an error because of the lack of possibilities to
+ represent the result. This is a genuine bug in the input since
+ UCS4 does not allow such values. */
+ if (irreversible == NULL)
+ /* We are transliterating, don't try to correct anything. */
+ return __GCONV_ILLEGAL_INPUT;
+
+ if (flags & __GCONV_IGNORE_ERRORS)
+ {
+ /* Just ignore this character. */
+ ++*irreversible;
+ continue;
+ }
+
+ return __GCONV_ILLEGAL_INPUT;
+ }
+
+ *((uint32_t *) outptr) = inval;
+ outptr = (unsigned char *)((uint32_t *) outptr + 1);
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+
+ /* Determine the status. */
+ if (*inptrp == inend)
+ result = __GCONV_EMPTY_INPUT;
+ else if (*outptrp + 4 > outend)
+ result = __GCONV_FULL_OUTPUT;
+ else
+ result = __GCONV_INCOMPLETE_INPUT;
+
+ return result;
+}
+
+#ifndef _STRING_ARCH_unaligned
+static inline int
+ucs4le_internal_loop_unaligned (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp,
+ const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ int flags = step_data->__flags;
+ const unsigned char *inptr = *inptrp;
+ unsigned char *outptr = *outptrp;
+ size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
+ int result;
+ size_t cnt;
+
+ for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
+ {
+ if (__builtin_expect (inptr[3] > 0x80, 0))
+ {
+ /* The value is too large. We don't try transliteration here since
+ this is not an error because of the lack of possibilities to
+ represent the result. This is a genuine bug in the input since
+ UCS4 does not allow such values. */
+ if (irreversible == NULL)
+ /* We are transliterating, don't try to correct anything. */
+ return __GCONV_ILLEGAL_INPUT;
+
+ if (flags & __GCONV_IGNORE_ERRORS)
+ {
+ /* Just ignore this character. */
+ ++*irreversible;
+ continue;
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+ return __GCONV_ILLEGAL_INPUT;
+ }
+
+# if __BYTE_ORDER == __BIG_ENDIAN
+ outptr[3] = inptr[0];
+ outptr[2] = inptr[1];
+ outptr[1] = inptr[2];
+ outptr[0] = inptr[3];
+# else
+ outptr[0] = inptr[0];
+ outptr[1] = inptr[1];
+ outptr[2] = inptr[2];
+ outptr[3] = inptr[3];
+# endif
+
+ outptr += 4;
+ }
+
+ *inptrp = inptr;
+ *outptrp = outptr;
+
+ /* Determine the status. */
+ if (*inptrp == inend)
+ result = __GCONV_EMPTY_INPUT;
+ else if (*outptrp + 4 > outend)
+ result = __GCONV_FULL_OUTPUT;
+ else
+ result = __GCONV_INCOMPLETE_INPUT;
+
+ return result;
+}
+#endif
+
+
+static inline int
+ucs4le_internal_loop_single (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ const unsigned char **inptrp,
+ const unsigned char *inend,
+ unsigned char **outptrp, unsigned char *outend,
+ size_t *irreversible)
+{
+ mbstate_t *state = step_data->__statep;
+ int flags = step_data->__flags;
+ size_t cnt = state->__count & 7;
+
+ while (*inptrp < inend && cnt < 4)
+ state->__value.__wchb[cnt++] = *(*inptrp)++;
+
+ if (__builtin_expect (cnt < 4, 0))
+ {
+ /* Still not enough bytes. Store the ones in the input buffer. */
+ state->__count &= ~7;
+ state->__count |= cnt;
+
+ return __GCONV_INCOMPLETE_INPUT;
+ }
+
+ if (__builtin_expect (((unsigned char *) state->__value.__wchb)[3] > 0x80,
+ 0))
+ {
+ /* The value is too large. We don't try transliteration here since
+ this is not an error because of the lack of possibilities to
+ represent the result. This is a genuine bug in the input since
+ UCS4 does not allow such values. */
+ if (!(flags & __GCONV_IGNORE_ERRORS))
+ return __GCONV_ILLEGAL_INPUT;
+ }
+ else
+ {
+#if __BYTE_ORDER == __BIG_ENDIAN
+ (*outptrp)[0] = state->__value.__wchb[3];
+ (*outptrp)[1] = state->__value.__wchb[2];
+ (*outptrp)[2] = state->__value.__wchb[1];
+ (*outptrp)[3] = state->__value.__wchb[0];
+#elif __BYTE_ORDER == __BIG_ENDIAN
+ (*outptrp)[0] = state->__value.__wchb[0];
+ (*outptrp)[1] = state->__value.__wchb[1];
+ (*outptrp)[2] = state->__value.__wchb[2];
+ (*outptrp)[3] = state->__value.__wchb[3];
+#endif
+
+ *outptrp += 4;
+ }
+
+ /* Clear the state buffer. */
+ state->__count &= ~7;
+
+ return __GCONV_OK;
+}
+
+#include
+
+
+/* Convert from ISO 646-IRV to the internal (UCS4-like) format. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 1
+#define MIN_NEEDED_TO 4
+#define FROM_DIRECTION 1
+#define FROM_LOOP ascii_internal_loop
+#define TO_LOOP ascii_internal_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_ascii_internal
+#define ONE_DIRECTION 1
+
+#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
+#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
+#define LOOPFCT FROM_LOOP
+#define BODY \
+ { \
+ if (__builtin_expect (*inptr > '\x7f', 0)) \
+ { \
+ /* The value is too large. We don't try transliteration here since \
+ this is not an error because of the lack of possibilities to \
+ represent the result. This is a genuine bug in the input since \
+ ASCII does not allow such values. */ \
+ if (! ignore_errors_p ()) \
+ { \
+ /* This is no correct ANSI_X3.4-1968 character. */ \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ \
+ *irreversible = *irreversible + 1; \
+ ++inptr; \
+ } \
+ else \
+ { \
+ /* It's an one byte sequence. */ \
+ *((uint32_t *) outptr) = *inptr; \
+ ++inptr; \
+ outptr = (unsigned char *)((uint32_t *) outptr + 1); \
+ } \
+ }
+#define LOOP_NEED_FLAGS
+#include
+#include
+
+
+/* Convert from the internal (UCS4-like) format to ISO 646-IRV. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 4
+#define MIN_NEEDED_TO 1
+#define FROM_DIRECTION 1
+#define FROM_LOOP internal_ascii_loop
+#define TO_LOOP internal_ascii_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_internal_ascii
+#define ONE_DIRECTION 1
+
+#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
+#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
+#define LOOPFCT FROM_LOOP
+#define BODY \
+ { \
+ if (__builtin_expect (*((const uint32_t *) inptr) > 0x7f, 0)) \
+ { \
+ UNICODE_TAG_HANDLER (*((const uint32_t *) inptr), 4); \
+ STANDARD_ERR_HANDLER (4); \
+ } \
+ else \
+ { \
+ /* It's an one byte sequence. */ \
+ *outptr++ = *((const uint32_t *) inptr); \
+ inptr = ((const uint32_t *) inptr + 1); \
+ } \
+ }
+#define LOOP_NEED_FLAGS
+#include
+#include
+
+
+/* Convert from the internal (UCS4-like) format to UTF-8. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 4
+#define MIN_NEEDED_TO 1
+#define MAX_NEEDED_TO 6
+#define FROM_DIRECTION 1
+#define FROM_LOOP internal_utf8_loop
+#define TO_LOOP internal_utf8_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_internal_utf8
+#define ONE_DIRECTION 1
+
+#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
+#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
+#define MAX_NEEDED_OUTPUT MAX_NEEDED_TO
+#define LOOPFCT FROM_LOOP
+#define BODY \
+ { \
+ uint32_t wc = *((const uint32_t *) inptr); \
+ \
+ if (wc < 0x80) \
+ /* It's an one byte sequence. */ \
+ *outptr++ = (unsigned char) wc; \
+ else if (__builtin_expect (wc <= 0x7fffffff, 1)) \
+ { \
+ size_t step; \
+ char *start; \
+ \
+ for (step = 2; step < 6; ++step) \
+ if ((wc & (~(uint32_t)0 << (5 * step + 1))) == 0) \
+ break; \
+ \
+ if (__builtin_expect (outptr + step > outend, 0)) \
+ { \
+ /* Too long. */ \
+ result = __GCONV_FULL_OUTPUT; \
+ break; \
+ } \
+ \
+ start = outptr; \
+ *outptr = (unsigned char) (~0xff >> step); \
+ outptr += step; \
+ --step; \
+ do \
+ { \
+ start[step] = 0x80 | (wc & 0x3f); \
+ wc >>= 6; \
+ } \
+ while (--step > 0); \
+ start[0] |= wc; \
+ } \
+ else \
+ { \
+ STANDARD_ERR_HANDLER (4); \
+ } \
+ \
+ inptr += 4; \
+ }
+#define LOOP_NEED_FLAGS
+#include
+#include
+
+
+/* Convert from UTF-8 to the internal (UCS4-like) format. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 1
+#define MAX_NEEDED_FROM 6
+#define MIN_NEEDED_TO 4
+#define FROM_DIRECTION 1
+#define FROM_LOOP utf8_internal_loop
+#define TO_LOOP utf8_internal_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_utf8_internal
+#define ONE_DIRECTION 1
+
+#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
+#define MAX_NEEDED_INPUT MAX_NEEDED_FROM
+#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
+#define LOOPFCT FROM_LOOP
+#define BODY \
+ { \
+ uint32_t ch; \
+ uint32_t cnt; \
+ uint32_t i; \
+ \
+ /* Next input byte. */ \
+ ch = *inptr; \
+ \
+ if (ch < 0x80) \
+ { \
+ /* One byte sequence. */ \
+ cnt = 1; \
+ ++inptr; \
+ } \
+ else \
+ { \
+ if (ch >= 0xc2 && ch < 0xe0) \
+ { \
+ /* We expect two bytes. The first byte cannot be 0xc0 or 0xc1, \
+ otherwise the wide character could have been represented \
+ using a single byte. */ \
+ cnt = 2; \
+ ch &= 0x1f; \
+ } \
+ else if (__builtin_expect ((ch & 0xf0) == 0xe0, 1)) \
+ { \
+ /* We expect three bytes. */ \
+ cnt = 3; \
+ ch &= 0x0f; \
+ } \
+ else if (__builtin_expect ((ch & 0xf8) == 0xf0, 1)) \
+ { \
+ /* We expect four bytes. */ \
+ cnt = 4; \
+ ch &= 0x07; \
+ } \
+ else if (__builtin_expect ((ch & 0xfc) == 0xf8, 1)) \
+ { \
+ /* We expect five bytes. */ \
+ cnt = 5; \
+ ch &= 0x03; \
+ } \
+ else if (__builtin_expect ((ch & 0xfe) == 0xfc, 1)) \
+ { \
+ /* We expect six bytes. */ \
+ cnt = 6; \
+ ch &= 0x01; \
+ } \
+ else \
+ { \
+ int skipped; \
+ \
+ if (! ignore_errors_p ()) \
+ { \
+ /* This is an illegal encoding. */ \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ \
+ /* Search the end of this ill-formed UTF-8 character. This \
+ is the next byte with (x & 0xc0) != 0x80. */ \
+ skipped = 0; \
+ do \
+ { \
+ ++inptr; \
+ ++skipped; \
+ } \
+ while (inptr < inend && (*inptr & 0xc0) == 0x80 && skipped < 5); \
+ \
+ continue; \
+ } \
+ \
+ if (__builtin_expect (inptr + cnt > inend, 0)) \
+ { \
+ /* We don't have enough input. But before we report that check \
+ that all the bytes are correct. */ \
+ for (i = 1; inptr + i < inend; ++i) \
+ if ((inptr[i] & 0xc0) != 0x80) \
+ break; \
+ \
+ if (__builtin_expect (inptr + i == inend, 1)) \
+ { \
+ result = __GCONV_INCOMPLETE_INPUT; \
+ break; \
+ } \
+ \
+ if (ignore_errors_p ()) \
+ { \
+ /* Ignore it. */ \
+ inptr += i; \
+ *irreversible = *irreversible + 1; \
+ continue; \
+ } \
+ \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ \
+ /* Read the possible remaining bytes. */ \
+ for (i = 1; i < cnt; ++i) \
+ { \
+ uint32_t byte = inptr[i]; \
+ \
+ if ((byte & 0xc0) != 0x80) \
+ /* This is an illegal encoding. */ \
+ break; \
+ \
+ ch <<= 6; \
+ ch |= byte & 0x3f; \
+ } \
+ \
+ /* If i < cnt, some trail byte was not >= 0x80, < 0xc0. \
+ If cnt > 2 and ch < 2^(5*cnt-4), the wide character ch could \
+ have been represented with fewer than cnt bytes. */ \
+ if (i < cnt || (cnt > 2 && (ch >> (5 * cnt - 4)) == 0)) \
+ { \
+ /* This is an illegal encoding. */ \
+ if (ignore_errors_p ()) \
+ { \
+ inptr += i; \
+ *irreversible = *irreversible + 1; \
+ continue; \
+ } \
+ \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ \
+ inptr += cnt; \
+ } \
+ \
+ /* Now adjust the pointers and store the result. */ \
+ *((uint32_t *) outptr) = ch; \
+ outptr = (unsigned char *)((uint32_t *) outptr + 1); \
+ }
+#define LOOP_NEED_FLAGS
+
+#define STORE_REST \
+ { \
+ /* We store the remaining bytes while converting them into the UCS4 \
+ format. We can assume that the first byte in the buffer is \
+ correct and that it requires a larger number of bytes than there \
+ are in the input buffer. */ \
+ wint_t ch = **inptrp; \
+ size_t cnt; \
+ \
+ state->__count = inend - *inptrp; \
+ \
+ if (ch >= 0xc2 && ch < 0xe0) \
+ { \
+ /* We expect two bytes. The first byte cannot be 0xc0 or \
+ 0xc1, otherwise the wide character could have been \
+ represented using a single byte. */ \
+ cnt = 2; \
+ ch &= 0x1f; \
+ } \
+ else if (__builtin_expect ((ch & 0xf0) == 0xe0, 1)) \
+ { \
+ /* We expect three bytes. */ \
+ cnt = 3; \
+ ch &= 0x0f; \
+ } \
+ else if (__builtin_expect ((ch & 0xf8) == 0xf0, 1)) \
+ { \
+ /* We expect four bytes. */ \
+ cnt = 4; \
+ ch &= 0x07; \
+ } \
+ else if (__builtin_expect ((ch & 0xfc) == 0xf8, 1)) \
+ { \
+ /* We expect five bytes. */ \
+ cnt = 5; \
+ ch &= 0x03; \
+ } \
+ else \
+ { \
+ /* We expect six bytes. */ \
+ cnt = 6; \
+ ch &= 0x01; \
+ } \
+ \
+ /* The first byte is already consumed. */ \
+ --cnt; \
+ while (++(*inptrp) < inend) \
+ { \
+ ch <<= 6; \
+ ch |= **inptrp & 0x3f; \
+ --cnt; \
+ } \
+ \
+ /* Shift for the so far missing bytes. */ \
+ ch <<= cnt * 6; \
+ \
+ /* Store the value. */ \
+ state->__value.__wch = ch; \
+ }
+
+#define UNPACK_BYTES \
+ { \
+ wint_t wch = state->__value.__wch; \
+ size_t ntotal; \
+ inlen = state->__count; \
+ \
+ if (state->__value.__wch <= 0x7ff) \
+ { \
+ bytebuf[0] = 0xc0; \
+ ntotal = 2; \
+ } \
+ else if (__builtin_expect (state->__value.__wch <= 0xffff, 1)) \
+ { \
+ bytebuf[0] = 0xe0; \
+ ntotal = 3; \
+ } \
+ else if (__builtin_expect (state->__value.__wch < 0x1fffff, 1)) \
+ { \
+ bytebuf[0] = 0xf0; \
+ ntotal = 4; \
+ } \
+ else if (__builtin_expect (state->__value.__wch < 0x3ffffff, 1)) \
+ { \
+ bytebuf[0] = 0xf8; \
+ ntotal = 5; \
+ } \
+ else \
+ { \
+ bytebuf[0] = 0xfc; \
+ ntotal = 6; \
+ } \
+ \
+ do \
+ { \
+ if (--ntotal < inlen) \
+ bytebuf[ntotal] = 0x80 | (wch & 0x3f); \
+ wch >>= 6; \
+ } \
+ while (ntotal > 1); \
+ \
+ bytebuf[0] |= wch; \
+ }
+
+#include
+#include
+
+
+/* Convert from UCS2 to the internal (UCS4-like) format. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 2
+#define MIN_NEEDED_TO 4
+#define FROM_DIRECTION 1
+#define FROM_LOOP ucs2_internal_loop
+#define TO_LOOP ucs2_internal_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_ucs2_internal
+#define ONE_DIRECTION 1
+
+#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
+#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
+#define LOOPFCT FROM_LOOP
+#define BODY \
+ { \
+ uint16_t u1 = *((const uint16_t *) inptr); \
+ \
+ if (__builtin_expect (u1 >= 0xd800 && u1 < 0xe000, 0)) \
+ { \
+ /* Surrogate characters in UCS-2 input are not valid. Reject \
+ them. (Catching this here is not security relevant.) */ \
+ if (! ignore_errors_p ()) \
+ { \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ inptr += 2; \
+ *irreversible = *irreversible + 1; \
+ continue; \
+ } \
+ \
+ *((uint32_t *) outptr) = u1; \
+ outptr = (unsigned char *)((uint32_t *) outptr + 1); \
+ inptr += 2; \
+ }
+#define LOOP_NEED_FLAGS
+#include
+#include
+
+
+/* Convert from the internal (UCS4-like) format to UCS2. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 4
+#define MIN_NEEDED_TO 2
+#define FROM_DIRECTION 1
+#define FROM_LOOP internal_ucs2_loop
+#define TO_LOOP internal_ucs2_loop /* This is not used. */
+#define FUNCTION_NAME __gconv_transform_internal_ucs2
+#define ONE_DIRECTION 1
+
+#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
+#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
+#define LOOPFCT FROM_LOOP
+#define BODY \
+ { \
+ uint32_t val = *((const uint32_t *) inptr); \
+ \
+ if (__builtin_expect (val >= 0x10000, 0)) \
+ { \
+ UNICODE_TAG_HANDLER (val, 4); \
+ STANDARD_ERR_HANDLER (4); \
+ } \
+ else if (__builtin_expect (val >= 0xd800 && val < 0xe000, 0)) \
+ { \
+ /* Surrogate characters in UCS-4 input are not valid. \
+ We must catch this, because the UCS-2 output might be \
+ interpreted as UTF-16 by other programs. If we let \
+ surrogates pass through, attackers could make a security \
+ hole exploit by synthesizing any desired plane 1-16 \
+ character. */ \
+ if (! ignore_errors_p ()) \
+ { \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ inptr += 4; \
+ *irreversible = *irreversible + 1; \
+ continue; \
+ } \
+ else \
+ { \
+ *((uint16_t *) outptr) = val; \
+ outptr = (unsigned char *)((uint16_t *) outptr + 1); \
+ inptr += 4; \
+ } \
+ }
+#define LOOP_NEED_FLAGS
+#include
+#include
+
+
+/* Convert from UCS2 in other endianness to the internal (UCS4-like) format. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 2
+#define MIN_NEEDED_TO 4
+#define FROM_DIRECTION 1
+#define FROM_LOOP ucs2reverse_internal_loop
+#define TO_LOOP ucs2reverse_internal_loop/* This is not used.*/
+#define FUNCTION_NAME __gconv_transform_ucs2reverse_internal
+#define ONE_DIRECTION 1
+
+#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
+#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
+#define LOOPFCT FROM_LOOP
+#define BODY \
+ { \
+ uint16_t u1 = bswap_16 (*((const uint16_t *) inptr)); \
+ \
+ if (__builtin_expect (u1 >= 0xd800 && u1 < 0xe000, 0)) \
+ { \
+ /* Surrogate characters in UCS-2 input are not valid. Reject \
+ them. (Catching this here is not security relevant.) */ \
+ if (! ignore_errors_p ()) \
+ { \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ inptr += 2; \
+ *irreversible = *irreversible + 1; \
+ continue; \
+ } \
+ \
+ *((uint32_t *) outptr) = u1; \
+ outptr = (unsigned char *)((uint32_t *) outptr + 1); \
+ inptr += 2; \
+ }
+#define LOOP_NEED_FLAGS
+#include
+#include
+
+
+/* Convert from the internal (UCS4-like) format to UCS2 in other endianness. */
+#define DEFINE_INIT 0
+#define DEFINE_FINI 0
+#define MIN_NEEDED_FROM 4
+#define MIN_NEEDED_TO 2
+#define FROM_DIRECTION 1
+#define FROM_LOOP internal_ucs2reverse_loop
+#define TO_LOOP internal_ucs2reverse_loop/* This is not used.*/
+#define FUNCTION_NAME __gconv_transform_internal_ucs2reverse
+#define ONE_DIRECTION 1
+
+#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
+#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
+#define LOOPFCT FROM_LOOP
+#define BODY \
+ { \
+ uint32_t val = *((const uint32_t *) inptr); \
+ if (__builtin_expect (val >= 0x10000, 0)) \
+ { \
+ UNICODE_TAG_HANDLER (val, 4); \
+ STANDARD_ERR_HANDLER (4); \
+ } \
+ else if (__builtin_expect (val >= 0xd800 && val < 0xe000, 0)) \
+ { \
+ /* Surrogate characters in UCS-4 input are not valid. \
+ We must catch this, because the UCS-2 output might be \
+ interpreted as UTF-16 by other programs. If we let \
+ surrogates pass through, attackers could make a security \
+ hole exploit by synthesizing any desired plane 1-16 \
+ character. */ \
+ if (! ignore_errors_p ()) \
+ { \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ inptr += 4; \
+ *irreversible = *irreversible + 1; \
+ continue; \
+ } \
+ else \
+ { \
+ *((uint16_t *) outptr) = bswap_16 (val); \
+ outptr = (unsigned char *)((uint16_t *) outptr + 1); \
+ inptr += 4; \
+ } \
+ }
+#define LOOP_NEED_FLAGS
+#include
+#include
gconv_simple.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: Makefile.am
===================================================================
--- Makefile.am (nonexistent)
+++ Makefile.am (revision 520)
@@ -0,0 +1,28 @@
+## Process this file with automake to generate Makefile.in
+
+AUTOMAKE_OPTIONS = cygnus
+
+INCLUDES = -DGCONV_DIR='"$(pkglibdir)"' -DGCONV_PATH='"$(pkglibdir)"' -I$(srcdir) -I$(srcdir)/.. $(NEWLIB_CFLAGS) $(CROSS_CFLAGS) $(TARGET_CFLAGS)
+
+LIB_SOURCES = \
+ iconv.h gconv.h \
+ iconv_open.c iconv.c iconv_close.c \
+ gconv_open.c gconv.c gconv_close.c \
+ gconv_db.c gconv_dl.c gconv_conf.c gconv_builtin.c \
+ gconv_simple.c gconv_trans.c gconv_cache.c
+
+libiconv_la_CFLAGS =
+libiconv_la_LDFLAGS = -Xcompiler -nostdlib
+
+if USE_LIBTOOL
+noinst_LTLIBRARIES = libiconv.la
+libiconv_la_SOURCES = $(LIB_SOURCES)
+noinst_DATA = objectlist.awk.in
+else
+noinst_LIBRARIES = lib.a
+lib_a_SOURCES = $(LIB_SOURCES)
+lib_a_CFLAGS = $(AM_CFLAGS)
+noinst_DATA =
+endif # USE_LIBTOOL
+
+include $(srcdir)/../../../../Makefile.shared
Makefile.am
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_charset.h
===================================================================
--- gconv_charset.h (nonexistent)
+++ gconv_charset.h (revision 520)
@@ -0,0 +1,73 @@
+/* Charset name normalization.
+ Copyright (C) 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 2001.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+
+
+static inline void
+strip (char *wp, const char *s)
+{
+ int slash_count = 0;
+ char old_locale[20], *old_locale_p;
+
+ /* Set locale to default C locale. */
+ old_locale_p = setlocale(LC_ALL, "C");
+ strncpy(old_locale, old_locale_p, 20);
+ while (*s != '\0')
+ {
+ if (isalnum (*s)
+ || *s == '_' || *s == '-' || *s == '.')
+ *wp++ = toupper (*s);
+ else if (*s == '/')
+ {
+ if (++slash_count == 3)
+ break;
+ *wp++ = '/';
+ }
+ ++s;
+ }
+
+ while (slash_count++ < 2)
+ *wp++ = '/';
+
+ *wp = '\0';
+ setlocale(LC_ALL, old_locale);
+}
+
+
+static char * __attribute__ ((unused))
+upstr (char *dst, const char *str)
+{
+ char *cp = dst;
+ char old_locale[20], *old_locale_p;
+ /* Set locale to default C locale. */
+ old_locale_p = setlocale(LC_ALL, "C");
+ strncpy(old_locale, old_locale_p, 20);
+ while ((*cp++ = toupper (*str++)) != '\0')
+ /* nothing */;
+ setlocale(LC_ALL, old_locale);
+ return dst;
+}
+
+
+/* If NAME is an codeset alias expand it. */
+extern int __gconv_compare_alias (const char *name1, const char *name2)
+ internal_function;
gconv_charset.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_int.h
===================================================================
--- gconv_int.h (nonexistent)
+++ gconv_int.h (revision 520)
@@ -0,0 +1,288 @@
+/* Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#ifndef _GCONV_INT_H
+#define _GCONV_INT_H 1
+
+#include "gconv.h"
+#include
+
+__BEGIN_DECLS
+
+
+/* Type to represent search path. */
+struct path_elem
+{
+ const char *name;
+ size_t len;
+};
+
+/* Variable with search path for `gconv' implementation. */
+extern struct path_elem *__gconv_path_elem;
+/* Maximum length of a single path element. */
+extern size_t __gconv_max_path_elem_len;
+
+
+/* Structure for alias definition. Simply two strings. */
+struct gconv_alias
+{
+ char *fromname;
+ char *toname;
+};
+
+
+/* How many character should be conveted in one call? */
+#define GCONV_NCHAR_GOAL 8160
+
+
+/* Structure describing one loaded shared object. This normally are
+ objects to perform conversation but as a special case the db shared
+ object is also handled. */
+struct __gconv_loaded_object
+{
+ /* Name of the object. It must be the first structure element. */
+ const char *name;
+
+ /* Reference counter for the db functionality. If no conversion is
+ needed we unload the db library. */
+ int counter;
+
+ /* The handle for the shared object. */
+ void *handle;
+
+ /* Pointer to the functions the module defines. */
+ __gconv_fct fct;
+ __gconv_init_fct init_fct;
+ __gconv_end_fct end_fct;
+};
+
+
+/* Description for an available conversion module. */
+struct gconv_module
+{
+ const char *from_string;
+ const char *to_string;
+
+ int cost_hi;
+ int cost_lo;
+
+ const char *module_name;
+
+ struct gconv_module *left; /* Prefix smaller. */
+ struct gconv_module *same; /* List of entries with identical prefix. */
+ struct gconv_module *right; /* Prefix larger. */
+};
+
+
+/* Internal data structure to represent transliteration module. */
+struct trans_struct
+{
+ const char *name;
+ struct trans_struct *next;
+
+ const char **csnames;
+ size_t ncsnames;
+ __gconv_trans_fct trans_fct;
+ __gconv_trans_context_fct trans_context_fct;
+ __gconv_trans_init_fct trans_init_fct;
+ __gconv_trans_end_fct trans_end_fct;
+};
+
+
+/* Flags for `gconv_open'. */
+enum
+{
+ GCONV_AVOID_NOCONV = 1 << 0
+};
+
+
+/* Global variables. */
+
+/* Database of alias names. */
+extern void *__gconv_alias_db;
+
+/* Array with available modules. */
+extern size_t __gconv_nmodules;
+extern struct gconv_module *__gconv_modules_db;
+
+/* Value of the GCONV_PATH environment variable. */
+extern const char *__gconv_path_envvar;
+
+
+/* The gconv functions expects the name to be in upper case and complete,
+ including the trailing slashes if necessary. */
+#define norm_add_slashes(str,suffix) \
+ ({ \
+ const char *cp = (str); \
+ char *result; \
+ char *tmp; \
+ size_t cnt = 0; \
+ size_t suffix_len = (suffix) == NULL ? 0 : strlen (suffix); \
+ \
+ while (*cp != '\0') \
+ if (*cp++ == '/') \
+ ++cnt; \
+ \
+ tmp = result = alloca (cp - (str) + 3 + suffix_len); \
+ cp = (str); \
+ while (*cp != '\0') \
+ *tmp++ = __toupper_l (*cp++, &_nl_C_locobj); \
+ if (cnt < 2) \
+ { \
+ *tmp++ = '/'; \
+ if (cnt < 1) \
+ { \
+ *tmp++ = '/'; \
+ if (suffix != NULL) \
+ { \
+ tmp = memcpy (tmp, suffix, suffix_len); \
+ tmp += suffix_len; \
+ } \
+ } \
+ } \
+ *tmp = '\0'; \
+ result; \
+ })
+
+
+/* Return in *HANDLE decriptor for transformation from FROMSET to TOSET. */
+extern int __gconv_open (const char *toset, const char *fromset,
+ __gconv_t *handle, int flags)
+ internal_function;
+
+/* Free resources associated with transformation descriptor CD. */
+extern int __gconv_close (__gconv_t cd)
+ internal_function;
+
+/* Transform at most *INBYTESLEFT bytes from buffer starting at *INBUF
+ according to rules described by CD and place up to *OUTBYTESLEFT
+ bytes in buffer starting at *OUTBUF. Return number of non-identical
+ conversions in *IRREVERSIBLE if this pointer is not null. */
+extern int __gconv (__gconv_t cd, const unsigned char **inbuf,
+ const unsigned char *inbufend, unsigned char **outbuf,
+ unsigned char *outbufend, size_t *irreversible)
+ internal_function;
+
+/* Return in *HANDLE a pointer to an array with *NSTEPS elements describing
+ the single steps necessary for transformation from FROMSET to TOSET. */
+extern int __gconv_find_transform (const char *toset, const char *fromset,
+ struct __gconv_step **handle,
+ size_t *nsteps, int flags)
+ internal_function;
+
+/* Search for transformation in cache data. */
+extern int __gconv_lookup_cache (const char *toset, const char *fromset,
+ struct __gconv_step **handle, size_t *nsteps,
+ int flags)
+ internal_function;
+
+/* Compare the two name for whether they are after alias expansion the
+ same. This function uses the cache and fails if none is
+ loaded. */
+extern int __gconv_compare_alias_cache (const char *name1, const char *name2,
+ int *result) internal_function;
+
+/* Free data associated with a step's structure. */
+extern void __gconv_release_step (struct __gconv_step *step)
+ internal_function;
+
+/* Read all the configuration data and cache it. */
+extern void __gconv_read_conf (void);
+
+/* Try to read module cache file. */
+extern int __gconv_load_cache (void) internal_function;
+
+/* Determine the directories we are looking in. */
+extern void __gconv_get_path (void);
+
+/* Comparison function to search alias. */
+extern int __gconv_alias_compare (const void *p1, const void *p2);
+
+/* Clear reference to transformation step implementations which might
+ cause the code to be unloaded. */
+extern int __gconv_close_transform (struct __gconv_step *steps,
+ size_t nsteps)
+ internal_function;
+
+/* Free all resources allocated for the transformation record when
+ using the cache. */
+extern void __gconv_release_cache (struct __gconv_step *steps, size_t nsteps)
+ internal_function;
+
+/* Load shared object named by NAME. If already loaded increment reference
+ count. */
+extern struct __gconv_loaded_object *__gconv_find_shlib (const char *name)
+ internal_function;
+
+/* Release shared object. If no further reference is available unload
+ the object. */
+extern void __gconv_release_shlib (struct __gconv_loaded_object *handle)
+ internal_function;
+
+/* Fill STEP with information about builtin module with NAME. */
+extern void __gconv_get_builtin_trans (const char *name,
+ struct __gconv_step *step)
+ internal_function;
+
+/* Try to load transliteration step module. */
+extern int __gconv_translit_find (struct trans_struct *trans)
+ internal_function;
+
+/* Transliteration using the locale's data. */
+extern int __gconv_transliterate (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ void *trans_data,
+ __const unsigned char *inbufstart,
+ __const unsigned char **inbufp,
+ __const unsigned char *inbufend,
+ unsigned char **outbufstart,
+ size_t *irreversible);
+
+
+/* Builtin transformations. */
+#ifdef _LIBC
+# define __BUILTIN_TRANS(Name) \
+ extern int Name (struct __gconv_step *step, \
+ struct __gconv_step_data *data, \
+ const unsigned char **inbuf, \
+ const unsigned char *inbufend, \
+ unsigned char **outbufstart, size_t *irreversible, \
+ int do_flush, int consume_incomplete)
+
+__BUILTIN_TRANS (__gconv_transform_ascii_internal);
+__BUILTIN_TRANS (__gconv_transform_internal_ascii);
+__BUILTIN_TRANS (__gconv_transform_utf8_internal);
+__BUILTIN_TRANS (__gconv_transform_internal_utf8);
+__BUILTIN_TRANS (__gconv_transform_ucs2_internal);
+__BUILTIN_TRANS (__gconv_transform_internal_ucs2);
+__BUILTIN_TRANS (__gconv_transform_ucs2reverse_internal);
+__BUILTIN_TRANS (__gconv_transform_internal_ucs2reverse);
+__BUILTIN_TRANS (__gconv_transform_internal_ucs4);
+__BUILTIN_TRANS (__gconv_transform_ucs4_internal);
+__BUILTIN_TRANS (__gconv_transform_internal_ucs4le);
+__BUILTIN_TRANS (__gconv_transform_ucs4le_internal);
+__BUILTIN_TRANS (__gconv_transform_internal_utf16);
+__BUILTIN_TRANS (__gconv_transform_utf16_internal);
+# undef __BUITLIN_TRANS
+
+#endif
+
+__END_DECLS
+
+#endif /* gconv_int.h */
gconv_int.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_dl.c
===================================================================
--- gconv_dl.c (nonexistent)
+++ gconv_dl.c (revision 520)
@@ -0,0 +1,237 @@
+/* Handle loading/unloading of shared object for transformation.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+
+#ifdef DEBUG
+/* For debugging purposes. */
+static void print_all (void);
+#endif
+
+
+/* This is a tuning parameter. If a transformation module is not used
+ anymore it gets not immediately unloaded. Instead we wait a certain
+ number of load attempts for further modules. If none of the
+ subsequent load attempts name the same object it finally gets unloaded.
+ Otherwise it is still available which hopefully is the frequent case.
+ The following number is the number of unloading attempts we wait
+ before unloading. */
+#define TRIES_BEFORE_UNLOAD 2
+
+/* Array of loaded objects. This is shared by all threads so we have
+ to use semaphores to access it. */
+static void *loaded;
+
+/* Comparison function for searching `loaded_object' tree. */
+static int
+known_compare (const void *p1, const void *p2)
+{
+ const struct __gconv_loaded_object *s1 =
+ (const struct __gconv_loaded_object *) p1;
+ const struct __gconv_loaded_object *s2 =
+ (const struct __gconv_loaded_object *) p2;
+
+ return strcmp (s1->name, s2->name);
+}
+
+/* Open the gconv database if necessary. A non-negative return value
+ means success. */
+struct __gconv_loaded_object *
+internal_function
+__gconv_find_shlib (const char *name)
+{
+ struct __gconv_loaded_object *found;
+ void *keyp;
+
+
+
+ /* Search the tree of shared objects previously requested. Data in
+ the tree are `loaded_object' structures, whose first member is a
+ `const char *', the lookup key. The search returns a pointer to
+ the tree node structure; the first member of the is a pointer to
+ our structure (i.e. what will be a `loaded_object'); since the
+ first member of that is the lookup key string, &FCT_NAME is close
+ enough to a pointer to our structure to use as a lookup key that
+ will be passed to `known_compare' (above). */
+
+ keyp = tfind (&name, &loaded, known_compare);
+ if (keyp == NULL)
+ {
+ /* This name was not known before. */
+ size_t namelen = strlen (name) + 1;
+
+ found = malloc (sizeof (struct __gconv_loaded_object) + namelen);
+ if (found != NULL)
+ {
+ /* Point the tree node at this new structure. */
+ found->name = (char *) memcpy (found + 1, name, namelen);
+ found->counter = -TRIES_BEFORE_UNLOAD - 1;
+ found->handle = NULL;
+
+ if (__builtin_expect (tsearch (found, &loaded, known_compare)
+ == NULL, 0))
+ {
+ /* Something went wrong while inserting the entry. */
+ free (found);
+ found = NULL;
+ }
+ }
+ }
+ else
+ found = *(struct __gconv_loaded_object **) keyp;
+
+ /* Try to load the shared object if the usage count is 0. This
+ implies that if the shared object is not loadable, the handle is
+ NULL and the usage count > 0. */
+ if (found != NULL)
+ {
+ if (found->counter < -TRIES_BEFORE_UNLOAD)
+ {
+ assert (found->handle == NULL);
+ found->handle = __libc_dlopen (found->name);
+ if (found->handle != NULL)
+ {
+ found->fct = __libc_dlsym (found->handle, "gconv");
+ if (found->fct == NULL)
+ {
+ /* Argh, no conversion function. There is something
+ wrong here. */
+ __gconv_release_shlib (found);
+ found = NULL;
+ }
+ else
+ {
+ found->init_fct = __libc_dlsym (found->handle, "gconv_init");
+ found->end_fct = __libc_dlsym (found->handle, "gconv_end");
+
+ /* We have succeeded in loading the shared object. */
+ found->counter = 1;
+ }
+ }
+ else
+ /* Error while loading the shared object. */
+ found = NULL;
+ }
+ else if (found->handle != NULL)
+ found->counter = MAX (found->counter + 1, 1);
+ }
+
+ return found;
+}
+
+
+/* This is very ugly but the tsearch functions provide no way to pass
+ information to the walker function. So we use a global variable.
+ It is MT safe since we use a lock. */
+static struct __gconv_loaded_object *release_handle;
+
+static void
+do_release_shlib (void *nodep, VISIT value, int level)
+{
+ struct __gconv_loaded_object *obj = *(struct __gconv_loaded_object **) nodep;
+
+
+
+ if (value != preorder && value != leaf)
+ return;
+
+ if (obj == release_handle)
+ {
+ /* This is the object we want to unload. Now decrement the
+ reference counter. */
+ assert (obj->counter > 0);
+ --obj->counter;
+ }
+ else if (obj->counter <= 0 && obj->counter >= -TRIES_BEFORE_UNLOAD
+ && --obj->counter < -TRIES_BEFORE_UNLOAD && obj->handle != NULL)
+ {
+ /* Unload the shared object. */
+ __libc_dlclose (obj->handle);
+ obj->handle = NULL;
+ }
+}
+
+
+/* Notify system that a shared object is not longer needed. */
+void
+internal_function
+__gconv_release_shlib (struct __gconv_loaded_object *handle)
+{
+ /* Urgh, this is ugly but we have no other possibility. */
+ release_handle = handle;
+
+ /* Process all entries. Please note that we also visit entries
+ with release counts <= 0. This way we can finally unload them
+ if necessary. */
+ twalk (loaded, (void *) do_release_shlib);
+}
+
+
+/* We run this if we debug the memory allocation. */
+static void
+do_release_all (void *nodep)
+{
+ struct __gconv_loaded_object *obj = (struct __gconv_loaded_object *) nodep;
+
+
+ /* Unload the shared object. */
+ if (obj->handle != NULL)
+ __libc_dlclose (obj->handle);
+
+ free (obj);
+}
+
+static void __attribute__ ((unused))
+free_mem (void)
+{
+ tdestroy (loaded, do_release_all);
+}
+text_set_element (__libc_subfreeres, free_mem);
+
+
+#ifdef DEBUG
+static void
+do_print (const void *nodep, VISIT value, int level)
+{
+ struct __gconv_loaded_object *obj = *(struct __gconv_loaded_object **) nodep;
+
+ printf ("%10s: \"%s\", %d\n",
+ value == leaf ? "leaf" :
+ value == preorder ? "preorder" :
+ value == postorder ? "postorder" : "endorder",
+ obj->name, obj->counter);
+}
+
+static void
+print_all (void)
+{
+ __twalk (loaded, do_print);
+}
+#endif
gconv_dl.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: hash-string.h
===================================================================
--- hash-string.h (nonexistent)
+++ hash-string.h (revision 520)
@@ -0,0 +1,60 @@
+/* Implements a string hashing function.
+ Copyright (C) 1995, 1997, 1998, 2000 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+/* @@ end of prolog @@ */
+
+#ifndef PARAMS
+# if __STDC__
+# define PARAMS(Args) Args
+# else
+# define PARAMS(Args) ()
+# endif
+#endif
+
+/* We assume to have `unsigned long int' value with at least 32 bits. */
+#define HASHWORDBITS 32
+
+
+/* Defines the so called `hashpjw' function by P.J. Weinberger
+ [see Aho/Sethi/Ullman, COMPILERS: Principles, Techniques and Tools,
+ 1986, 1987 Bell Telephone Laboratories, Inc.] */
+static unsigned long int hash_string PARAMS ((const char *__str_param));
+
+static inline unsigned long int
+hash_string (str_param)
+ const char *str_param;
+{
+ unsigned long int hval, g;
+ const char *str = str_param;
+
+ /* Compute the hash value for the given string. */
+ hval = 0;
+ while (*str != '\0')
+ {
+ hval <<= 4;
+ hval += (unsigned long int) *str++;
+ g = hval & ((unsigned long int) 0xf << (HASHWORDBITS - 4));
+ if (g != 0)
+ {
+ hval ^= g >> (HASHWORDBITS - 8);
+ hval ^= g;
+ }
+ }
+ return hval;
+}
hash-string.h
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property
Index: gconv_open.c
===================================================================
--- gconv_open.c (nonexistent)
+++ gconv_open.c (revision 520)
@@ -0,0 +1,329 @@
+/* Find matching transformation algorithms and initialize steps.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper , 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include
+#include
+#include
+#include
+
+#include
+
+int
+internal_function
+__gconv_open (const char *toset, const char *fromset, __gconv_t *handle,
+ int flags)
+{
+ struct __gconv_step *steps;
+ size_t nsteps;
+ __gconv_t result = NULL;
+ size_t cnt = 0;
+ int res;
+ int conv_flags = 0;
+ const char *errhand;
+ const char *ignore;
+ struct trans_struct *trans = NULL;
+ char old_locale[20], *old_locale_p;
+ char *old, *new;
+ size_t len;
+
+ /* Find out whether any error handling method is specified. */
+ errhand = strchr (toset, '/');
+ if (errhand != NULL)
+ errhand = strchr (errhand + 1, '/');
+ if (__builtin_expect (errhand != NULL, 1))
+ {
+ if (*++errhand == '\0')
+ errhand = NULL;
+ else
+ {
+ /* Make copy without the error handling description. */
+ char *newtoset = (char *) alloca (errhand - toset + 1);
+ char *tok;
+ char *ptr;
+
+ newtoset[errhand - toset] = '\0';
+ toset = memcpy (newtoset, toset, errhand - toset);
+
+ /* Find the appropriate transliteration handlers. */
+ old = (char *)(errhand);
+ len = strlen (old) + 1;
+ new = (char *) alloca (len);
+ tok = (char *) memcpy (new, old, len);
+
+ tok = strtok_r (tok, ",", &ptr);
+
+ /* Set locale to default C locale. */
+ old_locale_p = setlocale(LC_ALL, "C");
+ strncpy(old_locale, old_locale_p, 20);
+
+ while (tok != NULL)
+ {
+ if (strcasecmp (tok, "TRANSLIT") == 0)
+ {
+ /* It's the builtin transliteration handling. We only
+ support it for working on the internal encoding. */
+ static const char *internal_trans_names[1] = { "INTERNAL" };
+ struct trans_struct *lastp = NULL;
+ struct trans_struct *runp;
+
+ for (runp = trans; runp != NULL; runp = runp->next)
+ if (runp->trans_fct == __gconv_transliterate)
+ break;
+ else
+ lastp = runp;
+
+ if (runp == NULL)
+ {
+ struct trans_struct *newp;
+
+ newp = (struct trans_struct *) alloca (sizeof (*newp));
+ memset (newp, '\0', sizeof (*newp));
+
+ /* We leave the `name' field zero to signal that
+ this is an internal transliteration step. */
+ newp->csnames = internal_trans_names;
+ newp->ncsnames = 1;
+ newp->trans_fct = __gconv_transliterate;
+
+ if (lastp == NULL)
+ trans = newp;
+ else
+ lastp->next = newp;
+ }
+ }
+ else if (strcasecmp (tok, "IGNORE") == 0)
+ /* Set the flag to ignore all errors. */
+ conv_flags |= __GCONV_IGNORE_ERRORS;
+ else
+ {
+ /* `tok' is possibly a module name. We'll see later
+ whether we can find it. But first see that we do
+ not already a module of this name. */
+ struct trans_struct *lastp = NULL;
+ struct trans_struct *runp;
+
+ for (runp = trans; runp != NULL; runp = runp->next)
+ if (runp->name != NULL
+ && strcasecmp (tok, runp->name) == 0)
+ break;
+ else
+ lastp = runp;
+
+ if (runp == NULL)
+ {
+ struct trans_struct *newp;
+
+ newp = (struct trans_struct *) alloca (sizeof (*newp));
+ memset (newp, '\0', sizeof (*newp));
+ newp->name = tok;
+
+ if (lastp == NULL)
+ trans = newp;
+ else
+ lastp->next = newp;
+ }
+ }
+
+ tok = strtok_r (NULL, ",", &ptr);
+ }
+ }
+ }
+
+ /* For the source character set we ignore the error handler specification.
+ XXX Is this really always the best? */
+ ignore = strchr (fromset, '/');
+ if (ignore != NULL && (ignore = strchr (ignore + 1, '/')) != NULL
+ && *++ignore != '\0')
+ {
+ char *newfromset = (char *) alloca (ignore - fromset + 1);
+
+ newfromset[ignore - fromset] = '\0';
+ fromset = memcpy (newfromset, fromset, ignore - fromset);
+ }
+
+ res = __gconv_find_transform (toset, fromset, &steps, &nsteps, flags);
+ if (res == __GCONV_OK)
+ {
+ /* Find the modules. */
+ struct trans_struct *lastp = NULL;
+ struct trans_struct *runp;
+
+ for (runp = trans; runp != NULL; runp = runp->next)
+ {
+ if (runp->name == NULL
+ || __builtin_expect (__gconv_translit_find (runp), 0) == 0)
+ lastp = runp;
+ else
+ /* This means we haven't found the module. Remove it. */
+ if (lastp == NULL)
+ trans = runp->next;
+ else
+ lastp->next = runp->next;
+ }
+
+ /* Allocate room for handle. */
+ result = (__gconv_t) malloc (sizeof (struct __gconv_info)
+ + (nsteps
+ * sizeof (struct __gconv_step_data)));
+ if (result == NULL)
+ res = __GCONV_NOMEM;
+ else
+ {
+ size_t n;
+
+ /* Remember the list of steps. */
+ result->__steps = steps;
+ result->__nsteps = nsteps;
+
+ /* Clear the array for the step data. */
+ memset (result->__data, '\0',
+ nsteps * sizeof (struct __gconv_step_data));
+
+ /* Call all initialization functions for the transformation
+ step implementations. */
+ for (cnt = 0; cnt < nsteps; ++cnt)
+ {
+ size_t size;
+
+ /* Would have to be done if we would not clear the whole
+ array above. */
+#if 0
+ /* Reset the counter. */
+ result->__data[cnt].__invocation_counter = 0;
+
+ /* It's a regular use. */
+ result->__data[cnt].__internal_use = 0;
+#endif
+
+ /* We use the `mbstate_t' member in DATA. */
+ result->__data[cnt].__statep = &result->__data[cnt].__state;
+
+ /* Now see whether we can use any of the transliteration
+ modules for this step. */
+ for (runp = trans; runp != NULL; runp = runp->next)
+ for (n = 0; n < runp->ncsnames; ++n)
+ if (strcasecmp (steps[cnt].__from_name, runp->csnames[n]) == 0)
+ {
+ void *data = NULL;
+
+ /* Match! Now try the initializer. */
+ if (runp->trans_init_fct == NULL
+ || (runp->trans_init_fct (&data,
+ steps[cnt].__to_name)
+ == __GCONV_OK))
+ {
+ /* Append at the end of the list. */
+ struct __gconv_trans_data *newp;
+ struct __gconv_trans_data **lastp;
+
+ newp = (struct __gconv_trans_data *)
+ malloc (sizeof (struct __gconv_trans_data));
+ if (newp == NULL)
+ {
+ res = __GCONV_NOMEM;
+ goto bail;
+ }
+
+ newp->__trans_fct = runp->trans_fct;
+ newp->__trans_context_fct = runp->trans_context_fct;
+ newp->__trans_end_fct = runp->trans_end_fct;
+ newp->__data = data;
+ newp->__next = NULL;
+
+ lastp = &result->__data[cnt].__trans;
+ while (*lastp != NULL)
+ lastp = &(*lastp)->__next;
+
+ *lastp = newp;
+ }
+ break;
+ }
+
+ /* If this is the last step we must not allocate an
+ output buffer. */
+ if (cnt < nsteps - 1)
+ {
+ result->__data[cnt].__flags = conv_flags;
+
+ /* Allocate the buffer. */
+ size = (GCONV_NCHAR_GOAL * steps[cnt].__max_needed_to);
+
+ result->__data[cnt].__outbuf = (char *) malloc (size);
+ if (result->__data[cnt].__outbuf == NULL)
+ {
+ res = __GCONV_NOMEM;
+ goto bail;
+ }
+
+ result->__data[cnt].__outbufend =
+ result->__data[cnt].__outbuf + size;
+ }
+ else
+ {
+ /* Handle the last entry. */
+ result->__data[cnt].__flags = conv_flags | __GCONV_IS_LAST;
+
+ break;
+ }
+ }
+ }
+
+ if (res != __GCONV_OK)
+ {
+ /* Something went wrong. Free all the resources. */
+ int serrno;
+ bail:
+ serrno = errno;
+
+ if (result != NULL)
+ {
+ while (cnt-- > 0)
+ {
+ struct __gconv_trans_data *transp;
+
+ transp = result->__data[cnt].__trans;
+ while (transp != NULL)
+ {
+ struct __gconv_trans_data *curp = transp;
+ transp = transp->__next;
+
+ if (__builtin_expect (curp->__trans_end_fct != NULL, 0))
+ curp->__trans_end_fct (curp->__data);
+
+ free (curp);
+ }
+
+ free (result->__data[cnt].__outbuf);
+ }
+
+ free (result);
+ result = NULL;
+ }
+
+ __gconv_close_transform (steps, nsteps);
+
+ __set_errno (serrno);
+ }
+ }
+
+ *handle = result;
+ setlocale(LC_ALL, old_locale);
+ return res;
+}
gconv_open.c
Property changes :
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+Id
\ No newline at end of property