[SCM] GNU Mailutils branch, master, updated. rel-2_1-27-g93b51f5

[Sergey Poznyakoff]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Mailutils".

http://git.savannah.gnu.org/cgit/mailutils.git/commit/?id=93b51f57127ffacae8bc15b4e0a7d86aa6338fba

The branch, master has been updated
       via  93b51f57127ffacae8bc15b4e0a7d86aa6338fba (commit)
      from  c29efb856680ddb480b03c12e6f6395b45c7b386 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 93b51f57127ffacae8bc15b4e0a7d86aa6338fba
Author: Sergey Poznyakoff <address@hidden>
Date:   Wed Jan 13 21:00:58 2010 +0200

    Do not use deprecated Guile functions.
    
    * libmu_scm/mu_address.c: Use scm_to_locale_string
    instead of relying on scm_i_string_chars.
    * libmu_scm/mu_logger.c: Likewise.
    * libmu_scm/mu_mailbox.c: Likewise.
    * libmu_scm/mu_scm.c: Likewise.
    * libmu_scm/mu_util.c: Likewise.
    * libmu_scm/mu_message.c: Likewise.
    (mu_scm_message_add_owner): Don't use SCM_NEWCELL.
    (mu-message-get-envelope)
    (mu-message-get-envelope-date): New functions.
    (string_sloppy_member): Compare scm_i_string_length
    bytes from the car.
    (mu-message-get-header-fields): Don't use SCM_NEWCELL.
    * libmu_scm/mu_port.c (mu_port_make_from_stream): Don't use SCM_NEWCELL.

-----------------------------------------------------------------------

Summary of changes:
 libmu_scm/mu_address.c |   25 ++++--
 libmu_scm/mu_logger.c  |    9 ++-
 libmu_scm/mu_mailbox.c |   44 ++++++++---
 libmu_scm/mu_message.c |  192 ++++++++++++++++++++++++++++++++++++------------
 libmu_scm/mu_port.c    |    8 +-
 libmu_scm/mu_scm.c     |    5 +-
 libmu_scm/mu_util.c    |    9 +-
 7 files changed, 212 insertions(+), 80 deletions(-)

