src/xlibi18n/lcConv.c

   1 /*
   2  * Copyright 1992, 1993 by TOSHIBA Corp.
   3  *
   4  * Permission to use, copy, modify, and distribute this software and its
   5  * documentation for any purpose and without fee is hereby granted, provided
   6  * that the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of TOSHIBA not be used in advertising
   9  * or publicity pertaining to distribution of the software without specific,
  10  * written prior permission. TOSHIBA make no representations about the
  11  * suitability of this software for any purpose.  It is provided "as is"
  12  * without express or implied warranty.
  13  *
  14  * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  15  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  16  * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  17  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  18  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  19  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  20  * SOFTWARE.
  21  *
  22  * Author: Katsuhisa Yano       TOSHIBA Corp.
  23  *                              mopi@osa.ilab.toshiba.co.jp
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29 #include "Xlibint.h"
  30 #include "XlcPubI.h"
  31 #include <stdio.h>
  32
  33 typedef struct _XlcConverterListRec {
  34     XLCd from_lcd;
  35     const char *from;
  36     XrmQuark from_type;
  37     XLCd to_lcd;
  38     const char *to;
  39     XrmQuark to_type;
  40     XlcOpenConverterProc converter;
  41     struct _XlcConverterListRec *next;
  42 } XlcConverterListRec, *XlcConverterList;
  43
  44 static XlcConverterList conv_list = NULL;
  45
  46 static void
  47 close_converter(
  48     XlcConv conv)
  49 {
  50     (*conv->methods->close)(conv);
  51 }
  52
  53 static XlcConv
  54 get_converter(
  55     XLCd from_lcd,
  56     XrmQuark from_type,
  57     XLCd to_lcd,
  58     XrmQuark to_type)
  59 {
  60     XlcConverterList list, prev = NULL;
  61
  62     for (list = conv_list; list; list = list->next) {
  63         if (list->from_lcd == from_lcd && list->to_lcd == to_lcd
  64             && list->from_type == from_type && list->to_type == to_type) {
  65
  66             if (prev && prev != conv_list) {    /* XXX */
  67                 prev->next = list->next;
  68                 list->next = conv_list;
  69                 conv_list = list;
  70             }
  71
  72             return (*list->converter)(from_lcd, list->from, to_lcd, list->to);
  73         }
  74
  75         prev = list;
  76     }
  77
  78     return (XlcConv) NULL;
  79 }
  80
  81 Bool
  82 _XlcSetConverter(
  83     XLCd from_lcd,
  84     const char *from,
  85     XLCd to_lcd,
  86     const char *to,
  87     XlcOpenConverterProc converter)
  88 {
  89     XlcConverterList list;
  90     XrmQuark from_type, to_type;
  91
  92     from_type = XrmStringToQuark(from);
  93     to_type = XrmStringToQuark(to);
  94
  95     for (list = conv_list; list; list = list->next) {
  96         if (list->from_lcd == from_lcd && list->to_lcd == to_lcd
  97             && list->from_type == from_type && list->to_type == to_type) {
  98
  99             list->converter = converter;
 100             return True;
 101         }
 102     }
 103
 104     list = (XlcConverterList) Xmalloc(sizeof(XlcConverterListRec));
 105     if (list == NULL)
 106         return False;
 107
 108     list->from_lcd = from_lcd;
 109     list->from = from;
 110     list->from_type = from_type;
 111     list->to_lcd = to_lcd;
 112     list->to = to;
 113     list->to_type = to_type;
 114     list->converter = converter;
 115     list->next = conv_list;
 116     conv_list = list;
 117
 118     return True;
 119 }
 120
 121 typedef struct _ConvRec {
 122     XlcConv from_conv;
 123     XlcConv to_conv;
 124 } ConvRec, *Conv;
 125
 126 static int
 127 indirect_convert(
 128     XlcConv lc_conv,
 129     XPointer *from,
 130     int *from_left,
 131     XPointer *to,
 132     int *to_left,
 133     XPointer *args,
 134     int num_args)
 135 {
 136     Conv conv = (Conv) lc_conv->state;
 137     XlcConv from_conv = conv->from_conv;
 138     XlcConv to_conv = conv->to_conv;
 139     XlcCharSet charset;
 140     char buf[BUFSIZ], *cs;
 141     XPointer tmp_args[1];
 142     int cs_left, ret, length, unconv_num = 0;
 143
 144     if (from == NULL || *from == NULL) {
 145         if (from_conv->methods->reset)
 146             (*from_conv->methods->reset)(from_conv);
 147
 148         if (to_conv->methods->reset)
 149             (*to_conv->methods->reset)(to_conv);
 150
 151         return 0;
 152     }
 153
 154     while (*from_left > 0) {
 155         cs = buf;
 156         cs_left = BUFSIZ;
 157         tmp_args[0] = (XPointer) &charset;
 158
 159         ret = (*from_conv->methods->convert)(from_conv, from, from_left, &cs,
 160                                              &cs_left, tmp_args, 1);
 161         if (ret < 0)
 162             break;
 163
 164         unconv_num += ret;
 165
 166         length = cs - buf;
 167         if (length > 0) {
 168             cs_left = length;
 169             cs = buf;
 170
 171             tmp_args[0] = (XPointer) charset;
 172
 173             ret = (*to_conv->methods->convert)(to_conv, &cs, &cs_left, to, to_left,
 174                                                tmp_args, 1);
 175             if (ret < 0) {
 176                 unconv_num += length / (charset->char_size > 0 ? charset->char_size : 1);
 177                 continue;
 178             }
 179
 180             unconv_num += ret;
 181
 182             if (*to_left < 1)
 183                 break;
 184         }
 185     }
 186
 187     return unconv_num;
 188 }
 189
 190 static void
 191 close_indirect_converter(
 192     XlcConv lc_conv)
 193 {
 194     Conv conv = (Conv) lc_conv->state;
 195
 196     if (conv) {
 197         if (conv->from_conv)
 198             close_converter(conv->from_conv);
 199         if (conv->to_conv)
 200             close_converter(conv->to_conv);
 201
 202         Xfree((char *) conv);
 203     }
 204
 205     Xfree((char *) lc_conv);
 206 }
 207
 208 static void
 209 reset_indirect_converter(
 210     XlcConv lc_conv)
 211 {
 212     Conv conv = (Conv) lc_conv->state;
 213
 214     if (conv) {
 215         if (conv->from_conv && conv->from_conv->methods->reset)
 216             (*conv->from_conv->methods->reset)(conv->from_conv);
 217         if (conv->to_conv && conv->to_conv->methods->reset)
 218             (*conv->to_conv->methods->reset)(conv->to_conv);
 219     }
 220 }
 221
 222 static XlcConvMethodsRec conv_methods = {
 223     close_indirect_converter,
 224     indirect_convert,
 225     reset_indirect_converter
 226 } ;
 227
 228 static XlcConv
 229 open_indirect_converter(
 230     XLCd from_lcd,
 231     const char *from,
 232     XLCd to_lcd,
 233     const char *to)
 234 {
 235     XlcConv lc_conv, from_conv, to_conv;
 236     Conv conv;
 237     XrmQuark from_type, to_type;
 238     static XrmQuark QChar, QCharSet, QCTCharSet = (XrmQuark) 0;
 239
 240     if (QCTCharSet == (XrmQuark) 0) {
 241         QCTCharSet = XrmStringToQuark(XlcNCTCharSet);
 242         QCharSet = XrmStringToQuark(XlcNCharSet);
 243         QChar = XrmStringToQuark(XlcNChar);
 244     }
 245
 246     from_type = XrmStringToQuark(from);
 247     to_type = XrmStringToQuark(to);
 248
 249     if (from_type == QCharSet || from_type == QChar || to_type == QCharSet ||
 250         to_type == QChar)
 251         return (XlcConv) NULL;
 252
 253     lc_conv = (XlcConv) Xmalloc(sizeof(XlcConvRec));
 254     if (lc_conv == NULL)
 255         return (XlcConv) NULL;
 256
 257     lc_conv->methods = &conv_methods;
 258
 259     lc_conv->state = (XPointer) Xcalloc(1, sizeof(ConvRec));
 260     if (lc_conv->state == NULL)
 261         goto err;
 262
 263     conv = (Conv) lc_conv->state;
 264
 265     from_conv = get_converter(from_lcd, from_type, from_lcd, QCTCharSet);
 266     if (from_conv == NULL)
 267         from_conv = get_converter(from_lcd, from_type, from_lcd, QCharSet);
 268     if (from_conv == NULL)
 269         from_conv = get_converter((XLCd)NULL, from_type, (XLCd)NULL, QCharSet);
 270     if (from_conv == NULL)
 271         from_conv = get_converter(from_lcd, from_type, from_lcd, QChar);
 272     if (from_conv == NULL)
 273         goto err;
 274     conv->from_conv = from_conv;
 275
 276     to_conv = get_converter(to_lcd, QCTCharSet, to_lcd, to_type);
 277     if (to_conv == NULL)
 278         to_conv = get_converter(to_lcd, QCharSet, to_lcd, to_type);
 279     if (to_conv == NULL)
 280         to_conv = get_converter((XLCd) NULL, QCharSet, (XLCd) NULL, to_type);
 281     if (to_conv == NULL)
 282         goto err;
 283     conv->to_conv = to_conv;
 284
 285     return lc_conv;
 286
 287 err:
 288     close_indirect_converter(lc_conv);
 289
 290     return (XlcConv) NULL;
 291 }
 292
 293 XlcConv
 294 _XlcOpenConverter(
 295     XLCd from_lcd,
 296     const char *from,
 297     XLCd to_lcd,
 298     const char *to)
 299 {
 300     XlcConv conv;
 301     XrmQuark from_type, to_type;
 302
 303     from_type = XrmStringToQuark(from);
 304     to_type = XrmStringToQuark(to);
 305
 306     if ((conv = get_converter(from_lcd, from_type, to_lcd, to_type)))
 307         return conv;
 308
 309     return open_indirect_converter(from_lcd, from, to_lcd, to);
 310 }
 311
 312 void
 313 _XlcCloseConverter(
 314     XlcConv conv)
 315 {
 316     close_converter(conv);
 317 }
 318
 319 int
 320 _XlcConvert(
 321     XlcConv conv,
 322     XPointer *from,
 323     int *from_left,
 324     XPointer *to,
 325     int *to_left,
 326     XPointer *args,
 327     int num_args)
 328 {
 329     return (*conv->methods->convert)(conv, from, from_left, to, to_left, args,
 330                                      num_args);
 331 }
 332
 333 void
 334 _XlcResetConverter(
 335     XlcConv conv)
 336 {
 337     if (conv->methods->reset)
 338         (*conv->methods->reset)(conv);
 339 }