home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / Xlc_Std.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  7KB  |  339 lines
  1. /* $XConsortium: lcStd.c /main/5 1996/10/22 17:22:55 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.  
  27. #include "Xlib_private.h"
  28. #include "XlcPubI.h"
  29.  
  30. int
  31. _Xlcmbtowc(lcd, wstr, str, len)
  32.     XLCd lcd;
  33.     wchar_t *wstr;
  34.     char *str;
  35.     int len;
  36. {
  37.     DBUG_ENTER("_Xlcmbtowc")
  38.     static XLCd last_lcd = NULL;
  39.     static XlcConv conv = NULL;
  40.     XPointer from, to;
  41.     int from_left, to_left;
  42.     wchar_t tmp_wc;
  43.  
  44.     if (lcd == NULL) {
  45.     lcd = _XlcCurrentLC();
  46.     if (lcd == NULL)
  47.         DBUG_RETURN(-1);
  48.     }
  49.     if (str == NULL) {
  50.     int result = XLC_PUBLIC(lcd, is_state_depend);
  51.     DBUG_RETURN(result);
  52.     }
  53.  
  54.     if (conv && lcd != last_lcd) {
  55.     _XlcCloseConverter(conv);
  56.     conv = NULL;
  57.     }
  58.  
  59.     last_lcd = lcd;
  60.  
  61.     if (conv == NULL) {
  62.     conv = _XlcOpenConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar);
  63.     if (conv == NULL)
  64.         DBUG_RETURN(-1);
  65.     }
  66.  
  67.     from = (XPointer) str;
  68.     from_left = len;
  69.     to = (XPointer) (wstr ? wstr : &tmp_wc);
  70.     to_left = 1;
  71.  
  72.     if (_XlcConvert(conv, &from, &from_left, &to, &to_left, NULL, 0) < 0)
  73.     DBUG_RETURN(-1);
  74.  
  75.     DBUG_RETURN(len - from_left);
  76. }
  77.  
  78. int
  79. _Xlcwctomb(lcd, str, wc)
  80.     XLCd lcd;
  81.     char *str;
  82.     wchar_t wc;
  83. {
  84.     DBUG_ENTER("_Xlcwctomb")
  85.     static XLCd last_lcd = NULL;
  86.     static XlcConv conv = NULL;
  87.     XPointer from, to;
  88.     int from_left, to_left, length;
  89.  
  90.     if (lcd == NULL) {
  91.     lcd = _XlcCurrentLC();
  92.     if (lcd == NULL)
  93.         DBUG_RETURN(-1);
  94.     }
  95.     if (str == NULL) {
  96.     int result = XLC_PUBLIC(lcd, is_state_depend);
  97.     DBUG_RETURN(result);
  98.     }
  99.  
  100.     if (conv && lcd != last_lcd) {
  101.     _XlcCloseConverter(conv);
  102.     conv = NULL;
  103.     }
  104.  
  105.     last_lcd = lcd;
  106.  
  107.     if (conv == NULL) {
  108.     conv = _XlcOpenConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte);
  109.     if (conv == NULL)
  110.         DBUG_RETURN(-1);
  111.     }
  112.  
  113.     from = (XPointer) &wc;
  114.     from_left = 1;
  115.     to = (XPointer) str;
  116.     length = to_left = XLC_PUBLIC(lcd, mb_cur_max);
  117.  
  118.     if (_XlcConvert(conv, &from, &from_left, &to, &to_left, NULL, 0) < 0)
  119.     DBUG_RETURN(-1);
  120.  
  121.     DBUG_RETURN(length - to_left);
  122. }
  123.  
  124. int
  125. _Xlcmbstowcs(lcd, wstr, str, len)
  126.     XLCd lcd;
  127.     wchar_t *wstr;
  128.     char *str;
  129.     int len;
  130. {
  131.     DBUG_ENTER("_Xlcmbstowcs")
  132.     XlcConv conv;
  133.     XPointer from, to;
  134.     int from_left, to_left, ret;
  135.  
  136.     if (lcd == NULL) {
  137.     lcd = _XlcCurrentLC();
  138.     if (lcd == NULL)
  139.         DBUG_RETURN(-1);
  140.     }
  141.     
  142.     conv = _XlcOpenConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar);
  143.     if (conv == NULL)
  144.     DBUG_RETURN(-1);
  145.  
  146.     from = (XPointer) str;
  147.     from_left = strlen(str);
  148.     to = (XPointer) wstr;
  149.     to_left = len;
  150.  
  151.     if (_XlcConvert(conv, &from, &from_left, &to, &to_left, NULL, 0) < 0)
  152.     ret = -1;
  153.     else {
  154.     ret = len - to_left;
  155.     if (wstr && to_left > 0)
  156.         wstr[ret] = (wchar_t) 0;
  157.     }
  158.  
  159.     _XlcCloseConverter(conv);
  160.  
  161.     DBUG_RETURN(ret);
  162. }
  163.  
  164. int
  165. _Xlcwcstombs(lcd, str, wstr, len)
  166.     XLCd lcd;
  167.     char *str;
  168.     wchar_t *wstr;
  169.     int len;
  170. {
  171.     DBUG_ENTER("_Xlcwcstombs")
  172.     XlcConv conv;
  173.     XPointer from, to;
  174.     int from_left, to_left, ret;
  175.  
  176.     if (lcd == NULL) {
  177.     lcd = _XlcCurrentLC();
  178.     if (lcd == NULL)
  179.         DBUG_RETURN(-1);
  180.     }
  181.  
  182.     conv = _XlcOpenConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte);
  183.     if (conv == NULL)
  184.     DBUG_RETURN(-1);
  185.  
  186.     from = (XPointer) wstr;
  187.     from_left = _Xwcslen(wstr);
  188.     to = (XPointer) str;
  189.     to_left = len;
  190.  
  191.     if (_XlcConvert(conv, &from, &from_left, &to, &to_left, NULL, 0) < 0)
  192.     ret = -1;
  193.     else {
  194.     ret = len - to_left;
  195.     if (str && to_left > 0)
  196.         str[ret] = '\0';
  197.     }
  198.  
  199.     _XlcCloseConverter(conv);
  200.  
  201.     DBUG_RETURN(ret);
  202. }
  203.  
  204.  
  205. int
  206. _Xmbtowc(wstr, str, len)
  207.     wchar_t *wstr;
  208. #ifdef ISC
  209.     char const *str;
  210.     size_t len;
  211. #else
  212.     char *str;
  213.     int len;
  214. #endif
  215. {
  216.     DBUG_ENTER("_Xmbtowc")
  217.     int result = _Xlcmbtowc((XLCd) NULL, wstr, str, len);
  218.     DBUG_RETURN(result);
  219. }
  220.  
  221. int
  222. _Xmblen(str, len)
  223. #ifdef ISC
  224.     char const *str;
  225.     size_t len;
  226. #else
  227.     char *str;
  228.     int len;
  229. #endif
  230. {
  231.     DBUG_ENTER("_Xmblen")
  232.     int result = _Xmbtowc((wchar_t *) NULL, str, len);
  233.     DBUG_RETURN(result);
  234. }
  235.  
  236. int
  237. _Xwctomb(str, wc)
  238.     char *str;
  239.     wchar_t wc;
  240. {
  241.     DBUG_ENTER("_Xwctombs")
  242.     int result = _Xlcwctomb((XLCd) NULL, str, wc);
  243.     DBUG_RETURN(result);
  244. }
  245.  
  246. int
  247. _Xmbstowcs(wstr, str, len)
  248.     wchar_t *wstr;
  249.     char *str;
  250.     int len;
  251. {
  252.     DBUG_ENTER("_Xmbstowcs")
  253.     int result = _Xlcmbstowcs((XLCd) NULL, wstr, str, len);
  254.     DBUG_RETURN(result);
  255. }
  256.  
  257. int
  258. _Xwcstombs(str, wstr, len)
  259.     char *str;
  260.     wchar_t *wstr;
  261.     int len;
  262. {
  263.     DBUG_ENTER("_Xwcstombs")
  264.     int result = _Xlcwcstombs((XLCd) NULL, str, wstr, len);
  265.     DBUG_RETURN(result);
  266. }
  267.  
  268. wchar_t *
  269. _Xwcscpy(wstr1, wstr2)
  270.     register wchar_t *wstr1, *wstr2;
  271. {
  272.     DBUG_ENTER("_Xwcscpy")
  273.     wchar_t *wstr_tmp = wstr1;
  274.  
  275.     while (*wstr1++ = *wstr2++)
  276.     ;
  277.  
  278.     DBUG_RETURN(wstr_tmp);
  279. }
  280.  
  281. wchar_t *
  282. _Xwcsncpy(wstr1, wstr2, len)
  283.     register wchar_t *wstr1, *wstr2;
  284.     register int len;
  285. {
  286.     DBUG_ENTER("_Xwcsncpy")
  287.     wchar_t *wstr_tmp = wstr1;
  288.  
  289.     while (len-- > 0)
  290.     if (!(*wstr1++ = *wstr2++))
  291.         break;
  292.  
  293.     while (len-- > 0)
  294.     *wstr1++ = (wchar_t) 0;
  295.  
  296.     DBUG_RETURN(wstr_tmp);
  297. }
  298.  
  299. int
  300. _Xwcslen(wstr)
  301.     register wchar_t *wstr;
  302. {
  303.     DBUG_ENTER("_Xwcslen")
  304.     register wchar_t *wstr_ptr = wstr;
  305.  
  306.     while (*wstr_ptr)
  307.     wstr_ptr++;
  308.     
  309.     DBUG_RETURN(wstr_ptr - wstr);
  310. }
  311.  
  312. int
  313. _Xwcscmp(wstr1, wstr2)
  314.     register wchar_t *wstr1, *wstr2;
  315. {
  316.     DBUG_ENTER("_Xwcscmp")
  317.     for ( ; *wstr1 && *wstr2; wstr1++, wstr2++)
  318.     if (*wstr1 != *wstr2)
  319.         break;
  320.  
  321.     DBUG_RETURN(*wstr1 - *wstr2);
  322. }
  323.  
  324. int
  325. _Xwcsncmp(wstr1, wstr2, len)
  326.     register wchar_t *wstr1, *wstr2;
  327.     register int len;
  328. {
  329.     DBUG_ENTER("_Xwcsncmp")
  330.     for ( ; *wstr1 && *wstr2 && len > 0; wstr1++, wstr2++, len--)
  331.     if (*wstr1 != *wstr2)
  332.         break;
  333.  
  334.     if (len <= 0)
  335.     DBUG_RETURN(0);
  336.  
  337.     DBUG_RETURN(*wstr1 - *wstr2);
  338. }
  339.