Remove trailing whitespace.

25 files changed, 841 insertions, 841 deletions

diff --git a/gnu/lib/libregex/Makefile.gnu b/gnu/lib/libregex/Makefile.gnu
index 0976aa8..b8bc209 100644
--- a/gnu/lib/libregex/Makefile.gnu
+++ b/gnu/lib/libregex/Makefile.gnu
@@ -1,6 +1,6 @@
 # Generated automatically from Makefile.in by configure.
 # Makefile for regex.
-# 
+#
 # Copyright (C) 1992, 1993 Free Software Foundation, Inc.
 #
 # This program is free software; you can redistribute it and/or modify
@@ -27,7 +27,7 @@ version = 0.12
 #   -DEXTRACT_MACROS to use the macros EXTRACT_* (as opposed to
 #           the corresponding C procedures).  If not -DDEBUG, the macros
 #           are used.
-CPPFLAGS = 
+CPPFLAGS =
 
 # Likewise, you can override CFLAGS to optimize, use -Wall, etc.
 CFLAGS = -g
@@ -83,7 +83,7 @@ TAGS check::
 .NOEXPORT:
 
 distfiles = AUTHORS ChangeLog COPYING INSTALL NEWS README \
-            *.in configure regex.c regex.h 
+            *.in configure regex.c regex.h
 distdir = regex-$(version)
 distargs = version=$(version) distdir=../$(distdir)/$$d
 dist: TAGS configure
diff --git a/gnu/lib/libregex/Makefile.in b/gnu/lib/libregex/Makefile.in
index 836e6de..a21f970 100644
--- a/gnu/lib/libregex/Makefile.in
+++ b/gnu/lib/libregex/Makefile.in
@@ -1,5 +1,5 @@
 # Makefile for regex.
-# 
+#
 # Copyright (C) 1992, 1993 Free Software Foundation, Inc.
 #
 # This program is free software; you can redistribute it and/or modify
@@ -26,7 +26,7 @@ version = 0.12
 #   -DEXTRACT_MACROS to use the macros EXTRACT_* (as opposed to
 #           the corresponding C procedures).  If not -DDEBUG, the macros
 #           are used.
-CPPFLAGS = 
+CPPFLAGS =
 
 # Likewise, you can override CFLAGS to optimize, use -Wall, etc.
 CFLAGS = -g
@@ -82,7 +82,7 @@ TAGS check::
 .NOEXPORT:
 
 distfiles = AUTHORS ChangeLog COPYING INSTALL NEWS README \
-            *.in configure regex.c regex.h 
+            *.in configure regex.c regex.h
 distdir = regex-$(version)
 distargs = version=$(version) distdir=../$(distdir)/$$d
 dist: TAGS configure
diff --git a/gnu/lib/libregex/regex.c b/gnu/lib/libregex/regex.c
index 6a36f3d..320b72b 100644
--- a/gnu/lib/libregex/regex.c
+++ b/gnu/lib/libregex/regex.c
@@ -79,7 +79,7 @@ char *realloc ();
 
 /* This must be nonzero for the wordchar and notwordchar pattern
    commands in re_match_2.  */
-#ifndef Sword 
+#ifndef Sword
 #define Sword 1
 #endif
 
@@ -188,8 +188,8 @@ init_syntax_once ()
    use `alloca' instead of `malloc'.  This is because using malloc in
    re_search* or re_match* could cause memory leaks when C-g is used in
    Emacs; also, malloc is slower and causes storage fragmentation.  On
-   the other hand, malloc is more portable, and easier to debug.  
-   
+   the other hand, malloc is more portable, and easier to debug.
+
    Because we sometimes use alloca, some routines have to be macros,
    not functions -- `alloca'-allocated space disappears at the end of the
    function it is called in.  */
@@ -214,7 +214,7 @@ init_syntax_once ()
 #ifndef _AIX /* Already did AIX, up at the top.  */
 char *alloca ();
 #endif /* not _AIX */
-#endif /* not HAVE_ALLOCA_H */ 
+#endif /* not HAVE_ALLOCA_H */
 #endif /* not __GNUC__ */
 
 #endif /* not alloca */
@@ -317,9 +317,9 @@ typedef enum
 
         /* Analogously, for end of buffer/string.  */
   endbuf,
- 
+
         /* Followed by two byte relative address to which to jump.  */
-  jump, 
+  jump,
 
 	/* Same as jump, but marks the end of an alternative.  */
   jump_past_alt,
@@ -327,11 +327,11 @@ typedef enum
         /* Followed by two-byte relative address of place to resume at
            in case of failure.  */
   on_failure_jump,
-	
+
         /* Like on_failure_jump, but pushes a placeholder instead of the
            current string position when executed.  */
   on_failure_keep_string_jump,
-  
+
         /* Throw away latest failure point and then jump to following
            two-byte relative address.  */
   pop_failure_jump,
@@ -428,7 +428,7 @@ extract_number (dest, source)
     int *dest;
     unsigned char *source;
 {
-  int temp = SIGN_EXTEND_CHAR (*(source + 1)); 
+  int temp = SIGN_EXTEND_CHAR (*(source + 1));
   *dest = *source & 0377;
   *dest += temp << 8;
 }
@@ -456,7 +456,7 @@ static void
 extract_number_and_incr (destination, source)
     int *destination;
     unsigned char **source;
-{ 
+{
   extract_number (destination, *source);
   *source += 2;
 }
@@ -505,8 +505,8 @@ print_fastmap (fastmap)
     char *fastmap;
 {
   unsigned was_a_range = 0;
-  unsigned i = 0;  
-  
+  unsigned i = 0;
+
   while (i < (1 << BYTEWIDTH))
     {
       if (fastmap[i++])
@@ -525,7 +525,7 @@ print_fastmap (fastmap)
             }
         }
     }
-  putchar ('\n'); 
+  putchar ('\n');
 }
 
 
@@ -546,7 +546,7 @@ print_partial_compiled_pattern (start, end)
       printf ("(null)\n");
       return;
     }
-    
+
   /* Loop over pattern commands.  */
   while (p < pend)
     {
@@ -595,7 +595,7 @@ print_partial_compiled_pattern (start, end)
 
 	    printf ("/charset [%s",
 	            (re_opcode_t) *(p - 1) == charset_not ? "^" : "");
-            
+
             assert (p + *p < pend);
 
             for (c = 0; c < 256; c++)
@@ -614,7 +614,7 @@ print_partial_compiled_pattern (start, end)
 		      printchar (last);
 		      in_range = 0;
 		    }
-                
+
 		  if (! in_range)
 		    printchar (c);
 
@@ -656,7 +656,7 @@ print_partial_compiled_pattern (start, end)
 	case push_dummy_failure:
           printf ("/push_dummy_failure");
           break;
-          
+
         case maybe_pop_jump:
           extract_number_and_incr (&mcnt, &p);
   	  printf ("/maybe_pop_jump to %d", p + mcnt - start);
@@ -665,36 +665,36 @@ print_partial_compiled_pattern (start, end)
         case pop_failure_jump:
 	  extract_number_and_incr (&mcnt, &p);
   	  printf ("/pop_failure_jump to %d", p + mcnt - start);
-	  break;          
-          
+	  break;
+
         case jump_past_alt:
 	  extract_number_and_incr (&mcnt, &p);
   	  printf ("/jump_past_alt to %d", p + mcnt - start);
-	  break;          
-          
+	  break;
+
         case jump:
 	  extract_number_and_incr (&mcnt, &p);
   	  printf ("/jump to %d", p + mcnt - start);
 	  break;
 
-        case succeed_n: 
+        case succeed_n:
           extract_number_and_incr (&mcnt, &p);
           extract_number_and_incr (&mcnt2, &p);
 	  printf ("/succeed_n to %d, %d times", p + mcnt - start, mcnt2);
           break;
-        
-        case jump_n: 
+
+        case jump_n:
           extract_number_and_incr (&mcnt, &p);
           extract_number_and_incr (&mcnt2, &p);
 	  printf ("/jump_n to %d, %d times", p + mcnt - start, mcnt2);
           break;
-        
-        case set_number_at: 
+
+        case set_number_at:
           extract_number_and_incr (&mcnt, &p);
           extract_number_and_incr (&mcnt2, &p);
 	  printf ("/set_number_at location %d to %d", p + mcnt - start, mcnt2);
           break;
-        
+
         case wordbound:
 	  printf ("/wordbound");
 	  break;
@@ -706,10 +706,10 @@ print_partial_compiled_pattern (start, end)
 	case wordbeg:
 	  printf ("/wordbeg");
 	  break;
-          
+
 	case wordend:
 	  printf ("/wordend");
-          
+
 #ifdef emacs
 	case before_dot:
 	  printf ("/before_dot");
@@ -728,7 +728,7 @@ print_partial_compiled_pattern (start, end)
 	  mcnt = *p++;
 	  printf ("/%d", mcnt);
           break;
-	  
+
 	case notsyntaxspec:
           printf ("/notsyntaxspec");
 	  mcnt = *p++;
@@ -739,7 +739,7 @@ print_partial_compiled_pattern (start, end)
 	case wordchar:
 	  printf ("/wordchar");
           break;
-	  
+
 	case notwordchar:
 	  printf ("/notwordchar");
           break;
@@ -799,7 +799,7 @@ print_double_string (where, string1, size1, string2, size2)
     int size2;
 {
   unsigned this_char;
-  
+
   if (where == NULL)
     printf ("(null)");
   else
@@ -809,7 +809,7 @@ print_double_string (where, string1, size1, string2, size2)
           for (this_char = where - string1; this_char < size1; this_char++)
             printchar (string1[this_char]);
 
-          where = string2;    
+          where = string2;
         }
 
       for (this_char = where - string2; this_char < size2; this_char++)
@@ -850,7 +850,7 @@ re_set_syntax (syntax)
     reg_syntax_t syntax;
 {
   reg_syntax_t ret = re_syntax_options;
-  
+
   re_syntax_options = syntax;
   return ret;
 }
@@ -900,7 +900,7 @@ static reg_errcode_t compile_range _RE_ARGS((const char **p_ptr,
 					     reg_syntax_t syntax,
 					     unsigned char *b));
 
-/* Fetch the next character in the uncompiled pattern---translating it 
+/* Fetch the next character in the uncompiled pattern---translating it
    if necessary.  Also cast from a signed character in the constant
    string passed to us by the user to an unsigned char that we can use
    as an array index (in, e.g., `translate').  */
@@ -1054,7 +1054,7 @@ typedef struct
   pattern_offset_t begalt_offset;
   pattern_offset_t fixup_alt_jump;
   pattern_offset_t inner_group_offset;
-  pattern_offset_t laststart_offset;  
+  pattern_offset_t laststart_offset;
   regnum_t regnum;
 } compile_stack_elt_t;
 
@@ -1097,7 +1097,7 @@ typedef struct
            PATFETCH (c);						\
          } 								\
        } 								\
-    }		
+    }
 
 #define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */
 
