Upgrade to guile 1.6.0

8 files changed, 66 insertions, 38 deletions

diff --git a/libmu_scm/mu_address.c b/libmu_scm/mu_address.c
index 0f1701e85..46a35316f 100644
--- a/libmu_scm/mu_address.c
+++ b/libmu_scm/mu_address.c
@@ -38,18 +38,18 @@ _get_address_part (const char *func_name, address_get_fp fun,
 		  NUM, SCM_ARG1, func_name);
       num = SCM_INUM (NUM);
     }
   else
     num = 1;
 
-  str = SCM_CHARS (ADDRESS);
+  str = SCM_STRING_CHARS (ADDRESS);
   length = strlen (str);
   if (length == 0)
     return scm_makfrom0str("");
   
-  if (address_create (&addr, SCM_CHARS (ADDRESS)))
+  if (address_create (&addr, SCM_STRING_CHARS (ADDRESS)))
     return SCM_BOOL_F;
 
   str = malloc (length + 1);
   if (!str)
     {
       address_destroy (&addr);
@@ -123,13 +123,13 @@ SCM_DEFINE (mu_address_get_count, "mu-address-get-count", 1, 0, 0,
   address_t addr;
   size_t count = 0;
   
   SCM_ASSERT (SCM_NIMP (ADDRESS) && SCM_STRINGP (ADDRESS),
 	      ADDRESS, SCM_ARG1, FUNC_NAME);
 
-  if (address_create (&addr, SCM_CHARS (ADDRESS)))
+  if (address_create (&addr, SCM_STRING_CHARS (ADDRESS)))
     return SCM_MAKINUM(0);
 
   address_get_count (addr, &count);
   address_destroy (&addr);
   return scm_makenum (count);
 }
@@ -147,13 +147,13 @@ SCM_DEFINE (mu_username_to_email, "mu-username->email", 0, 1, 0,
   
   if (SCM_UNBNDP (NAME))
     name = NULL;
   else {
     SCM_ASSERT (SCM_NIMP (NAME) && SCM_STRINGP (NAME),
 		NAME, SCM_ARG1, FUNC_NAME);
-    name = SCM_CHARS (NAME);
+    name = SCM_STRING_CHARS (NAME);
   }
 
   email = mu_get_user_email (name);
   if (!email)
     return SCM_BOOL_F;
   ret = scm_makfrom0str (email);
diff --git a/libmu_scm/mu_body.c b/libmu_scm/mu_body.c
index 5faab6916..18ad85354 100644
--- a/libmu_scm/mu_body.c
+++ b/libmu_scm/mu_body.c
@@ -171,13 +171,13 @@ SCM_DEFINE (mu_body_write, "mu-body-write", 2, 0, 0,
   if (!mbp->stream)
     {
       if (body_get_stream (mbp->body, &mbp->stream))
 	return SCM_BOOL_F;
     }
 
-  ptr = SCM_CHARS (TEXT);
+  ptr = SCM_STRING_CHARS (TEXT);
   len = strlen (ptr);
   if (stream_write (mbp->stream, ptr, len, mbp->offset, &n))
     {
       return SCM_BOOL_F;
     }
   mbp->offset += n;
diff --git a/libmu_scm/mu_guimb.c b/libmu_scm/mu_guimb.c
index 5b1e40814..888a37d5f 100644
--- a/libmu_scm/mu_guimb.c
+++ b/libmu_scm/mu_guimb.c
@@ -53,19 +53,17 @@ _scheme_main (void *closure, int argc, char **argv)
   mu_scm_init ();
 
   /* Provide basic primitives */
 #include <mu_guimb.x>
 
   _current_mailbox = mu_scm_mailbox_create (param->mbox);
-  scm_loc = SCM_CDRLOC (scm_sysintern ("current-mailbox", SCM_EOL));
-  *scm_loc = _current_mailbox;
+  mu_set_variable ("current-mailbox", _current_mailbox);
 
   _user_name = param->user_name ?
                        scm_makfrom0str (param->user_name) : SCM_BOOL_F;
-  scm_loc = SCM_CDRLOC (scm_sysintern ("user-name", SCM_EOL));
-  *scm_loc = _user_name;
+  mu_set_variable ("user-name", _user_name);
 
   if (param->init) 
     param->init (param->data);
   
   do {
     scm_internal_lazy_catch (SCM_BOOL_T,
diff --git a/libmu_scm/mu_logger.c b/libmu_scm/mu_logger.c
index d42227fec..85d151aaf 100644
--- a/libmu_scm/mu_logger.c
+++ b/libmu_scm/mu_logger.c
@@ -30,26 +30,26 @@ SCM_DEFINE(mu_openlog, "mu-openlog", 3, 0, 0,
   if (IDENT == SCM_BOOL_F)
     ident = "libmu_scm";
   else
     {
       SCM_ASSERT (SCM_NIMP (IDENT) && SCM_STRINGP (IDENT),
 		 IDENT, SCM_ARG1, FUNC_NAME);
-      ident = SCM_CHARS (IDENT);
+      ident = SCM_STRING_CHARS (IDENT);
     }
 	
   if (SCM_IMP (OPTION) && SCM_INUMP (OPTION))
     option = SCM_INUM (OPTION);
   else if (SCM_BIGP (OPTION)) 
-    option = (int) scm_big2dbl (OPTION);
+    option = (int) scm_i_big2dbl (OPTION);
   else 
     SCM_ASSERT (0, OPTION, SCM_ARG2, FUNC_NAME);
 
   if (SCM_IMP (FACILITY) && SCM_INUMP (FACILITY)) 
     facility = SCM_INUM (FACILITY);
   else if (SCM_BIGP (FACILITY)) 
-    facility = (int) scm_big2dbl (FACILITY);
+    facility = (int) scm_i_big2dbl (FACILITY);
   else
     SCM_ASSERT (0, FACILITY, SCM_ARG3, FUNC_NAME);
 
   openlog (ident, option, facility);
   return SCM_UNSPECIFIED;
 }
@@ -64,19 +64,19 @@ SCM_DEFINE (mu_logger, "mu-logger", 2, 0, 0,
 
   if (PRIO == SCM_BOOL_F) 
     prio = LOG_INFO;
   else if (SCM_IMP (PRIO) && SCM_INUMP (PRIO)) 
     prio = SCM_INUM (PRIO);
   else if (SCM_BIGP (PRIO)) 
-    prio = (int) scm_big2dbl (PRIO);
+    prio = (int) scm_i_big2dbl (PRIO);
   else
     SCM_ASSERT (0, PRIO, SCM_ARG1, FUNC_NAME);
   
   SCM_ASSERT (SCM_NIMP (TEXT) && SCM_STRINGP (TEXT),
 	     TEXT, SCM_ARG2, FUNC_NAME);
-  syslog (prio, "%s", SCM_CHARS (TEXT));
+  syslog (prio, "%s", SCM_STRING_CHARS (TEXT));
   return SCM_UNSPECIFIED;
 }
 #undef FUNC_NAME
 
 SCM_DEFINE (mu_closelog, "mu-closelog", 0, 0, 0,
 	   (),
@@ -123,9 +123,9 @@ static struct
 void
 mu_scm_logger_init ()
 {
   int i;
   
   for (i = 0; i < sizeof (syslog_kw)/sizeof (syslog_kw[0]); i++)
-    scm_sysintern (syslog_kw[i].name, SCM_MAKINUM (syslog_kw[i].facility));
+    scm_c_define (syslog_kw[i].name, SCM_MAKINUM (syslog_kw[i].facility));
 #include <mu_logger.x>
 }
diff --git a/libmu_scm/mu_mailbox.c b/libmu_scm/mu_mailbox.c
index 301ab7140..f6b2baa5b 100644
--- a/libmu_scm/mu_mailbox.c
+++ b/libmu_scm/mu_mailbox.c
@@ -114,13 +114,13 @@ SCM_DEFINE (mu_mailbox_open, "mu-mailbox-open", 2, 0, 0,
   int mode = 0;
 
   SCM_ASSERT (SCM_NIMP (URL) && SCM_STRINGP (URL), URL, SCM_ARG1, FUNC_NAME);
   SCM_ASSERT (SCM_NIMP (MODE) && SCM_STRINGP (MODE),
 	      MODE, SCM_ARG2, FUNC_NAME);
 
-  for (mode_str = SCM_CHARS (MODE); *mode_str; mode_str++)
+  for (mode_str = SCM_STRING_CHARS (MODE); *mode_str; mode_str++)
     switch (*mode_str)
       {
       case 'r':
 	mode |= MU_STREAM_READ;
 	break;
       case 'w':
@@ -134,13 +134,13 @@ SCM_DEFINE (mu_mailbox_open, "mu-mailbox-open", 2, 0, 0,
 	break;
       }
 
   if (mode & MU_STREAM_READ && mode & MU_STREAM_WRITE)
     mode = (mode & ~(MU_STREAM_READ | MU_STREAM_WRITE)) | MU_STREAM_RDWR;
 
-  if (mailbox_create_default (&mbox, SCM_CHARS (URL)) != 0)
+  if (mailbox_create_default (&mbox, SCM_STRING_CHARS (URL)) != 0)
     return SCM_BOOL_F;
 
   if (mailbox_open (mbox, mode) != 0)
     {
       mailbox_destroy (&mbox);
       return SCM_BOOL_F;
@@ -194,13 +194,13 @@ SCM_DEFINE (mu_mailbox_get_port, "mu-mailbox-get-port", 2, 0, 0,
   SCM_ASSERT (SCM_NIMP (MODE) && SCM_STRINGP (MODE),
 	      MODE, SCM_ARG2, FUNC_NAME);
   mum = (struct mu_mailbox *) SCM_CDR (MBOX);
   if (mailbox_get_stream (mum->mbox, &stream))
     return SCM_BOOL_F;
   return mu_port_make_from_stream (MBOX, stream,
-				   scm_mode_bits (SCM_CHARS (MODE)));    
+				   scm_mode_bits (SCM_STRING_CHARS (MODE)));    
 }
 #undef FUNC_NAME
 
 SCM_DEFINE (mu_mailbox_get_message, "mu-mailbox-get-message", 2, 0, 0,
 	    (SCM MBOX, SCM MSGNO), "Retrieve from MBOX message # MSGNO.")
 #define FUNC_NAME s_mu_mailbox_get_message
diff --git a/libmu_scm/mu_message.c b/libmu_scm/mu_message.c
index ac9efd9a6..347582778 100644
--- a/libmu_scm/mu_message.c
+++ b/libmu_scm/mu_message.c
@@ -269,13 +269,13 @@ SCM_DEFINE (mu_message_set_header, "mu-message-set-header", 3, 1, 0,
       SCM_ASSERT (SCM_IMP (REPLACE) && SCM_INUMP (REPLACE),
 		  REPLACE, SCM_ARG3, FUNC_NAME);
       replace = REPLACE == SCM_BOOL_T;
     }
   
   message_get_header (msg, &hdr);
-  header_set_value (hdr, SCM_CHARS (HEADER), strdup (SCM_CHARS (VALUE)),
+  header_set_value (hdr, SCM_STRING_CHARS (HEADER), strdup (SCM_STRING_CHARS (VALUE)),
 		    replace);
   return SCM_UNSPECIFIED;
 }
 #undef FUNC_NAME
 
 SCM_DEFINE (mu_message_get_size, "mu-message-get-size", 1, 0, 0,
@@ -339,13 +339,13 @@ SCM_DEFINE (mu_message_get_header, "mu-message-get-header", 2, 0, 0,
   SCM ret = SCM_BOOL_F;
 
   SCM_ASSERT (mu_scm_is_message (MESG), MESG, SCM_ARG1, FUNC_NAME);
   msg = mu_scm_message_get (MESG);
   SCM_ASSERT (SCM_NIMP (HEADER) && SCM_STRINGP (HEADER),
 	      HEADER, SCM_ARG2, FUNC_NAME);
-  header_string = SCM_CHARS (HEADER);
+  header_string = SCM_STRING_CHARS (HEADER);
   message_get_header (msg, &hdr);
   if (header_aget_value (hdr, header_string, &value) == 0)
     {
       ret = scm_makfrom0str (value);
       free (value);
     }
@@ -357,13 +357,13 @@ static int
 string_sloppy_member (SCM lst, char *name)
 {
   for(; SCM_CONSP (lst); lst = SCM_CDR(lst))
     {
       SCM car = SCM_CAR (lst);
       if ((SCM_NIMP (car) && SCM_STRINGP (car))
-	  && strcasecmp (SCM_CHARS (car), name) == 0)
+	  && strcasecmp (SCM_STRING_CHARS (car), name) == 0)
 	return 1;
     }
   return 0;
 }
 
 SCM_DEFINE (mu_message_get_header_fields, "mu-message-get-header-fields", 1, 1, 0,
@@ -460,13 +460,13 @@ SCM_DEFINE (mu_message_set_header_fields, "mu-message-set-header-fields", 2, 1,
       car = SCM_CAR (cell);
       cdr = SCM_CDR (cell);
       SCM_ASSERT (SCM_NIMP (car) && SCM_STRINGP (car),
 		  car, SCM_ARGn, FUNC_NAME);
       SCM_ASSERT (SCM_NIMP (cdr) && SCM_STRINGP (cdr),
 		  cdr, SCM_ARGn, FUNC_NAME);
-      header_set_value (hdr, SCM_CHARS (car), SCM_CHARS (cdr), replace);
+      header_set_value (hdr, SCM_STRING_CHARS (car), SCM_STRING_CHARS (cdr), replace);
     }
   return SCM_UNDEFINED;
 }
 #undef FUNC_NAME
 
 SCM_DEFINE (mu_message_delete, "mu-message-delete", 1, 1, 0,
@@ -707,13 +707,13 @@ SCM_DEFINE (mu_message_get_port, "mu-message-get-port", 2, 1, 0,
       if (message_get_body (msg, &body)
 	  || body_get_stream (body, &stream))
 	return SCM_BOOL_F;
     }
   
   return mu_port_make_from_stream (MESG, stream,
-				   scm_mode_bits (SCM_CHARS (MODE)));    
+				   scm_mode_bits (SCM_STRING_CHARS (MODE)));    
 }
 #undef FUNC_NAME
   
 
 SCM_DEFINE (mu_message_get_body, "mu-message-get-body", 1, 0, 0,
 	    (SCM MESG),
@@ -807,28 +807,28 @@ SCM_DEFINE (mu_message_send, "mu-message-send", 1, 3, 0,
   msg = mu_scm_message_get (MESG);
   
   if (!SCM_UNBNDP (MAILER) && MAILER != SCM_BOOL_F)
     {
       SCM_ASSERT (SCM_NIMP (MAILER) && SCM_STRINGP (MAILER),
 		  MAILER, SCM_ARG2, FUNC_NAME);
-      mailer_name = SCM_CHARS (MAILER);
+      mailer_name = SCM_STRING_CHARS (MAILER);
     }
   else
-    mailer_name = SCM_CHARS(_mu_scm_mailer);
+    mailer_name = SCM_STRING_CHARS(_mu_scm_mailer);
 
   if (!SCM_UNBNDP (FROM) && FROM != SCM_BOOL_F)
     {
       SCM_ASSERT (SCM_NIMP (FROM) && SCM_STRINGP (FROM)
-		  && address_create (&from, SCM_CHARS (FROM)) == 0,
+		  && address_create (&from, SCM_STRING_CHARS (FROM)) == 0,
 		  FROM, SCM_ARG3, FUNC_NAME);
     }
   
   if (!SCM_UNBNDP (TO) && TO != SCM_BOOL_F)
     {
       SCM_ASSERT (SCM_NIMP (TO) && SCM_STRINGP (TO)
-		  && address_create (&to, SCM_CHARS (TO)) == 0,
+		  && address_create (&to, SCM_STRING_CHARS (TO)) == 0,
 		  TO, SCM_ARG4, FUNC_NAME);
     }
 
   if (mailer_create (&mailer, mailer_name))
     {
       return SCM_BOOL_F;
diff --git a/libmu_scm/mu_scm.c b/libmu_scm/mu_scm.c
index 0fe68e12a..ab69623bb 100644
--- a/libmu_scm/mu_scm.c
+++ b/libmu_scm/mu_scm.c
@@ -18,24 +18,41 @@
 #include "mu_scm.h"
 
 #ifndef _PATH_SENDMAIL
 # define _PATH_SENDMAIL "/usr/lib/sendmail"
 #endif
 
-SCM 
+SCM
 scm_makenum (unsigned long val)
+#ifndef HAVE_SCM_LONG2NUM
 {
   if (SCM_FIXABLE ((long) val))
     return SCM_MAKINUM (val);
 
 #ifdef SCM_BIGDIG
   return scm_long2big (val);
 #else /* SCM_BIGDIG */
   return scm_make_real ((double) val);
 #endif /* SCM_BIGDIG */
 }
+#else
+{
+  return scm_long2num (val);
+}
+#endif
+
+void
+mu_set_variable (const char *name, SCM value)
+{
+#if GUILE_VERSION == 14
+  scm_c_define (name, value); /*FIXME*/
+#else
+  scm_c_define (name, value);
+#endif
+}
+
 
 SCM _mu_scm_package; /* STRING: PACKAGE */
 SCM _mu_scm_version; /* STRING: VERSION */
 SCM _mu_scm_mailer;  /* STRING: Default mailer path. */
 SCM _mu_scm_debug;   /* NUM: Default debug level. */
 
@@ -57,36 +74,31 @@ static struct
   
 
 /* Initialize the library */
 void
 mu_scm_init ()
 {
-  SCM *scm_loc;
   char *defmailer;
   int i;
   
   asprintf (&defmailer, "sendmail:%s", _PATH_SENDMAIL);
   _mu_scm_mailer = scm_makfrom0str (defmailer);
-  scm_loc = SCM_CDRLOC (scm_sysintern ("mu-mailer", SCM_EOL));
-  *scm_loc = _mu_scm_mailer;
+  mu_set_variable ("mu-mailer", _mu_scm_mailer);
 
   _mu_scm_debug = scm_makenum(0);
-  scm_loc = SCM_CDRLOC (scm_sysintern ("mu-debug", SCM_EOL));
-  *scm_loc = _mu_scm_debug;
+  mu_set_variable ("mu-debug", _mu_scm_debug);
 
   _mu_scm_package = scm_makfrom0str (PACKAGE);
-  scm_loc = SCM_CDRLOC (scm_sysintern ("mu-package", SCM_EOL));
-  *scm_loc = _mu_scm_package;
+  mu_set_variable ("mu-package", _mu_scm_package);
 
   _mu_scm_version = scm_makfrom0str (VERSION);
-  scm_loc = SCM_CDRLOC (scm_sysintern ("mu-version", SCM_EOL));
-  *scm_loc = _mu_scm_version;
+  mu_set_variable ("mu-version", _mu_scm_version);
 
   /* Create MU- attribute names */
   for (i = 0; attr_kw[i].name; i++)
-    scm_sysintern(attr_kw[i].name, SCM_MAKINUM(attr_kw[i].value));
+    scm_c_define(attr_kw[i].name, SCM_MAKINUM(attr_kw[i].value));
   
   mu_scm_mutil_init ();
   mu_scm_mailbox_init ();
   mu_scm_message_init ();
   mu_scm_address_init ();
   mu_scm_body_init ();
diff --git a/libmu_scm/mu_scm.h b/libmu_scm/mu_scm.h
index 49fb74994..ee580c0e8 100644
--- a/libmu_scm/mu_scm.h
+++ b/libmu_scm/mu_scm.h
@@ -40,12 +40,29 @@
 #include <mailutils/mailer.h>
 #include <mailutils/envelope.h>
 #include <mailutils/url.h>
 
 #include <libguile.h>
 
+#if GUILE_VERSION == 14
+
+# define SCM_STRING_CHARS SCM_CHARS
+# define scm_list_1 SCM_LIST1
+# define scm_list_2 SCM_LIST2
+# define scm_list_3 SCM_LIST3
+# define scm_list_4 SCM_LIST4
+# define scm_list_5 SCM_LIST5
+# define scm_list_n SCM_LISTN
+# define scm_c_define scm_sysintern
+# define scm_primitive_eval_x scm_eval_x
+# define scm_i_big2dbl scm_big2dbl
+
+extern SCM scm_long2num (long val);
+
+#endif
+
 typedef struct
 {
   int debug_guile;
   mailbox_t mbox;
   char *user_name;
   int (*init) __P((void *data));
@@ -57,12 +74,13 @@ typedef struct
 } guimb_param_t;
 
 extern SCM _mu_scm_mailer;
 extern SCM _mu_scm_debug;
 
 extern SCM scm_makenum __P((unsigned long val));
+extern void mu_set_variable (const char *name, SCM value);
 extern void mu_scm_init __P((void));
 
 extern void mu_scm_mailbox_init __P((void));
 extern SCM mu_scm_mailbox_create __P((mailbox_t mbox));
 extern int mu_scm_is_mailbox __P((SCM scm));