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