@@ -1127,7 +1127,7 @@ static boolean group_in_compile_stack _RE_ARGS((compile_stack_type
      `fastmap_accurate' is zero;
      `re_nsub' is the number of subexpressions in PATTERN;
      `not_bol' and `not_eol' are zero;
-   
+
    The `fastmap' and `newline_anchor' fields are neither
    examined nor set.  */
 
@@ -1142,20 +1142,20 @@ regex_compile (pattern, size, syntax, bufp)
      `char *' (i.e., signed), we declare these variables as unsigned, so
      they can be reliably used as array indices.  */
   register unsigned char c, c1;
-  
+
   /* A random tempory spot in PATTERN.  */
   const char *p1;
 
   /* Points to the end of the buffer, where we should append.  */
   register unsigned char *b;
-  
+
   /* Keeps track of unclosed groups.  */
   compile_stack_type compile_stack;
 
   /* Points to the current (ending) position in the pattern.  */
   const char *p = pattern;
   const char *pend = pattern + size;
-  
+
   /* How to translate the characters in the pattern.  */
   char *translate = bufp->translate;
 
@@ -1176,7 +1176,7 @@ regex_compile (pattern, size, syntax, bufp)
   /* Place in the uncompiled pattern (i.e., the {) to
      which to go back if the interval is invalid.  */
   const char *beg_interval;
-                
+
   /* Address of the place where a forward jump should go to the end of
      the containing expression.  Each alternative of an `or' -- except the
      last -- ends with a forward jump of this sort.  */
@@ -1192,7 +1192,7 @@ regex_compile (pattern, size, syntax, bufp)
   if (debug)
     {
       unsigned debug_count;
-      
+
       for (debug_count = 0; debug_count < size; debug_count++)
         printchar (pattern[debug_count]);
       putchar ('\n');
@@ -1216,9 +1216,9 @@ regex_compile (pattern, size, syntax, bufp)
      printer (for debugging) will think there's no pattern.  We reset it
      at the end.  */
   bufp->used = 0;
-  
+
   /* Always count groups, whether or not bufp->no_sub is set.  */
-  bufp->re_nsub = 0;				
+  bufp->re_nsub = 0;
 
 #if !defined (emacs) && !defined (SYNTAX_TABLE)
   /* Initialize the syntax table.  */
@@ -1269,7 +1269,7 @@ regex_compile (pattern, size, syntax, bufp)
         case '$':
           {
             if (   /* If at end of pattern, it's an operator.  */
-                   p == pend 
+                   p == pend
                    /* If context independent, it's an operator.  */
                 || syntax & RE_CONTEXT_INDEP_ANCHORS
                    /* Otherwise, depends on what's next.  */
@@ -1300,7 +1300,7 @@ regex_compile (pattern, size, syntax, bufp)
           {
             /* Are we optimizing this jump?  */
             boolean keep_string_p = false;
-            
+
             /* 1 means zero (many) matches is allowed.  */
             char zero_times_ok = 0, many_times_ok = 0;
 
@@ -1348,7 +1348,7 @@ regex_compile (pattern, size, syntax, bufp)
 
             /* Star, etc. applied to an empty pattern is equivalent
                to an empty pattern.  */
-            if (!laststart)  
+            if (!laststart)
               break;
 
             /* Now we know whether or not zero matches is allowed
@@ -1357,7 +1357,7 @@ regex_compile (pattern, size, syntax, bufp)
               { /* More than one repetition is allowed, so put in at the
                    end a backward relative jump from `b' to before the next
                    jump we're going to put in below (which jumps from
-                   laststart to after this jump).  
+                   laststart to after this jump).
 
                    But if we are at the `*' in the exact sequence `.*\n',
                    insert an unconditional jump backwards to the .,
@@ -1434,7 +1434,7 @@ regex_compile (pattern, size, syntax, bufp)
 
             /* We test `*p == '^' twice, instead of using an if
                statement, so we only need one BUF_PUSH.  */
-            BUF_PUSH (*p == '^' ? charset_not : charset); 
+            BUF_PUSH (*p == '^' ? charset_not : charset);
             if (*p == '^')
               p++;
 
@@ -1484,8 +1484,8 @@ regex_compile (pattern, size, syntax, bufp)
                    was a character: if this is a hyphen not at the
                    beginning or the end of a list, then it's the range
                    operator.  */
-                if (c == '-' 
-                    && !(p - 2 >= pattern && p[-2] == '[') 
+                if (c == '-'
+                    && !(p - 2 >= pattern && p[-2] == '[')
                     && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
                     && *p != ']')
                   {
@@ -1500,7 +1500,7 @@ regex_compile (pattern, size, syntax, bufp)
 
 		    /* Move past the `-'.  */
                     PATFETCH (c1);
-                    
+
                     ret = compile_range (&p, pend, translate, syntax, b);
                     if (ret != REG_NOERROR) return ret;
                   }
@@ -1529,7 +1529,7 @@ regex_compile (pattern, size, syntax, bufp)
                     str[c1] = '\0';
 
                     /* If isn't a word bracketed by `[:' and:`]':
-                       undo the ending character, the letters, and leave 
+                       undo the ending character, the letters, and leave
                        the leading `:' and `[' (but set bits for them).  */
                     if (c == ':' && *p == ']')
                       {
@@ -1546,12 +1546,12 @@ regex_compile (pattern, size, syntax, bufp)
                         boolean is_space = STREQ (str, "space");
                         boolean is_upper = STREQ (str, "upper");
                         boolean is_xdigit = STREQ (str, "xdigit");
-                        
+
                         if (!IS_CHAR_CLASS (str)) return REG_ECTYPE;
 
                         /* Throw away the ] at the end of the character
                            class.  */
-                        PATFETCH (c);					
+                        PATFETCH (c);
 
                         if (p == pend) return REG_EBRACK;
 
@@ -1576,7 +1576,7 @@ regex_compile (pattern, size, syntax, bufp)
                     else
                       {
                         c1++;
-                        while (c1--)    
+                        while (c1--)
                           PATUNFETCH;
                         SET_LIST_BIT ('[');
                         SET_LIST_BIT (':');
@@ -1592,8 +1592,8 @@ regex_compile (pattern, size, syntax, bufp)
 
             /* Discard any (non)matching list bytes that are all 0 at the
                end of the map.  Decrease the map-length byte too.  */
-            while ((int) b[-1] > 0 && b[b[-1] - 1] == 0) 
-              b[-1]--; 
+            while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)
+              b[-1]--;
             b += b[-1];
           }
           break;
@@ -1653,7 +1653,7 @@ regex_compile (pattern, size, syntax, bufp)
               regnum++;
 
               if (COMPILE_STACK_FULL)
-                { 
+                {
                   RETALLOC (compile_stack.stack, compile_stack.size << 1,
                             compile_stack_elt_t);
                   if (compile_stack.stack == NULL) return REG_ESPACE;
@@ -1666,7 +1666,7 @@ regex_compile (pattern, size, syntax, bufp)
                  whole pattern moves because of realloc, they will still
                  be valid.  */
               COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer;
-              COMPILE_STACK_TOP.fixup_alt_jump 
+              COMPILE_STACK_TOP.fixup_alt_jump
                 = fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0;
               COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer;
               COMPILE_STACK_TOP.regnum = regnum;
@@ -1680,7 +1680,7 @@ regex_compile (pattern, size, syntax, bufp)
                   COMPILE_STACK_TOP.inner_group_offset = b - bufp->buffer + 2;
                   BUF_PUSH_3 (start_memory, regnum, 0);
                 }
-                
+
               compile_stack.avail++;
 
               fixup_alt_jump = 0;
@@ -1709,7 +1709,7 @@ regex_compile (pattern, size, syntax, bufp)
                      `pop_failure_jump' to pop.  See comments at
                      `push_dummy_failure' in `re_match_2'.  */
                   BUF_PUSH (push_dummy_failure);
-                  
+
                   /* We allocated space for this jump when we assigned
                      to `fixup_alt_jump', in the `handle_alt' case below.  */
                   STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1);
@@ -1731,11 +1731,11 @@ regex_compile (pattern, size, syntax, bufp)
                    as in `(ab)c(de)' -- the second group is #2.  */
                 regnum_t this_group_regnum;
 
-                compile_stack.avail--;		
+                compile_stack.avail--;
                 begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset;
                 fixup_alt_jump
                   = COMPILE_STACK_TOP.fixup_alt_jump
-                    ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1 
+                    ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1
                     : 0;
                 laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset;
                 this_group_regnum = COMPILE_STACK_TOP.regnum;
@@ -1750,7 +1750,7 @@ regex_compile (pattern, size, syntax, bufp)
                   {
                     unsigned char *inner_group_loc
                       = bufp->buffer + COMPILE_STACK_TOP.inner_group_offset;
-                    
+
                     *inner_group_loc = regnum - this_group_regnum;
                     BUF_PUSH_3 (stop_memory, this_group_regnum,
                                 regnum - this_group_regnum);
@@ -1779,10 +1779,10 @@ regex_compile (pattern, size, syntax, bufp)
                  jump (put in below, which in turn will jump to the next
                  (if any) alternative's such jump, etc.).  The last such
                  jump jumps to the correct final destination.  A picture:
-                          _____ _____ 
-                          |   | |   |   
-                          |   v |   v 
-                         a | b   | c   
+                          _____ _____
+                          |   | |   |
+                          |   v |   v
+                         a | b   | c
 
                  If we are at `b', then fixup_alt_jump right now points to a
                  three-byte space after `a'.  We'll put in the jump, set
@@ -1804,10 +1804,10 @@ regex_compile (pattern, size, syntax, bufp)
               break;
 
 
-            case '{': 
+            case '{':
               /* If \{ is a literal.  */
               if (!(syntax & RE_INTERVALS)
-                     /* If we're at `\{' and it's not the open-interval 
+                     /* If we're at `\{' and it's not the open-interval
                         operator.  */
                   || ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES))
                   || (p - 2 == pattern  &&  p == pend))
@@ -1846,11 +1846,11 @@ regex_compile (pattern, size, syntax, bufp)
                   {
                     if (syntax & RE_NO_BK_BRACES)
                       goto unfetch_interval;
-                    else 
+                    else
                       return REG_BADBR;
                   }
 
-                if (!(syntax & RE_NO_BK_BRACES)) 
+                if (!(syntax & RE_NO_BK_BRACES))
                   {
                     if (c != '\\') return REG_EBRACE;
 
@@ -1861,7 +1861,7 @@ regex_compile (pattern, size, syntax, bufp)
                   {
                     if (syntax & RE_NO_BK_BRACES)
                       goto unfetch_interval;
-                    else 
+                    else
                       return REG_BADBR;
                   }
 
@@ -1897,7 +1897,7 @@ regex_compile (pattern, size, syntax, bufp)
                       jump_n <succeed_n addr> <jump count>
                     (The upper bound and `jump_n' are omitted if
                     `upper_bound' is 1, though.)  */
-                 else 
+                 else
                    { /* If the upper bound is > 1, we need to insert
                         more at the end of the loop.  */
                      unsigned nbytes = 10 + (upper_bound > 1) * 10;
@@ -1914,7 +1914,7 @@ regex_compile (pattern, size, syntax, bufp)
                                    lower_bound);
                      b += 5;
 
-                     /* Code to initialize the lower bound.  Insert 
+                     /* Code to initialize the lower bound.  Insert
                         before the `succeed_n'.  The `5' is the last two
                         bytes of this `set_number_at', plus 3 bytes of
                         the following `succeed_n'.  */
@@ -1925,7 +1925,7 @@ regex_compile (pattern, size, syntax, bufp)
                        { /* More than one repetition is allowed, so
                             append a backward jump to the `succeed_n'
                             that starts this interval.
-                            
+
                             When we've reached this during matching,
                             we'll have matched the interval once, so
                             jump back only `upper_bound - 1' times.  */
@@ -1943,7 +1943,7 @@ regex_compile (pattern, size, syntax, bufp)
                             so everything is getting moved up by 5.
                             Conclusion: (b - 2) - (laststart + 3) + 5,
                             i.e., b - laststart.
-                            
+
                             We insert this at the beginning of the loop
                             so that if we fail during matching, we'll
                             reinitialize the bounds.  */
@@ -1964,7 +1964,7 @@ regex_compile (pattern, size, syntax, bufp)
                beg_interval = NULL;
 
                /* normal_char and normal_backslash need `c'.  */
-               PATFETCH (c);	
+               PATFETCH (c);
 
                if (!(syntax & RE_NO_BK_BRACES))
                  {
@@ -1980,7 +1980,7 @@ regex_compile (pattern, size, syntax, bufp)
               BUF_PUSH (at_dot);
               break;
 
-            case 's':	
+            case 's':
               laststart = b;
               PATFETCH (c);
               BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]);
@@ -2087,11 +2087,11 @@ regex_compile (pattern, size, syntax, bufp)
         /* Expects the character in `c'.  */
 	normal_char:
 	      /* If no exactn currently being built.  */
-          if (!pending_exact 
+          if (!pending_exact
 
               /* If last exactn not at current position.  */
               || pending_exact + *pending_exact + 1 != b
-              
+
               /* We have only one byte following the exactn for the count.  */
 	      || *pending_exact == (1 << BYTEWIDTH) - 1
 
@@ -2106,26 +2106,26 @@ regex_compile (pattern, size, syntax, bufp)
                       : (p[0] == '\\' && p[1] == '{'))))
 	    {
 	      /* Start building a new exactn.  */
-              
+
               laststart = b;
 
 	      BUF_PUSH_2 (exactn, 0);
 	      pending_exact = b - 1;
             }
-            
+
 	  BUF_PUSH (c);
           (*pending_exact)++;
 	  break;
         } /* switch (c) */
     } /* while p != pend */
 
-  
+
   /* Through the pattern now.  */
-  
+
   if (fixup_alt_jump)
     STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
 
-  if (!COMPILE_STACK_EMPTY) 
+  if (!COMPILE_STACK_EMPTY)
     return REG_EPAREN;
 
   free (compile_stack.stack);
@@ -2181,14 +2181,14 @@ insert_op1 (op, loc, arg, end)
     re_opcode_t op;
     unsigned char *loc;
     int arg;
-    unsigned char *end;    
+    unsigned char *end;
 {
   register unsigned char *pfrom = end;
   register unsigned char *pto = end + 3;
 
   while (pfrom != loc)
     *--pto = *--pfrom;
-    
+
   store_op1 (op, loc, arg);
 }
 
@@ -2200,14 +2200,14 @@ insert_op2 (op, loc, arg1, arg2, end)
     re_opcode_t op;
     unsigned char *loc;
     int arg1, arg2;
-    unsigned char *end;    
+    unsigned char *end;
 {
   register unsigned char *pfrom = end;
   register unsigned char *pto = end + 5;
 
   while (pfrom != loc)
     *--pto = *--pfrom;
-    
+
   store_op2 (op, loc, arg1, arg2);
 }
 
@@ -2223,7 +2223,7 @@ at_begline_loc_p (pattern, p, syntax)
 {
   const char *prev = p - 2;
   boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
-  
+
   return
        /* After a subexpression?  */
        (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash))
@@ -2243,7 +2243,7 @@ at_endline_loc_p (p, pend, syntax)
   const char *next = p;
   boolean next_backslash = *next == '\\';
   const char *next_next = p + 1 < pend ? p + 1 : NULL;
-  
+
   return
        /* Before a subexpression?  */
        (syntax & RE_NO_BK_PARENS ? *next == ')'
@@ -2254,7 +2254,7 @@ at_endline_loc_p (p, pend, syntax)
 }
 
 
-/* Returns true if REGNUM is in one of COMPILE_STACK's elements and 
+/* Returns true if REGNUM is in one of COMPILE_STACK's elements and
    false if it's not.  */
 
 static boolean
@@ -2264,8 +2264,8 @@ group_in_compile_stack (compile_stack, regnum)
 {
   int this_element;
 
-  for (this_element = compile_stack.avail - 1;  
-       this_element >= 0; 
+  for (this_element = compile_stack.avail - 1;
+       this_element >= 0;
        this_element--)
     if (compile_stack.stack[this_element].regnum == regnum)
       return true;
@@ -2279,9 +2279,9 @@ group_in_compile_stack (compile_stack, regnum)
    starting character is in `P[-2]'.  (`P[-1]' is the character `-'.)
    Then we set the translation of all bits between the starting and
    ending characters (inclusive) in the compiled pattern B.
-   
+
    Return an error code.
-   
+
    We use these short variable names so we can use the same macros as
    `regex_compile' itself.  */
 
@@ -2296,7 +2296,7 @@ compile_range (p_ptr, pend, translate, syntax, b)
 
   const char *p = *p_ptr;
   int range_start, range_end;
-  
+
   if (p == pend)
     return REG_ERANGE;
 
@@ -2305,7 +2305,7 @@ compile_range (p_ptr, pend, translate, syntax, b)
      is set, the range endpoints will be negative if we fetch using a
      signed char *.
 
-     We also want to fetch the endpoints without translating them; the 
+     We also want to fetch the endpoints without translating them; the
      appropriate translation is done in the bit-setting loop below.  */
   range_start = ((unsigned char *) p)[-2];
   range_end   = ((unsigned char *) p)[0];
@@ -2326,14 +2326,14 @@ compile_range (p_ptr, pend, translate, syntax, b)
     {
       SET_LIST_BIT (TRANSLATE (this_char));
     }
-  
+
   return REG_NOERROR;
 }
 
 /* Failure stack declarations and macros; both re_compile_fastmap and
    re_match_2 use a failure stack.  These have to be macros because of
    REGEX_ALLOCATE.  */
-   
+
 
 /* Number of failure points for which to initially allocate space
    when matching.  If this number is exceeded, we allocate more
@@ -2381,8 +2381,8 @@ typedef struct
 /* Double the size of FAIL_STACK, up to approximately `re_max_failures' items.
 
    Return 1 if succeeds, and 0 if either ran out of memory
-   allocating space for it or it was already too large.  
-   
+   allocating space for it or it was already too large.
+
    REGEX_REALLOCATE requires `destination' be declared.   */
 
 #define DOUBLE_FAIL_STACK(fail_stack)					\
@@ -2399,7 +2399,7 @@ typedef struct
          1)))
 
 
-/* Push PATTERN_OP on FAIL_STACK. 
+/* Push PATTERN_OP on FAIL_STACK.
 
    Return 1 if was able to do so and 0 if ran out of memory allocating
    space to do so.  */
@@ -2430,12 +2430,12 @@ typedef struct
 
 
 /* Push the information about the state we will need
-   if we ever fail back to it.  
-   
+   if we ever fail back to it.
+
    Requires variables fail_stack, regstart, regend, reg_info, and
    num_regs be declared.  DOUBLE_FAIL_STACK requires `destination' be
    declared.
-   
+
    Does `return FAILURE_CODE' if runs out of memory.  */
 
 #define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code)	\
@@ -2466,7 +2466,7 @@ typedef struct
 	DEBUG_PRINT2 ("\n  Doubled stack; size now: %d\n",		\
 		       (fail_stack).size);				\
 	DEBUG_PRINT2 ("  slots available: %d\n", REMAINING_AVAIL_SLOTS);\
-      }									
+      }
 
 #define PUSH_FAILURE_POINT2(pattern_place, string_place, failure_code)	\
     /* Push the info, starting with the registers.  */			\
@@ -2552,7 +2552,7 @@ typedef struct
      LOW_REG, HIGH_REG -- the highest and lowest active registers.
      REGSTART, REGEND -- arrays of string positions.
      REG_INFO -- array of information about each subexpression.
-   
+
    Also assumes the variables `fail_stack' and (if debugging), `bufp',
    `pend', `string1', `size1', `string2', and `size2'.  */
 
@@ -2627,7 +2627,7 @@ typedef struct
 
    The caller must supply the address of a (1 << BYTEWIDTH)-byte data
    area as BUFP->fastmap.
-   
+
    We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in
    the pattern buffer.
 
@@ -2644,7 +2644,7 @@ re_compile_fastmap (bufp)
 #endif
   /* We don't push any register information onto the failure stack.  */
   unsigned num_regs = 0;
-  
+
   register char *fastmap = bufp->fastmap;
   unsigned char *pattern = bufp->buffer;
   const unsigned char *p = pattern;
@@ -2660,27 +2660,27 @@ re_compile_fastmap (bufp)
   boolean succeed_n_p = false;
 
   assert (fastmap != NULL && p != NULL);
-  
+
   INIT_FAIL_STACK ();
   bzero (fastmap, 1 << BYTEWIDTH);  /* Assume nothing's valid.  */
   bufp->fastmap_accurate = 1;	    /* It will be when we're done.  */
   bufp->can_be_null = 0;
-      
+
   while (p != pend || !FAIL_STACK_EMPTY ())
     {
       if (p == pend)
         {
           bufp->can_be_null |= path_can_be_null;
-          
+
           /* Reset for next path.  */
           path_can_be_null = true;
-          
+
           p = fail_stack.stack[--fail_stack.avail];
 	}
 
       /* We should never be about to go beyond the end of the pattern.  */
       assert (p < pend);
-      
+
 #ifdef SWITCH_ENUM_BUG
       switch ((int) ((re_opcode_t) *p++))
 #else
@@ -2804,10 +2804,10 @@ re_compile_fastmap (bufp)
         case jump_past_alt:
 	case dummy_failure_jump:
           EXTRACT_NUMBER_AND_INCR (j, p);
-	  p += j;	
+	  p += j;
 	  if (j > 0)
 	    continue;
-            
+
           /* Jump backward implies we just went through the body of a
              loop and matched nothing.  Opcode jumped to should be
              `on_failure_jump' or `succeed_n'.  Just treat it like an
@@ -2819,10 +2819,10 @@ re_compile_fastmap (bufp)
 
           p++;
           EXTRACT_NUMBER_AND_INCR (j, p);
-          p += j;		
-	  
+          p += j;
+
           /* If what's on the stack is where we are now, pop it.  */
-          if (!FAIL_STACK_EMPTY () 
+          if (!FAIL_STACK_EMPTY ()
 	      && fail_stack.stack[fail_stack.avail - 1] == p)
             fail_stack.avail--;
 
@@ -2860,7 +2860,7 @@ re_compile_fastmap (bufp)
 
 	case succeed_n:
           /* Get to the number of times to succeed.  */
-          p += 2;		
+          p += 2;
 
           /* Increment p past the n for when k != 0.  */
           EXTRACT_NUMBER_AND_INCR (k, p);
@@ -2951,7 +2951,7 @@ re_search (bufp, string, size, startpos, range, regs)
      int size, startpos, range;
      struct re_registers *regs;
 {
-  return re_search_2 (bufp, NULL, 0, string, size, startpos, range, 
+  return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
 		      regs, size);
 }
 
@@ -2959,17 +2959,17 @@ re_search (bufp, string, size, startpos, range, regs)
 /* Using the compiled pattern in BUFP->buffer, first tries to match the
    virtual concatenation of STRING1 and STRING2, starting first at index
    STARTPOS, then at STARTPOS + 1, and so on.
-   
+
    STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.
-   
+
    RANGE is how far to scan while trying to match.  RANGE = 0 means try
    only at STARTPOS; in general, the last start tried is STARTPOS +
    RANGE.
-   
+
    In REGS, return the indices of the virtual concatenation of STRING1
    and STRING2 that matched the entire BUFP->buffer and its contained
    subexpressions.
-   
+
    Do not consider matching one past the index STOP in the virtual
    concatenation of STRING1 and STRING2.
 
@@ -2996,7 +2996,7 @@ re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)
   /* Check for out-of-range STARTPOS.  */
   if (startpos < 0 || startpos > total_size)
     return -1;
-    
+
   /* Fix up RANGE if it might eventually take us outside
      the virtual concatenation of STRING1 and STRING2.  */
   if (endpos < -1)
@@ -3018,10 +3018,10 @@ re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)
   if (fastmap && !bufp->fastmap_accurate)
     if (re_compile_fastmap (bufp) == -2)
       return -2;
-  
+
   /* Loop through the string, looking for a place to start matching.  */
   for (;;)
-    { 
+    {
       /* If a fastmap is supplied, skip quickly over characters that
          cannot be the start of a match.  If the pattern can match the
          null string, however, we don't need to skip characters; we want
@@ -3038,7 +3038,7 @@ re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)
                 lim = range - (size1 - startpos);
 
 	      d = (startpos >= size1 ? string2 - size1 : string1) + startpos;
-   
+
               /* Written out as an if-else to avoid testing `translate'
                  inside the loop.  */
 	      if (translate)
@@ -3055,7 +3055,7 @@ re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)
 	  else				/* Searching backwards.  */
 	    {
 	      register char c = (size1 == 0 || startpos >= size1
-                                 ? string2[startpos - size1] 
+                                 ? string2[startpos - size1]
                                  : string1[startpos]);
 
 	      if (!fastmap[(unsigned char) TRANSLATE (c)])
@@ -3072,21 +3072,21 @@ re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)
 	                startpos, regs, stop);
       if (val >= 0)
 	return startpos;
-        
+
       if (val == -2)
 	return -2;
 
     advance:
-      if (!range) 
+      if (!range)
         break;
-      else if (range > 0) 
+      else if (range > 0)
         {
-          range--; 
+          range--;
           startpos++;
         }
       else
         {
-          range++; 
+          range++;
           startpos--;
         }
     }
@@ -3098,8 +3098,8 @@ re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)
    onto the failure stack.  Other register information, such as the
    starting and ending positions (which are addresses), and the list of
    inner groups (which is a bits list) are maintained in separate
-   variables.  
-   
+   variables.
+
    We are making a (strictly speaking) nonportable assumption here: that
    the compiler will pack our bit fields into something that fits into
    the type of `word', i.e., is something that fits into one item on the
@@ -3187,7 +3187,7 @@ static int bcmp_translate _RE_ARGS((const char *s1, const char *s2,
 /* Test if at very beginning or at very end of the virtual concatenation
    of `string1' and `string2'.  If only one string, it's `string2'.  */
 #define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2)
-#define AT_STRINGS_END(d) ((d) == end2)	
+#define AT_STRINGS_END(d) ((d) == end2)
 
 
 /* Test if D points to a character which is word-constituent.  We have
@@ -3250,7 +3250,7 @@ re_match (bufp, string, size, pos, regs)
      int size, pos;
      struct re_registers *regs;
  {
-  return re_match_2 (bufp, NULL, 0, string, size, pos, regs, size); 
+  return re_match_2 (bufp, NULL, 0, string, size, pos, regs, size);
 }
 #endif /* not emacs */
 
@@ -3259,7 +3259,7 @@ re_match (bufp, string, size, pos, regs)
    the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1
    and SIZE2, respectively).  We start matching at POS, and stop
    matching at STOP.
-   
+
    If REGS is non-null and the `no_sub' field of BUFP is nonzero, we
    store offsets for the substring each group matched in REGS.  See the
    documentation for exactly how many groups we fill.
@@ -3290,7 +3290,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 
   /* Where we are in the data, and the end of the current string.  */
   const char *d, *dend;
-  
+
   /* Where we are in the pattern, and the end of the pattern.  */
   unsigned char *p = bufp->buffer;
   register unsigned char *pend = p + bufp->used;
@@ -3317,7 +3317,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
      return, for use in backreferences.  The number here includes
      an element for register zero.  */
   size_t num_regs = bufp->re_nsub + 1;
-  
+
   /* The currently active registers.  */
   active_reg_t lowest_active_reg = NO_LOWEST_ACTIVE_REG;
   active_reg_t highest_active_reg = NO_HIGHEST_ACTIVE_REG;
@@ -3344,15 +3344,15 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
      matched any of the pattern so far this time through the reg_num-th
      subexpression.  These two fields get reset each time through any
      loop their register is in.  */
-  register_info_type *reg_info = 0; 
+  register_info_type *reg_info = 0;
 
   /* The following record the register info as found in the above
-     variables when we find a match better than any we've seen before. 
+     variables when we find a match better than any we've seen before.
      This happens as we backtrack through the failure points, which in
      turn happens only if we have not yet matched the entire string. */
   unsigned best_regs_set = false;
   const char **best_regstart = 0, **best_regend = 0;
-  
+
   /* Logically, this is `best_regend[0]'.  But we don't want to have to
      allocate space for that if we're not allocating space for anything
      else (see below).  Also, we never need info about register 0 for
@@ -3369,13 +3369,13 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 
 #ifdef DEBUG
   /* Counts the total number of registers pushed.  */
-  unsigned num_regs_pushed = 0; 	
+  unsigned num_regs_pushed = 0;
 #endif
 
   DEBUG_PRINT1 ("\n\nEntering re_match_2.\n");
-  
+
   INIT_FAIL_STACK ();
-  
+
   /* Do not bother to initialize all the register variables if there are
      no groups in the pattern, as it takes a fair amount of time.  If
      there are groups, we include space for register 0 (the whole
@@ -3393,8 +3393,8 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
       reg_dummy = REGEX_TALLOC (num_regs, const char *);
       reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type);
 
-      if (!(regstart && regend && old_regstart && old_regend && reg_info 
-            && best_regstart && best_regend && reg_dummy && reg_info_dummy)) 
+      if (!(regstart && regend && old_regstart && old_regend && reg_info
+            && best_regstart && best_regend && reg_dummy && reg_info_dummy))
         {
           FREE_VARIABLES ();
           return -2;
@@ -3417,21 +3417,21 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
       FREE_VARIABLES ();
       return -1;
     }
-    
+
   /* Initialize subexpression text positions to -1 to mark ones that no
      start_memory/stop_memory has been seen for. Also initialize the
      register information struct.  */
   for (mcnt = 1; mcnt < num_regs; mcnt++)
     {
-      regstart[mcnt] = regend[mcnt] 
+      regstart[mcnt] = regend[mcnt]
         = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE;
-        
+
       REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE;
       IS_ACTIVE (reg_info[mcnt]) = 0;
       MATCHED_SOMETHING (reg_info[mcnt]) = 0;
       EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0;
     }
-  
+
   /* We move `string1' into `string2' if the latter's empty -- but not if
      `string1' is null.  */
   if (size2 == 0 && string1 != NULL)
@@ -3456,7 +3456,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
       end_match_2 = string2 + stop - size1;
     }
 
-  /* `p' scans through the pattern as `d' scans through the data. 
+  /* `p' scans through the pattern as `d' scans through the data.
      `dend' is the end of the input string that `d' points within.  `d'
      is advanced into the following input string whenever necessary, but
      this happens before fetching; therefore, at the beginning of the
@@ -3478,7 +3478,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
   DEBUG_PRINT1 ("The string to match is: `");
   DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);
   DEBUG_PRINT1 ("'\n");
-  
+
   /* This loops over pattern commands.  It exits by returning from the
      function if the match is complete, or it drops through if the match
      fails at this starting point in the input data.  */
@@ -3489,16 +3489,16 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
       if (p == pend)
 	{ /* End of pattern means we might have succeeded.  */
           DEBUG_PRINT1 ("end of pattern ... ");
-          
+
 	  /* If we haven't matched the entire string, and we want the
              longest match, try backtracking.  */
           if (d != end_match_2)
 	    {
               DEBUG_PRINT1 ("backtracking.\n");
-              
+
               if (!FAIL_STACK_EMPTY ())
                 { /* More failure points to try.  */
-                  boolean same_str_p = (FIRST_STRING_P (match_end) 
+                  boolean same_str_p = (FIRST_STRING_P (match_end)
 	        	                == MATCHING_IN_FIRST_STRING);
 
                   /* If exceeds best match so far, save it.  */
@@ -3508,20 +3508,20 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                     {
                       best_regs_set = true;
                       match_end = d;
-                      
+
                       DEBUG_PRINT1 ("\nSAVING match as best so far.\n");
-                      
+
                       for (mcnt = 1; mcnt < num_regs; mcnt++)
                         {
                           best_regstart[mcnt] = regstart[mcnt];
                           best_regend[mcnt] = regend[mcnt];
                         }
                     }
-                  goto fail;	       
+                  goto fail;
                 }
 
               /* If no failure points, don't restore garbage.  */
-              else if (best_regs_set)   
+              else if (best_regs_set)
                 {
   	        restore_best_regs:
                   /* Restore best match.  It may happen that `dend ==
@@ -3530,7 +3530,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                      strings `x-' and `y-z-', if the two strings are
                      not consecutive in memory.  */
                   DEBUG_PRINT1 ("Restoring best registers.\n");
-                  
+
                   d = match_end;
                   dend = ((d >= string1 && d <= end1)
 		           ? end_match_1 : end_match_2);
@@ -3589,7 +3589,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                   regs->end[0] = (MATCHING_IN_FIRST_STRING ? d - string1
 			          : d - string2 + size1);
                 }
-              
+
               /* Go through the first `min (num_regs, regs->num_regs)'
                  registers, since that is all we initialized.  */
 	      for (mcnt = 1; mcnt < MIN (num_regs, regs->num_regs); mcnt++)
@@ -3602,7 +3602,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                       regs->end[mcnt] = POINTER_TO_OFFSET (regend[mcnt]);
                     }
 		}
-              
+
               /* If the regs structure we return has more elements than
                  were in the pattern, set the extra elements to -1.  If
                  we (re)allocated the registers, this is the case,
@@ -3618,8 +3618,8 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                         nfailure_points_pushed - nfailure_points_popped);
           DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed);
 
-          mcnt = d - pos - (MATCHING_IN_FIRST_STRING 
-			    ? string1 
+          mcnt = d - pos - (MATCHING_IN_FIRST_STRING
+			    ? string1
 			    : string2 - size1);
 
           DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt);
@@ -3709,7 +3709,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 	    p += 1 + *p;
 
 	    if (!not) goto fail;
-            
+
 	    SET_REGS_MATCHED ();
             d++;
 	    break;
@@ -3726,9 +3726,9 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 
           /* Find out if this group can match the empty string.  */
 	  p1 = p;		/* To send to group_match_null_string_p.  */
-          
+
           if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE)
-            REG_MATCH_NULL_STRING_P (reg_info[*p]) 
+            REG_MATCH_NULL_STRING_P (reg_info[*p])
               = group_match_null_string_p (&p1, pend, reg_info);
 
           /* Save the position in the string where we were the last time
@@ -3739,7 +3739,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
           old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])
                              ? REG_UNSET (regstart[*p]) ? d : regstart[*p]
                              : regstart[*p];
-	  DEBUG_PRINT2 ("  old_regstart: %d\n", 
+	  DEBUG_PRINT2 ("  old_regstart: %d\n",
 			 POINTER_TO_OFFSET (old_regstart[*p]));
 
           regstart[*p] = d;
@@ -3747,10 +3747,10 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 
           IS_ACTIVE (reg_info[*p]) = 1;
           MATCHED_SOMETHING (reg_info[*p]) = 0;
-          
+
           /* This is the new highest active register.  */
           highest_active_reg = *p;
-          
+
           /* If nothing was active before, this is the new lowest active
              register.  */
           if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
@@ -3766,7 +3766,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
            number, and the number of inner groups.  */
 	case stop_memory:
 	  DEBUG_PRINT3 ("EXECUTING stop_memory %d (%d):\n", *p, p[1]);
-             
+
           /* We need to save the string position the last time we were at
              this close-group operator in case the group is operated
              upon by a repetition operator, e.g., with `((a*)*(b*)*)*'
@@ -3775,7 +3775,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
           old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])
                            ? REG_UNSET (regend[*p]) ? d : regend[*p]
 			   : regend[*p];
-	  DEBUG_PRINT2 ("      old_regend: %d\n", 
+	  DEBUG_PRINT2 ("      old_regend: %d\n",
 			 POINTER_TO_OFFSET (old_regend[*p]));
 
           regend[*p] = d;
@@ -3783,7 +3783,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 
           /* This register isn't active anymore.  */
           IS_ACTIVE (reg_info[*p]) = 0;
-          
+
           /* If this was the only register active, nothing is active
              anymore.  */
           if (lowest_active_reg == highest_active_reg)
@@ -3799,7 +3799,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
               unsigned char r = *p - 1;
               while (r > 0 && !IS_ACTIVE (reg_info[r]))
                 r--;
-              
+
               /* If we end up at register zero, that means that we saved
                  the registers as the result of an `on_failure_jump', not
                  a `start_memory', and we jumped to past the innermost
@@ -3815,7 +3815,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
               else
                 highest_active_reg = r;
             }
-          
+
           /* If just failed to match something this time around with a
              group that's operated on by a repetition operator, try to
              force exit from the ``loop'', and restore the register
@@ -3823,10 +3823,10 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
              last match.  */
           if ((!MATCHED_SOMETHING (reg_info[*p])
                || (re_opcode_t) p[-3] == start_memory)
-	      && (p + 2) < pend)              
+	      && (p + 2) < pend)
             {
               boolean is_a_jump_n = false;
-              
+
               p1 = p + 2;
               mcnt = 0;
               switch ((re_opcode_t) *p1++)
@@ -3841,12 +3841,12 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 		    if (is_a_jump_n)
 		      p1 += 2;
                     break;
-                  
+
                   default:
                     /* do nothing */ ;
                 }
 	      p1 += mcnt;
-        
+
               /* If the next operation is a jump backwards in the pattern
 	         to an on_failure_jump right before the start_memory
                  corresponding to this stop_memory, exit from the loop
@@ -3860,17 +3860,17 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                      failed match, e.g., with `(a*)*b' against `ab' for
                      regstart[1], and, e.g., with `((a*)*(b*)*)*'
                      against `aba' for regend[3].
-                     
+
                      Also restore the registers for inner groups for,
                      e.g., `((a*)(b*))*' against `aba' (register 3 would
                      otherwise get trashed).  */
-                     
+
                   if (EVER_MATCHED_SOMETHING (reg_info[*p]))
 		    {
-		      unsigned r; 
-        
+		      unsigned r;
+
                       EVER_MATCHED_SOMETHING (reg_info[*p]) = 0;
-                      
+
 		      /* Restore this and inner groups' (if any) registers.  */
                       for (r = *p; r < *p + *(p + 1); r++)
                         {
@@ -3879,7 +3879,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                           /* xx why this test?  */
                           if ((s_reg_t) old_regend[r] >= (s_reg_t) regstart[r])
                             regend[r] = old_regend[r];
-                        }     
+                        }
                     }
 		  p1++;
                   EXTRACT_NUMBER_AND_INCR (mcnt, p1);
@@ -3889,7 +3889,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                   goto fail;
                 }
             }
-          
+
           /* Move past the register number and the inner group count.  */
           p += 2;
           break;
@@ -3906,16 +3906,16 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 	    /* Can't back reference a group which we've never matched.  */
             if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))
               goto fail;
-              
+
             /* Where in input to try to start matching.  */
             d2 = regstart[regno];
-            
+
             /* Where to stop matching; if both the place to start and
                the place to stop matching are in the same string, then
                set to the place to stop, otherwise, for now have to use
                the end of the first string.  */
 
