Return to mbfilter_byte4.c CVS log

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

Annotation of embedaddon/php/ext/mbstring/libmbfl/filters/mbfilter_byte4.c, 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.c
                     26:  * by Moriyoshi Koizumi <moriyoshi@php.net> on 4 Dec 2002. The file
                     27:  * mbfilter.c is included in this package .
                     28:  *
                     29:  */
                     30: 
                     31: #ifdef HAVE_CONFIG_H
                     32: #include "config.h"
                     33: #endif
                     34: 
                     35: #include "mbfilter.h"
                     36: #include "mbfilter_byte4.h"
                     37: 
                     38: const mbfl_encoding mbfl_encoding_byte4be = {
                     39:        mbfl_no_encoding_byte4be,
                     40:        "byte4be",
                     41:        NULL,
                     42:        NULL,
                     43:        NULL,
                     44:        MBFL_ENCTYPE_SBCS
                     45: };
                     46: 
                     47: const mbfl_encoding mbfl_encoding_byte4le = {
                     48:        mbfl_no_encoding_byte4le,
                     49:        "byte4le",
                     50:        NULL,
                     51:        NULL,
                     52:        NULL,
                     53:        MBFL_ENCTYPE_SBCS
                     54: };
                     55: 
                     56: const struct mbfl_convert_vtbl vtbl_byte4be_wchar = {
                     57:        mbfl_no_encoding_byte4be,
                     58:        mbfl_no_encoding_wchar,
                     59:        mbfl_filt_conv_common_ctor,
                     60:        mbfl_filt_conv_common_dtor,
                     61:        mbfl_filt_conv_byte4be_wchar,
                     62:        mbfl_filt_conv_common_flush
                     63: };
                     64: 
                     65: const struct mbfl_convert_vtbl vtbl_wchar_byte4be = {
                     66:        mbfl_no_encoding_wchar,
                     67:        mbfl_no_encoding_byte4be,
                     68:        mbfl_filt_conv_common_ctor,
                     69:        mbfl_filt_conv_common_dtor,
                     70:        mbfl_filt_conv_wchar_byte4be,
                     71:        mbfl_filt_conv_common_flush };
                     72: 
                     73: const struct mbfl_convert_vtbl vtbl_byte4le_wchar = {
                     74:        mbfl_no_encoding_byte4le,
                     75:        mbfl_no_encoding_wchar,
                     76:        mbfl_filt_conv_common_ctor,
                     77:        mbfl_filt_conv_common_dtor,
                     78:        mbfl_filt_conv_byte4le_wchar,
                     79:        mbfl_filt_conv_common_flush
                     80: };
                     81: 
                     82: const struct mbfl_convert_vtbl vtbl_wchar_byte4le = {
                     83:        mbfl_no_encoding_wchar,
                     84:        mbfl_no_encoding_byte4le,
                     85:        mbfl_filt_conv_common_ctor,
                     86:        mbfl_filt_conv_common_dtor,
                     87:        mbfl_filt_conv_wchar_byte4le,
                     88:        mbfl_filt_conv_common_flush
                     89: };
                     90: 
                     91: #define CK(statement)  do { if ((statement) < 0) return (-1); } while (0)
                     92: 
                     93: int mbfl_filt_conv_byte4be_wchar(int c, mbfl_convert_filter *filter)
                     94: {
                     95:        int n;
                     96: 
                     97:        if (filter->status == 0) {
                     98:                filter->status = 1;
                     99:                n = (c & 0xff) << 24;
                    100:                filter->cache = n;
                    101:        } else if (filter->status == 1) {
                    102:                filter->status = 2;
                    103:                n = (c & 0xff) << 16;
                    104:                filter->cache |= n;
                    105:        } else if (filter->status == 2) {
                    106:                filter->status = 3;
                    107:                n = (c & 0xff) << 8;
                    108:                filter->cache |= n;
                    109:        } else {
                    110:                filter->status = 0;
                    111:                n = (c & 0xff) | filter->cache;
                    112:                CK((*filter->output_function)(n, filter->data));
                    113:        }
                    114:        return c;
                    115: }
                    116: 
                    117: int mbfl_filt_conv_wchar_byte4be(int c, mbfl_convert_filter *filter)
                    118: {
                    119:        CK((*filter->output_function)((c >> 24) & 0xff, filter->data));
                    120:        CK((*filter->output_function)((c >> 16) & 0xff, filter->data));
                    121:        CK((*filter->output_function)((c >> 8) & 0xff, filter->data));
                    122:        CK((*filter->output_function)(c & 0xff, filter->data));
                    123:        return c;
                    124: }
                    125: 
                    126: int mbfl_filt_conv_byte4le_wchar(int c, mbfl_convert_filter *filter)
                    127: {
                    128:        int n;
                    129: 
                    130:        if (filter->status == 0) {
                    131:                filter->status = 1;
                    132:                n = (c & 0xff);
                    133:                filter->cache = n;
                    134:        } else if (filter->status == 1) {
                    135:                filter->status = 2;
                    136:                n = (c & 0xff) << 8;
                    137:                filter->cache |= n;
                    138:        } else if (filter->status == 2) {
                    139:                filter->status = 3;
                    140:                n = (c & 0xff) << 16;
                    141:                filter->cache |= n;
                    142:        } else {
                    143:                filter->status = 0;
                    144:                n = ((c & 0xff) << 24) | filter->cache;
                    145:                CK((*filter->output_function)(n, filter->data));
                    146:        }
                    147:        return c;
                    148: }
                    149: 
                    150: int mbfl_filt_conv_wchar_byte4le(int c, mbfl_convert_filter *filter)
                    151: {
                    152:        CK((*filter->output_function)(c & 0xff, filter->data));
                    153:        CK((*filter->output_function)((c >> 8) & 0xff, filter->data));
                    154:        CK((*filter->output_function)((c >> 16) & 0xff, filter->data));
                    155:        CK((*filter->output_function)((c >> 24) & 0xff, filter->data));
                    156:        return c;
                    157: }
                    158: 
                    159: