开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
utf8.c
资源名称：imap-4.7.tar.Z　[点击查看]
上传用户：ycwykj01
上传日期：2007-01-04
资源大小：1819k
文件大小：33k
源码类别：

网络编程

开发平台：

Unix_Linux

utf8.c：源码内容
  1. /*
  2.  * Program: UTF-8 routines
  3.  *
  4.  * Author: Mark Crispin
  5.  * Networks and Distributed Computing
  6.  * Computing & Communications
  7.  * University of Washington
  8.  * Administration Building, AG-44
  9.  * Seattle, WA  98195
  10.  * Internet: MRC@CAC.Washington.EDU
  11.  *
  12.  * Date: 11 June 1997
  13.  * Last Edited: 4 October 1999
  14.  *
  15.  * Copyright 1999 by the University of Washington
  16.  *
  17.  *  Permission to use, copy, modify, and distribute this software and its
  18.  * documentation for any purpose and without fee is hereby granted, provided
  19.  * that the above copyright notices appear in all copies and that both the
  20.  * above copyright notices and this permission notice appear in supporting
  21.  * documentation, and that the name of the University of Washington not be
  22.  * used in advertising or publicity pertaining to distribution of the software
  23.  * without specific, written prior permission.  This software is made
  24.  * available "as is", and
  25.  * THE UNIVERSITY OF WASHINGTON DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
  26.  * WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION ALL IMPLIED
  27.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND IN
  28.  * NO EVENT SHALL THE UNIVERSITY OF WASHINGTON BE LIABLE FOR ANY SPECIAL,
  29.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
  30.  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT
  31.  * (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN
  32.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  33.  *
  34.  */
  37. #include <stdio.h>
  38. #include <ctype.h>
  39. #include "mail.h"
  40. #include "osdep.h"
  41. #include "misc.h"
  42. #include "rfc822.h"
  43. #include "utf8.h"
  45. /* *** IMPORTANT ***
  46.  *
  47.  *  There is a very important difference between "character set" and "charset",
  48.  * and the comments in this file reflect these differences.  A "character set"
  49.  * (also known as "coded character set") is a mapping between codepoints and
  50.  * characters.  A "charset" is as defined in MIME, and incorporates one or more
  51.  * coded character sets in a character encoding scheme.  See RFC 2130 for more
  52.  * details.
  53.  */
  56. /* Character set conversion tables */
  58. #include "iso_8859.c" /* 8-bit single-byte coded graphic */
  59. #include "koi8_r.c" /* Cyrillic - Russia */
  60. #include "koi8_u.c" /* Cyrillic - Ukraine */
  61. #include "tis_620.c" /* Thai */
  62. #include "viscii.c" /* Vietnamese */
  63. #include "gb_2312.c" /* Chinese (PRC) - simplified */
  64. #include "gb_12345.c" /* Chinese (PRC) - traditional */
  65. #include "jis_0208.c" /* Japanese - basic */
  66. #include "jis_0212.c" /* Japanese - supplementary */
  67. #include "ksc_5601.c" /* Korean */
  68. #include "big5.c" /* Taiwanese (ROC) - industrial standard */
  69. #include "cns11643.c" /* Taiwanese (ROC) - national standard */
  71. /* EUC parameters */
  73. #ifdef GBTOUNICODE /* PRC simplified Chinese */
  74. static const struct utf8_eucparam gb_param[] = {
  75.   {BASE_GB2312_KU,BASE_GB2312_TEN,MAX_GB2312_KU,MAX_GB2312_TEN,
  76.      (void *) gb2312tab},
  77.   {0,0,0,0,NIL},
  78.   {0,0,0,0,NIL},
  79. };
  80. #endif
  83. #ifdef GB12345TOUNICODE /* PRC traditional Chinese */
  84. static const struct utf8_eucparam gbt_param[] = {
  85.   {BASE_GB12345_KU,BASE_GB12345_TEN,MAX_GB12345_KU,MAX_GB12345_TEN,
  86.      (void *) gb12345tab},
  87.   {0,0,0,0,NIL},
  88.   {0,0,0,0,NIL}
  89. };
  90. #endif
  93. #ifdef BIG5TOUNICODE /* ROC traditional Chinese */
  94. static const struct utf8_eucparam big5_param[] = {
  95.   {BASE_BIG5_KU,BASE_BIG5_TEN_0,MAX_BIG5_KU,MAX_BIG5_TEN_0,(void *) big5tab},
  96.   {BASE_BIG5_KU,BASE_BIG5_TEN_1,MAX_BIG5_KU,MAX_BIG5_TEN_1,NIL}
  97. };
  98. #endif
  101. #ifdef JISTOUNICODE /* Japanese */
  102. static const struct utf8_eucparam jis_param[] = {
  103.   {BASE_JIS0208_KU,BASE_JIS0208_TEN,MAX_JIS0208_KU,MAX_JIS0208_TEN,
  104.      (void *) jis0208tab},
  105.   {MIN_KANA_8,0,MAX_KANA_8,0,(void *) KANA_8},
  106. #ifdef JIS0212TOUNICODE /* Japanese extended */
  107.   {BASE_JIS0212_KU,BASE_JIS0212_TEN,MAX_JIS0212_KU,MAX_JIS0212_TEN,
  108.      (void *) jis0212tab}
  109. #else
  110.   {0,0,0,0,NIL}
  111. #endif
  112. };
  113. #endif
  116. #ifdef KSCTOUNICODE /* Korean */
  117. static const struct utf8_eucparam ksc_param = {
  118.   BASE_KSC5601_KU,BASE_KSC5601_TEN,MAX_KSC5601_KU,MAX_KSC5601_TEN,(void *) ksc5601tab};
  119. #endif
  121. /* List of supported charsets (note: all names must be uppercase!) */
  122. static const struct utf8_csent utf8_csvalid[] = {
  123.   {"US-ASCII",NIL,NIL,NIL,NIL},
  124.   {"UTF-8",NIL,NIL,SC_UNICODE,NIL},
  125.   {"UTF-7",utf8_text_utf7,NIL,SC_UNICODE,"UTF-8"},
  126.   {"ISO-8859-1",utf8_text_8859_1,NIL,SC_LATIN_1,NIL},
  127.   {"ISO-8859-2",utf8_text_1byte,(void *) iso8859_2tab,SC_LATIN_2,NIL},
  128.   {"ISO-8859-3",utf8_text_1byte,(void *) iso8859_3tab,SC_LATIN_3,NIL},
  129.   {"ISO-8859-4",utf8_text_1byte,(void *) iso8859_4tab,SC_LATIN_4,NIL},
  130.   {"ISO-8859-5",utf8_text_1byte,(void *) iso8859_5tab,SC_CYRILLIC,"KOI-8"},
  131.   {"ISO-8859-6",utf8_text_1byte,(void *) iso8859_6tab,SC_ARABIC,NIL},
  132.   {"ISO-8859-7",utf8_text_1byte,(void *) iso8859_7tab,SC_GREEK,NIL},
  133.   {"ISO-8859-8",utf8_text_1byte,(void *) iso8859_8tab,SC_HEBREW,NIL},
  134.   {"ISO-8859-9",utf8_text_1byte,(void *) iso8859_9tab,SC_LATIN_5,NIL},
  135.   {"ISO-8859-10",utf8_text_1byte,(void *) iso8859_10tab,SC_LATIN_6,NIL},
  136.   {"ISO-8859-11",utf8_text_1byte,(void *) iso8859_11tab,SC_THAI,NIL},
  137. #if 0 /* ISO 8859-12 reserved */
  138.   {"ISO-8859-12",utf8_text_1byte,(void *) iso8859_12tab,NIL,NIL},
  139. #endif
  140.   {"ISO-8859-13",utf8_text_1byte,(void *) iso8859_13tab,SC_LATIN_7,NIL},
  141.   {"ISO-8859-14",utf8_text_1byte,(void *) iso8859_14tab,SC_LATIN_8,NIL},
  142.   {"ISO-8859-15",utf8_text_1byte,(void *) iso8859_15tab,SC_LATIN_9,NIL},
  143.   {"KOI8-R",utf8_text_1byte,(void *) koi8rtab,SC_CYRILLIC,NIL},
  144.   {"KOI8-U",utf8_text_1byte,(void *) koi8utab,SC_CYRILLIC | SC_UKRANIAN,NIL},
  145.   {"KOI8-RU",utf8_text_1byte,(void *) koi8utab,SC_CYRILLIC | SC_UKRANIAN,
  146.      "KOI8-U"},
  147.   {"TIS-620",utf8_text_1byte,(void *) tis620tab,SC_THAI,NIL},
  148.   {"VISCII",utf8_text_1byte8,(void *) visciitab,SC_VIETNAMESE,NIL},
  150. #ifdef GBTOUNICODE
  151.   {"GB2312",utf8_text_euc,(void *) gb_param,SC_CHINESE_SIMPLIFIED,NIL},
  152.   {"CN-GB",utf8_text_euc,(void *) gb_param,SC_CHINESE_SIMPLIFIED,"GB2312"},
  153. #ifdef CNS1TOUNICODE
  154.   {"ISO-2022-CN",utf8_text_2022,NIL,
  155.      SC_CHINESE_SIMPLIFIED | SC_CHINESE_TRADITIONAL,NIL},
  156. #endif
  157. #endif
  158. #ifdef GB12345TOUNICODE
  159.   {"CN-GB-12345",utf8_text_euc,(void *) gbt_param,SC_CHINESE_TRADITIONAL,NIL},
  160. #endif
  161. #ifdef BIG5TOUNICODE
  162.   {"BIG5",utf8_text_dbyte2,(void *) big5_param,SC_CHINESE_TRADITIONAL,NIL},
  163.   {"CN-BIG5",utf8_text_dbyte2,(void *) big5_param,SC_CHINESE_TRADITIONAL,
  164.      "BIG5"},
  165. #endif
  166. #ifdef JISTOUNICODE
  167.   {"ISO-2022-JP",utf8_text_2022,NIL,SC_JAPANESE,NIL},
  168.   {"EUC-JP",utf8_text_euc,(void *) jis_param,SC_JAPANESE,"ISO-2022-JP"},
  169.   {"SHIFT_JIS",utf8_text_sjis,NIL,SC_JAPANESE,"ISO-2022-JP"},
  170.   {"SHIFT-JIS",utf8_text_sjis,NIL,SC_JAPANESE,"ISO-2022-JP"},
  171. #ifdef JIS0212TOUNICODE
  172.   {"ISO-2022-JP-1",utf8_text_2022,NIL,SC_JAPANESE,"ISO-2022-JP"},
  173. #ifdef GBTOUNICODE
  174. #ifdef KSCTOUNICODE
  175.   {"ISO-2022-JP-2",utf8_text_2022,NIL,
  176.      SC_LATIN_1 | SC_LATIN_2 | SC_LATIN_3 | SC_LATIN_4 | SC_LATIN_5 |
  177.        SC_LATIN_6 | SC_LATIN_7 | SC_LATIN_8 | SC_LATIN_9 | SC_ARABIC |
  178.  SC_CYRILLIC | SC_GREEK | SC_HEBREW | SC_THAI | SC_VIETNAMESE |
  179.    SC_CHINESE_TRADITIONAL | SC_JAPANESE | SC_KOREAN
  180. #ifdef CNS1TOUNICODE
  181.      | SC_CHINESE_TRADITIONAL
  182. #endif
  183.        ,"UTF-8"},
  184. #endif
  185. #endif
  186. #endif
  187. #endif
  188. #ifdef KSCTOUNICODE
  189.   {"ISO-2022-KR",utf8_text_2022,NIL,SC_KOREAN,NIL},
  190.   {"EUC-KR",utf8_text_dbyte,(void *) &ksc_param,SC_KOREAN,NIL},
  191. #endif
  192.   NIL
  193. };
  195. /* Convert charset labelled sized text to UTF-8
  196.  * Accepts: source sized text
  197.  *     charset
  198.  *     pointer to returned sized text if non-NIL
  199.  *     flags (currently non-zero if want error for unknown charset)
  200.  * Returns: T if successful, NIL if failure
  201.  */
  203. long utf8_text (SIZEDTEXT *text,char *charset,SIZEDTEXT *ret,long flags)
  204. {
  205.   unsigned long i;
  206.   char *t,tmp[MAILTMPLEN];
  207.   if (ret) { /* default is to just return identity */
  208.     ret->data = text->data;
  209.     ret->size = text->size;
  210.   }
  211.   if (!charset || !*charset) { /* missing charset? */
  212.     if (ret && (text->size > 2)) for (i = 0; i < text->size - 1; i++) {
  213. /* special hack for untagged ISO-2022 */
  214.       if ((text->data[i] == '33') && (text->data[i+1] == '$')) {
  215. utf8_text_2022 (text,ret,NIL);
  216. break;
  217.       }
  218. /* special hack for "just send 8" cretins */
  219.       else if (text->data[i] & BIT8) {
  220. utf8_text_8859_1 (text,ret,NIL);
  221. break;
  222.       }
  223.     }
  224.     return LONGT;
  225.   }
  226. /* otherwise look for charset */
  227.   for (i = 0, ucase (strcpy (tmp,charset)); utf8_csvalid[i].name; i++)
  228.     if (!strcmp (tmp,utf8_csvalid[i].name)) {
  229.       if (ret && utf8_csvalid[i].dsp)
  230. (*utf8_csvalid[i].dsp) (text,ret,utf8_csvalid[i].tab);
  231.       return LONGT; /* success */
  232.     }
  233.   if (flags) { /* charset not found */
  234.     strcpy (tmp,"[BADCHARSET (");
  235.     for (i = 0, t = tmp + strlen (tmp); utf8_csvalid[i].name;
  236.  i++,t += strlen (t)) sprintf (t,"%s ",utf8_csvalid[i].name);
  237.     sprintf (t + strlen (t) - 1,")] Unknown charset: %.80s",charset);
  238.     mm_log (tmp,ERROR);
  239.   }
  240.   return NIL; /* failed */
  241. }
  243. /* Convert ISO-8859-1 sized text to UTF-8
  244.  * Accepts: source sized text
  245.  *     pointer to returned sized text
  246.  *     conversion table
  247.  */
  249. void utf8_text_8859_1 (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab)
  250. {
  251.   unsigned long i;
  252.   unsigned char *s;
  253.   unsigned int c;
  254.   for (ret->size = i = 0; i < text->size;
  255.        ret->size += (text->data[i++] & BIT8) ? 2 : 1);
  256.   s = ret->data = (unsigned char *) fs_get (ret->size + 1);
  257.   for (i = 0; i < text->size;) {
  258.     if ((c = text->data[i++]) & BIT8) {
  259.       *s++ = 0xc0 | ((c >> 6) & 0x3f);
  260.       *s++ = BIT8 | (c & 0x3f);
  261.     }
  262.     else *s++ = c; /* ASCII character */
  263.   }
  264. }
  266. /* Convert single byte ASCII+8bit character set sized text to UTF-8
  267.  * Accepts: source sized text
  268.  *     pointer to return sized text
  269.  *     conversion table
  270.  */
  272. void utf8_text_1byte (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab)
  273. {
  274.   unsigned long i;
  275.   unsigned char *s;
  276.   unsigned int c;
  277.   unsigned short *tbl = (unsigned short *) tab;
  278.   for (ret->size = i = 0; i < text->size; ret->size += UTF8_SIZE (c))
  279.     if ((c = text->data[i++]) & BIT8) c = tbl[c & BITS7];
  280.   s = ret->data = (unsigned char *) fs_get (ret->size + 1);
  281.   for (i = 0; i < text->size;) {
  282.     if ((c = text->data[i++]) & BIT8) c = tbl[c & BITS7];
  283.     UTF8_PUT (s,c) /* convert Unicode to UTF-8 */
  284.   }
  285. }
  288. /* Convert single byte 8bit character set sized text to UTF-8
  289.  * Accepts: source sized text
  290.  *     pointer to return sized text
  291.  *     conversion table
  292.  */
  294. void utf8_text_1byte8 (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab)
  295. {
  296.   unsigned long i;
  297.   unsigned char *s;
  298.   unsigned int c;
  299.   unsigned short *tbl = (unsigned short *) tab;
  300.   for (ret->size = i = 0; i < text->size; ret->size += UTF8_SIZE (c))
  301.     c = tbl[text->data[i++]];
  302.   s = ret->data = (unsigned char *) fs_get (ret->size + 1);
  303.   for (i = 0; i < text->size;) {
  304.     c = tbl[text->data[i++]];
  305.     UTF8_PUT (s,c) /* convert Unicode to UTF-8 */
  306.   }
  307. }
  309. /* Convert EUC sized text to UTF-8
  310.  * Accepts: source sized text
  311.  *     pointer to return sized text
  312.  *     EUC parameter table
  313.  */
  315. void utf8_text_euc (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab)
  316. {
  317.   unsigned long i;
  318.   unsigned char *s;
  319.   unsigned int pass,c,c1,ku,ten;
  320.   struct utf8_eucparam *p1 = (struct utf8_eucparam *) tab;
  321.   struct utf8_eucparam *p2 = p1 + 1;
  322.   struct utf8_eucparam *p3 = p1 + 2;
  323.   unsigned short *t1 = (unsigned short *) p1->tab;
  324.   unsigned short *t2 = (unsigned short *) p2->tab;
  325.   unsigned short *t3 = (unsigned short *) p3->tab;
  326.   for (pass = 0,s = NIL,ret->size = 0; pass <= 1; pass++) {
  327.     for (i = 0; i < text->size;) {
  328. /* not CS0? */
  329.       if ((c = text->data[i++]) & BIT8) {
  330. /* yes, must have another high byte */
  331. if ((i >= text->size) || !((c1 = text->data[i++]) & BIT8))
  332.   c = BOGON; /* out of space or bogon */
  333. else switch (c) { /* check 8bit code set */
  334. case EUC_CS2: /* CS2 */
  335.   if (p2->base_ku) { /* CS2 set up? */
  336.     if (p2->base_ten) /* yes, multibyte? */
  337.       c = ((i < text->size) && ((c = text->data[i++]) & BIT8) &&
  338.    ((ku = (c1 & BITS7) - p2->base_ku) < p2->max_ku) &&
  339.    ((ten = (c & BITS7) - p2->base_ten) < p2->max_ten)) ?
  340.      t2[(ku*p2->max_ten) + ten] : BOGON;
  341.     else c = ((c1 >= p2->base_ku) && (c1 <= p2->max_ku)) ?
  342.       c1 + ((unsigned int) p2->tab) : BOGON;
  343.   }   
  344.   else { /* CS2 not set up */
  345.     c = BOGON; /* swallow byte, say bogon */
  346.     if (i < text->size) i++;
  347.   }
  348.   break;
  349. case EUC_CS3: /* CS3 */
  350.   if (p3->base_ku) { /* CS3 set up? */
  351.     if (p3->base_ten) /* yes, multibyte? */
  352.       c = ((i < text->size) && ((c = text->data[i++]) & BIT8) &&
  353.    ((ku = (c1 & BITS7) - p3->base_ku) < p3->max_ku) &&
  354.    ((ten = (c & BITS7) - p3->base_ten) < p3->max_ten)) ?
  355.      t3[(ku*p3->max_ten) + ten] : BOGON;
  356.     else c = ((c1 >= p3->base_ku) && (c1 <= p3->max_ku)) ?
  357.       c1 + ((unsigned int) p3->tab) : BOGON;
  358.   }   
  359.   else { /* CS3 not set up */
  360.     c = BOGON; /* swallow byte, say bogon */
  361.     if (i < text->size) i++;
  362.   }
  363.   break;
  365. default:
  366.   if (((ku = (c & BITS7) - p1->base_ku) < p1->max_ku) &&
  367.        ((ten = (c1 & BITS7) - p1->base_ten) < p1->max_ten)) {
  368.     if (!(c = t1[(ku*p1->max_ten) + ten]) &&
  369. ku && (ku < 10) && t3 && p3->base_ten)
  370. /* special hack for JIS X 0212: merge rows less than 10 */
  371.       c = t3[((ku - (p3->base_ku - p1->base_ku))*p3->max_ten) + ten];
  372.   }
  373.   else c = BOGON;
  374. }
  375.       }
  376.       if (pass) UTF8_PUT (s,c)
  377.       else ret->size += UTF8_SIZE (c);
  378.     }
  379.     if (!pass) s = ret->data = (unsigned char *) fs_get (ret->size + 1);
  380.   }
  381. }
  384. /* Convert ASCII + double-byte sized text to UTF-8
  385.  * Accepts: source sized text
  386.  *     pointer to return sized text
  387.  *     conversion table
  388.  */
  390. void utf8_text_dbyte (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab)
  391. {
  392.   unsigned long i;
  393.   unsigned char *s;
  394.   unsigned int c,c1,ku,ten;
  395.   struct utf8_eucparam *p1 = (struct utf8_eucparam *) tab;
  396.   unsigned short *t1 = (unsigned short *) p1->tab;
  397.   for (ret->size = i = 0; i < text->size; ret->size += UTF8_SIZE (c))
  398.     if ((c = text->data[i++]) & BIT8)
  399.       c = ((i < text->size) && (c1 = text->data[i++]) &&
  400.    ((ku = c - p1->base_ku) < p1->max_ku) &&
  401.    ((ten = c1 - p1->base_ten) < p1->max_ten)) ?
  402.      t1[(ku*p1->max_ten) + ten] : BOGON;
  403.   s = ret->data = (unsigned char *) fs_get (ret->size + 1);
  404.   for (i = 0; i < text->size;) {
  405.     if ((c = text->data[i++]) & BIT8)
  406.       c = ((i < text->size) && (c1 = text->data[i++]) &&
  407.    ((ku = c - p1->base_ku) < p1->max_ku) &&
  408.    ((ten = c1 - p1->base_ten) < p1->max_ten)) ?
  409.      t1[(ku*p1->max_ten) + ten] : BOGON;
  410.     UTF8_PUT (s,c) /* convert Unicode to UTF-8 */
  411.   }
  412. }
  414. /* Convert ASCII + double byte 2 plane sized text to UTF-8
  415.  * Accepts: source sized text
  416.  *     pointer to return sized text
  417.  *     conversion table
  418.  */
  420. void utf8_text_dbyte2 (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab)
  421. {
  422.   unsigned long i,j;
  423.   unsigned char *s;
  424.   unsigned int c,c1,ku,ten;
  425.   struct utf8_eucparam *p1 = (struct utf8_eucparam *) tab;
  426.   struct utf8_eucparam *p2 = p1 + 1;
  427.   unsigned short *t = (unsigned short *) p1->tab;
  428.   for (ret->size = i = 0; i < text->size; ret->size += UTF8_SIZE (c))
  429.     if ((c = text->data[i++]) & BIT8) {
  430.       if ((i >= text->size) || !(c1 = text->data[i++]))
  431. c = BOGON; /* out of space or bogon */
  432.       else if (c1 & BIT8) /* high vs. low plane */
  433. c = ((ku = c - p2->base_ku) < p2->max_ku &&
  434.      ((ten = c1 - p2->base_ten) < p2->max_ten)) ?
  435.        t[(ku*(p1->max_ten + p2->max_ten)) + p1->max_ten + ten] : BOGON;
  436.       else c = ((ku = c - p1->base_ku) < p1->max_ku &&
  437. ((ten = c1 - p1->base_ten) < p1->max_ten)) ?
  438.   t[(ku*(p1->max_ten + p2->max_ten)) + ten] : BOGON;
  439.     }
  440.   s = ret->data = (unsigned char *) fs_get (ret->size + 1);
  441.   for (i = j = 0; i < text->size;) {
  442.     if ((c = text->data[i++]) & BIT8) {
  443.       if ((i >= text->size) || !(c1 = text->data[i++]))
  444. c = BOGON; /* out of space or bogon */
  445.       else if (c1 & BIT8) /* high vs. low plane */
  446. c = ((ku = c - p2->base_ku) < p2->max_ku &&
  447.      ((ten = c1 - p2->base_ten) < p2->max_ten)) ?
  448.        t[(ku*(p1->max_ten + p2->max_ten)) + p1->max_ten + ten] : BOGON;
  449.       else c = ((ku = c - p1->base_ku) < p1->max_ku &&
  450. ((ten = c1 - p1->base_ten) < p1->max_ten)) ?
  451.   t[(ku*(p1->max_ten + p2->max_ten)) + ten] : BOGON;
  452.     }
  453.     UTF8_PUT (s,c) /* convert Unicode to UTF-8 */
  454.   }
  455. }
  457. #ifdef JISTOUNICODE /* Japanese */
  458. /* Convert Shift JIS sized text to UTF-8
  459.  * Accepts: source sized text
  460.  *     pointer to return sized text
  461.  *     conversion table
  462.  */
  464. void utf8_text_sjis (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab)
  465. {
  466.   unsigned long i;
  467.   unsigned char *s;
  468.   unsigned int c,c1,ku,ten;
  469.   for (ret->size = i = 0; i < text->size; ret->size += UTF8_SIZE (c))
  470.     if ((c = text->data[i++]) & BIT8) {
  471. /* half-width katakana */
  472.       if ((c >= MIN_KANA_8) && (c <= MAX_KANA_8)) c += KANA_8;
  473.       else if (i >= text->size) c = BOGON;
  474.       else { /* Shift-JIS */
  475. c1 = text->data[i++];
  476. SJISTOJIS (c,c1);
  477. c = JISTOUNICODE (c,c1,ku,ten);
  478.       }
  479.     }
  480.   s = ret->data = (unsigned char *) fs_get (ret->size + 1);
  481.   for (i = 0; i < text->size;) {
  482.     if ((c = text->data[i++]) & BIT8) {
  483. /* half-width katakana */
  484.       if ((c >= MIN_KANA_8) && (c <= MAX_KANA_8)) c += KANA_8;
  485.       else { /* Shift-JIS */
  486. c1 = text->data[i++];
  487. SJISTOJIS (c,c1);
  488. c = JISTOUNICODE (c,c1,ku,ten);
  489.       }
  490.     }
  491.     UTF8_PUT (s,c) /* convert Unicode to UTF-8 */
  492.   }
  493. }
  494. #endif
  496. /* Convert ISO-2022 sized text to UTF-8
  497.  * Accepts: source sized text
  498.  *     pointer to returned sized text
  499.  *     conversion table
  500.  */
  502. void utf8_text_2022 (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab)
  503. {
  504.   unsigned long i;
  505.   unsigned char *s;
  506.   unsigned int pass,state,c,co,gi,gl,gr,g[4],ku,ten;
  507.   for (pass = 0,s = NIL,ret->size = 0; pass <= 1; pass++) {
  508.     gi = 0; /* quell compiler warnings */
  509.     state = I2S_CHAR; /* initialize engine */
  510.     g[0]= g[2] = I2CS_ASCII; /* G0 and G2 are ASCII */
  511.     g[1]= g[3] = I2CS_ISO8859_1;/* G1 and G3 are ISO-8850-1 */
  512.     gl = I2C_G0; gr = I2C_G1; /* left is G0, right is G1 */
  513.     for (i = 0; i < text->size;) {
  514.       c = text->data[i++];
  515.       switch (state) { /* dispatch based upon engine state */
  516.       case I2S_ESC: /* ESC seen */
  517. switch (c) { /* process intermediate character */
  518. case I2C_MULTI: /* multibyte character? */
  519.   state = I2S_MUL; /* mark multibyte flag seen */
  520.   break;
  521.         case I2C_SS2: /* single shift GL to G2 */
  522. case I2C_SS2_ALT: /* Taiwan SeedNet */
  523.   gl |= I2C_SG2;
  524.   break;
  525.         case I2C_SS3: /* single shift GL to G3 */
  526. case I2C_SS3_ALT: /* Taiwan SeedNet */
  527.   gl |= I2C_SG3;
  528.   break;
  529.         case I2C_LS2: /* shift GL to G2 */
  530.   gl = I2C_G2;
  531.   break;
  532.         case I2C_LS3: /* shift GL to G3 */
  533.   gl = I2C_G3;
  534.   break;
  535.         case I2C_LS1R: /* shift GR to G1 */
  536.   gr = I2C_G1;
  537.   break;
  538.         case I2C_LS2R: /* shift GR to G2 */
  539.   gr = I2C_G2;
  540.   break;
  541.         case I2C_LS3R: /* shift GR to G3 */
  542.   gr = I2C_G3;
  543.   break;
  544. case I2C_G0_94: case I2C_G1_94: case I2C_G2_94: case I2C_G3_94:
  545.   g[gi = c - I2C_G0_94] = (state == I2S_MUL) ? I2CS_94x94 : I2CS_94;
  546.   state = I2S_INT; /* ready for character set */
  547.   break;
  548. case I2C_G0_96: case I2C_G1_96: case I2C_G2_96: case I2C_G3_96:
  549.   g[gi = c - I2C_G0_96] = (state == I2S_MUL) ? I2CS_96x96 : I2CS_96;
  550.   state = I2S_INT; /* ready for character set */
  551.   break;
  552. default: /* bogon */
  553.   if (pass) *s++ = I2C_ESC,*s++ = c;
  554.   else ret->size += 2;
  555.   state = I2S_CHAR; /* return to previous state */
  556. }
  557. break;
  559.       case I2S_MUL: /* ESC $ */
  560. switch (c) { /* process multibyte intermediate character */
  561. case I2C_G0_94: case I2C_G1_94: case I2C_G2_94: case I2C_G3_94:
  562.   g[gi = c - I2C_G0_94] = I2CS_94x94;
  563.   state = I2S_INT; /* ready for character set */
  564.   break;
  565. case I2C_G0_96: case I2C_G1_96: case I2C_G2_96: case I2C_G3_96:
  566.   g[gi = c - I2C_G0_96] = I2CS_96x96;
  567.   state = I2S_INT; /* ready for character set */
  568.   break;
  569. default: /* probably omitted I2CS_94x94 */
  570.   g[gi = I2C_G0] = I2CS_94x94 | c;
  571.   state = I2S_CHAR; /* return to character state */
  572. }
  573. break;
  574.       case I2S_INT:
  575. state = I2S_CHAR; /* return to character state */
  576. g[gi] |= c; /* set character set */
  577. break;
  579.       case I2S_CHAR: /* character data */
  580. switch (c) {
  581. case I2C_ESC: /* ESC character */
  582.   state = I2S_ESC; /* see if ISO-2022 prefix */
  583.   break;
  584. case I2C_SI: /* shift GL to G0 */
  585.   gl = I2C_G0;
  586.   break;
  587. case I2C_SO: /* shift GL to G1 */
  588.   gl = I2C_G1;
  589.   break;
  590.         case I2C_SS2_ALT: /* single shift GL to G2 */
  591. case I2C_SS2_ALT_7:
  592.   gl |= I2C_SG2;
  593.   break;
  594.         case I2C_SS3_ALT: /* single shift GL to G3 */
  595. case I2C_SS3_ALT_7:
  596.   gl |= I2C_SG3;
  597.   break;
  599. default: /* ordinary character */
  600.   co = c; /* note original character */
  601.   if (gl & (3 << 2)) { /* single shifted? */
  602.     gi = g[gl >> 2]; /* get shifted character set */
  603.     gl &= 0x3; /* cancel shift */
  604.   }
  605. /* select left or right half */
  606.   else gi = (c & BIT8) ? g[gr] : g[gl];
  607.   c &= BITS7; /* make 7-bit */
  608.   switch (gi) { /* interpret in character set */
  609.   case I2CS_ASCII: /* ASCII */
  610.     break; /* easy! */
  611.   case I2CS_BRITISH: /* British ASCII */
  612. /* Pound sterling sign */
  613.     if (c == 0x23) c = UCS2_POUNDSTERLING;
  614.     break;
  615.   case I2CS_JIS_ROMAN: /* JIS Roman */
  616.   case I2CS_JIS_BUGROM: /* old bugs */
  617.     switch (c) { /* two exceptions to ASCII */
  618.     case 0x5c: /* Yen sign */
  619.       c = UCS2_YEN;
  620.       break;
  621.     case 0x7e: /* overline */
  622.       c = UCS2_OVERLINE;
  623.       break;
  624.     }
  625.     break;
  626.   case I2CS_JIS_KANA: /* JIS katakana */
  627.     if ((c >= MIN_KANA_7) && (c <= MAX_KANA_7)) c += KANA_7;
  628.     break;
  630.   case I2CS_ISO8859_1: /* Latin-1 (West European) */
  631.     c |= BIT8; /* just turn on high bit */
  632.     break;
  633.   case I2CS_ISO8859_2: /* Latin-2 (Czech, Slovak) */
  634.     c = iso8859_2tab[c];
  635.     break;
  636.   case I2CS_ISO8859_3: /* Latin-3 (Dutch, Turkish) */
  637.     c = iso8859_3tab[c];
  638.     break;
  639.   case I2CS_ISO8859_4: /* Latin-4 (Scandinavian) */
  640.     c = iso8859_4tab[c];
  641.     break;
  642.   case I2CS_ISO8859_5: /* Cyrillic */
  643.     c = iso8859_5tab[c];
  644.     break;
  645.   case I2CS_ISO8859_6: /* Arabic */
  646.     c = iso8859_6tab[c];
  647.     break;
  648.   case I2CS_ISO8859_7: /* Greek */
  649.     c = iso8859_7tab[c];
  650.     break;
  651.   case I2CS_ISO8859_8: /* Hebrew */
  652.     c = iso8859_8tab[c];
  653.     break;
  654.   case I2CS_ISO8859_9: /* Latin-5 (Finnish, Portuguese) */
  655.     c = iso8859_9tab[c];
  656.     break;
  657.   case I2CS_TIS620: /* Thai */
  658.     c = tis620tab[c];
  659.     break;
  660.   case I2CS_ISO8859_10: /* Latin-6 (Northern Europe) */
  661.     c = iso8859_10tab[c];
  662.     break;
  663.   case I2CS_ISO8859_13: /* Latin-7 (Baltic) */
  664.     c = iso8859_13tab[c];
  665.     break;
  666.   case I2CS_VSCII: /* Vietnamese */
  667.     c = visciitab[c];
  668.     break;
  669.   case I2CS_ISO8859_14: /* Latin-8 (Celtic) */
  670.     c = iso8859_14tab[c];
  671.     break;
  672.   case I2CS_ISO8859_15: /* Euro */
  673.     c = iso8859_15tab[c];
  674.     break;
  676.   default: /* all other character sets */
  677. /* multibyte character set */
  678.     if ((gi & I2CS_MUL) && !(c & BIT8) && isgraph (c)) {
  679.       c = (i < text->size) ? text->data[i++] : 0;
  680.       switch (gi) {
  681. #ifdef GBTOUNICODE
  682.       case I2CS_GB: /* GB 2312 */
  683. c = GBTOUNICODE (co,c,ku,ten);
  684. break;
  685. #endif
  686. #ifdef JISTOUNICODE
  687.       case I2CS_JIS_OLD:/* JIS X 0208-1978 */
  688.       case I2CS_JIS_NEW:/* JIS X 0208-1983 */
  689. c = JISTOUNICODE (co,c,ku,ten);
  690. break;
  691. #endif
  692. #ifdef JIS0212TOUNICODE
  693.       case I2CS_JIS_EXT:/* JIS X 0212-1990 */
  694. c = JIS0212TOUNICODE (co,c,ku,ten);
  695. break;
  696. #endif
  697. #ifdef KSCTOUNICODE
  698.       case I2CS_KSC: /* KSC 5601 */
  699. co |= BIT8; /* make into EUC */
  700. c |= BIT8;
  701. c = KSCTOUNICODE (co,c,ku,ten);
  702. break;
  703. #endif
  704. #ifdef CNS1TOUNICODE
  705.       case I2CS_CNS1: /* CNS 11643 plane 1 */
  706. c = CNS1TOUNICODE (co,c,ku,ten);
  707. break;
  708. #endif
  709. #ifdef CNS2TOUNICODE
  710.       case I2CS_CNS2: /* CNS 11643 plane 2 */
  711. c = CNS2TOUNICODE (co,c,ku,ten);
  712. break;
  713. #endif
  714. #ifdef CNS3TOUNICODE
  715.       case I2CS_CNS3: /* CNS 11643 plane 3 */
  716. c = CNS3TOUNICODE (co,c,ku,ten);
  717. break;
  718. #endif
  719. #ifdef CNS4TOUNICODE
  720.       case I2CS_CNS4: /* CNS 11643 plane 4 */
  721. c = CNS4TOUNICODE (co,c,ku,ten);
  722. break;
  723. #endif
  724. #ifdef CNS5TOUNICODE
  725.       case I2CS_CNS5: /* CNS 11643 plane 5 */
  726. c = CNS5TOUNICODE (co,c,ku,ten);
  727. break;
  728. #endif
  729. #ifdef CNS6TOUNICODE
  730.       case I2CS_CNS6: /* CNS 11643 plane 6 */
  731. c = CNS6TOUNICODE (co,c,ku,ten);
  732. break;
  733. #endif
  734. #ifdef CNS7TOUNICODE
  735.       case I2CS_CNS7: /* CNS 11643 plane 7 */
  736. c = CNS7TOUNICODE (co,c,ku,ten);
  737. break;
  738. #endif
  739.       default: /* unknown multibyte, treat as UCS-2 */
  740. c |= (co << 8); /* wrong, but nothing else to do */
  741. break;
  742.       }
  743.     }
  744.     else c = co; /* unknown single byte, treat as 8859-1 */
  745.   }
  746.   if (pass) UTF8_PUT (s,c)
  747.   else ret->size += UTF8_SIZE (c);
  748. }
  749.       }
  750.     }
  751.     if (!pass) s = ret->data = (unsigned char *) fs_get (ret->size + 1);
  752.     else if (((unsigned long) (s - ret->data)) != ret->size)
  753.       fatal ("ISO-2022 to UTF-8 botch");
  754.   }
  755. }
  757. /* Convert UTF-7 sized text to UTF-8
  758.  * Accepts: source sized text
  759.  *     pointer to returned sized text
  760.  *     conversion table
  761.  */
  763. void utf8_text_utf7 (SIZEDTEXT *text,SIZEDTEXT *ret,void *tab)
  764. {
  765.   unsigned long i;
  766.   unsigned char *s;
  767.   unsigned int c,c1,d,uc,pass,e,e1,state;
  768.   for (pass = 0,s = NIL,ret->size = 0; pass <= 1; pass++) {
  769.     c1 = d = uc = e = e1 = 0;
  770.     for (i = 0,state = NIL; i < text->size;) {
  771.       c = text->data[i++]; /* get next byte */
  772.       switch (state) {
  773.       case U7_PLUS: /* previous character was + */
  774. if (c == '-') { /* +- means textual + */
  775.   c = '+';
  776.   state = U7_ASCII; /* revert to ASCII */
  777.   break;
  778. }
  779. state = U7_UNICODE; /* enter Unicode state */
  780. e = e1 = 0; /* initialize Unicode quantum position */
  781.       case U7_UNICODE: /* Unicode state */
  782. if (c == '-') state = U7_MINUS;
  783. else { /* decode Unicode */
  784.   if (isupper (c)) c -= 'A';
  785.   else if (islower (c)) c -= 'a' - 26;
  786.   else if (isdigit (c)) c -= '0' - 52;
  787.   else if (c == '+') c = 62;
  788.   else if (c == '/') c = 63;
  789.   else state = U7_ASCII;/* end of modified BASE64 */
  790. }
  791. break;
  792.       case U7_MINUS: /* previous character was absorbed - */
  793. state = U7_ASCII; /* revert to ASCII */
  794.       case U7_ASCII: /* ASCII state */
  795. if (c == '+') state = U7_PLUS;
  796. break;
  797.       }
  799.       switch (state) { /* store character if in character mode */
  800.       case U7_UNICODE: /* Unicode */
  801. switch (e++) { /* install based on BASE64 state */
  802. case 0:
  803.   c1 = c << 2; /* byte 1: high 6 bits */
  804.   break;
  805. case 1:
  806.   d = c1 | (c >> 4); /* byte 1: low 2 bits */
  807.   c1 = c << 4; /* byte 2: high 4 bits */
  808.   break;
  809. case 2:
  810.   d = c1 | (c >> 2); /* byte 2: low 4 bits */
  811.   c1 = c << 6; /* byte 3: high 2 bits */
  812.   break;
  813. case 3:
  814.   d = c | c1; /* byte 3: low 6 bits */
  815.   e = 0; /* reinitialize mechanism */
  816.   break;
  817. }
  818. if (e == 1) break; /* done if first BASE64 state */
  819. if (!e1) { /* first byte of UCS-2 character */
  820.   uc = (d & 0xff) << 8; /* note first byte */
  821.   e1 = T; /* enter second UCS-2 state */
  822.   break; /* done */
  823. }
  824. c = uc | (d & 0xff); /* build UCS-2 character */
  825. e1 = NIL; /* back to first UCS-2 state, drop in */
  826.       case U7_ASCII: /* just install if ASCII */
  827. if (pass) UTF8_PUT (s,c)
  828. else ret->size += UTF8_SIZE (c);
  829.       }
  830.     }
  831.     if (!pass) s = ret->data = (unsigned char *) fs_get (ret->size + 1);
  832.     else if (((unsigned long) (s - ret->data)) != ret->size)
  833.       fatal ("UTF-7 to UTF-8 botch");
  834.   }
  835. }
  837. /* Convert charset labelled searchpgm to UTF-8 in place
  838.  * Accepts: search program
  839.  *     charset
  840.  */
  842. void utf8_searchpgm (SEARCHPGM *pgm,char *charset)
  843. {
  844.   SIZEDTEXT txt;
  845.   SEARCHHEADER *hl;
  846.   SEARCHOR *ol;
  847.   SEARCHPGMLIST *pl;
  848.   if (pgm) { /* must have a search program */
  849.     utf8_stringlist (pgm->bcc,charset);
  850.     utf8_stringlist (pgm->cc,charset);
  851.     utf8_stringlist (pgm->from,charset);
  852.     utf8_stringlist (pgm->to,charset);
  853.     utf8_stringlist (pgm->subject,charset);
  854.     for (hl = pgm->header; hl; hl = hl->next) {
  855.       if (utf8_text (&hl->line,charset,&txt,NIL)) {
  856. fs_give ((void **) &hl->line.data);
  857. hl->line.data = txt.data;
  858. hl->line.size = txt.size;
  859.       }
  860.       if (utf8_text (&hl->text,charset,&txt,NIL)) {
  861. fs_give ((void **) &hl->text.data);
  862. hl->text.data = txt.data;
  863. hl->text.size = txt.size;
  864.       }
  865.     }
  866.     utf8_stringlist (pgm->body,charset);
  867.     utf8_stringlist (pgm->text,charset);
  868.     for (ol = pgm->or; ol; ol = ol->next) {
  869.       utf8_searchpgm (ol->first,charset);
  870.       utf8_searchpgm (ol->second,charset);
  871.     }
  872.     for (pl = pgm->not; pl; pl = pl->next) utf8_searchpgm (pl->pgm,charset);
  873.   }
  874. }
  877. /* Convert charset labelled stringlist to UTF-8 in place
  878.  * Accepts: string list
  879.  *     charset
  880.  */
  882. void utf8_stringlist (STRINGLIST *st,char *charset)
  883. {
  884.   SIZEDTEXT txt;
  885. /* convert entire stringstruct */
  886.   if (st) do if (utf8_text (&st->text,charset,&txt,NIL)) {
  887.     fs_give ((void **) &st->text.data);
  888.     st->text.data = txt.data; /* transfer this text */
  889.     st->text.size = txt.size;
  890.   } while (st = st->next);
  891. }
  893. /* Convert MIME-2 sized text to UTF-8
  894.  * Accepts: source sized text
  895.  *     charset
  896.  * Returns: T if successful, NIL if failure
  897.  */
  899. #define MINENCWORD 9
  901. long utf8_mime2text (SIZEDTEXT *src,SIZEDTEXT *dst)
  902. {
  903.   unsigned char *s,*se,*e,*ee,*t,*te;
  904.   char *cs,*ce,*ls;
  905.   SIZEDTEXT txt,rtxt;
  906.   unsigned long i;
  907.   dst->data = NIL; /* default is no encoded words */
  908. /* look for encoded words */
  909.   for (s = src->data, se = src->data + src->size; s < se; s++) {
  910.     if (((se - s) > MINENCWORD) && (*s == '=') && (s[1] == '?') &&
  911.       (cs = (char *) mime2_token (s+2,se,(unsigned char **) &ce)) &&
  912. (e = mime2_token ((unsigned char *) ce+1,se,&ee)) &&
  913. (t = mime2_text (e+2,se,&te)) && (ee == e + 1)) {
  914.       if (mime2_decode (e,t,te,&txt)) {
  915. *ce = ''; /* temporarily tie off charset */
  916. if (ls = strchr (cs,'*')) *ls = '';
  917. if (utf8_text (&txt,cs,&rtxt,NIL)) {
  918.   if (!dst->data) { /* need to create buffer now? */
  919. /* allocate for worst case */
  920.     dst->data = (unsigned char *)
  921.       fs_get ((size_t) ((src->size / 8) + 1) * 9);
  922.     memcpy (dst->data,src->data,(size_t) (dst->size = s - src->data));
  923.   }
  924.   for (i=0; i < rtxt.size; i++) dst->data[dst->size++] = rtxt.data[i];
  925. /* all done with converted text */
  926.   if (rtxt.data != txt.data) fs_give ((void **) &rtxt.data);
  927. }
  928. if (ls) *ls = '*'; /* restore language tag delimiter */
  929. *ce = '?'; /* restore charset delimiter */
  930. /* all done with decoded text */
  931. fs_give ((void **) &txt.data);
  932. s = te+1; /* continue scan after encoded word */
  934. /* skip leading whitespace */
  935. for (t = s + 1; (t < se) && ((*t == ' ') || (*t == 't')); t++);
  936. /* see if likely continuation encoded word */
  937. if (t < (se - MINENCWORD)) switch (*t) {
  938. case '=': /* possible encoded word? */
  939.   if (t[1] == '?') s = t - 1;
  940.   break;
  941. case '15': /* CR, eat a following LF */
  942.   if (t[1] == '12') t++;
  943. case '12': /* possible end of logical line */
  944.   if ((t[1] == ' ') || (t[1] == 't')) {
  945.     do t++;
  946.     while ((t < (se - MINENCWORD)) && ((t[1] == ' ')||(t[1] == 't')));
  947.     if ((t < (se - MINENCWORD)) && (t[1] == '=') && (t[2] == '?'))
  948.       s = t; /* definitely looks like continuation */
  949.   }
  950. }
  951.       }
  952.       else { /* restore original text */
  953. if (dst->data) fs_give ((void **) &dst->data);
  954. dst->data = src->data;
  955. dst->size = src->size;
  956. return NIL; /* syntax error: MIME-2 decoding failure */
  957.       }
  958.     }
  959. /* stash ordinary character */
  960.     else if (dst->data) dst->data[dst->size++] = *s;
  961.   }
  962.   if (dst->data) dst->data[dst->size] = '';
  963.   else { /* nothing converted, return identity */
  964.     dst->data = src->data;
  965.     dst->size = src->size;
  966.   }
  967.   return T; /* success */
  968. }
  970. /* Decode MIME-2 text
  971.  * Accepts: Encoding
  972.  *     text
  973.  *     text end
  974.  *     destination sized text
  975.  * Returns: T if successful, else NIL
  976.  */
  978. long mime2_decode (unsigned char *e,unsigned char *t,unsigned char *te,
  979.    SIZEDTEXT *txt)
  980. {
  981.   unsigned char *q;
  982.   txt->data = NIL; /* initially no returned data */
  983.   switch (*e) { /* dispatch based upon encoding */
  984.   case 'Q': case 'q': /* sort-of QUOTED-PRINTABLE */
  985.     txt->data = (unsigned char *) fs_get ((size_t) (te - t) + 1);
  986.     for (q = t,txt->size = 0; q < te; q++) switch (*q) {
  987.     case '=': /* quoted character */
  988. /* both must be hex */
  989.       if (!isxdigit (q[1]) || !isxdigit (q[2])) {
  990. fs_give ((void **) &txt->data);
  991. return NIL; /* syntax error: bad quoted character */
  992.       }
  993.       txt->data[txt->size++] = /* assemble character */
  994. ((q[1] - (isdigit (q[1]) ? '0' :
  995.   ((isupper (q[1]) ? 'A' : 'a') - 10))) << 4) +
  996.     (q[2] - (isdigit (q[2]) ? '0' :
  997.      ((isupper (q[2]) ? 'A' : 'a') - 10)));
  998.       q += 2; /* advance past quoted character */
  999.       break;
  1000.     case '_': /* convert to space */
  1001.       txt->data[txt->size++] = ' ';
  1002.       break;
  1003.     default: /* ordinary character */
  1004.       txt->data[txt->size++] = *q;
  1005.       break;
  1006.     }
  1007.     txt->data[txt->size] = '';
  1008.     break;
  1009.   case 'B': case 'b': /* BASE64 */
  1010.     if (txt->data = (unsigned char *) rfc822_base64 (t,te - t,&txt->size))
  1011.       break;
  1012.   default: /* any other encoding is unknown */
  1013.     return NIL; /* syntax error: unknown encoding */
  1014.   }
  1015.   return T;
  1016. }
  1018. /* Get MIME-2 token from encoded word
  1019.  * Accepts: current text pointer
  1020.  *     text limit pointer
  1021.  *     pointer to returned end pointer
  1022.  * Returns: current text pointer & end pointer if success, else NIL
  1023.  */
  1025. unsigned char *mime2_token (unsigned char *s,unsigned char *se,
  1026.     unsigned char **t)
  1027. {
  1028.   for (*t = s; **t != '?'; ++*t) {
  1029.     if ((*t < se) && isgraph (**t)) switch (**t) {
  1030.     case '(': case ')': case '<': case '>': case '@': case ',': case ';':
  1031.     case ':': case '\': case '"': case '/': case '[': case ']': case '.':
  1032.     case '=':
  1033.       return NIL; /* none of these are valid in tokens */
  1034.     }
  1035.     else return NIL; /* out of text or CTL or space */
  1036.   }
  1037.   return s;
  1038. }
  1041. /* Get MIME-2 text from encoded word
  1042.  * Accepts: current text pointer
  1043.  *     text limit pointer
  1044.  *     pointer to returned end pointer
  1045.  * Returns: current text pointer & end pointer if success, else NIL
  1046.  */
  1048. unsigned char *mime2_text (unsigned char *s,unsigned char *se,
  1049.    unsigned char **t)
  1050. {
  1051. /* make sure valid, search for closing ? */
  1052.   for (*t = s; **t != '?'; ++*t) if ((*t >= se) || !isgraph (**t)) return NIL;
  1053. /* make sure terminated properly */
  1054.   if ((*t)[1] != '=') return NIL;
  1055.   return s;
  1056. }