-            dend2 = ((FIRST_STRING_P (regstart[regno]) 
+            dend2 = ((FIRST_STRING_P (regstart[regno])
 		      == FIRST_STRING_P (regend[regno]))
 		     ? regend[regno] : end_match_1);
 	    for (;;)
@@ -3939,16 +3939,16 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 
 		/* How many characters left in this segment to match.  */
 		mcnt = dend - d;
-                
+
 		/* Want how many consecutive characters we can match in
                    one shot, so, if necessary, adjust the count.  */
                 if (mcnt > dend2 - d2)
 		  mcnt = dend2 - d2;
-                  
+
 		/* Compare that many; failure if mismatch, else move
                    past them.  */
-		if (translate 
-                    ? bcmp_translate (d, d2, mcnt, translate) 
+		if (translate
+                    ? bcmp_translate (d, d2, mcnt, translate)
                     : bcmp (d, d2, mcnt))
 		  goto fail;
 		d += mcnt, d2 += mcnt;
@@ -3962,7 +3962,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
            `newline_anchor' is set, after newlines.  */
 	case begline:
           DEBUG_PRINT1 ("EXECUTING begline.\n");
-          
+
           if (AT_STRINGS_BEG (d))
             {
               if (!bufp->not_bol) break;
@@ -3983,7 +3983,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
             {
               if (!bufp->not_eol) break;
             }
-          
+
           /* We have to ``prefetch'' the next character.  */
           else if ((d == end1 ? *string2 : *d) == '\n'
                    && bufp->newline_anchor)
@@ -4017,7 +4017,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
            then the . fails against the \n.  But the next thing we want
            to do is match the \n against the \n; if we restored the
            string value, we would be back at the foo.
-           
+
            Because this is used only in specific cases, we don't need to
            check all the things that `on_failure_jump' does, to make
            sure the right things get saved on the stack.  Hence we don't
@@ -4027,7 +4027,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
            case; that seems worse than this.  */
         case on_failure_keep_string_jump:
           DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump");
-          
+
           EXTRACT_NUMBER_AND_INCR (mcnt, p);
           DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt);
 
@@ -4037,7 +4037,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 
 
 	/* Uses of on_failure_jump:
-        
+
            Each alternative starts with an on_failure_jump that points
            to the beginning of the next alternative.  Each alternative
            except the last ends with a jump that in effect jumps past
@@ -4104,7 +4104,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                would have to backtrack because of (as in, e.g., `a*a')
                then we can change to pop_failure_jump, because we'll
                never have to backtrack.
-               
+
                This is not true in the case of alternatives: in
                `(a|ab)*' we do need to backtrack to the `ab' alternative
                (e.g., if the string was `ab').  But instead of trying to
@@ -4136,7 +4136,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 		p1 = p + mcnt;
 
                 /* p1[0] ... p1[2] are the `on_failure_jump' corresponding
-                   to the `maybe_finalize_jump' of this case.  Examine what 
+                   to the `maybe_finalize_jump' of this case.  Examine what
                    follows.  */
                 if ((re_opcode_t) p1[3] == exactn && p1[5] != c)
                   {
@@ -4144,12 +4144,12 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                     DEBUG_PRINT3 ("  %c != %c => pop_failure_jump.\n",
                                   c, p1[5]);
                   }
-                  
+
 		else if ((re_opcode_t) p1[3] == charset
 			 || (re_opcode_t) p1[3] == charset_not)
 		  {
 		    int not = (re_opcode_t) p1[3] == charset_not;
-                    
+
 		    if (c < (unsigned char) (p1[4] * BYTEWIDTH)
 			&& p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
 		      not = !not;
@@ -4198,7 +4198,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
           }
           /* Note fall through.  */
 
-          
+
         /* Unconditionally jump (without popping any failure points).  */
         case jump:
 	unconditional_jump:
@@ -4208,7 +4208,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
           DEBUG_PRINT2 ("(to 0x%x).\n", p);
 	  break;
 
-	
+
         /* We need this opcode so we can detect where alternatives end
            in `group_match_null_string_p' et al.  */
         case jump_past_alt:
@@ -4245,7 +4245,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 
         /* Have to succeed matching what follows at least n times.
            After that, handle like `on_failure_jump'.  */
-        case succeed_n: 
+        case succeed_n:
           EXTRACT_NUMBER (mcnt, p + 2);
           DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt);
 
@@ -4266,8 +4266,8 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
               goto on_failure;
             }
           break;
-        
-        case jump_n: 
+
+        case jump_n:
           EXTRACT_NUMBER (mcnt, p + 2);
           DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt);
 
@@ -4276,13 +4276,13 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
             {
                mcnt--;
                STORE_NUMBER (p + 2, mcnt);
-	       goto unconditional_jump;	     
+	       goto unconditional_jump;
             }
           /* If don't have to jump any more, skip over the rest of command.  */
-	  else      
-	    p += 4;		     
+	  else
+	    p += 4;
           break;
-        
+
 	case set_number_at:
 	  {
             DEBUG_PRINT1 ("EXECUTING set_number_at.\n");
@@ -4327,13 +4327,13 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
  	  if (PTR_CHAR_POS ((unsigned char *) d) >= point)
   	    goto fail;
   	  break;
-  
+
   	case at_dot:
           DEBUG_PRINT1 ("EXECUTING at_dot.\n");
  	  if (PTR_CHAR_POS ((unsigned char *) d) != point)
   	    goto fail;
   	  break;
-  
+
   	case after_dot:
           DEBUG_PRINT1 ("EXECUTING after_dot.\n");
           if (PTR_CHAR_POS ((unsigned char *) d) <= point)
@@ -4386,7 +4386,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 	  SET_REGS_MATCHED ();
           d++;
 	  break;
-	  
+
 	case notwordchar:
           DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n");
 	  PREFETCH ();
@@ -4396,7 +4396,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
           d++;
 	  break;
 #endif /* not emacs */
-          
+
         default:
           abort ();
 	}
