*** empty log message ***

[bpt/guile.git] / libguile / regex-posix.c

diff --git a/libguile/regex-posix.c b/libguile/regex-posix.c
index 9206975..9b1ec07 100644 (file)
--- a/libguile/regex-posix.c
+++ b/libguile/regex-posix.c
@@ -1,4 +1,4 @@
-/*     Copyright (C) 1997 Free Software Foundation, Inc.
+/*     Copyright (C) 1997, 1998 Free Software Foundation, Inc.
  * 
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -58,8 +58,18 @@
    the file is CPP'able (for dependency scanning) even on systems that
    don't have a <regex.h> header.  */
 #ifdef HAVE_REGCOMP
+#ifdef HAVE_REGEX_H
 #include <regex.h>
-#endif 
+#else
+#ifdef HAVE_RXPOSIX_H
+#include <rxposix.h>           /* GNU Rx library */
+#else
+#ifdef HAVE_RX_RXPOSIX_H
+#include <rx/rxposix.h>                /* GNU Rx library on Linux */
+#endif
+#endif
+#endif
+#endif
 
 #include "smob.h"
 #include "symbols.h"
@@ -70,15 +80,20 @@
 
 #include "regex-posix.h"
 
+/* This is defined by some regex libraries and omitted by others. */
+#ifndef REG_BASIC
+#define REG_BASIC 0
+#endif
+
 long scm_tc16_regex_t;
 
-static size_t
+static scm_sizet
 scm_free_regex_t (obj)
      SCM obj;
 {
   regfree (SCM_RGX (obj));
   free (SCM_RGX (obj));
-  return 0;
+  return sizeof(regex_t);
 }
 
 static int
@@ -89,20 +104,20 @@ scm_print_regex_t (obj, port, pstate)
 {
   regex_t *r;
   r = SCM_RGX (obj);
-  scm_gen_puts (scm_regular_string, "#<rgx ", port);
+  scm_puts ("#<rgx ", port);
   scm_intprint (obj, 16, port);
-  scm_gen_puts (scm_regular_string, ">", port);
+  scm_puts (">", port);
   return 1;
 }
 
 
 static scm_smobfuns regex_t_smob =
-{ scm_mark0, scm_free_regex_t, scm_print_regex_t, 0 };
+{ 0, scm_free_regex_t, scm_print_regex_t, 0 };
 \f
 
 SCM_SYMBOL (scm_regexp_error_key, "regular-expression-syntax");
 
-char *
+static char *
 scm_regexp_error_msg (regerrno, rx)
      int regerrno;
      SCM rx;
@@ -141,25 +156,38 @@ scm_regexp_p (x)
   return (SCM_NIMP (x) && SCM_RGXP (x) ? SCM_BOOL_T : SCM_BOOL_F);
 }
 
-SCM_PROC (s_make_regexp, "make-regexp", 1, 1, 0, scm_make_regexp);
+SCM_PROC (s_make_regexp, "make-regexp", 1, 0, 1, scm_make_regexp);
 
 SCM
 scm_make_regexp (SCM pat, SCM flags)
 {
-  SCM result;
+  SCM result, flag;
   regex_t *rx;
-  int status;
+  int status, cflags;
 
   SCM_ASSERT (SCM_NIMP(pat) && SCM_ROSTRINGP(pat), pat, SCM_ARG1, 
              s_make_regexp);
   SCM_COERCE_SUBSTR (pat);
-  if (SCM_UNBNDP (flags))
-    flags = SCM_MAKINUM (REG_EXTENDED);
-  SCM_ASSERT (SCM_INUMP (flags), flags, SCM_ARG2, s_make_regexp);
 
+  /* Examine list of regexp flags.  If REG_BASIC is supplied, then
+     turn off REG_EXTENDED flag (on by default). */
+  cflags = REG_EXTENDED;
+  flag = flags;
+  while (SCM_NNULLP (flag))
+    {
+      if (SCM_INUM (SCM_CAR (flag)) == REG_BASIC)
+       cflags &= ~REG_EXTENDED;
+      else
+       cflags |= SCM_INUM (SCM_CAR (flag));
+      flag = SCM_CDR (flag);
+    }
+         
   SCM_DEFER_INTS;
   rx = (regex_t *) scm_must_malloc (sizeof (regex_t), s_make_regexp);
-  status = regcomp (rx, SCM_ROCHARS (pat), SCM_INUM (flags));
+  status = regcomp (rx, SCM_ROCHARS (pat),
+                   /* Make sure they're not passing REG_NOSUB;
+                       regexp-exec assumes we're getting match data.  */
+                   cflags & ~REG_NOSUB);
   if (status != 0)
     {
       SCM_ALLOW_INTS;
@@ -196,7 +224,7 @@ scm_regexp_exec (SCM rx, SCM str, SCM start, SCM flags)
     {
       SCM_ASSERT (SCM_INUMP (start), start, SCM_ARG3, s_regexp_exec);
       offset = SCM_INUM (start);
-      SCM_ASSERT (offset >= 0 && offset <= SCM_LENGTH (str), start,
+      SCM_ASSERT (offset >= 0 && (unsigned) offset <= SCM_LENGTH (str), start,
                  SCM_OUTOFRANGE, s_regexp_exec);
     }
 
@@ -221,13 +249,17 @@ scm_regexp_exec (SCM rx, SCM str, SCM start, SCM flags)
       int i;
       /* The match vector must include a cell for the string that was matched,
         so add 1. */
-      mvec = scm_make_vector (SCM_MAKINUM (nmatches + 1), SCM_UNSPECIFIED,
-                             SCM_UNDEFINED);
+      mvec = scm_make_vector (SCM_MAKINUM (nmatches + 1), SCM_UNSPECIFIED);
       SCM_VELTS(mvec)[0] = str;
       for (i = 0; i < nmatches; ++i)
-       SCM_VELTS(mvec)[i+1] = scm_cons(SCM_MAKINUM(matches[i].rm_so + offset),
-                                       SCM_MAKINUM(matches[i].rm_eo + offset));
+       if (matches[i].rm_so == -1)
+         SCM_VELTS(mvec)[i+1] = scm_cons (SCM_MAKINUM (-1), SCM_MAKINUM (-1));
+       else
+         SCM_VELTS(mvec)[i+1]
+           = scm_cons(SCM_MAKINUM(matches[i].rm_so + offset),
+                      SCM_MAKINUM(matches[i].rm_eo + offset));
     }
+  scm_must_free ((char *) matches);
   SCM_ALLOW_INTS;
 
   if (status != 0 && status != REG_NOMATCH)
@@ -245,9 +277,9 @@ scm_init_regex_posix ()
   scm_tc16_regex_t = scm_newsmob (&regex_t_smob);
 
   /* Compilation flags.  */
+  scm_sysintern ("regexp/basic", scm_long2num (REG_BASIC));
   scm_sysintern ("regexp/extended", scm_long2num (REG_EXTENDED));
   scm_sysintern ("regexp/icase", scm_long2num (REG_ICASE));
-  scm_sysintern ("regexp/nosub", scm_long2num (REG_NOSUB));
   scm_sysintern ("regexp/newline", scm_long2num (REG_NEWLINE));
 
   /* Execution flags.  */