cde/programs/dtudcfonted/libfal/_fallcDefConv.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these libraries and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* lcDefConv.c 1.1 - Fujitsu source for CDEnext    95/11/06 20:32:35    */
  24 /* $XConsortium: _fallcDefConv.c /main/1 1996/04/08 15:16:17 cde-fuj $ */
  25 /*
  26  * Copyright 1992, 1993 by TOSHIBA Corp.
  27  *
  28  * Permission to use, copy, modify, and distribute this software and its
  29  * documentation for any purpose and without fee is hereby granted, provided
  30  * that the above copyright notice appear in all copies and that both that
  31  * copyright notice and this permission notice appear in supporting
  32  * documentation, and that the name of TOSHIBA not be used in advertising
  33  * or publicity pertaining to distribution of the software without specific,
  34  * written prior permission. TOSHIBA make no representations about the
  35  * suitability of this software for any purpose.  It is provided "as is"
  36  * without express or implied warranty.
  37  *
  38  * TOSHIBA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  39  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  40  * TOSHIBA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  41  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  42  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  43  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  44  * SOFTWARE.
  45  *
  46  * Author: Katsuhisa Yano       TOSHIBA Corp.
  47  *                              mopi@osa.ilab.toshiba.co.jp
  48  */
  49
  50 #include "_fallibint.h"
  51 #include "_fallcPubI.h"
  52
  53 typedef struct _StateRec {
  54     XlcCharSet charset;
  55     XlcCharSet GL_charset;
  56     XlcCharSet GR_charset;
  57     XlcConv ct_conv;
  58     int (*to_converter)();
  59 } StateRec, *State;
  60
  61 static int
  62 strtostr(conv, from, from_left, to, to_left, args, num_args)
  63     XlcConv conv;
  64     XPointer *from;
  65     int *from_left;
  66     XPointer *to;
  67     int *to_left;
  68     XPointer *args;
  69     int num_args;
  70 {
  71     register char *src, *dst;
  72     unsigned char side;
  73     register length;
  74
  75     if (from == NULL || *from == NULL)
  76         return 0;
  77
  78     src = (char *) *from;
  79     dst = (char *) *to;
  80
  81     length = min(*from_left, *to_left);
  82
  83     if (num_args > 0) {
  84         side = *((unsigned char *) src) & 0x80;
  85         while (side == (*((unsigned char *) src) & 0x80) && length-- > 0)
  86             *dst++ = *src++;
  87     } else {
  88         while (length-- > 0)
  89             *dst++ = *src++;
  90     }
  91
  92     *from_left -= src - (char *) *from;
  93     *from = (XPointer) src;
  94     *to_left -= dst - (char *) *to;
  95     *to = (XPointer) dst;
  96
  97     if (num_args > 0) {
  98         State state = (State) conv->state;
  99
 100         *((XlcCharSet *)args[0]) = side ? state->GR_charset : state->GL_charset;
 101     }
 102
 103     return 0;
 104 }
 105
 106 static int
 107 wcstostr(conv, from, from_left, to, to_left, args, num_args)
 108     XlcConv conv;
 109     XPointer *from;
 110     int *from_left;
 111     XPointer *to;
 112     int *to_left;
 113     XPointer *args;
 114     int num_args;
 115 {
 116     register wchar_t *src, side;
 117     register char *dst;
 118     register length;
 119
 120     if (from == NULL || *from == NULL)
 121         return 0;
 122
 123     src = (wchar_t *) *from;
 124     dst = (char *) *to;
 125
 126     length = min(*from_left, *to_left);
 127
 128     if (num_args > 0) {
 129         side = *src & 0x80;
 130         while (side == (*src & 0x80) && length-- > 0)
 131             *dst++ = *src++;
 132     } else {
 133         while (length-- > 0)
 134             *dst++ = *src++;
 135     }
 136
 137     *from_left -= src - (wchar_t *) *from;
 138     *from = (XPointer) src;
 139     *to_left -= dst - (char *) *to;
 140     *to = (XPointer) dst;
 141
 142     if (num_args > 0) {
 143         State state = (State) conv->state;
 144
 145         *((XlcCharSet *)args[0]) = side ? state->GR_charset : state->GL_charset;
 146     }
 147
 148     return 0;
 149 }
 150
 151 static int
 152 cstostr(conv, from, from_left, to, to_left, args, num_args)
 153     XlcConv conv;
 154     XPointer *from;
 155     int *from_left;
 156     XPointer *to;
 157     int *to_left;
 158     XPointer *args;
 159     int num_args;
 160 {
 161     register char *src, *dst;
 162     unsigned char side;
 163     register length;
 164
 165     if (from == NULL || *from == NULL)
 166         return 0;
 167
 168     if (num_args > 0) {
 169         State state = (State) conv->state;
 170         XlcCharSet charset = (XlcCharSet) args[0];
 171
 172         if (charset != state->GL_charset && charset != state->GR_charset)
 173             return -1;
 174     }
 175
 176     src = (char *) *from;
 177     dst = (char *) *to;
 178
 179     length = min(*from_left, *to_left);
 180
 181     if (num_args > 0) {
 182         side = *((unsigned char *) src) & 0x80;
 183         while (side == (*((unsigned char *) src) & 0x80) && length-- > 0)
 184             *dst++ = *src++;
 185     } else {
 186         while (length-- > 0)
 187             *dst++ = *src++;
 188     }
 189
 190     *from_left -= src - (char *) *from;
 191     *from = (XPointer) src;
 192     *to_left -= dst - (char *) *to;
 193     *to = (XPointer) dst;
 194
 195     if (num_args > 0) {
 196         State state = (State) conv->state;
 197
 198         *((XlcCharSet *)args[0]) = side ? state->GR_charset : state->GL_charset;
 199     }
 200
 201     return 0;
 202 }
 203
 204 static int
 205 strtowcs(conv, from, from_left, to, to_left, args, num_args)
 206     XlcConv conv;
 207     XPointer *from;
 208     int *from_left;
 209     XPointer *to;
 210     int *to_left;
 211     XPointer *args;
 212     int num_args;
 213 {
 214     register char *src;
 215     register wchar_t *dst;
 216     register length;
 217
 218     if (from == NULL || *from == NULL)
 219         return 0;
 220
 221     if (num_args > 0) {
 222         State state = (State) conv->state;
 223         XlcCharSet charset = (XlcCharSet) args[0];
 224
 225         if (charset != state->GL_charset && charset != state->GR_charset)
 226             return -1;
 227     }
 228
 229     src = (char *) *from;
 230     dst = (wchar_t *) *to;
 231
 232     length = min(*from_left, *to_left);
 233
 234     while (length-- > 0)
 235         *dst++ = (wchar_t) *src++;
 236
 237     *from_left -= src - (char *) *from;
 238     *from = (XPointer) src;
 239     *to_left -= dst - (wchar_t *) *to;
 240     *to = (XPointer) dst;
 241
 242     return 0;
 243 }
 244
 245
 246 static void
 247 close_converter(conv)
 248     XlcConv conv;
 249 {
 250     if (conv->state)
 251         Xfree((char *) conv->state);
 252
 253     Xfree((char *) conv);
 254 }
 255
 256 static XlcConv
 257 create_conv(methods)
 258     XlcConvMethods methods;
 259 {
 260     register XlcConv conv;
 261     State state;
 262     static XlcCharSet GL_charset = NULL;
 263     static XlcCharSet GR_charset = NULL;
 264
 265     if (GL_charset == NULL) {
 266         GL_charset = _fallcGetCharSet("ISO8859-1:GL");
 267         GR_charset = _fallcGetCharSet("ISO8859-1:GR");
 268     }
 269
 270     conv = (XlcConv) Xmalloc(sizeof(XlcConvRec));
 271     if (conv == NULL)
 272         return (XlcConv) NULL;
 273
 274     conv->state = NULL;
 275
 276     state = (State) Xmalloc(sizeof(StateRec));
 277     if (state == NULL)
 278         goto err;
 279
 280     state->GL_charset = state->charset = GL_charset;
 281     state->GR_charset = GR_charset;
 282
 283     conv->methods = methods;
 284     conv->state = (XPointer) state;
 285
 286     return conv;
 287
 288 err:
 289     close_converter(conv);
 290
 291     return (XlcConv) NULL;
 292 }
 293
 294 static XlcConvMethodsRec strtostr_methods = {
 295     close_converter,
 296     strtostr,
 297     NULL
 298 } ;
 299
 300 static XlcConv
 301 open_strtostr(from_lcd, from_type, to_lcd, to_type)
 302     XLCd from_lcd;
 303     char *from_type;
 304     XLCd to_lcd;
 305     char *to_type;
 306 {
 307     return create_conv(&strtostr_methods);
 308 }
 309
 310 static XlcConvMethodsRec wcstostr_methods = {
 311     close_converter,
 312     wcstostr,
 313     NULL
 314 } ;
 315
 316 static XlcConv
 317 open_wcstostr(from_lcd, from_type, to_lcd, to_type)
 318     XLCd from_lcd;
 319     char *from_type;
 320     XLCd to_lcd;
 321     char *to_type;
 322 {
 323     return create_conv(&wcstostr_methods);
 324 }
 325
 326 static XlcConvMethodsRec cstostr_methods = {
 327     close_converter,
 328     cstostr,
 329     NULL
 330 } ;
 331
 332 static XlcConv
 333 open_cstostr(from_lcd, from_type, to_lcd, to_type)
 334     XLCd from_lcd;
 335     char *from_type;
 336     XLCd to_lcd;
 337     char *to_type;
 338 {
 339     return create_conv(&cstostr_methods);
 340 }
 341
 342 static XlcConvMethodsRec strtowcs_methods = {
 343     close_converter,
 344     strtowcs,
 345     NULL
 346 } ;
 347
 348 static XlcConv
 349 open_strtowcs(from_lcd, from_type, to_lcd, to_type)
 350     XLCd from_lcd;
 351     char *from_type;
 352     XLCd to_lcd;
 353     char *to_type;
 354 {
 355     return create_conv(&strtowcs_methods);
 356 }
 357
 358 XLCd
 359 _fallcDefaultLoader(name)
 360     char *name;
 361 {
 362     XLCd lcd;
 363
 364     if (strcmp(name, "C"))
 365         return (XLCd) NULL;
 366
 367     lcd = _fallcCreateLC(name, _fallcPublicMethods);
 368
 369     _fallcSetConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar, open_strtowcs);
 370     _fallcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCompoundText, open_strtostr);
 371     _fallcSetConverter(lcd, XlcNMultiByte, lcd, XlcNString, open_strtostr);
 372     _fallcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCharSet, open_strtostr);
 373     _fallcSetConverter(lcd, XlcNMultiByte, lcd, XlcNChar, open_strtostr);/* XXX */
 374
 375     _fallcSetConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte, open_wcstostr);
 376     _fallcSetConverter(lcd, XlcNWideChar, lcd, XlcNCompoundText, open_wcstostr);
 377     _fallcSetConverter(lcd, XlcNWideChar, lcd, XlcNString, open_wcstostr);
 378     _fallcSetConverter(lcd, XlcNWideChar, lcd, XlcNCharSet, open_wcstostr);
 379
 380     _fallcSetConverter(lcd, XlcNString, lcd, XlcNMultiByte, open_strtostr);
 381     _fallcSetConverter(lcd, XlcNString, lcd, XlcNWideChar, open_strtowcs);
 382
 383     _fallcSetConverter(lcd, XlcNCharSet, lcd, XlcNMultiByte, open_cstostr);
 384     _fallcSetConverter(lcd, XlcNCharSet, lcd, XlcNWideChar, open_strtowcs);
 385
 386     return lcd;
 387 }