@@ -4421,7 +4421,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
           if (p < pend)
             {
               boolean is_a_jump_n = false;
-              
+
               /* If failed to a backwards jump that's part of a repetition
                  loop, need to pop this failure point and use the next one.  */
               switch ((re_opcode_t) *p)
@@ -4433,7 +4433,7 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
                 case jump:
                   p1 = p + 1;
                   EXTRACT_NUMBER_AND_INCR (mcnt, p1);
-                  p1 += mcnt;	
+                  p1 += mcnt;
 
                   if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n)
                       || (!is_a_jump_n
@@ -4464,10 +4464,10 @@ re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
 
 
 /* We are passed P pointing to a register number after a start_memory.
-   
+
    Return true if the pattern up to the corresponding stop_memory can
    match the empty string, and false otherwise.
-   
+
    If we find the matching stop_memory, sets P to point to one past its number.
    Otherwise, sets P to an undefined byte less than or equal to END.
 
@@ -4481,20 +4481,20 @@ group_match_null_string_p (p, end, reg_info)
   int mcnt;
   /* Point to after the args to the start_memory.  */
   unsigned char *p1 = *p + 2;
-  
+
   while (p1 < end)
     {
       /* Skip over opcodes that can match nothing, and return true or
 	 false, as appropriate, when we get to one that can't, or to the
          matching stop_memory.  */
-      
+
       switch ((re_opcode_t) *p1)
         {
         /* Could be either a loop or a series of alternatives.  */
         case on_failure_jump:
           p1++;
           EXTRACT_NUMBER_AND_INCR (mcnt, p1);
-          
+
           /* If the next operation is not a jump backwards in the
 	     pattern.  */
 
@@ -4508,7 +4508,7 @@ group_match_null_string_p (p, end, reg_info)
 
                  /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6
                  /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3
-                 /exactn/1/c						
+                 /exactn/1/c
 
                  So, we have to first go through the first (n-1)
                  alternatives and then deal with the last one separately.  */
@@ -4524,19 +4524,19 @@ group_match_null_string_p (p, end, reg_info)
                      is, including the ending `jump_past_alt' and
                      its number.  */
 
-                  if (!alt_match_null_string_p (p1, p1 + mcnt - 3, 
+                  if (!alt_match_null_string_p (p1, p1 + mcnt - 3,
 				                      reg_info))
                     return false;
 
                   /* Move to right after this alternative, including the
 		     jump_past_alt.  */
-                  p1 += mcnt;	
+                  p1 += mcnt;
 
                   /* Break if it's the beginning of an n-th alternative
                      that doesn't begin with an on_failure_jump.  */
                   if ((re_opcode_t) *p1 != on_failure_jump)
                     break;
-		
+
 		  /* Still have to check that it's not an n-th
 		     alternative that starts with an on_failure_jump.  */
 		  p1++;
@@ -4561,14 +4561,14 @@ group_match_null_string_p (p, end, reg_info)
             } /* if mcnt > 0 */
           break;
 
-          
+
         case stop_memory:
 	  assert (p1[1] == **p);
           *p = p1 + 2;
           return true;
 
-        
-        default: 
+
+        default:
           if (!common_op_match_null_string_p (&p1, end, reg_info))
             return false;
         }
@@ -4581,7 +4581,7 @@ group_match_null_string_p (p, end, reg_info)
 /* Similar to group_match_null_string_p, but doesn't deal with alternatives:
    It expects P to be the first byte of a single alternative and END one
    byte past the last. The alternative can contain groups.  */
-   
+
 static boolean
 alt_match_null_string_p (p, end, reg_info)
     unsigned char *p, *end;
@@ -4589,12 +4589,12 @@ alt_match_null_string_p (p, end, reg_info)
 {
   int mcnt;
   unsigned char *p1 = p;
-  
+
   while (p1 < end)
     {
-      /* Skip over opcodes that can match nothing, and break when we get 
+      /* Skip over opcodes that can match nothing, and break when we get
          to one that can't.  */
-      
+
       switch ((re_opcode_t) *p1)
         {
 	/* It's a loop.  */
@@ -4603,8 +4603,8 @@ alt_match_null_string_p (p, end, reg_info)
           EXTRACT_NUMBER_AND_INCR (mcnt, p1);
           p1 += mcnt;
           break;
-          
-	default: 
+
+	default:
           if (!common_op_match_null_string_p (&p1, end, reg_info))
             return false;
         }
@@ -4615,8 +4615,8 @@ alt_match_null_string_p (p, end, reg_info)
 
 
 /* Deals with the ops common to group_match_null_string_p and
-   alt_match_null_string_p.  
-   
+   alt_match_null_string_p.
+
    Sets P to one after the op and its arguments, if any.  */
 
 static boolean
@@ -4651,7 +4651,7 @@ common_op_match_null_string_p (p, end, reg_info)
       reg_no = *p1;
       assert (reg_no > 0 && reg_no <= MAX_REGNUM);
       ret = group_match_null_string_p (&p1, end, reg_info);
-      
+
       /* Have to set this here in case we're checking a group which
          contains a group and a back reference to it.  */
 
@@ -4661,7 +4661,7 @@ common_op_match_null_string_p (p, end, reg_info)
       if (!ret)
         return false;
       break;
-          
+
     /* If this is an optimized succeed_n for zero times, make the jump.  */
     case jump:
       EXTRACT_NUMBER_AND_INCR (mcnt, p1);
@@ -4673,7 +4673,7 @@ common_op_match_null_string_p (p, end, reg_info)
 
     case succeed_n:
       /* Get to the number of times to succeed.  */
-      p1 += 2;		
+      p1 += 2;
       EXTRACT_NUMBER_AND_INCR (mcnt, p1);
 
       if (mcnt == 0)
@@ -4686,7 +4686,7 @@ common_op_match_null_string_p (p, end, reg_info)
         return false;
       break;
 
-    case duplicate: 
+    case duplicate:
       if (!REG_MATCH_NULL_STRING_P (reg_info[*p1]))
         return false;
       break;
@@ -4706,7 +4706,7 @@ common_op_match_null_string_p (p, end, reg_info)
 
 /* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN
    bytes; nonzero otherwise.  */
-   
+
 static int
 bcmp_translate (s1, s2, len, translate)
      const char *s1, *s2;
@@ -4728,10 +4728,10 @@ bcmp_translate (s1, s2, len, translate)
 /* re_compile_pattern is the GNU regular expression compiler: it
    compiles PATTERN (of length SIZE) and puts the result in BUFP.
    Returns 0 if the pattern was valid, otherwise an error string.
-   
+
    Assumes the `allocated' (and perhaps `buffer') and `translate' fields
    are set in BUFP on entry.
-   
+
    We call regex_compile to do the actual compilation.  */
 
 const char *
@@ -4741,23 +4741,23 @@ re_compile_pattern (pattern, length, bufp)
      struct re_pattern_buffer *bufp;
 {
   reg_errcode_t ret;
-  
+
   /* GNU code is written to assume at least RE_NREGS registers will be set
      (and at least one extra will be -1).  */
   bufp->regs_allocated = REGS_UNALLOCATED;
-  
+
   /* And GNU code determines whether or not to get register information
      by passing null for the REGS argument to re_match, etc., not by
      setting no_sub.  */
   bufp->no_sub = 0;
-  
+
   /* Match anchors at newline.  */
   bufp->newline_anchor = 1;
-  
+
   ret = regex_compile (pattern, length, re_syntax_options, bufp);
 
   return re_error_msg[(int) ret];
-}     
+}
 
 /* Entry points compatible with 4.2 BSD regex library.  We don't define
    them if this is an Emacs or POSIX compilation.  */
@@ -4772,7 +4772,7 @@ re_comp (s)
     const char *s;
 {
   reg_errcode_t ret;
-  
+
   if (!s)
     {
       if (!re_comp_buf.buffer)
@@ -4799,7 +4799,7 @@ re_comp (s)
   re_comp_buf.newline_anchor = 1;
 
   ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
-  
+
   /* Yes, we're discarding `const' here.  */
   return (char *) re_error_msg[(int) ret];
 }
@@ -4856,7 +4856,7 @@ re_exec (s)
 int
 regcomp (preg, pattern, cflags)
     regex_t *preg;
-    const char *pattern; 
+    const char *pattern;
     int cflags;
 {
   reg_errcode_t ret;
@@ -4868,17 +4868,17 @@ regcomp (preg, pattern, cflags)
   preg->buffer = 0;
   preg->allocated = 0;
   preg->used = 0;
-  
+
   /* Don't bother to use a fastmap when searching.  This simplifies the
      REG_NEWLINE case: if we used a fastmap, we'd have to put all the
      characters after newlines into the fastmap.  This way, we just try
      every character.  */
   preg->fastmap = 0;
-  
+
   if (cflags & REG_ICASE)
     {
       unsigned i;
-      
+
       preg->translate = (char *) malloc (CHAR_SET_SIZE);
       if (preg->translate == NULL)
         return (int) REG_ESPACE;
@@ -4903,38 +4903,38 @@ regcomp (preg, pattern, cflags)
 
   preg->no_sub = !!(cflags & REG_NOSUB);
 
-  /* POSIX says a null character in the pattern terminates it, so we 
+  /* POSIX says a null character in the pattern terminates it, so we
      can use strlen here in compiling the pattern.  */
   ret = regex_compile (pattern, strlen (pattern), syntax, preg);
-  
+
   /* POSIX doesn't distinguish between an unmatched open-group and an
      unmatched close-group: both are REG_EPAREN.  */
   if (ret == REG_ERPAREN) ret = REG_EPAREN;
-  
+
   return (int) ret;
 }
 
 
 /* regexec searches for a given pattern, specified by PREG, in the
    string STRING.
-   
+
    If NMATCH is zero or REG_NOSUB was set in the cflags argument to
    `regcomp', we ignore PMATCH.  Otherwise, we assume PMATCH has at
    least NMATCH elements, and we set them to the offsets of the
    corresponding matched substrings.
-   
+
    EFLAGS specifies `execution flags' which affect matching: if
    REG_NOTBOL is set, then ^ does not match at the beginning of the
    string; if REG_NOTEOL is set, then $ does not match at the end.
-   
+
    We return 0 if we find a match and REG_NOMATCH if not.  */
 
 int
 regexec (preg, string, nmatch, pmatch, eflags)
     const regex_t *preg;
-    const char *string; 
-    size_t nmatch; 
-    regmatch_t pmatch[]; 
+    const char *string;
+    size_t nmatch;
+    regmatch_t pmatch[];
     int eflags;
 {
   int ret;
@@ -4944,15 +4944,15 @@ regexec (preg, string, nmatch, pmatch, eflags)
   boolean want_reg_info = !preg->no_sub && nmatch > 0;
 
   private_preg = *preg;
-  
+
   private_preg.not_bol = !!(eflags & REG_NOTBOL);
   private_preg.not_eol = !!(eflags & REG_NOTEOL);
-  
+
   /* The user has told us exactly how many registers to return
      information about, via `nmatch'.  We have to pass that on to the
      matching routines.  */
   private_preg.regs_allocated = REGS_FIXED;
-  
+
   if (want_reg_info)
     {
       regs.num_regs = nmatch;
@@ -4966,7 +4966,7 @@ regexec (preg, string, nmatch, pmatch, eflags)
   ret = re_search (&private_preg, string, len,
                    /* start: */ 0, /* range: */ len,
                    want_reg_info ? &regs : (struct re_registers *) 0);
-  
+
   /* Copy the register information to the POSIX structure.  */
   if (want_reg_info)
     {
@@ -5006,7 +5006,7 @@ regerror (errcode, preg, errbuf, errbuf_size)
 
   if (errcode < 0
       || errcode >= (sizeof (re_error_msg) / sizeof (re_error_msg[0])))
-    /* Only error codes returned by the rest of the code should be passed 
+    /* Only error codes returned by the rest of the code should be passed
        to this routine.  If we are given anything else, or if other regex
        code generates an invalid error code, then the program has a bug.
        Dump core so we can fix it.  */
@@ -5020,7 +5020,7 @@ regerror (errcode, preg, errbuf, errbuf_size)
     msg = "Success";
 
   msg_size = strlen (msg) + 1; /* Includes the null.  */
-  
+
   if (errbuf_size != 0)
     {
       if (msg_size > errbuf_size)
@@ -5045,7 +5045,7 @@ regfree (preg)
   if (preg->buffer != NULL)
     free (preg->buffer);
   preg->buffer = NULL;
-  
+
   preg->allocated = 0;
   preg->used = 0;
 
diff --git a/gnu/lib/libregex/regex.h b/gnu/lib/libregex/regex.h
index 757dbac..462d883 100644
--- a/gnu/lib/libregex/regex.h
+++ b/gnu/lib/libregex/regex.h
@@ -49,7 +49,7 @@ typedef unsigned long reg_syntax_t;
 #define RE_BACKSLASH_ESCAPE_IN_LISTS (1L)
 
 /* If this bit is not set, then + and ? are operators, and \+ and \? are
-     literals. 
+     literals.
    If set, then \+ and \? are operators and + and ? are literals.  */
 #define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)
 
@@ -65,7 +65,7 @@ typedef unsigned long reg_syntax_t;
         ^  is an anchor if it is at the beginning of a regular
            expression or after an open-group or an alternation operator;
         $  is an anchor if it is at the end of a regular expression, or
-           before a close-group or an alternation operator.  
+           before a close-group or an alternation operator.
 
    This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
    POSIX draft 11.2 says that * etc. in leading positions is undefined.
@@ -76,7 +76,7 @@ typedef unsigned long reg_syntax_t;
 /* If this bit is set, then special characters are always special
      regardless of where they are in the pattern.
    If this bit is not set, then special characters are special only in
-     some contexts; otherwise they are ordinary.  Specifically, 
+     some contexts; otherwise they are ordinary.  Specifically,
      * + ? and intervals are only special when not after the beginning,
      open-group, or alternation operator.  */
 #define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)
@@ -98,7 +98,7 @@ typedef unsigned long reg_syntax_t;
 #define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)
 
 /* If this bit is set, either \{...\} or {...} defines an
-     interval, depending on RE_NO_BK_BRACES. 
+     interval, depending on RE_NO_BK_BRACES.
    If not set, \{, \}, {, and } are literals.  */
 #define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)
 
@@ -123,7 +123,7 @@ typedef unsigned long reg_syntax_t;
    If not set, then \<digit> is a back-reference.  */
 #define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)
 
-/* If this bit is set, then | is an alternation operator, and \| is literal. 
+/* If this bit is set, then | is an alternation operator, and \| is literal.
    If not set, then \| is an alternation operator, and | is literal.  */
 #define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)
 
@@ -149,7 +149,7 @@ extern reg_syntax_t re_syntax_options;
 
 /* Define combinations of the above bits for the standard possibilities.
    (The [[[ comments delimit what gets put into the Texinfo file, so
-   don't delete them!)  */ 
+   don't delete them!)  */
 /* [[[begin syntaxes]]] */
 #define RE_SYNTAX_EMACS 0
 
@@ -232,7 +232,7 @@ extern reg_syntax_t re_syntax_options;
 /* If this bit is set, then ignore case when matching.
    If not set, then case is significant.  */
 #define REG_ICASE (REG_EXTENDED << 1)
- 
+
 /* If this bit is set, then anchors do not match at newline
      characters in the string.
    If not set, then anchors do match at newlines.  */
@@ -271,7 +271,7 @@ typedef enum
   REG_EESCAPE,		/* Trailing backslash.  */
   REG_ESUBREG,		/* Invalid back reference.  */
   REG_EBRACK,		/* Unmatched left bracket.  */
-  REG_EPAREN,		/* Parenthesis imbalance.  */ 
+  REG_EPAREN,		/* Parenthesis imbalance.  */
   REG_EBRACE,		/* Unmatched \{.  */
   REG_BADBR,		/* Invalid contents of \{\}.  */
   REG_ERANGE,		/* Invalid range end.  */
@@ -302,7 +302,7 @@ struct re_pattern_buffer
   unsigned long allocated;
 
 	/* Number of bytes actually used in `buffer'.  */
-  unsigned long used;	
+  unsigned long used;
 
         /* Syntax setting with which the pattern was compiled.  */
   reg_syntax_t syntax;
@@ -346,7 +346,7 @@ struct re_pattern_buffer
   unsigned no_sub : 1;
 
         /* If set, a beginning-of-line anchor doesn't match at the
-           beginning of the string.  */ 
+           beginning of the string.  */
   unsigned not_bol : 1;
 
         /* Similarly for an end-of-line anchor.  */
@@ -458,7 +458,7 @@ extern int re_match
 
 
 /* Relates to `re_match' as `re_search_2' relates to `re_search'.  */
-extern int re_match_2 
+extern int re_match_2
   _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
              int length1, const char *string2, int length2,
              int start, struct re_registers *regs, int stop));
diff --git a/gnu/lib/libregex/test/Makefile b/gnu/lib/libregex/test/Makefile
index 5a8656a..84ebfcb 100644
--- a/gnu/lib/libregex/test/Makefile
+++ b/gnu/lib/libregex/test/Makefile
@@ -1,6 +1,6 @@
 # Generated automatically from Makefile.in by configure.
 # Makefile for regex testing.
-# 
+#
 # Copyright (C) 1992 Free Software Foundation, Inc.
 #
 # This program is free software; you can redistribute it and/or modify
@@ -46,7 +46,7 @@ test_o = test.o bsd-interf.o other.o tregress.o psx-basic.o psx-extend.o \
 common_o = printchar.o upcase.o xmalloc.o $(malloc)
 
 # We have a lot of mallocs we can try when we run afoul of strange bugs.
-malloc = 
+malloc =
 #malloc = # the libc malloc
 #malloc = g++malloc.o
 #malloc = debugmalloc.o
@@ -81,7 +81,7 @@ fileregex: $(fileregex_o)
 cppregex: regexcpp.o $(common_o) $(test_o) main.o
 	$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
 
-regexcpp.o: regexcpp.c 
+regexcpp.o: regexcpp.c
 
 regexcpp.c: regex.c regexcpp.sed
 	rm -f regexcpp.c
@@ -145,25 +145,25 @@ dist: Makefile TAGS
 	ln $(distfiles) $(distdir)
 
 # Automatically-generated dependencies below here.
-alloca.o : alloca.c 
-bsd-interf.o : bsd-interf.c 
-debugmalloc.o : debugmalloc.c 
-emacsmalloc.o : emacsmalloc.c getpagesize.h 
-fileregex.o : fileregex.c .././regex.h 
-g++malloc.o : g++malloc.c //usr/include/stdio.h getpagesize.h 
-iregex.o : iregex.c .././regex.h 
-main.o : main.c test.h .././regex.h 
-malloc-test.o : malloc-test.c 
-other.o : other.c test.h .././regex.h 
-printchar.o : printchar.c 
-psx-basic.o : psx-basic.c test.h .././regex.h 
-psx-extend.o : psx-extend.c test.h .././regex.h 
-psx-generic.o : psx-generic.c test.h .././regex.h 
-psx-group.o : psx-group.c test.h .././regex.h 
-psx-interf.o : psx-interf.c test.h .././regex.h 
-psx-interv.o : psx-interv.c test.h .././regex.h 
-syntax.o : syntax.c .././regex.h 
-test.o : test.c test.h .././regex.h 
-tregress.o : tregress.c test.h .././regex.h 
-upcase.o : upcase.c 
-xmalloc.o : xmalloc.c 
+alloca.o : alloca.c
+bsd-interf.o : bsd-interf.c
+debugmalloc.o : debugmalloc.c
+emacsmalloc.o : emacsmalloc.c getpagesize.h
+fileregex.o : fileregex.c .././regex.h
+g++malloc.o : g++malloc.c //usr/include/stdio.h getpagesize.h
+iregex.o : iregex.c .././regex.h
+main.o : main.c test.h .././regex.h
+malloc-test.o : malloc-test.c
+other.o : other.c test.h .././regex.h
+printchar.o : printchar.c
+psx-basic.o : psx-basic.c test.h .././regex.h
+psx-extend.o : psx-extend.c test.h .././regex.h
+psx-generic.o : psx-generic.c test.h .././regex.h
+psx-group.o : psx-group.c test.h .././regex.h
+psx-interf.o : psx-interf.c test.h .././regex.h
+psx-interv.o : psx-interv.c test.h .././regex.h
+syntax.o : syntax.c .././regex.h
+test.o : test.c test.h .././regex.h
+tregress.o : tregress.c test.h .././regex.h
+upcase.o : upcase.c
+xmalloc.o : xmalloc.c
diff --git a/gnu/lib/libregex/test/Makefile.in b/gnu/lib/libregex/test/Makefile.in
index b6a4133..fea1f10 100644
--- a/gnu/lib/libregex/test/Makefile.in
+++ b/gnu/lib/libregex/test/Makefile.in
@@ -1,5 +1,5 @@
 # Makefile for regex testing.
-# 
+#
 # Copyright (C) 1992 Free Software Foundation, Inc.
 #
 # This program is free software; you can redistribute it and/or modify
@@ -80,7 +80,7 @@ fileregex: $(fileregex_o)
 cppregex: regexcpp.o $(common_o) $(test_o) main.o
 	$(CC) -o $@ $(LDFLAGS) $^ $(LIBS)
 
-regexcpp.o: regexcpp.c 
+regexcpp.o: regexcpp.c
 
 regexcpp.c: regex.c regexcpp.sed
 	rm -f regexcpp.c
@@ -144,25 +144,25 @@ dist: Makefile TAGS
 	ln $(distfiles) $(distdir)
 
 # Automatically-generated dependencies below here.
-alloca.o : alloca.c 
-bsd-interf.o : bsd-interf.c 
-debugmalloc.o : debugmalloc.c 
-emacsmalloc.o : emacsmalloc.c getpagesize.h 
-fileregex.o : fileregex.c .././regex.h 
-g++malloc.o : g++malloc.c //usr/include/stdio.h getpagesize.h 
-iregex.o : iregex.c .././regex.h 
-main.o : main.c test.h .././regex.h 
-malloc-test.o : malloc-test.c 
-other.o : other.c test.h .././regex.h 
-printchar.o : printchar.c 
-psx-basic.o : psx-basic.c test.h .././regex.h 
-psx-extend.o : psx-extend.c test.h .././regex.h 
-psx-generic.o : psx-generic.c test.h .././regex.h 
-psx-group.o : psx-group.c test.h .././regex.h 
-psx-interf.o : psx-interf.c test.h .././regex.h 
-psx-interv.o : psx-interv.c test.h .././regex.h 
-syntax.o : syntax.c .././regex.h 
-test.o : test.c test.h .././regex.h 
-tregress.o : tregress.c test.h .././regex.h 
-upcase.o : upcase.c 
-xmalloc.o : xmalloc.c 
+alloca.o : alloca.c
+bsd-interf.o : bsd-interf.c
+debugmalloc.o : debugmalloc.c
+emacsmalloc.o : emacsmalloc.c getpagesize.h
+fileregex.o : fileregex.c .././regex.h
+g++malloc.o : g++malloc.c //usr/include/stdio.h getpagesize.h
+iregex.o : iregex.c .././regex.h
+main.o : main.c test.h .././regex.h
+malloc-test.o : malloc-test.c
+other.o : other.c test.h .././regex.h
+printchar.o : printchar.c
+psx-basic.o : psx-basic.c test.h .././regex.h
+psx-extend.o : psx-extend.c test.h .././regex.h
+psx-generic.o : psx-generic.c test.h .././regex.h
+psx-group.o : psx-group.c test.h .././regex.h
+psx-interf.o : psx-interf.c test.h .././regex.h
+psx-interv.o : psx-interv.c test.h .././regex.h
+syntax.o : syntax.c .././regex.h
+test.o : test.c test.h .././regex.h
+tregress.o : tregress.c test.h .././regex.h
+upcase.o : upcase.c
+xmalloc.o : xmalloc.c
diff --git a/gnu/lib/libregex/test/alloca.c b/gnu/lib/libregex/test/alloca.c
index c1ff222..d8b6748 100644
--- a/gnu/lib/libregex/test/alloca.c
+++ b/gnu/lib/libregex/test/alloca.c
@@ -7,7 +7,7 @@
 
 	This implementation of the PWB library alloca() function,
 	which is used to allocate space off the run-time stack so
-	that it is automatically reclaimed upon procedure exit, 
+	that it is automatically reclaimed upon procedure exit,
 	was inspired by discussions with J. Q. Johnson of Cornell.
 
 	It should work under any C implementation that uses an
diff --git a/gnu/lib/libregex/test/bsd-interf.c b/gnu/lib/libregex/test/bsd-interf.c
index 56f9e2a..226a513 100644
--- a/gnu/lib/libregex/test/bsd-interf.c
+++ b/gnu/lib/libregex/test/bsd-interf.c
@@ -10,7 +10,7 @@ test_berk_search (pattern, string)
     char *string;
 {
   const char *return_value = re_comp (pattern);
-  
+
   if (return_value != 0)
     {
       printf ("This didn't compile: `%s'.\n", pattern);
diff --git a/gnu/lib/libregex/test/debugmalloc.c b/gnu/lib/libregex/test/debugmalloc.c
index 5c468e2..6caeb65 100644
--- a/gnu/lib/libregex/test/debugmalloc.c
+++ b/gnu/lib/libregex/test/debugmalloc.c
@@ -11,7 +11,7 @@ static unsigned trace = 0;
 #define TRACE3(s, e1, e2, e3) if (trace) fprintf (stderr, s, e1, e2, e3)
 #define TRACE4(s, e1, e2, e3, e4) \
   if (trace) fprintf (stderr, s, e1, e2, e3, e4)
-  
+
 typedef char *address;
 
 
@@ -23,13 +23,13 @@ xsbrk (incr)
 {
   extern char *sbrk ();
   address ret = sbrk (incr);
-  
+
   if (ret == (address) -1)
     {
       perror ("sbrk"); /* Actually, we should return NULL, not quit.  */
       abort ();
     }
-  
+
   return ret;
 }
 
@@ -40,16 +40,16 @@ typedef struct chunk_struct
   /* This is the size (in bytes) that has actually been actually
      allocated, not the size that the user requested.  */
   unsigned alloc_size;
-  
+
   /* This is the size the user requested.  */
   unsigned user_size;
-  
+
   /* Points to the next block in one of the lists.  */
   struct chunk_struct *next;
-  
+
   /* Now comes the user's memory.  */
   address user_mem;
-  
+
   /* After the user's memory is a constant.  */
 } *chunk;
 
@@ -98,10 +98,10 @@ chunk_insert (chunk_list, new_c)
   chunk new_c;
 {
   chunk c = *chunk_list; /* old beginning of list */
-  
+
   TRACE3 ("  Inserting 0x%x at the beginning of 0x%x, before 0x%x.\n",
           new_c, chunk_list, c);
- 
+
   *chunk_list = new_c;
   new_c->next = c;
 }
@@ -120,7 +120,7 @@ chunk_delete (chunk_list, dead_c)
   chunk prev_c = NULL;
 
   TRACE2 ("  Deleting 0x%x from 0x%x:", dead_c, chunk_list);
-  
+
   while (c != dead_c && c != NULL)
     {
       TRACE1 (" 0x%x", c);
@@ -133,7 +133,7 @@ chunk_delete (chunk_list, dead_c)
       fprintf (stderr, "Chunk at 0x%x not found on list.\n", dead_c);
       abort ();
     }
-  
+
   if (prev_c == NULL)
     {
       TRACE1 (".\n  Setting head to 0x%x.\n", c->next);
@@ -154,16 +154,16 @@ validate_list (chunk_list)
   chunk *chunk_list;
 {
   chunk c;
-  
+
   TRACE1 ("  Validating list at 0x%x:", chunk_list);
-  
+
   for (c = *chunk_list; c != NULL; c = c->next)
     {
       assert (c->user_size < c->alloc_size);
       assert (memcmp (chunk_to_mem (c) + c->user_size, "Karl", 4));
       TRACE2 (" 0x%x/%d", c, c->user_size);
     }
-  
+
   TRACE (".\n");
 }
 
@@ -176,22 +176,22 @@ free_list_available (needed)
   unsigned needed;
 {
   chunk c;
-  
+
   TRACE1 ("  Checking free list for %d bytes:", needed);
-  
+
   if (free_list == NULL)
     {
       return NULL;
     }
-  
+
   c = free_list;
-  
+
   while (c != NULL && USER_ALLOC (c) < needed)
     {
       TRACE2 (" 0x%x/%d", c, USER_ALLOC (c));
       c = c->next;
     }
-  
+
   TRACE1 ("\n  Returning 0x%x.\n", c);
   return c;
 }
@@ -205,14 +205,14 @@ malloc (n)
 {
   address new_mem;
   chunk c;
-  
+
   TRACE1 ("Mallocing %d bytes.\n", n);
 
   validate_list (&free_list);
   validate_list (&alloc_list);
 
-  c = free_list_available (n); 
-  
+  c = free_list_available (n);
+
   if (c == NULL)
     { /* Nothing suitable on free list.  Allocate a new chunk.  */
       TRACE ("  not on free list.\n");
@@ -232,7 +232,7 @@ malloc (n)
   new_mem = chunk_to_mem (c);
   memcpy (new_mem + n, "Karl", 4);
   chunk_insert (&alloc_list, c);
-  
+
   TRACE2 ("Malloc returning 0x%x (chunk 0x%x).\n", new_mem, c);
   return new_mem;
 }
@@ -246,13 +246,13 @@ realloc (mem, n)
   void free ();
   chunk c = mem_to_chunk (mem);
   address new_mem;
-  
+
   TRACE3 ("Reallocing %d bytes at 0x%x (chunk 0x%x).\n", n, mem, c);
 
   new_mem = malloc (n);
   memcpy (new_mem, mem, c->user_size);
   free (mem);
-  
+
   return new_mem;
 }
 
@@ -262,12 +262,12 @@ free (mem)
   address mem;
 {
   chunk c = mem_to_chunk (mem);
-  
+
   TRACE2 ("Freeing memory at 0x%x (chunk at 0x%x).\n", mem, c);
 
   validate_list (&free_list);
   validate_list (&alloc_list);
-  
+
   chunk_delete (&alloc_list, c);
   chunk_insert (&free_list, c);
 }
diff --git a/gnu/lib/libregex/test/emacsmalloc.c b/gnu/lib/libregex/test/emacsmalloc.c
index 6eee1fa..ad7c4da 100644
--- a/gnu/lib/libregex/test/emacsmalloc.c
+++ b/gnu/lib/libregex/test/emacsmalloc.c
@@ -27,9 +27,9 @@ what you give them.   Help stamp out software-hoarding!  */
  *
  *	Nov 1983, Mike@BRL, Added support for 4.1C/4.2 BSD.
  *
- * This is a very fast storage allocator.  It allocates blocks of a small 
+ * This is a very fast storage allocator.  It allocates blocks of a small
  * number of different sizes, and keeps free lists of each size.  Blocks
- * that don't exactly fit are passed up to the next larger size.  In this 
+ * that don't exactly fit are passed up to the next larger size.  In this
  * implementation, the available sizes are (2^n)-4 (or -16) bytes long.
  * This is designed for use in a program that uses vast quantities of
  * memory, but bombs when it runs out.  To make it a little better, it
@@ -297,21 +297,21 @@ morecore (nu)			/* ask system for more memory */
   if (warnfunction)
     switch (warnlevel)
       {
-      case 0: 
+      case 0:
 	if (siz > (lim_data / 4) * 3)
 	  {
 	    warnlevel++;
 	    (*warnfunction) ("Warning: past 75% of memory limit");
 	  }
 	break;
-      case 1: 
+      case 1:
 	if (siz > (lim_data / 20) * 17)
 	  {
 	    warnlevel++;
 	    (*warnfunction) ("Warning: past 85% of memory limit");
 	  }
 	break;
-      case 2: 
+      case 2:
 	if (siz > (lim_data / 20) * 19)
 	  {
 	    warnlevel++;
@@ -691,31 +691,31 @@ malloc_mem_used ()
   int size_used;
 
   size_used = 0;
-  
+
   for (i = 0; i < 30; i++)
     {
       int allocation_size = 1 << (i + 3);
       struct mhead *p;
-      
+
       size_used += nmalloc[i] * allocation_size;
     }
 
   return size_used;
 }
 
-int 
+int
 malloc_mem_free ()
 {
   int i;
   int size_unused;
 
   size_unused = 0;
-  
+
   for (i = 0; i < 30; i++)
     {
       int allocation_size = 1 << (i + 3);
       struct mhead *p;
-      
+
       for (p = nextf[i]; p ; p = CHAIN (p))
 	size_unused += allocation_size;
     }
@@ -736,7 +736,7 @@ malloc_mem_free ()
 get_lim_data ()
 {
   extern long ulimit ();
-    
+
 #ifdef ULIMIT_BREAK_VALUE
   lim_data = ULIMIT_BREAK_VALUE;
 #else
diff --git a/gnu/lib/libregex/test/fileregex.c b/gnu/lib/libregex/test/fileregex.c
index 2c27a0f..ba81062 100644
--- a/gnu/lib/libregex/test/fileregex.c
+++ b/gnu/lib/libregex/test/fileregex.c
@@ -21,7 +21,7 @@ main (argc, argv)
   const char *compile_ret;
   unsigned lineno = 1;
   unsigned nfound = 0;
-  
+
   /* Actually, it might be useful to allow the data file to be standard
      input, and to specify the pattern on the command line.  */
   if (argc != 2)
@@ -29,7 +29,7 @@ main (argc, argv)
       fprintf (stderr, "Usage: %s <filename>.\n", argv[0]);
       exit (1);
     }
- 
+
   filename = argv[1];
   f = fopen (filename, "r");
   if (f == NULL)
@@ -41,7 +41,7 @@ main (argc, argv)
 
   printf ("Pattern = ", pat);
   gets (pat);
-  
+
   if (feof (stdin))
     {
       putchar ('\n');
@@ -61,13 +61,13 @@ main (argc, argv)
       struct re_registers regs;
       int search_ret
         = re_search_2 (&buf, NULL, 0, line, len, 0, len, &regs, len);
-      
+
       if (search_ret == -2)
         {
           fprintf (stderr, "%s:%d: re_search failed.\n", filename, lineno);
           exit (1);
         }
-      
+
       nfound += search_ret != -1;
       lineno++;
     }
diff --git a/gnu/lib/libregex/test/g++malloc.c b/gnu/lib/libregex/test/g++malloc.c
index d55ce45..88c181c5 100644
--- a/gnu/lib/libregex/test/g++malloc.c
+++ b/gnu/lib/libregex/test/g++malloc.c
@@ -1,6 +1,6 @@
-#define inline 
+#define inline
 
-/* 
+/*
 Copyright (C) 1989 Free Software Foundation
     written by Doug Lea (dl@oswego.edu)
 
@@ -19,7 +19,7 @@ GNU CC General Public License.   A copy of this license is
 supposed to have been given to you along with GNU CC so you
 can know your rights and responsibilities.  It should be in a
 file named COPYING.  Among other things, the copyright notice
-and this notice must be preserved on all copies.  
+and this notice must be preserved on all copies.
 */
 
 
@@ -92,7 +92,7 @@ and this notice must be preserved on all copies.
            avoid wasted iterations due to (1).
 */
 
-/* 
+/*
   A version of malloc/free/realloc tuned for C++ applications.
 
   Here's what you probably want to know first:
@@ -101,11 +101,11 @@ and this notice must be preserved on all copies.
   and usually substantially less memory-wasteful than BSD/GNUemacs malloc.
 
   Generally, it is slower (by perhaps 20%) than bsd-style malloc
-  only when bsd malloc would waste a great deal of space in 
+  only when bsd malloc would waste a great deal of space in
   fragmented blocks, which this malloc recovers; or when, by
   chance or design, nearly all requests are near the bsd malloc
   power-of-2 allocation bin boundaries, and as many chunks are
-  used as are allocated. 
+  used as are allocated.
 
   It uses more space than bsd malloc only when, again by chance
   or design, only bsdmalloc bin-sized requests are malloced, or when
@@ -117,8 +117,8 @@ and this notice must be preserved on all copies.
   deal with bsdmalloc's characteristics. But even here, the
   performance differences are slight.
 
- 
-  This malloc, like any other, is a compromised design. 
+
+  This malloc, like any other, is a compromised design.
 
 
   Chunks of memory are maintained using a `boundary tag' method as
@@ -135,7 +135,7 @@ and this notice must be preserved on all copies.
   Available chunks are kept in doubly linked lists. The lists are
   maintained in an array of bins using a power-of-two method, except
   that instead of 32 bins (one for each 1 << i), there are 128: each
-  power of two is split in quarters. The use of very fine bin sizes 
+  power of two is split in quarters. The use of very fine bin sizes
   closely approximates the use of one bin per actually used size,
   without necessitating the overhead of locating such bins. It is
   especially desirable in common C++ applications where large numbers
@@ -169,8 +169,8 @@ and this notice must be preserved on all copies.
   on fronts of lists. All remaindered or consolidated chunks are
   placed on the rear. Correspondingly, searching within a bin
   starts at the front, but finding victims is from the back. All
-  of this approximates  the  effect of having 2 kinds of lists per 
-  bin: returned chunks vs unallocated chunks, but without the overhead 
+  of this approximates  the  effect of having 2 kinds of lists per
+  bin: returned chunks vs unallocated chunks, but without the overhead
   of maintaining 2 lists.)
 
   Deallocation (free) consists only of placing the chunk on
@@ -203,14 +203,14 @@ and this notice must be preserved on all copies.
   The checks are fast enough to be made non-optional.
 
   The overwriting of parts of freed memory with the freelist pointers
-  can also be very effective (albeit in an annoying way) in helping 
+  can also be very effective (albeit in an annoying way) in helping
   users track down dangling pointers.
 
   User overwriting of freed space will often result in crashes
   within malloc or free.
-  
+
   These routines are also tuned to C++ in that free(0) is a noop and
-  a failed malloc automatically calls (*new_handler)(). 
+  a failed malloc automatically calls (*new_handler)().
 
   malloc(0) returns a pointer to something of the minimum allocatable size.
 
@@ -276,7 +276,7 @@ extern void abort();
 
 /* A good multiple to call sbrk with */
 
-#define SBRK_UNIT 4096 
+#define SBRK_UNIT 4096
 
 
 
@@ -334,13 +334,13 @@ typedef struct malloc_bin* mbinptr;
 
 static inline unsigned int request2size(unsigned int request)
 {
-  return  (request == 0) ?  MINSIZE : 
-    ((request + MALLOC_MIN_OVERHEAD + MALLOC_ALIGN_MASK) 
+  return  (request == 0) ?  MINSIZE :
+    ((request + MALLOC_MIN_OVERHEAD + MALLOC_ALIGN_MASK)
       & ~(MALLOC_ALIGN_MASK));
 }
 
 
-static inline int aligned_OK(void* m)  
+static inline int aligned_OK(void* m)
 {
   return ((unsigned int)(m) & (MALLOC_ALIGN_MASK)) == 0;
 }
@@ -355,9 +355,9 @@ static inline int aligned_OK(void* m)
 
 #define MAXBIN 120   /* 1 more than needed for 32 bit addresses */
 
-#define FIRSTBIN (&(av[0])) 
+#define FIRSTBIN (&(av[0]))
 
-static struct malloc_bin  av[MAXBIN] = 
+static struct malloc_bin  av[MAXBIN] =
 {
   { { 0, &(av[0].hd),  &(av[0].hd) }, 0 },
   { { 0, &(av[1].hd),  &(av[1].hd) }, 0 },
@@ -545,7 +545,7 @@ static void do_free_stats(const mchunkptr p)
 {
   ++n_frees;
   freed_mem += (p->size & ~(INUSE));
-}        
+}
 
 #endif
 
@@ -557,7 +557,7 @@ static void do_free_stats(const mchunkptr p)
 static unsigned int gcd(unsigned int a, unsigned int b)
 {
   unsigned int tmp;
-  
+
   if (b > a)
   {
     tmp = a; a = b; b = tmp;
@@ -591,7 +591,7 @@ static inline unsigned int lcm(unsigned int x, unsigned int y)
 #define set_inuse(p)   ((p)->size |= INUSE)
 #define clear_inuse(b) ((p)->size &= ~INUSE)
 
-  
+
 /* operations on  malloc_chunk addresses */
 
 
@@ -616,18 +616,18 @@ static inline void set_size(mchunkptr p, unsigned int sz)
 
 /* conversion from malloc headers to user pointers, and back */
 
-static inline void* chunk2mem(mchunkptr p) 
-{ 
+static inline void* chunk2mem(mchunkptr p)
+{
   void *mem;
   set_inuse(p);
-mem =  (void*)((char*)(p) + SIZE_SZ); 
+mem =  (void*)((char*)(p) + SIZE_SZ);
   return mem;
 }
 
 /* xxxx my own */
-mchunkptr sanity_check(void* mem) 
-{ 
-  mchunkptr p = (mchunkptr)((char*)(mem) - SIZE_SZ); 
+mchunkptr sanity_check(void* mem)
+{
+  mchunkptr p = (mchunkptr)((char*)(mem) - SIZE_SZ);
 
   /* a quick sanity check */
   unsigned int sz = p->size & ~(INUSE);
@@ -640,9 +640,9 @@ mchunkptr sanity_check(void* mem)
 
 
 
-static inline mchunkptr mem2chunk(void* mem) 
-{ 
-  mchunkptr p = (mchunkptr)((char*)(mem) - SIZE_SZ); 
+static inline mchunkptr mem2chunk(void* mem)
+{
+  mchunkptr p = (mchunkptr)((char*)(mem) - SIZE_SZ);
 
   /* a quick sanity check */
   unsigned int sz = p->size & ~(INUSE);
@@ -691,15 +691,15 @@ static inline void split(mchunkptr p, unsigned int offset)
     mchunkptr h  = &(bn->hd);                       /* its head */
     mchunkptr b  = h->bk;                           /* old back element */
     mchunkptr t = (mchunkptr)((char*)(p) + offset); /* remaindered chunk */
-    
+
     /* set size */
     t->size = *((int*)((char*)(t) + room    - SIZE_SZ)) = room;
 
     /* link up */
     t->bk = b;  t->fd = h;  h->bk = b->fd = t;
-    
+
     /* adjust maxbin (h == b means was empty) */
-    if (h == b && bn > malloc_maxbin) malloc_maxbin = bn; 
+    if (h == b && bn > malloc_maxbin) malloc_maxbin = bn;
 
     /* adjust size of chunk to be returned */
     p->size = *((int*)((char*)(p) + offset  - SIZE_SZ)) = offset;
@@ -721,7 +721,7 @@ static inline void consollink(mchunkptr p)
 
   p->bk = b;  p->fd = h;  h->bk = b->fd = p;
 
-  if (h == b && bn > malloc_maxbin) malloc_maxbin = bn; 
+  if (h == b && bn > malloc_maxbin) malloc_maxbin = bn;
 
   UPDATE_STATS(++n_avail);
 }
@@ -737,7 +737,7 @@ static inline void frontlink(mchunkptr p)
 
   p->bk = h;  p->fd = f;  f->bk = h->fd = p;
 
-  if (h == f && bn > malloc_maxbin) malloc_maxbin = bn;  
+  if (h == f && bn > malloc_maxbin) malloc_maxbin = bn;
 
   bn->dirty = 1;
 
@@ -770,11 +770,11 @@ static mchunkptr malloc_from_sys(unsigned nb)
   mchunkptr p;
   unsigned int sbrk_size;
   int* ip;
-  
+
   /* Minimally, we need to pad with enough space */
   /* to place dummy size/use fields to ends if needed */
 
-  sbrk_size = ((nb + SBRK_UNIT - 1 + SIZE_SZ + SIZE_SZ) 
+  sbrk_size = ((nb + SBRK_UNIT - 1 + SIZE_SZ + SIZE_SZ)
                / SBRK_UNIT) * SBRK_UNIT;
 
   ip = (int*)(sbrk(sbrk_size));
@@ -789,8 +789,8 @@ static mchunkptr malloc_from_sys(unsigned nb)
   UPDATE_STATS ((++n_sbrks, sbrked_mem += sbrk_size));
 
 
-  if (last_sbrk_end != &ip[-1]) 
-  {                             
+  if (last_sbrk_end != &ip[-1])
+  {
     /* It's either first time through or someone else called sbrk. */
     /* Arrange end-markers at front & back */
 
@@ -802,14 +802,14 @@ static mchunkptr malloc_from_sys(unsigned nb)
     /* Note we can get away with only 1 word, not MINSIZE overhead here */
 
     *ip++ = SIZE_SZ | INUSE;
-    
+
     p = (mchunkptr)ip;
-    set_size(p,sbrk_size - (SIZE_SZ + SIZE_SZ)); 
-    
+    set_size(p,sbrk_size - (SIZE_SZ + SIZE_SZ));
+
   }
-  else 
+  else
   {
-    mchunkptr l;  
+    mchunkptr l;
 
     /* We can safely make the header start at end of prev sbrked chunk. */
     /* We will still have space left at the end from a previous call */
@@ -822,7 +822,7 @@ static mchunkptr malloc_from_sys(unsigned nb)
     /* Even better, maybe we can merge with last fragment: */
 
     l = prev_chunk(p);
-    if (!inuse(l))  
+    if (!inuse(l))
     {
       unlink(l);
       set_size(l, p->size + l->size);
@@ -861,7 +861,7 @@ static mchunkptr malloc_find_space(unsigned int nb)
 
   /* first, re-adjust max used bin */
 
-  while (malloc_maxbin >= FIRSTBIN && 
+  while (malloc_maxbin >= FIRSTBIN &&
          malloc_maxbin->hd.bk == &(malloc_maxbin->hd))
   {
     malloc_maxbin->dirty = 0;
@@ -895,7 +895,7 @@ static mchunkptr malloc_find_space(unsigned int nb)
           p = t;
           UPDATE_STATS (++n_consol);
         }
-        
+
         while (!inuse(t = next_chunk(p))) /* consolidate forward */
         {
           if (!consolidated) { consolidated = 1; unlink(p); }
@@ -957,7 +957,7 @@ void* malloc(unsigned int bytes)
     {
       mchunkptr nextp = p->fd;       /* save, in case of relinks */
       int consolidated = 0;          /* only unlink/relink if consolidated */
-      
+
       mchunkptr t;
 
       while (!inuse(t = prev_chunk(p))) /* consolidate backward */
@@ -969,7 +969,7 @@ void* malloc(unsigned int bytes)
         p = t;
         UPDATE_STATS (++n_consol);
       }
-      
+
       while (!inuse(t = next_chunk(p))) /* consolidate forward */
       {
         if (!consolidated) { consolidated = 1; unlink(p); }
@@ -978,7 +978,7 @@ void* malloc(unsigned int bytes)
         set_size(p, p->size + t->size);
         UPDATE_STATS (++n_consol);
       }
-      
+
       if (consolidated)
       {
         if (p->size >= nb)
@@ -1017,7 +1017,7 @@ void* malloc(unsigned int bytes)
  found:   /* Use what we found */
 
   unlink(p);
-  split(p, nb); 
+  split(p, nb);
   UPDATE_STATS(do_malloc_stats(p));
   return chunk2mem(p);
 }
@@ -1049,7 +1049,7 @@ void cfree(void *mem)
 {
   free(mem);
 }
- 
+
 
 unsigned int malloc_usable_size(void* mem)
 {
@@ -1057,7 +1057,7 @@ unsigned int malloc_usable_size(void* mem)
     return 0;
   else
   {
-    mchunkptr p = (mchunkptr)((char*)(mem) - SIZE_SZ); 
+    mchunkptr p = (mchunkptr)((char*)(mem) - SIZE_SZ);
     unsigned int sz = p->size & ~(INUSE);
     if (p->size == sz || sz != *((int*)((char*)(p) + sz - SIZE_SZ)))
       return 0;
@@ -1070,7 +1070,7 @@ unsigned int malloc_usable_size(void* mem)
 
 void* realloc(void* mem, unsigned int bytes)
 {
-  if (mem == 0) 
+  if (mem == 0)
     return malloc(bytes);
   else
   {
@@ -1081,7 +1081,7 @@ void* realloc(void* mem, unsigned int bytes)
     mchunkptr    nxt;
 
     UPDATE_STATS((++n_reallocs, requested_mem += bytes-oldsize));
-    
+
     /* try to expand (even if already big enough), to clean up chunk */
 
     while (!inuse(nxt = next_chunk(p)))
@@ -1160,7 +1160,7 @@ void* memalign(unsigned int alignment, unsigned int bytes)
       /* and we've malloc'd enough total room */
 
       ap = (mchunkptr)( (int)(ap) + align );
-      gap += align;    
+      gap += align;
     }
 
     if (gap + nb > p->size) /* can't happen unless chunk sizes corrupted */
@@ -1179,7 +1179,7 @@ void* memalign(unsigned int alignment, unsigned int bytes)
 
   /* also give back spare room at the end */
 
-  split(p, nb); 
+  split(p, nb);
   UPDATE_STATS(do_malloc_stats(p));
   return chunk2mem(p);
 
@@ -1196,7 +1196,7 @@ void* valloc(unsigned int bytes)
   if (malloc_pagesize == 0) malloc_pagesize = getpagesize();
   return memalign (malloc_pagesize, bytes);
 }
-    
+
 
 void malloc_stats()
 {
@@ -1216,23 +1216,23 @@ void malloc_stats()
   if (n_mallocs != 0)
   fprintf(stderr, "mallocs   = %10u total size = %10u\tave = %10u\n",
           n_mallocs, malloced_mem, malloced_mem/n_mallocs);
-  
+
   if (n_frees != 0)
   fprintf(stderr, "frees     = %10u total size = %10u\tave = %10u\n",
           n_frees, freed_mem, freed_mem/n_frees);
-  
+
   if (n_mallocs-n_frees != 0)
   fprintf(stderr, "in use    = %10u total size = %10u\tave = %10u\n",
-          n_mallocs-n_frees, malloced_mem-freed_mem, 
+          n_mallocs-n_frees, malloced_mem-freed_mem,
           (malloced_mem-freed_mem) / (n_mallocs-n_frees));
 
   if (max_inuse != 0)
   fprintf(stderr, "max in use= %10u total size = %10u\tave = %10u\n",
           max_inuse, max_used_mem, max_used_mem / max_inuse);
-  
+
   if (n_avail != 0)
   fprintf(stderr, "available = %10u total size = %10u\tave = %10u\n",
-          n_avail, sbrked_mem - (malloced_mem-freed_mem), 
+          n_avail, sbrked_mem - (malloced_mem-freed_mem),
           (sbrked_mem - (malloced_mem-freed_mem)) / n_avail);
 
   if (n_sbrks != 0)
@@ -1246,13 +1246,13 @@ void malloc_stats()
 
   if (nm != 0)
   {
-    fprintf(stderr, "chunks scanned per malloc = %6.3f\n", 
+    fprintf(stderr, "chunks scanned per malloc = %6.3f\n",
             n_malloc_chunks / nm);
-    fprintf(stderr, "bins scanned per malloc   = %6.3f\n", 
+    fprintf(stderr, "bins scanned per malloc   = %6.3f\n",
             n_malloc_bins / nm);
-    fprintf(stderr, "splits per malloc         = %6.3f\n", 
+    fprintf(stderr, "splits per malloc         = %6.3f\n",
             n_split / nm);
-    fprintf(stderr, "consolidations per malloc = %6.3f\n", 
+    fprintf(stderr, "consolidations per malloc = %6.3f\n",
             n_consol / nm);
   }
 
@@ -1282,7 +1282,7 @@ void malloc_stats()
   }
 }
 #endif /* MALLOC_STATS */
- 
+
 #endif /* NO_LIBGXX_MALLOC */
 
 
diff --git a/gnu/lib/libregex/test/iregex.c b/gnu/lib/libregex/test/iregex.c
index 2346d44..1ff12b6 100644
--- a/gnu/lib/libregex/test/iregex.c
+++ b/gnu/lib/libregex/test/iregex.c
@@ -42,7 +42,7 @@ main (argc, argv)
 
       /* Some C compilers don't like `char pat[500] = ""'.  */
       pat[0] = 0;
-      
+
       printf ("Pattern (%s) = ", pat);
       gets (pat);
       scanstring (pat);
@@ -71,7 +71,7 @@ main (argc, argv)
       if (i >= 0)
         print_regs (regs);
       putchar ('\n');
-      
+
       i = re_search (&buf, str, strlen (str), 0, strlen (str), &regs);
       printf ("Search value %d.\t", i);
       if (i >= 0)
@@ -144,7 +144,7 @@ print_regs (regs)
   int i, end;
 
   printf ("Registers: ");
-  
+
   if (regs.num_regs == 0 || regs.start[0] == -1)
     {
       printf ("(none)");
diff --git a/gnu/lib/libregex/test/main.c b/gnu/lib/libregex/test/main.c
index 28ae315..da4536d 100644
--- a/gnu/lib/libregex/test/main.c
+++ b/gnu/lib/libregex/test/main.c
@@ -20,27 +20,27 @@ main ()
     test_posix_extended ();
     test_posix_interface ();
     break;
-    
+
   case other_test:
     test_others ();
     break;
-  
+
   case posix_basic_test:
     test_posix_basic ();
     break;
-  
+
   case posix_extended_test:
     test_posix_extended ();
     break;
-  
+
   case posix_interface_test:
     test_posix_interface ();
     break;
-  
+
   case regress_test:
     test_regress ();
     break;
-    
+
   default:
     fprintf (stderr, "Unknown test %d.\n", t);
   }
diff --git a/gnu/lib/libregex/test/other.c b/gnu/lib/libregex/test/other.c
index d2ceb38..1023fc6 100644
--- a/gnu/lib/libregex/test/other.c
+++ b/gnu/lib/libregex/test/other.c
@@ -6,7 +6,7 @@ void
 test_others ()
 {
   struct re_registers regs;
-  
+
   printf ("\nStarting non-POSIX tests.\n");
   t = other_test;
 
@@ -19,17 +19,17 @@ test_others ()
   TEST_REGISTERS ("(a*)*ab", "ab", 0, 2, 0, 0, -1, -1);
   test_match ("(a*)*", "");
   TEST_REGISTERS ("(a*)*ab", "ab", 0, 0, 0, 0, -1, -1);
-  
+
   /* This tests finding the highest and lowest active registers.  */
   test_match ("(a(b)c(d(e)f)g)h(i(j)k(l(m)n)o)\\1\\2\\3\\4\\5\\6\\7\\8",
               "abcdefghijklmnoabcdefgbdefeijklmnojlmnm");
 
   /* Test that \< and \> match at the beginning and end of the string.  */
   test_match ("\\<abc\\>", "abc");
-  
+
   /* May as well test \` and \' while we're at it.  */
   test_match ("\\`abc\\'", "abc");
-  
+
 #if 0
   /* Test backreferencing and the fastmap -- which doesn't work.  */
   test_fastmap ("(a)*\\1", "a", 0, 0);
@@ -37,9 +37,9 @@ test_others ()
 
   /* But at least we shouldn't search improperly.  */
   test_search_return (-1, "(a)\\1", "");
-  
+
   re_set_syntax (RE_SYNTAX_EMACS);
-  
+
   MATCH_SELF("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
   MATCH_SELF ("a^");
   MATCH_SELF ("a^b");
@@ -70,7 +70,7 @@ test_others ()
   test_match ("a|{1}", "a");
   test_match ("a|{1}", "{1}");
   test_match ("({1})", "{1}");
-  
+
   test_match ("\\{", "{");
 
 
@@ -94,7 +94,7 @@ test_others ()
 
   /* Test grouping.  */
   re_set_syntax (RE_NO_BK_PARENS);
-  
+
   test_match ("()", "");
   test_fastmap ("()", "", 0, 0);
   TEST_REGISTERS ("()", "", 0, 0, 0, 0, -1, -1);
@@ -106,22 +106,22 @@ test_others ()
 
   test_match ("(((((((((())))))))))", "");
   test_fastmap ("(((((((((())))))))))", "", 0, 0);
-  
+
   test_match ("()*", "");
   TEST_REGISTERS ("()*", "", 0, 0, 0, 0, -1, -1);  /* empty string */
   test_match ("(())*", "");
 
   re_set_syntax (RE_CONTEXT_INDEP_OPS);
   test_match ("*", "");
-  
+
   re_set_syntax (RE_INTERVALS | RE_CONTEXT_INDEP_OPS | RE_NO_BK_BRACES);
   test_match ("{1}", "");		/* Should remain an interval.  */
   MATCH_SELF ("{1");			/* Not a valid interval.  */
-  
+
   re_set_syntax (RE_NEWLINE_ALT);
   test_match ("a\nb", "a");
   test_match ("a\nb", "b");
-  
+
   re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
   test_match ("^a", "a");
   test_match ("(^a)", "a");
@@ -129,11 +129,11 @@ test_others ()
   test_match ("a$", "a");
   test_match ("(a$)", "a");
   test_match ("a$|b", "a");
-  
+
   /* You should be able to have empty alternatives if RE_NO_EMPTY_ALTS
      isn't set.  */
   re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
-  
+
   test_match ("|", "");
   test_match ("^|a", "");
   test_match ("^|a", "a");
@@ -293,8 +293,8 @@ test_others ()
 
   test_case_fold ("[!-`]", "A");
   test_case_fold ("[!-`]", "a");
-  
-  re_set_syntax (RE_CONTEXT_INDEP_OPS | RE_NO_BK_VBAR | RE_NO_BK_PARENS 
+
+  re_set_syntax (RE_CONTEXT_INDEP_OPS | RE_NO_BK_VBAR | RE_NO_BK_PARENS
                  | RE_NO_BK_BRACES | RE_INTERVALS);
   valid_nonposix_pattern ("()^a");
   valid_nonposix_pattern ("()\\1^a");
@@ -319,24 +319,24 @@ test_others ()
   TEST_SEARCH ("^(^a)", "ab", 0, 2);
   TEST_SEARCH ("(a$)$", "ba", 0, 2);
   test_match ("a|$b", "$b");
-  
+
   /* Mike's curiosity item.  */
   re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS);
   test_all_registers ("(foo|foobar)(foo|bar)*\\1(foo|bar)*",
   		      "foobarfoobar", "",
-    0, 12,  0, 3,  3, 6,  9, 12,  -1, -1,   -1, -1,   -1, -1,   -1, -1,  
+    0, 12,  0, 3,  3, 6,  9, 12,  -1, -1,   -1, -1,   -1, -1,   -1, -1,
     -1, -1,   -1, -1);
 
   /* Another one from Mike.  */
   test_match ("(foo|foobarfoo)(bar)*", "foobarfoo");
-  
+
   /* And another.  */
   test_match("(foo|foobar)(bar|barfoo)?\\1", "foobarfoobar");
-  
+
   re_set_syntax (RE_NO_BK_PARENS | RE_INTERVALS | RE_NO_BK_VBAR
                  | RE_NO_BK_BRACES);  /* xx get new ones from ext.*/
   test_match ("((a{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)*", "bb");
-  test_all_registers ("((a{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)*", "", "bb", 
+  test_all_registers ("((a{0,}{0,0}()\\3\\b\\B\\<\\>\\`\\')|b)*", "", "bb",
     0, 2, 1, 2, -1, -1,  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     -1, -1);
 
@@ -349,11 +349,11 @@ test_others ()
           /* See generic_test.c and extended_test.c for more search
              tests. xx Not sure all these tests are represented in the
              search tests.  */
-          
+
   re_set_syntax (RE_NO_BK_PARENS | RE_NO_BK_VBAR);
-  valid_nonposix_pattern 
+  valid_nonposix_pattern
     ("(((((((((((((((((((((((((((((((((^a)))))))))))))))))))))))))))))))))");
-  valid_nonposix_pattern 
+  valid_nonposix_pattern
     ("(((((((((((((((((((((((((((((((((a$)))))))))))))))))))))))))))))))))");
   valid_nonposix_pattern ("\\b\\B\\<\\>\\`\\'^a");
   valid_nonposix_pattern ("a$\\b\\B\\<\\>\\`\\'");
@@ -413,7 +413,7 @@ test_others ()
      RE_CONTEXT_INDEP_OPS.  */
 
   re_set_syntax (RE_CONTEXT_INDEP_OPS | RE_CONTEXT_INVALID_OPS
-                 | RE_NO_BK_VBAR | RE_NO_BK_PARENS 
+                 | RE_NO_BK_VBAR | RE_NO_BK_PARENS
                  | RE_NO_BK_BRACES | RE_INTERVALS);
   INVALID_PATTERN ("*");
   INVALID_PATTERN ("^*");
@@ -440,9 +440,9 @@ test_others ()
      are undefined as of draft 11.2.  */
 
   /* You can't have empty alternatives if RE_NO_EMPTY_ALTS is set.  */
-  
+
   re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS | RE_NO_EMPTY_ALTS);
-  
+
   INVALID_PATTERN ("|");
   INVALID_PATTERN ("^|a");
   INVALID_PATTERN ("a|");
@@ -463,7 +463,7 @@ test_others ()
 #endif
 
   /* Test grouping.  */
-  test_match ("()", "a");			
+  test_match ("()", "a");
 
   /* Test backslashed intervals that are CONTEXTly invalid if have
      nothing on which to operate.  */
@@ -476,13 +476,13 @@ test_others ()
 
   re_set_syntax (RE_BK_PLUS_QM);
   INVALID_PATTERN ("a*\\");
-  
+
   re_set_syntax (0);
   INVALID_PATTERN ("a*\\");
-  
+
   re_set_syntax (RE_BACKSLASH_ESCAPE_IN_LISTS);
   INVALID_PATTERN ("[\\");
-  
+
 #if 0
   /* Empty groups are always ok now.  (13 Sep 92)  */
   re_set_syntax (RE_NO_BK_VBAR | RE_NO_BK_PARENS | RE_NO_EMPTY_GROUPS);
diff --git a/gnu/lib/libregex/test/psx-basic.c b/gnu/lib/libregex/test/psx-basic.c
index 52535b6..487c604 100644
--- a/gnu/lib/libregex/test/psx-basic.c
+++ b/gnu/lib/libregex/test/psx-basic.c
@@ -9,18 +9,18 @@ test_posix_basic ()
   /* Intervals can only match up to RE_DUP_MAX occurences of anything.  */
   char dup_max_plus_one[6];
   sprintf (dup_max_plus_one, "%d", RE_DUP_MAX + 1);
-  
+
   printf ("\nStarting POSIX basic tests.\n");
   t = posix_basic_test;
 
-  re_set_syntax (RE_SYNTAX_POSIX_MINIMAL_BASIC);  
-  
+  re_set_syntax (RE_SYNTAX_POSIX_MINIMAL_BASIC);
+
   test_posix_generic ();
 
   printf ("\nContinuing POSIX basic tests.\n");
 
 /* Grouping tests that are not the same.  */
-  
+
   test_should_match = false;
   invalid_pattern (REG_EPAREN, PARENS_TO_OPS ("a)"));
 
@@ -31,7 +31,7 @@ test_posix_basic ()
   test_match ("\\(^*\\)", "*");
   test_match ("**", "***");
   test_match ("***", "****");
-  
+
   MATCH_SELF ("{");					/* of extended...  */
   MATCH_SELF ("()");					/* also non-Posix.  */
   MATCH_SELF ("a+");
@@ -82,67 +82,67 @@ test_posix_basic ()
   test_match ("\\(a\\)*\\1", "aa");
   TEST_REGISTERS ("\\(a\\)*\\1", "aa", 0, 2, 0, 1, -1, -1);
   TEST_REGISTERS ("\\(a\\)*\\1", "xaax", 0, 0, -1, -1, -1, -1);
-  
+
   test_match ("\\(\\(a\\)\\2b\\)*", "aab");
   TEST_REGISTERS ("\\(\\(a\\)\\2b\\)*", "aab", 0, 3, 0, 3, 0, 1);
   TEST_REGISTERS ("\\(\\(a\\)\\2b\\)*", "xaabx", 0, 0, -1, -1, -1, -1);
-  
+
   test_match ("\\(a*\\)*\\1", "");
   test_match ("\\(a*\\)*\\1", "aa");
   TEST_REGISTERS ("\\(a*\\)*\\1", "aa", 0, 2, 0, 1, -1, -1);
   TEST_REGISTERS ("\\(a*\\)*\\1", "xaax", 0, 0, 0, 0, -1, -1);
-  
-  test_match ("\\(a*\\)*\\1", ""); 
-  test_match ("\\(a*\\)*\\1", "aa"); 
-  test_match ("\\(\\(a*\\)*\\)*\\1", "aa"); 
+
+  test_match ("\\(a*\\)*\\1", "");
+  test_match ("\\(a*\\)*\\1", "aa");
+  test_match ("\\(\\(a*\\)*\\)*\\1", "aa");
   test_match ("\\(ab*\\)*\\1", "abab");
   TEST_REGISTERS ("\\(ab*\\)*\\1", "abab", 0, 4, 0, 2, -1, -1);
   TEST_REGISTERS ("\\(ab*\\)*\\1", "xababx", 0, 0, -1, -1, -1, -1);
 
-  test_match ("\\(a*\\)ab\\1", "aaba"); 
-  TEST_REGISTERS ("\\(a*\\)ab\\1", "aaba", 0, 4, 0, 1, -1, -1); 
-  TEST_REGISTERS ("\\(a*\\)ab\\1", "xaabax", 1, 5, 1, 2, -1, -1); 
+  test_match ("\\(a*\\)ab\\1", "aaba");
+  TEST_REGISTERS ("\\(a*\\)ab\\1", "aaba", 0, 4, 0, 1, -1, -1);
+  TEST_REGISTERS ("\\(a*\\)ab\\1", "xaabax", 1, 5, 1, 2, -1, -1);
 
-  test_match ("\\(a*\\)*ab\\1", "aaba"); 
-  TEST_REGISTERS ("\\(a*\\)*ab\\1", "aaba", 0, 4, 0, 1, -1, -1); 
-  TEST_REGISTERS ("\\(a*\\)*ab\\1", "xaabax", 1, 5, 1, 2, -1, -1); 
+  test_match ("\\(a*\\)*ab\\1", "aaba");
+  TEST_REGISTERS ("\\(a*\\)*ab\\1", "aaba", 0, 4, 0, 1, -1, -1);
+  TEST_REGISTERS ("\\(a*\\)*ab\\1", "xaabax", 1, 5, 1, 2, -1, -1);
 
-  test_match ("\\(\\(a*\\)b\\)*\\2", "abb"); 
+  test_match ("\\(\\(a*\\)b\\)*\\2", "abb");
   TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "abb", 0, 3, 2, 3, 2, 2);
-  TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "xabbx", 0, 0, -1, -1, -1, -1); 
+  TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "xabbx", 0, 0, -1, -1, -1, -1);
 
   /* Different from above.  */
-  test_match ("\\(\\(a*\\)b*\\)*\\2", "aa"); 
+  test_match ("\\(\\(a*\\)b*\\)*\\2", "aa");
   TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "aa", 0, 2, 0, 1, 0, 1);
-  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaax", 0, 0, 0, 0, 0, 0); 
+  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaax", 0, 0, 0, 0, 0, 0);
 
-  test_match ("\\(\\(a*\\)b*\\)*\\2", "aba"); 
+  test_match ("\\(\\(a*\\)b*\\)*\\2", "aba");
   TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "aba", 0, 3, 0, 2, 0, 1);
-  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xabax", 0, 0, 0, 0, 0, 0); 
+  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xabax", 0, 0, 0, 0, 0, 0);
 
   test_match ("\\(\\(a*\\)b\\)*\\2", "aababa");
-  TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "aababa", 0, 6, 3, 5, 3, 4); 
-  TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "xaababax", 0, 0, -1, -1, -1, -1); 
+  TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "aababa", 0, 6, 3, 5, 3, 4);
+  TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2", "xaababax", 0, 0, -1, -1, -1, -1);
 
-  test_match ("\\(\\(a*\\)b*\\)*\\2", "aabaa"); 
+  test_match ("\\(\\(a*\\)b*\\)*\\2", "aabaa");
   TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "aabaa", 0, 5, 0, 3, 0, 2);
-  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaabaax", 0, 0, 0, 0, 0, 0); 
+  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaabaax", 0, 0, 0, 0, 0, 0);
 
-  test_match ("\\(\\(a*\\)b*\\)*\\2", "aabbaa"); 
+  test_match ("\\(\\(a*\\)b*\\)*\\2", "aabbaa");
   TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "aabbaa", 0, 6, 0, 4, 0, 2);
-  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaabbaax", 0, 0, 0, 0, 0, 0); 
+  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaabbaax", 0, 0, 0, 0, 0, 0);
 
-  test_match ("\\(\\(a*\\)b*\\)*\\2", "abaabaa"); 
+  test_match ("\\(\\(a*\\)b*\\)*\\2", "abaabaa");
   TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "abaabaa", 0, 7, 2, 5, 2, 4);
-  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaababaax", 0, 0, 0, 0, 0, 0); 
+  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2", "xaababaax", 0, 0, 0, 0, 0, 0);
 
-  test_match ("\\(\\(a*\\)b*\\)*a\\2", "aabaaa"); 
+  test_match ("\\(\\(a*\\)b*\\)*a\\2", "aabaaa");
   TEST_REGISTERS ("\\(\\(a*\\)b*a\\)*\\2", "aabaaa", 0, 6, 0, 3, 0, 2);
-  TEST_REGISTERS ("\\(\\(a*\\)b*a\\)*\\2", "xaabaax", 0, 0, -1, -1, -1, -1); 
+  TEST_REGISTERS ("\\(\\(a*\\)b*a\\)*\\2", "xaabaax", 0, 0, -1, -1, -1, -1);
 
-  test_match ("\\(\\(a*\\)b*\\)*\\2a", "aabaaa"); 
+  test_match ("\\(\\(a*\\)b*\\)*\\2a", "aabaaa");
   TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2a", "aabaaa", 0, 6, 0, 3, 0, 2);
-  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2a", "xaabaaax", 1, 7, 1, 4, 1, 3); 
+  TEST_REGISTERS ("\\(\\(a*\\)b*\\)*\\2a", "xaabaaax", 1, 7, 1, 4, 1, 3);
 
   test_match ("\\(\\(a*\\)b\\)*\\2\\1", "abaabaaaab");
   TEST_REGISTERS ("\\(\\(a*\\)b\\)*\\2\\1", "abaabaaaab", 0, 10, 2, 5, 2, 4);
@@ -152,7 +152,7 @@ test_posix_basic ()
   test_match ("\\(a*b\\)\\1", "abab");
   test_match ("\\(a\\)\\1\\1", "aaa");
   test_match ("\\(a\\(c\\)d\\)\\1\\2", "acdacdc");
-  
+
   test_match ("\\(a\\)\\1*", "aaa");
   TEST_REGISTERS ("\\(a\\)\\1*", "aaa", 0, 3, 0, 1, -1, -1);
   TEST_REGISTERS ("\\(a\\)\\1*", "xaaax", 1, 4, 1, 2, -1, -1);
@@ -186,15 +186,15 @@ test_posix_basic ()
 
 
   /* Per POSIX D11.1, p. 125, leftmost longest match.  */
-  
+
   test_match (PARENS_TO_OPS ("(ac*)c*d[ac]*\\1"), "acdacaaa");
-  TEST_REGISTERS (PARENS_TO_OPS ("(ac*)c*d[ac]*\\1"), "acdacaaa", 	
+  TEST_REGISTERS (PARENS_TO_OPS ("(ac*)c*d[ac]*\\1"), "acdacaaa",
     0, 8, 0, 1, -1, -1);
 
   /* Anchors become ordinary, sometimes.  */
   MATCH_SELF ("a^");
-  MATCH_SELF ("$a");		
-  MATCH_SELF ("$^");		
+  MATCH_SELF ("$a");
+  MATCH_SELF ("$^");
   test_fastmap ("$a^", "$", 0, 0);
   test_match ("$^*", "$^^");
   test_match ("\\($^\\)", "$^");
diff --git a/gnu/lib/libregex/test/psx-extend.c b/gnu/lib/libregex/test/psx-extend.c
index 6f02d67..14b8a5e 100644
--- a/gnu/lib/libregex/test/psx-extend.c
+++ b/gnu/lib/libregex/test/psx-extend.c
@@ -13,15 +13,15 @@ test_posix_extended ()
 
   printf ("\nStarting POSIX extended tests.\n");
   t = posix_extended_test;
-  
-  re_set_syntax (RE_SYNTAX_POSIX_MINIMAL_EXTENDED);  
+
+  re_set_syntax (RE_SYNTAX_POSIX_MINIMAL_EXTENDED);
 
   test_posix_generic ();
 
   printf ("\nContinuing POSIX extended tests.\n");
 
   /* Grouping tests that differ from basic's.  */
-  
+
   test_should_match = true;
   MATCH_SELF ("a)");
 
@@ -74,8 +74,8 @@ test_posix_extended ()
   MATCH_SELF ("a{}");
   MATCH_SELF ("a{-1");
   MATCH_SELF ("a{-1}");
-  MATCH_SELF ("a{0");            
-  MATCH_SELF ("a{0,"); 
+  MATCH_SELF ("a{0");
+  MATCH_SELF ("a{0,");
   MATCH_SELF (concat ("a{", dup_max_plus_one));
   MATCH_SELF (concat (concat ("a{", dup_max_plus_one), ","));
   MATCH_SELF ("a{1,0");
@@ -83,7 +83,7 @@ test_posix_extended ()
   MATCH_SELF ("a{0,1");
   test_match ("[a{0,1}]", "}");
   test_match ("a{1,3}{-1}", "aaa{-1}");
-  test_match (concat ("a{1,3}{", dup_max_plus_one), 
+  test_match (concat ("a{1,3}{", dup_max_plus_one),
 	      concat ("aaa{", dup_max_plus_one));
   test_match ("a{1,3}{2,1}", "aaa{2,1}");
   test_match ("a{1,3}{1,2", "aaa{1,2");
@@ -96,7 +96,7 @@ test_posix_extended ()
   test_match ("a??", "a");
   test_match ("a?*", "a");
   test_match ("a?+", "a");
-  
+
   test_match ("a{2}?", "");
   test_match ("a{2}?", "aa");
   test_match ("a{2}+", "aa");
@@ -104,21 +104,21 @@ test_posix_extended ()
 
   test_match ("a{1}?*", "");
   test_match ("a{1}?*", "aa");
-  
-  test_match ("(a?){0,3}b", "aaab"); 
-  test_fastmap ("(a?){0,3}b", "ab", 0, 0); 
-  test_match ("(a+){0,3}b", "b"); 
-  test_fastmap ("(a+){0,3}b", "ab", 0, 0); 
+
+  test_match ("(a?){0,3}b", "aaab");
+  test_fastmap ("(a?){0,3}b", "ab", 0, 0);
+  test_match ("(a+){0,3}b", "b");
+  test_fastmap ("(a+){0,3}b", "ab", 0, 0);
   test_match ("(a+){0,3}b", "ab");
-  test_fastmap ("(a+){0,3}b", "ab", 0, 0); 
-  test_match ("(a+){1,3}b", "aaab"); 
+  test_fastmap ("(a+){0,3}b", "ab", 0, 0);
+  test_match ("(a+){1,3}b", "aaab");
   test_match ("(a?){1,3}b", "aaab");
 
   test_match ("\\\\{1}", "\\");				/* Extended only.  */
 
   test_match ("(a?)?", "a");
   test_match ("(a?b)?c", "abc");
-  test_match ("(a+)*b", "b"); 
+  test_match ("(a+)*b", "b");
 						/* Alternatives.  */
   test_match ("a|b", "a");
   test_match ("a|b", "b");
@@ -132,7 +132,7 @@ test_posix_extended ()
   test_match ("(a|b|c)", "c");
 
   test_match ("(a|b|c)*", "abccba");
-  
+
   test_match ("(a(b*))|c", "a");	/* xx do registers.  */
   test_match ("(a(b*))|c", "ab");
   test_match ("(a(b*))|c", "c");
@@ -140,7 +140,7 @@ test_posix_extended ()
   test_fastmap ("(a+?*|b)", "ab", 0, 0);
   test_match ("(a+?*|b)", "b");
   TEST_REGISTERS ("(a+?*|b)", "b", 0, 1, 0, 1, -1, -1);
-  
+
   test_fastmap ("(a+?*|b)*", "ab", 0, 0);
   test_match ("(a+?*|b)*", "bb");
   TEST_REGISTERS ("(a+?*|b)*", "bb", 0, 2, 1, 2, -1, -1);
@@ -165,7 +165,7 @@ test_posix_extended ()
   test_fastmap ("(a+?*|b)c", "abc", 0, 0);
   test_match ("(a+?*|b)c", "bc");
   TEST_REGISTERS ("(a+?*|b)c", "bc", 0, 2, 0, 1, -1, -1);
-  
+
   test_fastmap ("(a+?*|b)*c", "abc", 0, 0);
   test_match ("(a+?*|b)*c", "bbc");
   TEST_REGISTERS ("(a+?*|b)*c", "bbc", 0, 3, 1, 2, -1, -1);
@@ -189,12 +189,12 @@ test_posix_extended ()
 
   test_fastmap ("((a{0,}\\b\\<)|b)", "ab", 0, 0);
   test_match ("((a{0,}\\b\\<)|b)", "b");
-  TEST_REGISTERS ("((a{0,}\\b\\<)|b)", "b", 
+  TEST_REGISTERS ("((a{0,}\\b\\<)|b)", "b",
     0, 1, 0, 1, 0, 0);
 
   test_fastmap ("((a{0,}\\b\\<)|b)*", "ab", 0, 0);
   test_match ("((a{0,}\\b\\<)|b)*", "b");
-  TEST_REGISTERS ("((a{0,}\\b\\<)|b)*", "b", 
+  TEST_REGISTERS ("((a{0,}\\b\\<)|b)*", "b",
     0, 1, 0, 1, 0, 0);
 
   test_fastmap ("((a+?*{0,1}\\b\\<)|b)", "ab", 0, 0);
@@ -251,7 +251,7 @@ test_posix_extended ()
 
 
 				/* `*' after group.  */
-  test_match ("(a*|b*)*c", "c");	
+  test_match ("(a*|b*)*c", "c");
   TEST_REGISTERS ("(a*|b*)*c", "c", 0, 1, 0, 0, -1, -1);
 
   test_match ("(a*|b*)*c", "ac");
@@ -279,8 +279,8 @@ test_posix_extended ()
   test_match ("(a*|b*)c", "aac");
   TEST_REGISTERS ("(a*|b*)c", "aac", 0, 3, 0, 2, -1, -1);
 
-  /* Same as above, but with no `*'s in alternatives. 
-  
+  /* Same as above, but with no `*'s in alternatives.
+
   test_match ("(a|b)*c", "c");		/* `*' after group.  */
   TEST_REGISTERS ("(a|b)*c", "c", 0, 1, -1, -1, -1, -1);
 
@@ -298,7 +298,7 @@ test_posix_extended ()
   TEST_REGISTERS ("(a*|b*)c", "bbc", 0, 3, 0, 2, -1, -1);
 
   /* Complicated second alternative.  */
-  
+
   test_match ("(a*|(b*)*)*c", "bc");
   TEST_REGISTERS ("(a*|(b*)*)*c", "bc", 0, 2, 0, 1, 0, 1);
 
@@ -335,9 +335,9 @@ test_posix_extended ()
   valid_pattern ("(^$)");
 
       /* These are the same (but valid) as those (invalid) in other_test.c.  */
-  valid_pattern 
+  valid_pattern
     ("(((((((((((((((((((((((((((((((((a^)))))))))))))))))))))))))))))))))");
-  valid_pattern 
+  valid_pattern
     ("((((((((((((((((((((((((((((((((($a)))))))))))))))))))))))))))))))))");
   valid_pattern ("\\(^a\\)");
   valid_pattern ("a\\|^b");
@@ -724,7 +724,7 @@ test_posix_extended ()
   valid_pattern ("(^a)(b|^c)|^d");
   valid_pattern ("(^a)(b|c^)|^d");
   valid_pattern ("(^a)(b|c)^|^d");
-  
+
   valid_pattern ("(a)(b$|c$)d$");
   valid_pattern ("(a)(b|$c)$|d$");
   valid_pattern ("(a)($b|c)$|d$");
@@ -1003,11 +1003,11 @@ test_posix_extended ()
   TEST_SEARCH ("^(a)(b|c)|^d", "abe", 0, 3);
   TEST_SEARCH ("^(a)(b|c)|^d", "ace", 0, 3);
   TEST_SEARCH ("^(a)(b|c)|^d", "df", 0, 2);
-  
+
   TEST_SEARCH ("(^a)(b|c)|^d", "abe", 0, 3);
   TEST_SEARCH ("(^a)(b|c)|^d", "ace", 0, 3);
   TEST_SEARCH ("(^a)(b|c)|^d", "df", 0, 2);
-  
+
   TEST_SEARCH ("(a)(b|c)$|d$", "fab", 0, 3);
   TEST_SEARCH ("(a)(b|c)$|d$", "fac", 0, 3);
   TEST_SEARCH ("(a)(b|c)$|d$", "fd", 0, 2);
@@ -1027,11 +1027,11 @@ test_posix_extended ()
   TEST_SEARCH ("^d|^(b|c)(a)", "df", 0, 2);
   TEST_SEARCH ("^d|^(b|c)(a)", "baf", 0, 3);
   TEST_SEARCH ("^d|^(b|c)(a)", "caf", 0, 3);
-  
+
   TEST_SEARCH ("^d|(^b|^c)(a)", "df", 0, 2);
   TEST_SEARCH ("^d|(^b|^c)(a)", "baf", 0, 3);
   TEST_SEARCH ("^d|(^b|^c)(a)", "caf", 0, 3);
-  
+
   TEST_SEARCH ("d$|(b|c)(a$)", "fd", 0, 2);
   TEST_SEARCH ("d$|(b|c)(a$)", "fba", 0, 3);
   TEST_SEARCH ("d$|(b|c)(a$)", "fca", 0, 3);
@@ -1112,13 +1112,13 @@ test_posix_extended ()
   test_match ("(fooq|foo)(qbarx|bar)", "fooqbarx");
 
   /* Take first alternative that does the longest match.  */
-  test_all_registers ("(fooq|(foo)|(fo))((qbarx)|(oqbarx)|bar)", "fooqbarx", 
-    "", 0, 8,  0, 3,  0, 3,  -1, -1,  3, 8,  3, 8,  -1, -1,  -1, -1, -1, -1,  
+  test_all_registers ("(fooq|(foo)|(fo))((qbarx)|(oqbarx)|bar)", "fooqbarx",
+    "", 0, 8,  0, 3,  0, 3,  -1, -1,  3, 8,  3, 8,  -1, -1,  -1, -1, -1, -1,
     -1, -1);
 
   test_match ("(fooq|foo)*qbar", "fooqbar");
   test_match ("(fooq|foo)*(qbar)", "fooqbar");
-  test_match ("(fooq|foo)*(qbar)*", "fooqbar"); 
+  test_match ("(fooq|foo)*(qbar)*", "fooqbar");
 
   test_match ("(fooq|fo|o)*qbar", "fooqbar");
   test_match ("(fooq|fo|o)*(qbar)", "fooqbar");
diff --git a/gnu/lib/libregex/test/psx-generic.c b/gnu/lib/libregex/test/psx-generic.c
index 340e938..8e97f75 100644
--- a/gnu/lib/libregex/test/psx-generic.c
+++ b/gnu/lib/libregex/test/psx-generic.c
@@ -12,7 +12,7 @@ test_posix_generic ()
   if (omit_generic_tests)
     return;
                                 /* Tests somewhat in the order of P1003.2.  */
-  
+
   /* Both posix basic and extended; should match.  */
 
   printf ("\nStarting generic POSIX tests.\n");
@@ -29,12 +29,12 @@ test_posix_generic ()
   TEST_REGISTERS ("", "", 0, 0, -1, -1, -1, -1);
   TEST_SEARCH ("", "", 0, 0);
   TEST_SEARCH_2 ("", "", "", 0, 1, 0);
-  
-  MATCH_SELF ("abc");				
-  test_fastmap ("abc", "a", 0, 0);				
+
+  MATCH_SELF ("abc");
+  test_fastmap ("abc", "a", 0, 0);
   TEST_REGISTERS ("abc", "abc", 0, 3, -1, -1, -1, -1);
   TEST_REGISTERS ("abc", "xabcx", 1, 4, -1, -1, -1, -1);
-  
+
   test_match ("\\a","a");
   test_match ("\\0", "0");
 
@@ -44,7 +44,7 @@ test_posix_generic ()
   TEST_SEARCH_2 ("a", "a", "b", 0, 2, 2);
   TEST_SEARCH_2 ("b", "a", "b", 0, 2, 2);
   TEST_SEARCH_2 ("a", "a", "b", 1, -2, 2);
-  
+
   test_match ("\n", "\n");
   test_match ("a\n", "a\n");
   test_match ("\nb", "\nb");
@@ -55,8 +55,8 @@ test_posix_generic ()
   test_match ("a*", "aa");
   test_fastmap ("a*", "a", 0, 0);
   TEST_REGISTERS ("a*", "aa", 0, 2, -1, -1, -1, -1);
-  
-  test_match ("a*b", "aab");			
+
+  test_match ("a*b", "aab");
   test_fastmap ("a*b", "ab", 0, 0);
 
   test_match ("a*ab", "aab");
@@ -80,9 +80,9 @@ test_posix_generic ()
   test_match (".", "a");
   TEST_REGISTERS (".", "a", 0, 1, -1, -1, -1, -1);
   test_match (".", "\004");
-  test_match (".", "\n");		
+  test_match (".", "\n");
                                               /* Valid bracket expressions.  */
-  test_match ("[ab]", "a");		
+  test_match ("[ab]", "a");
   test_match ("[ab]", "b");
   test_fastmap ("[ab]", "ab", 0, 0);
   TEST_REGISTERS ("[ab]", "a", 0, 1, -1, -1, -1, -1);
@@ -92,7 +92,7 @@ test_posix_generic ()
   test_match ("[^ab]", "c");
   test_match ("[^a]", "\n");
 
-  test_match ("[a]*a", "aa");		
+  test_match ("[a]*a", "aa");
 
   test_match ("[[]", "[");
   test_match ("[]]", "]");
@@ -115,12 +115,12 @@ test_posix_generic ()
 
                                                 /* Collating, noncollating,
                                              	   equivalence classes aren't
-                                           	   implemented yet.  */  
-					
+                                           	   implemented yet.  */
+
 
                                                 /* Character classes.  */
-  test_match ("[:alpha:]", "p");	
-  test_match ("[[:alpha:]]", "a");	
+  test_match ("[:alpha:]", "p");
+  test_match ("[[:alpha:]]", "a");
   test_match ("[[:alpha:]]", "z");
   test_match ("[[:alpha:]]", "A");
   test_match ("[[:alpha:]]", "Z");
@@ -172,10 +172,10 @@ test_posix_generic ()
   test_match ("[a-]", "-");		/* Last  */
   test_match ("[a-]", "a");
   test_match ("[--@]", "@");		/* First and starting point.  */
-  
+
   test_match ("[%--a]", "%");		/* Ending point.  */
   test_match ("[%--a]", "-");		/* Ditto.  */
-  
+
   test_match ("[a%--]", "%");		/* Both ending point and last.  */
   test_match ("[a%--]", "-");
   test_match ("[%--a]", "a");		/* Ending point only.  */
@@ -186,29 +186,29 @@ test_posix_generic ()
   test_match ("[)-+--/]", "/");
   test_match ("[[:digit:]-]", "-");
                                         /* Concatenation  ????*/
-  test_match ("[ab][cd]", "ac");			
+  test_match ("[ab][cd]", "ac");
   test_fastmap ("[ab][cd]", "ab", 0, 0);
   TEST_REGISTERS ("[ab][cd]", "ad", 0, 2, -1, -1, -1, -1);
   TEST_REGISTERS ("[ab][cd]", "xadx", 1, 3, -1, -1, -1, -1);
-	
+
                                              /* Valid expression anchoring.  */
   test_match ("^a", "a");
   test_fastmap ("^a", "a", 0, 0);
   TEST_REGISTERS ("^a", "ax", 0, 1, -1, -1, -1, -1);
-  
+
   test_match ("^", "");
   TEST_REGISTERS ("^", "", 0, 0, -1, -1, -1, -1);
   test_match ("$", "");
   TEST_REGISTERS ("$", "", 0, 0, -1, -1, -1, -1);
-  
+
   test_match ("a$", "a");
   test_fastmap ("a$", "a", 0, 0);
   TEST_REGISTERS ("a$", "xa", 1, 2, -1, -1, -1, -1);
-  
+
   test_match ("^ab$", "ab");
   test_fastmap ("^ab$", "a", 0, 0);
   TEST_REGISTERS ("^a$", "a", 0, 1, -1, -1, -1, -1);
-  
+
   test_fastmap ("^$", "", 0, 0);
   test_match ("^$", "");
   TEST_REGISTERS ("^$", "", 0, 0, -1, -1, -1, -1);
@@ -221,7 +221,7 @@ test_posix_generic ()
                                                 /* Two strings.  */
   test_match_2 ("ab", "a", "b");
   TEST_REGISTERS_2 ("ab", "a", "b", 0, 2, -1, -1, -1, -1);
-  
+
   test_match_2 ("a", "", "a");
   test_match_2 ("a", "a", "");
   test_match_2 ("ab", "a", "b");
@@ -235,8 +235,8 @@ test_posix_generic ()
 
   test_should_match = false;
                                           /* Ordinary characters.  */
-  test_match ("abc", "ab");			
-  
+  test_match ("abc", "ab");
+
   TEST_SEARCH ("c", "ab", 0, 2);
   TEST_SEARCH ("c", "ab", 0, 2);
   TEST_SEARCH ("c", "ab", 1, -2);
@@ -257,8 +257,8 @@ test_posix_generic ()
 						  /* Invalid period.  */
   test_match (".", "");
 					  /* Invalid bracket expressions.  */
-  test_match ("[ab]", "c");		    
-  test_match ("[^b]", "b");			
+  test_match ("[ab]", "c");
+  test_match ("[^b]", "b");
   test_match ("[^]]", "]");
 
   invalid_pattern (REG_EBRACK, "[");
@@ -267,7 +267,7 @@ test_posix_generic ()
   invalid_pattern (REG_EBRACK, "[]");
   invalid_pattern (REG_EBRACK, "[]a");
   invalid_pattern (REG_EBRACK, "a[]a");
-  
+
 
   test_match ("[:alpha:]", "q");	       /* Character classes.  */
   test_match ("[[:alpha:]]", "2");
@@ -288,10 +288,10 @@ test_posix_generic ()
   invalid_pattern (REG_ECTYPE, "[[:a:]]");
   invalid_pattern (REG_ECTYPE, "[[:alpo:]]");
   invalid_pattern (REG_ECTYPE, "[[:a:]");
-  
+
   test_match ("[a-z]", "2");			/* Invalid ranges.  */
-  test_match ("[^-a]", "-");		
-  test_match ("[^a-]", "-");		
+  test_match ("[^-a]", "-");
+  test_match ("[^a-]", "-");
   test_match ("[)-+--/]", ".");
   invalid_pattern (REG_ERANGE, "[z-a]");		/* Empty  */
   invalid_pattern (REG_ERANGE, "[a--]");		/* Empty  */
diff --git a/gnu/lib/libregex/test/psx-interf.c b/gnu/lib/libregex/test/psx-interf.c
index 8312d5e..80498fb 100644
--- a/gnu/lib/libregex/test/psx-interf.c
+++ b/gnu/lib/libregex/test/psx-interf.c
@@ -7,7 +7,7 @@
 
 #define ERROR_CODE_LENGTH 20
 #define TEST_ERRBUF_SIZE 15
- 
+
 
 void test_compile ();
 
@@ -64,50 +64,50 @@ init_pattern_buffer (pattern_buffer_ptr)
 
 
 void
-test_compile (valid_pattern, error_code_expected, pattern, 
+test_compile (valid_pattern, error_code_expected, pattern,
 	      pattern_buffer_ptr, cflags)
     unsigned valid_pattern;
     int error_code_expected;
     const char *pattern;
     regex_t *pattern_buffer_ptr;
     int cflags;
-{    
+{
   int error_code_returned;
   boolean error = false;
   char errbuf[TEST_ERRBUF_SIZE];
-  
+
   init_pattern_buffer (pattern_buffer_ptr);
   error_code_returned = regcomp (pattern_buffer_ptr, pattern, cflags);
 
   if (valid_pattern && error_code_returned)
     {
       printf ("\nShould have been a valid pattern but wasn't.\n");
-      regerror (error_code_returned, pattern_buffer_ptr, errbuf, 
+      regerror (error_code_returned, pattern_buffer_ptr, errbuf,
 	        TEST_ERRBUF_SIZE);
       printf ("%s", errbuf);
       error = true;
     }
-    
+
   if (!valid_pattern && !error_code_returned)
     {
       printf ("\n\nInvalid pattern compiled as valid:\n");
       error = true;
     }
- 
+
   if (error_code_returned != error_code_expected)
     {
       char expected_error_string[ERROR_CODE_LENGTH];
       char returned_error_string[ERROR_CODE_LENGTH];
-      
-      get_error_string (error_code_expected, expected_error_string), 
+
+      get_error_string (error_code_expected, expected_error_string),
       get_error_string (error_code_returned, returned_error_string);
-      
-      printf ("  Expected error code %s but got `%s'.\n", 
+
+      printf ("  Expected error code %s but got `%s'.\n",
               expected_error_string, returned_error_string);
 
       error = true;
     }
-  
+
   if (error)
     print_pattern_info (pattern, pattern_buffer_ptr);
 }
@@ -121,7 +121,7 @@ test_nsub (sub_count, pattern, cflags)
 
 {
   regex_t pattern_buffer;
-  
+
   test_compile (1, 0, pattern, &pattern_buffer, cflags);
 
   if (pattern_buffer.re_nsub != sub_count)
@@ -132,7 +132,7 @@ instead.\n", sub_count, pattern_buffer.re_nsub);
 
   regfree (&pattern_buffer);
 }
-  
+
 
 static void
 test_regcomp ()
@@ -140,9 +140,9 @@ test_regcomp ()
   regex_t pattern_buffer;
   int cflags = 0;
 
-  
+
   printf ("\nStarting regcomp tests.\n");
-  
+
   cflags = 0;
   test_compile (0, REG_ESUBREG, "\\(a\\)\\2", &pattern_buffer, cflags);
   test_compile (0, REG_EBRACE, "a\\{", &pattern_buffer, cflags);
@@ -160,7 +160,7 @@ test_regcomp ()
   test_nsub (1, "(a)", cflags);
   test_nsub (2, "((a))", cflags);
   test_nsub (2, "(a)(b)", cflags);
-  
+
   cflags = REG_EXTENDED | REG_NOSUB;
   test_nsub (1, "(a)", cflags);
 
@@ -197,13 +197,13 @@ test_pmatch (pattern, string, nmatch, pmatch, correct_pmatch, cflags)
   unsigned this_match;
   int error_code_returned;
   boolean found_nonmatch = false;
-  
+
   test_compile (1, 0, pattern, &pattern_buffer, cflags);
   error_code_returned = regexec (&pattern_buffer, string, nmatch, pmatch, 0);
-  
+
   if (error_code_returned == REG_NOMATCH)
     printf ("Matching failed in test_pmatch.\n");
-  else    
+  else
     {
       for (this_match = 0; this_match < nmatch; this_match++)
         {
@@ -213,7 +213,7 @@ test_pmatch (pattern, string, nmatch, pmatch, correct_pmatch, cflags)
                 printf ("\n");
 
              printf ("Pmatch start %d wrong: was %d when should have \
-been %d.\n", this_match, pmatch[this_match].rm_so, 
+been %d.\n", this_match, pmatch[this_match].rm_so,
 		      correct_pmatch[this_match].rm_so);
               found_nonmatch = true;
             }
@@ -223,7 +223,7 @@ been %d.\n", this_match, pmatch[this_match].rm_so,
                 printf ("\n");
 
               printf ("Pmatch end   %d wrong: was %d when should have been \
-%d.\n", this_match, pmatch[this_match].rm_eo, 
+%d.\n", this_match, pmatch[this_match].rm_eo,
                        correct_pmatch[this_match].rm_eo);
               found_nonmatch = true;
             }
@@ -258,12 +258,12 @@ test_eflags (must_match_bol, must_match_eol, pattern, string, cflags, eflags)
   error_code_returned = regexec (&pattern_buffer, string, 0, 0, eflags);
 
   if (error_code_returned == REG_NOMATCH)
-    {  
+    {
       /* If wasn't true that both 1) the anchored part of the pattern
          had to match this string and 2) this string was a proper
 	 substring...  */
 
-      if (!( (must_match_bol && (eflags & REG_NOTBOL)) 
+      if (!( (must_match_bol && (eflags & REG_NOTBOL))
 	     || (must_match_eol && (eflags & REG_NOTEOL)) ))
         {
           printf ("\nEflags test failed:  didn't match when should have.\n");
@@ -271,7 +271,7 @@ test_eflags (must_match_bol, must_match_eol, pattern, string, cflags, eflags)
 	}
     }
   else  /* We got a match.  */
-    {  
+    {
       /* If wasn't true that either 1) the anchored part of the pattern
          didn't have to match this string or 2) this string wasn't a
          proper substring...  */
@@ -313,7 +313,7 @@ test_ignore_case (should_match, pattern, string, cflags)
   error_code_returned = regexec (&pattern_buffer, string, 0, 0, 0);
 
   if (should_match && error_code_returned == REG_NOMATCH)
-    {  
+    {
       printf ("\nIgnore-case test failed:\n");
       printf ("  The string to match was:  `%s'.\n", string);
       print_pattern_info (pattern, &pattern_buffer);
@@ -340,7 +340,7 @@ test_newline (should_match, pattern, string, cflags)
   error_code_returned = regexec (&pattern_buffer, string, 0, 0, 0);
 
   if (should_match && error_code_returned == REG_NOMATCH)
-    {  
+    {
       printf ("\nNewline test failed:\n");
       printf ("  The string to match was:  `%s'.\n", string);
       print_pattern_info (pattern, &pattern_buffer);
@@ -370,12 +370,12 @@ test_posix_match (should_match, pattern, string, cflags)
   error_code_returned = regexec (&pattern_buffer, string, 0, 0, 0);
 
   if (should_match && error_code_returned == REG_NOMATCH)
-    {  
+    {
       printf ("\nShould have matched but didn't:\n");
       was_error = true;
     }
   else if (!should_match && error_code_returned != REG_NOMATCH)
-    {  
+    {
       printf ("\nShould not have matched but did:\n");
       was_error = true;
     }
@@ -397,23 +397,23 @@ test_regexec ()
   regmatch_t correct_pmatch[3];
   int cflags = 0;
   int eflags = 0;
-    
+
   printf ("\nStarting regexec tests.\n");
 
   cflags = REG_NOSUB;    /* shouldn't look at any of pmatch.  */
   test_pmatch ("a", "a", 0, pmatch, correct_pmatch, cflags);
-    
+
   /* Ask for less `pmatch'es than there are pattern subexpressions.
      (Shouldn't look at pmatch[2].  */
   cflags = REG_EXTENDED;
   fill_pmatch (correct_pmatch, 0, 1, 0, 1, 100, 101);
   test_pmatch ("((a))", "a", 2, pmatch, correct_pmatch, cflags);
-    
+
   /* Ask for same number of `pmatch'es as there are pattern subexpressions.  */
   cflags = REG_EXTENDED;
   fill_pmatch(correct_pmatch, 0, 1, 0, 1, -1, -1);
   test_pmatch ("(a)", "a", 2, pmatch, correct_pmatch, cflags);
-    
+
   /* Ask for more `pmatch'es than there are pattern subexpressions.  */
   cflags = REG_EXTENDED;
   fill_pmatch (correct_pmatch, 0, 1, -1, -1, -1, -1);
@@ -487,7 +487,7 @@ test_regexec ()
 
   test_newline (true, "^a", "\na", cflags);
   test_newline (true, "a$", "a\n", cflags);
-  
+
   /* Now test normal behavior.  */
   cflags = REG_EXTENDED;
   test_newline (true, "\n", "\n", cflags);
@@ -508,11 +508,11 @@ test_regexec ()
   /* Test that matches whole string only.  */
   cflags = 0;
   test_posix_match (true, "a", "a", cflags);
-  
+
   /* Tests that match substrings.  */
   test_posix_match (true, "a", "ab", cflags);
   test_posix_match (true, "b", "ab", cflags);
-  
+
   /* Test that doesn't match.  */
   test_posix_match (false, "a", "b", cflags);
 
@@ -528,8 +528,8 @@ test_error_code_message (error_code, expected_error_message)
   char returned_error_message[TEST_ERRBUF_SIZE];
   char error_code_string[ERROR_CODE_LENGTH];
   size_t expected_error_message_length = strlen (expected_error_message) + 1;
-  size_t returned_error_message_length = regerror (error_code, 0, 
-					             returned_error_message, 
+  size_t returned_error_message_length = regerror (error_code, 0,
+					             returned_error_message,
 	                                             TEST_ERRBUF_SIZE);
 
   if (returned_error_message_length != expected_error_message_length)
@@ -543,14 +543,14 @@ message  `%s':\n", expected_error_message);
 	      expected_error_message_length, returned_error_message_length);
     }
 
-  if (strncmp (expected_error_message, returned_error_message, 
+  if (strncmp (expected_error_message, returned_error_message,
 	       TEST_ERRBUF_SIZE - 1) != 0)
     {
-      
-      get_error_string (error_code, error_code_string), 
+
+      get_error_string (error_code, error_code_string),
       printf ("\n\n  With error code %s (%d), expected error message:\n",
       	      error_code_string, error_code);
-                    
+
       printf ("    `%s'\n", expected_error_message);
       printf ("  but got:\n");
       printf ("    `%s'\n", returned_error_message);
@@ -565,21 +565,21 @@ test_error_code_allocation (error_code, expected_error_message)
 {
   char *returned_error_message = NULL;
   char error_code_string[ERROR_CODE_LENGTH];
-  size_t returned_error_message_length = regerror (error_code, 0, 
-					             returned_error_message, 
+  size_t returned_error_message_length = regerror (error_code, 0,
+					             returned_error_message,
 	                                             (size_t)0);
 
   returned_error_message = xmalloc (returned_error_message_length + 1);
-    
-  regerror (error_code, 0, returned_error_message, 
+
+  regerror (error_code, 0, returned_error_message,
 	    returned_error_message_length);
-  
+
   if (strcmp (expected_error_message, returned_error_message) != 0)
     {
-      get_error_string (error_code, error_code_string), 
-      
-      printf ("\n\n  Testing error code allocation,\n"); 
-      printf ("with error code %s (%d), expected error message:\n", 
+      get_error_string (error_code, error_code_string),
+
+      printf ("\n\n  Testing error code allocation,\n");
+      printf ("with error code %s (%d), expected error message:\n",
 	       error_code_string, error_code);
       printf ("    `%s'\n", expected_error_message);
       printf ("  but got:\n");
@@ -591,18 +591,18 @@ test_error_code_allocation (error_code, expected_error_message)
 static void
 test_regerror ()
 {
-  test_error_code_message (REG_NOMATCH, "No match"); 
+  test_error_code_message (REG_NOMATCH, "No match");
   test_error_code_message (REG_BADPAT, "Invalid regular expression");
-  test_error_code_message (REG_ECOLLATE, "Invalid collation character"); 
-  test_error_code_message (REG_ECTYPE, "Invalid character class name"); 
-  test_error_code_message (REG_EESCAPE, "Trailing backslash"); 
-  test_error_code_message (REG_ESUBREG, "Invalid back reference"); 
-  test_error_code_message (REG_EBRACK, "Unmatched [ or [^"); 
-  test_error_code_message (REG_EPAREN, "Unmatched ( or \\("); 
-  test_error_code_message (REG_EBRACE, "Unmatched \\{"); 
-  test_error_code_message (REG_BADBR, "Invalid content of \\{\\}"); 
-  test_error_code_message (REG_ERANGE, "Invalid range end"); 
-  test_error_code_message (REG_ESPACE, "Memory exhausted"); 
+  test_error_code_message (REG_ECOLLATE, "Invalid collation character");
+  test_error_code_message (REG_ECTYPE, "Invalid character class name");
+  test_error_code_message (REG_EESCAPE, "Trailing backslash");
+  test_error_code_message (REG_ESUBREG, "Invalid back reference");
+  test_error_code_message (REG_EBRACK, "Unmatched [ or [^");
+  test_error_code_message (REG_EPAREN, "Unmatched ( or \\(");
+  test_error_code_message (REG_EBRACE, "Unmatched \\{");
+  test_error_code_message (REG_BADBR, "Invalid content of \\{\\}");
+  test_error_code_message (REG_ERANGE, "Invalid range end");
+  test_error_code_message (REG_ESPACE, "Memory exhausted");
   test_error_code_message (REG_BADRPT, "Invalid preceding regular expression");
   test_error_code_message (REG_EEND, "Premature end of regular expression");
   test_error_code_message (REG_ESIZE, "Regular expression too big");
@@ -615,10 +615,10 @@ test_posix_interface ()
 {
   printf ("\nStarting POSIX interface tests.\n");
   t = posix_interface_test;
-  
+
   test_regcomp ();
   test_regexec ();
   test_regerror ();
-  
+
   printf ("\nFinished POSIX interface tests.\n");
 }
diff --git a/gnu/lib/libregex/test/psx-interv.c b/gnu/lib/libregex/test/psx-interv.c
index 6725c38..fcdf488 100644
--- a/gnu/lib/libregex/test/psx-interv.c
+++ b/gnu/lib/libregex/test/psx-interv.c
@@ -27,10 +27,10 @@ test_intervals ()
 
   test_match (BRACES_TO_OPS ("a{1}"), "a");
   test_match (BRACES_TO_OPS ("a{1,}"), "a");
-  test_match (BRACES_TO_OPS ("a{1,}"), "aa"); 
+  test_match (BRACES_TO_OPS ("a{1,}"), "aa");
   test_match (BRACES_TO_OPS ("a{0,0}"), "");
   test_match (BRACES_TO_OPS ("a{0,1}"), "");
-  test_match (BRACES_TO_OPS ("a{0,1}"), "a"); 
+  test_match (BRACES_TO_OPS ("a{0,1}"), "a");
   test_match (BRACES_TO_OPS ("a{1,3}"), "a");
   test_match (BRACES_TO_OPS ("a{1,3}"), "aa");
   test_match (BRACES_TO_OPS ("a{1,3}"), "aaa");
@@ -68,7 +68,7 @@ test_intervals ()
 
   test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){1,1}ab")), "aaaab");
   TEST_REGISTERS (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){1,1}ab")), "aaaab", 0, 5, 0, 3, -1, -1);
-  
+
   test_match (BRACES_TO_OPS (".{0,3}b"), "b");
   test_match (BRACES_TO_OPS (".{0,3}b"), "ab");
 
@@ -98,7 +98,7 @@ test_intervals ()
   test_match (BRACES_TO_OPS ("a{1}*"), "");
   test_match (BRACES_TO_OPS ("a{1}*"), "a");
   test_match (BRACES_TO_OPS ("a{1}*"), "aa");
-  
+
   test_match (BRACES_TO_OPS ("a{1}{1}"), "a");
 
   test_match (BRACES_TO_OPS ("a{1}{1}{1}"), "a");
@@ -108,25 +108,25 @@ test_intervals ()
   test_match (BRACES_TO_OPS ("a{1}{1}*"), "a");
   test_match (BRACES_TO_OPS ("a{1}{1}*"), "aa");
   test_match (BRACES_TO_OPS ("a{1}{1}*"), "aaa");
-  
+
   test_match (BRACES_TO_OPS ("a{1}{2}"), "aa");
   test_match (BRACES_TO_OPS ("a{2}{1}"), "aa");
 
 
   test_should_match = false;
-  
+
   test_match (BRACES_TO_OPS ("a{0}"), "a");
   test_match (BRACES_TO_OPS ("a{0,}"), "b");
-  test_match (BRACES_TO_OPS ("a{1}"), ""); 
+  test_match (BRACES_TO_OPS ("a{1}"), "");
   test_match (BRACES_TO_OPS ("a{1}"), "aa");
   test_match (BRACES_TO_OPS ("a{1,}"), "");
   test_match (BRACES_TO_OPS ("a{1,}"), "b");
-  test_match (BRACES_TO_OPS ("a{0,0}"), "a"); 
+  test_match (BRACES_TO_OPS ("a{0,0}"), "a");
   test_match (BRACES_TO_OPS ("a{0,1}"), "aa");
   test_match (BRACES_TO_OPS ("a{0,1}"), "b");
-  test_match (BRACES_TO_OPS ("a{1,3}"), ""); 
+  test_match (BRACES_TO_OPS ("a{1,3}"), "");
   test_match (BRACES_TO_OPS ("a{1,3}"), "aaaa");
-  test_match (BRACES_TO_OPS ("a{1,3}"), "b"); 
+  test_match (BRACES_TO_OPS ("a{1,3}"), "b");
   test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a){1,3}b")), "aaaab");
   test_match (BRACES_TO_OPS (PARENS_TO_OPS ("(a*){1,3}b")), "bb");
   test_match (BRACES_TO_OPS ("[a]{0,3}"), "aaaa");
diff --git a/gnu/lib/libregex/test/test.c b/gnu/lib/libregex/test/test.c
index a8de23e..74b43b2 100644
--- a/gnu/lib/libregex/test/test.c
+++ b/gnu/lib/libregex/test/test.c
@@ -55,32 +55,32 @@ boolean test_should_match;
 
 
 static void
-set_all_registers (start0, end0, start1, end1, 
+set_all_registers (start0, end0, start1, end1,
 	           start2, end2, start3, end3,
-                   start4, end4, start5, end5, 
+                   start4, end4, start5, end5,
                    start6, end6, start7, end7,
                    start8, end8, start9, end9, regs)
 
-  int start0; int end0; int start1; int end1; 
+  int start0; int end0; int start1; int end1;
   int start2; int end2; int start3; int end3;
-  int start4; int end4; int start5; int end5; 
+  int start4; int end4; int start5; int end5;
   int start6; int end6; int start7; int end7;
-  int start8; int end8; int start9; int end9; 
+  int start8; int end8; int start9; int end9;
   struct re_registers *regs;
 
   {
     unsigned r;
-    
-    regs->start[0] = start0;   regs->end[0] = end0;      
-    regs->start[1] = start1;   regs->end[1] = end1;	
-    regs->start[2] = start2;   regs->end[2] = end2;	
-    regs->start[3] = start3;   regs->end[3] = end3;	
-    regs->start[4] = start4;   regs->end[4] = end4;	
-    regs->start[5] = start5;   regs->end[5] = end5;	
-    regs->start[6] = start6;   regs->end[6] = end6;	
-    regs->start[7] = start7;   regs->end[7] = end7;	
-    regs->start[8] = start8;   regs->end[8] = end8;	
-    regs->start[9] = start9;   regs->end[9] = end9;	
+
+    regs->start[0] = start0;   regs->end[0] = end0;
+    regs->start[1] = start1;   regs->end[1] = end1;
+    regs->start[2] = start2;   regs->end[2] = end2;
+    regs->start[3] = start3;   regs->end[3] = end3;
+    regs->start[4] = start4;   regs->end[4] = end4;
+    regs->start[5] = start5;   regs->end[5] = end5;
+    regs->start[6] = start6;   regs->end[6] = end6;
+    regs->start[7] = start7;   regs->end[7] = end7;
+    regs->start[8] = start8;   regs->end[8] = end8;
+    regs->start[9] = start9;   regs->end[9] = end9;
     for (r = 10; r < regs->num_regs; r++)
       {
         regs->start[r] = -1;
@@ -111,16 +111,16 @@ concat (s1, s2)
 
 /* We ignore the `can_be_null' argument.  Should just be removed.  */
 
-void 
+void
 general_test (pattern_should_be_valid, match_whole_string,
 	      pat, str1, str2, start, range, end, correct_fastmap,
               correct_regs, can_be_null)
-    unsigned pattern_should_be_valid; 
+    unsigned pattern_should_be_valid;
     unsigned match_whole_string;
     const char *pat;
     char *str1, *str2;
-    int start, range, end; 
-    char *correct_fastmap; 
+    int start, range, end;
+    char *correct_fastmap;
     struct re_registers *correct_regs;
     int can_be_null;
 {
@@ -138,8 +138,8 @@ general_test (pattern_should_be_valid, match_whole_string,
   unsigned invalid_pattern = 0;
   boolean internal_error_1 = false;
   boolean internal_error_2 = false;
-  
-  
+
+
   nonconst_buf.allocated = 8;
   nonconst_buf.buffer = xmalloc (nonconst_buf.allocated);
   nonconst_buf.fastmap = fastmap;
@@ -147,7 +147,7 @@ general_test (pattern_should_be_valid, match_whole_string,
 
   assert (pat != NULL);
   r = re_compile_pattern (pat, strlen (pat), &nonconst_buf);
-  
+
   /* Kludge: if we are doing POSIX testing, we really should have
      called regcomp, not re_compile_pattern.  As it happens, the only
      way in which it matters is that re_compile_pattern sets the
@@ -156,7 +156,7 @@ general_test (pattern_should_be_valid, match_whole_string,
      matching.  */
   if (t == posix_basic_test || t == posix_extended_test)
     nonconst_buf.newline_anchor = 0;
-    
+
   invalid_pattern = r != NULL;
 
   if (!r)
@@ -168,27 +168,27 @@ general_test (pattern_should_be_valid, match_whole_string,
       else
         {
           fastmap_internal_error = (re_compile_fastmap (&nonconst_buf) == -2);
-          
+
           if (correct_fastmap)
-            nonconst_buf.fastmap_accurate = 
+            nonconst_buf.fastmap_accurate =
               memcmp (nonconst_buf.fastmap, correct_fastmap, 1 << BYTEWIDTH)
               == 0;
-	    
+
 	  if (OK_TO_SEARCH)
 	   {
               old_buf = nonconst_buf;
               old_buf.buffer = (unsigned char *) xmalloc (nonconst_buf.used);
               memcpy (old_buf.buffer, nonconst_buf.buffer, nonconst_buf.used);
-	      
+
               /* If only one string is null, call re_match or re_search,
-                which is what the user would probably do.  */ 
+                which is what the user would probably do.  */
               if (str1 == NULL && str2 != NULL
                   || str2 == NULL && str1 != NULL)
                 {
                   char *the_str = str1 == NULL ? str2 : str1;
-                  
+
                   match_1
-                    = match_whole_string 
+                    = match_whole_string
 	              ? (r = re_match (&nonconst_buf, the_str,
                                        strlen (the_str), start, &regs))
 			== strlen (the_str)
@@ -200,16 +200,16 @@ general_test (pattern_should_be_valid, match_whole_string,
                   if (r == -2)
 	           internal_error_1 = true;
                  }
-	      else  
+	      else
                 match_1 = 1;
-                
+
               /* Also call with re_match_2 or re_search_2, as they might
                  do this.  (Also can check calling with either string1
                  or string2 or both null.)  */
               if (match_whole_string)
                 {
                   r = re_match_2 (&nonconst_buf,
-                                  str1, SAFE_STRLEN (str1), 
+                                  str1, SAFE_STRLEN (str1),
 	                          str2, SAFE_STRLEN (str2),
                                   start, &regs, end);
                   match_2 = r == SAFE_STRLEN (str1) + SAFE_STRLEN (str2);
@@ -217,7 +217,7 @@ general_test (pattern_should_be_valid, match_whole_string,
               else
                 {
                   r = re_search_2 (&nonconst_buf,
-                                   str1, SAFE_STRLEN (str1), 
+                                   str1, SAFE_STRLEN (str1),
 				   str2, SAFE_STRLEN (str2),
                                    start, range, &regs, end);
                   match_2 = r >= 0;
@@ -225,16 +225,16 @@ general_test (pattern_should_be_valid, match_whole_string,
 
               if (r == -2)
 	       internal_error_2 = true;
-                
+
               match = match_1 & match_2;
-              
+
               if (correct_regs)
                 {
 		  unsigned reg;
 		  if (regs_correct != NULL)
                     free (regs_correct);
-                    
-                  regs_correct 
+
+                  regs_correct
                     = (unsigned *) xmalloc (regs.num_regs * sizeof (unsigned));
 
                   for (reg = 0;
@@ -256,9 +256,9 @@ general_test (pattern_should_be_valid, match_whole_string,
                           || (regs.start[reg] == -1 && regs.end[reg] == -1
                               && correct_regs->start[reg]
                                  == correct_regs->end[reg])
-#endif 
+#endif
                           ;
-                                                  
+
                       all_regs_correct &= regs_correct[reg];
                     }
     	        }
@@ -268,15 +268,15 @@ general_test (pattern_should_be_valid, match_whole_string,
 
   if (fastmap_internal_error)
     printf ("\n\nInternal error in re_compile_fastmap:");
-    
+
   if (internal_error_1)
     {
       if (!fastmap_internal_error)
         printf ("\n");
-        
+
       printf ("\nInternal error in re_match or re_search:");
     }
-  
+
   if (internal_error_2)
     {
       if (!internal_error_1)
@@ -285,11 +285,11 @@ general_test (pattern_should_be_valid, match_whole_string,
       printf ("\nInternal error in re_match_2 or re_search_2:");
     }
 
-  if ((OK_TO_SEARCH && ((match && !test_should_match) 
+  if ((OK_TO_SEARCH && ((match && !test_should_match)
 		       || (!match && test_should_match))
                        || (correct_regs && !all_regs_correct))
       || !nonconst_buf.fastmap_accurate
-      || invalid_pattern 
+      || invalid_pattern
       || !pattern_should_be_valid
       || internal_error_1 || internal_error_2
       || verbose)
@@ -324,8 +324,8 @@ general_test (pattern_should_be_valid, match_whole_string,
 
       if ((!(invalid_pattern && !pattern_should_be_valid)) || verbose)
         printf ("  Pattern:  `%s'.\n", pat);
-             
-      if (pattern_should_be_valid || verbose 
+
+      if (pattern_should_be_valid || verbose
           || internal_error_1 || internal_error_2)
         {
           printf("  Strings: ");
@@ -335,7 +335,7 @@ general_test (pattern_should_be_valid, match_whole_string,
           if ((OK_TO_SEARCH || verbose || internal_error_1 || internal_error_2)
               && !invalid_pattern)
 	    {
-              if (memcmp (old_buf.buffer, nonconst_buf.buffer, 
+              if (memcmp (old_buf.buffer, nonconst_buf.buffer,
 	                  nonconst_buf.used) != 0
                   && !invalid_pattern)
                 {
@@ -346,16 +346,16 @@ general_test (pattern_should_be_valid, match_whole_string,
 		}
 	      else
 		printf ("\n  Compiled pattern:   ");
-                
+
               print_compiled_pattern (&nonconst_buf);
             }
 
           if (correct_fastmap && (!nonconst_buf.fastmap_accurate || verbose))
 	    {
-	      printf ("\n  The fastmap should have been: "); 
+	      printf ("\n  The fastmap should have been: ");
               print_fastmap (correct_fastmap);
 
-              printf ("\n  Fastmap: "); 
+              printf ("\n  Fastmap: ");
 	      print_fastmap (fastmap);
 
               printf ("\n  Compiled pattern before matching: ");
@@ -366,25 +366,25 @@ general_test (pattern_should_be_valid, match_whole_string,
             {
               unsigned this_reg;
 	      printf ("\n  Incorrect registers:");
-              
+
 	      for (this_reg = 0; this_reg < regs.num_regs; this_reg++)
                 {
                   if (!regs_correct[this_reg])
 		    {
               	      printf ("\n    Register %d's start was %2d.  ", this_reg,
 				                regs.start[this_reg]);
-		      printf ("\tIt should have been %d.\n", 
+		      printf ("\tIt should have been %d.\n",
 						correct_regs->start[this_reg]);
               	      printf ("    Register %d's end was   %2d.  ", this_reg,
 				                regs.end[this_reg]);
-		      printf ("\tIt should have been %d.\n", 
+		      printf ("\tIt should have been %d.\n",
 						correct_regs->end[this_reg]);
                     }
                 }
             }
         }
     }
-    
+
   if (nonconst_buf.buffer != NULL)
     free (nonconst_buf.buffer);
 
@@ -396,7 +396,7 @@ general_test (pattern_should_be_valid, match_whole_string,
         free (regs_correct);
 
     }
-    
+
   nonconst_buf.buffer = old_buf.buffer = NULL;
   regs_correct = NULL;
   regs.start = regs.end = NULL;
@@ -419,17 +419,17 @@ test_search_return (match_start_wanted, pattern, string)
   num_times_called++;
   buf.allocated = 1;
   buf.buffer = xmalloc (buf.allocated);
-    
+
   assert (pattern != NULL);
   buf.translate = 0;
   compile_return = re_compile_pattern (pattern, strlen (pattern), &buf);
-  
+
   if (compile_return)
     {
       printf ("\n\nInvalid pattern in test_match_start:\n");
       printf ("%s\n", compile_return);
     }
-  else 
+  else
     {
       buf.fastmap = fastmap;
       match_start = re_search (&buf, string, strlen (string),
@@ -453,8 +453,8 @@ test_search_return (match_start_wanted, pattern, string)
     for (this_char = 0; this_char < strlen (fastmap_string); this_char++)\
       correct_fastmap[fastmap_string[this_char]] = !invert;		\
     correct_fastmap['\n'] = match_newline;				\
-  }					
-  
+  }
+
 
 void
 test_fastmap (pat, fastmap_string, invert, match_newline)
@@ -463,7 +463,7 @@ test_fastmap (pat, fastmap_string, invert, match_newline)
     unsigned invert;
     unsigned match_newline;
 {
-  char correct_fastmap[(1 << BYTEWIDTH)];				
+  char correct_fastmap[(1 << BYTEWIDTH)];
 
   SET_FASTMAP ();
   general_test (1, 0, pat, NULL, NULL, -1, 0, -1, correct_fastmap, 0, -1);
@@ -471,25 +471,25 @@ test_fastmap (pat, fastmap_string, invert, match_newline)
 
 
 void
-test_fastmap_search (pat, str, fastmap_string, invert, match_newline, 
+test_fastmap_search (pat, str, fastmap_string, invert, match_newline,
                      can_be_null, start0, end0)
-    const char *pat; 
-    char *str; 
+    const char *pat;
+    char *str;
     char *fastmap_string;
-    unsigned invert; 
-    unsigned match_newline; 
-    int can_be_null; 
-    int start0; 
+    unsigned invert;
+    unsigned match_newline;
+    int can_be_null;
+    int start0;
     int end0;
 {
-  char correct_fastmap[(1 << BYTEWIDTH)];				
+  char correct_fastmap[(1 << BYTEWIDTH)];
   struct re_registers correct_regs;
 
   correct_regs.num_regs = RE_NREGS;
   correct_regs.start = (int *) xmalloc (RE_NREGS * sizeof (int));
   correct_regs.end = (int *) xmalloc (RE_NREGS * sizeof (int));
-  
-  set_all_registers (start0, end0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+
+  set_all_registers (start0, end0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                      -1, -1, -1, -1, -1, -1, -1, -1, &correct_regs);
   SET_FASTMAP ();
   general_test (1, 0, pat, str, NULL, 0, SAFE_STRLEN (str), SAFE_STRLEN (str),
@@ -503,34 +503,34 @@ test_fastmap_search (pat, str, fastmap_string, invert, match_newline,
 
 
 void
-test_all_registers (pat, str1, str2, 
-		    start0, end0, start1, end1, 
-                    start2, end2, start3, end3, 
-                    start4, end4, start5, end5, 
-                    start6, end6, start7, end7, 
+test_all_registers (pat, str1, str2,
+		    start0, end0, start1, end1,
+                    start2, end2, start3, end3,
+                    start4, end4, start5, end5,
+                    start6, end6, start7, end7,
                     start8, end8, start9, end9)
-  char *pat; char *str1; char *str2; 
-  int start0; int end0; int start1; int end1; 
-  int start2; int end2; int start3; int end3; 
-  int start4; int end4; int start5; int end5; 
-  int start6; int end6; int start7; int end7; 
+  char *pat; char *str1; char *str2;
+  int start0; int end0; int start1; int end1;
+  int start2; int end2; int start3; int end3;
+  int start4; int end4; int start5; int end5;
+  int start6; int end6; int start7; int end7;
   int start8; int end8; int start9; int end9;
 {
   struct re_registers correct_regs;
-  
+
   if (omit_register_tests) return;
-  
+
   correct_regs.num_regs = RE_NREGS;
   correct_regs.start = (int *) xmalloc (RE_NREGS * sizeof (int));
   correct_regs.end = (int *) xmalloc (RE_NREGS * sizeof (int));
 
-  set_all_registers (start0, end0, start1, end1, start2, end2, start3, end3, 
-                     start4, end4, start5, end5, start6, end6, start7, end7, 
+  set_all_registers (start0, end0, start1, end1, start2, end2, start3, end3,
+                     start4, end4, start5, end5, start6, end6, start7, end7,
                      start8, end8, start9, end9, &correct_regs);
 
-  general_test (1, 0, pat, str1, str2, 0, 
-	        SAFE_STRLEN (str1) + SAFE_STRLEN (str2), 
-		SAFE_STRLEN (str1) + SAFE_STRLEN (str2), 
+  general_test (1, 0, pat, str1, str2, 0,
+	        SAFE_STRLEN (str1) + SAFE_STRLEN (str2),
+		SAFE_STRLEN (str1) + SAFE_STRLEN (str2),
                 NULL, &correct_regs, -1);
 
   free (correct_regs.start);
@@ -547,8 +547,8 @@ invalid_pattern (error_code_expected, pattern)
   int cflags
     = re_syntax_options == RE_SYNTAX_POSIX_EXTENDED
       || re_syntax_options == RE_SYNTAX_POSIX_MINIMAL_EXTENDED
-      ? REG_EXTENDED : 0; 
-  
+      ? REG_EXTENDED : 0;
+
   test_compile (0, error_code_expected, pattern, &pattern_buffer, cflags);
 }
 
@@ -561,8 +561,8 @@ valid_pattern (pattern)
   int cflags
     = re_syntax_options == RE_SYNTAX_POSIX_EXTENDED
       || re_syntax_options == RE_SYNTAX_POSIX_MINIMAL_EXTENDED
-      ? REG_EXTENDED : 0; 
-  
+      ? REG_EXTENDED : 0;
+
   test_compile (1, 0, pattern, &pattern_buffer, cflags);
 }
 
@@ -578,7 +578,7 @@ delimiters_to_ops (source, left_delimiter, right_delimiter)
   boolean double_size = false;
   unsigned source_char;
   unsigned answer_char = 0;
-  
+
   assert (source != NULL);
 
   switch (left_delimiter)
@@ -608,7 +608,7 @@ delimiters_to_ops (source, left_delimiter, right_delimiter)
       answer = NULL;
     }
 
-  answer = (char *) xmalloc ((double_size 
+  answer = (char *) xmalloc ((double_size
 		             ? strlen (source) << 1
                              : strlen (source))
                             + 1);
@@ -618,7 +618,7 @@ delimiters_to_ops (source, left_delimiter, right_delimiter)
     {
       for (source_char = 0; source_char < strlen (source); source_char++)
         {
-          if (source[source_char] == left_delimiter 
+          if (source[source_char] == left_delimiter
 	      || source[source_char] == right_delimiter)
             answer[answer_char++] = '\\';
 
@@ -626,14 +626,14 @@ delimiters_to_ops (source, left_delimiter, right_delimiter)
         }
       answer[answer_char] = 0;
     }
-    
+
   return answer;
 }
 
 
 void
 print_pattern_info (pattern, pattern_buffer_ptr)
-  const char *pattern; 
+  const char *pattern;
   regex_t *pattern_buffer_ptr;
 {
   printf ("  Pattern:  `%s'.\n", pattern);
@@ -647,13 +647,13 @@ valid_nonposix_pattern (pattern)
   char *pattern;
 {
   struct re_pattern_buffer nonconst_buf;
-  
+
   nonconst_buf.allocated = 0;
   nonconst_buf.buffer = NULL;
   nonconst_buf.translate = NULL;
-  
+
   assert (pattern != NULL);
-  
+
   if (re_compile_pattern (pattern, strlen (pattern), &nonconst_buf))
     {
       printf ("Couldn't compile the pattern.\n");
@@ -667,13 +667,13 @@ compile_and_print_pattern (pattern)
   char *pattern;
 {
   struct re_pattern_buffer nonconst_buf;
-  
+
   nonconst_buf.allocated = 0;
   nonconst_buf.buffer = NULL;
-  
+
   if (re_compile_pattern (pattern, strlen (pattern), &nonconst_buf))
     printf ("Couldn't compile the pattern.\n");
-    
+
   print_pattern_info (pattern, &nonconst_buf);
 }
 
@@ -691,7 +691,7 @@ test_case_fold (pattern, string)
 
   assert (pattern != NULL);
   ret = re_compile_pattern (pattern, strlen (pattern), &nonconst_buf);
-  
+
   if (ret)
     {
       printf ("\nShould have been a valid pattern but wasn't.\n");
@@ -699,8 +699,8 @@ test_case_fold (pattern, string)
     }
   else
     {
-      if (test_should_match 
-          && re_match (&nonconst_buf, string, strlen (string), 0, 0) 
+      if (test_should_match
+          && re_match (&nonconst_buf, string, strlen (string), 0, 0)
              != strlen (string))
        {
          printf ("Match failed for case fold.\n");
@@ -727,7 +727,7 @@ test_match_n_times (n, pattern, string)
   buf.translate = 0;
 
   assert (pattern != NULL);
-  
+
   r = re_compile_pattern (pattern, strlen (pattern), &buf);
   if (r)
     {
@@ -738,14 +738,14 @@ test_match_n_times (n, pattern, string)
     {
       for (this_match = 1; this_match <= n; this_match++)
         match = (re_match (&buf, string, strlen (string),
-                           0, 0) 
+                           0, 0)
 	         == strlen (string));
 
       if (match && !test_should_match)
           printf ("\n\nMatched but shouldn't have:\n");
       else if (!match && test_should_match)
           printf ("\n\nDidn't match but should have:\n");
-      
+
       if ((match && !test_should_match) || (!match && test_should_match))
         {
 	  printf("  The string to match was:  ");
@@ -753,7 +753,7 @@ test_match_n_times (n, pattern, string)
             printf ("`%s' and ", string);
           else
             printf ("`'");
-    
+
           printf ("  Pattern: %s.\n", pattern);
           printf ("  Compiled pattern: %s.\n", pattern);
 	  print_compiled_pattern (&buf);
@@ -762,17 +762,17 @@ test_match_n_times (n, pattern, string)
 }
 
 
-void 
+void
 test_match_2 (pat, str1, str2)
-  const char *pat; 
-  char *str1; 
+  const char *pat;
+  char *str1;
   char *str2;
 {
   general_test (1, 1, pat, str1, str2, 0, 1,
 		  SAFE_STRLEN (str1) + SAFE_STRLEN (str2), NULL, 0, -1);
 }
 
-void 
+void
 test_match (pat, str)
   const char *pat;
   char *str;
diff --git a/gnu/lib/libregex/test/test.h b/gnu/lib/libregex/test/test.h
index fb67126..e367c93 100644
--- a/gnu/lib/libregex/test/test.h
+++ b/gnu/lib/libregex/test/test.h
@@ -39,21 +39,21 @@ extern test_type t;
 
 extern char *concat (char *, char *);
 
-extern void general_test (unsigned pattern_should_be_valid, 
+extern void general_test (unsigned pattern_should_be_valid,
 		          unsigned match_whole_string,
 			  const char *pat, char *str1, char *str2,
-		          int start, int range, int end, 
-              		  char *correct_fastmap, 
+		          int start, int range, int end,
+              		  char *correct_fastmap,
                           struct re_registers *correct_regs, int can_be_null);
 
 
 extern void init_pattern_buffer (regex_t *pattern_buffer_ptr);
 
-extern void test_compile (unsigned valid_pattern, int error_code_expected,  
+extern void test_compile (unsigned valid_pattern, int error_code_expected,
 			  const char *pattern, regex_t *pattern_buffer_ptr,
 			  int cflags);
 
-extern char *delimiter_to_ops (char *source, char left_delimiter, 
+extern char *delimiter_to_ops (char *source, char left_delimiter,
 			       char right_delimiter);
 
 
@@ -61,18 +61,18 @@ extern void test_search_return (int, const char *, char *);
 
 extern void test_berk_search (const char *pattern, char *string);
 
-extern void test_fastmap (const char *pat, char *fastmap_string, unsigned invert, 
+extern void test_fastmap (const char *pat, char *fastmap_string, unsigned invert,
 	    		  unsigned match_newline);
 
 extern void test_fastmap_search (const char *pat, char *str, char *fastmap_string,
-				 unsigned invert, unsigned match_newline, 
+				 unsigned invert, unsigned match_newline,
 		                 int can_be_null, int start0, int end0);
 
-extern void test_all_registers (char *pat, char *str1, char *str2, 
-			       int start0, int end0, int start1, int end1, 
-		               int start2, int end2, int start3, int end3, 
-                	       int start4, int end4, int start5, int end5, 
-	                       int start6, int end6, int start7, int end7, 
+extern void test_all_registers (char *pat, char *str1, char *str2,
+			       int start0, int end0, int start1, int end1,
+		               int start2, int end2, int start3, int end3,
+                	       int start4, int end4, int start5, int end5,
+	                       int start6, int end6, int start7, int end7,
            		       int start8, int end8, int start9, int end9);
 
 extern void print_pattern_info (const char *pattern, regex_t *pattern_buffer_ptr);
diff --git a/gnu/lib/libregex/test/tregress.c b/gnu/lib/libregex/test/tregress.c
index 7858cac..b6aa560 100644
--- a/gnu/lib/libregex/test/tregress.c
+++ b/gnu/lib/libregex/test/tregress.c
@@ -11,7 +11,7 @@ itoa (i)
     int i;
 {
   char *a = xmalloc (21); /* sign + 19 digits (enough for 64 bits) + null */
-  
+
   sprintf (a, "%d", i);
   return a;
 }
@@ -29,7 +29,7 @@ simple_fail (routine, pat, buf, str, ret)
   if (str && *str) fprintf (stderr, "   String = %s\n", str);
   fprintf (stderr, "  Pattern = %s\n", pat);
   print_compiled_pattern (buf);
-  
+
   if (pause_at_error)
     {
       fprintf (stderr, "RET to continue: ");
@@ -46,7 +46,7 @@ simple_compile (pat, buf)
     struct re_pattern_buffer *buf;
 {
   const char *ret = re_compile_pattern (pat, strlen (pat), buf);
-  
+
   if (ret != NULL) simple_fail ("compile", pat, buf, NULL, ret);
 }
 
@@ -58,13 +58,13 @@ simple_fastmap (pat)
   struct re_pattern_buffer buf;
   char fastmap[256];
   int ret;
-  
+
   buf.allocated = 0;
   buf.buffer = buf.translate = NULL;
   buf.fastmap = fastmap;
-  
+
   simple_compile (pat, &buf);
-  
+
   ret = re_compile_fastmap (&buf);
 
   if (ret != 0) simple_fail ("fastmap compile", pat, &buf, NULL, itoa (ret));
@@ -85,13 +85,13 @@ do_match (pat, str, expected)
 
   buf.allocated = 0;
   buf.buffer = buf.translate = buf.fastmap = NULL;
-  
+
   simple_compile (pat, &buf);
 
   len = strlen (str);
-  
+
   ret = re_match_2 (&buf, NULL, 0, str, len, 0, NULL, len);
-  
+
   if (ret != expected) simple_fail ("match", pat, &buf, str, itoa (ret));
 }
 
@@ -107,13 +107,13 @@ simple_search (pat, str, correct_startpos)
 
   buf.allocated = 0;
   buf.buffer = buf.translate = buf.fastmap = NULL;
-  
+
   simple_compile (pat, &buf);
 
   len = strlen (str);
-  
+
   ret = re_search_2 (&buf, NULL, 0, str, len, 0, len, NULL, len);
-  
+
   if (ret != correct_startpos)
     simple_fail ("match", pat, &buf, str, itoa (ret));
 }
@@ -128,8 +128,8 @@ test_regress ()
   unsigned len;
   struct re_registers regs;
   int ret;
-  char *fastmap = xmalloc (256);  
-  
+  char *fastmap = xmalloc (256);
+
   buf.translate = NULL;
   buf.fastmap = NULL;
   buf.allocated = 0;
@@ -145,10 +145,10 @@ test_regress ()
   buf.translate = upcase;
   SIMPLE_MATCH ("[A-[]", "A");
   buf.translate = NULL;
-  
+
   /* meyering@cs.utexas.edu  Nov  6 22:34:41 1992  */
   simple_search ("\\w+", "a", 0);
-   
+
   /* jimb@occs.cs.oberlin.edu  10 Sep 92 00:42:33  */
   buf.translate = upcase;
   SIMPLE_MATCH ("[\001-\377]", "\001");
@@ -158,13 +158,13 @@ test_regress ()
 
   /* mike@skinner.cs.uoregon.edu  1 Sep 92 01:45:22  */
   SIMPLE_MATCH ("^^$", "^");
-  
+
   /* pclink@qld.tne.oz.au  Sep  7 22:42:36 1992  */
   re_set_syntax (RE_INTERVALS);
   SIMPLE_MATCH ("^a\\{3\\}$", "aaa");
   SIMPLE_NONMATCH ("^a\\{3\\}$", "aa");
   re_set_syntax (RE_SYNTAX_EMACS);
-  
+
   /* pclink@qld.tne.oz.au, 31 Aug 92.  (conjecture) */
   re_set_syntax (RE_INTERVALS);
   simple_search ("a\\{1,3\\}b", "aaab", 0);
@@ -173,14 +173,14 @@ test_regress ()
 
   /* trq@dionysos.thphys.ox.ac.uk, 31 Aug 92.  (simplified) */
   simple_fastmap ("^.*\n[  ]*");
-  
+
   /* wind!greg@plains.NoDak.edu, 25 Aug 92.  (simplified) */
   re_set_syntax (RE_INTERVALS);
   SIMPLE_MATCH ("[a-zA-Z]*.\\{5\\}", "xN0000");
   SIMPLE_MATCH ("[a-zA-Z]*.\\{5\\}$", "systemxN0000");
   SIMPLE_MATCH ("\\([a-zA-Z]*\\).\\{5\\}$", "systemxN0000");
   re_set_syntax (RE_SYNTAX_EMACS);
-  
+
   /* jimb, 18 Aug 92.  Don't use \000, so `strlen' (in our testing
      routines) will work.  (This still tickles the bug jimb reported.)  */
   SIMPLE_MATCH ("[\001-\377]", "\001");
@@ -307,7 +307,7 @@ test_regress ()
 
   /* jla's bug (with string-match), 5 Feb 92.  */
   TEST_SEARCH ("\\`[ \t\n]*", "jla@challenger (Joseph Arceneaux)", 0, 100);
-  
+
   /* jwz@lucid.com, 8 March 1992 (re-search-forward).  (His is the
      second.)  These are not supposed to match.  */
 #if 0
@@ -335,7 +335,7 @@ References: <9203080736.AA05869@thalidomide.lucid>\n\
 	<9203081900.AA24794@titanic.lucid>", 0, 5000);
 #endif /* 0 [failed searches] */
 
-  
+
   /* macrakis' bugs.  */
   buf.translate = upcase; /* message of 24 Jan 91 */
   if (re_compile_pattern ("[!-`]", 5, &buf) != NULL)
@@ -355,7 +355,7 @@ References: <9203080736.AA05869@thalidomide.lucid>\n\
     printf ("faofdx test, reg #1 wrong.\n");
   if (regs.start[2] != 1 || regs.end[2] != 2)
     printf ("faofdx test, reg #2 wrong.\n");
-  
+
   TEST_REGISTERS ("\\(a\\)*a", "aaa", 0, 3, 1, 2, -1, -1);
   test_fastmap ("^\\([^ \n]+:\n\\)+\\([^ \n]+:\\)", " \n", 1, 0);
 
@@ -412,7 +412,7 @@ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:");
   /* Dave G. bug: Reference to a subexpression which didn't match.
      Should fail. */
   re_set_syntax (RE_NO_BK_PARENS | RE_NO_BK_VBAR);
-  test_match ("(ooooooooooone())-annnnnnnnnnnd-(twooooooooooo\\2)", 
+  test_match ("(ooooooooooone())-annnnnnnnnnnd-(twooooooooooo\\2)",
                "ooooooooooone-annnnnnnnnnnd-twooooooooooo");
   test_match ("(o|t)", "o");
   test_match ("(o()|t)", "o");
@@ -424,23 +424,23 @@ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:");
   test_match ("(o()|t())-a-(t\\2|f\\3)", "o-a-t");
   test_match ("(o()|t())-a-(t\\2|f\\3)", "t-a-f");
 
-  test_should_match = 0; 
+  test_should_match = 0;
   test_match ("(foo(bar)|second)\\2", "second");
   test_match ("(o()|t())-a-(t\\2|f\\3)", "t-a-t");
   test_match ("(o()|t())-a-(t\\2|f\\3)", "o-a-f");
 
   re_set_syntax (RE_SYNTAX_EMACS);
   test_match ("\\(foo\\(bar\\)\\|second\\)\\2", "secondbar");
-  test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)", 
+  test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)",
 	      "one-and-four");
-  test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)", 
+  test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)",
 	      "two-and-three");
-  
+
   test_should_match = 1;
   re_set_syntax (RE_SYNTAX_EMACS);
-  test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)", 
+  test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)",
 	      "one-and-three");
-  test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)", 
+  test_match ("\\(one\\(\\)\\|two\\(\\)\\)-and-\\(three\\2\\|four\\3\\)",
 	      "two-and-four");
 
   TEST_REGISTERS (":\\(.*\\)", ":/", 0, 2, 1, 2, -1, -1);
diff --git a/gnu/lib/libregex/test/upcase.c b/gnu/lib/libregex/test/upcase.c
index 5147b81..a3c0fbc 100644
--- a/gnu/lib/libregex/test/upcase.c
+++ b/gnu/lib/libregex/test/upcase.c
@@ -1,7 +1,7 @@
 /* Indexed by a character, gives the upper case equivalent of the
    character.  */
 
-char upcase[0400] = 
+char upcase[0400] =
   { 000, 001, 002, 003, 004, 005, 006, 007,
     010, 011, 012, 013, 014, 015, 016, 017,
     020, 021, 022, 023, 024, 025, 026, 027,
diff --git a/gnu/lib/libregex/test/xmalloc.c b/gnu/lib/libregex/test/xmalloc.c
index 88be1a6..aa1c6c4 100644
--- a/gnu/lib/libregex/test/xmalloc.c
+++ b/gnu/lib/libregex/test/xmalloc.c
@@ -9,8 +9,8 @@ void *
 xmalloc (size)
   unsigned size;
 {
-  char *new_mem = malloc (size); 
-  
+  char *new_mem = malloc (size);
+
   if (new_mem == NULL)
     {
       fprintf (stderr, "xmalloc: request for %u bytes failed.\n", size);