home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / libi18n / cvchcode.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  8.8 KB  |  364 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18. /*    cvchcode.c    */
  19.  
  20. #include "intlpriv.h"
  21. #include "xp.h"
  22. #include "libi18n.h"
  23.  
  24.  
  25. extern cscvt_t cscvt_tbl[];
  26. extern int haveBig5;
  27.  
  28. struct RealCCCDataObject {
  29.     struct INTL_CCCFuncs *funcs_pointer;
  30.     CCCRADFunc           report_autodetect;
  31.     void                 *autodetect_closure;
  32.     CCCFunc              cvtfunc;
  33.     int32                jismode;
  34.     int32                cvtflag;                /* cvt func dependent flag   */
  35.     unsigned char        uncvtbuf[UNCVTBUF_SIZE];
  36.     uint16               default_doc_csid;
  37.     int16                from_csid;
  38.     int16                to_csid;
  39.     int                  retval;                 /* error value for return    */
  40.     int32                len;                    /* byte len of converted buf */
  41. };
  42.  
  43.  
  44. /* 
  45.  * report_autodetect
  46.  */
  47. PRIVATE void
  48. CallCCCReportAutoDetect(CCCDataObject obj, uint16 detected_doc_csid)
  49. {
  50.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  51.     if (c->report_autodetect)
  52.         (c->report_autodetect)(c->autodetect_closure, obj, detected_doc_csid);
  53. }
  54.  
  55. PRIVATE void
  56. SetCCCReportAutoDetect(CCCDataObject obj,
  57.                             CCCRADFunc report_autodetect,
  58.                             void *autodetect_closure)
  59. {
  60.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  61.  
  62.     c->report_autodetect = report_autodetect;
  63.     c->autodetect_closure = autodetect_closure;
  64. }
  65.  
  66. /* 
  67.  * cvtfunc
  68.  */
  69. PRIVATE CCCFunc
  70. GetCCCCvtfunc(CCCDataObject obj)
  71. {
  72.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  73.  
  74.     return c->cvtfunc;
  75. }
  76.  
  77. PRIVATE void
  78. SetCCCCvtfunc(CCCDataObject obj, CCCFunc cvtfunc)
  79. {
  80.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  81.  
  82.     c->cvtfunc = cvtfunc;
  83. }
  84.  
  85.  
  86. /* 
  87.  * jismode
  88.  */
  89. PRIVATE int32
  90. GetCCCJismode(CCCDataObject obj)
  91. {
  92.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  93.  
  94.     return c->jismode;
  95. }
  96.  
  97. PRIVATE void
  98. SetCCCJismode(CCCDataObject obj, int32 jismode)
  99. {
  100.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  101.  
  102.     c->jismode = jismode;
  103. }
  104.  
  105. /* 
  106.  * cvtflag
  107.  */
  108.  
  109. PRIVATE int32
  110. GetCCCCvtflag(CCCDataObject obj)
  111. {
  112.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  113.  
  114.     return c->cvtflag;
  115. }
  116.  
  117. PRIVATE void
  118. SetCCCCvtflag(CCCDataObject obj, int32 cvtflag)
  119. {
  120.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  121.  
  122.     c->cvtflag = cvtflag;
  123. }
  124.  
  125. /* 
  126.  * uncvtbuf
  127.  */
  128. PRIVATE unsigned char*
  129. GetCCCUncvtbuf(CCCDataObject obj)
  130. {
  131.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  132.  
  133.     return c->uncvtbuf;
  134. }
  135.  
  136. /* 
  137.  * len
  138.  */
  139. PRIVATE int32
  140. GetCCCLen(CCCDataObject obj)
  141. {
  142.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  143.  
  144.     return c->len;
  145. }
  146.  
  147. PRIVATE void
  148. SetCCCLen(CCCDataObject obj, int32 len)
  149. {
  150.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  151.  
  152.     c->len = len;
  153. }
  154.  
  155. /* 
  156.  * retval
  157.  */
  158. PRIVATE int
  159. GetCCCRetval(CCCDataObject obj)
  160. {
  161.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  162.  
  163.     return c->retval;
  164. }
  165.  
  166. PRIVATE void
  167. SetCCCRetval(CCCDataObject obj, int retval)
  168. {
  169.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  170.  
  171.     c->retval = retval;
  172. }
  173.  
  174. /* 
  175.  * default_doc_csid
  176.  */
  177. PRIVATE void
  178. SetCCCDefaultCSID(CCCDataObject obj, uint16 default_doc_csid)
  179. {
  180.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  181.  
  182.     c->default_doc_csid = default_doc_csid;
  183. }
  184.  
  185. PRIVATE uint16
  186. GetCCCDefaultCSID(CCCDataObject obj)
  187. {
  188.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  189.  
  190.     return c->default_doc_csid;
  191. }
  192.  
  193. /* 
  194.  * from_csid
  195.  */
  196. PRIVATE uint16
  197. GetCCCFromCSID(CCCDataObject obj)
  198. {
  199.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  200.  
  201.     return c->from_csid;
  202. }
  203.  
  204. PRIVATE void
  205. SetCCCFromCSID(CCCDataObject obj, uint16 from_csid)
  206. {
  207.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  208.  
  209.     c->from_csid = from_csid;
  210. }
  211.  
  212. /* 
  213.  * to_csid
  214.  */
  215. PRIVATE uint16
  216. GetCCCToCSID(CCCDataObject obj)
  217. {
  218.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  219.  
  220.     return c->to_csid;
  221. }
  222.  
  223. PRIVATE void
  224. SetCCCToCSID(CCCDataObject obj, uint16 to_csid)
  225. {
  226.     struct RealCCCDataObject *c = (struct RealCCCDataObject *)obj;
  227.  
  228.     c->to_csid = to_csid;
  229. }
  230.  
  231.  
  232. PUBLIC unsigned char *
  233. INTL_CallCharCodeConverter(CCCDataObject obj, const unsigned char *buf,
  234.     int32 bufsz)
  235. {
  236.     return (INTL_GetCCCCvtfunc(obj))(obj, buf, bufsz);
  237. }
  238.  
  239.  
  240.     /* INTL_GetCharCodeConverter:
  241.      * RETURN: 1 if converter found, else 0
  242.      * Also, sets:
  243.      *            obj->cvtfunc:    function handle for chararcter
  244.      *                    code set streams converter
  245.      *            obj->cvtflag:    (Optional) flag to converter
  246.      *                    function
  247.      *            obj->from_csid:    Code set converting from
  248.      *            obj->to_csid:    Code set converting to
  249.      * If the arg to_csid==0, then use the the conversion  for the
  250.      * first conversion entry that matches the from_csid.
  251.      */
  252. PUBLIC int
  253. INTL_GetCharCodeConverter(    register int16    from_csid,
  254.                 register int16    to_csid,
  255.                 CCCDataObject    obj)
  256. {
  257.     register cscvt_t        *cscvtp;
  258.  
  259.     if (from_csid == CS_DEFAULT)
  260.         INTL_SetCCCFromCSID(obj, INTL_GetCCCDefaultCSID(obj)); 
  261.     else
  262.         INTL_SetCCCFromCSID(obj, from_csid);
  263.  
  264.     if(to_csid == 0)    /* unknown TO codeset */
  265.         to_csid = INTL_DocToWinCharSetID(from_csid);
  266.     INTL_SetCCCToCSID(obj, to_csid);
  267.  
  268.         /* Look-up conversion method given FROM and TO char. code sets    */
  269.     cscvtp = cscvt_tbl;
  270.  
  271.     while (cscvtp->from_csid) {
  272.         if ((cscvtp->from_csid == from_csid)  && (cscvtp->to_csid == to_csid))
  273.             break;
  274.         cscvtp++;
  275.     }
  276.     INTL_SetCCCCvtflag(obj, cscvtp->cvtflag);
  277.     INTL_SetCCCCvtfunc(obj, cscvtp->cvtmethod);
  278.  
  279.     return (INTL_GetCCCCvtfunc(obj)) ? 1 : 0;
  280. }
  281.  
  282. /* WARNING: THIS TABLE AND THE STRUCT MUST BE IN SYNC WITH EACH OTHER */
  283. PRIVATE struct INTL_CCCFuncs ccc_funcs = {
  284.     /* set_report_autodetect */  SetCCCReportAutoDetect,
  285.     /* call_report_autodetect */ CallCCCReportAutoDetect,
  286.     /* set_cvtfunc */            SetCCCCvtfunc,
  287.     /* get_cvtfunc */            GetCCCCvtfunc,
  288.     /* set_jismode */            SetCCCJismode,
  289.     /* get_jismode */            GetCCCJismode,
  290.     /* set_cvtflag */            SetCCCCvtflag,
  291.     /* get_cvtflag */            GetCCCCvtflag,
  292.     /* get_uncvtbuf */           GetCCCUncvtbuf,
  293.     /* set_default_doc_csid */   SetCCCDefaultCSID,
  294.     /* get_default_doc_csid */   GetCCCDefaultCSID,
  295.     /* set_from_csid */          SetCCCFromCSID,
  296.     /* get_from_csid */          GetCCCFromCSID,
  297.     /* set_to_csid */            SetCCCToCSID,
  298.     /* get_to_csid */            GetCCCToCSID,
  299.     /* set_retval */             SetCCCRetval,
  300.     /* get_retval */             GetCCCRetval,
  301.     /* set_len */                SetCCCLen,
  302.     /* get_len */                GetCCCLen
  303. };
  304.  
  305.  
  306. PUBLIC CCCDataObject
  307. INTL_CreateCharCodeConverter()
  308. {
  309.     struct RealCCCDataObject *obj;
  310.     obj = XP_NEW_ZAP(struct RealCCCDataObject);
  311.     obj->funcs_pointer = &ccc_funcs;
  312.     obj->default_doc_csid = INTL_DefaultDocCharSetID(0);
  313.     return (CCCDataObject) obj;
  314. }
  315.  
  316. PUBLIC void
  317. INTL_DestroyCharCodeConverter(CCCDataObject obj)
  318. {
  319.     XP_FREE(obj);
  320. }
  321.  
  322. PRIVATE unsigned char *intl_conv (int16 fromcsid, int16 tocsid, unsigned char *pSrc, uint32 block_size);
  323. PRIVATE
  324. unsigned char *intl_conv(int16 fromcsid, int16 tocsid, unsigned char *pSrc, uint32 block_size)
  325. {
  326.     CCCDataObject    obj;
  327.     unsigned char *pDest = NULL;
  328.     if (NULL != (obj = INTL_CreateCharCodeConverter()))
  329.     {
  330.         if(0 != INTL_GetCharCodeConverter(fromcsid, tocsid, obj)) 
  331.         {
  332.             CCCFunc cvtfunc;
  333.             if (NULL != (cvtfunc = INTL_GetCCCCvtfunc(obj))) 
  334.             {
  335.                 if(pSrc == (pDest = (unsigned char *)cvtfunc(obj, pSrc, block_size)) )
  336.                 {
  337.                     /* if it use the same buffer to do conversion, we return NULL */
  338.                     pDest = NULL;
  339.                 }
  340.             }
  341.         }
  342.         INTL_DestroyCharCodeConverter(obj);
  343.     }
  344.     return pDest ;
  345. }
  346.  
  347. PUBLIC unsigned char *
  348. INTL_ConvertLineWithoutAutoDetect (int16 fromcsid, int16 tocsid, unsigned char *pSrc, uint32 block_size)
  349. {
  350. #ifdef XP_OS2
  351.     if (fromcsid != tocsid)
  352.     {
  353.         return intl_conv(fromcsid, tocsid, pSrc, block_size);
  354.     else
  355.     {
  356.         return XP_STRDUP(pSrc);
  357.     }
  358. #else
  359.     return intl_conv(fromcsid, tocsid, pSrc, block_size);
  360. #endif /* XP_OS2 */
  361. }
  362.  
  363.  
  364.