diff --git a/libmu_scm/mu_address.c b/libmu_scm/mu_address.c
index 4d193b3..ace89c2 100644
--- a/libmu_scm/mu_address.c
+++ b/libmu_scm/mu_address.c
@@ -42,12 +42,15 @@ _get_address_part (const char *func_name, address_get_fp 
fun,
   else
     num = 1;
 
-  length = strlen (scm_i_string_chars (ADDRESS));
-  if (length == 0)
-    mu_scm_error (func_name, 0,
-                 "Empty address", SCM_BOOL_F);
+  str = scm_to_locale_string (ADDRESS);
+  if (!str[0])
+    {
+      free (str);
+      mu_scm_error (func_name, 0, "Empty address", SCM_BOOL_F);
+    }
   
-  status = mu_address_create (&addr, scm_i_string_chars (ADDRESS));
+  status = mu_address_create (&addr, str);
+  free (str);
   if (status)
     mu_scm_error (func_name, status, "Cannot create address", SCM_BOOL_F);
 
@@ -133,10 +136,13 @@ SCM_DEFINE (scm_mu_address_get_count, 
"mu-address-get-count", 1, 0, 0,
   mu_address_t addr;
   size_t count = 0;
   int status;
+  char *str;
   
   SCM_ASSERT (scm_is_string (ADDRESS), ADDRESS, SCM_ARG1, FUNC_NAME);
 
-  status = mu_address_create (&addr, scm_i_string_chars (ADDRESS));
+  str = scm_to_locale_string (ADDRESS);
+  status = mu_address_create (&addr, str);
+  free (str);
   if (status)
     mu_scm_error (FUNC_NAME, status,
                  "Cannot create address for ~A",
@@ -154,7 +160,7 @@ SCM_DEFINE (scm_mu_username_to_email, "mu-username->email", 
0, 1, 0,
 "current username is assumed\n")
 #define FUNC_NAME s_scm_mu_username_to_email
 {
-  const char *name;
+  char *name;
   char *email;
   SCM ret;
   
@@ -163,14 +169,15 @@ SCM_DEFINE (scm_mu_username_to_email, 
"mu-username->email", 0, 1, 0,
   else
     {
       SCM_ASSERT (scm_is_string (NAME), NAME, SCM_ARG1, FUNC_NAME);
-      name = scm_i_string_chars (NAME);
+      name = scm_to_locale_string (NAME);
     }
 
   email = mu_get_user_email (name);
+  free (name);
   if (!email)
     mu_scm_error (FUNC_NAME, 0,
                  "Cannot get user email for ~A",
-                 scm_list_1 (scm_makfrom0str (name)));
+                 scm_list_1 (NAME));
 
   ret = scm_makfrom0str (email);
   free (email);
diff --git a/libmu_scm/mu_logger.c b/libmu_scm/mu_logger.c
index 8b474d8..5b6d0f4 100644
--- a/libmu_scm/mu_logger.c
+++ b/libmu_scm/mu_logger.c
@@ -27,7 +27,7 @@ SCM_DEFINE (scm_mu_openlog, "mu-openlog", 3, 0, 0,
 "IDENT, OPTION and FACILITY have the same meaning as in openlog(3)")
 #define FUNC_NAME s_scm_mu_openlog
 {
-  const char *ident;
+  char *ident, *ident_mem = NULL;
   int option, facility;
 
   if (IDENT == SCM_BOOL_F)
@@ -35,7 +35,7 @@ SCM_DEFINE (scm_mu_openlog, "mu-openlog", 3, 0, 0,
   else
     {
       SCM_ASSERT (scm_is_string (IDENT), IDENT, SCM_ARG1, FUNC_NAME);
-      ident = scm_i_string_chars (IDENT);
+      ident = ident_mem = scm_to_locale_string (IDENT);
     }
        
   if (scm_is_integer (OPTION))
@@ -53,6 +53,7 @@ SCM_DEFINE (scm_mu_openlog, "mu-openlog", 3, 0, 0,
     SCM_ASSERT (0, FACILITY, SCM_ARG3, FUNC_NAME);
 
   openlog (ident, option, facility);
+  free (ident_mem);
   return SCM_UNSPECIFIED;
 }
 #undef FUNC_NAME
@@ -63,6 +64,7 @@ SCM_DEFINE (scm_mu_logger, "mu-logger", 2, 0, 0,
 #define FUNC_NAME s_scm_mu_logger
 {
   int prio;
+  char *str;
 
   if (PRIO == SCM_BOOL_F) 
     prio = LOG_INFO;
@@ -74,7 +76,8 @@ SCM_DEFINE (scm_mu_logger, "mu-logger", 2, 0, 0,
     SCM_ASSERT (0, PRIO, SCM_ARG1, FUNC_NAME);
   
   SCM_ASSERT (scm_is_string (TEXT), TEXT, SCM_ARG2, FUNC_NAME);
-  syslog (prio, "%s", scm_i_string_chars (TEXT));
+  str = scm_to_locale_string (TEXT);
+  syslog (prio, "%s", str);
   return SCM_UNSPECIFIED;
 }
 #undef FUNC_NAME
diff --git a/libmu_scm/mu_mailbox.c b/libmu_scm/mu_mailbox.c
index 82dd745..dbc56df 100644
--- a/libmu_scm/mu_mailbox.c
+++ b/libmu_scm/mu_mailbox.c
@@ -149,11 +149,13 @@ SCM_DEFINE (scm_mu_user_mailbox_url, 
"mu-user-mailbox-url", 1, 0, 0,
 #define FUNC_NAME s_scm_mu_user_mailbox_url
 {
   int rc;
-  char *p;
+  char *p, *str;
   SCM ret;
   
   SCM_ASSERT (scm_is_string (USER), USER, SCM_ARG1, FUNC_NAME);
-  rc = mu_construct_user_mailbox_url (&p, scm_i_string_chars (USER));
+  str = scm_to_locale_string (USER);
+  rc = mu_construct_user_mailbox_url (&p, str);
+  free (str);
   if (rc)
     mu_scm_error (FUNC_NAME, rc,
                  "Cannot construct mailbox URL for ~A",
@@ -172,8 +174,12 @@ SCM_DEFINE (scm_mu_folder_directory, 
"mu-folder-directory", 0, 1, 0,
 {
   if (!SCM_UNBNDP (URL))
     {
+      char *s;
+      
       SCM_ASSERT (scm_is_string (URL), URL, SCM_ARG1, FUNC_NAME);
-      mu_set_folder_directory (scm_i_string_chars (URL));
+      s = scm_to_locale_string (URL);
+      mu_set_folder_directory (s);
+      free (s);
     }
   return scm_makfrom0str (mu_folder_directory ());
 }
@@ -195,14 +201,19 @@ SCM_DEFINE (scm_mu_mailbox_open, "mu-mailbox-open", 2, 0, 
0,
 #define FUNC_NAME s_scm_mu_mailbox_open
 {
   mu_mailbox_t mbox = NULL;
-  const char *mode_str;
+  char *mode_str;
   int mode = 0;
   int status;
-
+  SCM ret;
+  
   SCM_ASSERT (scm_is_string (URL), URL, SCM_ARG1, FUNC_NAME);
   SCM_ASSERT (scm_is_string (MODE), MODE, SCM_ARG2, FUNC_NAME);
-
-  for (mode_str = scm_i_string_chars (MODE); *mode_str; mode_str++)
+  
+  scm_dynwind_begin (0);
+  
+  mode_str = scm_to_locale_string (MODE);
+  scm_dynwind_free (mode_str);
+  for (; *mode_str; mode_str++)
     switch (*mode_str)
       {
       case 'r':
@@ -218,11 +229,14 @@ SCM_DEFINE (scm_mu_mailbox_open, "mu-mailbox-open", 2, 0, 
0,
        mode |= MU_STREAM_CREAT;
        break;
       }
-
+  
   if (mode & MU_STREAM_READ && mode & MU_STREAM_WRITE)
     mode = (mode & ~(MU_STREAM_READ | MU_STREAM_WRITE)) | MU_STREAM_RDWR;
 
-  status = mu_mailbox_create_default (&mbox, scm_i_string_chars (URL));
+  mode_str = scm_to_locale_string (URL);
+  scm_dynwind_free (mode_str);
+  
+  status = mu_mailbox_create_default (&mbox, mode_str);
   if (status)
     mu_scm_error (FUNC_NAME, status,
                  "Cannot create default mailbox ~A",
@@ -237,8 +251,9 @@ SCM_DEFINE (scm_mu_mailbox_open, "mu-mailbox-open", 2, 0, 0,
                    "Cannot open default mailbox ~A",
                    scm_list_1 (URL));
     }
-      
-  return mu_scm_mailbox_create (mbox);
+  ret = mu_scm_mailbox_create (mbox);
+  scm_dynwind_end ();
+  return ret;
 }
 #undef FUNC_NAME
 
@@ -288,6 +303,7 @@ SCM_DEFINE (scm_mu_mailbox_get_port, "mu-mailbox-get-port", 
2, 0, 0,
   struct mu_mailbox *mum;
   mu_stream_t stream;
   int status;
+  char *s;
   
   SCM_ASSERT (mu_scm_is_mailbox (MBOX), MBOX, SCM_ARG1, FUNC_NAME);
   SCM_ASSERT (scm_is_string (MODE), MODE, SCM_ARG2, FUNC_NAME);
@@ -297,8 +313,10 @@ SCM_DEFINE (scm_mu_mailbox_get_port, 
"mu-mailbox-get-port", 2, 0, 0,
     mu_scm_error (FUNC_NAME, status,
                  "Cannot get mailbox stream",
                  scm_list_1 (MBOX));
-  return mu_port_make_from_stream (MBOX, stream,
-                          scm_mode_bits ((char*)scm_i_string_chars (MODE))); 
+  s = scm_to_locale_string (MODE);
+  status = mu_port_make_from_stream (MBOX, stream, scm_mode_bits (s));
+  free (s);
+  return status;
 }
 #undef FUNC_NAME
 
diff --git a/libmu_scm/mu_message.c b/libmu_scm/mu_message.c
index 220e4ad..9e178cd 100644
--- a/libmu_scm/mu_message.c
+++ b/libmu_scm/mu_message.c
@@ -153,18 +153,10 @@ mu_scm_message_add_owner (SCM MESG, SCM owner)
       return;
     }
   
-  SCM_NEWCELL (cell);
-  SCM_SETCAR (cell, owner);
   if (SCM_NIMP (mum->mbox) && SCM_CONSP (mum->mbox))
-    SCM_SETCDR (cell, mum->mbox);
+    cell = scm_cons (owner, mum->mbox);
   else
-    {
-      SCM scm;
-      SCM_NEWCELL (scm);
-      SCM_SETCAR (scm, mum->mbox);
-      SCM_SETCDR (scm, SCM_EOL);
-      SCM_SETCDR (cell, scm);
-    }
+    cell = scm_cons (owner, scm_cons (mum->mbox, SCM_EOL));
   mum->mbox = cell;
 }
 
@@ -283,6 +275,7 @@ SCM_DEFINE (scm_mu_message_set_header, 
"mu-message-set-header", 3, 1, 0,
   mu_header_t hdr;
   int replace = 0;
   int status;
+  char *hdr_c, *val_c;
   
   SCM_ASSERT (mu_scm_is_message (MESG), MESG, SCM_ARG1, FUNC_NAME);
   msg = mu_scm_message_get (MESG);
@@ -302,9 +295,12 @@ SCM_DEFINE (scm_mu_message_set_header, 
"mu-message-set-header", 3, 1, 0,
     mu_scm_error (FUNC_NAME, status,
                  "Cannot get message headers", SCM_BOOL_F);
 
-  status = mu_header_set_value (hdr, scm_i_string_chars (HEADER),
-                               scm_i_string_chars (VALUE),
-                               replace);
+  hdr_c = scm_to_locale_string (HEADER);
+  val_c = scm_to_locale_string (VALUE);
+  status = mu_header_set_value (hdr, hdr_c, val_c, replace);
+  free (hdr_c);
+  free (val_c);
+  
   if (status)
     mu_scm_error (FUNC_NAME, status,
                  "Cannot set header \"~A: ~A\" in message ~A",
@@ -349,6 +345,92 @@ SCM_DEFINE (scm_mu_message_get_lines, 
"mu-message-get-lines", 1, 0, 0,
 }
 #undef FUNC_NAME
 
+static SCM
+filltime (struct tm *bd_time, int zoff, const char *zname)
+{
+  SCM result = scm_c_make_vector (11, SCM_UNDEFINED);
+
+  SCM_SIMPLE_VECTOR_SET (result,0, scm_from_int (bd_time->tm_sec));
+  SCM_SIMPLE_VECTOR_SET (result,1, scm_from_int (bd_time->tm_min));
+  SCM_SIMPLE_VECTOR_SET (result,2, scm_from_int (bd_time->tm_hour));
+  SCM_SIMPLE_VECTOR_SET (result,3, scm_from_int (bd_time->tm_mday));
+  SCM_SIMPLE_VECTOR_SET (result,4, scm_from_int (bd_time->tm_mon));
+  SCM_SIMPLE_VECTOR_SET (result,5, scm_from_int (bd_time->tm_year));
+  SCM_SIMPLE_VECTOR_SET (result,6, scm_from_int (bd_time->tm_wday));
+  SCM_SIMPLE_VECTOR_SET (result,7, scm_from_int (bd_time->tm_yday));
+  SCM_SIMPLE_VECTOR_SET (result,8, scm_from_int (bd_time->tm_isdst));
+  SCM_SIMPLE_VECTOR_SET (result,9, scm_from_int (zoff));
+  SCM_SIMPLE_VECTOR_SET (result,10, (zname
+                                    ? scm_from_locale_string (zname)
+                                    : SCM_BOOL_F));
+  return result;
+}
+
+SCM_DEFINE (scm_mu_message_get_envelope, "mu-message-get-envelope", 1, 0, 0,
+           (SCM MESG),
+           "Returns envelope date of the message MESG.\n")
+#define FUNC_NAME s_scm_mu_message_get_envelope
+{
+  mu_message_t msg;
+  mu_envelope_t env = NULL;
+  int status;
+  const char *sender;
+  const char *date;
+  size_t dlen;
+  
+  SCM_ASSERT (mu_scm_is_message (MESG), MESG, SCM_ARG1, FUNC_NAME);
+  msg = mu_scm_message_get (MESG);
+  status = mu_message_get_envelope (msg, &env);
+  if (status)
+    mu_scm_error (FUNC_NAME, status, "cannot get envelope",
+                 scm_list_1 (MESG));
+  status = mu_envelope_sget_sender (env, &sender);
+  if (status)
+    mu_scm_error (FUNC_NAME, status, "cannot get envelope sender",
+                 scm_list_1 (MESG));
+  status = mu_envelope_sget_date (env, &date);
+  if (status)
+    mu_scm_error (FUNC_NAME, status, "cannot get envelope date",
+                 scm_list_1 (MESG));
+  dlen = strlen (date);
+  if (date[dlen-1] == '\n')
+    dlen--;
+  return scm_string_append (scm_list_3 (scm_from_locale_string (sender),
+                                       scm_from_locale_string (" "),
+                                       scm_from_locale_stringn (date, dlen)));
+}
+#undef FUNC_NAME
+
+SCM_DEFINE (scm_mu_message_get_envelope_date, "mu-message-get-envelope-date", 
1, 0, 0,
+           (SCM MESG),
+           "Returns envelope date of the message MESG.\n")
+#define FUNC_NAME s_scm_mu_message_get_envelope_date
+{
+  mu_message_t msg;
+  mu_envelope_t env = NULL;
+  int status;
+  const char *sdate;
+  struct tm tm;
+  mu_timezone tz;
+  
+  SCM_ASSERT (mu_scm_is_message (MESG), MESG, SCM_ARG1, FUNC_NAME);
+  msg = mu_scm_message_get (MESG);
+  status = mu_message_get_envelope (msg, &env);
+  if (status)
+    mu_scm_error (FUNC_NAME, status, "cannot get envelope",
+                 scm_list_1 (MESG));
+  status = mu_envelope_sget_date (env, &sdate);
+  if (status)
+    mu_scm_error (FUNC_NAME, status, "cannot get envelope date",
+                 scm_list_1 (MESG));
+  status = mu_parse_ctime_date_time (&sdate, &tm, &tz);
+  if (status)
+    mu_scm_error (FUNC_NAME, status, "invalid envelope date",
+                 scm_list_1 (scm_makfrom0str (sdate)));
+  return filltime (&tm, tz.utc_offset, tz.tz_name);  
+}
+#undef FUNC_NAME
+
 SCM_DEFINE (scm_mu_message_get_sender, "mu-message-get-sender", 1, 0, 0,
            (SCM MESG),
            "Returns email address of the sender of the message MESG.\n")
@@ -384,20 +466,21 @@ SCM_DEFINE (scm_mu_message_get_header, 
"mu-message-get-header", 2, 0, 0,
   mu_message_t msg;
   mu_header_t hdr;
   char *value = NULL;
-  const char *header_string;
+  char *header_string;
   SCM ret;
   int status;
   
   SCM_ASSERT (mu_scm_is_message (MESG), MESG, SCM_ARG1, FUNC_NAME);
   msg = mu_scm_message_get (MESG);
   SCM_ASSERT (scm_is_string (HEADER), HEADER, SCM_ARG2, FUNC_NAME);
-  header_string = scm_i_string_chars (HEADER);
   status = mu_message_get_header (msg, &hdr);
   if (status)
     mu_scm_error (FUNC_NAME, status,
                  "Cannot get message headers", SCM_BOOL_F);
 
+  header_string = scm_to_locale_string (HEADER);
   status = mu_header_aget_value (hdr, header_string, &value);
+  free (header_string);
   switch (status)
     {
     case 0:
@@ -426,7 +509,8 @@ string_sloppy_member (SCM lst, char *name)
     {
       SCM car = SCM_CAR (lst);
       if (scm_is_string (car)
-         && mu_c_strcasecmp (scm_i_string_chars (car), name) == 0)
+         && mu_c_strncasecmp (scm_i_string_chars (car), name,
+                              scm_i_string_length (car)) == 0)
        return 1;
     }
   return 0;
@@ -441,7 +525,7 @@ SCM_DEFINE (scm_mu_message_get_header_fields, 
"mu-message-get-header-fields", 1,
   size_t i, nfields = 0;
   mu_message_t msg;
   mu_header_t hdr = NULL;
-  SCM scm_first = SCM_EOL, scm_last;
+  SCM scm_first = SCM_EOL, scm_last = SCM_EOL;
   SCM headers = SCM_EOL;
   int status;
   
@@ -465,7 +549,7 @@ SCM_DEFINE (scm_mu_message_get_header_fields, 
"mu-message-get-header-fields", 1,
   
   for (i = 1; i <= nfields; i++)
     {
-      SCM new_cell, scm_name, scm_value;
+      SCM scm_name, scm_value, scm_new;
       char *name, *value;
       
       status = mu_header_aget_field_name (hdr, i, &name);
@@ -485,22 +569,16 @@ SCM_DEFINE (scm_mu_message_get_header_fields, 
"mu-message-get-header-fields", 1,
       scm_name = scm_makfrom0str (name);
       scm_value = scm_makfrom0str (value);
 
-      SCM_NEWCELL(new_cell);
-      SCM_SETCAR(new_cell, scm_cons(scm_name, scm_value));
+      scm_new = scm_cons (scm_cons (scm_name, scm_value), SCM_EOL);
       
       if (scm_first == SCM_EOL)
-       {
-         scm_first = new_cell;
-         scm_last = scm_first;
-       }
+       scm_first = scm_last = scm_new;
       else
        {
-         SCM_SETCDR(scm_last, new_cell);
-         scm_last = new_cell;
+         SCM_SETCDR (scm_last, scm_new);
+         scm_last = scm_new;
        }
     }
-  if (scm_first != SCM_EOL)
-    SCM_SETCDR(scm_last, SCM_EOL);
   return scm_first;
 }
 #undef FUNC_NAME
@@ -542,6 +620,7 @@ SCM_DEFINE (scm_mu_message_set_header_fields, 
"mu-message-set-header-fields", 2,
     {
       SCM cell = SCM_CAR (list);
       SCM car, cdr;
+      char *hdr_c, *val_c;
       
       SCM_ASSERT (SCM_NIMP (cell) && SCM_CONSP (cell),
                  cell, SCM_ARGn, FUNC_NAME);
@@ -549,9 +628,11 @@ SCM_DEFINE (scm_mu_message_set_header_fields, 
"mu-message-set-header-fields", 2,
       cdr = SCM_CDR (cell);
       SCM_ASSERT (scm_is_string (car), car, SCM_ARGn, FUNC_NAME);
       SCM_ASSERT (scm_is_string (cdr), cdr, SCM_ARGn, FUNC_NAME);
-      status = mu_header_set_value (hdr,
-                                   scm_i_string_chars (car),
-                                   scm_i_string_chars (cdr), replace);
+      hdr_c = scm_to_locale_string (car);
+      val_c = scm_to_locale_string (cdr);
+      status = mu_header_set_value (hdr, hdr_c, val_c, replace);
+      free (hdr_c);
+      free (val_c);
       if (status)
        mu_scm_error (FUNC_NAME, status,
                      "Cannot set header value: message ~A, header ~A, value 
~A",
@@ -831,7 +912,9 @@ SCM_DEFINE (scm_mu_message_get_port, "mu-message-get-port", 
2, 1, 0,
   mu_message_t msg;
   mu_stream_t stream = NULL;
   int status;
-    
+  char *str;
+  SCM ret;
+  
   SCM_ASSERT (mu_scm_is_message (MESG), MESG, SCM_ARG1, FUNC_NAME);
   SCM_ASSERT (scm_is_string (MODE), MODE, SCM_ARG2, FUNC_NAME);
 
@@ -863,9 +946,11 @@ SCM_DEFINE (scm_mu_message_get_port, 
"mu-message-get-port", 2, 1, 0,
        mu_scm_error (FUNC_NAME, status, "Cannot get message body stream",
                      SCM_BOOL_F);
     }
-  
-  return mu_port_make_from_stream (MESG, stream,
-                          scm_mode_bits ((char*)scm_i_string_chars (MODE))); 
+
+  str = scm_to_locale_string (MODE);
+  ret = mu_port_make_from_stream (MESG, stream, scm_mode_bits (str));
+  free (str);
+  return ret;
 }
 #undef FUNC_NAME
   
@@ -962,42 +1047,57 @@ SCM_DEFINE (scm_mu_message_send, "mu-message-send", 1, 
3, 0,
 "in mu-mailer. Optional FROM and TO give sender and recever addresses.\n")
 #define FUNC_NAME s_scm_mu_message_send
 {
-  const char *mailer_name;
+  char *mailer_name;
   mu_address_t from = NULL;
   mu_address_t to = NULL;
   mu_mailer_t mailer = NULL;
   mu_message_t msg;
   int status;
-
+  
   SCM_ASSERT (mu_scm_is_message (MESG), MESG, SCM_ARG1, FUNC_NAME);
   msg = mu_scm_message_get (MESG);
   
   if (!SCM_UNBNDP (MAILER) && MAILER != SCM_BOOL_F)
     {
       SCM_ASSERT (scm_is_string (MAILER), MAILER, SCM_ARG2, FUNC_NAME);
-      mailer_name = scm_i_string_chars (MAILER);
+      mailer_name = scm_to_locale_string (MAILER);
     }
   else
     {
-      SCM val = MU_SCM_SYMBOL_VALUE("mu-mailer");
-      mailer_name = scm_i_string_chars(val);
+      SCM val = MU_SCM_SYMBOL_VALUE ("mu-mailer");
+      mailer_name = scm_to_locale_string (val);
     }
   
   if (!SCM_UNBNDP (FROM) && FROM != SCM_BOOL_F)
     {
-      SCM_ASSERT (scm_is_string (FROM)
-                 && mu_address_create (&from, scm_i_string_chars (FROM)) == 0,
-                 FROM, SCM_ARG3, FUNC_NAME);
+      char *s;
+      int rc;
+      
+      SCM_ASSERT (scm_is_string (FROM), FROM, SCM_ARG3, FUNC_NAME);
+      s = scm_to_locale_string (FROM);
+      rc = mu_address_create (&from, s);
+      free (s);
+      if (rc)
+       mu_scm_error (FUNC_NAME, rc, "cannot create address",
+                     scm_list_1 (FROM));
     }
   
   if (!SCM_UNBNDP (TO) && TO != SCM_BOOL_F)
     {
-      SCM_ASSERT (scm_is_string (TO)
-                 && mu_address_create (&to, scm_i_string_chars (TO)) == 0,
-                 TO, SCM_ARG4, FUNC_NAME);
+      char *s;
+      int rc;
+      
+      SCM_ASSERT (scm_is_string (TO), TO, SCM_ARG4, FUNC_NAME);
+      s = scm_to_locale_string (TO);
+      rc = mu_address_create (&to, s);
+      free (s);
+      if (rc)
+       mu_scm_error (FUNC_NAME, rc, "cannot create address",
+                     scm_list_1 (TO));
     }
 
   status = mu_mailer_create (&mailer, mailer_name);
+  free (mailer_name);
   if (status)
     mu_scm_error (FUNC_NAME, status, "Cannot get create mailer", SCM_BOOL_F);
 
diff --git a/libmu_scm/mu_port.c b/libmu_scm/mu_port.c
index 25a565f..180fc60 100644
--- a/libmu_scm/mu_port.c
+++ b/libmu_scm/mu_port.c
@@ -87,15 +87,15 @@ mu_port_make_from_stream (SCM msg, mu_stream_t stream, long 
mode)
   mp->stream = stream;
   mp->offset = 0;
 
-  SCM_NEWCELL (port);
-  SCM_DEFER_INTS;
+  port = scm_cell (scm_tc16_smuport | mode, 0);
+
   pt = scm_add_to_port_table (port);
   SCM_SETPTAB_ENTRY (port, pt);
   pt->rw_random = mu_stream_is_seekable (stream);
-  SCM_SET_CELL_TYPE (port, (scm_tc16_smuport | mode));
+
   SCM_SETSTREAM (port, mp);
   mu_port_alloc_buffer (port, 0, 0);
-  SCM_ALLOW_INTS;
+
   /*  SCM_PTAB_ENTRY (port)->file_name = "name";FIXME*/
   return port;
 }
diff --git a/libmu_scm/mu_scm.c b/libmu_scm/mu_scm.c
index 488ac81..3b02a86 100644
--- a/libmu_scm/mu_scm.c
+++ b/libmu_scm/mu_scm.c
@@ -145,9 +145,12 @@ SCM_DEFINE (scm_mu_register_format, "mu-register-format", 
0, 0, 1,
     {
       for (; REST != SCM_EOL; REST = SCM_CDR (REST))
        {
+         char *s;
          SCM scm = SCM_CAR (REST);
          SCM_ASSERT (scm_is_string (scm), scm, SCM_ARGn, FUNC_NAME);
-         status = register_format (scm_i_string_chars (scm));
+         s = scm_to_locale_string (scm);
+         status = register_format (s);
+         free (scm);
          if (status)
            mu_scm_error (FUNC_NAME, status,
                          "Cannot register format ~A",
diff --git a/libmu_scm/mu_util.c b/libmu_scm/mu_util.c
index 4482ac8..2668a76 100644
--- a/libmu_scm/mu_util.c
+++ b/libmu_scm/mu_util.c
@@ -45,11 +45,12 @@ SCM_DEFINE (scm_mu_getpwuid, "mu-getpwuid", 1, 0, 0,
     }
   else
     {
+      char *s;
+      
       SCM_VALIDATE_STRING (1, USER);
-      if (scm_is_string (USER))
-       USER = scm_from_locale_stringn (scm_i_string_chars (USER), 
-                                       scm_i_string_length (USER));
-      entry = mu_get_auth_by_name (scm_i_string_chars (USER));
+      s = scm_to_locale_string (USER);
+      entry = mu_get_auth_by_name (s);
+      free (s);
     }
   if (!entry)
     mu_scm_error (FUNC_NAME, errno,


hooks/post-receive
-- 
GNU Mailutils