Changeset 827:08dd55cf4de1 for charset.c

Timestamp:

1999-02-02 07:47:44 (10 years ago)

Author:

Thomas Roessler <roessler@…>

Branch:

HEAD

Message:

Merging the external character set patch into unstable.
Additionally, this change introduces a M_CHARCONV state flag which
gives us some more control about when character set conversions are
actually done. Current versions of mutt would happily apply
character set conversions when, e.g., saving a text/plain attachment
to a file. (We had at least one corrupt russing translation file
due to this mis-feature.)

Additionally, we clean up some of the character set related code in
handler.c. Most of that is now done by the decoder functions in
charset.c.

Files:

• charset.c (modified) (3 diffs)

charset.c

@@ -822 +822 @@
 }
 
-static char *sfu_buffer = NULL;
-static size_t sfu_blen = 0;
-static size_t sfu_bp = 0;
-
-static void _state_utf8_flush(STATE *s, CHARSET *chs)
+/* internal use only */
+
+struct utf8_state
+{
+  char *buffer;
+  size_t blen;
+  size_t bp;
+};
+
+static struct utf8_state *new_utf8_state (void)
+{
+  return safe_calloc (sizeof (struct utf8_state), 1);
+}
+
+static void free_utf8_state (struct utf8_state **sp)
+{
+  if (!sp || !*sp) return;
+  safe_free ((void **) &(*sp)->buffer);
+  safe_free ((void **) sp);
+}
+
+static void _state_utf8_flush(STATE *s, CHARSET *chs, struct utf8_state *sfu)
 {
   char *t;
-  if(!sfu_buffer || !sfu_bp)
+  if(!sfu->buffer || !sfu->bp)
     return;
   
-  sfu_buffer[sfu_bp] = '\0';
-  
-  mutt_decode_utf8_string(sfu_buffer, chs);
-  for(t = sfu_buffer; *t; t++)
+  sfu->buffer[sfu->bp] = '\0';
+  
+  mutt_decode_utf8_string(sfu->buffer, chs);
+  for(t = sfu->buffer; *t; t++)
   {
     /* This may lead to funny-looking output if 
@@ -845 +862 @@
     state_prefix_putc(*t, s);
   }
-  sfu_bp = 0;
+  sfu->bp = 0;
 }
     
-void state_fput_utf8(STATE *st, char u, CHARSET *chs)
-{
-  if((u & 0x80) == 0 || (sfu_bp && (u & IIOOOOOO) != IOOOOOOO))
-    _state_utf8_flush(st, chs);
+static void state_fput_utf8(STATE *st, char u, CHARSET *chs, struct utf8_state *sfu)
+{
+  if((u & 0x80) == 0 || (sfu->bp && (u & IIOOOOOO) != IOOOOOOO))
+    _state_utf8_flush(st, chs, sfu);
      
   if((u & 0x80) == 0)
@@ -859 +876 @@
   else
   {
-    if(sfu_bp + 1 >= sfu_blen)
-    {
-      sfu_blen = (sfu_blen + 80) * 2;
-      safe_realloc((void **) &sfu_buffer, sfu_blen);
-    }
-    sfu_buffer[sfu_bp++] = u;
-  }
-}
-
+    if(sfu->bp + 1 >= sfu->blen)
+    {
+      sfu->blen = (sfu->blen + 80) * 2;
+      safe_realloc((void **) &sfu->buffer, sfu->blen);
+    }
+    sfu->buffer[sfu->bp++] = u;
+  }
+}
+
+/* a nicer interface for decoding */
+
+DECODER *mutt_open_decoder (STATE *s, BODY *b, int istext)
+{
+  DECODER *dp = safe_calloc (sizeof (DECODER), 1);
+  
+  dp->s = s;
+  
+  if (istext && (s->flags & M_CHARCONV))
+  {
+    char *charset = mutt_get_parameter ("charset", b->parameter);
+    dp->is_utf8 = mutt_is_utf8 (charset) && !mutt_is_utf8 (Charset);
+    
+    if (dp->is_utf8)
+    {
+      dp->sfu = new_utf8_state ();
+      dp->chs = mutt_get_charset (Charset);
+    }
+    else
+      dp->map = mutt_get_translation (charset, Charset);
+  }
+  
+  return dp;
+}
+
+void mutt_close_decoder (DECODER **dpp)
+{
+  if (!dpp || !*dpp)
+    return;
+  
+  if ((*dpp)->is_utf8)
+  {
+    _state_utf8_flush ((*dpp)->s, (*dpp)->chs, (*dpp)->sfu);
+    free_utf8_state (&(*dpp)->sfu);
+  }
+
+  safe_free ((void **) dpp);
+}
+
+void mutt_decoder_putc (DECODER *dp, char c)
+{
+  if (dp->is_utf8)
+    state_fput_utf8 (dp->s, c, dp->chs, dp->sfu);
+  else
+    state_prefix_putc (mutt_display_char ((unsigned char) c, dp->map), dp->s);
+}