This is the mail archive of the gcc-bugs@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

c/4117: Got a internal error when make php



>Number:         4117
>Category:       c
>Synopsis:       Got a internal error when make php
>Confidential:   no
>Severity:       serious
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          ice-on-illegal-code
>Submitter-Id:   net
>Arrival-Date:   Fri Aug 24 08:26:01 PDT 2001
>Closed-Date:
>Last-Modified:
>Originator:     
>Release:        3.0.1
>Organization:
>Environment:
System: Linux qizhi.homeip.net 2.2.16-22 #1 Tue Aug 22 16:49:06 EDT 2000 i686 unknown
Architecture: i686

	
host: i686-pc-linux-gnu
build: i686-pc-linux-gnu
target: i686-pc-linux-gnu
configured with: ../gcc-3.0.1/configure --enable-shared --enable-threads
>Description:
	When make php-4.0.6 as an Apache module, got segmentation fault.
	It seems enabling multi-bite string feature of PHP4 causes the problem.
>How-To-Repeat:
	tar xzvf php-4.0.6.tar.gz
	cd php-4.0.6
	./configure --with-apxs=/usr/local/apache/bin/apxs --with-mysql=/usr/local/mysql --with-pgsql=/usr/local/pgsql --with-pspell --enable-mbstring --enable-memory-limit --enable-trans-sid
	make
	... ...
	/bin/sh /usr/local/src/temp/php-4.0.6/libtool --silent --mode=compile gcc  -E -I. -I/usr/local/src/temp/php-4.0.6/ext/mbstring -I/usr/local/src/temp/php-4.0.6/main -I/usr/local/src/temp/php-4.0.6 -I/usr/local/apache/include -I/usr/local/src/temp/php-4.0.6/Zend -I/usr/local/mysql/include/mysql -I/usr/include/pspell -I/usr/local/src/temp/php-4.0.6/ext/xml/expat/xmltok -I/usr/local/src/temp/php-4.0.6/ext/xml/expat/xmlparse -I/usr/local/src/temp/php-4.0.6/TSRM  -DLINUX=22 -DMOD_PERL -DUSE_HSREGEX -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -DSUPPORT_UTF8 -DXML_BYTE_ORDER=12 -g -O2  -c mbfilter.c
	mbfilter.c:129: Internal error: Segmentation fault
	Please submit a full bug report,
	with preprocessed source if appropriate.
	See <URL:http://www.gnu.org/software/gcc/bugs.html> for instructions.
	make[3]: *** [mbfilter.lo] Error 1
	make[3]: Leaving directory `/usr/local/src/temp/php-4.0.6/ext/mbstring'
	make[2]: *** [all-recursive] Error 1
	make[2]: Leaving directory `/usr/local/src/temp/php-4.0.6/ext/mbstring'
	make[1]: *** [all-recursive] Error 1
	make[1]: Leaving directory `/usr/local/src/temp/php-4.0.6/ext'
	make: *** [all-recursive] Error 1

	
	----preprocessor output for mbfilter.c --- begin ---
# 83 "mbfilter.c"
# 1 "/usr/include/stdlib.h" 1 3
# 25 "/usr/include/stdlib.h" 3
# 1 "/usr/include/features.h" 1 3
# 282 "/usr/include/features.h" 3
# 1 "/usr/include/sys/cdefs.h" 1 3
# 283 "/usr/include/features.h" 2 3
# 310 "/usr/include/features.h" 3
# 1 "/usr/include/gnu/stubs.h" 1 3
# 311 "/usr/include/features.h" 2 3
# 26 "/usr/include/stdlib.h" 2 3







# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 199 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 3
typedef unsigned int size_t;
# 287 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 3
typedef long int wchar_t;
# 34 "/usr/include/stdlib.h" 2 3
# 94 "/usr/include/stdlib.h" 3
typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;
# 133 "/usr/include/stdlib.h" 3
extern size_t __ctype_get_mb_cur_max (void) ;



extern double atof (__const char *__nptr) __attribute__ ((__pure__));

extern int atoi (__const char *__nptr) __attribute__ ((__pure__));

extern long int atol (__const char *__nptr) __attribute__ ((__pure__));



__extension__ extern long long int atoll (__const char *__nptr)
             __attribute__ ((__pure__));



extern double strtod (__const char *__restrict __nptr,
                      char **__restrict __endptr) ;
# 163 "/usr/include/stdlib.h" 3
extern long int strtol (__const char *__restrict __nptr,
                        char **__restrict __endptr, int __base) ;

extern unsigned long int strtoul (__const char *__restrict __nptr,
                                  char **__restrict __endptr, int __base)
            ;



__extension__
extern long long int strtoq (__const char *__restrict __nptr,
                             char **__restrict __endptr, int __base) ;

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
                                       char **__restrict __endptr, int __base)
            ;






__extension__
extern long long int strtoll (__const char *__restrict __nptr,
                              char **__restrict __endptr, int __base) ;

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
                                        char **__restrict __endptr, int __base)
            ;
# 250 "/usr/include/stdlib.h" 3
extern double __strtod_internal (__const char *__restrict __nptr,
                                 char **__restrict __endptr, int __group)
            ;
extern float __strtof_internal (__const char *__restrict __nptr,
                                char **__restrict __endptr, int __group)
            ;
extern long double __strtold_internal (__const char *__restrict __nptr,
                                       char **__restrict __endptr,
                                       int __group) ;

extern long int __strtol_internal (__const char *__restrict __nptr,
                                   char **__restrict __endptr,
                                   int __base, int __group) ;



extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
                                             char **__restrict __endptr,
                                             int __base, int __group) ;




__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr,
                                         char **__restrict __endptr,
                                         int __base, int __group) ;



__extension__
extern unsigned long long int __strtoull_internal (__const char *
                                                   __restrict __nptr,
                                                   char **__restrict __endptr,
                                                   int __base, int __group)
            ;
# 294 "/usr/include/stdlib.h" 3
extern __inline double
strtod (__const char *__restrict __nptr, char **__restrict __endptr)
{
  return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
strtol (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base)
{
  return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
strtoul (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base)
{
  return __strtoul_internal (__nptr, __endptr, __base, 0);
}
# 326 "/usr/include/stdlib.h" 3
__extension__ extern __inline long long int
strtoq (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base)
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtouq (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base)
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}



__extension__ extern __inline long long int
strtoll (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base)
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtoull (__const char * __restrict __nptr, char **__restrict __endptr,
          int __base)
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}


extern __inline double
atof (__const char *__nptr)
{
  return strtod (__nptr, (char **) ((void *)0));
}
extern __inline int
atoi (__const char *__nptr)
{
  return (int) strtol (__nptr, (char **) ((void *)0), 10);
}
extern __inline long int
atol (__const char *__nptr)
{
  return strtol (__nptr, (char **) ((void *)0), 10);
}


__extension__ extern __inline long long int
atoll (__const char *__nptr)
{
  return strtoll (__nptr, (char **) ((void *)0), 10);
}
# 385 "/usr/include/stdlib.h" 3
extern char *l64a (long int __n) ;


extern long int a64l (__const char *__s) __attribute__ ((__pure__));


# 1 "/usr/include/sys/types.h" 1 3
# 26 "/usr/include/sys/types.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/sys/types.h" 2 3



# 1 "/usr/include/bits/types.h" 1 3
# 26 "/usr/include/bits/types.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/bits/types.h" 2 3


# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 30 "/usr/include/bits/types.h" 2 3


typedef unsigned char __u_char;
typedef unsigned short __u_short;
typedef unsigned int __u_int;
typedef unsigned long __u_long;

__extension__ typedef unsigned long long int __u_quad_t;
__extension__ typedef long long int __quad_t;
# 49 "/usr/include/bits/types.h" 3
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;

typedef __quad_t *__qaddr_t;

typedef __u_quad_t __dev_t;
typedef __u_int __uid_t;
typedef __u_int __gid_t;
typedef __u_long __ino_t;
typedef __u_int __mode_t;
typedef __u_int __nlink_t;
typedef long int __off_t;
typedef __quad_t __loff_t;
typedef int __pid_t;
typedef int __ssize_t;
typedef __u_long __rlim_t;
typedef __u_quad_t __rlim64_t;
typedef __u_int __id_t;

typedef struct
  {
    int __val[2];
  } __fsid_t;


typedef int __daddr_t;
typedef char *__caddr_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef long int __swblk_t;

typedef long int __clock_t;


typedef int __clockid_t;


typedef int __timer_t;



typedef unsigned long int __fd_mask;
# 109 "/usr/include/bits/types.h" 3
typedef struct
  {






    __fd_mask __fds_bits[1024 / (8 * sizeof (__fd_mask))];


  } __fd_set;


typedef int __key_t;


typedef unsigned short int __ipc_pid_t;



typedef long int __blksize_t;




typedef long int __blkcnt_t;
typedef __quad_t __blkcnt64_t;


typedef __u_long __fsblkcnt_t;
typedef __u_quad_t __fsblkcnt64_t;


typedef __u_long __fsfilcnt_t;
typedef __u_quad_t __fsfilcnt64_t;


typedef __u_quad_t __ino64_t;


typedef __loff_t __off64_t;


typedef long int __t_scalar_t;
typedef unsigned long int __t_uscalar_t;


typedef int __intptr_t;


typedef unsigned int __socklen_t;




# 1 "/usr/include/bits/pthreadtypes.h" 1 3
# 23 "/usr/include/bits/pthreadtypes.h" 3
# 1 "/usr/include/bits/sched.h" 1 3
# 68 "/usr/include/bits/sched.h" 3
struct __sched_param
  {
    int sched_priority;
  };
# 24 "/usr/include/bits/pthreadtypes.h" 2 3


struct _pthread_fastlock
{
  long int __status;
  int __spinlock;

};



typedef struct _pthread_descr_struct *_pthread_descr;





typedef struct
{
  int __detachstate;
  int __schedpolicy;
  struct __sched_param __schedparam;
  int __inheritsched;
  int __scope;
  size_t __guardsize;
  int __stackaddr_set;
  void *__stackaddr;
  size_t __stacksize;
} pthread_attr_t;



typedef struct
{
  struct _pthread_fastlock __c_lock;
  _pthread_descr __c_waiting;
} pthread_cond_t;



typedef struct
{
  int __dummy;
} pthread_condattr_t;


typedef unsigned int pthread_key_t;





typedef struct
{
  int __m_reserved;
  int __m_count;
  _pthread_descr __m_owner;
  int __m_kind;
  struct _pthread_fastlock __m_lock;
} pthread_mutex_t;



typedef struct
{
  int __mutexkind;
} pthread_mutexattr_t;



typedef int pthread_once_t;
# 140 "/usr/include/bits/pthreadtypes.h" 3
typedef unsigned long int pthread_t;
# 166 "/usr/include/bits/types.h" 2 3
# 31 "/usr/include/sys/types.h" 2 3


typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;


typedef __loff_t loff_t;





typedef __ino64_t ino_t;
# 58 "/usr/include/sys/types.h" 3
typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;







typedef __off64_t off_t;
# 96 "/usr/include/sys/types.h" 3
typedef __pid_t pid_t;




typedef __id_t id_t;




typedef __ssize_t ssize_t;




typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;



typedef __key_t key_t;
# 126 "/usr/include/sys/types.h" 3
# 1 "/usr/include/time.h" 1 3
# 68 "/usr/include/time.h" 3
# 1 "/usr/include/bits/types.h" 1 3
# 69 "/usr/include/time.h" 2 3


typedef __time_t time_t;







# 1 "/usr/include/bits/types.h" 1 3
# 80 "/usr/include/time.h" 2 3


typedef __clockid_t clockid_t;







# 1 "/usr/include/bits/types.h" 1 3
# 91 "/usr/include/time.h" 2 3


typedef __timer_t timer_t;
# 127 "/usr/include/sys/types.h" 2 3
# 140 "/usr/include/sys/types.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 141 "/usr/include/sys/types.h" 2 3



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 184 "/usr/include/sys/types.h" 3
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 206 "/usr/include/sys/types.h" 3
# 1 "/usr/include/endian.h" 1 3
# 22 "/usr/include/endian.h" 3
# 1 "/usr/include/features.h" 1 3
# 23 "/usr/include/endian.h" 2 3
# 37 "/usr/include/endian.h" 3
# 1 "/usr/include/bits/endian.h" 1 3
# 38 "/usr/include/endian.h" 2 3
# 207 "/usr/include/sys/types.h" 2 3


# 1 "/usr/include/sys/select.h" 1 3
# 25 "/usr/include/sys/select.h" 3
# 1 "/usr/include/features.h" 1 3
# 26 "/usr/include/sys/select.h" 2 3


# 1 "/usr/include/bits/types.h" 1 3
# 29 "/usr/include/sys/select.h" 2 3


# 1 "/usr/include/bits/select.h" 1 3
# 32 "/usr/include/sys/select.h" 2 3


# 1 "/usr/include/bits/sigset.h" 1 3
# 23 "/usr/include/bits/sigset.h" 3
typedef int __sig_atomic_t;




typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 35 "/usr/include/sys/select.h" 2 3



# 1 "/usr/include/time.h" 1 3
# 105 "/usr/include/time.h" 3
struct timespec
  {
    long int tv_sec;
    long int tv_nsec;
  };
# 39 "/usr/include/sys/select.h" 2 3







struct timeval;

typedef __fd_mask fd_mask;


typedef __fd_set fd_set;
# 74 "/usr/include/sys/select.h" 3
extern int select (int __nfds, __fd_set *__restrict __readfds,
                   __fd_set *__restrict __writefds,
                   __fd_set *__restrict __exceptfds,
                   struct timeval *__restrict __timeout) ;
# 210 "/usr/include/sys/types.h" 2 3


# 1 "/usr/include/sys/sysmacros.h" 1 3
# 213 "/usr/include/sys/types.h" 2 3
# 237 "/usr/include/sys/types.h" 3
typedef __blkcnt64_t blkcnt_t;



typedef __fsblkcnt64_t fsblkcnt_t;



typedef __fsfilcnt64_t fsfilcnt_t;
# 392 "/usr/include/stdlib.h" 2 3






extern int32_t random (void) ;


extern void srandom (unsigned int __seed) ;





extern char *initstate (unsigned int __seed, char *__statebuf,
                        size_t __statelen) ;



extern char *setstate (char *__statebuf) ;







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
                     int32_t *__restrict __result) ;

extern int srandom_r (unsigned int __seed, struct random_data *__buf) ;

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
                        size_t __statelen,
                        struct random_data *__restrict __buf) ;

extern int setstate_r (char *__restrict __statebuf,
                       struct random_data *__restrict __buf) ;





extern int rand (void) ;

extern void srand (unsigned int __seed) ;



extern int rand_r (unsigned int *__seed) ;







extern double drand48 (void) ;
extern double erand48 (unsigned short int __xsubi[3]) ;


extern long int lrand48 (void) ;
extern long int nrand48 (unsigned short int __xsubi[3]) ;


extern long int mrand48 (void) ;
extern long int jrand48 (unsigned short int __xsubi[3]) ;


extern void srand48 (long int __seedval) ;
extern unsigned short int *seed48 (unsigned short int __seed16v[3]) ;
extern void lcong48 (unsigned short int __param[7]) ;


struct drand48_data
  {
    unsigned short int x[3];
    unsigned short int a[3];
    unsigned short int c;
    unsigned short int old_x[3];
    int init;
  };



extern int drand48_r (struct drand48_data *__restrict __buffer,
                      double *__restrict __result) ;
extern int erand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      double *__restrict __result) ;


extern int lrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;
extern int nrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;


extern int mrand48_r (struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;
extern int jrand48_r (unsigned short int __xsubi[3],
                      struct drand48_data *__restrict __buffer,
                      long int *__restrict __result) ;


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
            ;

extern int seed48_r (unsigned short int __seed16v[3],
                     struct drand48_data *__buffer) ;

extern int lcong48_r (unsigned short int __param[7],
                      struct drand48_data *__buffer) ;
# 526 "/usr/include/stdlib.h" 3
extern void *malloc (size_t __size) __attribute__ ((__malloc__));

extern void *calloc (size_t __nmemb, size_t __size)
             __attribute__ ((__malloc__));





extern void *realloc (void *__ptr, size_t __size) __attribute__ ((__malloc__));

extern void free (void *__ptr) ;



extern void cfree (void *__ptr) ;



# 1 "/usr/include/alloca.h" 1 3
# 22 "/usr/include/alloca.h" 3
# 1 "/usr/include/features.h" 1 3
# 23 "/usr/include/alloca.h" 2 3


# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 26 "/usr/include/alloca.h" 2 3







extern void *alloca (size_t __size) ;
# 546 "/usr/include/stdlib.h" 2 3




extern void *valloc (size_t __size) __attribute__ ((__malloc__));
# 560 "/usr/include/stdlib.h" 3
extern void abort (void) __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) ;




extern int __on_exit (void (*__func) (int __status, void *__arg), void *__arg)
            ;
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
            ;





extern void exit (int __status) __attribute__ ((__noreturn__));
# 588 "/usr/include/stdlib.h" 3
extern char *getenv (__const char *__name) ;



extern char *__secure_getenv (__const char *__name) ;





extern int putenv (char *__string) ;





extern int setenv (__const char *__name, __const char *__value, int __replace)
            ;


extern void unsetenv (__const char *__name) ;






extern int clearenv (void) ;
# 624 "/usr/include/stdlib.h" 3
extern char *mktemp (char *__template) ;






extern int mkstemp (char *__template) ;
# 640 "/usr/include/stdlib.h" 3
extern char *mkdtemp (char *__template) ;




extern int system (__const char *__command) ;
# 662 "/usr/include/stdlib.h" 3
extern char *realpath (__const char *__restrict __name,
                       char *__restrict __resolved) ;






typedef int (*__compar_fn_t) (__const void *, __const void *);
# 679 "/usr/include/stdlib.h" 3
extern void *bsearch (__const void *__key, __const void *__base,
                      size_t __nmemb, size_t __size, __compar_fn_t __compar);



extern void qsort (void *__base, size_t __nmemb, size_t __size,
                   __compar_fn_t __compar);



extern int abs (int __x) __attribute__ ((__const__));
extern long int labs (long int __x) __attribute__ ((__const__));
# 700 "/usr/include/stdlib.h" 3
extern div_t div (int __numer, int __denom)
             __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom)
             __attribute__ ((__const__));
# 718 "/usr/include/stdlib.h" 3
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) ;




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign) ;




extern char *gcvt (double __value, int __ndigit, char *__buf) ;


extern char *qecvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign) ;
extern char *qfcvt (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf) ;





extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) ;
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
                   int *__restrict __sign, char *__restrict __buf,
                   size_t __len) ;

extern int qecvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) ;
extern int qfcvt_r (long double __value, int __ndigit,
                    int *__restrict __decpt, int *__restrict __sign,
                    char *__restrict __buf, size_t __len) ;






extern int mblen (__const char *__s, size_t __n) ;


extern int mbtowc (wchar_t *__restrict __pwc,
                   __const char *__restrict __s, size_t __n) ;


extern int wctomb (char *__s, wchar_t __wchar) ;



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
                        __const char *__restrict __s, size_t __n) ;

extern size_t wcstombs (char *__restrict __s,
                        __const wchar_t *__restrict __pwcs, size_t __n)
            ;







extern int rpmatch (__const char *__response) ;
# 840 "/usr/include/stdlib.h" 3
extern int getloadavg (double __loadavg[], int __nelem) ;
# 84 "mbfilter.c" 2
# 1 "mbfilter.h" 1
# 93 "mbfilter.h"
enum mbfl_no_language {
        mbfl_no_language_invalid = -1,
        mbfl_no_language_uni,
        mbfl_no_language_min,
        mbfl_no_language_catalan,
        mbfl_no_language_danish,
        mbfl_no_language_german,
        mbfl_no_language_english,
        mbfl_no_language_estonian,
        mbfl_no_language_greek,
        mbfl_no_language_spanish,
        mbfl_no_language_french,
        mbfl_no_language_italian,
        mbfl_no_language_japanese,
        mbfl_no_language_korean,
        mbfl_no_language_dutch,
        mbfl_no_language_polish,
        mbfl_no_language_portuguese,
        mbfl_no_language_swedish,
        mbfl_no_language_chinese,
        mbfl_no_language_max
};

enum mbfl_no_encoding {
        mbfl_no_encoding_invalid = -1,
        mbfl_no_encoding_pass,
        mbfl_no_encoding_auto,
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_byte2be,
        mbfl_no_encoding_byte2le,
        mbfl_no_encoding_byte4be,
        mbfl_no_encoding_byte4le,
        mbfl_no_encoding_base64,
        mbfl_no_encoding_qprint,
        mbfl_no_encoding_7bit,
        mbfl_no_encoding_8bit,
        mbfl_no_encoding_charset_min,
        mbfl_no_encoding_ucs4,
        mbfl_no_encoding_ucs4be,
        mbfl_no_encoding_ucs4le,
        mbfl_no_encoding_ucs2,
        mbfl_no_encoding_ucs2be,
        mbfl_no_encoding_ucs2le,
        mbfl_no_encoding_utf32,
        mbfl_no_encoding_utf32be,
        mbfl_no_encoding_utf32le,
        mbfl_no_encoding_utf16,
        mbfl_no_encoding_utf16be,
        mbfl_no_encoding_utf16le,
        mbfl_no_encoding_utf8,
        mbfl_no_encoding_utf7,
        mbfl_no_encoding_utf7imap,
        mbfl_no_encoding_ascii,
        mbfl_no_encoding_euc_jp,
        mbfl_no_encoding_sjis,
        mbfl_no_encoding_eucjp_win,
        mbfl_no_encoding_sjis_win,
        mbfl_no_encoding_sjis_mac,
        mbfl_no_encoding_jis,
        mbfl_no_encoding_2022jp,
        mbfl_no_encoding_8859_1,
        mbfl_no_encoding_8859_2,
        mbfl_no_encoding_8859_3,
        mbfl_no_encoding_8859_4,
        mbfl_no_encoding_8859_5,
        mbfl_no_encoding_8859_6,
        mbfl_no_encoding_8859_7,
        mbfl_no_encoding_8859_8,
        mbfl_no_encoding_8859_9,
        mbfl_no_encoding_8859_10,
        mbfl_no_encoding_8859_13,
        mbfl_no_encoding_8859_14,
        mbfl_no_encoding_8859_15,
        mbfl_no_encoding_charset_max
};





typedef struct _mbfl_language {
        enum mbfl_no_language no_language;
        const char *name;
        const char *short_name;
        const char *(*aliases)[];
        enum mbfl_no_encoding mail_charset;
        enum mbfl_no_encoding mail_header_encoding;
        enum mbfl_no_encoding mail_body_encoding;
} mbfl_language;





typedef struct _mbfl_encoding {
        enum mbfl_no_encoding no_encoding;
        const char *name;
        const char *mime_name;
        const char *(*aliases)[];
        const unsigned char *mblen_table;
        unsigned int flag;
} mbfl_encoding;
# 242 "mbfilter.h"
typedef struct _mbfl_string {
        enum mbfl_no_language no_language;
        enum mbfl_no_encoding no_encoding;
        unsigned char *val;
        unsigned int len;
} mbfl_string;

void mbfl_string_init(mbfl_string *string);
void mbfl_string_init_set(mbfl_string *string, enum mbfl_no_language no_language, enum mbfl_no_encoding no_encoding);
void mbfl_string_clear(mbfl_string *string);





mbfl_language * mbfl_name2language(const char *name);
mbfl_language * mbfl_no2language(enum mbfl_no_language no_language);
enum mbfl_no_language mbfl_name2no_language(const char *name);
const char * mbfl_no_language2name(enum mbfl_no_language no_language);





mbfl_encoding * mbfl_name2encoding(const char *name);
mbfl_encoding * mbfl_no2encoding(enum mbfl_no_encoding no_encoding);
enum mbfl_no_encoding mbfl_name2no_encoding(const char *name);
const char * mbfl_no_encoding2name(enum mbfl_no_encoding no_encoding);
const char * mbfl_no2preferred_mime_name(enum mbfl_no_encoding no_encoding);
int mbfl_is_support_encoding(const char *name);







typedef struct _mbfl_memory_device {
        unsigned char *buffer;
        int length;
        int pos;
        int allocsz;
} mbfl_memory_device;

typedef struct _mbfl_wchar_device {
        unsigned int *buffer;
        int length;
        int pos;
        int allocsz;
} mbfl_wchar_device;

void mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz);
void mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz);
void mbfl_memory_device_clear(mbfl_memory_device *device);
void mbfl_memory_device_reset(mbfl_memory_device *device);
mbfl_string * mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result);
int mbfl_memory_device_output(int c, void *data);
int mbfl_memory_device_output2(int c, void *data);
int mbfl_memory_device_output4(int c, void *data);
int mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc);
int mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len);
int mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src);

void mbfl_wchar_device_init(mbfl_wchar_device *device);
int mbfl_wchar_device_output(int c, void *data);
# 316 "mbfilter.h"
typedef struct _mbfl_convert_filter mbfl_convert_filter;

struct _mbfl_convert_filter {
        void (*filter_ctor)(mbfl_convert_filter *filter);
        void (*filter_dtor)(mbfl_convert_filter *filter);
        int (*filter_function)(int c, mbfl_convert_filter *filter);
        int (*filter_flush)(mbfl_convert_filter *filter);
        int (*output_function)(int c, void *data);
        int (*flush_function)(void *data);
        void *data;
        int status;
        int cache;
        mbfl_encoding *from;
        mbfl_encoding *to;
        int illegal_mode;
        int illegal_substchar;
};

struct mbfl_convert_vtbl {
        enum mbfl_no_encoding from;
        enum mbfl_no_encoding to;
        void (*filter_ctor)(mbfl_convert_filter *filter);
        void (*filter_dtor)(mbfl_convert_filter *filter);
        int (*filter_function)(int c, mbfl_convert_filter *filter);
        int (*filter_flush)(mbfl_convert_filter *filter);
};

mbfl_convert_filter *
mbfl_convert_filter_new(
    enum mbfl_no_encoding from,
    enum mbfl_no_encoding to,
    int (*output_function)(int, void *),
    int (*flush_function)(void *),
    void *data);
void mbfl_convert_filter_delete(mbfl_convert_filter *filter);
int mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter);
int mbfl_convert_filter_flush(mbfl_convert_filter *filter);
void mbfl_convert_filter_reset(mbfl_convert_filter *filter, enum mbfl_no_encoding from, enum mbfl_no_encoding to);
void mbfl_convert_filter_copy(mbfl_convert_filter *src, mbfl_convert_filter *dist);
int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter);





typedef struct _mbfl_identify_filter mbfl_identify_filter;

struct _mbfl_identify_filter {
        void (*filter_ctor)(mbfl_identify_filter *filter);
        void (*filter_dtor)(mbfl_identify_filter *filter);
        int (*filter_function)(int c, mbfl_identify_filter *filter);
        int status;
        int flag;
        int score;
        mbfl_encoding *encoding;
};

struct mbfl_identify_vtbl {
        enum mbfl_no_encoding encoding;
        void (*filter_ctor)(mbfl_identify_filter *filter);
        void (*filter_dtor)(mbfl_identify_filter *filter);
        int (*filter_function)(int c, mbfl_identify_filter *filter);
};

mbfl_identify_filter * mbfl_identify_filter_new(enum mbfl_no_encoding encoding);
void mbfl_identify_filter_delete(mbfl_identify_filter *filter);





typedef struct _mbfl_buffer_converter mbfl_buffer_converter;

struct _mbfl_buffer_converter {
        mbfl_convert_filter *filter1;
        mbfl_convert_filter *filter2;
        mbfl_memory_device device;
        mbfl_encoding *from;
        mbfl_encoding *to;
};

mbfl_buffer_converter * mbfl_buffer_converter_new(enum mbfl_no_encoding from, enum mbfl_no_encoding to, int buf_initsz);
void mbfl_buffer_converter_delete(mbfl_buffer_converter *convd);
void mbfl_buffer_converter_reset(mbfl_buffer_converter *convd);
int mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode);
int mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar);
int mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n);
int mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string);
int mbfl_buffer_converter_flush(mbfl_buffer_converter *convd);
mbfl_string * mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result);
mbfl_string * mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result);
mbfl_string * mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string, mbfl_string *result);





typedef struct _mbfl_encoding_detector mbfl_encoding_detector;

struct _mbfl_encoding_detector {
        mbfl_identify_filter **filter_list;
        int filter_list_size;
};

mbfl_encoding_detector * mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz);
void mbfl_encoding_detector_delete(mbfl_encoding_detector *identd);
int mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string);
enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd);





mbfl_string *
mbfl_convert_encoding(mbfl_string *string, mbfl_string *result, enum mbfl_no_encoding toenc);





mbfl_encoding *
mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz);

const char *
mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz);

enum mbfl_no_encoding
mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz);




int
mbfl_strlen(mbfl_string *string);




int
mbfl_strpos(mbfl_string *haystack, mbfl_string *needle, int offset, int reverse);




mbfl_string *
mbfl_substr(mbfl_string *string, mbfl_string *result, int from, int length);




mbfl_string *
mbfl_strcut(mbfl_string *string, mbfl_string *result, int from, int length);




int
mbfl_strwidth(mbfl_string *string);




mbfl_string *
mbfl_strimwidth(mbfl_string *string, mbfl_string *marker, mbfl_string *result, int from, int width);




struct mime_header_encoder_data;

struct mime_header_encoder_data *
mime_header_encoder_new(
    enum mbfl_no_encoding incode,
    enum mbfl_no_encoding outcode,
    enum mbfl_no_encoding encoding);

void
mime_header_encoder_delete(struct mime_header_encoder_data *pe);

int
mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe);

mbfl_string *
mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result);

mbfl_string *
mbfl_mime_header_encode(
    mbfl_string *string, mbfl_string *result,
    enum mbfl_no_encoding outcode,
    enum mbfl_no_encoding encoding,
    const char *linefeed,
    int indent);




struct mime_header_decoder_data;

struct mime_header_decoder_data *
mime_header_decoder_new(enum mbfl_no_encoding outcode);

void
mime_header_decoder_delete(struct mime_header_decoder_data *pd);

int
mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd);

mbfl_string *
mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result);

mbfl_string *
mbfl_mime_header_decode(
    mbfl_string *string,
    mbfl_string *result,
    enum mbfl_no_encoding outcode);





mbfl_string *
mbfl_html_numeric_entity(mbfl_string *string, mbfl_string *result, int *convmap, int mapsize, int type);





mbfl_string *
mbfl_ja_jp_hantozen(mbfl_string *string, mbfl_string *result, int mode);
# 85 "mbfilter.c" 2
# 1 "mbfilter_ja.h" 1
# 85 "mbfilter_ja.h"
int mbfl_filt_conv_eucjp_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_eucjp(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_eucjpwin_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_eucjpwin(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_sjis_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_sjis(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_sjiswin_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_sjiswin(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_jis_wchar(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_jis(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_wchar_2022jp(int c, mbfl_convert_filter *filter);
int mbfl_filt_conv_any_jis_flush(mbfl_convert_filter *filter);
# 86 "mbfilter.c" 2
# 1 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 1
# 34 "/usr/local/src/temp/php-4.0.6/Zend/zend.h"
# 1 "/usr/include/stdio.h" 1 3
# 27 "/usr/include/stdio.h" 3
# 1 "/usr/include/features.h" 1 3
# 28 "/usr/include/stdio.h" 2 3





# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 34 "/usr/include/stdio.h" 2 3




# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stdarg.h" 1 3
# 43 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stdarg.h" 3
typedef __builtin_va_list __gnuc_va_list;
# 39 "/usr/include/stdio.h" 2 3

# 1 "/usr/include/bits/types.h" 1 3
# 41 "/usr/include/stdio.h" 2 3







typedef struct _IO_FILE FILE;
# 57 "/usr/include/stdio.h" 3
# 1 "/usr/include/libio.h" 1 3
# 30 "/usr/include/libio.h" 3
# 1 "/usr/include/_G_config.h" 1 3
# 9 "/usr/include/_G_config.h" 3
# 1 "/usr/include/bits/types.h" 1 3
# 10 "/usr/include/_G_config.h" 2 3




# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 312 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 3
typedef unsigned int wint_t;
# 15 "/usr/include/_G_config.h" 2 3
# 24 "/usr/include/_G_config.h" 3
# 1 "/usr/include/wchar.h" 1 3
# 45 "/usr/include/wchar.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 46 "/usr/include/wchar.h" 2 3
# 62 "/usr/include/wchar.h" 3
typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
# 25 "/usr/include/_G_config.h" 2 3

typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 44 "/usr/include/_G_config.h" 3
# 1 "/usr/include/gconv.h" 1 3
# 26 "/usr/include/gconv.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/gconv.h" 2 3

# 1 "/usr/include/wchar.h" 1 3
# 45 "/usr/include/wchar.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 46 "/usr/include/wchar.h" 2 3
# 29 "/usr/include/gconv.h" 2 3

# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 31 "/usr/include/gconv.h" 2 3





enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};



enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};



struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;



typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
                            __const unsigned char **, __const unsigned char *,
                            unsigned char **, size_t *, int, int);


typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);



typedef int (*__gconv_trans_fct) (struct __gconv_step *,
                                  struct __gconv_step_data *, void *,
                                  __const unsigned char *,
                                  __const unsigned char **,
                                  __const unsigned char *, unsigned char **,
                                  size_t *);


typedef int (*__gconv_trans_context_fct) (struct __gconv_trans_data *,
                                          __const unsigned char *,
                                          __const unsigned char *,
                                          unsigned char *, unsigned char *);


typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
                                        size_t *);


typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{

  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};



struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  __const char *__from_name;
  __const char *__to_name;

  __gconv_fct __fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;



  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;


  int __stateful;

  void *__data;
};



struct __gconv_step_data
{
  unsigned char *__outbuf;
  unsigned char *__outbufend;



  int __flags;



  int __invocation_counter;



  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;



  struct __gconv_trans_data *__trans;
};



typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data[0];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3
typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 31 "/usr/include/libio.h" 2 3
# 51 "/usr/include/libio.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stdarg.h" 1 3
# 52 "/usr/include/libio.h" 2 3
# 157 "/usr/include/libio.h" 3
struct _IO_jump_t; struct _IO_FILE;
# 167 "/usr/include/libio.h" 3
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 190 "/usr/include/libio.h" 3
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 262 "/usr/include/libio.h" 3
struct _IO_FILE {
  int _flags;




  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;
  int _blksize;
  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 306 "/usr/include/libio.h" 3
  __off64_t _offset;





  void *__pad1;
  void *__pad2;

  int _mode;

  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};


typedef struct _IO_FILE _IO_FILE;


struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 345 "/usr/include/libio.h" 3
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
                                 size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);
# 397 "/usr/include/libio.h" 3
extern int __underflow (_IO_FILE *) ;
extern int __uflow (_IO_FILE *) ;
extern int __overflow (_IO_FILE *, int) ;
extern wint_t __wunderflow (_IO_FILE *) ;
extern wint_t __wuflow (_IO_FILE *) ;
extern wint_t __woverflow (_IO_FILE *, wint_t) ;
# 427 "/usr/include/libio.h" 3
extern int _IO_getc (_IO_FILE *__fp) ;
extern int _IO_putc (int __c, _IO_FILE *__fp) ;
extern int _IO_feof (_IO_FILE *__fp) ;
extern int _IO_ferror (_IO_FILE *__fp) ;

extern int _IO_peekc_locked (_IO_FILE *__fp) ;





extern void _IO_flockfile (_IO_FILE *) ;
extern void _IO_funlockfile (_IO_FILE *) ;
extern int _IO_ftrylockfile (_IO_FILE *) ;
# 453 "/usr/include/libio.h" 3
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
                        __gnuc_va_list, int *__restrict) ;
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
                         __gnuc_va_list) ;
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) ;
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) ;

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) ;
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) ;

extern void _IO_free_backup_area (_IO_FILE *) ;
# 58 "/usr/include/stdio.h" 2 3





typedef _G_fpos64_t fpos_t;
# 110 "/usr/include/stdio.h" 3
# 1 "/usr/include/bits/stdio_lim.h" 1 3
# 111 "/usr/include/stdio.h" 2 3



extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;






extern int remove (__const char *__filename) ;

extern int rename (__const char *__old, __const char *__new) ;







extern FILE *tmpfile (void) __asm__ ("" "tmpfile64");
# 142 "/usr/include/stdio.h" 3
extern char *tmpnam (char *__s) ;




extern char *tmpnam_r (char *__s) ;
# 159 "/usr/include/stdio.h" 3
extern char *tempnam (__const char *__dir, __const char *__pfx)
             __attribute__ ((__malloc__));




extern int fclose (FILE *__stream) ;

extern int fflush (FILE *__stream) ;



extern int fflush_unlocked (FILE *__stream) ;
# 190 "/usr/include/stdio.h" 3
extern FILE *fopen (__const char *__restrict __filename, __const char *__restrict __modes) __asm__ ("" "fopen64");


extern FILE *freopen (__const char *__restrict __filename, __const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64");
# 212 "/usr/include/stdio.h" 3
extern FILE *fdopen (int __fd, __const char *__modes) ;
# 235 "/usr/include/stdio.h" 3
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) ;



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
                    int __modes, size_t __n) ;




extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
                       size_t __size) ;


extern void setlinebuf (FILE *__stream) ;




extern int fprintf (FILE *__restrict __stream,
                    __const char *__restrict __format, ...) ;

extern int printf (__const char *__restrict __format, ...) ;

extern int sprintf (char *__restrict __s,
                    __const char *__restrict __format, ...) ;


extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg) ;

extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg)
            ;

extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
                     __gnuc_va_list __arg) ;



extern int snprintf (char *__restrict __s, size_t __maxlen,
                     __const char *__restrict __format, ...)
             __attribute__ ((__format__ (__printf__, 3, 4)));

extern int __vsnprintf (char *__restrict __s, size_t __maxlen,
                        __const char *__restrict __format, __gnuc_va_list __arg)
             __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
                      __const char *__restrict __format, __gnuc_va_list __arg)
             __attribute__ ((__format__ (__printf__, 3, 0)));
# 309 "/usr/include/stdio.h" 3
extern int fscanf (FILE *__restrict __stream,
                   __const char *__restrict __format, ...) ;

extern int scanf (__const char *__restrict __format, ...) ;

extern int sscanf (__const char *__restrict __s,
                   __const char *__restrict __format, ...) ;
# 335 "/usr/include/stdio.h" 3
extern int fgetc (FILE *__stream) ;
extern int getc (FILE *__stream) ;


extern int getchar (void) ;







extern int getc_unlocked (FILE *__stream) ;
extern int getchar_unlocked (void) ;




extern int fgetc_unlocked (FILE *__stream) ;




extern int fputc (int __c, FILE *__stream) ;
extern int putc (int __c, FILE *__stream) ;


extern int putchar (int __c) ;







extern int fputc_unlocked (int __c, FILE *__stream) ;




extern int putc_unlocked (int __c, FILE *__stream) ;
extern int putchar_unlocked (int __c) ;





extern int getw (FILE *__stream) ;


extern int putw (int __w, FILE *__stream) ;




extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
            ;
# 401 "/usr/include/stdio.h" 3
extern char *gets (char *__s) ;
# 425 "/usr/include/stdio.h" 3
extern int fputs (__const char *__restrict __s, FILE *__restrict __stream)
            ;
# 435 "/usr/include/stdio.h" 3
extern int puts (__const char *__s) ;



extern int ungetc (int __c, FILE *__stream) ;



extern size_t fread (void *__restrict __ptr, size_t __size,
                     size_t __n, FILE *__restrict __stream) ;

extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
                      size_t __n, FILE *__restrict __s) ;



extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
                              size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
                               size_t __n, FILE *__restrict __stream) ;




extern int fseek (FILE *__stream, long int __off, int __whence) ;

extern long int ftell (FILE *__stream) ;

extern void rewind (FILE *__stream) ;
# 502 "/usr/include/stdio.h" 3
extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64");


extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");

extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64");

extern int fsetpos (FILE *__stream, __const fpos_t *__pos) __asm__ ("" "fsetpos64");
# 531 "/usr/include/stdio.h" 3
extern void clearerr (FILE *__stream) ;

extern int feof (FILE *__stream) ;

extern int ferror (FILE *__stream) ;



extern void clearerr_unlocked (FILE *__stream) ;
extern int feof_unlocked (FILE *__stream) ;
extern int ferror_unlocked (FILE *__stream) ;




extern void perror (__const char *__s) ;




extern int sys_nerr;
extern __const char *__const sys_errlist[];
# 562 "/usr/include/stdio.h" 3
extern int fileno (FILE *__stream) ;




extern int fileno_unlocked (FILE *__stream) ;






extern FILE *popen (__const char *__command, __const char *__modes) ;


extern int pclose (FILE *__stream) ;





extern char *ctermid (char *__s) ;
# 609 "/usr/include/stdio.h" 3
extern void flockfile (FILE *__stream) ;



extern int ftrylockfile (FILE *__stream) ;


extern void funlockfile (FILE *__stream) ;
# 630 "/usr/include/stdio.h" 3
# 1 "/usr/include/bits/stdio.h" 1 3
# 32 "/usr/include/bits/stdio.h" 3
extern __inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}


extern __inline int
getchar (void)
{
  return _IO_getc (stdin);
}




extern __inline int
getc_unlocked (FILE *__fp)
{
  return ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


extern __inline int
getchar_unlocked (void)
{
  return ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




extern __inline int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




extern __inline int
fputc_unlocked (int __c, FILE *__stream)
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





extern __inline int
putc_unlocked (int __c, FILE *__stream)
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


extern __inline int
putchar_unlocked (int __c)
{
  return (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}
# 110 "/usr/include/bits/stdio.h" 3
extern __inline int
feof_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x10) != 0);
}


extern __inline int
ferror_unlocked (FILE *__stream)
{
  return (((__stream)->_flags & 0x20) != 0);
}
# 631 "/usr/include/stdio.h" 2 3
# 35 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2
# 44 "/usr/local/src/temp/php-4.0.6/Zend/zend.h"
# 1 "/usr/local/src/temp/php-4.0.6/Zend/zend_config.h" 1
# 1 "/usr/local/src/temp/php-4.0.6/main/php_config.h" 1
# 1919 "/usr/local/src/temp/php-4.0.6/main/php_config.h"
# 1 "/usr/include/stdlib.h" 1 3
# 1920 "/usr/local/src/temp/php-4.0.6/main/php_config.h" 2



# 1 "/usr/include/sys/types.h" 1 3
# 1924 "/usr/local/src/temp/php-4.0.6/main/php_config.h" 2







# 1 "/usr/include/string.h" 1 3
# 26 "/usr/include/string.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/string.h" 2 3






# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stddef.h" 1 3
# 34 "/usr/include/string.h" 2 3



extern void *memcpy (void *__restrict __dest,
                     __const void *__restrict __src, size_t __n) ;


extern void *memmove (void *__dest, __const void *__src, size_t __n)
            ;





extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
                      int __c, size_t __n)
            ;




extern void *memset (void *__s, int __c, size_t __n) ;


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
             __attribute__ ((__pure__));


extern void *memchr (__const void *__s, int __c, size_t __n)
              __attribute__ ((__pure__));
# 77 "/usr/include/string.h" 3
extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
            ;

extern char *strncpy (char *__restrict __dest,
                      __const char *__restrict __src, size_t __n) ;


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
            ;

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
                      size_t __n) ;


extern int strcmp (__const char *__s1, __const char *__s2)
             __attribute__ ((__pure__));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
             __attribute__ ((__pure__));


extern int strcoll (__const char *__s1, __const char *__s2)
             __attribute__ ((__pure__));

extern size_t strxfrm (char *__restrict __dest,
                       __const char *__restrict __src, size_t __n) ;
# 120 "/usr/include/string.h" 3
extern char *strdup (__const char *__s) __attribute__ ((__malloc__));
# 155 "/usr/include/string.h" 3
extern char *strchr (__const char *__s, int __c) __attribute__ ((__pure__));

extern char *strrchr (__const char *__s, int __c) __attribute__ ((__pure__));
# 167 "/usr/include/string.h" 3
extern size_t strcspn (__const char *__s, __const char *__reject)
             __attribute__ ((__pure__));


extern size_t strspn (__const char *__s, __const char *__accept)
             __attribute__ ((__pure__));

extern char *strpbrk (__const char *__s, __const char *__accept)
             __attribute__ ((__pure__));

extern char *strstr (__const char *__haystack, __const char *__needle)
             __attribute__ ((__pure__));
# 189 "/usr/include/string.h" 3
extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
            ;



extern char *__strtok_r (char *__restrict __s,
                         __const char *__restrict __delim,
                         char **__restrict __save_ptr) ;

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
                       char **__restrict __save_ptr) ;
# 220 "/usr/include/string.h" 3
extern size_t strlen (__const char *__s) __attribute__ ((__pure__));
# 231 "/usr/include/string.h" 3
extern char *strerror (int __errnum) ;



extern char *__strerror_r (int __errnum, char *__buf, size_t __buflen) ;
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) ;




extern void __bzero (void *__s, size_t __n) ;



extern void bcopy (__const void *__src, void *__dest, size_t __n) ;


extern void bzero (void *__s, size_t __n) ;


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
             __attribute__ ((__pure__));


extern char *index (__const char *__s, int __c) __attribute__ ((__pure__));


extern char *rindex (__const char *__s, int __c) __attribute__ ((__pure__));



extern int __ffs (int __i) __attribute__ ((const));
extern int ffs (int __i) __attribute__ ((const));
# 276 "/usr/include/string.h" 3
extern int __strcasecmp (__const char *__s1, __const char *__s2)
             __attribute__ ((__pure__));
extern int strcasecmp (__const char *__s1, __const char *__s2)
             __attribute__ ((__pure__));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
             __attribute__ ((__pure__));
# 300 "/usr/include/string.h" 3
extern char *strsep (char **__restrict __stringp,
                     __const char *__restrict __delim) ;
# 362 "/usr/include/string.h" 3
# 1 "/usr/include/bits/string.h" 1 3
# 363 "/usr/include/string.h" 2 3


# 1 "/usr/include/bits/string2.h" 1 3
# 52 "/usr/include/bits/string2.h" 3
# 1 "/usr/include/endian.h" 1 3
# 53 "/usr/include/bits/string2.h" 2 3
# 1 "/usr/include/bits/types.h" 1 3
# 54 "/usr/include/bits/string2.h" 2 3
# 371 "/usr/include/bits/string2.h" 3
extern void *__rawmemchr (const void *__s, int __c);
# 395 "/usr/include/bits/string2.h" 3
extern __inline char *__strcpy_small (char *, __uint16_t, __uint16_t,
                                      __uint32_t, __uint32_t, size_t);
extern __inline char *
__strcpy_small (char *__dest,
                __uint16_t __src0_2, __uint16_t __src4_2,
                __uint32_t __src0_4, __uint32_t __src4_4,
                size_t __srclen)
{
  union {
    __uint32_t __ui;
    __uint16_t __usi;
    unsigned char __uc;
  } *__u = (void *) __dest;
  switch ((unsigned int) __srclen)
    {
    case 1:
      __u->__uc = '\0';
      break;
    case 2:
      __u->__usi = __src0_2;
      break;
    case 3:
      __u->__usi = __src0_2;
      __u = __extension__ ((void *) __u + 2);
      __u->__uc = '\0';
      break;
    case 4:
      __u->__ui = __src0_4;
      break;
    case 5:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__uc = '\0';
      break;
    case 6:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__usi = __src4_2;
      break;
    case 7:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__usi = __src4_2;
      __u = __extension__ ((void *) __u + 2);
      __u->__uc = '\0';
      break;
    case 8:
      __u->__ui = __src0_4;
      __u = __extension__ ((void *) __u + 4);
      __u->__ui = __src4_4;
      break;
    }
  return __dest;
}
# 872 "/usr/include/bits/string2.h" 3
extern __inline size_t __strcspn_c1 (__const char *__s, char __reject);
extern __inline size_t
__strcspn_c1 (__const char *__s, char __reject)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c2 (__const char *__s, char __reject1,
                                     char __reject2);
extern __inline size_t
__strcspn_c2 (__const char *__s, char __reject1, char __reject2)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
         && __s[__result] != __reject2)
    ++__result;
  return __result;
}

extern __inline size_t __strcspn_c3 (__const char *__s, char __reject1,
                                     char __reject2, char __reject3);
extern __inline size_t
__strcspn_c3 (__const char *__s, char __reject1, char __reject2,
              char __reject3)
{
  register size_t __result = 0;
  while (__s[__result] != '\0' && __s[__result] != __reject1
         && __s[__result] != __reject2 && __s[__result] != __reject3)
    ++__result;
  return __result;
}
# 927 "/usr/include/bits/string2.h" 3
extern __inline size_t __strspn_c1 (__const char *__s, char __accept);
extern __inline size_t
__strspn_c1 (__const char *__s, char __accept)
{
  register size_t __result = 0;

  while (__s[__result] == __accept)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c2 (__const char *__s, char __accept1,
                                    char __accept2);
extern __inline size_t
__strspn_c2 (__const char *__s, char __accept1, char __accept2)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2)
    ++__result;
  return __result;
}

extern __inline size_t __strspn_c3 (__const char *__s, char __accept1,
                                    char __accept2, char __accept3);
extern __inline size_t
__strspn_c3 (__const char *__s, char __accept1, char __accept2, char __accept3)
{
  register size_t __result = 0;

  while (__s[__result] == __accept1 || __s[__result] == __accept2
         || __s[__result] == __accept3)
    ++__result;
  return __result;
}
# 982 "/usr/include/bits/string2.h" 3
extern __inline char *__strpbrk_c2 (__const char *__s, char __accept1,
                                     char __accept2);
extern __inline char *
__strpbrk_c2 (__const char *__s, char __accept1, char __accept2)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}

extern __inline char *__strpbrk_c3 (__const char *__s, char __accept1,
                                     char __accept2, char __accept3);
extern __inline char *
__strpbrk_c3 (__const char *__s, char __accept1, char __accept2,
              char __accept3)
{

  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
         && *__s != __accept3)
    ++__s;
  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
}
# 1043 "/usr/include/bits/string2.h" 3
extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
extern __inline char *
__strtok_r_1c (char *__s, char __sep, char **__nextp)
{
  char *__result;
  if (__s == ((void *)0))
    __s = *__nextp;
  while (*__s == __sep)
    ++__s;
  if (*__s == '\0')
    __result = ((void *)0);
  else
    {
      __result = __s;
      while (*__s != '\0' && *__s != __sep)
        ++__s;
      if (*__s == '\0')
        *__nextp = __s;
      else
        {
          *__s = '\0';
          *__nextp = __s + 1;
        }
    }
  return __result;
}
# 1093 "/usr/include/bits/string2.h" 3
extern __inline char *__strsep_1c (char **__s, char __reject);
extern __inline char *
__strsep_1c (char **__s, char __reject)
{
  register char *__retval = *__s;
  if (__retval == ((void *)0))
    return *__s = ((void *)0);
  if (*__retval == __reject)
    *(*__s)++ = '\0';
  else
    if ((*__s = (__extension__ (__builtin_constant_p (__reject) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : strchr (__retval, __reject)))) != ((void *)0))
      *(*__s)++ = '\0';
    else
      *__s = ((void *)0);
  return __retval;
}

extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
extern __inline char *
__strsep_2c (char **__s, char __reject1, char __reject2)
{
  register char *__retval = *__s;
  if (__retval == ((void *)0))
    return *__s = ((void *)0);
  if (*__retval == __reject1 || *__retval == __reject2)
    *(*__s)++ = '\0';
  else
    {
      register char *__cp = __retval;
      while (*__cp != '\0' && *__cp != __reject1 && *__cp != __reject2)
        ++__cp;
      if (*__cp != '\0')
        {
          *__s = __cp;
          *(*__s)++ = '\0';
        }
      else
        *__s = ((void *)0);
    }
  return __retval;
}

extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
                                   char __reject3);
extern __inline char *
__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
{
  register char *__retval = *__s;
  if (__retval == ((void *)0))
    return *__s = ((void *)0);
  if (*__retval == __reject1 || *__retval == __reject2
      || *__retval == __reject3)
    *(*__s)++ = '\0';
  else
    {
      register char *__cp = __retval;
      while (*__cp != '\0' && *__cp != __reject1 && *__cp != __reject2
             && *__cp != __reject3)
        ++__cp;
      if (*__cp != '\0')
        {
          *__s = __cp;
          *(*__s)++ = '\0';
        }
      else
        *__s = ((void *)0);
    }
  return __retval;
}

extern __inline char *__strsep_g (char **__s, __const char *__reject);
extern __inline char *
__strsep_g (char **__s, __const char *__reject)
{
  register char *__retval = *__s;
  if (__retval == ((void *)0))
    return ((void *)0);
  if ((*__s = __extension__ ({ char __a0, __a1, __a2; (__builtin_constant_p (__reject) && ((size_t)(const void *)((__reject) + 1) - (size_t)(const void *)(__reject) == 1) ? ((__a0 = ((__const char *) (__reject))[0], __a0 == '\0') ? ((void *)0) : ((__a1 = ((__const char *) (__reject))[1], __a1 == '\0') ? (__extension__ (__builtin_constant_p (__a0) && (__a0) == '\0' ? (char *) __rawmemchr (__retval, __a0) : strchr (__retval, __a0))) : ((__a2 = ((__const char *) (__reject))[2], __a2 == '\0') ? __strpbrk_c2 (__retval, __a0, __a1) : (((__const char *) (__reject))[3] == '\0' ? __strpbrk_c3 (__retval, __a0, __a1, __a2) : strpbrk (__retval, __reject))))) : strpbrk (__retval, __reject)); })) != ((void *)0))
    *(*__s)++ = '\0';
  return __retval;
}
# 1186 "/usr/include/bits/string2.h" 3
# 1 "/usr/include/stdlib.h" 1 3
# 1187 "/usr/include/bits/string2.h" 2 3




extern char *__strdup (__const char *__string) __attribute__ ((__malloc__));
# 1210 "/usr/include/bits/string2.h" 3
extern char *__strndup (__const char *__string, size_t __n)
             __attribute__ ((__malloc__));
# 366 "/usr/include/string.h" 2 3
# 1932 "/usr/local/src/temp/php-4.0.6/main/php_config.h" 2
# 1942 "/usr/local/src/temp/php-4.0.6/main/php_config.h"
# 1 "/usr/include/math.h" 1 3
# 27 "/usr/include/math.h" 3
# 1 "/usr/include/features.h" 1 3
# 28 "/usr/include/math.h" 2 3





# 1 "/usr/include/bits/huge_val.h" 1 3
# 25 "/usr/include/bits/huge_val.h" 3
# 1 "/usr/include/features.h" 1 3
# 26 "/usr/include/bits/huge_val.h" 2 3
# 34 "/usr/include/math.h" 2 3






# 1 "/usr/include/bits/mathdef.h" 1 3
# 41 "/usr/include/math.h" 2 3
# 63 "/usr/include/math.h" 3
# 1 "/usr/include/bits/mathcalls.h" 1 3
# 54 "/usr/include/bits/mathcalls.h" 3
extern double acos (double __x) ; extern double __acos (double __x) ;

extern double asin (double __x) ; extern double __asin (double __x) ;

extern double atan (double __x) ; extern double __atan (double __x) ;

extern double atan2 (double __y, double __x) ; extern double __atan2 (double __y, double __x) ;


extern double cos (double __x) ; extern double __cos (double __x) ;

extern double sin (double __x) ; extern double __sin (double __x) ;

extern double tan (double __x) ; extern double __tan (double __x) ;
# 78 "/usr/include/bits/mathcalls.h" 3
extern double cosh (double __x) ; extern double __cosh (double __x) ;

extern double sinh (double __x) ; extern double __sinh (double __x) ;

extern double tanh (double __x) ; extern double __tanh (double __x) ;



extern double acosh (double __x) ; extern double __acosh (double __x) ;

extern double asinh (double __x) ; extern double __asinh (double __x) ;

extern double atanh (double __x) ; extern double __atanh (double __x) ;





extern double exp (double __x) ; extern double __exp (double __x) ;
# 106 "/usr/include/bits/mathcalls.h" 3
extern double frexp (double __x, int *__exponent) ; extern double __frexp (double __x, int *__exponent) ;


extern double ldexp (double __x, int __exponent) ; extern double __ldexp (double __x, int __exponent) ;


extern double log (double __x) ; extern double __log (double __x) ;


extern double log10 (double __x) ; extern double __log10 (double __x) ;


extern double modf (double __x, double *__iptr) ; extern double __modf (double __x, double *__iptr) ;



extern double expm1 (double __x) ; extern double __expm1 (double __x) ;


extern double log1p (double __x) ; extern double __log1p (double __x) ;


extern double logb (double __x) ; extern double __logb (double __x) ;
# 143 "/usr/include/bits/mathcalls.h" 3
extern double pow (double __x, double __y) ; extern double __pow (double __x, double __y) ;


extern double sqrt (double __x) ; extern double __sqrt (double __x) ;



extern double hypot (double __x, double __y) ; extern double __hypot (double __x, double __y) ;




extern double cbrt (double __x) ; extern double __cbrt (double __x) ;






extern double ceil (double __x) ; extern double __ceil (double __x) ;


extern double fabs (double __x) __attribute__ ((__const__)); extern double __fabs (double __x) __attribute__ ((__const__));


extern double floor (double __x) ; extern double __floor (double __x) ;


extern double fmod (double __x, double __y) ; extern double __fmod (double __x, double __y) ;




extern int __isinf (double __value) __attribute__ ((__const__));


extern int __finite (double __value) __attribute__ ((__const__));




extern int isinf (double __value) __attribute__ ((__const__));


extern int finite (double __value) __attribute__ ((__const__));







extern double infnan (int __error) __attribute__ ((__const__)); extern double __infnan (int __error) __attribute__ ((__const__));


extern double drem (double __x, double __y) ; extern double __drem (double __x, double __y) ;



extern double significand (double __x) ; extern double __significand (double __x) ;




extern double copysign (double __x, double __y) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) __attribute__ ((__const__));
# 217 "/usr/include/bits/mathcalls.h" 3
extern int __isnan (double __value) __attribute__ ((__const__));



extern int isnan (double __value) __attribute__ ((__const__));


extern double j0 (double) ; extern double __j0 (double) ;
extern double j1 (double) ; extern double __j1 (double) ;
extern double jn (int, double) ; extern double __jn (int, double) ;
extern double y0 (double) ; extern double __y0 (double) ;
extern double y1 (double) ; extern double __y1 (double) ;
extern double yn (int, double) ; extern double __yn (int, double) ;





extern double erf (double) ; extern double __erf (double) ;
extern double erfc (double) ; extern double __erfc (double) ;
extern double lgamma (double) ; extern double __lgamma (double) ;
# 246 "/usr/include/bits/mathcalls.h" 3
extern double gamma (double) ; extern double __gamma (double) ;






extern double lgamma_r (double, int *__signgamp) ; extern double __lgamma_r (double, int *__signgamp) ;






extern double rint (double __x) ; extern double __rint (double __x) ;


extern double nextafter (double __x, double __y) __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) __attribute__ ((__const__));





extern double remainder (double __x, double __y) ; extern double __remainder (double __x, double __y) ;



extern double scalb (double __x, double __n) ; extern double __scalb (double __x, double __n) ;




extern double scalbn (double __x, int __n) ; extern double __scalbn (double __x, int __n) ;



extern int ilogb (double __x) ; extern int __ilogb (double __x) ;
# 64 "/usr/include/math.h" 2 3
# 82 "/usr/include/math.h" 3
# 1 "/usr/include/bits/mathcalls.h" 1 3
# 54 "/usr/include/bits/mathcalls.h" 3
extern float acosf (float __x) ; extern float __acosf (float __x) ;

extern float asinf (float __x) ; extern float __asinf (float __x) ;

extern float atanf (float __x) ; extern float __atanf (float __x) ;

extern float atan2f (float __y, float __x) ; extern float __atan2f (float __y, float __x) ;


extern float cosf (float __x) ; extern float __cosf (float __x) ;

extern float sinf (float __x) ; extern float __sinf (float __x) ;

extern float tanf (float __x) ; extern float __tanf (float __x) ;
# 78 "/usr/include/bits/mathcalls.h" 3
extern float coshf (float __x) ; extern float __coshf (float __x) ;

extern float sinhf (float __x) ; extern float __sinhf (float __x) ;

extern float tanhf (float __x) ; extern float __tanhf (float __x) ;



extern float acoshf (float __x) ; extern float __acoshf (float __x) ;

extern float asinhf (float __x) ; extern float __asinhf (float __x) ;

extern float atanhf (float __x) ; extern float __atanhf (float __x) ;





extern float expf (float __x) ; extern float __expf (float __x) ;
# 106 "/usr/include/bits/mathcalls.h" 3
extern float frexpf (float __x, int *__exponent) ; extern float __frexpf (float __x, int *__exponent) ;


extern float ldexpf (float __x, int __exponent) ; extern float __ldexpf (float __x, int __exponent) ;


extern float logf (float __x) ; extern float __logf (float __x) ;


extern float log10f (float __x) ; extern float __log10f (float __x) ;


extern float modff (float __x, float *__iptr) ; extern float __modff (float __x, float *__iptr) ;



extern float expm1f (float __x) ; extern float __expm1f (float __x) ;


extern float log1pf (float __x) ; extern float __log1pf (float __x) ;


extern float logbf (float __x) ; extern float __logbf (float __x) ;
# 143 "/usr/include/bits/mathcalls.h" 3
extern float powf (float __x, float __y) ; extern float __powf (float __x, float __y) ;


extern float sqrtf (float __x) ; extern float __sqrtf (float __x) ;



extern float hypotf (float __x, float __y) ; extern float __hypotf (float __x, float __y) ;




extern float cbrtf (float __x) ; extern float __cbrtf (float __x) ;






extern float ceilf (float __x) ; extern float __ceilf (float __x) ;


extern float fabsf (float __x) __attribute__ ((__const__)); extern float __fabsf (float __x) __attribute__ ((__const__));


extern float floorf (float __x) ; extern float __floorf (float __x) ;


extern float fmodf (float __x, float __y) ; extern float __fmodf (float __x, float __y) ;




extern int __isinff (float __value) __attribute__ ((__const__));


extern int __finitef (float __value) __attribute__ ((__const__));




extern int isinff (float __value) __attribute__ ((__const__));


extern int finitef (float __value) __attribute__ ((__const__));







extern float infnanf (int __error) __attribute__ ((__const__)); extern float __infnanf (int __error) __attribute__ ((__const__));


extern float dremf (float __x, float __y) ; extern float __dremf (float __x, float __y) ;



extern float significandf (float __x) ; extern float __significandf (float __x) ;




extern float copysignf (float __x, float __y) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) __attribute__ ((__const__));
# 217 "/usr/include/bits/mathcalls.h" 3
extern int __isnanf (float __value) __attribute__ ((__const__));



extern int isnanf (float __value) __attribute__ ((__const__));


extern float j0f (float) ; extern float __j0f (float) ;
extern float j1f (float) ; extern float __j1f (float) ;
extern float jnf (int, float) ; extern float __jnf (int, float) ;
extern float y0f (float) ; extern float __y0f (float) ;
extern float y1f (float) ; extern float __y1f (float) ;
extern float ynf (int, float) ; extern float __ynf (int, float) ;





extern float erff (float) ; extern float __erff (float) ;
extern float erfcf (float) ; extern float __erfcf (float) ;
extern float lgammaf (float) ; extern float __lgammaf (float) ;
# 246 "/usr/include/bits/mathcalls.h" 3
extern float gammaf (float) ; extern float __gammaf (float) ;






extern float lgammaf_r (float, int *__signgamp) ; extern float __lgammaf_r (float, int *__signgamp) ;






extern float rintf (float __x) ; extern float __rintf (float __x) ;


extern float nextafterf (float __x, float __y) __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) __attribute__ ((__const__));





extern float remainderf (float __x, float __y) ; extern float __remainderf (float __x, float __y) ;



extern float scalbf (float __x, float __n) ; extern float __scalbf (float __x, float __n) ;




extern float scalbnf (float __x, int __n) ; extern float __scalbnf (float __x, int __n) ;



extern int ilogbf (float __x) ; extern int __ilogbf (float __x) ;
# 83 "/usr/include/math.h" 2 3
# 99 "/usr/include/math.h" 3
# 1 "/usr/include/bits/mathcalls.h" 1 3
# 54 "/usr/include/bits/mathcalls.h" 3
extern long double acosl (long double __x) ; extern long double __acosl (long double __x) ;

extern long double asinl (long double __x) ; extern long double __asinl (long double __x) ;

extern long double atanl (long double __x) ; extern long double __atanl (long double __x) ;

extern long double atan2l (long double __y, long double __x) ; extern long double __atan2l (long double __y, long double __x) ;


extern long double cosl (long double __x) ; extern long double __cosl (long double __x) ;

extern long double sinl (long double __x) ; extern long double __sinl (long double __x) ;

extern long double tanl (long double __x) ; extern long double __tanl (long double __x) ;
# 78 "/usr/include/bits/mathcalls.h" 3
extern long double coshl (long double __x) ; extern long double __coshl (long double __x) ;

extern long double sinhl (long double __x) ; extern long double __sinhl (long double __x) ;

extern long double tanhl (long double __x) ; extern long double __tanhl (long double __x) ;



extern long double acoshl (long double __x) ; extern long double __acoshl (long double __x) ;

extern long double asinhl (long double __x) ; extern long double __asinhl (long double __x) ;

extern long double atanhl (long double __x) ; extern long double __atanhl (long double __x) ;





extern long double expl (long double __x) ; extern long double __expl (long double __x) ;
# 106 "/usr/include/bits/mathcalls.h" 3
extern long double frexpl (long double __x, int *__exponent) ; extern long double __frexpl (long double __x, int *__exponent) ;


extern long double ldexpl (long double __x, int __exponent) ; extern long double __ldexpl (long double __x, int __exponent) ;


extern long double logl (long double __x) ; extern long double __logl (long double __x) ;


extern long double log10l (long double __x) ; extern long double __log10l (long double __x) ;


extern long double modfl (long double __x, long double *__iptr) ; extern long double __modfl (long double __x, long double *__iptr) ;



extern long double expm1l (long double __x) ; extern long double __expm1l (long double __x) ;


extern long double log1pl (long double __x) ; extern long double __log1pl (long double __x) ;


extern long double logbl (long double __x) ; extern long double __logbl (long double __x) ;
# 143 "/usr/include/bits/mathcalls.h" 3
extern long double powl (long double __x, long double __y) ; extern long double __powl (long double __x, long double __y) ;


extern long double sqrtl (long double __x) ; extern long double __sqrtl (long double __x) ;



extern long double hypotl (long double __x, long double __y) ; extern long double __hypotl (long double __x, long double __y) ;




extern long double cbrtl (long double __x) ; extern long double __cbrtl (long double __x) ;






extern long double ceill (long double __x) ; extern long double __ceill (long double __x) ;


extern long double fabsl (long double __x) __attribute__ ((__const__)); extern long double __fabsl (long double __x) __attribute__ ((__const__));


extern long double floorl (long double __x) ; extern long double __floorl (long double __x) ;


extern long double fmodl (long double __x, long double __y) ; extern long double __fmodl (long double __x, long double __y) ;




extern int __isinfl (long double __value) __attribute__ ((__const__));


extern int __finitel (long double __value) __attribute__ ((__const__));




extern int isinfl (long double __value) __attribute__ ((__const__));


extern int finitel (long double __value) __attribute__ ((__const__));







extern long double infnanl (int __error) __attribute__ ((__const__)); extern long double __infnanl (int __error) __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) ; extern long double __dreml (long double __x, long double __y) ;



extern long double significandl (long double __x) ; extern long double __significandl (long double __x) ;




extern long double copysignl (long double __x, long double __y) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) __attribute__ ((__const__));
# 217 "/usr/include/bits/mathcalls.h" 3
extern int __isnanl (long double __value) __attribute__ ((__const__));



extern int isnanl (long double __value) __attribute__ ((__const__));


extern long double j0l (long double) ; extern long double __j0l (long double) ;
extern long double j1l (long double) ; extern long double __j1l (long double) ;
extern long double jnl (int, long double) ; extern long double __jnl (int, long double) ;
extern long double y0l (long double) ; extern long double __y0l (long double) ;
extern long double y1l (long double) ; extern long double __y1l (long double) ;
extern long double ynl (int, long double) ; extern long double __ynl (int, long double) ;





extern long double erfl (long double) ; extern long double __erfl (long double) ;
extern long double erfcl (long double) ; extern long double __erfcl (long double) ;
extern long double lgammal (long double) ; extern long double __lgammal (long double) ;
# 246 "/usr/include/bits/mathcalls.h" 3
extern long double gammal (long double) ; extern long double __gammal (long double) ;






extern long double lgammal_r (long double, int *__signgamp) ; extern long double __lgammal_r (long double, int *__signgamp) ;






extern long double rintl (long double __x) ; extern long double __rintl (long double __x) ;


extern long double nextafterl (long double __x, long double __y) __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) __attribute__ ((__const__));





extern long double remainderl (long double __x, long double __y) ; extern long double __remainderl (long double __x, long double __y) ;



extern long double scalbl (long double __x, long double __n) ; extern long double __scalbl (long double __x, long double __n) ;




extern long double scalbnl (long double __x, int __n) ; extern long double __scalbnl (long double __x, int __n) ;



extern int ilogbl (long double __x) ; extern int __ilogbl (long double __x) ;
# 100 "/usr/include/math.h" 2 3
# 113 "/usr/include/math.h" 3
extern int signgam;
# 236 "/usr/include/math.h" 3
typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 261 "/usr/include/math.h" 3
struct exception

  {
    int type;
    char *name;
    double arg1;
    double arg2;
    double retval;
  };




extern int matherr (struct exception *__exc);
# 289 "/usr/include/math.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/float.h" 1 3
# 290 "/usr/include/math.h" 2 3
# 348 "/usr/include/math.h" 3
# 1 "/usr/include/bits/mathinline.h" 1 3
# 281 "/usr/include/bits/mathinline.h" 3
extern __inline double __sgn (double) ; extern __inline double __sgn (double __x) { return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); } extern __inline float __sgnf (float) ; extern __inline float __sgnf (float __x) { return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); } extern __inline long double __sgnl (long double) ; extern __inline long double __sgnl (long double __x) { return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); }
# 466 "/usr/include/bits/mathinline.h" 3
extern __inline double atan2 (double __y, double __x) { register long double __value; __asm __volatile__ ("fpatan" : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); return __value; } extern __inline float atan2f (float __y, float __x) { register long double __value; __asm __volatile__ ("fpatan" : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); return __value; } extern __inline long double atan2l (long double __y, long double __x) { register long double __value; __asm __volatile__ ("fpatan" : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); return __value; }
extern __inline long double __atan2l (long double __y, long double __x) { register long double __value; __asm __volatile__ ("fpatan" : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); return __value; }


extern __inline double fmod (double __x, double __y) { register long double __value; __asm __volatile__ ("1:	fprem\n\t" "fnstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc"); return __value; } extern __inline float fmodf (float __x, float __y) { register long double __value; __asm __volatile__ ("1:	fprem\n\t" "fnstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc"); return __value; } extern __inline long double fmodl (long double __x, long double __y) { register long double __value; __asm __volatile__ ("1:	fprem\n\t" "fnstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc"); return __value; }
# 481 "/usr/include/bits/mathinline.h" 3
extern __inline double sqrt (double __x) { register double __result; __asm __volatile__ ("fsqrt" : "=t" (__result) : "0" (__x)); return __result; } extern __inline float sqrtf (float __x) { register float __result; __asm __volatile__ ("fsqrt" : "=t" (__result) : "0" (__x)); return __result; } extern __inline long double sqrtl (long double __x) { register long double __result; __asm __volatile__ ("fsqrt" : "=t" (__result) : "0" (__x)); return __result; }
extern __inline long double __sqrtl (long double __x) { register long double __result; __asm __volatile__ ("fsqrt" : "=t" (__result) : "0" (__x)); return __result; }


extern __inline double fabs (double __x) { return __builtin_fabs (__x); }
extern __inline float fabsf (float __x) { return __builtin_fabsf (__x); }
extern __inline long double fabsl (long double __x) { return __builtin_fabsl (__x); }
extern __inline long double __fabsl (long double __x) { return __builtin_fabsl (__x); }
# 507 "/usr/include/bits/mathinline.h" 3
extern __inline double atan (double __x) { register double __result; __asm __volatile__ ("fld1; fpatan" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } extern __inline float atanf (float __x) { register float __result; __asm __volatile__ ("fld1; fpatan" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } extern __inline long double atanl (long double __x) { register long double __result; __asm __volatile__ ("fld1; fpatan" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; }

extern __inline long double __sgn1l (long double) ; extern __inline long double __sgn1l (long double __x) { __extension__ union { long double __xld; unsigned int __xi[3]; } __n = { __xld: __x }; __n.__xi[2] = (__n.__xi[2] & 0x8000) | 0x3fff; __n.__xi[1] = 0x80000000; __n.__xi[0] = 0; return __n.__xld; }
# 533 "/usr/include/bits/mathinline.h" 3
extern __inline double floor (double __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0400; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; } extern __inline float floorf (float __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0400; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; } extern __inline long double floorl (long double __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0400; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; }
# 544 "/usr/include/bits/mathinline.h" 3
extern __inline double ceil (double __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0800; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; } extern __inline float ceilf (float __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0800; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; } extern __inline long double ceill (long double __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0800; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; }
# 562 "/usr/include/bits/mathinline.h" 3
extern __inline double
ldexp (double __x, int __y)
{
  register long double __value; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__x), "u" ((long double) __y)); return __value;
}
# 580 "/usr/include/bits/mathinline.h" 3
extern __inline double log1p (double __x) { register long double __value; if (__fabsl (__x) >= 1.0 - 0.5 * 1.41421356237309504880L) __value = logl (1.0 + __x); else __asm __volatile__ ("fldln2\n\t" "fxch\n\t" "fyl2xp1" : "=t" (__value) : "0" (__x) : "st(1)"); return __value; } extern __inline float log1pf (float __x) { register long double __value; if (__fabsl (__x) >= 1.0 - 0.5 * 1.41421356237309504880L) __value = logl (1.0 + __x); else __asm __volatile__ ("fldln2\n\t" "fxch\n\t" "fyl2xp1" : "=t" (__value) : "0" (__x) : "st(1)"); return __value; } extern __inline long double log1pl (long double __x) { register long double __value; if (__fabsl (__x) >= 1.0 - 0.5 * 1.41421356237309504880L) __value = logl (1.0 + __x); else __asm __volatile__ ("fldln2\n\t" "fxch\n\t" "fyl2xp1" : "=t" (__value) : "0" (__x) : "st(1)"); return __value; }
# 594 "/usr/include/bits/mathinline.h" 3
extern __inline double asinh (double __x) { register long double __y = __fabsl (__x); return (log1pl (__y * __y / (__sqrtl (__y * __y + 1.0) + 1.0) + __y) * __sgn1l (__x)); } extern __inline float asinhf (float __x) { register long double __y = __fabsl (__x); return (log1pl (__y * __y / (__sqrtl (__y * __y + 1.0) + 1.0) + __y) * __sgn1l (__x)); } extern __inline long double asinhl (long double __x) { register long double __y = __fabsl (__x); return (log1pl (__y * __y / (__sqrtl (__y * __y + 1.0) + 1.0) + __y) * __sgn1l (__x)); }




extern __inline double acosh (double __x) { return logl (__x + __sqrtl (__x - 1.0) * __sqrtl (__x + 1.0)); } extern __inline float acoshf (float __x) { return logl (__x + __sqrtl (__x - 1.0) * __sqrtl (__x + 1.0)); } extern __inline long double acoshl (long double __x) { return logl (__x + __sqrtl (__x - 1.0) * __sqrtl (__x + 1.0)); }


extern __inline double atanh (double __x) { register long double __y = __fabsl (__x); return -0.5 * log1pl (-(__y + __y) / (1.0 + __y)) * __sgn1l (__x); } extern __inline float atanhf (float __x) { register long double __y = __fabsl (__x); return -0.5 * log1pl (-(__y + __y) / (1.0 + __y)) * __sgn1l (__x); } extern __inline long double atanhl (long double __x) { register long double __y = __fabsl (__x); return -0.5 * log1pl (-(__y + __y) / (1.0 + __y)) * __sgn1l (__x); }




extern __inline double hypot (double __x, double __y) { return __sqrtl (__x * __x + __y * __y); } extern __inline float hypotf (float __x, float __y) { return __sqrtl (__x * __x + __y * __y); } extern __inline long double hypotl (long double __x, long double __y) { return __sqrtl (__x * __x + __y * __y); }

extern __inline double logb (double __x) { register long double __value; register long double __junk; __asm __volatile__ ("fxtract\n\t" : "=t" (__junk), "=u" (__value) : "0" (__x)); return __value; } extern __inline float logbf (float __x) { register long double __value; register long double __junk; __asm __volatile__ ("fxtract\n\t" : "=t" (__junk), "=u" (__value) : "0" (__x)); return __value; } extern __inline long double logbl (long double __x) { register long double __value; register long double __junk; __asm __volatile__ ("fxtract\n\t" : "=t" (__junk), "=u" (__value) : "0" (__x)); return __value; }
# 693 "/usr/include/bits/mathinline.h" 3
extern __inline double drem (double __x, double __y) { register double __value; register int __clobbered; __asm __volatile__ ("1:	fprem1\n\t" "fstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value), "=&a" (__clobbered) : "0" (__x), "u" (__y) : "cc"); return __value; } extern __inline float dremf (float __x, float __y) { register double __value; register int __clobbered; __asm __volatile__ ("1:	fprem1\n\t" "fstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value), "=&a" (__clobbered) : "0" (__x), "u" (__y) : "cc"); return __value; } extern __inline long double dreml (long double __x, long double __y) { register double __value; register int __clobbered; __asm __volatile__ ("1:	fprem1\n\t" "fstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value), "=&a" (__clobbered) : "0" (__x), "u" (__y) : "cc"); return __value; }
# 706 "/usr/include/bits/mathinline.h" 3
extern __inline int
__finite (double __x)
{
  return (__extension__
          (((((union { double __d; int __i[2]; }) {__d: __x}).__i[1]
             | 0x800fffffu) + 1) >> 31));
}
# 349 "/usr/include/math.h" 2 3
# 1943 "/usr/local/src/temp/php-4.0.6/main/php_config.h" 2
# 2 "/usr/local/src/temp/php-4.0.6/Zend/zend_config.h" 2
# 45 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2
# 55 "/usr/local/src/temp/php-4.0.6/Zend/zend.h"
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stdarg.h" 1 3
# 110 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/stdarg.h" 3
typedef __gnuc_va_list va_list;
# 56 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2



# 1 "/usr/include/dlfcn.h" 1 3
# 23 "/usr/include/dlfcn.h" 3
# 1 "/usr/include/features.h" 1 3
# 24 "/usr/include/dlfcn.h" 2 3


# 1 "/usr/include/bits/dlfcn.h" 1 3
# 27 "/usr/include/dlfcn.h" 2 3
# 45 "/usr/include/dlfcn.h" 3
extern void *dlopen (__const char *__file, int __mode) ;



extern int dlclose (void *__handle) ;



extern void *dlsym (void *__restrict __handle,
                    __const char *__restrict __name) ;
# 67 "/usr/include/dlfcn.h" 3
extern char *dlerror (void) ;
# 60 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2
# 89 "/usr/local/src/temp/php-4.0.6/Zend/zend.h"
# 1 "/usr/include/alloca.h" 1 3
# 90 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2
# 134 "/usr/local/src/temp/php-4.0.6/Zend/zend.h"
# 1 "/usr/local/src/temp/php-4.0.6/Zend/zend_errors.h" 1
# 135 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2
# 1 "/usr/local/src/temp/php-4.0.6/Zend/zend_alloc.h" 1
# 24 "/usr/local/src/temp/php-4.0.6/Zend/zend_alloc.h"
# 1 "/usr/include/stdio.h" 1 3
# 25 "/usr/local/src/temp/php-4.0.6/Zend/zend_alloc.h" 2





# 1 "/usr/local/src/temp/php-4.0.6/Zend/zend_globals_macros.h" 1
# 24 "/usr/local/src/temp/php-4.0.6/Zend/zend_globals_macros.h"
typedef struct _zend_compiler_globals zend_compiler_globals;
typedef struct _zend_executor_globals zend_executor_globals;
typedef struct _zend_alloc_globals zend_alloc_globals;
# 46 "/usr/local/src/temp/php-4.0.6/Zend/zend_globals_macros.h"
extern struct _zend_compiler_globals compiler_globals;
int zendparse(void);
# 66 "/usr/local/src/temp/php-4.0.6/Zend/zend_globals_macros.h"
extern zend_executor_globals executor_globals;
# 85 "/usr/local/src/temp/php-4.0.6/Zend/zend_globals_macros.h"
extern zend_alloc_globals alloc_globals;
# 31 "/usr/local/src/temp/php-4.0.6/Zend/zend_alloc.h" 2






typedef struct _zend_mem_header {
# 49 "/usr/local/src/temp/php-4.0.6/Zend/zend_alloc.h"
    struct _zend_mem_header *pNext;
    struct _zend_mem_header *pLast;
        unsigned int size:30;
        unsigned int persistent:1;
        unsigned int cached:1;
} zend_mem_header;

typedef union _align_test {
        void *ptr;
        double dbl;
        long lng;
} align_test;
# 77 "/usr/local/src/temp/php-4.0.6/Zend/zend_alloc.h"
         char *zend_strndup(const char *s, unsigned int length);

         void *_emalloc(size_t size );
         void _efree(void *ptr );
         void *_ecalloc(size_t nmemb, size_t size );
         void *_erealloc(void *ptr, size_t size, int allow_failure );
         char *_estrdup(const char *s );
         char *_estrndup(const char *s, unsigned int length );
         int _persist_alloc(void *ptr );
# 118 "/usr/local/src/temp/php-4.0.6/Zend/zend_alloc.h"
         int zend_set_memory_limit(unsigned int memory_limit);

         void start_memory_manager(void);
         void shutdown_memory_manager(int silent, int clean_cache);
# 136 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2

typedef unsigned char zend_bool;
typedef unsigned char zend_uchar;
typedef unsigned int zend_uint;
typedef unsigned long zend_ulong;
typedef unsigned short zend_ushort;


# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/limits.h" 1 3
# 11 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/limits.h" 3
# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/syslimits.h" 1 3






# 1 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/limits.h" 1 3
# 125 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/limits.h" 3
# 1 "/usr/include/limits.h" 1 3
# 26 "/usr/include/limits.h" 3
# 1 "/usr/include/features.h" 1 3
# 27 "/usr/include/limits.h" 2 3



# 1 "/usr/include/bits/posix1_lim.h" 1 3
# 126 "/usr/include/bits/posix1_lim.h" 3
# 1 "/usr/include/bits/local_lim.h" 1 3
# 36 "/usr/include/bits/local_lim.h" 3
# 1 "/usr/include/linux/limits.h" 1 3
# 37 "/usr/include/bits/local_lim.h" 2 3
# 127 "/usr/include/bits/posix1_lim.h" 2 3
# 31 "/usr/include/limits.h" 2 3



# 1 "/usr/include/bits/posix2_lim.h" 1 3
# 35 "/usr/include/limits.h" 2 3
# 126 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/limits.h" 2 3
# 8 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/syslimits.h" 2 3
# 12 "/usr/local/lib/gcc-lib/i686-pc-linux-gnu/3.0.1/include/limits.h" 2 3
# 145 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2
# 161 "/usr/local/src/temp/php-4.0.6/Zend/zend.h"
# 1 "/usr/local/src/temp/php-4.0.6/Zend/zend_hash.h" 1
# 23 "/usr/local/src/temp/php-4.0.6/Zend/zend_hash.h"
# 1 "/usr/include/sys/types.h" 1 3
# 24 "/usr/local/src/temp/php-4.0.6/Zend/zend_hash.h" 2
# 36 "/usr/local/src/temp/php-4.0.6/Zend/zend_hash.h"
typedef int (*compare_func_t)(const void *, const void *);
typedef void (*sort_func_t)(void *, size_t, register size_t, compare_func_t);
typedef void (*dtor_func_t)(void *pDest);
typedef int (*apply_func_t)(void *pDest);
typedef int (*apply_func_arg_t)(void *pDest, void *argument);
typedef ulong (*hash_func_t)(char *arKey, uint nKeyLength);
typedef void (*copy_ctor_func_t)(void *pElement);

struct _hashtable;

typedef struct bucket {
        ulong h;
        uint nKeyLength;
        void *pData;
        void *pDataPtr;
        struct bucket *pListNext;
        struct bucket *pListLast;
        struct bucket *pNext;
        struct bucket *pLast;
        char arKey[1];
} Bucket;

typedef struct _hashtable {
        uint nTableSize;
        uint nHashSizeIndex;
        uint nNumOfElements;
        ulong nNextFreeElement;
        hash_func_t pHashFunction;
        Bucket *pInternalPointer;
        Bucket *pListHead;
        Bucket *pListTail;
        Bucket **arBuckets;
        dtor_func_t pDestructor;
        zend_bool persistent;
        unsigned char nApplyCount;
        zend_bool bApplyProtection;



} HashTable;

typedef Bucket* HashPosition;




         int zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent);
         int zend_hash_init_ex(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, int persistent, zend_bool bApplyProtection);
         void zend_hash_destroy(HashTable *ht);

         void zend_hash_clean(HashTable *ht);


         int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest,int flag);





         int zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest,int flag);





         int zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag);





typedef struct _zend_hash_key {
        char *arKey;
        uint nKeyLength;
        ulong h;
} zend_hash_key;


typedef int (*apply_func_args_t)(void *pDest, int num_args, va_list args, zend_hash_key *hash_key);




         void zend_hash_graceful_destroy(HashTable *ht);
         void zend_hash_apply(HashTable *ht, apply_func_t apply_func);
         void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void *);
         void zend_hash_apply_with_arguments(HashTable *ht, int (*)(void *element, int num_args, va_list args, zend_hash_key *hash_key), int, ...);





         int zend_hash_del_key_or_index(HashTable *ht, char *arKey, uint nKeyLength, ulong h, int flag);





         ulong zend_get_hash_value(HashTable *ht, char *arKey, uint nKeyLength);


         int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
         int zend_hash_quick_find(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void **pData);
         int zend_hash_index_find(HashTable *ht, ulong h, void **pData);


         int zend_hash_exists(HashTable *ht, char *arKey, uint nKeyLength);
         int zend_hash_index_exists(HashTable *ht, ulong h);
         ulong zend_hash_next_free_element(HashTable *ht);


         int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos);
         int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos);
         int zend_hash_get_current_key_ex(HashTable *ht, char **str_index, ulong *str_length, ulong *num_index, zend_bool duplicate, HashPosition *pos);
         int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos);
         int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos);
         void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos);
         void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos);
# 171 "/usr/local/src/temp/php-4.0.6/Zend/zend_hash.h"
         void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size);
         void zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite);
         void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, zend_bool (*pReplaceOrig)(void *orig, void *p_new));
         int zend_hash_sort(HashTable *ht, sort_func_t sort_func, compare_func_t compare_func, int renumber);
         int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered);
         int zend_hash_minmax(HashTable *ht, int (*compar)(const void *, const void *), int flag, void **pData);

         int zend_hash_num_elements(HashTable *ht);

         int zend_hash_rehash(HashTable *ht);

         ulong hashpjw(char *arKey, uint nKeyLength);
# 162 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2
# 1 "/usr/local/src/temp/php-4.0.6/Zend/zend_llist.h" 1
# 24 "/usr/local/src/temp/php-4.0.6/Zend/zend_llist.h"
# 1 "/usr/include/stdlib.h" 1 3
# 25 "/usr/local/src/temp/php-4.0.6/Zend/zend_llist.h" 2

typedef struct _zend_llist_element {
        struct _zend_llist_element *next;
        struct _zend_llist_element *prev;
        char data[1];
} zend_llist_element;

typedef void (*llist_dtor_func_t)(void *);
typedef int (*llist_compare_func_t)(const zend_llist_element *, const zend_llist_element *);
typedef void (*llist_apply_with_arg_func_t)(void *data, void *arg);
typedef void (*llist_apply_with_args_func_t)(void *data, int num_args, va_list args);
typedef void (*llist_apply_func_t)(void *);

typedef struct _zend_llist {
        zend_llist_element *head;
        zend_llist_element *tail;
        size_t size;
        llist_dtor_func_t dtor;
        unsigned char persistent;
        zend_llist_element *traverse_ptr;
} zend_llist;

typedef zend_llist_element* zend_llist_position;


         void zend_llist_init(zend_llist *l, size_t size, llist_dtor_func_t dtor, unsigned char persistent);
         void zend_llist_add_element(zend_llist *l, void *element);
         void zend_llist_prepend_element(zend_llist *l, void *element);
         void zend_llist_del_element(zend_llist *l, void *element, int (*compare)(void *element1, void *element2));
         void zend_llist_destroy(zend_llist *l);
         void zend_llist_clean(zend_llist *l);
         void zend_llist_remove_tail(zend_llist *l);
         void zend_llist_copy(zend_llist *dst, zend_llist *src);
         void zend_llist_apply(zend_llist *l, llist_apply_func_t);
         void zend_llist_apply_with_del(zend_llist *l, int (*func)(void *data));
         void zend_llist_apply_with_argument(zend_llist *l, llist_apply_with_arg_func_t, void *arg);
         void zend_llist_apply_with_arguments(zend_llist *l, llist_apply_with_args_func_t func, int num_args, ...);
         int zend_llist_count(zend_llist *l);
         void zend_llist_sort(zend_llist *l, llist_compare_func_t comp_func);


         void *zend_llist_get_first_ex(zend_llist *l, zend_llist_position *pos);
         void *zend_llist_get_last_ex(zend_llist *l, zend_llist_position *pos);
         void *zend_llist_get_next_ex(zend_llist *l, zend_llist_position *pos);
         void *zend_llist_get_prev_ex(zend_llist *l, zend_llist_position *pos);
# 163 "/usr/local/src/temp/php-4.0.6/Zend/zend.h" 2







typedef struct _zval_struct zval;
typedef struct _zend_class_entry zend_class_entry;

typedef union _zvalue_value {
        long lval;
        double dval;
        struct {
                char *val;
                int len;
        } str;
        HashTable *ht;
        struct {
                zend_class_entry *ce;
                HashTable *properties;
        } obj;
} zvalue_value;


struct _zval_struct {

        zvalue_value value;
        zend_uchar type;
        zend_uchar is_ref;
        zend_ushort refcount;
};



typedef struct _zend_function_entry {
        char *fname;
        void (*handler)(int ht, zval *return_value, zval *this_ptr, int return_value_used );
        unsigned char *func_arg_types;
} zend_function_entry;


typedef struct _zend_property_reference {
        int type;
        zval *object;
        zend_llist *elements_list;
} zend_property_reference;



typedef struct _zend_overloaded_element {
        int type;
        zval element;
} zend_overloaded_element;




struct _zend_class_entry {
        char type;
        char *name;
        uint name_length;
        struct _zend_class_entry *parent;
        int *refcount;
        zend_bool constants_updated;

        HashTable function_table;
        HashTable default_properties;
        zend_function_entry *builtin_functions;


        void (*handle_function_call)(int ht, zval *return_value, zval *this_ptr, int return_value_used , zend_property_reference *property_reference);
        zval (*handle_property_get)(zend_property_reference *property_reference);
        int (*handle_property_set)(zend_property_reference *property_reference, zval *value);
};



typedef struct _zend_utility_functions {
        void (*error_function)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);
        int (*printf_function)(const char *format, ...);
        int (*write_function)(const char *str, uint str_length);
        FILE *(*fopen_function)(const char *filename, char **opened_path);
        void (*message_handler)(long message, void *data);
        void (*block_interruptions)(void);
        void (*unblock_interruptions)(void);
        int (*get_configuration_directive)(char *name, uint name_length, zval *contents);
        void (*ticks_function)(int ticks);
} zend_utility_functions;


typedef struct _zend_utility_values {
        char *import_use_extension;
        uint import_use_extension_length;
} zend_utility_values;


typedef int (*zend_write_func_t)(const char *str, uint str_length);
# 300 "/usr/local/src/temp/php-4.0.6/Zend/zend.h"
int zend_startup(zend_utility_functions *utility_functions, char **extensions, int start_builtin_functions);
void zend_shutdown(void);

void zend_set_utility_values(zend_utility_values *utility_values);

         void zend_bailout(void);

         char *get_zend_version(void);

         void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy);
         int zend_print_zval(zval *expr, int indent);
         int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent);
         void zend_print_zval_r(zval *expr, int indent);
         void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent);

         void zend_output_debug_string(zend_bool trigger_break, char *format, ...);






         extern char *empty_string;

         void free_estring(char **str_p);
# 344 "/usr/local/src/temp/php-4.0.6/Zend/zend.h"
extern int (*zend_printf)(const char *format, ...);
extern zend_write_func_t zend_write;
extern FILE *(*zend_fopen)(const char *filename, char **opened_path);
extern void (*zend_block_interruptions)(void);
extern void (*zend_unblock_interruptions)(void);
extern void (*zend_ticks_function)(int ticks);
extern void (*zend_error_cb)(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args);


         void zend_error(int type, const char *format, ...);

void zenderror(char *error);

extern zend_class_entry zend_standard_class_def;
extern zend_utility_values zend_uv;
extern zval zval_used_for_init;
# 370 "/usr/local/src/temp/php-4.0.6/Zend/zend.h"
         void zend_message_dispatcher(long message, void *data);


         int zend_get_configuration_directive(char *name, uint name_length, zval *contents);
# 87 "mbfilter.c" 2
# 98 "mbfilter.c"
extern const unsigned short iso8859_2_ucs_table[];
extern const unsigned short iso8859_3_ucs_table[];
extern const unsigned short iso8859_4_ucs_table[];
extern const unsigned short iso8859_5_ucs_table[];
extern const unsigned short iso8859_6_ucs_table[];
extern const unsigned short iso8859_7_ucs_table[];
extern const unsigned short iso8859_8_ucs_table[];
extern const unsigned short iso8859_9_ucs_table[];
extern const unsigned short iso8859_10_ucs_table[];
extern const unsigned short iso8859_13_ucs_table[];
extern const unsigned short iso8859_14_ucs_table[];
extern const unsigned short iso8859_15_ucs_table[];
# 119 "mbfilter.c"
extern const unsigned char mbfl_charprop_table[];



static const char *mbfl_language_uni_aliases[] = {"universal", "none", ((void *)0)};

static mbfl_language mbfl_language_uni = {
        mbfl_no_language_uni,
        "uni",
        "uni",
        &mbfl_language_uni_aliases,
        mbfl_no_encoding_utf8,
        mbfl_no_encoding_base64,
        mbfl_no_encoding_base64
};

static mbfl_language mbfl_language_japanese = {
        mbfl_no_language_japanese,
        "Japanese",
        "ja",
        ((void *)0),
        mbfl_no_encoding_2022jp,
        mbfl_no_encoding_base64,
        mbfl_no_encoding_7bit
};

static mbfl_language mbfl_language_english = {
        mbfl_no_language_english,
        "English",
        "en",
        ((void *)0),
        mbfl_no_encoding_8859_1,
        mbfl_no_encoding_qprint,
        mbfl_no_encoding_8bit
};

static mbfl_language *mbfl_language_ptr_table[] = {
        &mbfl_language_uni,
        &mbfl_language_japanese,
        &mbfl_language_english,
        ((void *)0)
};



static const unsigned char mblen_table_utf8[] = {
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 1, 1
};

static const unsigned char mblen_table_eucjp[] = {
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1
};

static const unsigned char mblen_table_sjis[] = {
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
};



static const char *mbfl_encoding_pass_aliases[] = {"none", ((void *)0)};

static mbfl_encoding mbfl_encoding_pass = {
        mbfl_no_encoding_pass,
        "pass",
        ((void *)0),
        &mbfl_encoding_pass_aliases,
        ((void *)0),
        0
};

static const char *mbfl_encoding_auto_aliases[] = {"unknown", ((void *)0)};

static mbfl_encoding mbfl_encoding_auto = {
        mbfl_no_encoding_auto,
        "auto",
        ((void *)0),
        &mbfl_encoding_auto_aliases,
        ((void *)0),
        0
};

static mbfl_encoding mbfl_encoding_wchar = {
        mbfl_no_encoding_wchar,
        "wchar",
        ((void *)0),
        ((void *)0),
        ((void *)0),
        0x00000100
};

static mbfl_encoding mbfl_encoding_byte2be = {
        mbfl_no_encoding_byte2be,
        "byte2be",
        ((void *)0),
        ((void *)0),
        ((void *)0),
        0x00000001
};

static mbfl_encoding mbfl_encoding_byte2le = {
        mbfl_no_encoding_byte2le,
        "byte2le",
        ((void *)0),
        ((void *)0),
        ((void *)0),
        0x00000001
};

static mbfl_encoding mbfl_encoding_byte4be = {
        mbfl_no_encoding_byte4be,
        "byte4be",
        ((void *)0),
        ((void *)0),
        ((void *)0),
        0x00000001
};

static mbfl_encoding mbfl_encoding_byte4le = {
        mbfl_no_encoding_byte4le,
        "byte4le",
        ((void *)0),
        ((void *)0),
        ((void *)0),
        0x00000001
};

static mbfl_encoding mbfl_encoding_base64 = {
        mbfl_no_encoding_base64,
        "BASE64",
        "BASE64",
        ((void *)0),
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_qprint_aliases[] = {"qprint", ((void *)0)};

static mbfl_encoding mbfl_encoding_qprint = {
        mbfl_no_encoding_qprint,
        "Quoted-Printable",
        "Quoted-Printable",
        &mbfl_encoding_qprint_aliases,
        ((void *)0),
        0x00000001
};

static mbfl_encoding mbfl_encoding_7bit = {
        mbfl_no_encoding_7bit,
        "7bit",
        "7bit",
        ((void *)0),
        ((void *)0),
        0x00000001
};

static mbfl_encoding mbfl_encoding_8bit = {
        mbfl_no_encoding_8bit,
        "8bit",
        "8bit",
        ((void *)0),
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_ucs2_aliases[] = {"ISO-10646-UCS-2", "UCS2" , "UNICODE", ((void *)0)};

static mbfl_encoding mbfl_encoding_ucs2 = {
        mbfl_no_encoding_ucs2,
        "UCS-2",
        "UCS-2",
        &mbfl_encoding_ucs2_aliases,
        ((void *)0),
        0x00000010
};

static mbfl_encoding mbfl_encoding_ucs2be = {
        mbfl_no_encoding_ucs2be,
        "UCS-2BE",
        "UCS-2BE",
        ((void *)0),
        ((void *)0),
        0x00000010
};

static mbfl_encoding mbfl_encoding_ucs2le = {
        mbfl_no_encoding_ucs2le,
        "UCS-2LE",
        "UCS-2LE",
        ((void *)0),
        ((void *)0),
        0x00000020
};

static const char *mbfl_encoding_ucs4_aliases[] = {"ISO-10646-UCS-4", "UCS4", ((void *)0)};

static mbfl_encoding mbfl_encoding_ucs4 = {
        mbfl_no_encoding_ucs4,
        "UCS-4",
        "UCS-4",
        &mbfl_encoding_ucs4_aliases,
        ((void *)0),
        0x00000100
};

static mbfl_encoding mbfl_encoding_ucs4be = {
        mbfl_no_encoding_ucs4be,
        "UCS-4BE",
        "UCS-4BE",
        ((void *)0),
        ((void *)0),
        0x00000100
};

static mbfl_encoding mbfl_encoding_ucs4le = {
        mbfl_no_encoding_ucs4le,
        "UCS-4LE",
        "UCS-4LE",
        ((void *)0),
        ((void *)0),
        0x00000200
};

static const char *mbfl_encoding_utf32_aliases[] = {"utf32", ((void *)0)};

static mbfl_encoding mbfl_encoding_utf32 = {
        mbfl_no_encoding_utf32,
        "UTF-32",
        "UTF-32",
        &mbfl_encoding_utf32_aliases,
        ((void *)0),
        0x00000100
};

static mbfl_encoding mbfl_encoding_utf32be = {
        mbfl_no_encoding_utf32be,
        "UTF-32BE",
        "UTF-32BE",
        ((void *)0),
        ((void *)0),
        0x00000100
};

static mbfl_encoding mbfl_encoding_utf32le = {
        mbfl_no_encoding_utf32le,
        "UTF-32LE",
        "UTF-32LE",
        ((void *)0),
        ((void *)0),
        0x00000200
};

static const char *mbfl_encoding_utf16_aliases[] = {"utf16", ((void *)0)};

static mbfl_encoding mbfl_encoding_utf16 = {
        mbfl_no_encoding_utf16,
        "UTF-16",
        "UTF-16",
        &mbfl_encoding_utf16_aliases,
        ((void *)0),
        0x00000040
};

static mbfl_encoding mbfl_encoding_utf16be = {
        mbfl_no_encoding_utf16be,
        "UTF-16BE",
        "UTF-16BE",
        ((void *)0),
        ((void *)0),
        0x00000040
};

static mbfl_encoding mbfl_encoding_utf16le = {
        mbfl_no_encoding_utf16le,
        "UTF-16LE",
        "UTF-16LE",
        ((void *)0),
        ((void *)0),
        0x00000080
};

static const char *mbfl_encoding_utf8_aliases[] = {"utf8", ((void *)0)};

static mbfl_encoding mbfl_encoding_utf8 = {
        mbfl_no_encoding_utf8,
        "UTF-8",
        "UTF-8",
        &mbfl_encoding_utf8_aliases,
        mblen_table_utf8,
        0x00000002
};

static const char *mbfl_encoding_utf7_aliases[] = {"utf7", ((void *)0)};

static mbfl_encoding mbfl_encoding_utf7 = {
        mbfl_no_encoding_utf7,
        "UTF-7",
        "UTF-7",
        &mbfl_encoding_utf7_aliases,
        ((void *)0),
        0x00000002 | 0x00001000
};

static mbfl_encoding mbfl_encoding_utf7imap = {
        mbfl_no_encoding_utf7imap,
        "UTF7-IMAP",
        ((void *)0),
        ((void *)0),
        ((void *)0),
        0x00000002 | 0x00001000
};

static mbfl_encoding mbfl_encoding_ascii = {
        mbfl_no_encoding_ascii,
        "ASCII",
        "US-ASCII",
        ((void *)0),
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_euc_jp_aliases[] = {"EUC", "EUC_JP", "eucJP", "x-euc-jp", ((void *)0)};

static mbfl_encoding mbfl_encoding_euc_jp = {
        mbfl_no_encoding_euc_jp,
        "EUC-JP",
        "EUC-JP",
        &mbfl_encoding_euc_jp_aliases,
        mblen_table_eucjp,
        0x00000002
};

static const char *mbfl_encoding_sjis_aliases[] = {"x-sjis", "SHIFT-JIS", ((void *)0)};

static mbfl_encoding mbfl_encoding_sjis = {
        mbfl_no_encoding_sjis,
        "SJIS",
        "Shift_JIS",
        &mbfl_encoding_sjis_aliases,
        mblen_table_sjis,
        0x00000002
};

static const char *mbfl_encoding_eucjp_win_aliases[] = {"eucJP-open", ((void *)0)};

static mbfl_encoding mbfl_encoding_eucjp_win = {
        mbfl_no_encoding_eucjp_win,
        "eucJP-win",
        "EUC-JP",
        &mbfl_encoding_eucjp_win_aliases,
        mblen_table_eucjp,
        0x00000002
};

static const char *mbfl_encoding_sjis_win_aliases[] = {"SJIS-open", "MS_Kanji", "Windows-31J", ((void *)0)};

static mbfl_encoding mbfl_encoding_sjis_win = {
        mbfl_no_encoding_sjis_win,
        "SJIS-win",
        "Shift_JIS",
        &mbfl_encoding_sjis_win_aliases,
        mblen_table_sjis,
        0x00000002
};

static mbfl_encoding mbfl_encoding_jis = {
        mbfl_no_encoding_jis,
        "JIS",
        "ISO-2022-JP",
        ((void *)0),
        ((void *)0),
        0x00000002 | 0x00001000
};

static mbfl_encoding mbfl_encoding_2022jp = {
        mbfl_no_encoding_2022jp,
        "ISO-2022-JP",
        "ISO-2022-JP",
        ((void *)0),
        ((void *)0),
        0x00000002 | 0x00001000
};

static const char *mbfl_encoding_8859_1_aliases[] = {"ISO_8859-1", "latin1", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_1 = {
        mbfl_no_encoding_8859_1,
        "ISO-8859-1",
        "ISO-8859-1",
        &mbfl_encoding_8859_1_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_2_aliases[] = {"ISO_8859-2", "latin2", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_2 = {
        mbfl_no_encoding_8859_2,
        "ISO-8859-2",
        "ISO-8859-2",
        &mbfl_encoding_8859_2_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_3_aliases[] = {"ISO_8859-3", "latin3", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_3 = {
        mbfl_no_encoding_8859_3,
        "ISO-8859-3",
        "ISO-8859-3",
        &mbfl_encoding_8859_3_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_4_aliases[] = {"ISO_8859-4", "latin4", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_4 = {
        mbfl_no_encoding_8859_4,
        "ISO-8859-4",
        "ISO-8859-4",
        &mbfl_encoding_8859_4_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_5_aliases[] = {"ISO_8859-5", "cyrillic", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_5 = {
        mbfl_no_encoding_8859_5,
        "ISO-8859-5",
        "ISO-8859-5",
        &mbfl_encoding_8859_5_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_6_aliases[] = {"ISO_8859-6", "arabic", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_6 = {
        mbfl_no_encoding_8859_6,
        "ISO-8859-6",
        "ISO-8859-6",
        &mbfl_encoding_8859_6_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_7_aliases[] = {"ISO_8859-7", "greek", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_7 = {
        mbfl_no_encoding_8859_7,
        "ISO-8859-7",
        "ISO-8859-7",
        &mbfl_encoding_8859_7_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_8_aliases[] = {"ISO_8859-8", "hebrew", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_8 = {
        mbfl_no_encoding_8859_8,
        "ISO-8859-8",
        "ISO-8859-8",
        &mbfl_encoding_8859_8_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_9_aliases[] = {"ISO_8859-9", "latin5", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_9 = {
        mbfl_no_encoding_8859_9,
        "ISO-8859-9",
        "ISO-8859-9",
        &mbfl_encoding_8859_9_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_10_aliases[] = {"ISO_8859-10", "latin6", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_10 = {
        mbfl_no_encoding_8859_10,
        "ISO-8859-10",
        "ISO-8859-10",
        &mbfl_encoding_8859_10_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_13_aliases[] = {"ISO_8859-13", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_13 = {
        mbfl_no_encoding_8859_13,
        "ISO-8859-13",
        "ISO-8859-13",
        &mbfl_encoding_8859_13_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_14_aliases[] = {"ISO_8859-14", "latin8", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_14 = {
        mbfl_no_encoding_8859_14,
        "ISO-8859-14",
        "ISO-8859-14",
        &mbfl_encoding_8859_14_aliases,
        ((void *)0),
        0x00000001
};

static const char *mbfl_encoding_8859_15_aliases[] = {"ISO_8859-15", ((void *)0)};

static mbfl_encoding mbfl_encoding_8859_15 = {
        mbfl_no_encoding_8859_15,
        "ISO-8859-15",
        "ISO-8859-15",
        &mbfl_encoding_8859_15_aliases,
        ((void *)0),
        0x00000001
};

static mbfl_encoding *mbfl_encoding_ptr_list[] = {
        &mbfl_encoding_pass,
        &mbfl_encoding_auto,
        &mbfl_encoding_wchar,
        &mbfl_encoding_byte2be,
        &mbfl_encoding_byte2le,
        &mbfl_encoding_byte4be,
        &mbfl_encoding_byte4le,
        &mbfl_encoding_base64,
        &mbfl_encoding_qprint,
        &mbfl_encoding_7bit,
        &mbfl_encoding_8bit,
        &mbfl_encoding_ucs4,
        &mbfl_encoding_ucs4be,
        &mbfl_encoding_ucs4le,
        &mbfl_encoding_ucs2,
        &mbfl_encoding_ucs2be,
        &mbfl_encoding_ucs2le,
        &mbfl_encoding_utf32,
        &mbfl_encoding_utf32be,
        &mbfl_encoding_utf32le,
        &mbfl_encoding_utf16,
        &mbfl_encoding_utf16be,
        &mbfl_encoding_utf16le,
        &mbfl_encoding_utf8,
        &mbfl_encoding_utf7,
        &mbfl_encoding_utf7imap,
        &mbfl_encoding_ascii,
        &mbfl_encoding_euc_jp,
        &mbfl_encoding_sjis,
        &mbfl_encoding_eucjp_win,
        &mbfl_encoding_sjis_win,
        &mbfl_encoding_jis,
        &mbfl_encoding_2022jp,
        &mbfl_encoding_8859_1,
        &mbfl_encoding_8859_2,
        &mbfl_encoding_8859_3,
        &mbfl_encoding_8859_4,
        &mbfl_encoding_8859_5,
        &mbfl_encoding_8859_6,
        &mbfl_encoding_8859_7,
        &mbfl_encoding_8859_8,
        &mbfl_encoding_8859_9,
        &mbfl_encoding_8859_10,
        &mbfl_encoding_8859_13,
        &mbfl_encoding_8859_14,
        &mbfl_encoding_8859_15,
        ((void *)0)
};


static void mbfl_filt_conv_common_ctor(mbfl_convert_filter *filter);
static int mbfl_filt_conv_common_flush(mbfl_convert_filter *filter);
static void mbfl_filt_conv_common_dtor(mbfl_convert_filter *filter);

static int mbfl_filt_conv_pass(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_byte2be(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_byte2be_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_byte2le(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_byte2le_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_byte4be(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_byte4be_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_byte4le(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_byte4le_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_any_7bit(int c, mbfl_convert_filter *filter);

static int mbfl_filt_conv_base64enc(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_base64enc_flush(mbfl_convert_filter *filter);
static int mbfl_filt_conv_base64dec(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_base64dec_flush(mbfl_convert_filter *filter);
static int mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_qprintenc_flush(mbfl_convert_filter *filter);
static int mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_qprintdec_flush(mbfl_convert_filter *filter);

static int mbfl_filt_conv_ucs4_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_ucs4be(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_ucs4le(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_ucs2_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_ucs2be(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_ucs2le(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_utf16_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_utf16be_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_utf16be(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_utf16le_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_utf16le(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_utf8_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_utf8(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_utf7_flush(mbfl_convert_filter *filter);
static int mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_utf7imap_flush(mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_ascii(int c, mbfl_convert_filter *filter);

static int mbfl_filt_conv_wchar_8859_1(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_2_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_2(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_3_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_3(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_4_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_4(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_5_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_5(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_6_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_6(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_7_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_7(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_8_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_8(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_9_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_9(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_10_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_10(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_13_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_13(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_14_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_14(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_8859_15_wchar(int c, mbfl_convert_filter *filter);
static int mbfl_filt_conv_wchar_8859_15(int c, mbfl_convert_filter *filter);

static void mbfl_filt_ident_common_ctor(mbfl_identify_filter *filter);
static void mbfl_filt_ident_common_dtor(mbfl_identify_filter *filter);
static void mbfl_filt_ident_false_ctor(mbfl_identify_filter *filter);
static int mbfl_filt_ident_utf8(int c, mbfl_identify_filter *filter);
static int mbfl_filt_ident_utf7(int c, mbfl_identify_filter *filter);
static int mbfl_filt_ident_ascii(int c, mbfl_identify_filter *filter);
static int mbfl_filt_ident_eucjp(int c, mbfl_identify_filter *filter);
static int mbfl_filt_ident_sjis(int c, mbfl_identify_filter *filter);
static int mbfl_filt_ident_sjiswin(int c, mbfl_identify_filter *filter);
static int mbfl_filt_ident_jis(int c, mbfl_identify_filter *filter);
static int mbfl_filt_ident_2022jp(int c, mbfl_identify_filter *filter);
static int mbfl_filt_ident_false(int c, mbfl_identify_filter *filter);
static int mbfl_filt_ident_true(int c, mbfl_identify_filter *filter);


static struct mbfl_convert_vtbl vtbl_pass = {
        mbfl_no_encoding_pass,
        mbfl_no_encoding_pass,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_pass,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_byte2be_wchar = {
        mbfl_no_encoding_byte2be,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte2be_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_byte2be = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_byte2be,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_byte2be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_byte2le_wchar = {
        mbfl_no_encoding_byte2le,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte2le_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_byte2le = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_byte2le,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_byte2le,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_byte4be_wchar = {
        mbfl_no_encoding_byte4be,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte4be_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_byte4be = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_byte4be,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_byte4be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_byte4le_wchar = {
        mbfl_no_encoding_byte4le,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte4le_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_byte4le = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_byte4le,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_byte4le,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8bit_b64 = {
        mbfl_no_encoding_8bit,
        mbfl_no_encoding_base64,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_base64enc,
        mbfl_filt_conv_base64enc_flush };

static struct mbfl_convert_vtbl vtbl_b64_8bit = {
        mbfl_no_encoding_base64,
        mbfl_no_encoding_8bit,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_base64dec,
        mbfl_filt_conv_base64dec_flush };

static struct mbfl_convert_vtbl vtbl_8bit_qprint = {
        mbfl_no_encoding_8bit,
        mbfl_no_encoding_qprint,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_qprintenc,
        mbfl_filt_conv_qprintenc_flush };

static struct mbfl_convert_vtbl vtbl_qprint_8bit = {
        mbfl_no_encoding_qprint,
        mbfl_no_encoding_8bit,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_qprintdec,
        mbfl_filt_conv_qprintdec_flush };

static struct mbfl_convert_vtbl vtbl_8bit_7bit = {
        mbfl_no_encoding_8bit,
        mbfl_no_encoding_7bit,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_any_7bit,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_7bit_8bit = {
        mbfl_no_encoding_7bit,
        mbfl_no_encoding_8bit,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_pass,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_ucs4_wchar = {
        mbfl_no_encoding_ucs4,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_ucs4_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_ucs4 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_ucs4,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ucs4be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_ucs4be_wchar = {
        mbfl_no_encoding_ucs4be,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte4be_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_ucs4be = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_ucs4be,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ucs4be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_ucs4le_wchar = {
        mbfl_no_encoding_ucs4le,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte4le_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_ucs4le = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_ucs4le,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ucs4le,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_ucs2_wchar = {
        mbfl_no_encoding_ucs2,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_ucs2_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_ucs2 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_ucs2,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ucs2be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_ucs2be_wchar = {
        mbfl_no_encoding_ucs2be,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte2be_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_ucs2be = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_ucs2be,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ucs2be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_ucs2le_wchar = {
        mbfl_no_encoding_ucs2le,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte2le_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_ucs2le = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_ucs2le,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ucs2le,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_utf32_wchar = {
        mbfl_no_encoding_utf32,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_ucs4_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_utf32 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_utf32,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ucs4be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_utf32be_wchar = {
        mbfl_no_encoding_utf32be,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte4be_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_utf32be = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_utf32be,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ucs4be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_utf32le_wchar = {
        mbfl_no_encoding_utf32le,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_byte4le_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_utf32le = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_utf32le,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ucs4le,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_utf16_wchar = {
        mbfl_no_encoding_utf16,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_utf16_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_utf16 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_utf16,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_utf16be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_utf16be_wchar = {
        mbfl_no_encoding_utf16be,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_utf16be_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_utf16be = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_utf16be,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_utf16be,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_utf16le_wchar = {
        mbfl_no_encoding_utf16le,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_utf16le_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_utf16le = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_utf16le,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_utf16le,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_utf8_wchar = {
        mbfl_no_encoding_utf8,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_utf8_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_utf8 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_utf8,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_utf8,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_utf7_wchar = {
        mbfl_no_encoding_utf7,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_utf7_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_utf7 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_utf7,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_utf7,
        mbfl_filt_conv_wchar_utf7_flush };

static struct mbfl_convert_vtbl vtbl_utf7imap_wchar = {
        mbfl_no_encoding_utf7imap,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_utf7imap_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_utf7imap = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_utf7imap,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_utf7imap,
        mbfl_filt_conv_wchar_utf7imap_flush };

static struct mbfl_convert_vtbl vtbl_ascii_wchar = {
        mbfl_no_encoding_ascii,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_pass,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_ascii = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_ascii,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_ascii,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_eucjp_wchar = {
        mbfl_no_encoding_euc_jp,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_eucjp_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_eucjp = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_euc_jp,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_eucjp,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_sjis_wchar = {
        mbfl_no_encoding_sjis,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_sjis_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_sjis = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_sjis,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_sjis,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_jis_wchar = {
        mbfl_no_encoding_jis,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_jis_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_jis = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_jis,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_jis,
        mbfl_filt_conv_any_jis_flush };

static struct mbfl_convert_vtbl vtbl_2022jp_wchar = {
        mbfl_no_encoding_2022jp,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_jis_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_2022jp = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_2022jp,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_2022jp,
        mbfl_filt_conv_any_jis_flush };

static struct mbfl_convert_vtbl vtbl_eucjpwin_wchar = {
        mbfl_no_encoding_eucjp_win,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_eucjpwin_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_eucjpwin = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_eucjp_win,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_eucjpwin,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_sjiswin_wchar = {
        mbfl_no_encoding_sjis_win,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_sjiswin_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_sjiswin = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_sjis_win,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_sjiswin,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_1_wchar = {
        mbfl_no_encoding_8859_1,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_pass,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_1 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_1,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_1,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_2_wchar = {
        mbfl_no_encoding_8859_2,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_2_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_2 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_2,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_2,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_3_wchar = {
        mbfl_no_encoding_8859_3,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_3_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_3 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_3,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_3,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_4_wchar = {
        mbfl_no_encoding_8859_4,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_4_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_4 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_4,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_4,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_5_wchar = {
        mbfl_no_encoding_8859_5,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_5_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_5 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_5,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_5,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_6_wchar = {
        mbfl_no_encoding_8859_6,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_6_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_6 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_6,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_6,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_7_wchar = {
        mbfl_no_encoding_8859_7,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_7_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_7 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_7,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_7,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_8_wchar = {
        mbfl_no_encoding_8859_8,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_8_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_8 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_8,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_8,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_9_wchar = {
        mbfl_no_encoding_8859_9,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_9_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_9 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_9,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_9,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_10_wchar = {
        mbfl_no_encoding_8859_10,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_10_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_10 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_10,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_10,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_13_wchar = {
        mbfl_no_encoding_8859_13,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_13_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_13 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_13,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_13,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_14_wchar = {
        mbfl_no_encoding_8859_14,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_14_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_14 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_14,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_14,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_8859_15_wchar = {
        mbfl_no_encoding_8859_15,
        mbfl_no_encoding_wchar,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_8859_15_wchar,
        mbfl_filt_conv_common_flush };

static struct mbfl_convert_vtbl vtbl_wchar_8859_15 = {
        mbfl_no_encoding_wchar,
        mbfl_no_encoding_8859_15,
        mbfl_filt_conv_common_ctor,
        mbfl_filt_conv_common_dtor,
        mbfl_filt_conv_wchar_8859_15,
        mbfl_filt_conv_common_flush };


static struct mbfl_convert_vtbl *mbfl_convert_filter_list[] = {
        &vtbl_utf8_wchar,
        &vtbl_wchar_utf8,
        &vtbl_eucjp_wchar,
        &vtbl_wchar_eucjp,
        &vtbl_sjis_wchar,
        &vtbl_wchar_sjis,
        &vtbl_jis_wchar,
        &vtbl_wchar_jis,
        &vtbl_2022jp_wchar,
        &vtbl_wchar_2022jp,
        &vtbl_eucjpwin_wchar,
        &vtbl_wchar_eucjpwin,
        &vtbl_sjiswin_wchar,
        &vtbl_wchar_sjiswin,
        &vtbl_ascii_wchar,
        &vtbl_wchar_ascii,
        &vtbl_8859_1_wchar,
        &vtbl_wchar_8859_1,
        &vtbl_8859_2_wchar,
        &vtbl_wchar_8859_2,
        &vtbl_8859_3_wchar,
        &vtbl_wchar_8859_3,
        &vtbl_8859_4_wchar,
        &vtbl_wchar_8859_4,
        &vtbl_8859_5_wchar,
        &vtbl_wchar_8859_5,
        &vtbl_8859_6_wchar,
        &vtbl_wchar_8859_6,
        &vtbl_8859_7_wchar,
        &vtbl_wchar_8859_7,
        &vtbl_8859_8_wchar,
        &vtbl_wchar_8859_8,
        &vtbl_8859_9_wchar,
        &vtbl_wchar_8859_9,
        &vtbl_8859_10_wchar,
        &vtbl_wchar_8859_10,
        &vtbl_8859_13_wchar,
        &vtbl_wchar_8859_13,
        &vtbl_8859_14_wchar,
        &vtbl_wchar_8859_14,
        &vtbl_8859_15_wchar,
        &vtbl_wchar_8859_15,
        &vtbl_8bit_b64,
        &vtbl_b64_8bit,
        &vtbl_8bit_qprint,
        &vtbl_qprint_8bit,
        &vtbl_8bit_7bit,
        &vtbl_7bit_8bit,
        &vtbl_utf7_wchar,
        &vtbl_wchar_utf7,
        &vtbl_utf7imap_wchar,
        &vtbl_wchar_utf7imap,
        &vtbl_utf16_wchar,
        &vtbl_wchar_utf16,
        &vtbl_utf16be_wchar,
        &vtbl_wchar_utf16be,
        &vtbl_utf16le_wchar,
        &vtbl_wchar_utf16le,
        &vtbl_utf32_wchar,
        &vtbl_wchar_utf32,
        &vtbl_utf32be_wchar,
        &vtbl_wchar_utf32be,
        &vtbl_utf32le_wchar,
        &vtbl_wchar_utf32le,
        &vtbl_ucs4_wchar,
        &vtbl_wchar_ucs4,
        &vtbl_ucs4be_wchar,
        &vtbl_wchar_ucs4be,
        &vtbl_ucs4le_wchar,
        &vtbl_wchar_ucs4le,
        &vtbl_ucs2_wchar,
        &vtbl_wchar_ucs2,
        &vtbl_ucs2be_wchar,
        &vtbl_wchar_ucs2be,
        &vtbl_ucs2le_wchar,
        &vtbl_wchar_ucs2le,
        &vtbl_byte4be_wchar,
        &vtbl_wchar_byte4be,
        &vtbl_byte4le_wchar,
        &vtbl_wchar_byte4le,
        &vtbl_byte2be_wchar,
        &vtbl_wchar_byte2be,
        &vtbl_byte2le_wchar,
        &vtbl_wchar_byte2le,
        &vtbl_pass,
        ((void *)0)
};



static struct mbfl_identify_vtbl vtbl_identify_ascii = {
        mbfl_no_encoding_ascii,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_ascii };

static struct mbfl_identify_vtbl vtbl_identify_utf8 = {
        mbfl_no_encoding_utf8,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_utf8 };

static struct mbfl_identify_vtbl vtbl_identify_utf7 = {
        mbfl_no_encoding_utf7,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_utf7 };

static struct mbfl_identify_vtbl vtbl_identify_eucjp = {
        mbfl_no_encoding_euc_jp,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_eucjp };

static struct mbfl_identify_vtbl vtbl_identify_eucjpwin = {
        mbfl_no_encoding_eucjp_win,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_eucjp };

static struct mbfl_identify_vtbl vtbl_identify_sjis = {
        mbfl_no_encoding_sjis,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_sjis };

static struct mbfl_identify_vtbl vtbl_identify_sjiswin = {
        mbfl_no_encoding_sjis_win,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_sjiswin };

static struct mbfl_identify_vtbl vtbl_identify_jis = {
        mbfl_no_encoding_jis,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_jis };

static struct mbfl_identify_vtbl vtbl_identify_2022jp = {
        mbfl_no_encoding_2022jp,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_2022jp };

static struct mbfl_identify_vtbl vtbl_identify_8859_1 = {
        mbfl_no_encoding_8859_1,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_2 = {
        mbfl_no_encoding_8859_2,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_3 = {
        mbfl_no_encoding_8859_3,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_4 = {
        mbfl_no_encoding_8859_4,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_5 = {
        mbfl_no_encoding_8859_5,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_6 = {
        mbfl_no_encoding_8859_6,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_7 = {
        mbfl_no_encoding_8859_7,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_8 = {
        mbfl_no_encoding_8859_8,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_9 = {
        mbfl_no_encoding_8859_9,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_10 = {
        mbfl_no_encoding_8859_10,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_13 = {
        mbfl_no_encoding_8859_13,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_14 = {
        mbfl_no_encoding_8859_14,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_8859_15 = {
        mbfl_no_encoding_8859_15,
        mbfl_filt_ident_common_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_true };

static struct mbfl_identify_vtbl vtbl_identify_false = {
        mbfl_no_encoding_pass,
        mbfl_filt_ident_false_ctor,
        mbfl_filt_ident_common_dtor,
        mbfl_filt_ident_false };

static struct mbfl_identify_vtbl *mbfl_identify_filter_list[] = {
        &vtbl_identify_utf8,
        &vtbl_identify_utf7,
        &vtbl_identify_ascii,
        &vtbl_identify_eucjp,
        &vtbl_identify_sjis,
        &vtbl_identify_eucjpwin,
        &vtbl_identify_sjiswin,
        &vtbl_identify_jis,
        &vtbl_identify_2022jp,
        &vtbl_identify_8859_1,
        &vtbl_identify_8859_2,
        &vtbl_identify_8859_3,
        &vtbl_identify_8859_4,
        &vtbl_identify_8859_5,
        &vtbl_identify_8859_6,
        &vtbl_identify_8859_7,
        &vtbl_identify_8859_8,
        &vtbl_identify_8859_9,
        &vtbl_identify_8859_10,
        &vtbl_identify_8859_13,
        &vtbl_identify_8859_14,
        &vtbl_identify_8859_15,
        &vtbl_identify_false,
        ((void *)0)
};



mbfl_language *
mbfl_name2language(const char *name)
{
        mbfl_language *language;
        int i, j;

        if (name == ((void *)0)) {
                return ((void *)0);
        }

        i = 0;
        while ((language = mbfl_language_ptr_table[i++]) != ((void *)0)){
                if (strcasecmp(language->name, name) == 0) {
                        return language;
                }
        }

        i = 0;
        while ((language = mbfl_language_ptr_table[i++]) != ((void *)0)){
                if (strcasecmp(language->short_name, name) == 0) {
                        return language;
                }
        }


        i = 0;
        while ((language = mbfl_language_ptr_table[i++]) != ((void *)0)) {
                if (language->aliases != ((void *)0)) {
                        j = 0;
                        while ((*language->aliases)[j] != ((void *)0)) {
                                if (strcasecmp((*language->aliases)[j], name) == 0) {
                                        return language;
                                }
                                j++;
                        }
                }
        }

        return ((void *)0);
}

mbfl_language *
mbfl_no2language(enum mbfl_no_language no_language)
{
        mbfl_language *language;
        int i;

        i = 0;
        while ((language = mbfl_language_ptr_table[i++]) != ((void *)0)){
                if (language->no_language == no_language) {
                        return language;
                }
        }

        return ((void *)0);
}

enum mbfl_no_language
mbfl_name2no_language(const char *name)
{
        mbfl_language *language;

        language = mbfl_name2language(name);
        if (language == ((void *)0)) {
                return mbfl_no_language_invalid;
        } else {
                return language->no_language;
        }
}

const char *
mbfl_no_language2name(enum mbfl_no_language no_language)
{
        mbfl_language *language;

        language = mbfl_no2language(no_language);
        if (language == ((void *)0)) {
                return "";
        } else {
                return language->name;
        }
}




mbfl_encoding *
mbfl_name2encoding(const char *name)
{
        mbfl_encoding *encoding;
        int i, j;

        if (name == ((void *)0)) {
                return ((void *)0);
        }

        i = 0;
        while ((encoding = mbfl_encoding_ptr_list[i++]) != ((void *)0)){
                if (strcasecmp(encoding->name, name) == 0) {
                        return encoding;
                }
        }


        i = 0;
        while ((encoding = mbfl_encoding_ptr_list[i++]) != ((void *)0)) {
                if (encoding->mime_name != ((void *)0)) {
                        if (strcasecmp(encoding->mime_name, name) == 0) {
                                return encoding;
                        }
                }
        }


        i = 0;
        while ((encoding = mbfl_encoding_ptr_list[i++]) != ((void *)0)) {
                if (encoding->aliases != ((void *)0)) {
                        j = 0;
                        while ((*encoding->aliases)[j] != ((void *)0)) {
                                if (strcasecmp((*encoding->aliases)[j], name) == 0) {
                                        return encoding;
                                }
                                j++;
                        }
                }
        }

        return ((void *)0);
}

mbfl_encoding *
mbfl_no2encoding(enum mbfl_no_encoding no_encoding)
{
        mbfl_encoding *encoding;
        int i;

        i = 0;
        while ((encoding = mbfl_encoding_ptr_list[i++]) != ((void *)0)){
                if (encoding->no_encoding == no_encoding) {
                        return encoding;
                }
        }

        return ((void *)0);
}

enum mbfl_no_encoding
mbfl_name2no_encoding(const char *name)
{
        mbfl_encoding *encoding;

        encoding = mbfl_name2encoding(name);
        if (encoding == ((void *)0)) {
                return mbfl_no_encoding_invalid;
        } else {
                return encoding->no_encoding;
        }
}

const char *
mbfl_no_encoding2name(enum mbfl_no_encoding no_encoding)
{
        mbfl_encoding *encoding;

        encoding = mbfl_no2encoding(no_encoding);
        if (encoding == ((void *)0)) {
                return "";
        } else {
                return encoding->name;
        }
}

const char *
mbfl_no2preferred_mime_name(enum mbfl_no_encoding no_encoding)
{
        mbfl_encoding *encoding;

        encoding = mbfl_no2encoding(no_encoding);
        if (encoding != ((void *)0) && encoding->mime_name != ((void *)0) && encoding->mime_name[0] != '\0') {
                return encoding->mime_name;
        } else {
                return ((void *)0);
        }
}

int
mbfl_is_support_encoding(const char *name)
{
        mbfl_encoding *encoding;

        encoding = mbfl_name2encoding(name);
        if (encoding == ((void *)0)) {
                return 0;
        } else {
                return 1;
        }
}






void
mbfl_memory_device_init(mbfl_memory_device *device, int initsz, int allocsz)
{
        if (device) {
                device->length = 0;
                device->buffer = (unsigned char *)0;
                if (initsz > 0) {
                        device->buffer = (unsigned char *)_emalloc((initsz*sizeof(unsigned char)) );
                        if (device->buffer != ((void *)0)) {
                                device->length = initsz;
                        }
                }
                device->pos= 0;
                if (allocsz > 64) {
                        device->allocsz = allocsz;
                } else {
                        device->allocsz = 64;
                }
        }
}

void
mbfl_memory_device_realloc(mbfl_memory_device *device, int initsz, int allocsz)
{
        unsigned char *tmp;

        if (device) {
                if (initsz > device->length) {
                        tmp = (unsigned char *)_erealloc(((void *)device->buffer), (initsz*sizeof(unsigned char)),0 );
                        if (tmp != ((void *)0)) {
                                device->buffer = tmp;
                                device->length = initsz;
                        }
                }
                if (allocsz > 64) {
                        device->allocsz = allocsz;
                } else {
                        device->allocsz = 64;
                }
        }
}

void
mbfl_memory_device_clear(mbfl_memory_device *device)
{
        if (device) {
                if (device->buffer) {
                        _efree((device->buffer) );
                }
                device->buffer = (unsigned char *)0;
                device->length = 0;
                device->pos = 0;
        }
}

void
mbfl_memory_device_reset(mbfl_memory_device *device)
{
        if (device) {
                device->pos = 0;
        }
}

void
mbfl_memory_device_unput(mbfl_memory_device *device)
{
        if (device->pos > 0) {
                device->pos--;
        }
}

mbfl_string *
mbfl_memory_device_result(mbfl_memory_device *device, mbfl_string *result)
{
        if (device && result) {
                result->len = device->pos;
                mbfl_memory_device_output4('\0', device);
                result->val = device->buffer;
                device->buffer = (unsigned char *)0;
                device->length = 0;
                device->pos= 0;
                if (result->val == ((void *)0)) {
                        result->len = 0;
                        result = ((void *)0);
                }
        } else {
                result = ((void *)0);
        }

        return result;
}

int
mbfl_memory_device_output(int c, void *data)
{
        mbfl_memory_device *device = (mbfl_memory_device *)data;

        if (device->pos >= device->length) {

                int newlen;
                unsigned char *tmp;

                newlen = device->length + device->allocsz;
                tmp = (unsigned char *)_erealloc(((void *)device->buffer), (newlen*sizeof(unsigned char)),0 );
                if (tmp == ((void *)0)) {
                        return -1;
                }
                device->length = newlen;
                device->buffer = tmp;
        }

        device->buffer[device->pos++] = (unsigned char)c;
        return c;
}

int
mbfl_memory_device_output2(int c, void *data)
{
        mbfl_memory_device *device = (mbfl_memory_device *)data;

        if ((device->pos + 2) >= device->length) {

                int newlen;
                unsigned char *tmp;

                newlen = device->length + device->allocsz;
                tmp = (unsigned char *)_erealloc(((void *)device->buffer), (newlen*sizeof(unsigned char)),0 );
                if (tmp == ((void *)0)) {
                        return -1;
                }
                device->length = newlen;
                device->buffer = tmp;
        }

        device->buffer[device->pos++] = (unsigned char)((c >> 8) & 0xff);
        device->buffer[device->pos++] = (unsigned char)(c & 0xff);

        return c;
}

int
mbfl_memory_device_output4(int c, void* data)
{
        mbfl_memory_device *device = (mbfl_memory_device *)data;

        if ((device->pos + 4) >= device->length) {

                int newlen;
                unsigned char *tmp;

                newlen = device->length + device->allocsz;
                tmp = (unsigned char *)_erealloc(((void *)device->buffer), (newlen*sizeof(unsigned char)),0 );
                if (tmp == ((void *)0)) {
                        return -1;
                }
                device->length = newlen;
                device->buffer = tmp;
        }

        device->buffer[device->pos++] = (unsigned char)((c >> 24) & 0xff);
        device->buffer[device->pos++] = (unsigned char)((c >> 16) & 0xff);
        device->buffer[device->pos++] = (unsigned char)((c >> 8) & 0xff);
        device->buffer[device->pos++] = (unsigned char)(c & 0xff);

        return c;
}

int
mbfl_memory_device_strcat(mbfl_memory_device *device, const char *psrc)
{
        int len;
        unsigned char *w;
        const unsigned char *p;

        len = 0;
        p = psrc;
        while (*p) {
                p++;
                len++;
        }

        if ((device->pos + len) >= device->length) {

                int newlen = device->length + (len + 64)*sizeof(unsigned char);
                unsigned char *tmp = (unsigned char *)_erealloc(((void *)device->buffer), (newlen*sizeof(unsigned char)),0 );
                if (tmp == ((void *)0)) {
                        return -1;
                }
                device->length = newlen;
                device->buffer = tmp;
        }

        p = psrc;
        w = &device->buffer[device->pos];
        device->pos += len;
        while (len > 0) {
                *w++ = *p++;
                len--;
        }

        return len;
}

int
mbfl_memory_device_strncat(mbfl_memory_device *device, const char *psrc, int len)
{
        unsigned char *w;

        if ((device->pos + len) >= device->length) {

                int newlen = device->length + len + 64;
                unsigned char *tmp = (unsigned char *)_erealloc(((void *)device->buffer), (newlen*sizeof(unsigned char)),0 );
                if (tmp == ((void *)0)) {
                        return -1;
                }
                device->length = newlen;
                device->buffer = tmp;
        }

        w = &device->buffer[device->pos];
        device->pos += len;
        while (len > 0) {
                *w++ = *psrc++;
                len--;
        }

        return len;
}

int
mbfl_memory_device_devcat(mbfl_memory_device *dest, mbfl_memory_device *src)
{
        int n;
        unsigned char *p, *w;

        if ((dest->pos + src->pos) >= dest->length) {

                int newlen = dest->length + src->pos + 64;
                unsigned char *tmp = (unsigned char *)_erealloc(((void *)dest->buffer), (newlen*sizeof(unsigned char)),0 );
                if (tmp == ((void *)0)) {
                        return -1;
                }
                dest->length = newlen;
                dest->buffer = tmp;
        }

        p = src->buffer;
        w = &dest->buffer[dest->pos];
        n = src->pos;
        dest->pos += n;
        while (n > 0) {
                *w++ = *p++;
                n--;
        }

        return n;
}

void
mbfl_wchar_device_init(mbfl_wchar_device *device)
{
        if (device) {
                device->buffer = (unsigned int *)0;
                device->length = 0;
                device->pos= 0;
                device->allocsz = 64;
        }
}

void
mbfl_wchar_device_clear(mbfl_wchar_device *device)
{
        if (device) {
                if (device->buffer) {
                        _efree((device->buffer) );
                }
                device->buffer = (unsigned int*)0;
                device->length = 0;
                device->pos = 0;
        }
}

int
mbfl_wchar_device_output(int c, void *data)
{
        mbfl_wchar_device *device = (mbfl_wchar_device *)data;

        if (device->pos >= device->length) {

                int newlen;
                unsigned int *tmp;

                newlen = device->length + device->allocsz;
                tmp = (unsigned int *)_erealloc(((void *)device->buffer), (newlen*sizeof(int)),0 );
                if (tmp == ((void *)0)) {
                        return -1;
                }
                device->length = newlen;
                device->buffer = tmp;
        }

        device->buffer[device->pos++] = c;

        return c;
}





void
mbfl_string_init(mbfl_string *string)
{
        if (string) {
                string->no_language = mbfl_no_language_uni;
                string->no_encoding = mbfl_no_encoding_pass;
                string->val = (unsigned char*)0;
                string->len = 0;
        }
}

void
mbfl_string_init_set(mbfl_string *string, enum mbfl_no_language no_language, enum mbfl_no_encoding no_encoding)
{
        if (string) {
                string->no_language = no_language;
                string->no_encoding = no_encoding;
                string->val = (unsigned char*)0;
                string->len = 0;
        }
}

void
mbfl_string_clear(mbfl_string *string)
{
        if (string) {
                if (string->val != (unsigned char*)0) {
                        _efree((string->val) );
                }
                string->val = (unsigned char*)0;
                string->len = 0;
        }
}
# 2322 "mbfilter.c"
static void
mbfl_filt_conv_common_ctor(mbfl_convert_filter *filter)
{
        filter->status = 0;
        filter->cache = 0;
}

static int
mbfl_filt_conv_common_flush(mbfl_convert_filter *filter)
{
        filter->status = 0;
        filter->cache = 0;
        return 0;
}

static void
mbfl_filt_conv_common_dtor(mbfl_convert_filter *filter)
{
        filter->status = 0;
        filter->cache = 0;
}

static int
mbfl_filt_conv_pass(int c, mbfl_convert_filter *filter)
{
        return (*filter->output_function)(c, filter->data);
}

static int
mbfl_filt_conv_any_7bit(int c, mbfl_convert_filter *filter)
{
        if (c >= 0 && c < 0x80) {
                do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
        }
        return c;
}

static int
mbfl_filt_conv_byte2be_wchar(int c, mbfl_convert_filter *filter)
{
        int n;

        if (filter->status == 0) {
                filter->status = 1;
                n = (c & 0xff) << 8;
                filter->cache = n;
        } else {
                filter->status = 0;
                n = (c & 0xff) | filter->cache;
                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
        }
        return c;
}

static int
mbfl_filt_conv_wchar_byte2be(int c, mbfl_convert_filter *filter)
{
        do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
        do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
        return c;
}

static int
mbfl_filt_conv_byte2le_wchar(int c, mbfl_convert_filter *filter)
{
        int n;

        if (filter->status == 0) {
                filter->status = 1;
                n = c & 0xff;
                filter->cache = n;
        } else {
                filter->status = 0;
                n = ((c & 0xff) << 8) | filter->cache;
                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
        }
        return c;
}

static int
mbfl_filt_conv_wchar_byte2le(int c, mbfl_convert_filter *filter)
{
        do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
        do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
        return c;
}

static int
mbfl_filt_conv_byte4be_wchar(int c, mbfl_convert_filter *filter)
{
        int n;

        if (filter->status == 0) {
                filter->status = 1;
                n = (c & 0xff) << 24;
                filter->cache = n;
        } else if (filter->status == 1) {
                filter->status = 2;
                n = (c & 0xff) << 16;
                filter->cache |= n;
        } else if (filter->status == 2) {
                filter->status = 3;
                n = (c & 0xff) << 8;
                filter->cache |= n;
        } else {
                filter->status = 0;
                n = (c & 0xff) | filter->cache;
                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
        }
        return c;
}

static int
mbfl_filt_conv_wchar_byte4be(int c, mbfl_convert_filter *filter)
{
        do { if (((*filter->output_function)((c >> 24) & 0xff, filter->data)) < 0) return (-1); } while (0);
        do { if (((*filter->output_function)((c >> 16) & 0xff, filter->data)) < 0) return (-1); } while (0);
        do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
        do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
        return c;
}

static int
mbfl_filt_conv_byte4le_wchar(int c, mbfl_convert_filter *filter)
{
        int n;

        if (filter->status == 0) {
                filter->status = 1;
                n = (c & 0xff);
                filter->cache = n;
        } else if (filter->status == 1) {
                filter->status = 2;
                n = (c & 0xff) << 8;
                filter->cache |= n;
        } else if (filter->status == 2) {
                filter->status = 3;
                n = (c & 0xff) << 16;
                filter->cache |= n;
        } else {
                filter->status = 0;
                n = ((c & 0xff) << 24) | filter->cache;
                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
        }
        return c;
}

static int
mbfl_filt_conv_wchar_byte4le(int c, mbfl_convert_filter *filter)
{
        do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
        do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
        do { if (((*filter->output_function)((c >> 16) & 0xff, filter->data)) < 0) return (-1); } while (0);
        do { if (((*filter->output_function)((c >> 24) & 0xff, filter->data)) < 0) return (-1); } while (0);
        return c;
}






static const unsigned char mbfl_base64_table[] =
{

   0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,

   0x4e,0x4f,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,

   0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,

   0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,

   0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x2b,0x2f,0x00
};



static int
mbfl_filt_conv_base64enc(int c, mbfl_convert_filter *filter)
{
        int n;

        n = (filter->status & 0xff);
        if (n == 0) {
                filter->status++;
                filter->cache = (c & 0xff) << 16;
        } else if (n == 1) {
                filter->status++;
                filter->cache |= (c & 0xff) << 8;
        } else {
                filter->status &= ~0xff;
                if ((filter->status & 0x1000000) == 0) {
                        n = (filter->status & 0xff00) >> 8;
                        if (n > 72) {
                                do { if (((*filter->output_function)(0x0d, filter->data)) < 0) return (-1); } while (0);
                                do { if (((*filter->output_function)(0x0a, filter->data)) < 0) return (-1); } while (0);
                                filter->status &= ~0xff00;
                        }
                        filter->status += 0x400;
                }
                n = filter->cache | (c & 0xff);
                do { if (((*filter->output_function)(mbfl_base64_table[(n >> 18) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(n >> 12) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(n >> 6) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[n & 0x3f], filter->data)) < 0) return (-1); } while (0);
        }

        return c;
}

static int
mbfl_filt_conv_base64enc_flush(mbfl_convert_filter *filter)
{
        int status, cache, len;

        status = filter->status & 0xff;
        cache = filter->cache;
        len = (filter->status & 0xff00) >> 8;
        filter->status &= ~0xffff;
        filter->cache = 0;

        if (status >= 1) {
                if ((filter->status & 0x1000000) == 0) {
                        if (len > 72){
                                do { if (((*filter->output_function)(0x0d, filter->data)) < 0) return (-1); } while (0);
                                do { if (((*filter->output_function)(0x0a, filter->data)) < 0) return (-1); } while (0);
                        }
                }
                do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 18) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 12) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                if (status == 1) {
                        do { if (((*filter->output_function)(0x3d, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(0x3d, filter->data)) < 0) return (-1); } while (0);
                } else {
                        do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 6) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(0x3d, filter->data)) < 0) return (-1); } while (0);
                }
        }
        return 0;
}




static int
mbfl_filt_conv_base64dec(int c, mbfl_convert_filter *filter)
{
        int n;

        if (c == 0x0d || c == 0x0a || c == 0x20 || c == 0x09 || c == 0x3d) {
                return c;
        }

        n = 0;
        if (c >= 0x41 && c <= 0x5a) {
                n = c - 65;
        } else if (c >= 0x61 && c <= 0x7a) {
                n = c - 71;
        } else if (c >= 0x30 && c <= 0x39) {
                n = c + 4;
        } else if (c == 0x2b) {
                n = 62;
        } else if (c == 0x2f) {
                n = 63;
        }
        n &= 0x3f;

        switch (filter->status) {
        case 0:
                filter->status = 1;
                filter->cache = n << 18;
                break;
        case 1:
                filter->status = 2;
                filter->cache |= n << 12;
                break;
        case 2:
                filter->status = 3;
                filter->cache |= n << 6;
                break;
        default:
                filter->status = 0;
                n |= filter->cache;
                do { if (((*filter->output_function)((n >> 16) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((n >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(n & 0xff, filter->data)) < 0) return (-1); } while (0);
                break;
        }

        return c;
}

static int
mbfl_filt_conv_base64dec_flush(mbfl_convert_filter *filter)
{
        int status, cache;

        status = filter->status;
        cache = filter->cache;
        filter->status = 0;
        filter->cache = 0;

        if (status >= 2) {
                do { if (((*filter->output_function)((cache >> 16) & 0xff, filter->data)) < 0) return (-1); } while (0);
                if (status >= 3) {
                        do { if (((*filter->output_function)((cache >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
                }
        }
        return 0;
}






static int
mbfl_filt_conv_qprintenc(int c, mbfl_convert_filter *filter)
{
        int s, n;

        switch (filter->status & 0xff) {
        case 0:
                filter->cache = c;
                filter->status++;
                break;
        default:
                s = filter->cache;
                filter->cache = c;
                n = (filter->status & 0xff00) >> 8;

                if (s == 0) {
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        filter->status &= ~0xff00;
                        break;
                }

                if ((filter->status & 0x1000000) == 0) {
                        if (s == 0x0a || (s == 0x0d && c != 0x0a)) {
                                do { if (((*filter->output_function)(0x0d, filter->data)) < 0) return (-1); } while (0);
                                do { if (((*filter->output_function)(0x0a, filter->data)) < 0) return (-1); } while (0);
                                filter->status &= ~0xff00;
                                break;
                        } else if (s == 0x0d) {
                                break;
                        }
                }

                if ((filter->status & 0x1000000) == 0 && n >= 72) {
                        do { if (((*filter->output_function)(0x3d, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(0x0d, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(0x0a, filter->data)) < 0) return (-1); } while (0);
                        filter->status &= ~0xff00;
                }

                if (s <= 0 || s >= 0x80 || s == 0x3d
                   || ((filter->status & 0x1000000) != 0 &&
                       (mbfl_charprop_table[s] & 0x10) != 0)) {

                        do { if (((*filter->output_function)(0x3d, filter->data)) < 0) return (-1); } while (0);
                        n = (s >> 4) & 0xf;
                        if (n < 10) {
                                n += 48;
                        } else {
                                n += 55;
                        }
                        do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                        n = s & 0xf;
                        if (n < 10) {
                                n += 48;
                        } else {
                                n += 55;
                        }
                        do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                        if ((filter->status & 0x1000000) == 0) {
                                filter->status += 0x300;
                        }
                } else {
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        if ((filter->status & 0x1000000) == 0) {
                                filter->status += 0x100;
                        }
                }
                break;
        }

        return c;
}

static int
mbfl_filt_conv_qprintenc_flush(mbfl_convert_filter *filter)
{

        (*filter->filter_function)('\0', filter);
        filter->status &= ~0xffff;
        filter->cache = 0;
        return 0;
}




static int
mbfl_filt_conv_qprintdec(int c, mbfl_convert_filter *filter)
{
        int n;

        switch (filter->status) {
        case 1:
                if ((c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x46)) {
                        filter->cache = c;
                        filter->status = 2;
                } else if (c == 0x0d) {
                        filter->status = 3;
                } else if (c == 0x0a) {
                        filter->status = 0;
                } else {
                        do { if (((*filter->output_function)(0x3d, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        filter->status = 0;
                }
                break;
        case 2:
                n = filter->cache;
                if (n >= 0x30 && n <= 0x39) {
                        n -= 48;
                } else {
                        n -= 55;
                }
                n <<= 4;
                if (c >= 0x30 && c <= 0x39) {
                        n += (c - 48);
                } else if (c >= 0x41 && c <= 0x46) {
                        n += (c - 55);
                } else {
                        do { if (((*filter->output_function)(0x3d, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(filter->cache, filter->data)) < 0) return (-1); } while (0);
                        n = c;
                }
                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                filter->status = 0;
                break;
        case 3:
                if (c != 0x0a) {
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                }
                filter->status = 0;
                break;
        default:
                if (c == 0x3d) {
                        filter->status = 1;
                } else {
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                }
                break;
        }

        return c;
}

static int
mbfl_filt_conv_qprintdec_flush(mbfl_convert_filter *filter)
{
        int status, cache;

        status = filter->status;
        cache = filter->cache;
        filter->status = 0;
        filter->cache = 0;

        if (status == 1) {
                do { if (((*filter->output_function)(0x3d, filter->data)) < 0) return (-1); } while (0);
        } else if (status == 2) {
                do { if (((*filter->output_function)(0x3d, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(cache, filter->data)) < 0) return (-1); } while (0);
        }

        return 0;
}





static int
mbfl_filt_conv_ucs4_wchar(int c, mbfl_convert_filter *filter)
{
        int n, endian;

        endian = filter->status & 0xff00;
        switch (filter->status & 0xff) {
        case 0:
                if (endian) {
                        n = c & 0xff;
                } else {
                        n = (c & 0xff) << 24;
                }
                filter->cache = n;
                filter->status++;
                break;
        case 1:
                if (endian) {
                        n = (c & 0xff) << 8;
                } else {
                        n = (c & 0xff) << 16;
                }
                filter->cache |= n;
                filter->status++;
                break;
        case 2:
                if (endian) {
                        n = (c & 0xff) << 16;
                } else {
                        n = (c & 0xff) << 8;
                }
                filter->cache |= n;
                filter->status++;
                break;
        default:
                if (endian) {
                        n = (c & 0xff) << 24;
                } else {
                        n = c & 0xff;
                }
                n |= filter->cache;
                if ((n & 0xffff) == 0 && ((n >> 16) & 0xffff) == 0xfffe) {
                        if (endian) {
                                filter->status = 0;
                        } else {
                                filter->status = 0x100;
                        }
                        do { if (((*filter->output_function)(0xfeff, filter->data)) < 0) return (-1); } while (0);
                } else {
                        filter->status &= ~0xff;
                        do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                }
                break;
        }

        return c;
}




static int
mbfl_filt_conv_wchar_ucs4be(int c, mbfl_convert_filter *filter)
{
        if (c >= 0 && c < 0x70000000) {
                do { if (((*filter->output_function)((c >> 24) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((c >> 16) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_wchar_ucs4le(int c, mbfl_convert_filter *filter)
{
        if (c >= 0 && c < 0x70000000) {
                do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((c >> 16) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((c >> 24) & 0xff, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_ucs2_wchar(int c, mbfl_convert_filter *filter)
{
        int n, endian;

        endian = filter->status & 0xff00;
        switch (filter->status & 0xff) {
        case 0:
                if (endian) {
                        n = c & 0xff;
                } else {
                        n = (c & 0xff) << 8;
                }
                filter->cache = n;
                filter->status++;
                break;
        default:
                if (endian) {
                        n = (c & 0xff) << 8;
                } else {
                        n = c & 0xff;
                }
                n |= filter->cache;
                if (n == 0xfffe) {
                        if (endian) {
                                filter->status = 0;
                        } else {
                                filter->status = 0x100;
                        }
                        do { if (((*filter->output_function)(0xfeff, filter->data)) < 0) return (-1); } while (0);
                } else {
                        filter->status &= ~0xff;
                        do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                }
                break;
        }

        return c;
}




static int
mbfl_filt_conv_wchar_ucs2be(int c, mbfl_convert_filter *filter)
{
        if (c >= 0 && c < 0x00010000) {
                do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_wchar_ucs2le(int c, mbfl_convert_filter *filter)
{
        if (c >= 0 && c < 0x00010000) {
                do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}





static int
mbfl_filt_conv_utf16_wchar(int c, mbfl_convert_filter *filter)
{
        int n, endian;

        endian = filter->status & 0xff00;
        switch (filter->status & 0xff) {
        case 0:
                if (endian) {
                        n = c & 0xff;
                } else {
                        n = (c & 0xff) << 8;
                }
                filter->cache |= n;
                filter->status++;
                break;
        default:
                if (endian) {
                        n = (c & 0xff) << 8;
                } else {
                        n = c & 0xff;
                }
                n |= filter->cache & 0xffff;
                filter->status &= ~0xff;
                if (n == 0xfffe) {
                        if (endian) {
                                filter->status = 0;
                        } else {
                                filter->status = 0x100;
                        }
                        do { if (((*filter->output_function)(0xfeff, filter->data)) < 0) return (-1); } while (0);
                } else if (n >= 0xd800 && n < 0xdc00) {
                        filter->cache = ((n & 0x3ff) << 16) + 0x400000;
                } else if (n >= 0xdc00 && n < 0xe000) {
                        n &= 0x3ff;
                        n |= (filter->cache & 0xfff0000) >> 6;
                        filter->cache = 0;
                        if (n >= 0x00010000 && n < 0x00200000) {
                                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                n &= 0xffffff;
                                n |= 0x78000000;
                                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        filter->cache = 0;
                        do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                }
                break;
        }

        return c;
}




static int
mbfl_filt_conv_utf16be_wchar(int c, mbfl_convert_filter *filter)
{
        int n;

        switch (filter->status) {
        case 0:
                filter->status = 1;
                n = (c & 0xff) << 8;
                filter->cache |= n;
                break;
        default:
                filter->status = 0;
                n = (filter->cache & 0xff00) | (c & 0xff);
                if (n >= 0xd800 && n < 0xdc00) {
                        filter->cache = ((n & 0x3ff) << 16) + 0x400000;
                } else if (n >= 0xdc00 && n < 0xe000) {
                        n &= 0x3ff;
                        n |= (filter->cache & 0xfff0000) >> 6;
                        filter->cache = 0;
                        if (n >= 0x00010000 && n < 0x00200000) {
                                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                n &= 0xffffff;
                                n |= 0x78000000;
                                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        filter->cache = 0;
                        do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                }
                break;
        }

        return c;
}




static int
mbfl_filt_conv_wchar_utf16be(int c, mbfl_convert_filter *filter)
{
        int n;

        if (c >= 0 && c < 0x00010000) {
                do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
        } else if (c >= 0x00010000 && c < 0x00200000) {
                n = ((c >> 10) - 0x40) | 0xd800;
                do { if (((*filter->output_function)((n >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(n & 0xff, filter->data)) < 0) return (-1); } while (0);
                n = (c & 0x3ff) | 0xdc00;
                do { if (((*filter->output_function)((n >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(n & 0xff, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_utf16le_wchar(int c, mbfl_convert_filter *filter)
{
        int n;

        switch (filter->status) {
        case 0:
                filter->status = 1;
                n = c & 0xff;
                filter->cache |= n;
                break;
        default:
                filter->status = 0;
                n = (filter->cache & 0xff) | ((c & 0xff) << 8);
                if (n >= 0xd800 && n < 0xdc00) {
                        filter->cache = ((n & 0x3ff) << 16) + 0x400000;
                } else if (n >= 0xdc00 && n < 0xe000) {
                        n &= 0x3ff;
                        n |= (filter->cache & 0xfff0000) >> 6;
                        filter->cache = 0;
                        if (n >= 0x00010000 && n < 0x00200000) {
                                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                n &= 0xffffff;
                                n |= 0x78000000;
                                do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        filter->cache = 0;
                        do { if (((*filter->output_function)(n, filter->data)) < 0) return (-1); } while (0);
                }
                break;
        }

        return c;
}




static int
mbfl_filt_conv_wchar_utf16le(int c, mbfl_convert_filter *filter)
{
        int n;

        if (c >= 0 && c < 0x00010000) {
                do { if (((*filter->output_function)(c & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((c >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
        } else if (c >= 0x00010000 && c < 0x00200000) {
                n = ((c >> 10) - 0x40) | 0xd800;
                do { if (((*filter->output_function)(n & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((n >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
                n = (c & 0x3ff) | 0xdc00;
                do { if (((*filter->output_function)(n & 0xff, filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)((n >> 8) & 0xff, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}





static int
mbfl_filt_conv_utf8_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c < 0x80) {
                if (c >= 0) {
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                }
                filter->status = 0;
        } else if (c < 0xc0) {
                switch (filter->status & 0xff) {
                case 0x10:
                case 0x21:
                case 0x32:
                case 0x43:
                case 0x54:
                        filter->status = 0;
                        s = filter->cache | (c & 0x3f);
                        if (s >= 0x80) {
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        }
                        break;
                case 0x20:
                case 0x31:
                case 0x42:
                case 0x53:
                        filter->cache |= ((c & 0x3f) << 6);
                        filter->status++;
                        break;
                case 0x30:
                case 0x41:
                case 0x52:
                        filter->cache |= ((c & 0x3f) << 12);
                        filter->status++;
                        break;
                case 0x40:
                case 0x51:
                        filter->cache |= ((c & 0x3f) << 18);
                        filter->status++;
                        break;
                case 0x50:
                        filter->cache |= ((c & 0x3f) << 24);
                        filter->status++;
                        break;
                default:
                        filter->status = 0;
                        break;
                }
        } else if (c < 0xe0) {
                filter->status = 0x10;
                filter->cache = (c & 0x1f) << 6;
        } else if (c < 0xf0) {
                filter->status = 0x20;
                filter->cache = (c & 0xf) << 12;
        } else if (c < 0xf8) {
                filter->status = 0x30;
                filter->cache = (c & 0x7) << 18;
        } else if (c < 0xfc) {
                filter->status = 0x40;
                filter->cache = (c & 0x3) << 24;
        } else if (c < 0xfe) {
                filter->status = 0x50;
                filter->cache = (c & 0x1) << 30;
        } else {
                filter->status = 0;
                filter->cache = 0;
        }

        return c;
}




static int
mbfl_filt_conv_wchar_utf8(int c, mbfl_convert_filter *filter)
{
        if (c >= 0 && c < 0x70000000) {
                if (c < 0x80) {
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                } else if (c < 0x800) {
                        do { if (((*filter->output_function)(((c >> 6) & 0x1f) | 0xc0, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)((c & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                } else if (c < 0x10000) {
                        do { if (((*filter->output_function)(((c >> 12) & 0x0f) | 0xe0, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)((c & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                } else if (c < 0x200000) {
                        do { if (((*filter->output_function)(((c >> 18) & 0x07) | 0xf0, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 12) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)((c & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                } else if (c < 0x4000000) {
                        do { if (((*filter->output_function)(((c >> 24) & 0x03) | 0xf8, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 18) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 12) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)((c & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                } else {
                        do { if (((*filter->output_function)(((c >> 30) & 0x01) | 0xfc, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 24) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 18) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 12) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(((c >> 6) & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)((c & 0x3f) | 0x80, filter->data)) < 0) return (-1); } while (0);
                }
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}





static int
mbfl_filt_conv_utf7_wchar(int c, mbfl_convert_filter *filter)
{
        int s, n;

        n = -1;
        if (filter->status != 0) {
                if (c >= 0x41 && c <= 0x5a) {
                        n = c - 65;
                } else if (c >= 0x61 && c <= 0x7a) {
                        n = c - 71;
                } else if (c >= 0x30 && c <= 0x39) {
                        n = c + 4;
                } else if (c == 0x2b) {
                        n = 62;
                } else if (c == 0x2f) {
                        n = 63;
                }
                if (n < 0 || n > 63) {
                        if (c == 0x2d) {
                                if (filter->status == 1) {
                                        do { if (((*filter->output_function)(0x2b, filter->data)) < 0) return (-1); } while (0);
                                }
                        } else if (c >= 0 && c < 0x80) {
                                do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                s = c & 0xffffff;
                                s |= 0x78000000;
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        }
                        filter->cache = 0;
                        filter->status = 0;
                        return c;
                }
        }

        switch (filter->status) {

        case 0:
                if (c == 0x2b) {
                        filter->status = 1;
                } else if (c >= 0 && c < 0x80) {
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                } else {
                        s = c & 0xffffff;
                        s |= 0x78000000;
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                }
                break;


        case 1:
        case 2:
                filter->cache |= n << 10;
                filter->status = 3;
                break;
        case 3:
                filter->cache |= n << 4;
                filter->status = 4;
                break;
        case 4:
                s = ((n >> 2) & 0xf) | (filter->cache & 0xffff);
                n = (n & 0x3) << 14;
                filter->status = 5;
                if (s >= 0xd800 && s < 0xdc00) {
                        s = (((s & 0x3ff) << 16) + 0x400000) | n;
                        filter->cache = s;
                } else if (s >= 0xdc00 && s < 0xe000) {
                        s &= 0x3ff;
                        s |= (filter->cache & 0xfff0000) >> 6;
                        filter->cache = n;
                        if (s >= 0x00010000 && s < 0x00200000) {
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                s &= 0xffffff;
                                s |= 0x78000000;
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        filter->cache = n;
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                }
                break;

        case 5:
                filter->cache |= n << 8;
                filter->status = 6;
                break;
        case 6:
                filter->cache |= n << 2;
                filter->status = 7;
                break;
        case 7:
                s = ((n >> 4) & 0x3) | (filter->cache & 0xffff);
                n = (n & 0xf) << 12;
                filter->status = 8;
                if (s >= 0xd800 && s < 0xdc00) {
                        s = (((s & 0x3ff) << 16) + 0x400000) | n;
                        filter->cache = s;
                } else if (s >= 0xdc00 && s < 0xe000) {
                        s &= 0x3ff;
                        s |= (filter->cache & 0xfff0000) >> 6;
                        filter->cache = n;
                        if (s >= 0x00010000 && s < 0x00200000) {
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                s &= 0xffffff;
                                s |= 0x78000000;
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        filter->cache = n;
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                }
                break;

        case 8:
                filter->cache |= n << 6;
                filter->status = 9;
                break;
        case 9:
                s = n | (filter->cache & 0xffff);
                filter->status = 2;
                if (s >= 0xd800 && s < 0xdc00) {
                        s = (((s & 0x3ff) << 16) + 0x400000);
                        filter->cache = s;
                } else if (s >= 0xdc00 && s < 0xe000) {
                        s &= 0x3ff;
                        s |= (filter->cache & 0xfff0000) >> 6;
                        filter->cache = 0;
                        if (s >= 0x00010000 && s < 0x00200000) {
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                s &= 0xffffff;
                                s |= 0x78000000;
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        filter->cache = 0;
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                }
                break;

        default:
                filter->status = 0;
                break;
        }

        return c;
}




static int
mbfl_filt_conv_wchar_utf7(int c, mbfl_convert_filter *filter)
{
        int s, n;

        n = 0;
        if (c >= 0 && c < 0x80) {
                if (c >= 0x41 && c <= 0x5a) {
                        n = 1;
                } else if (c >= 0x61 && c <= 0x7a) {
                        n = 1;
                } else if (c >= 0x30 && c <= 0x39) {
                        n = 1;
                } else if (c == '\0') {
                        n = 1;
                } else if (c == 0x2f) {
                        n = 1;
                } else if (c == 0x2d) {
                        n = 1;
                } else if (c == 0x20) {
                        n = 2;
                } else if (c == 0x09) {
                        n = 2;
                } else if (c == 0x0d) {
                        n = 2;
                } else if (c == 0x0a) {
                        n = 2;
                } else if (c == 0x27) {
                        n = 2;
                } else if (c == 0x28) {
                        n = 2;
                } else if (c == 0x29) {
                        n = 2;
                } else if (c == 0x2c) {
                        n = 2;
                } else if (c == 0x2e) {
                        n = 2;
                } else if (c == 0x3a) {
                        n = 2;
                } else if (c == 0x3f) {
                        n = 2;
                }
        } else if (c >= 0 && c < 0x00010000) {
                ;
        } else if (c >= 0x00010000 && c < 0x00200000) {
                s = ((c >> 10) - 0x40) | 0xd800;
                do { if (((*filter->filter_function)(s, filter)) < 0) return (-1); } while (0);
                s = (c & 0x3ff) | 0xdc00;
                do { if (((*filter->filter_function)(s, filter)) < 0) return (-1); } while (0);
                return c;
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
                return c;
        }

        switch (filter->status) {
        case 0:
                if (n != 0) {
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                } else {
                        do { if (((*filter->output_function)(0x2b, filter->data)) < 0) return (-1); } while (0);
                        filter->status++;
                        filter->cache = c;
                }
                break;


        case 1:
                s = filter->cache;
                do { if (((*filter->output_function)(mbfl_base64_table[(s >> 10) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(s >> 4) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                if (n != 0) {
                        do { if (((*filter->output_function)(mbfl_base64_table[(s << 2) & 0x3c], filter->data)) < 0) return (-1); } while (0);
                        if (n == 1) {
                                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        }
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        filter->status = 0;
                } else {
                        filter->status++;
                        filter->cache = ((s & 0xf) << 16) | c;
                }
                break;

        case 2:
                s = filter->cache;
                do { if (((*filter->output_function)(mbfl_base64_table[(s >> 14) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(s >> 8) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(s >> 2) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                if (n != 0) {
                        do { if (((*filter->output_function)(mbfl_base64_table[(s << 4) & 0x30], filter->data)) < 0) return (-1); } while (0);
                        if (n == 1) {
                                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        }
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        filter->status = 0;
                } else {
                        filter->status++;
                        filter->cache = ((s & 0x3) << 16) | c;
                }
                break;

        case 3:
                s = filter->cache;
                do { if (((*filter->output_function)(mbfl_base64_table[(s >> 12) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(s >> 6) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[s & 0x3f], filter->data)) < 0) return (-1); } while (0);
                if (n != 0) {
                        if (n == 1) {
                                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        }
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        filter->status = 0;
                } else {
                        filter->status = 1;
                        filter->cache = c;
                }
                break;

        default:
                filter->status = 0;
                break;
        }

        return c;

}

static int
mbfl_filt_conv_wchar_utf7_flush(mbfl_convert_filter *filter)
{
        int status, cache;

        status = filter->status;
        cache = filter->cache;
        filter->status = 0;
        filter->cache = 0;

        switch (status) {
        case 1:
                do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 10) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 4) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(cache << 2) & 0x3c], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                break;

        case 2:
                do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 14) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 8) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 2) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(cache << 4) & 0x30], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                break;

        case 3:
                do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 12) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[(cache >> 6) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_base64_table[cache & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                break;
        }
        return 0;
}





static int
mbfl_filt_conv_utf7imap_wchar(int c, mbfl_convert_filter *filter)
{
        int s, n;

        n = -1;
        if (filter->status != 0) {
                if (c >= 0x41 && c <= 0x5a) {
                        n = c - 65;
                } else if (c >= 0x61 && c <= 0x7a) {
                        n = c - 71;
                } else if (c >= 0x30 && c <= 0x39) {
                        n = c + 4;
                } else if (c == 0x2b) {
                        n = 62;
                } else if (c == 0x2c) {
                        n = 63;
                }
                if (n < 0 || n > 63) {
                        if (c == 0x2d) {
                                if (filter->status == 1) {
                                        do { if (((*filter->output_function)(0x26, filter->data)) < 0) return (-1); } while (0);
                                }
                        } else if (c >= 0 && c < 0x80) {
                                do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                s = c & 0xffffff;
                                s |= 0x78000000;
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        }
                        filter->cache = 0;
                        filter->status = 0;
                        return c;
                }
        }

        switch (filter->status) {

        case 0:
                if (c == 0x26) {
                        filter->status++;
                } else if (c >= 0 && c < 0x80) {
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                } else {
                        s = c & 0xffffff;
                        s |= 0x78000000;
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                }
                break;


        case 1:
        case 2:
                filter->cache |= n << 10;
                filter->status = 3;
                break;
        case 3:
                filter->cache |= n << 4;
                filter->status = 4;
                break;
        case 4:
                s = ((n >> 2) & 0xf) | (filter->cache & 0xffff);
                n = (n & 0x3) << 14;
                filter->status = 5;
                if (s >= 0xd800 && s < 0xdc00) {
                        s = (((s & 0x3ff) << 16) + 0x400000) | n;
                        filter->cache = s;
                } else if (s >= 0xdc00 && s < 0xe000) {
                        s &= 0x3ff;
                        s |= (filter->cache & 0xfff0000) >> 6;
                        filter->cache = n;
                        if (s >= 0x00010000 && s < 0x00200000) {
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                s &= 0xffffff;
                                s |= 0x78000000;
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        filter->cache = n;
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                }
                break;

        case 5:
                filter->cache |= n << 8;
                filter->status = 6;
                break;
        case 6:
                filter->cache |= n << 2;
                filter->status = 7;
                break;
        case 7:
                s = ((n >> 4) & 0x3) | (filter->cache & 0xffff);
                n = (n & 0xf) << 12;
                filter->status = 8;
                if (s >= 0xd800 && s < 0xdc00) {
                        s = (((s & 0x3ff) << 16) + 0x400000) | n;
                        filter->cache = s;
                } else if (s >= 0xdc00 && s < 0xe000) {
                        s &= 0x3ff;
                        s |= (filter->cache & 0xfff0000) >> 6;
                        filter->cache = n;
                        if (s >= 0x00010000 && s < 0x00200000) {
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                s &= 0xffffff;
                                s |= 0x78000000;
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        filter->cache = n;
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                }
                break;

        case 8:
                filter->cache |= n << 6;
                filter->status = 9;
                break;
        case 9:
                s = n | (filter->cache & 0xffff);
                filter->status = 2;
                if (s >= 0xd800 && s < 0xdc00) {
                        s = (((s & 0x3ff) << 16) + 0x400000);
                        filter->cache = s;
                } else if (s >= 0xdc00 && s < 0xe000) {
                        s &= 0x3ff;
                        s |= (filter->cache & 0xfff0000) >> 6;
                        filter->cache = 0;
                        if (s >= 0x00010000 && s < 0x00200000) {
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        } else {
                                s &= 0xffffff;
                                s |= 0x78000000;
                                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        filter->cache = 0;
                        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
                }
                break;

        default:
                filter->status = 0;
                break;
        }

        return c;
}

static const unsigned char mbfl_utf7imap_base64_table[] =
{

   0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,

   0x4e,0x4f,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5a,

   0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x6b,0x6c,0x6d,

   0x6e,0x6f,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,

   0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x2b,0x2c,0x00
};




static int
mbfl_filt_conv_wchar_utf7imap(int c, mbfl_convert_filter *filter)
{
        int n, s;

        n = 0;
        if (c == 0x26) {
                n = 1;
        } else if ((c >= 0x20 && c <= 0x7e) || c == 0) {
                n = 2;
        } else if (c >= 0 && c < 0x00010000) {
                ;
        } else if (c >= 0x00010000 && c < 0x00200000) {
                s = ((c >> 10) - 0x40) | 0xd800;
                do { if (((*filter->filter_function)(s, filter)) < 0) return (-1); } while (0);
                s = (c & 0x3ff) | 0xdc00;
                do { if (((*filter->filter_function)(s, filter)) < 0) return (-1); } while (0);
                return c;
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
                return c;
        }

        switch (filter->status) {
        case 0:
                if (n != 0) {
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        if (n == 1) {
                                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        }
                } else {
                        do { if (((*filter->output_function)(0x26, filter->data)) < 0) return (-1); } while (0);
                        filter->status = 1;
                        filter->cache = c;
                }
                break;


        case 1:
                s = filter->cache;
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 10) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 4) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                if (n != 0) {
                        do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(s << 2) & 0x3c], filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        if (n == 1) {
                                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        }
                        filter->status = 0;
                } else {
                        filter->status = 2;
                        filter->cache = ((s & 0xf) << 16) | c;
                }
                break;

        case 2:
                s = filter->cache;
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 14) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 8) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 2) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                if (n != 0) {
                        do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(s << 4) & 0x30], filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        if (n == 1) {
                                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        }
                        filter->status = 0;
                } else {
                        filter->status = 3;
                        filter->cache = ((s & 0x3) << 16) | c;
                }
                break;

        case 3:
                s = filter->cache;
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 12) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(s >> 6) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[s & 0x3f], filter->data)) < 0) return (-1); } while (0);
                if (n != 0) {
                        do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
                        if (n == 1) {
                                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                        }
                        filter->status = 0;
                } else {
                        filter->status = 1;
                        filter->cache = c;
                }
                break;

        default:
                filter->status = 0;
                break;
        }

        return c;

}

static int
mbfl_filt_conv_wchar_utf7imap_flush(mbfl_convert_filter *filter)
{
        int status, cache;

        status = filter->status;
        cache = filter->cache;
        filter->status = 0;
        filter->cache = 0;

        switch (status) {
        case 1:
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 10) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 4) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(cache << 2) & 0x3c], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                break;

        case 2:
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 14) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 8) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 2) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(cache << 4) & 0x30], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                break;

        case 3:
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 12) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[(cache >> 6) & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(mbfl_utf7imap_base64_table[cache & 0x3f], filter->data)) < 0) return (-1); } while (0);
                do { if (((*filter->output_function)(0x2d, filter->data)) < 0) return (-1); } while (0);
                break;
        }
        return 0;
}





static int
mbfl_filt_conv_wchar_ascii(int c, mbfl_convert_filter *filter)
{
        if (c >= 0 && c < 0x80) {
                do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}





static int
mbfl_filt_conv_wchar_8859_1(int c, mbfl_convert_filter *filter)
{
        if (c >= 0 && c < 0x100) {
                do { if (((*filter->output_function)(c, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_2_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_2_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70e50000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_2(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_2_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70e50000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_3_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_3_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70e60000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_3(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_3_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70e60000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_4_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_4_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70e70000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_4(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_4_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70e70000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_5_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_5_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70e80000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_5(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_5_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70e80000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_6_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_6_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70e90000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_6(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_6_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70e90000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_7_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_7_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70ea0000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_7(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_7_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70ea0000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_8_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_8_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70eb0000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_8(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_8_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70eb0000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_9_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_9_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70ec0000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_9(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_9_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70ec0000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_10_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_10_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70ed0000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_10(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_10_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70ed0000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_13_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_13_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70ee0000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_13(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_13_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70ee0000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_14_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_14_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70ef0000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_14(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_14_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70ef0000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}




static int
mbfl_filt_conv_8859_15_wchar(int c, mbfl_convert_filter *filter)
{
        int s;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else if (c >= 0xa0 && c < 0x100) {
                s = iso8859_15_ucs_table[c - 0xa0];
                if (s <= 0) {
                        s = c;
                        s &= 0xffff;
                        s |= 0x70f00000;
                }
        } else {
                s = c;
                s &= 0xffffff;
                s |= 0x78000000;
        }

        do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);

        return c;
}




static int
mbfl_filt_conv_wchar_8859_15(int c, mbfl_convert_filter *filter)
{
        int s, n;

        if (c >= 0 && c < 0xa0) {
                s = c;
        } else {
                s = -1;
                n = 95;
                while (n >= 0) {
                        if (c == iso8859_15_ucs_table[n]) {
                                s = 0xa0 + n;
                                break;
                        }
                        n--;
                }
                if (s <= 0 && (c & ~0xffff) == 0x70f00000) {
                        s = c & 0xffff;
                }
        }

        if (s >= 0) {
                do { if (((*filter->output_function)(s, filter->data)) < 0) return (-1); } while (0);
        } else {
                if (filter->illegal_mode != 0) {
                        do { if ((mbfl_filt_conv_illegal_output(c, filter)) < 0) return (-1); } while (0);
                }
        }

        return c;
}
# 4744 "mbfilter.c"
static void
mbfl_filt_ident_common_ctor(mbfl_identify_filter *filter)
{
        filter->status = 0;
        filter->flag = 0;
}

static void
mbfl_filt_ident_common_dtor(mbfl_identify_filter *filter)
{
        filter->status = 0;
}

static int
mbfl_filt_ident_ascii(int c, mbfl_identify_filter *filter)
{
        if (c >= 0x20 && c < 0x80) {
                ;
        } else if (c == 0x0d || c == 0x0a || c == 0x09 || c == 0) {
                ;
        } else {
                filter->flag = 1;
        }

        return c;
}

static int
mbfl_filt_ident_utf8(int c, mbfl_identify_filter *filter)
{
        if (c < 0x80) {
                if (c < 0) {
                        filter->flag = 1;
                } else if (c != 0 && filter->status) {
                        filter->flag = 1;
                }
                filter->status = 0;
        } else if (c < 0xc0) {
                switch (filter->status) {
                case 0x20:
                case 0x30:
                case 0x31:
                case 0x40:
                case 0x41:
                case 0x42:
                case 0x50:
                case 0x51:
                case 0x52:
                case 0x53:
                        filter->status++;
                        break;
                case 0x10:
                case 0x21:
                case 0x32:
                case 0x43:
                case 0x54:
                        filter->status = 0;
                        break;
                default:
                        filter->flag = 1;
                        filter->status = 0;
                        break;
                }
        } else {
                if (filter->status) {
                        filter->flag = 1;
                }
                filter->status = 0;
                if (c < 0xe0) {
                        filter->status = 0x10;
                } else if (c < 0xf0) {
                        filter->status = 0x20;
                } else if (c < 0xf8) {
                        filter->status = 0x30;
                } else if (c < 0xfc) {
                        filter->status = 0x40;
                } else if (c < 0xfe) {
                        filter->status = 0x50;
                } else {
                        filter->flag = 1;
                }
        }

        return c;
}

static int
mbfl_filt_ident_utf7(int c, mbfl_identify_filter *filter)
{
        int n;

        switch (filter->status) {

        case 0:
                if (c == 0x2b) {
                        filter->status++;
                } else if (c == 0x5c || c == 0x7e || c < 0 || c > 0x7f) {
                        filter->flag = 1;
                }
                break;


        case 1:
        case 2:
                n = 0;
                if (c >= 0x41 && c <= 0x5a) {
                        n = 1;
                } else if (c >= 0x61 && c <= 0x7a) {
                        n = 1;
                } else if (c >= 0x30 && c <= 0x39) {
                        n = 1;
                } else if (c == 0x2b) {
                        n = 1;
                } else if (c == 0x2f) {
                        n = 1;
                }
                if (n <= 0) {
                        if (filter->status == 1 && c != 0x2d) {
                                filter->flag = 1;
                        } else if (c < 0 || c > 0x7f) {
                                filter->flag = 1;
                        }
                        filter->status = 0;
                } else {
                        filter->status = 2;
                }
                break;

        default:
                filter->status = 0;
                break;
        }

        return c;
}

static int
mbfl_filt_ident_eucjp(int c, mbfl_identify_filter *filter)
{
        switch (filter->status) {
        case 0:
                if (c >= 0 && c < 0x80) {
                        ;
                } else if (c > 0xa0 && c < 0xff) {
                        filter->status = 1;
                } else if (c == 0x8e) {
                        filter->status = 2;
                } else if (c == 0x8f) {
                        filter->status = 3;
                } else {
                        filter->flag = 1;
                }
                break;

        case 1:
                if (c < 0xa1 || c > 0xfe) {
                        filter->flag = 1;
                }
                filter->status = 0;
                break;

        case 2:
                if (c < 0xa1 || c > 0xdf) {
                        filter->flag = 1;
                }
                filter->status = 0;
                break;

        case 3:
                if (c < 0xa1 || c > 0xfe) {
                        filter->flag = 1;
                }
                filter->status++;
                break;
        case 4:
                if (c < 0xa1 || c > 0xfe) {
                        filter->flag = 1;
                }
                filter->status = 0;
                break;

        default:
                filter->status = 0;
                break;
        }

        return c;
}

static int
mbfl_filt_ident_sjis(int c, mbfl_identify_filter *filter)
{
        if (filter->status) {
                if (c < 0x40 || c > 0xfc || c == 0x7f) {
                    filter->flag = 1;
                }
                filter->status = 0;
        } else if (c >= 0 && c < 0x80) {
                ;
        } else if (c > 0xa0 && c < 0xe0) {
                ;
        } else if (c > 0x80 && c < 0xf0 && c != 0xa0) {
                filter->status = 1;
        } else {
                filter->flag = 1;
        }

        return c;
}

static int
mbfl_filt_ident_sjiswin(int c, mbfl_identify_filter *filter)
{
        if (filter->status) {
                if (c < 0x40 || c > 0xfc || c == 0x7f) {
                    filter->flag = 1;
                }
                filter->status = 0;
        } else if (c >= 0 && c < 0x80) {
                ;
        } else if (c > 0xa0 && c < 0xe0) {
                ;
        } else if (c > 0x80 && c < 0xfd && c != 0xa0) {
                filter->status = 1;
        } else {
                filter->flag = 1;
        }

        return c;
}

static int
mbfl_filt_ident_jis(int c, mbfl_identify_filter *filter)
{
retry:
        switch (filter->status & 0xf) {





        case 0:
                if (c == 0x1b) {
                        filter->status += 2;
                } else if (c == 0x0e) {
                        filter->status = 0x20;
                } else if (c == 0x0f) {
                        filter->status = 0;
                } else if ((filter->status == 0x80 || filter->status == 0x90) && c > 0x20 && c < 0x7f) {
                        filter->status += 1;
                } else if (c >= 0 && c < 0x80) {
                        ;
                } else {
                        filter->flag = 1;
                }
                break;



        case 1:
                filter->status &= ~0xf;
                if (c == 0x1b) {
                        goto retry;
                } else if (c < 0x21 || c > 0x7e) {
                        filter->flag = 1;
                }
                break;


        case 2:
                if (c == 0x24) {
                        filter->status++;
                } else if (c == 0x28) {
                        filter->status += 3;
                } else {
                        filter->flag = 1;
                        filter->status &= ~0xf;
                        goto retry;
                }
                break;


        case 3:
                if (c == 0x40 || c == 0x42) {
                        filter->status = 0x80;
                } else if (c == 0x28) {
                        filter->status++;
                } else {
                        filter->flag = 1;
                        filter->status &= ~0xf;
                        goto retry;
                }
                break;


        case 4:
                if (c == 0x40 || c == 0x42) {
                        filter->status = 0x80;
                } else if (c == 0x44) {
                        filter->status = 0x90;
                } else {
                        filter->flag = 1;
                        filter->status &= ~0xf;
                        goto retry;
                }
                break;


        case 5:
                if (c == 0x42 || c == 0x48) {
                        filter->status = 0;
                } else if (c == 0x4a) {
                        filter->status = 0x10;
                } else if (c == 0x49) {
                        filter->status = 0x20;
                } else {
                        filter->flag = 1;
                        filter->status &= ~0xf;
                        goto retry;
                }
                break;

        default:
                filter->status = 0;
                break;
        }

        return c;
}

static int
mbfl_filt_ident_2022jp(int c, mbfl_identify_filter *filter)
{
retry:
        switch (filter->status & 0xf) {



        case 0:
                if (c == 0x1b) {
                        filter->status += 2;
                } else if (filter->status == 0x80 && c > 0x20 && c < 0x7f) {
                        filter->status += 1;
                } else if (c >= 0 && c < 0x80) {
                        ;
                } else {
                        filter->flag = 1;
                }
                break;


        case 1:
                if (c == 0x1b) {
                        filter->status++;
                } else {
                        filter->status &= ~0xf;
                        if (c < 0x21 || c > 0x7e) {
                                filter->flag = 1;
                        }
                }
                break;


        case 2:
                if (c == 0x24) {
                        filter->status++;
                } else if (c == 0x28) {
                        filter->status += 3;
                } else {
                        filter->flag = 1;
                        filter->status &= ~0xf;
                        goto retry;
                }
                break;


        case 3:
                if (c == 0x40 || c == 0x42) {
                        filter->status = 0x80;
                } else {
                        filter->flag = 1;
                        filter->status &= ~0xf;
                        goto retry;
                }
                break;


        case 5:
                if (c == 0x42) {
                        filter->status = 0;
                } else if (c == 0x4a) {
                        filter->status = 0x10;
                } else {
                        filter->flag = 1;
                        filter->status &= ~0xf;
                        goto retry;
                }
                break;

        default:
                filter->status = 0;
                break;
        }

        return c;
}

static void
mbfl_filt_ident_false_ctor(mbfl_identify_filter *filter)
{
        filter->status = 0;
        filter->flag = 1;
}

static int
mbfl_filt_ident_false(int c, mbfl_identify_filter *filter)
{
        filter->flag = 1;
        return c;
}

static int
mbfl_filt_ident_true(int c, mbfl_identify_filter *filter)
{
        return c;
}
# 5178 "mbfilter.c"
static void
mbfl_convert_filter_set_vtbl(mbfl_convert_filter *filter, struct mbfl_convert_vtbl *vtbl)
{
        if (filter && vtbl) {
                filter->filter_ctor = vtbl->filter_ctor;
                filter->filter_dtor = vtbl->filter_dtor;
                filter->filter_function = vtbl->filter_function;
                filter->filter_flush = vtbl->filter_flush;
        }
}


static struct mbfl_convert_vtbl *
mbfl_convert_filter_get_vtbl(enum mbfl_no_encoding from, enum mbfl_no_encoding to)
{
        struct mbfl_convert_vtbl *vtbl;
        int i;

        if (to == mbfl_no_encoding_base64 ||
            to == mbfl_no_encoding_qprint ||
            to == mbfl_no_encoding_7bit) {
                from = mbfl_no_encoding_8bit;
        } else if (from == mbfl_no_encoding_base64 ||
                   from == mbfl_no_encoding_qprint) {
                to = mbfl_no_encoding_8bit;
        }

        i = 0;
        while ((vtbl = mbfl_convert_filter_list[i++]) != ((void *)0)){
                if (vtbl->from == from && vtbl->to == to) {
                        return vtbl;
                }
        }

        return ((void *)0);
}


static void
mbfl_convert_filter_select_vtbl(mbfl_convert_filter *filter)
{
        struct mbfl_convert_vtbl *vtbl;

        vtbl = mbfl_convert_filter_get_vtbl(filter->from->no_encoding, filter->to->no_encoding);
        if (vtbl == ((void *)0)) {
                vtbl = &vtbl_pass;
        }
        mbfl_convert_filter_set_vtbl(filter, vtbl);
}



static int
mbfl_filter_output_pipe(int c, void* data)
{
        mbfl_convert_filter *filter = (mbfl_convert_filter*)data;
        return (*filter->filter_function)(c, filter);
}



static int
mbfl_filter_output_null(int c, void* data)
{
        return c;
}


mbfl_convert_filter *
mbfl_convert_filter_new(
    enum mbfl_no_encoding from,
    enum mbfl_no_encoding to,
    int (*output_function)(int, void*),
    int (*flush_function)(void*),
    void* data)
{
        mbfl_convert_filter * filter;


        filter = (mbfl_convert_filter *)_emalloc((sizeof(mbfl_convert_filter)) );
        if (filter == ((void *)0)) {
                return ((void *)0);
        }


        filter->from = mbfl_no2encoding(from);
        filter->to = mbfl_no2encoding(to);
        if (filter->from == ((void *)0)) {
                filter->from = &mbfl_encoding_pass;
        }
        if (filter->to == ((void *)0)) {
                filter->to = &mbfl_encoding_pass;
        }

        if (output_function != ((void *)0)) {
                filter->output_function = output_function;
        } else {
                filter->output_function = mbfl_filter_output_null;
        }
        filter->flush_function = flush_function;
        filter->data = data;
        filter->illegal_mode = 1;
        filter->illegal_substchar = 0x3f;


        mbfl_convert_filter_select_vtbl(filter);


        (*filter->filter_ctor)(filter);

        return filter;
}

void
mbfl_convert_filter_delete(mbfl_convert_filter *filter)
{
        if (filter) {
                (*filter->filter_dtor)(filter);
                _efree(((void*)filter) );
        }
}

int
mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter)
{
        return (*filter->filter_function)(c, filter);
}

int
mbfl_convert_filter_flush(mbfl_convert_filter *filter)
{
        (*filter->filter_flush)(filter);
        return (filter->flush_function ? (*filter->flush_function)(filter->data) : 0);
}

void
mbfl_convert_filter_reset(
    mbfl_convert_filter *filter,
    enum mbfl_no_encoding from,
    enum mbfl_no_encoding to)
{

        (*filter->filter_dtor)(filter);


        filter->from = mbfl_no2encoding(from);
        filter->to = mbfl_no2encoding(to);


        mbfl_convert_filter_select_vtbl(filter);


        (*filter->filter_ctor)(filter);
}

void
mbfl_convert_filter_copy(
    mbfl_convert_filter *src,
    mbfl_convert_filter *dist)
{
        dist->filter_ctor = src->filter_ctor;
        dist->filter_dtor = src->filter_dtor;
        dist->filter_function = src->filter_function;
        dist->filter_flush = src->filter_flush;
        dist->output_function = src->output_function;
        dist->flush_function = src->flush_function;
        dist->data = src->data;
        dist->status = src->status;
        dist->cache = src->cache;
        dist->from = src->from;
        dist->to = src->to;
        dist->illegal_mode = src->illegal_mode;
        dist->illegal_substchar = src->illegal_substchar;
}

static int
mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src)
{
        int n;
        unsigned char *p;

        p = src->buffer;
        n = src->pos;
        while (n > 0) {
                if ((*filter->filter_function)(*p++, filter) < 0) {
                        return -1;
                }
                n--;
        }

        return n;
}

static int
mbfl_convert_filter_strcat(mbfl_convert_filter *filter, const unsigned char *p)
{
        int c;

        while ((c = *p++) != '\0') {
                if ((*filter->filter_function)(c, filter) < 0) {
                        return -1;
                }
        }

        return 0;
}
# 5401 "mbfilter.c"
static char mbfl_hexchar_table[] = {
        0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x41,0x42,0x43,0x44,0x45,0x46
};


int
mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter)
{
        int mode_backup, ret, n, m, r;

        ret = 0;
        mode_backup = filter->illegal_mode;
        filter->illegal_mode = 0;
        switch (mode_backup) {
        case 1:
                ret = (*filter->filter_function)(filter->illegal_substchar, filter);
                break;
        case 2:
                if (c >= 0) {
                        if (c < 0x70000000) {
                                ret = mbfl_convert_filter_strcat(filter, "U+");
                        } else {
                                if (c < 0x78000000) {
                                        m = c & ~0xffff;
                                        switch (m) {
                                        case 0x70e10000:
                                                ret = mbfl_convert_filter_strcat(filter, "JIS+");
                                                break;
                                        case 0x70e20000:
                                                ret = mbfl_convert_filter_strcat(filter, "JIS2+");
                                                break;
                                        case 0x70e30000:
                                                ret = mbfl_convert_filter_strcat(filter, "W932+");
                                                break;
                                        case 0x70e40000:
                                                ret = mbfl_convert_filter_strcat(filter, "I8859_1+");
                                                break;
                                        default:
                                                ret = mbfl_convert_filter_strcat(filter, "?+");
                                                break;
                                        }
                                        c &= 0xffff;
                                } else {
                                        ret = mbfl_convert_filter_strcat(filter, "BAD+");
                                        c &= 0xffffff;
                                }
                        }
                        if (ret >= 0) {
                                m = 0;
                                r = 28;
                                while (r >= 0) {
                                        n = (c >> r) & 0xf;
                                        if (n || m) {
                                                m = 1;
                                                ret = (*filter->filter_function)(mbfl_hexchar_table[n], filter);
                                                if (ret < 0) {
                                                        break;
                                                }
                                        }
                                        r -= 4;
                                }
                                if (m == 0 && ret >= 0) {
                                        ret = (*filter->filter_function)(mbfl_hexchar_table[0], filter);
                                }
                        }
                }
                break;
        default:
                break;
        }
        filter->illegal_mode = mode_backup;

        return ret;
}






static void
mbfl_identify_filter_set_vtbl(mbfl_identify_filter *filter, struct mbfl_identify_vtbl *vtbl)
{
        if (filter && vtbl) {
                filter->filter_ctor = vtbl->filter_ctor;
                filter->filter_dtor = vtbl->filter_dtor;
                filter->filter_function = vtbl->filter_function;
        }
}

static struct mbfl_identify_vtbl *
mbfl_identify_filter_get_vtbl(enum mbfl_no_encoding encoding)
{
        struct mbfl_identify_vtbl *vtbl;
        int i;

        i = 0;
        while ((vtbl = mbfl_identify_filter_list[i++]) != ((void *)0)) {
                if (vtbl->encoding == encoding) {
                        break;
                }
        }

        return vtbl;
}

static void
mbfl_identify_filter_select_vtbl(mbfl_identify_filter *filter)
{
        struct mbfl_identify_vtbl *vtbl;

        vtbl = mbfl_identify_filter_get_vtbl(filter->encoding->no_encoding);
        if (vtbl == ((void *)0)) {
                vtbl = &vtbl_identify_false;
        }
        mbfl_identify_filter_set_vtbl(filter, vtbl);
}

mbfl_identify_filter *
mbfl_identify_filter_new(enum mbfl_no_encoding encoding)
{
        mbfl_identify_filter * filter;


        filter = (mbfl_identify_filter *)_emalloc((sizeof(mbfl_identify_filter)) );
        if (filter == ((void *)0)) {
                return ((void *)0);
        }


        filter->encoding = mbfl_no2encoding(encoding);
        if (filter->encoding == ((void *)0)) {
                filter->encoding = &mbfl_encoding_pass;
        }

        filter->status = 0;
        filter->flag = 0;
        filter->score = 0;


        mbfl_identify_filter_select_vtbl(filter);


        (*filter->filter_ctor)(filter);

        return filter;
}

void
mbfl_identify_filter_delete(mbfl_identify_filter *filter)
{
        if (filter) {
                (*filter->filter_dtor)(filter);
                _efree(((void*)filter) );
        }
}






mbfl_buffer_converter *
mbfl_buffer_converter_new(
    enum mbfl_no_encoding from,
    enum mbfl_no_encoding to,
    int buf_initsz)
{
        mbfl_buffer_converter *convd;


        convd = (mbfl_buffer_converter*)_emalloc((sizeof (mbfl_buffer_converter)) );
        if (convd == ((void *)0)) {
                return ((void *)0);
        }


        convd->from = mbfl_no2encoding(from);
        convd->to = mbfl_no2encoding(to);
        if (convd->from == ((void *)0)) {
                convd->from = &mbfl_encoding_pass;
        }
        if (convd->to == ((void *)0)) {
                convd->to = &mbfl_encoding_pass;
        }


        convd->filter1 = ((void *)0);
        convd->filter2 = ((void *)0);
        if (mbfl_convert_filter_get_vtbl(convd->from->no_encoding, convd->to->no_encoding) != ((void *)0)) {
                convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, convd->to->no_encoding, mbfl_memory_device_output, 0, &convd->device);
        } else {
                convd->filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, convd->to->no_encoding, mbfl_memory_device_output, 0, &convd->device);
                if (convd->filter2 != ((void *)0)) {
                        convd->filter1 = mbfl_convert_filter_new(convd->from->no_encoding, mbfl_no_encoding_wchar, (int (*)(int, void*))convd->filter2->filter_function, ((void *)0), convd->filter2);
                        if (convd->filter1 == ((void *)0)) {
                                mbfl_convert_filter_delete(convd->filter2);
                        }
                }
        }
        if (convd->filter1 == ((void *)0)) {
                return ((void *)0);
        }

        mbfl_memory_device_init(&convd->device, buf_initsz, buf_initsz/4);

        return convd;
}

void
mbfl_buffer_converter_delete(mbfl_buffer_converter *convd)
{
        if (convd != ((void *)0)) {
                if (convd->filter1) {
                        mbfl_convert_filter_delete(convd->filter1);
                }
                if (convd->filter2) {
                        mbfl_convert_filter_delete(convd->filter2);
                }
                mbfl_memory_device_clear(&convd->device);
                _efree(((void*)convd) );
        }
}

void
mbfl_buffer_converter_reset(mbfl_buffer_converter *convd)
{
        mbfl_memory_device_reset(&convd->device);
}

int
mbfl_buffer_converter_illegal_mode(mbfl_buffer_converter *convd, int mode)
{
        if (convd != ((void *)0)) {
                if (convd->filter2 != ((void *)0)) {
                        convd->filter2->illegal_mode = mode;
                } else if (convd->filter1 != ((void *)0)) {
                        convd->filter1->illegal_mode = mode;
                } else {
                        return 0;
                }
        }

        return 1;
}

int
mbfl_buffer_converter_illegal_substchar(mbfl_buffer_converter *convd, int substchar)
{
        if (convd != ((void *)0)) {
                if (convd->filter2 != ((void *)0)) {
                        convd->filter2->illegal_substchar = substchar;
                } else if (convd->filter1 != ((void *)0)) {
                        convd->filter1->illegal_substchar = substchar;
                } else {
                        return 0;
                }
        }

        return 1;
}

int
mbfl_buffer_converter_strncat(mbfl_buffer_converter *convd, const unsigned char *p, int n)
{
        mbfl_convert_filter *filter;
        int (*filter_function)(int c, mbfl_convert_filter *filter);

        if (convd != ((void *)0) && p != ((void *)0)) {
                filter = convd->filter1;
                if (filter != ((void *)0)) {
                        filter_function = filter->filter_function;
                        while (n > 0) {
                                if ((*filter_function)(*p++, filter) < 0) {
                                        break;
                                }
                                n--;
                        }
                }
        }

        return n;
}

int
mbfl_buffer_converter_feed(mbfl_buffer_converter *convd, mbfl_string *string)
{
        int n;
        unsigned char *p;
        mbfl_convert_filter *filter;
        int (*filter_function)(int c, mbfl_convert_filter *filter);

        if (convd == ((void *)0) || string == ((void *)0)) {
                return -1;
        }
        mbfl_memory_device_realloc(&convd->device, convd->device.pos + string->len, string->len/4);

        n = string->len;
        p = string->val;
        filter = convd->filter1;
        if (filter != ((void *)0)) {
                filter_function = filter->filter_function;
                while (n > 0) {
                        if ((*filter_function)(*p++, filter) < 0) {
                                return -1;
                        }
                        n--;
                }
        }

        return 0;
}

int
mbfl_buffer_converter_flush(mbfl_buffer_converter *convd)
{
        if (convd == ((void *)0)) {
                return -1;
        }

        if (convd->filter1 != ((void *)0)) {
                mbfl_convert_filter_flush(convd->filter1);
        }
        if (convd->filter2 != ((void *)0)) {
                mbfl_convert_filter_flush(convd->filter2);
        }

        return 0;
}

mbfl_string *
mbfl_buffer_converter_getbuffer(mbfl_buffer_converter *convd, mbfl_string *result)
{
        if (convd != ((void *)0) && result != ((void *)0) && convd->device.buffer != ((void *)0)) {
                result->no_encoding = convd->to->no_encoding;
                result->val = convd->device.buffer;
                result->len = convd->device.pos;
        } else {
                result = ((void *)0);
        }

        return result;
}

mbfl_string *
mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result)
{
        if (convd == ((void *)0) || result == ((void *)0)) {
                return ((void *)0);
        }
        result->no_encoding = convd->to->no_encoding;
        return mbfl_memory_device_result(&convd->device, result);
}

mbfl_string *
mbfl_buffer_converter_feed_result(mbfl_buffer_converter *convd, mbfl_string *string, mbfl_string *result)
{
        if (convd == ((void *)0) || string == ((void *)0) || result == ((void *)0)) {
                return ((void *)0);
        }
        mbfl_buffer_converter_feed(convd, string);
        if (convd->filter1 != ((void *)0)) {
                mbfl_convert_filter_flush(convd->filter1);
        }
        if (convd->filter2 != ((void *)0)) {
                mbfl_convert_filter_flush(convd->filter2);
        }
        result->no_encoding = convd->to->no_encoding;
        return mbfl_memory_device_result(&convd->device, result);
}





mbfl_encoding_detector *
mbfl_encoding_detector_new(enum mbfl_no_encoding *elist, int eliztsz)
{
        mbfl_encoding_detector *identd;

        int i, num;
        mbfl_identify_filter *filter;

        if (elist == ((void *)0) || eliztsz <= 0) {
                return ((void *)0);
        }


        identd = (mbfl_encoding_detector*)_emalloc((sizeof(mbfl_encoding_detector)) );
        if (identd == ((void *)0)) {
                return ((void *)0);
        }
        identd->filter_list = (mbfl_identify_filter **)_ecalloc((eliztsz), (sizeof(mbfl_identify_filter *)) );
        if (identd->filter_list == ((void *)0)) {
                _efree((identd) );
                return ((void *)0);
        }


        i = 0;
        num = 0;
        while (i < eliztsz) {
                filter = mbfl_identify_filter_new(elist[i]);
                if (filter != ((void *)0)) {
                        identd->filter_list[num] = filter;
                        num++;
                }
                i++;
        }
        identd->filter_list_size = num;

        return identd;
}

void
mbfl_encoding_detector_delete(mbfl_encoding_detector *identd)
{
        int i;

        if (identd != ((void *)0)) {
                if (identd->filter_list != ((void *)0)) {
                        i = identd->filter_list_size;
                        while (i > 0) {
                                i--;
                                mbfl_identify_filter_delete(identd->filter_list[i]);
                        }
                        _efree(((void *)identd->filter_list) );
                }
                _efree(((void *)identd) );
        }
}

int
mbfl_encoding_detector_feed(mbfl_encoding_detector *identd, mbfl_string *string)
{
        int i, n, num, bad, res;
        unsigned char *p;
        mbfl_identify_filter *filter;

        res = 0;

        if (identd != ((void *)0) && string != ((void *)0) && string->val != ((void *)0)) {
                num = identd->filter_list_size;
                n = string->len;
                p = string->val;
                while (n > 0) {
                        i = 0;
                        bad = 0;
                        while (i < num) {
                                filter = identd->filter_list[i];
                                (*filter->filter_function)(*p, filter);
                                if (filter->flag) {
                                        bad++;
                                }
                                i++;
                        }
                        if ((num - 1) <= bad) {
                                res = 1;
                                break;
                        }
                        p++;
                        n--;
                }
        }

        return res;
}

enum mbfl_no_encoding mbfl_encoding_detector_judge(mbfl_encoding_detector *identd)
{
        mbfl_identify_filter *filter;
        enum mbfl_no_encoding encoding;
        int n;


        encoding = mbfl_no_encoding_invalid;
        if (identd != ((void *)0)) {
                n = identd->filter_list_size - 1;
                while (n >= 0) {
                        filter = identd->filter_list[n];
                        if (!filter->flag) {
                                encoding = filter->encoding->no_encoding;
                        }
                        n--;
                }
        }

        return encoding;
}





mbfl_string *
mbfl_convert_encoding(
    mbfl_string *string,
    mbfl_string *result,
    enum mbfl_no_encoding toenc)
{
        int n;
        unsigned char *p;
        mbfl_encoding *encoding;
        mbfl_memory_device device;
        mbfl_convert_filter *filter1;
        mbfl_convert_filter *filter2;


        encoding = mbfl_no2encoding(toenc);
        if (encoding == ((void *)0) || string == ((void *)0) || result == ((void *)0)) {
                return ((void *)0);
        }

        filter1 = ((void *)0);
        filter2 = ((void *)0);
        if (mbfl_convert_filter_get_vtbl(string->no_encoding, toenc) != ((void *)0)) {
                filter1 = mbfl_convert_filter_new(string->no_encoding, toenc, mbfl_memory_device_output, 0, &device);
        } else {
                filter2 = mbfl_convert_filter_new(mbfl_no_encoding_wchar, toenc, mbfl_memory_device_output, 0, &device);
                if (filter2 != ((void *)0)) {
                        filter1 = mbfl_convert_filter_new(string->no_encoding, mbfl_no_encoding_wchar, (int (*)(int, void*))filter2->filter_function, ((void *)0), filter2);
                        if (filter1 == ((void *)0)) {
                                mbfl_convert_filter_delete(filter2);
                        }
                }
        }
        if (filter1 == ((void *)0)) {
                return ((void *)0);
        }
        filter2->illegal_mode = 1;
        filter2->illegal_substchar = 0x3f;
        mbfl_memory_device_init(&device, string->len, (string->len >> 2) + 8);


        n = string->len;
        p = string->val;
        if (p != ((void *)0)) {
                while (n > 0) {
                        if ((*filter1->filter_function)(*p++, filter1) < 0) {
                                break;
                        }
                        n--;
                }
        }

        mbfl_convert_filter_flush(filter1);
        mbfl_convert_filter_delete(filter1);
        if (filter2 != ((void *)0)) {
                mbfl_convert_filter_flush(filter2);
                mbfl_convert_filter_delete(filter2);
        }

        return mbfl_memory_device_result(&device, result);
}





mbfl_encoding *
mbfl_identify_encoding(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz)
{
        int i, n, num, bad;
        unsigned char *p;
        struct mbfl_identify_vtbl *vtbl;
        mbfl_identify_filter *flist, *filter;
        mbfl_encoding *encoding;


        flist = (mbfl_identify_filter *)_ecalloc((eliztsz), (sizeof(mbfl_identify_filter)) );
        if (flist == ((void *)0)) {
                return ((void *)0);
        }
        i = 0;
        num = 0;
        if (elist != ((void *)0)) {
                while (i < eliztsz) {
                        vtbl = mbfl_identify_filter_get_vtbl(elist[i]);
                        if (vtbl != ((void *)0)) {
                                filter = &flist[num];
                                mbfl_identify_filter_set_vtbl(filter, vtbl);
                                filter->encoding = mbfl_no2encoding(vtbl->encoding);
                                (*filter->filter_ctor)(filter);
                                num++;
                        }
                        i++;
                }
        }


        n = string->len;
        p = string->val;
        if (p != ((void *)0)) {
                while (n > 0) {
                        i = 0;
                        bad = 0;
                        while (i < num) {
                                filter = &flist[i];
                                (*filter->filter_function)(*p, filter);
                                if (filter->flag) {
                                        bad++;
                                }
                                i++;
                        }
                        if ((num - 1) <= bad) {
                                break;
                        }
                        p++;
                        n--;
                }
        }


        i = num - 1;
        bad = 1;
        encoding = ((void *)0);
        while (i >= 0) {
                filter = &flist[i];
                if (filter->flag) {
                        bad++;
                } else {
                        encoding = filter->encoding;
                }
                i--;
        }






        i = 0;
        while (i < num) {
                filter = &flist[i];
                (*filter->filter_dtor)(filter);
                i++;
        }
        _efree(((void *)flist) );

        return encoding;
}

const char*
mbfl_identify_encoding_name(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz)
{
        mbfl_encoding *encoding;

        encoding = mbfl_identify_encoding(string, elist, eliztsz);
        if (encoding != ((void *)0) &&
            encoding->no_encoding > mbfl_no_encoding_charset_min &&
            encoding->no_encoding < mbfl_no_encoding_charset_max) {
                return encoding->name;
        } else {
                return ((void *)0);
        }
}

enum mbfl_no_encoding
mbfl_identify_encoding_no(mbfl_string *string, enum mbfl_no_encoding *elist, int eliztsz)
{
        mbfl_encoding *encoding;

        encoding = mbfl_identify_encoding(string, elist, eliztsz);
        if (encoding != ((void *)0) &&
            encoding->no_encoding > mbfl_no_encoding_charset_min &&
            encoding->no_encoding < mbfl_no_encoding_charset_max) {
                return encoding->no_encoding;
        } else {
                return mbfl_no_encoding_invalid;
        }
}





static int
filter_count_output(int c, void *data)
{
        (*(int *)data)++;
        return c;
}

int
mbfl_strlen(mbfl_string *string)
{
        int len, n, m, k;
        unsigned char *p;
        const unsigned char *mbtab;
        mbfl_encoding *encoding;

        encoding = mbfl_no2encoding(string->no_encoding);
        if (encoding == ((void *)0) || string == ((void *)0)) {
                return -1;
        }

        len = 0;
        if (encoding->flag & 0x00000001) {
                len = string->len;
        } else if (encoding->flag & (0x00000010 | 0x00000020)) {
                len = string->len/2;
        } else if (encoding->flag & (0x00000100 | 0x00000200)) {
                len = string->len/4;
        } else if (encoding->mblen_table != ((void *)0)) {
                mbtab = encoding->mblen_table;
                n = 0;
                p = string->val;
                k = string->len;

                if (p != ((void *)0)) {
                        while (n < k) {
                                m = mbtab[*p];
                                n += m;
                                p += m;
                                len++;
                        };
                }
        } else {

                mbfl_convert_filter *filter = mbfl_convert_filter_new(
                  string->no_encoding,
                  mbfl_no_encoding_wchar,
                  filter_count_output, 0, &len);
                if (filter == ((void *)0)) {
                        return -1;
                }

                n = string->len;
                p = string->val;
                if (p != ((void *)0)) {
                        while (n > 0) {
                                (*filter->filter_function)(*p++, filter);
                                n--;
                        }
                }
                mbfl_convert_filter_delete(filter);
        }

        return len;
}





struct collector_strpos_data {
        mbfl_convert_filter *next_filter;
        mbfl_wchar_device needle;
        int needle_len;
        int start;
        int output;
        int found_pos;
        int needle_pos;
        int matched_pos;
};

static int
collector_strpos(int c, void* data)
{
        int *p, *h, *m, n;
        struct collector_strpos_data *pc = (struct collector_strpos_data*)data;

        if (pc->output >= pc->start) {
                if (c == pc->needle.buffer[pc->needle_pos]) {
                        if (pc->needle_pos == 0) {
                                pc->found_pos = pc->output;
                        }
                        pc->needle_pos++;
                        if (pc->needle_pos >= pc->needle_len) {
                                pc->matched_pos = pc->found_pos;
                                pc->needle_pos--;
                                goto retry;
                        }
                } else if (pc->needle_pos != 0) {
retry:
                        h = pc->needle.buffer;
                        h++;
                        for (;;) {
                                pc->found_pos++;
                                p = h;
                                m = pc->needle.buffer;
                                n = pc->needle_pos - 1;
                                while (n > 0 && *p == *m) {
                                        n--;
                                        p++;
                                        m++;
                                }
                                if (n <= 0) {
                                        if (*m != c) {
                                                pc->needle_pos = 0;
                                        }
                                        break;
                                } else {
                                        h++;
                                        pc->needle_pos--;
                                }
                        }
                }
        }

        pc->output++;
        return c;
}

int
mbfl_strpos(
    mbfl_string *haystack,
    mbfl_string *needle,
    int offset,
    int reverse)
{
        int n, result;
        unsigned char *p;
        mbfl_convert_filter *filter;
        struct collector_strpos_data pc;

        if (haystack == ((void *)0) || needle == ((void *)0)) {
                return -8;
        }

        mbfl_wchar_device_init(&pc.needle);
        filter = mbfl_convert_filter_new(
          needle->no_encoding,
          mbfl_no_encoding_wchar,
          mbfl_wchar_device_output, 0, &pc.needle);
        if (filter == ((void *)0)) {
                return -4;
        }
        p = needle->val;
        n = needle->len;
        if (p != ((void *)0)) {
                while (n > 0) {
                        if ((*filter->filter_function)(*p++, filter) < 0) {
                                break;
                        }
                        n--;
                }
        }
        mbfl_convert_filter_flush(filter);
        mbfl_convert_filter_delete(filter);
        pc.needle_len = pc.needle.pos;
        if (pc.needle.buffer == ((void *)0)) {
                return -4;
        }
        if (pc.needle_len <= 0) {
                mbfl_wchar_device_clear(&pc.needle);
                return -2;
        }

        filter = mbfl_convert_filter_new(
          haystack->no_encoding,
          mbfl_no_encoding_wchar,
          collector_strpos, 0, &pc);
        if (filter == ((void *)0)) {
                mbfl_wchar_device_clear(&pc.needle);
                return -4;
        }
        pc.start = offset;
        pc.output = 0;
        pc.needle_pos = 0;
        pc.found_pos = 0;
        pc.matched_pos = -1;


        p = haystack->val;
        n = haystack->len;
        if (p != ((void *)0)) {
                while (n > 0) {
                        if ((*filter->filter_function)(*p++, filter) < 0) {
                                pc.matched_pos = -4;
                                break;
                        }
                        if (pc.matched_pos >= 0 && !reverse) {
                                break;
                        }
                        n--;
                }
        }
        mbfl_convert_filter_flush(filter);
        result = pc.matched_pos;
        mbfl_convert_filter_delete(filter);
        mbfl_wchar_device_clear(&pc.needle);

        return result;
}





struct collector_substr_data {
        mbfl_convert_filter *next_filter;
        int start;
        int stop;
        int output;
};

static int
collector_substr(int c, void* data)
{
        struct collector_substr_data *pc = (struct collector_substr_data*)data;

        if (pc->output >= pc->stop) {
                return -1;
        }

        if (pc->output >= pc->start) {
                (*pc->next_filter->filter_function)(c, pc->next_filter);
        }

        pc->output++;

        return c;
}

mbfl_string *
mbfl_substr(
    mbfl_string *string,
    mbfl_string *result,
    int from,
    int length)
{
        mbfl_encoding *encoding;
        int n, m, k, len, start, end;
        unsigned char *p, *w;
        const unsigned char *mbtab;

        encoding = mbfl_no2encoding(string->no_encoding);
        if (encoding == ((void *)0) || string == ((void *)0) || result == ((void *)0)) {
                return ((void *)0);
        }
        mbfl_string_init(result);
        result->no_language = string->no_language;
        result->no_encoding = string->no_encoding;

        if ((encoding->flag & (0x00000001 | 0x00000010 | 0x00000020 | 0x00000100 | 0x00000200)) ||
           encoding->mblen_table != ((void *)0)) {
                len = string->len;
                start = from;
                end = from + length;
                if (encoding->flag & (0x00000010 | 0x00000080)) {
                        start *= 2;
                        end = start + length*2;
                } else if (encoding->flag & (0x00000100 | 0x00000800)) {
                        start *= 4;
                        end = start + length*4;
                } else if (encoding->mblen_table != ((void *)0)) {
                        mbtab = encoding->mblen_table;
                        start = 0;
                        end = 0;
                        n = 0;
                        k = 0;
                        p = string->val;
                        if (p != ((void *)0)) {

                                while (k <= from) {
                                        start = n;
                                        if (n >= len) {
                                                break;
                                        }
                                        m = mbtab[*p];
                                        n += m;
                                        p += m;
                                        k++;
                                }

                                k = 0;
                                end = start;
                                while (k < length) {
                                        end = n;
                                        if (n >= len) {
                                                break;
                                        }
                                        m = mbtab[*p];
                                        n += m;
                                        p += m;
                                        k++;
                                }
                        }
                }

                if (start > len) {
                        start = len;
                }
                if (start < 0) {
                        start = 0;
                }
                if (end > len) {
                        end = len;
                }
                if (end < 0) {
                        end = 0;
                }
                if (start > end) {
                        start = end;
                }


                n = end - start;
                result->len = 0;
                result->val = w = (unsigned char*)_emalloc(((n + 8)*sizeof(unsigned char)) );
                if (w != ((void *)0)) {
                        p = string->val;
                        if (p != ((void *)0)) {
                                p += start;
                                result->len = n;
                                while (n > 0) {
                                        *w++ = *p++;
                                        n--;
                                }
                        }
                        *w++ = '\0';
                        *w++ = '\0';
                        *w++ = '\0';
                        *w = '\0';
                } else {
                        result = ((void *)0);
                }
        } else {
                mbfl_memory_device device;
                struct collector_substr_data pc;
                mbfl_convert_filter *decoder;
                mbfl_convert_filter *encoder;

                mbfl_memory_device_init(&device, length + 1, 0);
                mbfl_string_init(result);
                result->no_language = string->no_language;
                result->no_encoding = string->no_encoding;

                decoder = mbfl_convert_filter_new(
                    mbfl_no_encoding_wchar,
                    string->no_encoding,
                    mbfl_memory_device_output, 0, &device);

                encoder = mbfl_convert_filter_new(
                    string->no_encoding,
                    mbfl_no_encoding_wchar,
                    collector_substr, 0, &pc);
                if (decoder == ((void *)0) || encoder == ((void *)0)) {
                        mbfl_convert_filter_delete(encoder);
                        mbfl_convert_filter_delete(decoder);
                        return ((void *)0);
                }
                pc.next_filter = decoder;
                pc.start = from;
                pc.stop = from + length;
                pc.output = 0;


                p = string->val;
                n = string->len;
                if (p != ((void *)0)) {
                        while (n > 0) {
                                if ((*encoder->filter_function)(*p++, encoder) < 0) {
                                        break;
                                }
                                n--;
                        }
                }

                mbfl_convert_filter_flush(encoder);
                mbfl_convert_filter_flush(decoder);
                result = mbfl_memory_device_result(&device, result);
                mbfl_convert_filter_delete(encoder);
                mbfl_convert_filter_delete(decoder);
        }

        return result;
}





mbfl_string *
mbfl_strcut(
    mbfl_string *string,
    mbfl_string *result,
    int from,
    int length)
{
        mbfl_encoding *encoding;
        int n, m, k, len, start, end;
        unsigned char *p, *w;
        const unsigned char *mbtab;
        mbfl_memory_device device;
        mbfl_convert_filter *encoder, *encoder_tmp, *decoder, *decoder_tmp;

        encoding = mbfl_no2encoding(string->no_encoding);
        if (encoding == ((void *)0) || string == ((void *)0) || result == ((void *)0)) {
                return ((void *)0);
        }
        mbfl_string_init(result);
        result->no_language = string->no_language;
        result->no_encoding = string->no_encoding;

        if ((encoding->flag & (0x00000001 | 0x00000010 | 0x00000020 | 0x00000100 | 0x00000200)) ||
           encoding->mblen_table != ((void *)0)) {
                len = string->len;
                start = from;
                end = from + length;
                if (encoding->flag & (0x00000010 | 0x00000020)) {
                        start /= 2;
                        start *= 2;
                        end = length/2;
                        end *= 2;
                        end += start;
                } else if (encoding->flag & (0x00000100 | 0x00000200)) {
                        start /= 4;
                        start *= 4;
                        end = length/4;
                        end *= 4;
                        end += start;
                } else if (encoding->mblen_table != ((void *)0)) {
                        mbtab = encoding->mblen_table;
                        start = 0;
                        end = 0;
                        n = 0;
                        p = string->val;
                        if (p != ((void *)0)) {

                                for (;;) {
                                        m = mbtab[*p];
                                        n += m;
                                        p += m;
                                        if (n > from) {
                                                break;
                                        }
                                        start = n;
                                }

                                k = start + length;
                                if (k >= string->len) {
                                        end = string->len;
                                } else {
                                        end = start;
                                        while (n <= k) {
                                                end = n;
                                                m = mbtab[*p];
                                                n += m;
                                                p += m;
                                        }
                                }
                        }
                }

                if (start > len) {
                        start = len;
                }
                if (start < 0) {
                        start = 0;
                }
                if (end > len) {
                        end = len;
                }
                if (end < 0) {
                        end = 0;
                }
                if (start > end) {
                        start = end;
                }

                n = end - start;
                result->len = 0;
                result->val = w = (unsigned char*)_emalloc(((n + 8)*sizeof(unsigned char)) );
                if (w != ((void *)0)) {
                        result->len = n;
                        p = &(string->val[start]);
                        while (n > 0) {
                                *w++ = *p++;
                                n--;
                        }
                        *w++ = '\0';
                        *w++ = '\0';
                        *w++ = '\0';
                        *w = '\0';
                } else {
                        result = ((void *)0);
                }
        } else {

                encoder = mbfl_convert_filter_new(
                  string->no_encoding,
                  mbfl_no_encoding_wchar,
                  mbfl_filter_output_null, 0, 0);
                encoder_tmp = mbfl_convert_filter_new(
                  string->no_encoding,
                  mbfl_no_encoding_wchar,
                  mbfl_filter_output_null, 0, 0);

                decoder = mbfl_convert_filter_new(
                  mbfl_no_encoding_wchar,
                  string->no_encoding,
                  mbfl_memory_device_output, 0, &device);
                decoder_tmp = mbfl_convert_filter_new(
                  mbfl_no_encoding_wchar,
                  string->no_encoding,
                  mbfl_memory_device_output, 0, &device);
                if (encoder == ((void *)0) || encoder_tmp == ((void *)0) || decoder == ((void *)0) || decoder_tmp == ((void *)0)) {
                        mbfl_convert_filter_delete(encoder);
                        mbfl_convert_filter_delete(encoder_tmp);
                        mbfl_convert_filter_delete(decoder);
                        mbfl_convert_filter_delete(decoder_tmp);
                        return ((void *)0);
                }
                mbfl_memory_device_init(&device, length + 8, 0);
                k = 0;
                n = 0;
                p = string->val;
                if (p != ((void *)0)) {

                        while (n < from) {
                                (*encoder->filter_function)(*p++, encoder);
                                n++;
                        }

                        encoder->output_function = mbfl_filter_output_pipe;
                        encoder->data = decoder;
                        k = length - 20;
                        len = string->len;
                        while (n < len && device.pos < k) {
                                (*encoder->filter_function)(*p++, encoder);
                                n++;
                        }

                        for (;;) {

                                k = device.pos;
                                mbfl_convert_filter_copy(encoder, encoder_tmp);
                                mbfl_convert_filter_copy(decoder, decoder_tmp);
                                if (n >= len) {
                                        break;
                                }

                                (*encoder->filter_function)(*p, encoder);
                                (*encoder->filter_flush)(encoder);
                                (*decoder->filter_flush)(decoder);
                                if (device.pos > length) {
                                        break;
                                }

                                device.pos = k;
                                mbfl_convert_filter_copy(encoder_tmp, encoder);
                                mbfl_convert_filter_copy(decoder_tmp, decoder);
                                (*encoder->filter_function)(*p, encoder);
                                p++;
                                n++;
                        }
                        device.pos = k;
                        mbfl_convert_filter_copy(encoder_tmp, encoder);
                        mbfl_convert_filter_copy(decoder_tmp, decoder);
                        mbfl_convert_filter_flush(encoder);
                        mbfl_convert_filter_flush(decoder);
                }
                result = mbfl_memory_device_result(&device, result);
                mbfl_convert_filter_delete(encoder);
                mbfl_convert_filter_delete(encoder_tmp);
                mbfl_convert_filter_delete(decoder);
                mbfl_convert_filter_delete(decoder_tmp);
        }

        return result;
}





static int
filter_count_width(int c, void* data)
{
        if (c >= 0x20) {
                if (c < 0x2000 || (c > 0xff60 && c < 0xffa0)) {
                        (*(int *)data)++;
                } else {
                        (*(int *)data) += 2;
                }
        }

        return c;
}

int
mbfl_strwidth(mbfl_string *string)
{
        int len, n;
        unsigned char *p;
        mbfl_convert_filter *filter;

        len = 0;
        if (string->len > 0 && string->val != ((void *)0)) {

                filter = mbfl_convert_filter_new(
                    string->no_encoding,
                    mbfl_no_encoding_wchar,
                    filter_count_width, 0, &len);
                if (filter == ((void *)0)) {
                        mbfl_convert_filter_delete(filter);
                        return -1;
                }


                p = string->val;
                n = string->len;
                while (n > 0) {
                        (*filter->filter_function)(*p++, filter);
                        n--;
                }

                mbfl_convert_filter_flush(filter);
                mbfl_convert_filter_delete(filter);
        }

        return len;
}





struct collector_strimwidth_data {
        mbfl_convert_filter *decoder;
        mbfl_convert_filter *decoder_backup;
        mbfl_memory_device device;
        int from;
        int width;
        int outwidth;
        int outchar;
        int status;
        int endpos;
};

static int
collector_strimwidth(int c, void* data)
{
        struct collector_strimwidth_data *pc = (struct collector_strimwidth_data*)data;

        switch (pc->status) {
        case 10:
                (*pc->decoder->filter_function)(c, pc->decoder);
                break;
        default:
                if (pc->outchar >= pc->from) {
                        if (c >= 0x20) {
                                if (c < 0x2000 || (c > 0xff60 && c < 0xffa0)) {
                                        pc->outwidth++;
                                } else {
                                        pc->outwidth += 2;
                                }
                        }
                        if (pc->outwidth > pc->width) {
                                if (pc->status == 0) {
                                        pc->endpos = pc->device.pos;
                                        mbfl_convert_filter_copy(pc->decoder, pc->decoder_backup);
                                }
                                pc->status++;
                                (*pc->decoder->filter_function)(c, pc->decoder);
                                c = -1;
                        } else {
                                (*pc->decoder->filter_function)(c, pc->decoder);
                        }
                }
                pc->outchar++;
                break;
        }

        return c;
}

mbfl_string *
mbfl_strimwidth(
    mbfl_string *string,
    mbfl_string *marker,
    mbfl_string *result,
    int from,
    int width)
{
        struct collector_strimwidth_data pc;
        mbfl_convert_filter *encoder;
        int n, mkwidth;
        unsigned char *p;

        if (string == ((void *)0) || result == ((void *)0)) {
                return ((void *)0);
        }
        mbfl_string_init(result);
        result->no_language = string->no_language;
        result->no_encoding = string->no_encoding;
        mbfl_memory_device_init(&pc.device, width, 0);


        pc.decoder = mbfl_convert_filter_new(
            mbfl_no_encoding_wchar,
            string->no_encoding,
            mbfl_memory_device_output, 0, &pc.device);
        pc.decoder_backup = mbfl_convert_filter_new(
            mbfl_no_encoding_wchar,
            string->no_encoding,
            mbfl_memory_device_output, 0, &pc.device);

        encoder = mbfl_convert_filter_new(
            string->no_encoding,
            mbfl_no_encoding_wchar,
            collector_strimwidth, 0, &pc);
        if (pc.decoder == ((void *)0) || pc.decoder_backup == ((void *)0) || encoder == ((void *)0)) {
                mbfl_convert_filter_delete(encoder);
                mbfl_convert_filter_delete(pc.decoder);
                mbfl_convert_filter_delete(pc.decoder_backup);
                return ((void *)0);
        }
        mkwidth = 0;
        if (marker) {
                mkwidth = mbfl_strwidth(marker);
        }
        pc.from = from;
        pc.width = width - mkwidth;
        pc.outwidth = 0;
        pc.outchar = 0;
        pc.status = 0;
        pc.endpos = 0;


        p = string->val;
        n = string->len;
        if (p != ((void *)0)) {
                while (n > 0) {
                        if ((*encoder->filter_function)(*p++, encoder) < 0) {
                                break;
                        }
                        n--;
                }
                mbfl_convert_filter_flush(encoder);
                if (pc.status != 0 && mkwidth > 0) {
                        pc.width += mkwidth;
                        while (n > 0) {
                                if ((*encoder->filter_function)(*p++, encoder) < 0) {
                                        break;
                                }
                                n--;
                        }
                        mbfl_convert_filter_flush(encoder);
                        if (pc.status != 1) {
                                pc.status = 10;
                                pc.device.pos = pc.endpos;
                                mbfl_convert_filter_copy(pc.decoder_backup, pc.decoder);
                                mbfl_convert_filter_reset(encoder, marker->no_encoding, mbfl_no_encoding_wchar);
                                p = marker->val;
                                n = marker->len;
                                while (n > 0) {
                                        if ((*encoder->filter_function)(*p++, encoder) < 0) {
                                                break;
                                        }
                                        n--;
                                }
                                mbfl_convert_filter_flush(encoder);
                        }
                } else if (pc.status != 0) {
                        pc.device.pos = pc.endpos;
                        mbfl_convert_filter_copy(pc.decoder_backup, pc.decoder);
                }
                mbfl_convert_filter_flush(pc.decoder);
        }
        result = mbfl_memory_device_result(&pc.device, result);
        mbfl_convert_filter_delete(encoder);
        mbfl_convert_filter_delete(pc.decoder);
        mbfl_convert_filter_delete(pc.decoder_backup);

        return result;
}






struct collector_hantozen_data {
        mbfl_convert_filter *next_filter;
        int mode;
        int status;
        int cache;
};

static const unsigned char hankana2zenkata_table[64] = {
        0x00,0x02,0x0C,0x0D,0x01,0xFB,0xF2,0xA1,0xA3,0xA5,
        0xA7,0xA9,0xE3,0xE5,0xE7,0xC3,0xFC,0xA2,0xA4,0xA6,
        0xA8,0xAA,0xAB,0xAD,0xAF,0xB1,0xB3,0xB5,0xB7,0xB9,
        0xBB,0xBD,0xBF,0xC1,0xC4,0xC6,0xC8,0xCA,0xCB,0xCC,
        0xCD,0xCE,0xCF,0xD2,0xD5,0xD8,0xDB,0xDE,0xDF,0xE0,
        0xE1,0xE2,0xE4,0xE6,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,
        0xEF,0xF3,0x9B,0x9C
};
static const unsigned char hankana2zenhira_table[64] = {
        0x00,0x02,0x0C,0x0D,0x01,0xFB,0x92,0x41,0x43,0x45,
        0x47,0x49,0x83,0x85,0x87,0x63,0xFC,0x42,0x44,0x46,
        0x48,0x4A,0x4B,0x4D,0x4F,0x51,0x53,0x55,0x57,0x59,
        0x5B,0x5D,0x5F,0x61,0x64,0x66,0x68,0x6A,0x6B,0x6C,
        0x6D,0x6E,0x6F,0x72,0x75,0x78,0x7B,0x7E,0x7F,0x80,
        0x81,0x82,0x84,0x86,0x88,0x89,0x8A,0x8B,0x8C,0x8D,
        0x8F,0x93,0x9B,0x9C
};
static const unsigned char zenkana2hankana_table[84][2] = {
        {0x67,0x00},{0x71,0x00},{0x68,0x00},{0x72,0x00},{0x69,0x00},
        {0x73,0x00},{0x6A,0x00},{0x74,0x00},{0x6B,0x00},{0x75,0x00},
        {0x76,0x00},{0x76,0x9E},{0x77,0x00},{0x77,0x9E},{0x78,0x00},
        {0x78,0x9E},{0x79,0x00},{0x79,0x9E},{0x7A,0x00},{0x7A,0x9E},
        {0x7B,0x00},{0x7B,0x9E},{0x7C,0x00},{0x7C,0x9E},{0x7D,0x00},
        {0x7D,0x9E},{0x7E,0x00},{0x7E,0x9E},{0x7F,0x00},{0x7F,0x9E},
        {0x80,0x00},{0x80,0x9E},{0x81,0x00},{0x81,0x9E},{0x6F,0x00},
        {0x82,0x00},{0x82,0x9E},{0x83,0x00},{0x83,0x9E},{0x84,0x00},
        {0x84,0x9E},{0x85,0x00},{0x86,0x00},{0x87,0x00},{0x88,0x00},
        {0x89,0x00},{0x8A,0x00},{0x8A,0x9E},{0x8A,0x9F},{0x8B,0x00},
        {0x8B,0x9E},{0x8B,0x9F},{0x8C,0x00},{0x8C,0x9E},{0x8C,0x9F},
        {0x8D,0x00},{0x8D,0x9E},{0x8D,0x9F},{0x8E,0x00},{0x8E,0x9E},
        {0x8E,0x9F},{0x8F,0x00},{0x90,0x00},{0x91,0x00},{0x92,0x00},
        {0x93,0x00},{0x6C,0x00},{0x94,0x00},{0x6D,0x00},{0x95,0x00},
        {0x6E,0x00},{0x96,0x00},{0x97,0x00},{0x98,0x00},{0x99,0x00},
        {0x9A,0x00},{0x9B,0x00},{0x9C,0x00},{0x9C,0x00},{0x72,0x00},
        {0x74,0x00},{0x66,0x00},{0x9D,0x00},{0x73,0x9E}
};

static int
collector_hantozen(int c, void* data)
{
        int s, mode, n;
        struct collector_hantozen_data *pc = (struct collector_hantozen_data*)data;

        s = c;
        mode = pc->mode;

        if (mode & 0xf) {
                if ((mode & 0x1) && c >= 0x21 && c <= 0x7d && c != 0x22 && c != 0x27 && c != 0x5c) {
                        s = c + 0xfee0;
                } else if ((mode & 0x2) && ((c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a))) {
                        s = c + 0xfee0;
                } else if ((mode & 0x4) && c >= 0x30 && c <= 0x39) {
                        s = c + 0xfee0;
                } else if ((mode & 0x8) && c == 0x20) {
                        s = 0x3000;
                }
        }

        if (mode & 0xf0) {
                if ((mode & 0x10) && c >= 0xff01 && c <= 0xff5d && c != 0xff02 && c != 0xff07 && c!= 0xff3c) {
                        s = c - 0xfee0;
                } else if ((mode & 0x20) && ((c >= 0xff21 && c <= 0xff3a) || (c >= 0xff41 && c <= 0xff5a))) {
                        s = c - 0xfee0;
                } else if ((mode & 0x40) && (c >= 0xff10 && c <= 0xff19)) {
                        s = c - 0xfee0;
                } else if ((mode & 0x80) && (c == 0x3000)) {
                        s = 0x20;
                } else if ((mode & 0x10) && (c == 0x2212)) {
                        s = 0x2d;
                }
        }

        if (mode & 0x300) {
                if ((mode & 0x100) && (mode & 0x800)) {
                        if (c >= 0xff61 && c <= 0xff9f) {
                                if (pc->status) {
                                        n = (pc->cache - 0xff60) & 0x3f;
                                        if (c == 0xff9e && ((n >= 22 && n <= 36) || (n >= 42 && n <= 46))) {
                                                pc->status = 0;
                                                s = 0x3001 + hankana2zenkata_table[n];
                                        } else if (c == 0xff9e && n == 19) {
                                                pc->status = 0;
                                                s = 0x30f4;
                                        } else if (c == 0xff9f && (n >= 42 && n <= 46)) {
                                                pc->status = 0;
                                                s = 0x3002 + hankana2zenkata_table[n];
                                        } else {
                                                pc->status = 1;
                                                pc->cache = c;
                                                s = 0x3000 + hankana2zenkata_table[n];
                                        }
                                } else {
                                        pc->status = 1;
                                        pc->cache = c;
                                        return c;
                                }
                        } else {
                                if (pc->status) {
                                        n = (pc->cache - 0xff60) & 0x3f;
                                        pc->status = 0;
                                        (*pc->next_filter->filter_function)(0x3000 + hankana2zenkata_table[n], pc->next_filter);
                                }
                        }
                } else if ((mode & 0x200) && (mode & 0x800)) {
                        if (c >= 0xff61 && c <= 0xff9f) {
                                if (pc->status) {
                                        n = (pc->cache - 0xff60) & 0x3f;
                                        if (c == 0xff9e && ((n >= 22 && n <= 36) || (n >= 42 && n <= 46))) {
                                                pc->status = 0;
                                                s = 0x3001 + hankana2zenhira_table[n];
                                        } else if (c == 0xff9f && (n >= 42 && n <= 46)) {
                                                pc->status = 0;
                                                s = 0x3002 + hankana2zenhira_table[n];
                                        } else {
                                                pc->status = 1;
                                                pc->cache = c;
                                                s = 0x3000 + hankana2zenhira_table[n];
                                        }
                                } else {
                                        pc->status = 1;
                                        pc->cache = c;
                                        return c;
                                }
                        } else {
                                if (pc->status) {
                                        n = (pc->cache - 0xff60) & 0x3f;
                                        pc->status = 0;
                                        (*pc->next_filter->filter_function)(0x3000 + hankana2zenhira_table[n], pc->next_filter);
                                }
                        }
                } else if ((mode & 0x100) && c >= 0xff61 && c <= 0xff9f) {
                        s = 0x3000 + hankana2zenkata_table[c - 0xff60];
                } else if ((mode & 0x200) && c >= 0xff61 && c <= 0xff9f) {
                        s = 0x3000 + hankana2zenhira_table[c - 0xff60];
                }
        }

        if (mode & 0x3000) {
                if ((mode & 0x1000) && c >= 0x30a1 && c <= 0x30f4) {
                        n = c - 0x30a1;
                        if (zenkana2hankana_table[n][1] != 0) {
                                (*pc->next_filter->filter_function)(0xff00 + zenkana2hankana_table[n][0], pc->next_filter);
                                s = 0xff00 + zenkana2hankana_table[n][1];
                        } else {
                                s = 0xff00 + zenkana2hankana_table[n][0];
                        }
                } else if ((mode & 0x2000) && c >= 0x3041 && c <= 0x3093) {
                        n = c - 0x3041;
                        if (zenkana2hankana_table[n][1] != 0) {
                                (*pc->next_filter->filter_function)(0xff00 + zenkana2hankana_table[n][0], pc->next_filter);
                                s = 0xff00 + zenkana2hankana_table[n][1];
                        } else {
                                s = 0xff00 + zenkana2hankana_table[n][0];
                        }
                } else if (c == 0x3001) {
                        s = 0xff64;
                } else if (c == 0x3002) {
                        s = 0xff61;
                } else if (c == 0x300c) {
                        s = 0xff62;
                } else if (c == 0x300d) {
                        s = 0xff63;
                } else if (c == 0x309b) {
                        s = 0xff9e;
                } else if (c == 0x309c) {
                        s = 0xff9f;
                } else if (c == 0x30fc) {
                        s = 0xff70;
                } else if (c == 0x30fb) {
                        s = 0xff65;
                }
        } else if (mode & 0x30000) {
                if ((mode & 0x10000) && c >= 0x3041 && c <= 0x3093) {
                        s = c + 0x60;
                } else if ((mode & 0x20000) && c >= 0x30a1 && c <= 0x30f3) {
                        s = c - 0x60;
                }
        }

        if (mode & 0x100000) {
                if (c == 0x5c) {
                        s = 0xffe5;
                } else if (c == 0xa5) {
                        s = 0xffe5;
                } else if (c == 0x7e) {
                        s = 0xffe3;
                } else if (c == 0x203e) {
                        s = 0xffe3;
                } else if (c == 0x27) {
                        s = 0x2019;
                } else if (c == 0x22) {
                        s = 0x201d;
                }
        } else if (mode & 0x200000) {
                if (c == 0xffe5) {
                        s = 0x5c;
                } else if (c == 0xff3c) {
                        s = 0x5c;
                } else if (c == 0xffe3) {
                        s = 0x7e;
                } else if (c == 0x203e) {
                        s = 0x7e;
                } else if (c == 0x2018) {
                        s = 0x27;
                } else if (c == 0x2019) {
                        s = 0x27;
                } else if (c == 0x201c) {
                        s = 0x22;
                } else if (c == 0x201d) {
                        s = 0x22;
                }
        }

        if (mode & 0x400000) {
                if (c == 0x5c) {
                        s = 0xff3c;
                } else if (c == 0x7e) {
                        s = 0xff5e;
                } else if (c == 0x27) {
                        s = 0xff07;
                } else if (c == 0x22) {
                        s = 0xff02;
                }
        } else if (mode & 0x800000) {
                if (c == 0xff3c) {
                        s = 0x5c;
                } else if (c == 0xff5e) {
                        s = 0x7e;
                } else if (c == 0xff07) {
                        s = 0x27;
                } else if (c == 0xff02) {
                        s = 0x22;
                }
        }

        return (*pc->next_filter->filter_function)(s, pc->next_filter);
}

static int
collector_hantozen_flush(struct collector_hantozen_data *pc)
{
        int ret, n;

        ret = 0;
        if (pc->status) {
                n = (pc->cache - 0xff60) & 0x3f;
                if (pc->mode & 0x100) {
                        ret = (*pc->next_filter->filter_function)(0x3000 + hankana2zenkata_table[n], pc->next_filter);
                } else if (pc->mode & 0x200) {
                        ret = (*pc->next_filter->filter_function)(0x3000 + hankana2zenhira_table[n], pc->next_filter);
                }
                pc->status = 0;
        }

        return ret;
}

mbfl_string *
mbfl_ja_jp_hantozen(
    mbfl_string *string,
    mbfl_string *result,
    int mode)
{
        int n;
        unsigned char *p;
        mbfl_encoding *encoding;
        mbfl_memory_device device;
        struct collector_hantozen_data pc;
        mbfl_convert_filter *decoder;
        mbfl_convert_filter *encoder;


        if (string == ((void *)0) || result == ((void *)0)) {
                return ((void *)0);
        }
        encoding = mbfl_no2encoding(string->no_encoding);
        if (encoding == ((void *)0)) {
                return ((void *)0);
        }
        mbfl_memory_device_init(&device, string->len, 0);
        mbfl_string_init(result);
        result->no_language = string->no_language;
        result->no_encoding = string->no_encoding;
        decoder = mbfl_convert_filter_new(
          mbfl_no_encoding_wchar,
          string->no_encoding,
          mbfl_memory_device_output, 0, &device);
        encoder = mbfl_convert_filter_new(
          string->no_encoding,
          mbfl_no_encoding_wchar,
          collector_hantozen, 0, &pc);
        if (decoder == ((void *)0) || encoder == ((void *)0)) {
                mbfl_convert_filter_delete(encoder);
                mbfl_convert_filter_delete(decoder);
                return ((void *)0);
        }
        pc.next_filter = decoder;
        pc.mode = mode;
        pc.status = 0;
        pc.cache = 0;


        p = string->val;
        n = string->len;
        if (p != ((void *)0)) {
                while (n > 0) {
                        if ((*encoder->filter_function)(*p++, encoder) < 0) {
                                break;
                        }
                        n--;
                }
        }

        mbfl_convert_filter_flush(encoder);
        collector_hantozen_flush(&pc);
        mbfl_convert_filter_flush(decoder);
        result = mbfl_memory_device_result(&device, result);
        mbfl_convert_filter_delete(encoder);
        mbfl_convert_filter_delete(decoder);

        return result;
}





struct mime_header_encoder_data {
        mbfl_convert_filter *conv1_filter;
        mbfl_convert_filter *block_filter;
        mbfl_convert_filter *conv2_filter;
        mbfl_convert_filter *conv2_filter_backup;
        mbfl_convert_filter *encod_filter;
        mbfl_convert_filter *encod_filter_backup;
        mbfl_memory_device outdev;
        mbfl_memory_device tmpdev;
        int status1;
        int status2;
        int prevpos;
        int linehead;
        int firstindent;
        int encnamelen;
        int lwsplen;
        char encname[128];
        char lwsp[16];
};

static int
mime_header_encoder_block_collector(int c, void *data)
{
        int n;
        struct mime_header_encoder_data *pe = (struct mime_header_encoder_data *)data;

        switch (pe->status2) {
        case 1:
                pe->prevpos = pe->outdev.pos;
                mbfl_convert_filter_copy(pe->conv2_filter, pe->conv2_filter_backup);
                mbfl_convert_filter_copy(pe->encod_filter, pe->encod_filter_backup);
                (*pe->conv2_filter->filter_function)(c, pe->conv2_filter);
                (*pe->conv2_filter->filter_flush)(pe->conv2_filter);
                (*pe->encod_filter->filter_flush)(pe->encod_filter);
                n = pe->outdev.pos - pe->linehead + pe->firstindent;
                pe->outdev.pos = pe->prevpos;
                mbfl_convert_filter_copy(pe->conv2_filter_backup, pe->conv2_filter);
                mbfl_convert_filter_copy(pe->encod_filter_backup, pe->encod_filter);
                if (n >= 74) {
                        (*pe->conv2_filter->filter_flush)(pe->conv2_filter);
                        (*pe->encod_filter->filter_flush)(pe->encod_filter);
                        mbfl_memory_device_strncat(&pe->outdev, "\x3f\x3d", 2);
                        mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen);
                        pe->linehead = pe->outdev.pos;
                        pe->firstindent = 0;
                        mbfl_memory_device_strncat(&pe->outdev, pe->encname, pe->encnamelen);
                        c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter);
                } else {
                        c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter);
                }
                break;

        default:
                mbfl_memory_device_strncat(&pe->outdev, pe->encname, pe->encnamelen);
                c = (*pe->conv2_filter->filter_function)(c, pe->conv2_filter);
                pe->status2 = 1;
                break;
        }

        return c;
}

static int
mime_header_encoder_collector(int c, void *data)
{
        int n;
        struct mime_header_encoder_data *pe = (struct mime_header_encoder_data *)data;

        switch (pe->status1) {
        case 11:
                (*pe->block_filter->filter_function)(c, pe->block_filter);
                break;

        default:
                if (c >= 0x21 && c < 0x7f) {
                        mbfl_memory_device_output(c, &pe->tmpdev);
                        pe->status1 = 1;
                } else if (pe->status1 == 0 && c == 0x20) {
                        mbfl_memory_device_output(c, &pe->tmpdev);
                } else {
                        if (pe->tmpdev.pos < 74 && c == 0x20) {
                                n = pe->outdev.pos - pe->linehead + pe->tmpdev.pos + pe->firstindent;
                                if (n > 74) {
                                        mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen);
                                        pe->linehead = pe->outdev.pos;
                                        pe->firstindent = 0;
                                } else if (pe->outdev.pos > 0) {
                                        mbfl_memory_device_output(0x20, &pe->outdev);
                                }
                                mbfl_memory_device_devcat(&pe->outdev, &pe->tmpdev);
                                mbfl_memory_device_reset(&pe->tmpdev);
                                pe->status1 = 0;
                        } else {
                                n = pe->outdev.pos - pe->linehead + pe->encnamelen + pe->firstindent;
                                if (n > 60) {
                                        mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen);
                                        pe->linehead = pe->outdev.pos;
                                        pe->firstindent = 0;
                                } else if (pe->outdev.pos > 0) {
                                        mbfl_memory_device_output(0x20, &pe->outdev);
                                }
                                mbfl_convert_filter_devcat(pe->block_filter, &pe->tmpdev);
                                mbfl_memory_device_reset(&pe->tmpdev);
                                (*pe->block_filter->filter_function)(c, pe->block_filter);
                                pe->status1 = 11;
                        }
                }
                break;
        }

        return c;
}

mbfl_string *
mime_header_encoder_result(struct mime_header_encoder_data *pe, mbfl_string *result)
{
        if (pe->status1 >= 10) {
                (*pe->conv2_filter->filter_flush)(pe->conv2_filter);
                (*pe->encod_filter->filter_flush)(pe->encod_filter);
                mbfl_memory_device_strncat(&pe->outdev, "\x3f\x3d", 2);
        } else if (pe->tmpdev.pos > 0) {
                if (pe->outdev.pos > 0) {
                        if ((pe->outdev.pos - pe->linehead + pe->tmpdev.pos) > 74) {
                                mbfl_memory_device_strncat(&pe->outdev, pe->lwsp, pe->lwsplen);
                        } else {
                                mbfl_memory_device_output(0x20, &pe->outdev);
                        }
                }
                mbfl_memory_device_devcat(&pe->outdev, &pe->tmpdev);
        }
        mbfl_memory_device_reset(&pe->tmpdev);
        pe->prevpos = 0;
        pe->linehead = 0;
        pe->status1 = 0;
        pe->status2 = 0;

        return mbfl_memory_device_result(&pe->outdev, result);
}

struct mime_header_encoder_data*
mime_header_encoder_new(
    enum mbfl_no_encoding incode,
    enum mbfl_no_encoding outcode,
    enum mbfl_no_encoding transenc)
{
        int n;
        const char *s;
        mbfl_encoding *outencoding;
        struct mime_header_encoder_data *pe;


        outencoding = mbfl_no2encoding(outcode);
        if (outencoding == ((void *)0) || outencoding->mime_name == ((void *)0) || outencoding->mime_name[0] == '\0') {
                return ((void *)0);
        }

        pe = (struct mime_header_encoder_data*)_emalloc((sizeof(struct mime_header_encoder_data)) );
        if (pe == ((void *)0)) {
                return ((void *)0);
        }

        mbfl_memory_device_init(&pe->outdev, 0, 0);
        mbfl_memory_device_init(&pe->tmpdev, 0, 0);
        pe->prevpos = 0;
        pe->linehead = 0;
        pe->firstindent = 0;
        pe->status1 = 0;
        pe->status2 = 0;


        n = 0;
        pe->encname[n++] = 0x3d;
        pe->encname[n++] = 0x3f;
        s = outencoding->mime_name;
        while (*s) {
                pe->encname[n++] = *s++;
        }
        pe->encname[n++] = 0x3f;
        if (transenc == mbfl_no_encoding_qprint) {
                pe->encname[n++] = 0x51;
        } else {
                pe->encname[n++] = 0x42;
                transenc = mbfl_no_encoding_base64;
        }
        pe->encname[n++] = 0x3f;
        pe->encname[n] = '\0';
        pe->encnamelen = n;

        n = 0;
        pe->lwsp[n++] = 0x0d;
        pe->lwsp[n++] = 0x0a;
        pe->lwsp[n++] = 0x20;
        pe->lwsp[n] = '\0';
        pe->lwsplen = n;


        pe->encod_filter = mbfl_convert_filter_new(outcode, transenc, mbfl_memory_device_output, 0, &(pe->outdev));
        pe->encod_filter_backup = mbfl_convert_filter_new(outcode, transenc, mbfl_memory_device_output, 0, &(pe->outdev));


        pe->conv2_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter);
        pe->conv2_filter_backup = mbfl_convert_filter_new(mbfl_no_encoding_wchar, outcode, mbfl_filter_output_pipe, 0, pe->encod_filter);


        pe->block_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, mbfl_no_encoding_wchar, mime_header_encoder_block_collector, 0, pe);


        pe->conv1_filter = mbfl_convert_filter_new(incode, mbfl_no_encoding_wchar, mime_header_encoder_collector, 0, pe);

        if (pe->encod_filter == ((void *)0) ||
            pe->encod_filter_backup == ((void *)0) ||
            pe->conv2_filter == ((void *)0) ||
            pe->conv2_filter_backup == ((void *)0) ||
            pe->conv1_filter == ((void *)0)) {
                mime_header_encoder_delete(pe);
                return ((void *)0);
        }

        if (transenc == mbfl_no_encoding_qprint) {
                pe->encod_filter->status |= 0x1000000;
                pe->encod_filter_backup->status |= 0x1000000;
        } else {
                pe->encod_filter->status |= 0x1000000;
                pe->encod_filter_backup->status |= 0x1000000;
        }

        return pe;
}

void
mime_header_encoder_delete(struct mime_header_encoder_data *pe)
{
        if (pe) {
                mbfl_convert_filter_delete(pe->conv1_filter);
                mbfl_convert_filter_delete(pe->block_filter);
                mbfl_convert_filter_delete(pe->conv2_filter);
                mbfl_convert_filter_delete(pe->conv2_filter_backup);
                mbfl_convert_filter_delete(pe->encod_filter);
                mbfl_convert_filter_delete(pe->encod_filter_backup);
                mbfl_memory_device_clear(&pe->outdev);
                mbfl_memory_device_clear(&pe->tmpdev);
                _efree(((void*)pe) );
        }
}

int
mime_header_encoder_feed(int c, struct mime_header_encoder_data *pe)
{
        return (*pe->conv1_filter->filter_function)(c, pe->conv1_filter);
}

mbfl_string *
mbfl_mime_header_encode(
    mbfl_string *string,
    mbfl_string *result,
    enum mbfl_no_encoding outcode,
    enum mbfl_no_encoding encoding,
    const char *linefeed,
    int indent)
{
        int n;
        unsigned char *p;
        struct mime_header_encoder_data *pe;

        mbfl_string_init(result);
        result->no_language = string->no_language;
        result->no_encoding = mbfl_no_encoding_ascii;

        pe = mime_header_encoder_new(string->no_encoding, outcode, encoding);
        if (pe == ((void *)0)) {
                return ((void *)0);
        }

        if (linefeed != ((void *)0)) {
                n = 0;
                while (*linefeed && n < 8) {
                        pe->lwsp[n++] = *linefeed++;
                }
                pe->lwsp[n++] = 0x20;
                pe->lwsp[n] = '\0';
                pe->lwsplen = n;
        }
        if (indent > 0 && indent < 74) {
                pe->firstindent = indent;
        }

        n = string->len;
        p = string->val;
        while (n > 0) {
                (*pe->conv1_filter->filter_function)(*p++, pe->conv1_filter);
                n--;
        }

        result = mime_header_encoder_result(pe, result);
        mime_header_encoder_delete(pe);

        return result;
}





struct mime_header_decoder_data {
        mbfl_convert_filter *deco_filter;
        mbfl_convert_filter *conv1_filter;
        mbfl_convert_filter *conv2_filter;
        mbfl_memory_device outdev;
        mbfl_memory_device tmpdev;
        int cspos;
        int status;
        enum mbfl_no_encoding encoding;
        enum mbfl_no_encoding incode;
        enum mbfl_no_encoding outcode;
};

static int
mime_header_decoder_collector(int c, void* data)
{
        mbfl_encoding *encoding;
        struct mime_header_decoder_data *pd = (struct mime_header_decoder_data*)data;

        switch (pd->status) {
        case 1:
                if (c == 0x3f) {
                        mbfl_memory_device_output(c, &pd->tmpdev);
                        pd->cspos = pd->tmpdev.pos;
                        pd->status = 2;
                } else {
                        mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
                        mbfl_memory_device_reset(&pd->tmpdev);
                        if (c == 0x3d) {
                                mbfl_memory_device_output(c, &pd->tmpdev);
                        } else if (c == 0x0d || c == 0x0a) {
                                pd->status = 9;
                        } else {
                                (*pd->conv1_filter->filter_function)(c, pd->conv1_filter);
                                pd->status = 0;
                        }
                }
                break;
        case 2:
                if (c == 0x3f) {

                        mbfl_memory_device_output('\0', &pd->tmpdev);
                        encoding = mbfl_name2encoding(&pd->tmpdev.buffer[pd->cspos]);
                        if (encoding != ((void *)0)) {
                                pd->incode = encoding->no_encoding;
                                pd->status = 3;
                        }
                        mbfl_memory_device_unput(&pd->tmpdev);
                        mbfl_memory_device_output(c, &pd->tmpdev);
                } else {
                        mbfl_memory_device_output(c, &pd->tmpdev);
                        if (pd->tmpdev.pos > 100) {
                                pd->status = 0;
                        } else if (c == 0x0d || c == 0x0a) {
                                mbfl_memory_device_unput(&pd->tmpdev);
                                pd->status = 9;
                        }
                        if (pd->status != 2) {
                                mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
                                mbfl_memory_device_reset(&pd->tmpdev);
                        }
                }
                break;
        case 3:
                mbfl_memory_device_output(c, &pd->tmpdev);
                if (c == 0x42 || c == 0x62) {
                        pd->encoding = mbfl_no_encoding_base64;
                        pd->status = 4;
                } else if (c == 0x51 || c == 0x71) {
                        pd->encoding = mbfl_no_encoding_qprint;
                        pd->status = 4;
                } else {
                        if (c == 0x0d || c == 0x0a) {
                                mbfl_memory_device_unput(&pd->tmpdev);
                                pd->status = 9;
                        } else {
                                pd->status = 0;
                        }
                        mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
                        mbfl_memory_device_reset(&pd->tmpdev);
                }
                break;
        case 4:
                mbfl_memory_device_output(c, &pd->tmpdev);
                if (c == 0x3f) {

                        mbfl_convert_filter_reset(pd->conv1_filter, pd->incode, mbfl_no_encoding_wchar);

                        mbfl_convert_filter_reset(pd->deco_filter, pd->encoding, mbfl_no_encoding_8bit);
                        pd->status = 5;
                } else {
                        if (c == 0x0d || c == 0x0a) {
                                mbfl_memory_device_unput(&pd->tmpdev);
                                pd->status = 9;
                        } else {
                                pd->status = 0;
                        }
                        mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
                }
                mbfl_memory_device_reset(&pd->tmpdev);
                break;
        case 5:
                if (c == 0x3f) {
                        pd->status = 6;
                } else {
                        (*pd->deco_filter->filter_function)(c, pd->deco_filter);
                }
                break;
        case 6:
                if (c == 0x3d) {

                        (*pd->deco_filter->filter_flush)(pd->deco_filter);
                        (*pd->conv1_filter->filter_flush)(pd->conv1_filter);
                        mbfl_convert_filter_reset(pd->conv1_filter, mbfl_no_encoding_ascii, mbfl_no_encoding_wchar);
                        pd->status = 7;
                } else {
                        (*pd->deco_filter->filter_function)(0x3f, pd->deco_filter);
                        if (c != 0x3f) {
                                (*pd->deco_filter->filter_function)(c, pd->deco_filter);
                                pd->status = 5;
                        }
                }
                break;
        case 7:
                if (c == 0x0d || c == 0x0a) {
                        pd->status = 8;
                } else {
                        mbfl_memory_device_output(c, &pd->tmpdev);
                        if (c == 0x3d) {
                                pd->status = 1;
                        } else if (c != 0x20 && c != 0x09) {
                                mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
                                mbfl_memory_device_reset(&pd->tmpdev);
                                pd->status = 0;
                        }
                }
                break;
        case 8:
        case 9:
                if (c != 0x0d && c != 0x0a && c != 0x20 && c != 0x09) {
                        if (c == 0x3d) {
                                if (pd->status == 8) {
                                        mbfl_memory_device_output(0x20, &pd->tmpdev);
                                } else {
                                        (*pd->conv1_filter->filter_function)(0x20, pd->conv1_filter);
                                }
                                mbfl_memory_device_output(c, &pd->tmpdev);
                                pd->status = 1;
                        } else {
                                mbfl_memory_device_output(0x20, &pd->tmpdev);
                                mbfl_memory_device_output(c, &pd->tmpdev);
                                mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
                                mbfl_memory_device_reset(&pd->tmpdev);
                                pd->status = 0;
                        }
                }
                break;
        default:
                if (c == 0x0d || c == 0x0a) {
                        pd->status = 9;
                } else if (c == 0x3d) {
                        mbfl_memory_device_output(c, &pd->tmpdev);
                        pd->status = 1;
                } else {
                        (*pd->conv1_filter->filter_function)(c, pd->conv1_filter);
                }
                break;
        }

        return c;
}

mbfl_string *
mime_header_decoder_result(struct mime_header_decoder_data *pd, mbfl_string *result)
{
        switch (pd->status) {
        case 1:
        case 2:
        case 3:
        case 4:
        case 7:
        case 8:
        case 9:
                mbfl_convert_filter_devcat(pd->conv1_filter, &pd->tmpdev);
                break;
        case 5:
        case 6:
                (*pd->deco_filter->filter_flush)(pd->deco_filter);
                (*pd->conv1_filter->filter_flush)(pd->conv1_filter);
                break;
        }
        (*pd->conv2_filter->filter_flush)(pd->conv2_filter);
        mbfl_memory_device_reset(&pd->tmpdev);
        pd->status = 0;

        return mbfl_memory_device_result(&pd->outdev, result);
}

struct mime_header_decoder_data*
mime_header_decoder_new(enum mbfl_no_encoding outcode)
{
        struct mime_header_decoder_data *pd;

        pd = (struct mime_header_decoder_data*)_emalloc((sizeof(struct mime_header_decoder_data)) );
        if (pd == ((void *)0)) {
                return ((void *)0);
        }

        mbfl_memory_device_init(&pd->outdev, 0, 0);
        mbfl_memory_device_init(&pd->tmpdev, 0, 0);
        pd->cspos = 0;
        pd->status = 0;
        pd->encoding = mbfl_no_encoding_pass;
        pd->incode = mbfl_no_encoding_ascii;
        pd->outcode = outcode;

        pd->conv2_filter = mbfl_convert_filter_new(mbfl_no_encoding_wchar, pd->outcode, mbfl_memory_device_output, 0, &pd->outdev);
        pd->conv1_filter = mbfl_convert_filter_new(pd->incode, mbfl_no_encoding_wchar, mbfl_filter_output_pipe, 0, pd->conv2_filter);

        pd->deco_filter = mbfl_convert_filter_new(pd->encoding, mbfl_no_encoding_8bit, mbfl_filter_output_pipe, 0, pd->conv1_filter);

        if (pd->conv1_filter == ((void *)0) || pd->conv2_filter == ((void *)0) || pd->deco_filter == ((void *)0)) {
                mime_header_decoder_delete(pd);
                return ((void *)0);
        }

        return pd;
}

void
mime_header_decoder_delete(struct mime_header_decoder_data *pd)
{
        if (pd) {
                mbfl_convert_filter_delete(pd->conv2_filter);
                mbfl_convert_filter_delete(pd->conv1_filter);
                mbfl_convert_filter_delete(pd->deco_filter);
                mbfl_memory_device_clear(&pd->outdev);
                mbfl_memory_device_clear(&pd->tmpdev);
                _efree(((void*)pd) );
        }
}

int
mime_header_decoder_feed(int c, struct mime_header_decoder_data *pd)
{
        return mime_header_decoder_collector(c, pd);
}

mbfl_string *
mbfl_mime_header_decode(
    mbfl_string *string,
    mbfl_string *result,
    enum mbfl_no_encoding outcode)
{
        int n;
        unsigned char *p;
        struct mime_header_decoder_data *pd;

        mbfl_string_init(result);
        result->no_language = string->no_language;
        result->no_encoding = outcode;

        pd = mime_header_decoder_new(outcode);
        if (pd == ((void *)0)) {
                return ((void *)0);
        }


        n = string->len;
        p = string->val;
        while (n > 0) {
                mime_header_decoder_collector(*p++, pd);
                n--;
        }

        result = mime_header_decoder_result(pd, result);
        mime_header_decoder_delete(pd);

        return result;
}






struct collector_htmlnumericentity_data {
        mbfl_convert_filter *decoder;
        int status;
        int cache;
        int digit;
        int *convmap;
        int mapsize;
};

static int
collector_encode_htmlnumericentity(int c, void *data)
{
        struct collector_htmlnumericentity_data *pc = (struct collector_htmlnumericentity_data *)data;
        int f, n, s, r, d, size, *mapelm;

        size = pc->mapsize;
        f = 0;
        n = 0;
        while (n < size) {
                mapelm = &(pc->convmap[n*4]);
                if (c >= mapelm[0] && c <= mapelm[1]) {
                        s = (c + mapelm[2]) & mapelm[3];
                        if (s >= 0) {
                                (*pc->decoder->filter_function)(0x26, pc->decoder);
                                (*pc->decoder->filter_function)(0x23, pc->decoder);
                                r = 100000000;
                                s %= r;
                                while (r > 0) {
                                        d = s/r;
                                        if (d || f) {
                                                f = 1;
                                                s %= r;
                                                (*pc->decoder->filter_function)(mbfl_hexchar_table[d], pc->decoder);
                                        }
                                        r /= 10;
                                }
                                if (!f) {
                                        f = 1;
                                        (*pc->decoder->filter_function)(mbfl_hexchar_table[0], pc->decoder);
                                }
                                (*pc->decoder->filter_function)(0x3b, pc->decoder);
                        }
                }
                if (f) {
                        break;
                }
                n++;
        }
        if (!f) {
                (*pc->decoder->filter_function)(c, pc->decoder);
        }

        return c;
}

static int
collector_decode_htmlnumericentity(int c, void *data)
{
        struct collector_htmlnumericentity_data *pc = (struct collector_htmlnumericentity_data *)data;
        int f, n, s, r, d, size, *mapelm;

        switch (pc->status) {
        case 1:
                if (c == 0x23) {
                        pc->status = 2;
                } else {
                        pc->status = 0;
                        (*pc->decoder->filter_function)(0x26, pc->decoder);
                        (*pc->decoder->filter_function)(c, pc->decoder);
                }
                break;
        case 2:
                if (c >= 0x30 && c <= 0x39) {
                        pc->cache = c - 0x30;
                        pc->status = 3;
                        pc->digit = 1;
                } else {
                        pc->status = 0;
                        (*pc->decoder->filter_function)(0x26, pc->decoder);
                        (*pc->decoder->filter_function)(0x23, pc->decoder);
                        (*pc->decoder->filter_function)(c, pc->decoder);
                }
                break;
        case 3:
                s = 0;
                f = 0;
                if (c >= 0x30 && c <= 0x39) {
                        if (pc->digit > 9) {
                                pc->status = 0;
                                s = pc->cache;
                                f = 1;
                        } else {
                                s = pc->cache*10 + c - 0x30;
                                pc->cache = s;
                                pc->digit++;
                        }
                } else {
                        pc->status = 0;
                        s = pc->cache;
                        f = 1;
                        n = 0;
                        size = pc->mapsize;
                        while (n < size) {
                                mapelm = &(pc->convmap[n*4]);
                                d = s - mapelm[2];
                                if (d >= mapelm[0] && d <= mapelm[1]) {
                                        f = 0;
                                        (*pc->decoder->filter_function)(d, pc->decoder);
                                        if (c != 0x3b) {
                                                (*pc->decoder->filter_function)(c, pc->decoder);
                                        }
                                        break;
                                }
                                n++;
                        }
                }
                if (f) {
                        (*pc->decoder->filter_function)(0x26, pc->decoder);
                        (*pc->decoder->filter_function)(0x23, pc->decoder);
                        r = 1;
                        n = pc->digit;
                        while (n > 0) {
                                r *= 10;
                                n--;
                        }
                        s %= r;
                        r /= 10;
                        while (r > 0) {
                                d = s/r;
                                s %= r;
                                r /= 10;
                                (*pc->decoder->filter_function)(mbfl_hexchar_table[d], pc->decoder);
                        }
                        (*pc->decoder->filter_function)(c, pc->decoder);
                }
                break;
        default:
                if (c == 0x26) {
                        pc->status = 1;
                } else {
                        (*pc->decoder->filter_function)(c, pc->decoder);
                }
                break;
        }

        return c;
}

mbfl_string *
mbfl_html_numeric_entity(
    mbfl_string *string,
    mbfl_string *result,
    int *convmap,
    int mapsize,
    int type)
{
        struct collector_htmlnumericentity_data pc;
        mbfl_memory_device device;
        mbfl_convert_filter *encoder;
        int n;
        unsigned char *p;

        if (string == ((void *)0) || result == ((void *)0)) {
                return ((void *)0);
        }
        mbfl_string_init(result);
        result->no_language = string->no_language;
        result->no_encoding = string->no_encoding;
        mbfl_memory_device_init(&device, string->len, 0);


        pc.decoder = mbfl_convert_filter_new(
            mbfl_no_encoding_wchar,
            string->no_encoding,
            mbfl_memory_device_output, 0, &device);

        if (type == 0) {
                encoder = mbfl_convert_filter_new(
                    string->no_encoding,
                    mbfl_no_encoding_wchar,
                    collector_encode_htmlnumericentity, 0, &pc);
        } else {
                encoder = mbfl_convert_filter_new(
                    string->no_encoding,
                    mbfl_no_encoding_wchar,
                    collector_decode_htmlnumericentity, 0, &pc);
        }
        if (pc.decoder == ((void *)0) || encoder == ((void *)0)) {
                mbfl_convert_filter_delete(encoder);
                mbfl_convert_filter_delete(pc.decoder);
                return ((void *)0);
        }
        pc.status = 0;
        pc.cache = 0;
        pc.digit = 0;
        pc.convmap = convmap;
        pc.mapsize = mapsize;


        p = string->val;
        n = string->len;
        if (p != ((void *)0)) {
                while (n > 0) {
                        if ((*encoder->filter_function)(*p++, encoder) < 0) {
                                break;
                        }
                        n--;
                }
        }
        mbfl_convert_filter_flush(encoder);
        mbfl_convert_filter_flush(pc.decoder);
        result = mbfl_memory_device_result(&device, result);
        mbfl_convert_filter_delete(encoder);
        mbfl_convert_filter_delete(pc.decoder);

        return result;
}
# 8025 "mbfilter.c"
static const unsigned short iso8859_2_ucs_table[] = {
 0x00A0,0x0104,0x02D8,0x0141,0x00A4,0x013D,0x015A,0x00A7,
 0x00A8,0x0160,0x015E,0x0164,0x0179,0x00AD,0x017D,0x017B,
 0x00B0,0x0105,0x02DB,0x0142,0x00B4,0x013E,0x015B,0x02C7,
 0x00B8,0x0161,0x015F,0x0165,0x017A,0x02DD,0x017E,0x017C,
 0x0154,0x00C1,0x00C2,0x0102,0x00C4,0x0139,0x0106,0x00C7,
 0x010C,0x00C9,0x0118,0x00CB,0x011A,0x00CD,0x00CE,0x010E,
 0x0110,0x0143,0x0147,0x00D3,0x00D4,0x0150,0x00D6,0x00D7,
 0x0158,0x016E,0x00DA,0x0170,0x00DC,0x00DD,0x0162,0x00DF,
 0x0155,0x00E1,0x00E2,0x0103,0x00E4,0x013A,0x0107,0x00E7,
 0x010D,0x00E9,0x0119,0x00EB,0x011B,0x00ED,0x00EE,0x010F,
 0x0111,0x0144,0x0148,0x00F3,0x00F4,0x0151,0x00F6,0x00F7,
 0x0159,0x016F,0x00FA,0x0171,0x00FC,0x00FD,0x0163,0x02D9
};


static const unsigned short iso8859_3_ucs_table[] = {
 0x00A0,0x0126,0x02D8,0x00A3,0x00A4,0x0000,0x0124,0x00A7,
 0x00A8,0x0130,0x015E,0x011E,0x0134,0x00AD,0x0000,0x017B,
 0x00B0,0x0127,0x00B2,0x00B3,0x00B4,0x00B5,0x0125,0x00B7,
 0x00B8,0x0131,0x015F,0x011F,0x0135,0x00BD,0x0000,0x017C,
 0x00C0,0x00C1,0x00C2,0x0000,0x00C4,0x010A,0x0108,0x00C7,
 0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,0x00CD,0x00CE,0x00CF,
 0x0000,0x00D1,0x00D2,0x00D3,0x00D4,0x0120,0x00D6,0x00D7,
 0x011C,0x00D9,0x00DA,0x00DB,0x00DC,0x016C,0x015C,0x00DF,
 0x00E0,0x00E1,0x00E2,0x0000,0x00E4,0x010B,0x0109,0x00E7,
 0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,
 0x0000,0x00F1,0x00F2,0x00F3,0x00F4,0x0121,0x00F6,0x00F7,
 0x011D,0x00F9,0x00FA,0x00FB,0x00FC,0x016D,0x015D,0x02D9
};


static const unsigned short iso8859_4_ucs_table[] = {
 0x00A0,0x0104,0x0138,0x0156,0x00A4,0x0128,0x013B,0x00A7,
 0x00A8,0x0160,0x0112,0x0122,0x0166,0x00AD,0x017D,0x00AF,
 0x00B0,0x0105,0x02DB,0x0157,0x00B4,0x0129,0x013C,0x02C7,
 0x00B8,0x0161,0x0113,0x0123,0x0167,0x014A,0x017E,0x014B,
 0x0100,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x012E,
 0x010C,0x00C9,0x0118,0x00CB,0x0116,0x00CD,0x00CE,0x012A,
 0x0110,0x0145,0x014C,0x0136,0x00D4,0x00D5,0x00D6,0x00D7,
 0x00D8,0x0172,0x00DA,0x00DB,0x00DC,0x0168,0x016A,0x00DF,
 0x0101,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x012F,
 0x010D,0x00E9,0x0119,0x00EB,0x0117,0x00ED,0x00EE,0x012B,
 0x0111,0x0146,0x014D,0x0137,0x00F4,0x00F5,0x00F6,0x00F7,
 0x00F8,0x0173,0x00FA,0x00FB,0x00FC,0x0169,0x016B,0x02D9
};


static const unsigned short iso8859_5_ucs_table[] = {
 0x00A0,0x0401,0x0402,0x0403,0x0404,0x0405,0x0406,0x0407,
 0x0408,0x0409,0x040A,0x040B,0x040C,0x00AD,0x040E,0x040F,
 0x0410,0x0411,0x0412,0x0413,0x0414,0x0415,0x0416,0x0417,
 0x0418,0x0419,0x041A,0x041B,0x041C,0x041D,0x041E,0x041F,
 0x0420,0x0421,0x0422,0x0423,0x0424,0x0425,0x0426,0x0427,
 0x0428,0x0429,0x042A,0x042B,0x042C,0x042D,0x042E,0x042F,
 0x0430,0x0431,0x0432,0x0433,0x0434,0x0435,0x0436,0x0437,
 0x0438,0x0439,0x043A,0x043B,0x043C,0x043D,0x043E,0x043F,
 0x0440,0x0441,0x0442,0x0443,0x0444,0x0445,0x0446,0x0447,
 0x0448,0x0449,0x044A,0x044B,0x044C,0x044D,0x044E,0x044F,
 0x2116,0x0451,0x0452,0x0453,0x0454,0x0455,0x0456,0x0457,
 0x0458,0x0459,0x045A,0x045B,0x045C,0x00A7,0x045E,0x045F
};


static const unsigned short iso8859_6_ucs_table[] = {
 0x00A0,0x0000,0x0000,0x0000,0x00A4,0x0000,0x0000,0x0000,
 0x0000,0x0000,0x0000,0x0000,0x060C,0x00AD,0x0000,0x0000,
 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
 0x0000,0x0000,0x0000,0x061B,0x0000,0x0000,0x0000,0x061F,
 0x0000,0x0621,0x0622,0x0623,0x0624,0x0625,0x0626,0x0627,
 0x0628,0x0629,0x062A,0x062B,0x062C,0x062D,0x062E,0x062F,
 0x0630,0x0631,0x0632,0x0633,0x0634,0x0635,0x0636,0x0637,
 0x0638,0x0639,0x063A,0x0000,0x0000,0x0000,0x0000,0x0000,
 0x0640,0x0641,0x0642,0x0643,0x0644,0x0645,0x0646,0x0647,
 0x0648,0x0649,0x064A,0x064B,0x064C,0x064D,0x064E,0x064F,
 0x0650,0x0651,0x0652,0x0000,0x0000,0x0000,0x0000,0x0000,
 0x0000,0x0000,0x0000,0x0000,0x060C,0x00AD,0x0000,0x0000
};


static const unsigned short iso8859_7_ucs_table[] = {
 0x00A0,0x2018,0x2019,0x00A3,0x0000,0x0000,0x00A6,0x00A7,
 0x00A8,0x00A9,0x0000,0x00AB,0x00AC,0x00AD,0x0000,0x2015,
 0x00B0,0x00B1,0x00B2,0x00B3,0x0384,0x0385,0x0386,0x00B7,
 0x0388,0x0389,0x038A,0x00BB,0x038C,0x00BD,0x038E,0x038F,
 0x0390,0x0391,0x0392,0x0393,0x0394,0x0395,0x0396,0x0397,
 0x0398,0x0399,0x039A,0x039B,0x039C,0x039D,0x039E,0x039F,
 0x03A0,0x03A1,0x0000,0x03A3,0x03A4,0x03A5,0x03A6,0x03A7,
 0x03A8,0x03A9,0x03AA,0x03AB,0x03AC,0x03AD,0x03AE,0x03AF,
 0x03B0,0x03B1,0x03B2,0x03B3,0x03B4,0x03B5,0x03B6,0x03B7,
 0x03B8,0x03B9,0x03BA,0x03BB,0x03BC,0x03BD,0x03BE,0x03BF,
 0x03C0,0x03C1,0x03C2,0x03C3,0x03C4,0x03C5,0x03C6,0x03C7,
 0x03C8,0x03C9,0x03CA,0x03CB,0x03CC,0x03CD,0x03CE,0x0000
};


static const unsigned short iso8859_8_ucs_table[] = {
 0x00A0,0x0000,0x00A2,0x00A3,0x00A4,0x00A5,0x00A6,0x00A7,
 0x00A8,0x00A9,0x00D7,0x00AB,0x00AC,0x00AD,0x00AE,0x203E,
 0x00B0,0x00B1,0x00B2,0x00B3,0x00B4,0x00B5,0x00B6,0x00B7,
 0x00B8,0x00B9,0x00F7,0x00BB,0x00BC,0x00BD,0x00BE,0x0000,
 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x2017,
 0x05D0,0x05D1,0x05D2,0x05D3,0x05D4,0x05D5,0x05D6,0x05D7,
 0x05D8,0x05D9,0x05DA,0x05DB,0x05DC,0x05DD,0x05DE,0x05DF,
 0x05E0,0x05E1,0x05E2,0x05E3,0x05E4,0x05E5,0x05E6,0x05E7,
 0x05E8,0x05E9,0x05EA,0x0000,0x0000,0x0000,0x0000,0x0000
};


static const unsigned short iso8859_9_ucs_table[] = {
 0x00A0,0x00A1,0x00A2,0x00A3,0x00A4,0x00A5,0x00A6,0x00A7,
 0x00A8,0x00A9,0x00AA,0x00AB,0x00AC,0x00AD,0x00AE,0x00AF,
 0x00B0,0x00B1,0x00B2,0x00B3,0x00B4,0x00B5,0x00B6,0x00B7,
 0x00B8,0x00B9,0x00BA,0x00BB,0x00BC,0x00BD,0x00BE,0x00BF,
 0x00C0,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x00C7,
 0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,0x00CD,0x00CE,0x00CF,
 0x011E,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D7,
 0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x0130,0x015E,0x00DF,
 0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,
 0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,
 0x011F,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F7,
 0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x0131,0x015F,0x00FF
};


static const unsigned short iso8859_10_ucs_table[] = {
 0x00A0,0x0104,0x0112,0x0122,0x0124,0x0128,0x0136,0x00A7,
 0x013B,0x0110,0x0160,0x0166,0x017D,0x00AD,0x016A,0x014A,
 0x00B0,0x0105,0x0113,0x0123,0x012B,0x0129,0x0137,0x00B7,
 0x013C,0x0111,0x0161,0x0167,0x017E,0x2015,0x016B,0x014B,
 0x0100,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x012E,
 0x010C,0x00C9,0x0118,0x00CB,0x0116,0x00CD,0x00CE,0x00CF,
 0x00D0,0x0145,0x014C,0x00D3,0x00D4,0x00D5,0x00D6,0x0168,
 0x00D8,0x0172,0x00DA,0x00DB,0x00DC,0x00DD,0x00DE,0x00DF,
 0x0101,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x012F,
 0x010D,0x00E9,0x0119,0x00EB,0x0117,0x00ED,0x00EE,0x00EF,
 0x00F0,0x0146,0x014D,0x00F3,0x00F4,0x00F5,0x00F6,0x0169,
 0x00F8,0x0173,0x00FA,0x00FB,0x00FC,0x00FD,0x00FE,0x0138
};


static const unsigned short iso8859_13_ucs_table[] = {
 0x00A0,0x201D,0x00A2,0x00A3,0x00A4,0x201E,0x00A6,0x00A7,
 0x00D8,0x00A9,0x0156,0x00AB,0x00AC,0x00AD,0x00AE,0x00C6,
 0x00B0,0x00B1,0x00B2,0x00B3,0x201C,0x00B5,0x00B6,0x00B7,
 0x00F8,0x00B9,0x0157,0x00BB,0x00BC,0x00BD,0x00BE,0x00E6,
 0x0104,0x012E,0x0100,0x0106,0x00C4,0x00C5,0x0118,0x0112,
 0x010C,0x00C9,0x0179,0x0116,0x0122,0x0136,0x012A,0x013B,
 0x0160,0x0143,0x0145,0x00D3,0x014C,0x00D5,0x00D6,0x00D7,
 0x0172,0x0141,0x015A,0x016A,0x00DC,0x017B,0x017D,0x00DF,
 0x0105,0x012F,0x0101,0x0107,0x00E4,0x00E5,0x0119,0x0113,
 0x010D,0x00E9,0x017A,0x0117,0x0123,0x0137,0x012B,0x013C,
 0x0161,0x0144,0x0146,0x00F3,0x014D,0x00F5,0x00F6,0x00F7,
 0x0173,0x0142,0x015B,0x016B,0x00FC,0x017C,0x017E,0x2019
};


static const unsigned short iso8859_14_ucs_table[] = {
 0x00A0,0x1E02,0x1E03,0x00A3,0x010A,0x010B,0x1E0A,0x00A7,
 0x1E80,0x00A9,0x1E82,0x1E0B,0x1EF2,0x00AD,0x00AE,0x0178,
 0x1E1E,0x1E1F,0x0120,0x0121,0x1E40,0x1E41,0x00B6,0x1E56,
 0x1E81,0x1E57,0x1E83,0x1E60,0x1EF3,0x1E84,0x1E85,0x1E61,
 0x00C0,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x00C7,
 0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,0x00CD,0x00CE,0x00CF,
 0x0174,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x1E6A,
 0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x00DD,0x0176,0x00DF,
 0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,
 0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,
 0x0175,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x1E6B,
 0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x00FD,0x0177,0x00FF
};


static const unsigned short iso8859_15_ucs_table[] = {
 0x00A0,0x00A1,0x00A2,0x00A3,0x20AC,0x00A5,0x0160,0x00A7,
 0x0161,0x00A9,0x00AA,0x00AB,0x00AC,0x00AD,0x00AE,0x00AF,
 0x00B0,0x00B1,0x00B2,0x00B3,0x017D,0x00B5,0x00B6,0x00B7,
 0x017E,0x00B9,0x00BA,0x00BB,0x0152,0x0153,0x0178,0x00BF,
 0x00C0,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x00C6,0x00C7,
 0x00C8,0x00C9,0x00CA,0x00CB,0x00CC,0x00CD,0x00CE,0x00CF,
 0x00D0,0x00D1,0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D7,
 0x00D8,0x00D9,0x00DA,0x00DB,0x00DC,0x00DD,0x00DE,0x00DF,
 0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x00E6,0x00E7,
 0x00E8,0x00E9,0x00EA,0x00EB,0x00EC,0x00ED,0x00EE,0x00EF,
 0x00F0,0x00F1,0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F7,
 0x00F8,0x00F9,0x00FA,0x00FB,0x00FC,0x00FD,0x00FE,0x00FF
};


static const unsigned char mbfl_charprop_table[] = {
                0x01 | 0x10,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x01 | 0x10 ,
                0x10 ,
                0 ,
                0x10 | 0x20 ,
                0x10 ,
                0x10 ,
                0x10 ,
                0x10 ,
                0x10 ,
                0x10 | 0x20 ,
                0x10 | 0x20 ,
                0 ,
                0 ,
                0x10 | 0x20 ,
                0 ,
                0x10 | 0x20 ,
                0 ,
                0x02 | 0x10 ,
                0x02 | 0x10 ,
                0x02 | 0x10 ,
                0x02 | 0x10 ,
                0x02 | 0x10 ,
                0x02 | 0x10 ,
                0x02 | 0x10 ,
                0x02 | 0x10 ,
                0x02 | 0x10 ,
                0x02 | 0x10 ,
                0x10 | 0x20 ,
                0x10 | 0x20 ,
                0x10 | 0x20 ,
                0 ,
                0x10 | 0x20 ,
                0x10 ,
                0x10 | 0x20 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x04 ,
                0x10 | 0x20 ,
                0x10 | 0x20 ,
                0x10 | 0x20 ,
                0x10 ,
                0x10 ,
                0x10 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x08 ,
                0x10 ,
                0x10 ,
                0x10 ,
                0x10 ,
                0x10
};
	----preprocessor output for mbfilter.c --- end ---
>Fix:
	
>Release-Note:
>Audit-Trail:
>Unformatted:


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]