+2000-06-12 Ulrich Drepper <drepper@redhat.com>
+
+ * Rules (%.out): Define GCONV_PATH in the environment.
+ * assert/Depend: New file.
+ * iconvdata/Depend: New file.
+ * intl/Depend: New file.
+ * timezone/Makefile (build-testdata): Add GCONV_PATH to environment.
+ * intl/tst-gettext.sh: Likewise.
+ * iconv/Makefile (routines): Add gconv_trans.
+ * iconv/gconv_trans.c: New file.
+ * iconv/gconv.h (struct __gconv_trans_data): New type.
+ (__gconv_fct): New parameter with starting position in output buffer.
+ (__gconv_trans_fct, __gconv_trans_context_fct, __gconv_trans_query_fct,
+ __gconv_trans_init_fct, __gconv_trans_end_fct): New types.
+ (struct __gconv_step): Add new member __trans.
+ * iconv/gconv_int.h: Pretty print prototypes.
+ (gconv_transliterate): New prototype.
+ (__BUILTIN_TRANS): Update for new conversion function interface.
+ * iconv/gconv.c (__gconv): Pass new parameter to conversion function.
+ * iconv/gconv_open.c (__gconv_open): Recognize error handling suffix
+ in names, find appropriate function, and install in the conversion
+ steps it can be used.
+ * iconv/skeleton.c: Add additional parameter for beginning of output
+ buffer. Change calls of downstream functions.
+ * iconv/loop.c: Change loop function interface completely. Pass in
+ step and step_data structure. Remove optimization for BODY with
+ NEED_LENGTH_TEST == 0.
+ * iconv/gconv_simple.c: Update interfaces of functions. Insert
+ appropriate error handling code to use transliteration steps. Remove
+ optimization for BODY with NEED_LENGTH_TEST == 0.
+ * iconvdata/8bit-gap.c: Likewise.
+ * iconvdata/8bit-generic.c: Likewise.
+ * iconvdata/ansi_x3.110.c: Likewise.
+ * iconvdata/big5.c: Likewise.
+ * iconvdata/big5hkscs.c: Likewise.
+ * iconvdata/euc-cn.c: Likewise.
+ * iconvdata/euc-jp.c: Likewise.
+ * iconvdata/euc-kr.c: Likewise.
+ * iconvdata/euc-tw.c: Likewise.
+ * iconvdata/gbgbk.c: Likewise.
+ * iconvdata/gbk.c: Likewise.
+ * iconvdata/iso-2022-cn.c: Likewise.
+ * iconvdata/iso-2022-jp.c: Likewise.
+ * iconvdata/iso-2022-kr.c: Likewise.
+ * iconvdata/iso646.c: Likewise.
+ * iconvdata/iso8859-1.c: Likewise.
+ * iconvdata/iso_6937-2.c: Likewise.
+ * iconvdata/iso_6937.c: Likewise.
+ * iconvdata/johab.c: Likewise.
+ * iconvdata/sjis.c: Likewise.
+ * iconvdata/t.61.c: Likewise.
+ * iconvdata/uhc.c: Likewise.
+ * iconvdata/unicode.c: Likewise.
+ * iconvdata/utf-16.c: Likewise.
+ * libio/iofwide.c: Adjust to new interface of gconv functions. Use
+ DL_CALL_FCT.
+ * wcsmbs/btowc.c: Likewise.
+ * wcsmbs/mbrtowc.c: Likewise.
+ * wcsmbs/mbsnrtowcs.c: Likewise.
+ * wcsmbs/mbsrtowcs.c: Likewise.
+ * wcsmbs/wcrtomb.c: Likewise.
+ * wcsmbs/wcsnrtombs.c: Likewise.
+ * wcsmbs/wcsrtombs.c: Likewise.
+ * wcsmbs/wctob.c: Likewise.
+
2000-04-11 Geoff Keating <geoffk@cygnus.com>
* sysdeps/powerpc/dl-machine.c: Include dl-machine.h after the
headers = iconv.h gconv.h
routines = iconv_open iconv iconv_close \
gconv_open gconv gconv_close gconv_db gconv_conf \
- gconv_builtin gconv_simple
+ gconv_builtin gconv_simple gconv_trans
ifeq ($(elf),yes)
routines += gconv_dl
else
if (inbuf == NULL || *inbuf == NULL)
/* We just flush. */
result = DL_CALL_FCT (cd->__steps->__fct,
- (cd->__steps, cd->__data, NULL, NULL,
- irreversible, 1, 0));
+ (cd->__steps, cd->__data, NULL, NULL,
+ cd->__data[0].__outbuf, irreversible, 1, 0));
else
{
const unsigned char *last_start;
{
last_start = *inbuf;
result = DL_CALL_FCT (cd->__steps->__fct,
- (cd->__steps, cd->__data, inbuf, inbufend,
- irreversible, 0, 0));
+ (cd->__steps, cd->__data, inbuf, inbufend,
+ cd->__data[0].__outbuf, irreversible, 0, 0));
}
while (result == __GCONV_EMPTY_INPUT && last_start != *inbuf
&& *inbuf + cd->__steps->__min_needed_from <= inbufend);
struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
+struct __gconv_trans_data;
/* Type of a conversion function. */
typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
__const unsigned char **, __const unsigned char *,
- size_t *, int, int);
+ unsigned char *, size_t *, int, int);
/* Constructor and destructor for local data for conversion step. */
typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);
+/* Type of a transliteration/transscription function. */
+typedef int (*__gconv_trans_fct) (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ __const unsigned char *,
+ __const unsigned char **,
+ __const unsigned char *, unsigned char *,
+ unsigned char **, unsigned char *, size_t *);
+
+/* Function to call to provide transliteration module with context. */
+typedef int (*__gconv_trans_context_fct) (struct __gconv_trans_data *data,
+ __const unsigned char *,
+ __const unsigned char *,
+ __const unsigned char *,
+ unsigned char *, unsigned char *,
+ unsigned char *);
+
+/* Function to query module about supported encoded character sets. */
+typedef int (*__gconv_trans_query_fct) (__const char **, size_t *);
+
+/* Constructor and destructor for local data for transliteration. */
+typedef int (*__gconv_trans_init_fct) (void **, const char *);
+typedef void (*__gconv_trans_end_fct) (void *);
+
+struct __gconv_trans_data
+{
+ /* Transliteration/Transscription function. */
+ __gconv_trans_fct __trans_fct;
+ __gconv_trans_context_fct __trans_context_fct;
+ __gconv_trans_end_fct __trans_end_fct;
+ void *__data;
+};
+
+
/* Description of a conversion step. */
struct __gconv_step
{
__mbstate_t *__statep;
__mbstate_t __state; /* This element must not be used directly by
any module; always use STATEP! */
+
+ /* Transliteration information. */
+ struct __gconv_trans_data __trans;
};
/* 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)
+extern int __gconv_open (const char *toset, const char *fromset,
+ __gconv_t *handle, int flags)
internal_function;
/* Free resources associated with transformation descriptor CD. */
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,
+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)
+extern int __gconv_find_transform (const char *toset, const char *fromset,
+ struct __gconv_step **handle,
+ size_t *nsteps, int flags)
internal_function;
/* Read all the configuration data and cache it. */
extern void __gconv_read_conf (void);
/* Comparison function to search alias. */
-extern int __gconv_alias_compare (const void *__p1, const void *__p2);
+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)
+extern int __gconv_close_transform (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)
+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 int __gconv_release_shlib (struct __gconv_loaded_object *__handle)
+extern int __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)
+extern void __gconv_get_builtin_trans (const char *name,
+ struct __gconv_step *step)
internal_function;
+/* Transliteration using the locale's data. */
+extern int gconv_transliterate (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ __const unsigned char *inbufstart,
+ __const unsigned char **inbufp,
+ __const unsigned char *inbufend,
+ unsigned char *outbufstart,
+ unsigned char **outbufp,
+ unsigned char *outbufend,
+ 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, size_t *__written, \
- int __do_flush, int __consume_incomplete)
+ 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);
size_t cnt = 0;
int res;
int conv_flags = 0;
- const char *runp;
+ const char *errhand;
- /* Find out whether "IGNORE" is part of the options in the `toset'
- name. If yes, remove the string and remember this in the flag. */
- runp = __strchrnul (__strchrnul (toset, '/'), '/');
- if (strcmp (runp, "IGNORE") == 0)
+ /* 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))
{
- /* Found it. This means we should ignore conversion errors. */
- char *newtoset = (char *) alloca (runp - toset + 1);
+ if (errhand[1] == '\0')
+ errhand = NULL;
+ else
+ {
+ /* Make copy without the error handling description. */
+ char *newtoset = (char *) alloca (errhand - toset + 1);
- newtoset[runp - toset] = '\0';
- toset = memcpy (newtoset, toset, runp - toset);
+ newtoset[errhand - toset] = '\0';
+ toset = memcpy (newtoset, toset, errhand - toset);
- flags = __GCONV_IGNORE_ERRORS;
+ flags = __GCONV_IGNORE_ERRORS;
+
+ if (strcasecmp (errhand, "IGNORE") == 0)
+ {
+ /* Found it. This means we should ignore conversion errors. */
+ flags = __GCONV_IGNORE_ERRORS;
+ errhand = NULL;
+ }
+ }
}
res = __gconv_find_transform (toset, fromset, &steps, &nsteps, flags);
if (res == __GCONV_OK)
{
+ const char **csnames = NULL;
+ size_t ncsnames = 0;
+ __gconv_trans_fct trans_fct = NULL;
+ __gconv_trans_context_fct trans_context_fct = NULL;
+ __gconv_trans_init_fct trans_init_fct = NULL;
+ __gconv_trans_end_fct trans_end_fct = NULL;
+
+ if (errhand != NULL)
+ {
+ /* Find the appropriate transliteration handling. */
+ if (strcasecmp (errhand, "TRANSLIT") == 0)
+ {
+ /* It's the builtin transliteration handling. We only
+ suport for it working on the internal encoding. */
+ static const char *internal_trans_names[1] = { "INTERNAL" };
+
+ csnames = internal_trans_names;
+ ncsnames = 1;
+ trans_fct = gconv_transliterate;
+ /* No context, init, or end function. */
+ }
+ else if (strcasecmp (errhand, "WORK AROUND A GCC BUG") == 0)
+ {
+ trans_init_fct = (__gconv_trans_init_fct) 1;
+ }
+ }
+
/* Allocate room for handle. */
result = (__gconv_t) malloc (sizeof (struct __gconv_info)
+ (nsteps
res = __GCONV_NOMEM;
else
{
+ size_t n;
+
/* Remember the list of steps. */
result->__steps = steps;
result->__nsteps = nsteps;
}
result->__data[cnt].__outbufend =
result->__data[cnt].__outbuf + size;
+
+ /* Now see whether we can use the transliteration module
+ for this step. */
+ for (n = 0; n < ncsnames; ++n)
+ if (strcasecmp (steps[cnt].__from_name, csnames[n]) == 0)
+ {
+ /* Match! Now try the initializer. */
+ if (trans_init_fct == NULL
+ || (trans_init_fct (&result->__data[cnt].__trans.__data,
+ steps[cnt].__to_name)
+ == __GCONV_OK))
+ {
+ result->__data[cnt].__trans.__trans_fct = trans_fct;
+ result->__data[cnt].__trans.__trans_context_fct =
+ trans_context_fct;
+ result->__data[cnt].__trans.__trans_end_fct =
+ trans_end_fct;
+ }
+ break;
+ }
}
/* Now handle the last entry. */
result->__data[cnt].__internal_use = 0;
#endif
result->__data[cnt].__statep = &result->__data[cnt].__state;
+
+ /* Now see whether we can use the transliteration module
+ for this step. */
+ for (n = 0; n < ncsnames; ++n)
+ if (strcasecmp (steps[cnt].__from_name, csnames[n]) == 0)
+ {
+ /* Match! Now try the initializer. */
+ if (trans_init_fct == NULL
+ || trans_init_fct (&result->__data[cnt].__trans.__data,
+ steps[cnt].__to_name)
+ == __GCONV_OK)
+ {
+ result->__data[cnt].__trans.__trans_fct = trans_fct;
+ result->__data[cnt].__trans.__trans_context_fct =
+ trans_context_fct;
+ result->__data[cnt].__trans.__trans_end_fct =
+ trans_end_fct;
+ }
+ break;
+ }
}
if (res != __GCONV_OK)
Boston, MA 02111-1307, USA. */
#include <byteswap.h>
+#include <dlfcn.h>
#include <endian.h>
#include <errno.h>
#include <gconv.h>
static inline int
-internal_ucs4_loop (const unsigned char **inptrp, const unsigned char *inend,
+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,
- mbstate_t *state, int flags, void *data,
size_t *irreversible)
{
const unsigned char *inptr = *inptrp;
#ifndef _STRING_ARCH_unaligned
static inline int
-internal_ucs4_loop_unaligned (const unsigned char **inptrp,
+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,
- mbstate_t *state, int flags, void *data,
size_t *irreversible)
{
const unsigned char *inptr = *inptrp;
static inline int
-internal_ucs4_loop_single (const unsigned char **inptrp,
+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,
- mbstate_t *state, int flags, void *data,
size_t *irreversible)
{
+ mbstate_t *state = step_data->__statep;
size_t cnt = state->__count & 7;
while (*inptrp < inend && cnt < 4)
static inline int
-ucs4_internal_loop (const unsigned char **inptrp, const unsigned char *inend,
+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,
- mbstate_t *state, int flags, void *data,
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;
if (__builtin_expect (inval, 0) > 0x7fffffff)
{
+ /* 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)
{
/* Just ignore this character. */
#ifndef _STRING_ARCH_unaligned
static inline int
-ucs4_internal_loop_unaligned (const unsigned char **inptrp,
+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,
- mbstate_t *state, int flags, void *data,
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, outptr += 4)
+ for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
{
if (__builtin_expect (inptr[0], 0) > 0x80)
{
- /* The value is too large. */
+ /* 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)
{
/* Just ignore this character. */
outptr[2] = inptr[2];
outptr[3] = inptr[3];
# endif
+ outptr += 4;
}
*inptrp = inptr;
static inline int
-ucs4_internal_loop_single (const unsigned char **inptrp,
+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,
- mbstate_t *state, int flags, void *data,
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)
if (__builtin_expect (((unsigned char *) state->__value.__wchb)[0], 0)
> 0x80)
{
- /* The value is too large. */
+ /* 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);
static inline int
-internal_ucs4le_loop (const unsigned char **inptrp, const unsigned char *inend,
+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,
- mbstate_t *state, int flags, void *data,
size_t *irreversible)
{
const unsigned char *inptr = *inptrp;
#ifndef _STRING_ARCH_unaligned
static inline int
-internal_ucs4le_loop_unaligned (const unsigned char **inptrp,
+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,
- mbstate_t *state, int flags, void *data,
size_t *irreversible)
{
const unsigned char *inptr = *inptrp;
static inline int
-internal_ucs4le_loop_single (const unsigned char **inptrp,
+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,
- mbstate_t *state, int flags, void *data,
size_t *irreversible)
{
+ mbstate_t *state = step_data->__statep;
size_t cnt = state->__count & 7;
while (*inptrp < inend && cnt < 4)
static inline int
-ucs4le_internal_loop (const unsigned char **inptrp, const unsigned char *inend,
+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,
- mbstate_t *state, int flags, void *data,
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;
if (__builtin_expect (inval, 0) > 0x7fffffff)
{
+ /* 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)
{
/* Just ignore this character. */
#ifndef _STRING_ARCH_unaligned
static inline int
-ucs4le_internal_loop_unaligned (const unsigned char **inptrp,
+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,
- mbstate_t *state, int flags, void *data,
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;
{
if (__builtin_expect (inptr[3], 0) > 0x80)
{
- /* The value is too large. */
+ /* 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)
{
/* Just ignore this character. */
static inline int
-ucs4le_internal_loop_single (const unsigned char **inptrp,
+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,
- mbstate_t *state, int flags, void *data,
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)
if (__builtin_expect (((unsigned char *) state->__value.__wchb)[3], 0)
> 0x80)
{
- /* The value is too large. */
+ /* 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;
}
{ \
if (__builtin_expect (*inptr, 0) > '\x7f') \
{ \
+ /* 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. */ \
} \
\
++*irreversible; \
- ++inptr; \
+ ++inptr; \
} \
else \
/* It's an one byte sequence. */ \
/* XXX unaligned. */ \
*((uint32_t *) outptr)++ = *inptr++; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
#include <iconv/skeleton.c>
#define FUNCTION_NAME __gconv_transform_internal_ascii
#define ONE_DIRECTION 1
+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);
+
#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
#define LOOPFCT FROM_LOOP
/* XXX unaligned. */ \
if (__builtin_expect (*((uint32_t *) inptr), 0) > 0x7f) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is no correct ANSI_X3.4-1968 character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
} \
else \
/* It's an one byte sequence. */ \
*outptr++ = *((uint32_t *) inptr)++; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
#include <iconv/skeleton.c>
continue; \
} \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + cnt > inend, 0)) \
+ 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. */ \
/* Now adjust the pointers and store the result. */ \
*((uint32_t *) outptr)++ = ch; \
}
+#define LOOP_NEED_FLAGS
#define STORE_REST \
{ \
{ \
if (__builtin_expect (*((uint32_t *) inptr), 0) >= 0x10000) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
} \
else \
*((uint16_t *) outptr)++ = *((uint32_t *) inptr)++; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
#include <iconv/skeleton.c>
uint32_t val = *((uint32_t *) inptr); \
if (__builtin_expect (val, 0) >= 0x10000) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
+ continue; \
} \
*((uint16_t *) outptr)++ = bswap_16 (val); \
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
#include <iconv/skeleton.c>
--- /dev/null
+/* 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 <drepper@cygnus.com>, 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 <stdint.h>
+
+#include "gconv_int.h"
+#include "../locale/localeinfo.h"
+
+
+int
+gconv_transliterate (struct __gconv_step *step,
+ struct __gconv_step_data *step_data,
+ __const unsigned char *inbufstart,
+ __const unsigned char **inbufp,
+ __const unsigned char *inbufend,
+ unsigned char *outbufstart,
+ unsigned char **outbufp, unsigned char *outbufend,
+ size_t *irreversible)
+{
+ /* Find out about the locale's transliteration. */
+ uint_fast32_t size = _NL_CURRENT_WORD (LC_CTYPE,
+ _NL_CTYPE_TRANSLIT_HASH_SIZE);
+ uint_fast32_t layers = _NL_CURRENT_WORD (LC_CTYPE,
+ _NL_CTYPE_TRANSLIT_HASH_LAYERS);
+
+ /* If there is no transliteration information in the locale don't do
+ anything and return the error. */
+ if (size == 0)
+ return __GCONV_ILLEGAL_INPUT;
+
+ /* XXX For now we don't do anything. */
+ return __GCONV_ILLEGAL_INPUT;
+}
/* The function returns the status, as defined in gconv.h. */
static inline int
-FCTNAME (LOOPFCT) (const unsigned char **inptrp, const unsigned char *inend,
+FCTNAME (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,
- mbstate_t *state, int flags, void *data,
size_t *irreversible EXTRA_LOOP_DECLS)
{
- int result = __GCONV_OK;
+#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;
- /* We run one loop where we avoid checks for underflow/overflow of the
- buffers to speed up the conversion a bit. */
- size_t min_in_rounds = (inend - inptr) / MAX_NEEDED_INPUT;
- size_t min_out_rounds = (outend - outptr) / MAX_NEEDED_OUTPUT;
- size_t min_rounds = MIN (min_in_rounds, min_out_rounds);
-
#ifdef INIT_PARAMS
INIT_PARAMS;
#endif
-#undef NEED_LENGTH_TEST
-#define NEED_LENGTH_TEST 0
- while (min_rounds-- > 0)
+ while (inptr != inend)
{
- /* 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
- }
-
- if (result == __GCONV_OK)
- {
-#if MIN_NEEDED_INPUT == MAX_NEEDED_INPUT \
- && MIN_NEEDED_OUTPUT == MAX_NEEDED_OUTPUT
- /* We don't need to start another loop since we were able to determine
- the maximal number of characters to copy in advance. What remains
- to be determined is the status. */
- if (inptr == inend)
- /* No more input. */
- result = __GCONV_EMPTY_INPUT;
- else if ((MIN_NEEDED_OUTPUT != 1 && outptr + MIN_NEEDED_OUTPUT > outend)
- || (MIN_NEEDED_OUTPUT == 1 && outptr >= outend))
- /* Overflow in the output buffer. */
- result = __GCONV_FULL_OUTPUT;
- else
- /* We have something left in the input buffer. */
- result = __GCONV_INCOMPLETE_INPUT;
-#else
- result = __GCONV_EMPTY_INPUT;
-
-# undef NEED_LENGTH_TEST
-# define NEED_LENGTH_TEST 1
- while (inptr != inend)
+ /* `if' cases for MIN_NEEDED_OUTPUT ==/!= 1 is made to help the
+ compiler generating better code. It will 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))
{
- /* `if' cases for MIN_NEEDED_OUTPUT ==/!= 1 is made to help the
- compiler generating better code. It will 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
+ /* We don't have enough input for another complete input
+ character. */
+ result = __GCONV_INCOMPLETE_INPUT;
+ break;
}
-#endif /* Input and output charset are not both fixed width. */
+
+ /* 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. */
# define SINGLE(fct) SINGLE2 (fct)
# define SINGLE2(fct) fct##_single
static inline int
-SINGLE(LOOPFCT) (const unsigned char **inptrp, const unsigned char *inend,
+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,
- mbstate_t *state, int flags, void *data, size_t *irreversible
- EXTRA_LOOP_DECLS)
+ 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;
inptr = bytebuf;
inend = &bytebuf[inlen];
-#undef NEED_LENGTH_TEST
-#define NEED_LENGTH_TEST 1
+
do
{
BODY
#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
-#undef UNPACK_BYTES
int
FUNCTION_NAME (struct __gconv_step *step, struct __gconv_step_data *data,
const unsigned char **inptrp, const unsigned char *inend,
- size_t *irreversible, int do_flush, int consume_incomplete)
+ 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;
successfully emitted the escape sequence. */
if (status == __GCONV_OK && ! (data->__flags & __GCONV_IS_LAST))
status = DL_CALL_FCT (fct, (next_step, next_data, NULL, NULL,
- irreversible, 1, consume_incomplete));
+ next_data->__outbuf, irreversible, 1,
+ consume_incomplete));
}
else
{
/* We preserve the initial values of the pointer variables. */
const unsigned char *inptr = *inptrp;
- unsigned char *outbuf = data->__outbuf;
+ unsigned char *outbuf = outbufstart;
unsigned char *outend = data->__outbufend;
unsigned char *outstart;
/* This variable is used to count the number of characters we
# if MAX_NEEDED_FROM > 1
if (MAX_NEEDED_TO == 1 || FROM_DIRECTION)
- status = SINGLE(FROM_LOOP) (inptrp, inend, &outbuf, outend,
- data->__statep, data->__flags,
- step->__data, &lirreversible
+ status = SINGLE(FROM_LOOP) (step, data, inptrp, inend, &outbuf,
+ outend, &lirreversible
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) (inptrp, inend, &outbuf, outend,
- data->__statep, data->__flags,
- step->__data, &lirreversible
- EXTRA_LOOP_ARGS);
+ status = SINGLE(TO_LOOP) (step, data, inptrp, inend, &outbuf,
+ outend, &lirreversible EXTRA_LOOP_ARGS);
# endif
if (__builtin_expect (status, __GCONV_OK) != __GCONV_OK)
{
if (FROM_DIRECTION)
/* Run the conversion loop. */
- status = FROM_LOOP (inptrp, inend, &outbuf, outend,
- data->__statep, data->__flags,
- step->__data, &lirreversible
- EXTRA_LOOP_ARGS);
+ status = FROM_LOOP (step, data, inptrp, inend, &outbuf, outend,
+ &lirreversible EXTRA_LOOP_ARGS);
else
/* Run the conversion loop. */
- status = TO_LOOP (inptrp, inend, &outbuf, outend,
- data->__statep, data->__flags,
- step->__data, &lirreversible
- EXTRA_LOOP_ARGS);
+ status = TO_LOOP (step, data, inptrp, inend, &outbuf, outend,
+ &lirreversible EXTRA_LOOP_ARGS);
}
#if !defined _STRING_ARCH_unaligned \
&& MIN_NEEDED_FROM != 1 && MAX_NEEDED_FROM % MIN_NEEDED_FROM == 0 \
{
if (FROM_DIRECTION)
/* Run the conversion loop. */
- status = GEN_unaligned (FROM_LOOP) (inptrp, inend, &outbuf,
- outend, data->__statep,
- data->__flags,
- step->__data,
+ status = GEN_unaligned (FROM_LOOP) (step, data, inptrp, inend,
+ &outbuf, outend,
&lirreversible
EXTRA_LOOP_ARGS);
else
/* Run the conversion loop. */
- status = GEN_unaligned (TO_LOOP) (inptrp, inend, &outbuf,
- outend, data->__statep,
- data->__flags,
- step->__data,
+ status = GEN_unaligned (TO_LOOP) (step, data, inptrp, inend,
+ &outbuf, outend,
&lirreversible
EXTRA_LOOP_ARGS);
}
int result;
result = DL_CALL_FCT (fct, (next_step, next_data, &outerr,
- outbuf, irreversible, 0,
+ outbuf, next_data->__outbuf,
+ irreversible, 0,
consume_incomplete));
if (result != __GCONV_EMPTY_INPUT)
/* XXX Handle unaligned access here as well. */
if (FROM_DIRECTION)
/* Run the conversion loop. */
- nstatus = FROM_LOOP ((const unsigned char **) inptrp,
+ nstatus = FROM_LOOP (step, data,
+ (const unsigned char **) inptrp,
(const unsigned char *) inend,
(unsigned char **) &outbuf,
(unsigned char *) outerr,
- data->__statep, data->__flags,
- step->__data, &lirreversible
- EXTRA_LOOP_ARGS);
+ &lirreversible EXTRA_LOOP_ARGS);
else
/* Run the conversion loop. */
- nstatus = TO_LOOP ((const unsigned char **) inptrp,
+ nstatus = TO_LOOP (step, data,
+ (const unsigned char **) inptrp,
(const unsigned char *) inend,
(unsigned char **) &outbuf,
(unsigned char *) outerr,
- data->__statep, data->__flags,
- step->__data, &lirreversible
- EXTRA_LOOP_ARGS);
+ &lirreversible EXTRA_LOOP_ARGS);
/* We must run out of output buffer space in this
rerun. */
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
struct gap
\
++inptr; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
if (__builtin_expect (ch, 0) >= 0xffff) \
{ \
/* This is an illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
if (__builtin_expect (ch < rp->start, 0)) \
{ \
/* This is an illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
continue; \
} \
\
if (__builtin_expect (res, '\1') == '\0' && ch != 0) \
{ \
/* This is an illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
continue; \
} \
\
*outptr++ = res; \
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
+
#define FROM_LOOP from_generic
#define TO_LOOP to_generic
#define DEFINE_INIT 1
outptr += 4; \
++inptr; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
|| (__builtin_expect (from_ucs4[ch], '\1') == '\0' && ch != 0)) \
{ \
/* This is an illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
} \
else \
- *outptr++ = from_ucs4[ch]; \
- \
- inptr += 4; \
+ { \
+ *outptr++ = from_ucs4[ch]; \
+ inptr += 4; \
+ } \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
#include <string.h>
is also available. */ \
uint32_t ch2; \
\
- if (NEED_LENGTH_TEST && inptr + 1 >= inend) \
+ if (inptr + 1 >= inend) \
{ \
/* The second character is not available. */ \
result = __GCONV_INCOMPLETE_INPUT; \
\
inptr += incr; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
if (tmp[0] == '\0') \
{ \
/* Illegal characters. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
continue; \
} \
tmp[1] = '\0'; \
else \
{ \
/* Illegal characters. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
continue; \
} \
} \
if (__builtin_expect (cp[0], '\1') == '\0' && ch != 0) \
{ \
/* Illegal characters. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
continue; \
} \
} \
/* Now test for a possible second byte and write this if possible. */ \
if (cp[1] != '\0') \
{ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr >= outend, 0)) \
+ if (__builtin_expect (outptr >= outend, 0)) \
{ \
/* The result does not fit into the buffer. */ \
--outptr; \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
#include <stdlib.h>
uint32_t ch2; \
int idx; \
\
- if (NEED_LENGTH_TEST && inptr + 1 >= inend) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. */ \
result = __GCONV_INCOMPLETE_INPUT; \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
if (__builtin_expect (cp[0], '\1') == '\0' && ch != 0) \
{ \
/* Illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
+ continue; \
} \
else \
{ \
/* See whether there is enough room for the second byte we write. */ \
- if (NEED_LENGTH_TEST && __builtin_expect (cp[1], '\1') != '\0' \
+ if (__builtin_expect (cp[1], '\1') != '\0' \
&& __builtin_expect (outptr + 1 >= outend, 0)) \
{ \
/* We have not enough room. */ \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
#include <stdlib.h>
uint32_t ch2; \
int idx; \
\
- if (NEED_LENGTH_TEST && inptr + 1 >= inend) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. */ \
result = __GCONV_INCOMPLETE_INPUT; \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
if (__builtin_expect (cp[0], '\1') == '\0' && ch != 0) \
{ \
/* Illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
+ continue; \
} \
else \
{ \
/* See whether there is enough room for the second byte we write. */ \
- if (NEED_LENGTH_TEST && __builtin_expect (cp[1], '\1') != '\0' \
+ if (__builtin_expect (cp[1], '\1') != '\0' \
&& __builtin_expect (outptr + 1 >= outend, 0)) \
{ \
/* We have not enough room. */ \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gb2312.h>
#include <stdint.h>
next character is also available. */ \
const unsigned char *endp; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store \
the intermediate result. */ \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
{ \
size_t found; \
\
- found = ucs4_to_gb2312 (ch, outptr, \
- (NEED_LENGTH_TEST \
- ? outend - outptr : MAX_NEEDED_OUTPUT)); \
- if (!NEED_LENGTH_TEST || __builtin_expect (found, 1) != 0) \
+ found = ucs4_to_gb2312 (ch, outptr, outend - outptr); \
+ if (__builtin_expect (found, 1) != 0) \
{ \
if (__builtin_expect (found, 0) == __UNKNOWN_10646_CHAR) \
{ \
/* Illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
\
} \
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
#include <gconv.h>
#include <jis0201.h>
character is also available. */ \
int ch2; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store the \
intermediate result. */ \
/* This is code set 3: JIS X 0212-1990. */ \
endp = inptr + 1; \
\
- ch = jisx0212_to_ucs4 (&endp, \
- NEED_LENGTH_TEST ? inend - endp : 2, \
- 0x80); \
+ ch = jisx0212_to_ucs4 (&endp, inend - endp, 0x80); \
} \
else \
{ \
/* This is code set 1: JIS X 0208. */ \
endp = inptr; \
\
- ch = jisx0208_to_ucs4 (&endp, \
- NEED_LENGTH_TEST ? inend - inptr : 2, \
- 0x80); \
+ ch = jisx0208_to_ucs4 (&endp, inend - inptr, 0x80); \
} \
\
- if (NEED_LENGTH_TEST && __builtin_expect (ch, 1) == 0) \
+ if (__builtin_expect (ch, 1) == 0) \
{ \
/* Not enough input available. */ \
result = __GCONV_INCOMPLETE_INPUT; \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
size_t found; \
\
/* See whether we have room for at least two characters. */ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr + 1 >= outend, 0)) \
+ if (__builtin_expect (outptr + 1 >= outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
{ \
/* No JIS 0208 character. */ \
found = ucs4_to_jisx0212 (ch, outptr + 1, \
- (NEED_LENGTH_TEST \
- ? outend - outptr - 1 : 2)); \
+ outend - outptr - 1); \
\
if (__builtin_expect (found, 1) == 0) \
{ \
else \
{ \
/* Illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, \
+ &inptr, inend, *outptrp, \
+ &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
} \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
#include <ksc5601.h>
{ \
/* Two-byte character. First test whether the next character \
is also available. */ \
- ch = ksc5601_to_ucs4 (&inptr, \
- NEED_LENGTH_TEST ? inptr - inend : 2, 0x80); \
- if (NEED_LENGTH_TEST && __builtin_expect (ch, 1) == 0) \
+ ch = ksc5601_to_ucs4 (&inptr, inptr - inend, 0x80); \
+ if (__builtin_expect (ch, 1) == 0) \
{ \
/* The second character is not available. */ \
result = __GCONV_INCOMPLETE_INPUT; \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
if (__builtin_expect (cp[0], '\1') == '\0' && ch != 0) \
{ \
/* Illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
\
/* Now test for a possible second byte and write this if possible. */ \
if (cp[1] != '\0') \
{ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr >= outend, 0)) \
+ if (__builtin_expect (outptr >= outend, 0)) \
{ \
/* The result does not fit into the buffer. */ \
--outptr; \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
#include <cns11643l1.h>
#include <cns11643.h>
else if ((ch <= 0xa0 || ch > 0xfe) && ch != 0x8e) \
{ \
/* This is illegal. */ \
- result = __GCONV_ILLEGAL_INPUT; \
- break; \
+ if (! ignore_errors_p ()) \
+ { \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ \
+ ++inptr; \
+ ++*irreversible; \
+ continue; \
} \
else \
{ \
character is also available. */ \
uint32_t ch2; \
\
- if (NEED_LENGTH_TEST && inptr + (ch == 0x8e ? 3 : 1) >= inend) \
+ if (inptr + (ch == 0x8e ? 3 : 1) >= inend) \
{ \
/* The second character is not available. Store the \
intermediate result. */ \
/* All second bytes of a multibyte character must be >= 0xa1. */ \
if (ch2 < 0xa1 || ch2 == 0xff) \
{ \
- /* This is an illegal character. */ \
- result = __GCONV_ILLEGAL_INPUT; \
- break; \
+ /* This is illegal. */ \
+ if (! ignore_errors_p ()) \
+ { \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ \
+ ++inptr; \
+ ++*irreversible; \
+ continue; \
} \
\
if (ch == 0x8e) \
/* This is code set 2: CNS 11643, planes 1 to 16. */ \
const char *endp = inptr + 1; \
\
- ch = cns11643_to_ucs4 (&endp, \
- NEED_LENGTH_TEST ? inend - inptr - 1 : 3, \
- 0x80); \
+ ch = cns11643_to_ucs4 (&endp, inend - inptr - 1, 0x80); \
/* Please note that we need not test for the missing input \
characters here anymore. */ \
if (ch == __UNKNOWN_10646_CHAR) \
{ \
/* Illegal input. */ \
- result = __GCONV_ILLEGAL_INPUT; \
- break; \
+ if (! ignore_errors_p ()) \
+ { \
+ /* This is an illegal character. */ \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ \
+ ++inptr; \
+ ++*irreversible; \
+ continue; \
} \
\
inptr += 4; \
/* This is code set 1: CNS 11643, plane 1. */ \
const unsigned char *endp = inptr; \
\
- ch = cns11643l1_to_ucs4 (&endp, \
- NEED_LENGTH_TEST ? inend - inptr : 2, \
- 0x80); \
+ ch = cns11643l1_to_ucs4 (&endp, inend - inptr, 0x80); \
/* Please note that we need not test for the missing input \
characters here anymore. */ \
if (ch == __UNKNOWN_10646_CHAR) \
{ \
/* Illegal input. */ \
- result = __GCONV_ILLEGAL_INPUT; \
- break; \
+ if (! ignore_errors_p ()) \
+ { \
+ /* This is an illegal character. */ \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ \
+ inptr += 2; \
+ ++*irreversible; \
+ continue; \
} \
\
inptr += 2; \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
/* Try the JIS character sets. */ \
size_t found; \
\
- found = ucs4_to_cns11643l1 (ch, outptr, \
- NEED_LENGTH_TEST ? outend - outptr : 2); \
- if (NEED_LENGTH_TEST && found == 0) \
+ found = ucs4_to_cns11643l1 (ch, outptr, outend - outptr); \
+ if (__builtin_expect (found, 1) == 0) \
{ \
/* We ran out of space. */ \
result = __GCONV_INCOMPLETE_INPUT; \
break; \
} \
- if (found != __UNKNOWN_10646_CHAR) \
+ if (__builtin_expect (found, 1) != __UNKNOWN_10646_CHAR) \
{ \
/* It's a CNS 11643, plane 1 character, adjust it for EUC-TW. */ \
*outptr++ += 0x80; \
{ \
/* No CNS 11643, plane 1 character. */ \
\
- found = ucs4_to_cns11643 (ch, outptr + 1, \
- (NEED_LENGTH_TEST \
- ? outend - outptr - 1 : 3)); \
- if (NEED_LENGTH_TEST && found == 0) \
+ found = ucs4_to_cns11643 (ch, outptr + 1, outend - outptr - 1); \
+ if (__builtin_expect (found, 1) == 0) \
{ \
/* We ran out of space. */ \
result = __GCONV_INCOMPLETE_INPUT; \
break; \
} \
- if (found == __UNKNOWN_10646_CHAR) \
+ if (__builtin_expect (found, 0) == __UNKNOWN_10646_CHAR) \
{ \
- /* No legal input. */ \
- result = __GCONV_ILLEGAL_INPUT; \
- break; \
+ /* Illegal character. */ \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
+ { \
+ result = __GCONV_ILLEGAL_INPUT; \
+ break; \
+ } \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
+ continue; \
} \
\
/* It's a CNS 11643 character, adjust it for EUC-TW. */ \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
UCS4 -> GB2312 -> GBK -> UCS4 \
\
might not produce identical text. */ \
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store \
the intermediate result. */ \
break; \
} \
\
- if (NEED_LENGTH_TEST && __builtin_expect (outend - outptr < 2, 0)) \
+ if (__builtin_expect (outend - outptr < 2, 0)) \
{ \
/* We ran out of space. */ \
result = __GCONV_FULL_OUTPUT; \
&& __builtin_expect (ch, 0xa1a1) <= 0xa8c0)) \
{ \
/* One of the characters we cannot map. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 2; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 2; \
+ ++*irreversible; \
+ } \
} \
else \
{ \
} \
} \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
\
if (ch > 0x7f) \
{ \
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store \
the intermediate result. */ \
break; \
} \
\
- if (NEED_LENGTH_TEST && __builtin_expect (outend - outptr < 2, 0)) \
+ if (__builtin_expect (outend - outptr < 2, 0)) \
{ \
/* We ran out of space. */ \
result = __GCONV_FULL_OUTPUT; \
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
#include <stdlib.h>
#define MIN_NEEDED_TO 4
-/* First define the conversion function from ISO 8859-1 to UCS4. */
+/* First define the conversion function from GBK to UCS4. */
#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
#define MAX_NEEDED_INPUT MAX_NEEDED_FROM
#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
uint32_t ch2; \
int idx; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store \
the intermediate result. */ \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
if (__builtin_expect (cp[0], '\1') == '\0' && ch != 0) \
{ \
/* Illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
+ continue; \
} \
/* See whether there is enough room for the second byte we write. */ \
- else if (NEED_LENGTH_TEST && cp[1] != '\0' \
- && __builtin_expect (outptr + 1 >= outend, 0)) \
+ else if (cp[1] != '\0' && __builtin_expect (outptr + 1 >= outend, 0)) \
{ \
/* We have not enough room. */ \
result = __GCONV_FULL_OUTPUT; \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
#include <string.h>
line; we can simply ignore them \
- the initial byte of the SS2 sequence. \
*/ \
- if (NEED_LENGTH_TEST \
- && (__builtin_expect (inptr + 1 > inend, 0) \
- || (inptr[1] == '$' \
- && (__builtin_expect (inptr + 2 > inend, 0) \
- || (inptr[2] == ')' \
- && __builtin_expect (inptr + 3 > inend, 0)) \
- || (inptr[2] == '*' \
- && __builtin_expect (inptr + 3 > inend, 0)))) \
- || (inptr[1] == SS2_1 \
- && __builtin_expect (inptr + 3 > inend, 0)))) \
+ if (__builtin_expect (inptr + 1 > inend, 0) \
+ || (inptr[1] == '$' \
+ && (__builtin_expect (inptr + 2 > inend, 0) \
+ || (inptr[2] == ')' \
+ && __builtin_expect (inptr + 3 > inend, 0)) \
+ || (inptr[2] == '*' \
+ && __builtin_expect (inptr + 3 > inend, 0)))) \
+ || (inptr[1] == SS2_1 \
+ && __builtin_expect (inptr + 3 > inend, 0))) \
{ \
result = __GCONV_EMPTY_INPUT; \
break; \
{ \
/* That's pretty easy, we have a dedicated functions for this. */ \
if (set == GB2312_set) \
- ch = gb2312_to_ucs4 (&inptr, \
- NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
+ ch = gb2312_to_ucs4 (&inptr, inend - inptr, 0); \
else \
{ \
assert (set == CNS11643_1_set); \
- ch = cns11643l1_to_ucs4 (&inptr, \
- NEED_LENGTH_TEST ? inend - inptr : 2, 0);\
+ ch = cns11643l1_to_ucs4 (&inptr, inend - inptr, 0); \
} \
\
- if (NEED_LENGTH_TEST && __builtin_expect (ch, 1) == 0) \
+ if (__builtin_expect (ch, 1) == 0) \
{ \
result = __GCONV_EMPTY_INPUT; \
break; \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS , int *setp
#define INIT_PARAMS int set = *setp & CURRENT_SEL_MASK; \
int ann = *setp & CURRENT_ANN_MASK
{ \
*outptr++ = SI; \
set = ASCII_set; \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr == outend, 0)) \
+ if (__builtin_expect (outptr == outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
else \
{ \
/* Even this does not work. Error. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, \
+ &inptr, inend, *outptrp, \
+ &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
} \
{ \
const char *escseq; \
\
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 4 > outend, 0)) \
+ if (__builtin_expect (outptr + 4 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
break; \
} \
} \
- else if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 2 > outend, 0)) \
+ else if (__builtin_expect (outptr + 2 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
/* Now that we wrote the output increment the input pointer. */ \
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS , int *setp
#define INIT_PARAMS int set = *setp & CURRENT_SEL_MASK; \
int ann = *setp & CURRENT_ANN_MASK
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
#include <stdlib.h>
JIS X 0208. Therefore I'm using the tables for JIS X \
0208-1990. If somebody has problems with this please \
provide the appropriate tables. */ \
- ch = jisx0208_to_ucs4 (&inptr, \
- NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
+ ch = jisx0208_to_ucs4 (&inptr, inend - inptr, 0); \
else if (set == JISX0212_set) \
/* Use the JIS X 0212 table. */ \
- ch = jisx0212_to_ucs4 (&inptr, \
- NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
+ ch = jisx0212_to_ucs4 (&inptr, inend - inptr, 0); \
else if (set == GB2312_set) \
/* Use the GB 2312 table. */ \
- ch = gb2312_to_ucs4 (&inptr, \
- NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
+ ch = gb2312_to_ucs4 (&inptr, inend - inptr, 0); \
else \
{ \
assert (set == KSC5601_set); \
\
/* Use the KSC 5601 table. */ \
- ch = ksc5601_to_ucs4 (&inptr, \
- NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
+ ch = ksc5601_to_ucs4 (&inptr, inend - inptr, 0); \
} \
\
- if (NEED_LENGTH_TEST && __builtin_expect (ch, 1) == 0) \
+ if (__builtin_expect (ch, 1) == 0) \
{ \
result = __GCONV_EMPTY_INPUT; \
break; \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS , enum variant var, int *setp
#define INIT_PARAMS int set = *setp & CURRENT_SEL_MASK; \
int set2 = *setp & CURRENT_ASSIGN_MASK
else \
{ \
if (set == JISX0208_1978_set || set == JISX0208_1983_set) \
- written = ucs4_to_jisx0208 (ch, outptr, \
- (NEED_LENGTH_TEST \
- ? outend - outptr : 2)); \
+ written = ucs4_to_jisx0208 (ch, outptr, outend - outptr); \
else if (set == JISX0212_set) \
- written = ucs4_to_jisx0212 (ch, outptr, \
- (NEED_LENGTH_TEST \
- ? outend - outptr : 2)); \
+ written = ucs4_to_jisx0212 (ch, outptr, outend - outptr); \
else if (set == GB2312_set) \
- written = ucs4_to_gb2312 (ch, outptr, (NEED_LENGTH_TEST \
- ? outend - outptr : 2)); \
+ written = ucs4_to_gb2312 (ch, outptr, outend - outptr); \
else \
{ \
assert (set == KSC5601_set); \
\
- written = ucs4_to_ksc5601 (ch, outptr, \
- (NEED_LENGTH_TEST \
- ? outend - outptr : 2)); \
+ written = ucs4_to_ksc5601 (ch, outptr, outend - outptr); \
} \
\
- if (NEED_LENGTH_TEST && __builtin_expect (written, 1) == 0) \
+ if (__builtin_expect (written, 1) == 0) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
{ \
/* We must encode using ASCII. First write out the \
escape sequence. */ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr + 3 > outend, 0))\
+ if (__builtin_expect (outptr + 3 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
*outptr++ = 'B'; \
set = ASCII_set; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (outptr + 1 > outend, 0))\
+ if (__builtin_expect (outptr + 1 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
if (written != __UNKNOWN_10646_CHAR && buf[0] < 0x80) \
{ \
/* We use JIS X 0201. */ \
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 3 > outend, 0)) \
+ if (__builtin_expect (outptr + 3 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
*outptr++ = 'J'; \
set = JISX0201_Roman_set; \
\
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 1 > outend, 0)) \
+ if (__builtin_expect (outptr + 1 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
if (written != __UNKNOWN_10646_CHAR) \
{ \
/* We use JIS X 0208. */ \
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 3 > outend, 0)) \
+ if (__builtin_expect (outptr + 3 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
*outptr++ = 'B'; \
set = JISX0208_1983_set; \
\
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 2 > outend, 0)) \
+ if (__builtin_expect (outptr + 2 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
else if (__builtin_expect (var, iso2022jp2) == iso2022jp) \
{ \
/* We have no other choice. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, \
+ &inptr, inend, *outptrp, \
+ &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
+ continue; \
} \
else \
{ \
if (written != __UNKNOWN_10646_CHAR) \
{ \
/* We use JIS X 0212. */ \
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 4 > outend, 0)) \
+ if (__builtin_expect (outptr + 4 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
*outptr++ = 'D'; \
set = JISX0212_set; \
\
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 2 > outend, 0)) \
+ if (__builtin_expect (outptr + 2 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
&& buf[0] >= 0x80) \
{ \
/* We use JIS X 0201. */ \
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 3 > outend, 0)) \
+ if (__builtin_expect (outptr + 3 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
*outptr++ = 'I'; \
set = JISX0201_Kana_set; \
\
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 1 > outend, 0)) \
+ if (__builtin_expect (outptr + 1 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
else if (ch != 0xa5 && ch >= 0x80 && ch <= 0xff) \
{ \
/* ISO 8859-1 upper half. */ \
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 3 > outend, 0)) \
+ if (__builtin_expect (outptr + 3 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
*outptr++ = 'A'; \
set2 = ISO88591_set; \
\
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 3 > outend, 0)) \
+ if (__builtin_expect (outptr + 3 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
if (written != __UNKNOWN_10646_CHAR) \
{ \
/* We use GB 2312. */ \
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 3 > outend, \
- 0)) \
+ if (__builtin_expect (outptr + 3 > outend, 0))\
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
*outptr++ = 'A'; \
set = GB2312_set; \
\
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 2 > outend, \
- 0)) \
+ if (__builtin_expect (outptr + 2 > outend, 0))\
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
if (written != __UNKNOWN_10646_CHAR) \
{ \
/* We use KSC 5601. */ \
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 4 \
- > outend, 0)) \
+ if (__builtin_expect (outptr + 4 > outend,\
+ 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
*outptr++ = 'C'; \
set = KSC5601_set; \
\
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 2 \
- > outend, 0)) \
+ if (__builtin_expect (outptr + 2 > outend,\
+ 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
if (__builtin_expect (gch, 1) != 0) \
{ \
/* We use ISO 8859-7 greek. */ \
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 3 \
- > outend, 0))\
+ if (__builtin_expect (outptr + 3 \
+ > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
*outptr++ = 'F'; \
set2 = ISO88597_set; \
\
- if (NEED_LENGTH_TEST \
- && __builtin_expect (outptr + 3 \
- > outend, 0))\
+ if (__builtin_expect (outptr + 3 \
+ > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
} \
else \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct \
+ != NULL) \
+ { \
+ result = DL_CALL_FCT \
+ (step_data->__trans.__trans_fct,\
+ (step, step_data, *inptrp, \
+ &inptr, inend, *outptrp, \
+ &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
+ continue; \
} \
} \
} \
/* Now that we wrote the output increment the input pointer. */ \
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS , enum variant var, int *setp
#define INIT_PARAMS int set = *setp & CURRENT_SEL_MASK; \
int set2 = *setp & CURRENT_ASSIGN_MASK
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
#include <string.h>
switching is done using the SI and SO bytes. But we have to \
recognize `Esc $ ) C' since this is a kind of flag for this \
encoding. We simply ignore it. */ \
- if ((NEED_LENGTH_TEST && __builtin_expect (inptr + 1 > inend, 0)) \
+ if (__builtin_expect (inptr + 1 > inend, 0) \
|| (inptr[1] == '$' \
- && ((NEED_LENGTH_TEST \
- && __builtin_expect (inptr + 2 > inend, 0)) \
+ && (__builtin_expect (inptr + 2 > inend, 0) \
|| (inptr[2] == ')' \
&& __builtin_expect (inptr + 3 > inend, 0))))) \
\
assert (set == KSC5601_set); \
\
/* Use the KSC 5601 table. */ \
- ch = ksc5601_to_ucs4 (&inptr, \
- NEED_LENGTH_TEST ? inend - inptr : 2, 0); \
+ ch = ksc5601_to_ucs4 (&inptr, inend - inptr, 0); \
\
- if (NEED_LENGTH_TEST && __builtin_expect (ch, 1) == 0) \
+ if (__builtin_expect (ch, 1) == 0) \
{ \
result = __GCONV_EMPTY_INPUT; \
break; \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS , int *setp
#define INIT_PARAMS int set = *setp
#define UPDATE_PARAMS *setp = set
{ \
*outptr++ = SI; \
set = ASCII_set; \
- if (NEED_LENGTH_TEST && outptr == outend) \
+ if (__builtin_expect (outptr == outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
if (__builtin_expect (written, 0) == __UNKNOWN_10646_CHAR) \
{ \
/* Illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
+ continue; \
} \
else \
{ \
set = KSC5601_set; \
} \
\
- if (NEED_LENGTH_TEST && __builtin_expect (outptr + 2 > outend, 0))\
+ if (__builtin_expect (outptr + 2 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
/* Now that we wrote the output increment the input pointer. */ \
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS , int *setp
#define INIT_PARAMS int set = *setp
#define UPDATE_PARAMS *setp = set
allows one to easily provide a tuned implementation in case this
proofs to be necessary. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
#include <stdlib.h>
} \
++inptr; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS , enum variant var
#include <iconv/loop.c>
\
if (__builtin_expect (failure, __GCONV_OK) == __GCONV_ILLEGAL_INPUT) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* Exit the loop with an error. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
+ continue; \
} \
else \
*outptr++ = (unsigned char) ch; \
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS , enum variant var
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
/* Definitions used in the body of the `gconv' function. */
if (__builtin_expect (ch, 0) > 0xff) \
{ \
/* We have an illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
+ continue; \
} \
else \
*outptr++ = (unsigned char) ch; \
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
/* Data taken from the WG15 tables. */
is also available. */ \
int ch2; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store the \
intermediate result. */ \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
if (__builtin_expect (ch, 0) \
>= sizeof (from_ucs4) / sizeof (from_ucs4[0])) \
{ \
- int fail = 0; \
switch (ch) \
{ \
case 0x2c7: \
cp = "\xd5"; \
break; \
default: \
- cp = NULL; \
- fail = 1; \
- } \
- \
- if (__builtin_expect (fail, 0)) \
- { \
/* Illegal characters. */ \
- if (! ignore_errors_p ()) \
+ cp = NULL; \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
} \
else if (__builtin_expect (from_ucs4[ch][0], '\1') == '\0' && ch != 0) \
{ \
/* Illegal characters. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
else \
/* Now test for a possible second byte and write this if possible. */ \
if (cp[1] != '\0') \
{ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr >= outend, 0)) \
+ if (__builtin_expect (outptr >= outend, 0)) \
{ \
/* The result does not fit into the buffer. */ \
--outptr; \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
/* Data taken from the WG15 tables. */
is also available. */ \
int ch2; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store the \
intermediate result. */ \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
if (__builtin_expect (fail, 0)) \
{ \
/* Illegal characters. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
} \
else if (__builtin_expect (from_ucs4[ch][0], '\1') == '\0' && ch != 0) \
{ \
/* Illegal characters. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
else \
/* Now test for a possible second byte and write this if possible. */ \
if (cp[1] != '\0') \
{ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr >= outend, 0)) \
+ if (__builtin_expect (outptr >= outend, 0)) \
{ \
/* The result does not fit into the buffer. */ \
--outptr; \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
#include <ksc5601.h>
uint32_t ch2; \
uint_fast32_t idx; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store the \
intermediate result. */ \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
{ \
if (ch >= 0xac00 && ch <= 0xd7a3) \
{ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr + 2 > outend, 0))\
+ if (__builtin_expect (outptr + 2 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
{ \
ch = jamo_from_ucs_table[ch - 0x3131]; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (outptr + 2 > outend, 0))\
+ if (__builtin_expect (outptr + 2 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
size_t written; \
uint32_t temp; \
\
- written = ucs4_to_ksc5601_hanja (ch, outptr, \
- (NEED_LENGTH_TEST \
- ? outend - outptr : 2)); \
- if (NEED_LENGTH_TEST && __builtin_expect (written, 1) == 0) \
+ written = ucs4_to_ksc5601_hanja (ch, outptr, outend - outptr); \
+ if (__builtin_expect (written, 1) == 0) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
} \
if (__builtin_expect (written, 0) == __UNKNOWN_10646_CHAR) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
\
{ \
size_t written; \
\
- written = ucs4_to_ksc5601_sym (ch, outptr, \
- (NEED_LENGTH_TEST \
- ? outend - outptr : 2)); \
- if (NEED_LENGTH_TEST && __builtin_expect (written, 1) == 0) \
+ written = ucs4_to_ksc5601_sym (ch, outptr, outend - outptr); \
+ if (__builtin_expect (written, 1) == 0) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
} \
if (__builtin_expect (written, 1) == __UNKNOWN_10646_CHAR) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
\
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
#include <wchar.h>
uint32_t ch2; \
uint_fast32_t idx; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store \
the intermediate result. */ \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
else \
{ \
/* Illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
} \
if (__builtin_expect (cp[0], '\1') == '\0' && ch != 0) \
{ \
/* Illegal character. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
+ continue; \
} \
else \
{ \
/* Now test for a possible second byte and write this if possible. */\
if (cp[1] != '\0') \
{ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr >= outend, 0)) \
+ if (__builtin_expect (outptr >= outend, 0)) \
{ \
/* The result does not fit into the buffer. */ \
result = __GCONV_FULL_OUTPUT; \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdint.h>
#include <string.h>
is also available. */ \
uint32_t ch2; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. */ \
result = __GCONV_INCOMPLETE_INPUT; \
} \
inptr += increment; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
|| __builtin_expect (ch, 0x2d8) == 0x02dc) \
{ \
/* Illegal characters. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
else \
if (__builtin_expect (cp[0], '\1') == '\0' && ch != 0) \
{ \
/* Illegal. */ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
} \
/* Now test for a possible second byte and write this if possible. */ \
if (cp[1] != '\0') \
{ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr >= outend, 0)) \
+ if (__builtin_expect (outptr >= outend, 0)) \
{ \
/* The result does not fit into the buffer. */ \
--outptr; \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <stdint.h>
#include <ksc5601.h>
is also available. */ \
uint32_t ch2; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 1 >= inend, 0)) \
+ if (__builtin_expect (inptr + 1 >= inend, 0)) \
{ \
/* The second character is not available. Store \
the intermediate result. */ \
put32 (outptr, ch); \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
{ \
const char *s = uhc_hangul_from_ucs[ch - 0xac00]; \
\
- if (NEED_LENGTH_TEST && __builtin_expect (outptr + 2 > outend, 0)) \
+ if (__builtin_expect (outptr + 2 > outend, 0)) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
} \
else if ((ch >= 0x4e00 && ch <= 0x9fa5) || (ch >= 0xf900 && ch <= 0xfa0b))\
{ \
- size_t written = ucs4_to_ksc5601_hanja (ch, outptr, \
- (NEED_LENGTH_TEST \
- ? outend - outptr : 2)); \
+ size_t written = ucs4_to_ksc5601_hanja (ch, outptr, outend - outptr); \
\
- if (NEED_LENGTH_TEST && __builtin_expect (written, 1) == 0) \
+ if (__builtin_expect (written, 1) == 0) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
} \
if (__builtin_expect (written, 0) == __UNKNOWN_10646_CHAR) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
\
*/ \
else \
{ \
- size_t written = ucs4_to_ksc5601_sym (ch, outptr, \
- (NEED_LENGTH_TEST \
- ? outend - outptr : 2)); \
+ size_t written = ucs4_to_ksc5601_sym (ch, outptr, outend - outptr); \
\
- if (NEED_LENGTH_TEST && __builtin_expect (written, 1) == 0) \
+ if (__builtin_expect (written, 1) == 0) \
{ \
result = __GCONV_FULL_OUTPUT; \
break; \
} \
if (__builtin_expect (written, 0) == __UNKNOWN_10646_CHAR) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- inptr += 4; \
- ++*irreversible; \
+ else \
+ { \
+ inptr += 4; \
+ ++*irreversible; \
+ } \
continue; \
} \
\
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#include <iconv/loop.c>
Boston, MA 02111-1307, USA. */
#include <byteswap.h>
+#include <dlfcn.h>
#include <gconv.h>
#include <stddef.h>
#include <stdint.h>
outbuf += 2; \
} \
swap = ((struct unicode_data *) step->__data)->swap;
-#define EXTRA_LOOP_ARGS , data, swap
+#define EXTRA_LOOP_ARGS , swap
/* Direction of the transformation. */
\
if (__builtin_expect (c, 0) >= 0x10000) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, inend, \
+ *outptrp, &outptr, outend, irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
+ continue; \
} \
else \
{ \
\
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS \
- , struct __gconv_step_data *step_data, int swap
+ , int swap
#include <iconv/loop.c>
outptr += 4; \
}
#define EXTRA_LOOP_DECLS \
- , struct __gconv_step_data *step_data, int swap
+ , int swap
#include <iconv/loop.c>
Boston, MA 02111-1307, USA. */
#include <byteswap.h>
+#include <dlfcn.h>
#include <gconv.h>
#include <stddef.h>
#include <stdint.h>
put16u (outbuf, BOM); \
outbuf += 2; \
}
-#define EXTRA_LOOP_ARGS , var, data, swap
+#define EXTRA_LOOP_ARGS , var, swap
/* Direction of the transformation. */
{ \
if (__builtin_expect (c, 0) >= 0x110000) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
continue; \
} \
\
/* Generate a surrogate character. */ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr + 4 > outend, 0))\
+ if (__builtin_expect (outptr + 4 > outend, 0)) \
{ \
/* Overflow in the output buffer. */ \
result = __GCONV_FULL_OUTPUT; \
{ \
if (__builtin_expect (c, 0) >= 0x110000) \
{ \
- if (! ignore_errors_p ()) \
+ if (step_data->__trans.__trans_fct != NULL) \
+ { \
+ result = DL_CALL_FCT (step_data->__trans.__trans_fct, \
+ (step, step_data, *inptrp, &inptr, \
+ inend, *outptrp, &outptr, outend, \
+ irreversible)); \
+ if (result != __GCONV_OK) \
+ break; \
+ } \
+ else if (! ignore_errors_p ()) \
{ \
/* This is an illegal character. */ \
result = __GCONV_ILLEGAL_INPUT; \
break; \
} \
- \
- ++*irreversible; \
- inptr += 4; \
+ else \
+ { \
+ ++*irreversible; \
+ inptr += 4; \
+ } \
continue; \
} \
\
/* Generate a surrogate character. */ \
- if (NEED_LENGTH_TEST && __builtin_expect (outptr + 4 > outend, 0))\
+ if (__builtin_expect (outptr + 4 > outend, 0)) \
{ \
/* Overflow in the output buffer. */ \
result = __GCONV_FULL_OUTPUT; \
outptr += 2; \
inptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS \
- , enum variant var, struct __gconv_step_data *step_data, int swap
+ , enum variant var, int swap
#include <iconv/loop.c>
\
/* It's a surrogate character. At least the first word says \
it is. */ \
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 4 > inend, 0)) \
+ if (__builtin_expect (inptr + 4 > inend, 0)) \
{ \
/* We don't have enough input for another complete input \
character. */ \
\
/* It's a surrogate character. At least the first word says \
it is. */ \
- if (NEED_LENGTH_TEST && __builtin_expect (inptr + 4 > inend, 0)) \
+ if (__builtin_expect (inptr + 4 > inend, 0)) \
{ \
/* We don't have enough input for another complete input \
character. */ \
} \
outptr += 4; \
}
+#define LOOP_NEED_FLAGS
#define EXTRA_LOOP_DECLS \
- , enum variant var, struct __gconv_step_data *step_data, int swap
+ , enum variant var, int swap
#include <iconv/loop.c>
common_objpfx=$1
objpfx=$2
+GCONV_PATH=${common_objpfx}iconvdata
+export GCONV_PATH
+
# Generate the test data.
test -d ${objpfx}domaindir || mkdir ${objpfx}domaindir
# Create the locale directories.
#include <libioP.h>
#ifdef _LIBC
+# include <dlfcn.h>
# include <wchar.h>
#endif
#include <stdlib.h>
#ifdef _LIBC
struct __gconv_step *gs = codecvt->__cd_out.__cd.__steps;
int status;
- size_t written;
+ size_t dummy;
const unsigned char *from_start_copy = (unsigned char *) from_start;
codecvt->__cd_out.__cd.__data[0].__outbuf = to_start;
codecvt->__cd_out.__cd.__data[0].__outbufend = to_end;
codecvt->__cd_out.__cd.__data[0].__statep = statep;
- status = (*gs->__fct) (gs, codecvt->__cd_out.__cd.__data, &from_start_copy,
- (const unsigned char *) from_end, &written, 0, 0);
+ status = DL_CALL_FCT (gs->__fct,
+ (gs, codecvt->__cd_out.__cd.__data, &from_start_copy,
+ (const unsigned char *) from_end, to_start,
+ &dummy, 0, 0));
*from_stop = (wchar_t *) from_start_copy;
*to_stop = codecvt->__cd_out.__cd.__data[0].__outbuf;
#ifdef _LIBC
struct __gconv_step *gs = codecvt->__cd_out.__cd.__steps;
int status;
- size_t written;
+ size_t dummy;
codecvt->__cd_out.__cd.__data[0].__outbuf = to_start;
codecvt->__cd_out.__cd.__data[0].__outbufend = to_end;
codecvt->__cd_out.__cd.__data[0].__statep = statep;
- status = (*gs->__fct) (gs, codecvt->__cd_out.__cd.__data, NULL, NULL,
- &written, 1, 0);
+ status = DL_CALL_FCT (gs->__fct,
+ (gs, codecvt->__cd_out.__cd.__data, NULL, NULL,
+ to_start, &dummy, 1, 0));
*to_stop = codecvt->__cd_out.__cd.__data[0].__outbuf;
#ifdef _LIBC
struct __gconv_step *gs = codecvt->__cd_in.__cd.__steps;
int status;
- size_t written;
+ size_t dummy;
const unsigned char *from_start_copy = (unsigned char *) from_start;
codecvt->__cd_in.__cd.__data[0].__outbuf = (char *) to_start;
codecvt->__cd_in.__cd.__data[0].__outbufend = (char *) to_end;
codecvt->__cd_in.__cd.__data[0].__statep = statep;
- status = (*gs->__fct) (gs, codecvt->__cd_in.__cd.__data, &from_start_copy,
- from_end, &written, 0, 0);
+ status = DL_CALL_FCT (gs->__fct,
+ (gs, codecvt->__cd_in.__cd.__data, &from_start_copy,
+ from_end, (char *) to_start, &dummy, 0, 0));
*from_stop = from_start_copy;
*to_stop = (wchar_t *) codecvt->__cd_in.__cd.__data[0].__outbuf;
wchar_t to_buf[max];
struct __gconv_step *gs = codecvt->__cd_in.__cd.__steps;
int status;
- size_t written;
+ size_t dummy;
codecvt->__cd_in.__cd.__data[0].__outbuf = (char *) to_buf;
codecvt->__cd_in.__cd.__data[0].__outbufend = (char *) &to_buf[max];
codecvt->__cd_in.__cd.__data[0].__statep = statep;
- status = (*gs->__fct) (gs, codecvt->__cd_in.__cd.__data, &cp, from_end,
- &written, 0, 0);
+ status = DL_CALL_FCT (gs->__fct,
+ (gs, codecvt->__cd_in.__cd.__data, &cp, from_end,
+ (char *) to_buf, &dummy, 0, 0));
result = cp - (const unsigned char *) from_start;
#else
2000-06-12 Ulrich Drepper <drepper@redhat.com>
+ * Makefile (tests): Add joinrace.
+
* Examples/ex6.c: Test return value of pthread_join.
2000-06-11 Geoff Keating <geoffk@cygnus.com>
oldsemaphore events getcpuclockid pspinlock
vpath %.c Examples
-tests = ex1 ex2 ex3 ex4 ex5 ex6 ex7 ex8
+tests = ex1 ex2 ex3 ex4 ex5 ex6 ex7 ex8 joinrace
include ../Rules
$(objpfx)ex6: $(libpthread)
$(objpfx)ex7: $(libpthread)
$(objpfx)ex8: $(libpthread)
+$(objpfx)joinrace: $(libpthread)
-# Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+# Copyright (C) 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
# leapseconds.
testdata = $(objpfx)testdata
define build-testdata
-$(built-program-cmd) -d $(testdata) -y ./yearistype $<
+GCONV_PATH=${common-objpfx}iconvdata \
+ $(built-program-cmd) -d $(testdata) -y ./yearistype $<
endef
$(objpfx)test-tz.out: $(addprefix $(testdata)/, America/New_York Etc/UTC UTC)
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdio.h>
#include <string.h>
/* Create the input string. */
inbuf[0] = c;
- status = (*__wcsmbs_gconv_fcts.towc->__fct) (__wcsmbs_gconv_fcts.towc, &data,
- &inptr, inptr + 1, &dummy,
- 0, 1);
+ status = DL_CALL_FCT (__wcsmbs_gconv_fcts.towc->__fct,
+ (__wcsmbs_gconv_fcts.towc, &data, &inptr, inptr + 1,
+ data.__outbuf, &dummy, 0, 1));
/* The conversion failed. */
if (status != __GCONV_OK && status != __GCONV_FULL_OUTPUT
&& status != __GCONV_EMPTY_INPUT)
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <errno.h>
#include <gconv.h>
#include <wchar.h>
/* Do a normal conversion. */
inbuf = (const unsigned char *) s;
- status = (*__wcsmbs_gconv_fcts.towc->__fct) (__wcsmbs_gconv_fcts.towc,
- &data, &inbuf, inbuf + n,
- &dummy, 0, 1);
+ status = DL_CALL_FCT (__wcsmbs_gconv_fcts.towc->__fct,
+ (__wcsmbs_gconv_fcts.towc, &data, &inbuf, inbuf + n,
+ data.__outbuf, &dummy, 0, 1));
/* There must not be any problems with the conversion but illegal input
characters. The output buffer must be large enough, otherwise the
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <errno.h>
#include <gconv.h>
#include <string.h>
size_t result;
int status;
struct __gconv_step *towc;
- size_t non_reversible;
+ size_t dummy;
/* Tell where we want the result. */
data.__invocation_counter = 0;
{
data.__outbuf = (unsigned char *) buf;
- status = (*towc->__fct) (__wcsmbs_gconv_fcts.towc, &data, &inbuf,
- srcend, &non_reversible, 0, 1);
+ status = DL_CALL_FCT (towc->__fct,
+ (towc, &data, &inbuf, srcend, data.__outbuf,
+ &dummy, 0, 1));
result += (wchar_t *) data.__outbuf - buf;
}
data.__outbuf = (unsigned char *) dst;
data.__outbufend = data.__outbuf + len * sizeof (wchar_t);
- status = (*towc->__fct) (__wcsmbs_gconv_fcts.towc, &data,
- (const unsigned char **) src, srcend,
- &non_reversible, 0, 1);
+ status = DL_CALL_FCT (towc->__fct,
+ (towc, &data, (const unsigned char **) src, srcend,
+ data.__outbuf, &dummy, 0, 1));
result = (wchar_t *) data.__outbuf - dst;
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <errno.h>
#include <gconv.h>
#include <stdlib.h>
{
data.__outbuf = (char *) buf;
- status = (*towc->__fct) (__wcsmbs_gconv_fcts.towc, &data, &inbuf,
- srcend, &non_reversible, 0, 1);
+ status = DL_CALL_FCT (towc->__fct,
+ (towc, &data, &inbuf, srcend, data.__outbuf,
+ &non_reversible, 0, 1));
result += (wchar_t *) data.__outbuf - buf;
}
data.__outbuf = (unsigned char *) dst;
data.__outbufend = data.__outbuf + len * sizeof (wchar_t);
- status = (*towc->__fct) (__wcsmbs_gconv_fcts.towc, &data,
- (const unsigned char **) src, srcend,
- &non_reversible, 0, 1);
+ status = DL_CALL_FCT (towc->__fct,
+ (towc, &data, (const unsigned char **) src, srcend,
+ data.__outbuf, &non_reversible, 0, 1));
result = (wchar_t *) data.__outbuf - dst;
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <errno.h>
#include <gconv.h>
#include <stdlib.h>
by a NUL byte. */
if (wc == L'\0')
{
- status = (*__wcsmbs_gconv_fcts.tomb->__fct) (__wcsmbs_gconv_fcts.tomb,
- &data, NULL, NULL,
- &dummy, 1, 1);
+ status = DL_CALL_FCT (__wcsmbs_gconv_fcts.tomb->__fct,
+ (__wcsmbs_gconv_fcts.tomb, &data, NULL, NULL,
+ data.__outbuf, &dummy, 1, 1));
if (status == __GCONV_OK || status == __GCONV_EMPTY_INPUT)
*data.__outbuf++ = '\0';
/* Do a normal conversion. */
const unsigned char *inbuf = (const unsigned char *) &wc;
- status = (*__wcsmbs_gconv_fcts.tomb->__fct) (__wcsmbs_gconv_fcts.tomb,
- &data, &inbuf,
- inbuf + sizeof (wchar_t),
- &dummy, 0, 1);
+ status = DL_CALL_FCT (__wcsmbs_gconv_fcts.tomb->__fct,
+ (__wcsmbs_gconv_fcts.tomb, &data, &inbuf,
+ inbuf + sizeof (wchar_t), data.__outbuf, &dummy,
+ 0, 1));
}
/* There must not be any problems with the conversion but illegal input
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <errno.h>
#include <gconv.h>
#include <wchar.h>
{
data.__outbuf = buf;
- status = (*tomb->__fct) (__wcsmbs_gconv_fcts.tomb, &data,
- (const unsigned char **) &inbuf,
- (const unsigned char *) srcend, &dummy,
- 0, 1);
+ status = DL_CALL_FCT (tomb->__fct,
+ (tomb, &data, (const unsigned char **) &inbuf,
+ (const unsigned char *) srcend, data.__outbuf,
+ &dummy, 0, 1));
/* Count the number of bytes. */
result += data.__outbuf - buf;
data.__outbuf = dst;
data.__outbufend = dst + len;
- status = (*tomb->__fct) (__wcsmbs_gconv_fcts.tomb, &data,
- (const unsigned char **) src,
- (const unsigned char *) srcend, &dummy, 0, 1);
+ status = DL_CALL_FCT (tomb->__fct,
+ (tomb, &data, (const unsigned char **) src,
+ (const unsigned char *) srcend, data.__outbuf,
+ &dummy, 0, 1));
/* Count the number of bytes. */
result = data.__outbuf - (unsigned char *) dst;
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <errno.h>
#include <stdlib.h>
#include <gconv.h>
{
data.__outbuf = buf;
- status = (*tomb->__fct) (__wcsmbs_gconv_fcts.tomb, &data,
- (const unsigned char **) &inbuf,
- (const unsigned char *) srcend, &dummy,
- 0, 1);
+ status = DL_CALL_FCT (tomb->__fct,
+ (tomb, &data, (const unsigned char **) &inbuf,
+ (const unsigned char *) srcend, data.__outbuf,
+ &dummy, 0, 1));
/* Count the number of bytes. */
result += data.__outbuf - buf;
data.__outbuf = dst;
data.__outbufend = dst + len;
- status = (*tomb->__fct) (__wcsmbs_gconv_fcts.tomb, &data,
- (const unsigned char **) src,
- (const unsigned char *) srcend, &dummy, 0, 1);
+ status = DL_CALL_FCT (tomb->__fct,
+ (tomb, &data, (const unsigned char **) src,
+ (const unsigned char *) srcend, data.__outbuf,
+ &dummy, 0, 1));
/* Count the number of bytes. */
result = data.__outbuf - (unsigned char *) dst;
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#include <dlfcn.h>
#include <gconv.h>
#include <stdio.h>
#include <string.h>
/* Create the input string. */
inbuf[0] = c;
- status = (*__wcsmbs_gconv_fcts.tomb->__fct) (__wcsmbs_gconv_fcts.tomb, &data,
- (const unsigned char **) &inptr,
- (const unsigned char *) &inbuf[1],
- &dummy, 0, 1);
+ status = DL_CALL_FCT (__wcsmbs_gconv_fcts.tomb->__fct,
+ (__wcsmbs_gconv_fcts.tomb, &data,
+ (const unsigned char **) &inptr,
+ (const unsigned char *) &inbuf[1],
+ data.__outbuf, &dummy, 0, 1));
+
/* The conversion failed or the output is too long. */
if ((status != __GCONV_OK && status != __GCONV_FULL_OUTPUT
&& status != __GCONV_EMPTY_INPUT)