Return to mbfl_convert.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mbstring / libmbfl / mbfl

Annotation of embedaddon/php/ext/mbstring/libmbfl/mbfl/mbfl_convert.h, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * "streamable kanji code filter and converter"
                      3:  * Copyright (c) 1998-2002 HappySize, Inc. All rights reserved.
                      4:  *
                      5:  * LICENSE NOTICES
                      6:  *
                      7:  * This file is part of "streamable kanji code filter and converter",
                      8:  * which is distributed under the terms of GNU Lesser General Public 
                      9:  * License (version 2) as published by the Free Software Foundation.
                     10:  *
                     11:  * This software is distributed in the hope that it will be useful,
                     12:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
                     13:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     14:  * GNU Lesser General Public License for more details.
                     15:  *
                     16:  * You should have received a copy of the GNU Lesser General Public
                     17:  * License along with "streamable kanji code filter and converter";
                     18:  * if not, write to the Free Software Foundation, Inc., 59 Temple Place,
                     19:  * Suite 330, Boston, MA  02111-1307  USA
                     20:  *
                     21:  * The author of this file:
                     22:  *
                     23:  */
                     24: /*
                     25:  * The source code included in this files was separated from mbfilter.h
                     26:  * by Moriyoshi Koizumi <moriyoshi@php.net> on 20 Dec 2002. The file
                     27:  * mbfilter.h is included in this package .
                     28:  *
                     29:  */
                     30: 
                     31: #ifndef MBFL_CONVERT_H
                     32: #define MBFL_CONVERT_H
                     33: 
                     34: #include "mbfl_defs.h"
                     35: #include "mbfl_encoding.h"
                     36: #include "mbfl_memory_device.h"
                     37: 
                     38: typedef struct _mbfl_convert_filter mbfl_convert_filter;
                     39: 
                     40: struct _mbfl_convert_filter {
                     41:        void (*filter_ctor)(mbfl_convert_filter *filter);
                     42:        void (*filter_dtor)(mbfl_convert_filter *filter);
                     43:        void (*filter_copy)(mbfl_convert_filter *src, mbfl_convert_filter *dest);
                     44:        int (*filter_function)(int c, mbfl_convert_filter *filter);
                     45:        int (*filter_flush)(mbfl_convert_filter *filter);
                     46:        int (*output_function)(int c, void *data);
                     47:        int (*flush_function)(void *data);
                     48:        void *data;
                     49:        int status;
                     50:        int cache;
                     51:        const mbfl_encoding *from;
                     52:        const mbfl_encoding *to;
                     53:        int illegal_mode;
                     54:        int illegal_substchar;
                     55:        int num_illegalchar;
                     56:        void *opaque;
                     57: };
                     58: 
                     59: struct mbfl_convert_vtbl {
                     60:        enum mbfl_no_encoding from;
                     61:        enum mbfl_no_encoding to;
                     62:        void (*filter_ctor)(mbfl_convert_filter *filter);
                     63:        void (*filter_dtor)(mbfl_convert_filter *filter);
                     64:        int (*filter_function)(int c, mbfl_convert_filter *filter);
                     65:        int (*filter_flush)(mbfl_convert_filter *filter);
                     66:        void (*filter_copy)(mbfl_convert_filter *src, mbfl_convert_filter *dest);
                     67: };
                     68: 
                     69: MBFLAPI extern const struct mbfl_convert_vtbl *mbfl_convert_filter_list[];
                     70: 
                     71: MBFLAPI extern mbfl_convert_filter *mbfl_convert_filter_new(
                     72:     enum mbfl_no_encoding from,
                     73:     enum mbfl_no_encoding to,
                     74:     int (*output_function)(int, void *),
                     75:     int (*flush_function)(void *),
                     76:     void *data );
                     77: MBFLAPI extern mbfl_convert_filter *mbfl_convert_filter_new2(
                     78:        const struct mbfl_convert_vtbl *vtbl,
                     79:     int (*output_function)(int, void *),
                     80:     int (*flush_function)(void *),
                     81:     void *data );
                     82: MBFLAPI extern void mbfl_convert_filter_delete(mbfl_convert_filter *filter);
                     83: MBFLAPI extern int mbfl_convert_filter_feed(int c, mbfl_convert_filter *filter);
                     84: MBFLAPI extern int mbfl_convert_filter_flush(mbfl_convert_filter *filter);
                     85: MBFLAPI extern void mbfl_convert_filter_reset(mbfl_convert_filter *filter, enum mbfl_no_encoding from, enum mbfl_no_encoding to);
                     86: MBFLAPI extern void mbfl_convert_filter_copy(mbfl_convert_filter *src, mbfl_convert_filter *dist);
                     87: MBFLAPI extern int mbfl_filt_conv_illegal_output(int c, mbfl_convert_filter *filter);
                     88: MBFLAPI extern const struct mbfl_convert_vtbl * mbfl_convert_filter_get_vtbl(enum mbfl_no_encoding from, enum mbfl_no_encoding to);
                     89: 
                     90: MBFLAPI extern void mbfl_filt_conv_common_ctor(mbfl_convert_filter *filter);
                     91: MBFLAPI extern int mbfl_filt_conv_common_flush(mbfl_convert_filter *filter);
                     92: MBFLAPI extern void mbfl_filt_conv_common_dtor(mbfl_convert_filter *filter);
                     93: 
                     94: MBFLAPI extern int mbfl_convert_filter_devcat(mbfl_convert_filter *filter, mbfl_memory_device *src);
                     95: MBFLAPI extern int mbfl_convert_filter_strcat(mbfl_convert_filter *filter, const unsigned char *p);
                     96: 
                     97: #endif /* MBFL_CONVERT_H */