Remove information about the authors from the source files.

(This information could be observed via "git log" or by looking into
the original version of a file.)

* Makefile.am: Remove original-author and modified-by information
(as well as a time-stamp) from the file header.
* configure.ac: Ditto.
* cord/cordbscs.c: Ditto.
* cord/cordprnt.c: Ditto.
* cord/cordxtra.c: Ditto.
* cord/de.c: Ditto.
* cord/de_cmds.h: Ditto.
* cord/de_win.h: Ditto.
* doc/README.arm.cross: Ditto.
* doc/doc.am: Ditto.
* dyn_load.c: Ditto.
* gc_cpp.cc: Ditto.
* gc_dlopen.c: Ditto.
* include/cord.h: Ditto.
* include/include.am: Ditto.
* include/private/cord_pos.h: Ditto.
* include/private/gc_hdrs.h: Ditto.
* include/weakpointer.h: Ditto.
* m4/gc_set_version.m4: Ditto.
* tests/test_cpp.cc: Ditto.
* cord/cordprnt.c: Fix a typo in a comment.
* AUTHORS: Add authors.
* cord/cordprnt.c: Expand all tabs to spaces; remove trailing spaces
at EOLn.
* cord/de.c: Ditto.
* cord/de_cmds.h: Ditto.
* cord/de_win.c: Ditto.
* cord/de_win.h: Ditto.
* doc/README.arm.cross: Ditto.
* include/private/cord_pos.h: Ditto.
* include/weakpointer.h: Ditto.
* m4/gc_set_version.m4: Ditto.

1 files changed, 249 insertions, 250 deletions

diff --git a/cord/cordprnt.c b/cord/cordprnt.c
index 6d278fed..fe4aea1a 100644
--- a/cord/cordprnt.c
+++ b/cord/cordprnt.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
  *
  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
@@ -10,17 +10,16 @@
  * provided the above notices are retained, and a notice that the code was
  * modified is included with the above copyright notice.
  */
-/* An sprintf implementation that understands cords.  This is probably	*/
-/* not terribly portable.  It assumes an ANSI stdarg.h.  It further	*/
-/* assumes that I can make copies of va_list variables, and read 	*/
-/* arguments repeatedly by applyting va_arg to the copies.  This	*/
-/* could be avoided at some performance cost.				*/
-/* We also assume that unsigned and signed integers of various kinds	*/
-/* have the same sizes, and can be cast back and forth.			*/
-/* We assume that void * and char * have the same size.			*/
-/* All this cruft is needed because we want to rely on the underlying	*/
-/* sprintf implementation whenever possible.				*/
-/* Boehm, September 21, 1995 6:00 pm PDT */
+/* An sprintf implementation that understands cords.  This is probably  */
+/* not terribly portable.  It assumes an ANSI stdarg.h.  It further     */
+/* assumes that I can make copies of va_list variables, and read        */
+/* arguments repeatedly by applying va_arg to the copies.  This         */
+/* could be avoided at some performance cost.                           */
+/* We also assume that unsigned and signed integers of various kinds    */
+/* have the same sizes, and can be cast back and forth.                 */
+/* We assume that void * and char * have the same size.                 */
+/* All this cruft is needed because we want to rely on the underlying   */
+/* sprintf implementation whenever possible.                            */
 
 #include "cord.h"
 #include "ec.h"
@@ -29,11 +28,11 @@
 #include <string.h>
 #include "gc.h"
 
-#define CONV_SPEC_LEN 50	/* Maximum length of a single	*/
-				/* conversion specification.	*/
-#define CONV_RESULT_LEN 50	/* Maximum length of any 	*/
-				/* conversion with default	*/
-				/* width and prec.		*/
+#define CONV_SPEC_LEN 50        /* Maximum length of a single   */
+                                /* conversion specification.    */
+#define CONV_RESULT_LEN 50      /* Maximum length of any        */
+                                /* conversion with default      */
+                                /* width and prec.              */
 
 
 static int ec_len(CORD_ec x)
@@ -41,20 +40,20 @@ static int ec_len(CORD_ec x)
     return(CORD_len(x[0].ec_cord) + (x[0].ec_bufptr - x[0].ec_buf));
 }
 
-/* Possible nonumeric precision values.	*/
+/* Possible nonumeric precision values. */
 # define NONE -1
 # define VARIABLE -2
-/* Copy the conversion specification from CORD_pos into the buffer buf	*/
-/* Return negative on error.						*/
-/* Source initially points one past the leading %.			*/
-/* It is left pointing at the conversion type.				*/
-/* Assign field width and precision to *width and *prec.		*/
-/* If width or prec is *, VARIABLE is assigned.				*/
-/* Set *left to 1 if left adjustment flag is present.			*/
-/* Set *long_arg to 1 if long flag ('l' or 'L') is present, or to	*/
-/* -1 if 'h' is present.						*/
+/* Copy the conversion specification from CORD_pos into the buffer buf  */
+/* Return negative on error.                                            */
+/* Source initially points one past the leading %.                      */
+/* It is left pointing at the conversion type.                          */
+/* Assign field width and precision to *width and *prec.                */
+/* If width or prec is *, VARIABLE is assigned.                         */
+/* Set *left to 1 if left adjustment flag is present.                   */
+/* Set *long_arg to 1 if long flag ('l' or 'L') is present, or to       */
+/* -1 if 'h' is present.                                                */
 static int extract_conv_spec(CORD_pos source, char *buf,
-			     int * width, int *prec, int *left, int * long_arg)
+                             int * width, int *prec, int *left, int * long_arg)
 {
     register int result = 0;
     register int current_number = 0;
@@ -62,7 +61,7 @@ static int extract_conv_spec(CORD_pos source, char *buf,
     register int saw_number = 0;
     register int chars_so_far = 0;
     register char current;
-    
+
     *width = NONE;
     buf[chars_so_far++] = '%';
     while(CORD_pos_valid(source)) {
@@ -70,73 +69,73 @@ static int extract_conv_spec(CORD_pos source, char *buf,
         current = CORD_pos_fetch(source);
         buf[chars_so_far++] = current;
         switch(current) {
-	  case '*':
-	    saw_number = 1;
-	    current_number = VARIABLE;
-	    break;
+          case '*':
+            saw_number = 1;
+            current_number = VARIABLE;
+            break;
           case '0':
             if (!saw_number) {
                 /* Zero fill flag; ignore */
                 break;
             } /* otherwise fall through: */
           case '1':
-	  case '2':
-	  case '3':
-	  case '4':
-	  case '5':
+          case '2':
+          case '3':
+          case '4':
+          case '5':
           case '6':
-	  case '7':
-	  case '8':
-	  case '9':
-	    saw_number = 1;
-	    current_number *= 10;
-	    current_number += current - '0';
-	    break;
-	  case '.':
-	    saw_period = 1;
-	    if(saw_number) {
-	        *width = current_number;
-	        saw_number = 0;
-	    }
-	    current_number = 0;
-	    break;
-	  case 'l':
-	  case 'L':
-	    *long_arg = 1;
-	    current_number = 0;
-	    break;
-	  case 'h':
-	    *long_arg = -1;
-	    current_number = 0;
-	    break;
-	  case ' ':
-	  case '+':
-	  case '#':
-	    current_number = 0;
-	    break;
-	  case '-':
-	    *left = 1;
-	    current_number = 0;
-	    break;
-	  case 'd':
-	  case 'i':
-	  case 'o':
-	  case 'u':
-	  case 'x':
-	  case 'X':
-	  case 'f':
-	  case 'e':
-	  case 'E':
-	  case 'g':
-	  case 'G':
-	  case 'c':
-	  case 'C':
-	  case 's':
-	  case 'S':
-	  case 'p':
-	  case 'n':
-	  case 'r':
-	    goto done;          
+          case '7':
+          case '8':
+          case '9':
+            saw_number = 1;
+            current_number *= 10;
+            current_number += current - '0';
+            break;
+          case '.':
+            saw_period = 1;
+            if(saw_number) {
+                *width = current_number;
+                saw_number = 0;
+            }
+            current_number = 0;
+            break;
+          case 'l':
+          case 'L':
+            *long_arg = 1;
+            current_number = 0;
+            break;
+          case 'h':
+            *long_arg = -1;
+            current_number = 0;
+            break;
+          case ' ':
+          case '+':
+          case '#':
+            current_number = 0;
+            break;
+          case '-':
+            *left = 1;
+            current_number = 0;
+            break;
+          case 'd':
+          case 'i':
+          case 'o':
+          case 'u':
+          case 'x':
+          case 'X':
+          case 'f':
+          case 'e':
+          case 'E':
+          case 'g':
+          case 'G':
+          case 'c':
+          case 'C':
+          case 's':
+          case 'S':
+          case 'p':
+          case 'n':
+          case 'r':
+            goto done;
           default:
             return(-1);
         }
@@ -145,14 +144,14 @@ static int extract_conv_spec(CORD_pos source, char *buf,
     return(-1);
   done:
     if (saw_number) {
-    	if (saw_period) {
-    	    *prec = current_number;
-    	} else {
-    	    *prec = NONE;
-    	    *width = current_number;
-    	}
+        if (saw_period) {
+            *prec = current_number;
+        } else {
+            *prec = NONE;
+            *width = current_number;
+        }
     } else {
-    	*prec = NONE;
+        *prec = NONE;
     }
     buf[chars_so_far] = '\0';
     return(result);
@@ -165,168 +164,168 @@ int CORD_vsprintf(CORD * out, CORD format, va_list args)
     register char current;
     CORD_pos pos;
     char conv_spec[CONV_SPEC_LEN + 1];
-    
+
     CORD_ec_init(result);
     for (CORD_set_pos(pos, format, 0); CORD_pos_valid(pos); CORD_next(pos)) {
-       	current = CORD_pos_fetch(pos);
-       	if (current == '%') {
+        current = CORD_pos_fetch(pos);
+        if (current == '%') {
             CORD_next(pos);
             if (!CORD_pos_valid(pos)) return(-1);
             current = CORD_pos_fetch(pos);
             if (current == '%') {
-               	CORD_ec_append(result, current);
+                CORD_ec_append(result, current);
             } else {
-             	int width, prec;
-             	int left_adj = 0;
-             	int long_arg = 0;
-		CORD arg;
-		size_t len;
-               
-              	if (extract_conv_spec(pos, conv_spec,
-              			      &width, &prec,
-              			      &left_adj, &long_arg) < 0) {
-              	    return(-1);
-              	}
-              	current = CORD_pos_fetch(pos);
-            	switch(current) {
-            	    case 'n':
-            	    	/* Assign length to next arg */
-            	    	if (long_arg == 0) {
-            	    	    int * pos_ptr;
-            	    	    pos_ptr = va_arg(args, int *);
-            	    	    *pos_ptr = ec_len(result);
-            	    	} else if (long_arg > 0) {
-            	    	    long * pos_ptr;
-            	    	    pos_ptr = va_arg(args, long *);
-            	    	    *pos_ptr = ec_len(result);
-            	    	} else {
-            	    	    short * pos_ptr;
-            	    	    pos_ptr = va_arg(args, short *);
-            	    	    *pos_ptr = ec_len(result);
-            	    	}
-            	    	goto done;
-            	    case 'r':
-            	    	/* Append cord and any padding	*/
-            	    	if (width == VARIABLE) width = va_arg(args, int);
-            	    	if (prec == VARIABLE) prec = va_arg(args, int);
-			arg = va_arg(args, CORD);
-			len = CORD_len(arg);
-			if (prec != NONE && len > prec) {
-			  if (prec < 0) return(-1);
-			  arg = CORD_substr(arg, 0, prec);
-			  len = prec;
-			}
-			if (width != NONE && len < width) {
-			  char * blanks = GC_MALLOC_ATOMIC(width-len+1);
+                int width, prec;
+                int left_adj = 0;
+                int long_arg = 0;
+                CORD arg;
+                size_t len;
+
+                if (extract_conv_spec(pos, conv_spec,
+                                      &width, &prec,
+                                      &left_adj, &long_arg) < 0) {
+                    return(-1);
+                }
+                current = CORD_pos_fetch(pos);
+                switch(current) {
+                    case 'n':
+                        /* Assign length to next arg */
+                        if (long_arg == 0) {
+                            int * pos_ptr;
+                            pos_ptr = va_arg(args, int *);
+                            *pos_ptr = ec_len(result);
+                        } else if (long_arg > 0) {
+                            long * pos_ptr;
+                            pos_ptr = va_arg(args, long *);
+                            *pos_ptr = ec_len(result);
+                        } else {
+                            short * pos_ptr;
+                            pos_ptr = va_arg(args, short *);
+                            *pos_ptr = ec_len(result);
+                        }
+                        goto done;
+                    case 'r':
+                        /* Append cord and any padding  */
+                        if (width == VARIABLE) width = va_arg(args, int);
+                        if (prec == VARIABLE) prec = va_arg(args, int);
+                        arg = va_arg(args, CORD);
+                        len = CORD_len(arg);
+                        if (prec != NONE && len > prec) {
+                          if (prec < 0) return(-1);
+                          arg = CORD_substr(arg, 0, prec);
+                          len = prec;
+                        }
+                        if (width != NONE && len < width) {
+                          char * blanks = GC_MALLOC_ATOMIC(width-len+1);
 
-			  memset(blanks, ' ', width-len);
-			  blanks[width-len] = '\0';
-			  if (left_adj) {
-			    arg = CORD_cat(arg, blanks);
-			  } else {
-			    arg = CORD_cat(blanks, arg);
-			  }
-			}
-			CORD_ec_append_cord(result, arg);
-            	    	goto done;
-		    case 'c':
-			if (width == NONE && prec == NONE) {
-			    register char c;
+                          memset(blanks, ' ', width-len);
+                          blanks[width-len] = '\0';
+                          if (left_adj) {
+                            arg = CORD_cat(arg, blanks);
+                          } else {
+                            arg = CORD_cat(blanks, arg);
+                          }
+                        }
+                        CORD_ec_append_cord(result, arg);
+                        goto done;
+                    case 'c':
+                        if (width == NONE && prec == NONE) {
+                            register char c;
 
-			    c = (char)va_arg(args, int);
-			    CORD_ec_append(result, c);
-			    goto done;
-			}
-			break;
-		    case 's':
-		        if (width == NONE && prec == NONE) {
-			    char * str = va_arg(args, char *);
-			    register char c;
+                            c = (char)va_arg(args, int);
+                            CORD_ec_append(result, c);
+                            goto done;
+                        }
+                        break;
+                    case 's':
+                        if (width == NONE && prec == NONE) {
+                            char * str = va_arg(args, char *);
+                            register char c;
 
-			    while ((c = *str++)) {
-			        CORD_ec_append(result, c);
-			    }
-			    goto done;
-			}
-			break;
-            	    default:
-            	        break;
-            	}
-            	/* Use standard sprintf to perform conversion */
-            	{
-            	    register char * buf;
-            	    va_list vsprintf_args;
-            	    int max_size = 0;
-            	    int res;
-#		    ifdef __va_copy
+                            while ((c = *str++)) {
+                                CORD_ec_append(result, c);
+                            }
+                            goto done;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                /* Use standard sprintf to perform conversion */
+                {
+                    register char * buf;
+                    va_list vsprintf_args;
+                    int max_size = 0;
+                    int res;
+#                   ifdef __va_copy
                       __va_copy(vsprintf_args, args);
-#		    else
-#		      if defined(__GNUC__) && !defined(__DJGPP__) /* and probably in other cases */
+#                   else
+#                     if defined(__GNUC__) && !defined(__DJGPP__) /* and probably in other cases */
                         va_copy(vsprintf_args, args);
-#		      else
-			vsprintf_args = args;
-#		      endif
-#		    endif
-            	    if (width == VARIABLE) width = va_arg(args, int);
-            	    if (prec == VARIABLE) prec = va_arg(args, int);
-            	    if (width != NONE) max_size = width;
-            	    if (prec != NONE && prec > max_size) max_size = prec;
-            	    max_size += CONV_RESULT_LEN;
-            	    if (max_size >= CORD_BUFSZ) {
-            	        buf = GC_MALLOC_ATOMIC(max_size + 1);
-            	    } else {
-            	        if (CORD_BUFSZ - (result[0].ec_bufptr-result[0].ec_buf)
-            	            < max_size) {
-            	            CORD_ec_flush_buf(result);
-            	        }
-            	        buf = result[0].ec_bufptr;
-            	    }
-            	    switch(current) {
-            	        case 'd':
-            	        case 'i':
-            	        case 'o':
-            	        case 'u':
-            	        case 'x':
-            	        case 'X':
-            	        case 'c':
-            	            if (long_arg <= 0) {
-            	              (void) va_arg(args, int);
-            	            } else if (long_arg > 0) {
-            	              (void) va_arg(args, long);
-            	            }
-            	            break;
-            	        case 's':
-            	        case 'p':
-            	            (void) va_arg(args, char *);
-            	            break;
-            	        case 'f':
-            	        case 'e':
-            	        case 'E':
-            	        case 'g':
-            	        case 'G':
-            	            (void) va_arg(args, double);
-            	            break;
-            	        default:
-            	            return(-1);
-            	    }
-            	    res = vsprintf(buf, conv_spec, vsprintf_args);
-            	    len = (size_t)res;
-            	    if ((char *)(GC_word)res == buf) {
-            	    	/* old style vsprintf */
-            	    	len = strlen(buf);
-            	    } else if (res < 0) {
-            	        return(-1);
-            	    }
-            	    if (buf != result[0].ec_bufptr) {
-            	        register char c;
+#                     else
+                        vsprintf_args = args;
+#                     endif
+#                   endif
+                    if (width == VARIABLE) width = va_arg(args, int);
+                    if (prec == VARIABLE) prec = va_arg(args, int);
+                    if (width != NONE) max_size = width;
+                    if (prec != NONE && prec > max_size) max_size = prec;
+                    max_size += CONV_RESULT_LEN;
+                    if (max_size >= CORD_BUFSZ) {
+                        buf = GC_MALLOC_ATOMIC(max_size + 1);
+                    } else {
+                        if (CORD_BUFSZ - (result[0].ec_bufptr-result[0].ec_buf)
+                            < max_size) {
+                            CORD_ec_flush_buf(result);
+                        }
+                        buf = result[0].ec_bufptr;
+                    }
+                    switch(current) {
+                        case 'd':
+                        case 'i':
+                        case 'o':
+                        case 'u':
+                        case 'x':
+                        case 'X':
+                        case 'c':
+                            if (long_arg <= 0) {
+                              (void) va_arg(args, int);
+                            } else if (long_arg > 0) {
+                              (void) va_arg(args, long);
+                            }
+                            break;
+                        case 's':
+                        case 'p':
+                            (void) va_arg(args, char *);
+                            break;
+                        case 'f':
+                        case 'e':
+                        case 'E':
+                        case 'g':
+                        case 'G':
+                            (void) va_arg(args, double);
+                            break;
+                        default:
+                            return(-1);
+                    }
+                    res = vsprintf(buf, conv_spec, vsprintf_args);
+                    len = (size_t)res;
+                    if ((char *)(GC_word)res == buf) {
+                        /* old style vsprintf */
+                        len = strlen(buf);
+                    } else if (res < 0) {
+                        return(-1);
+                    }
+                    if (buf != result[0].ec_bufptr) {
+                        register char c;
 
-			while ((c = *buf++)) {
-			    CORD_ec_append(result, c);
-		        }
-		    } else {
-		        result[0].ec_bufptr = buf + len;
-		    }
-            	}
+                        while ((c = *buf++)) {
+                            CORD_ec_append(result, c);
+                        }
+                    } else {
+                        result[0].ec_bufptr = buf + len;
+                    }
+                }
               done:;
             }
         } else {
@@ -342,7 +341,7 @@ int CORD_sprintf(CORD * out, CORD format, ...)
 {
     va_list args;
     int result;
-    
+
     va_start(args, format);
     result = CORD_vsprintf(out, format, args);
     va_end(args);
@@ -354,7 +353,7 @@ int CORD_fprintf(FILE * f, CORD format, ...)
     va_list args;
     int result;
     CORD out;
-    
+
     va_start(args, format);
     result = CORD_vsprintf(&out, format, args);
     va_end(args);
@@ -366,7 +365,7 @@ int CORD_vfprintf(FILE * f, CORD format, va_list args)
 {
     int result;
     CORD out;
-    
+
     result = CORD_vsprintf(&out, format, args);
     if (result > 0) CORD_put(out, f);
     return(result);
@@ -377,7 +376,7 @@ int CORD_printf(CORD format, ...)
     va_list args;
     int result;
     CORD out;
-    
+
     va_start(args, format);
     result = CORD_vsprintf(&out, format, args);
     va_end(args);
@@ -389,7 +388,7 @@ int CORD_vprintf(CORD format, va_list args)
 {
     int result;
     CORD out;
-    
+
     result = CORD_vsprintf(&out, format, args);
     if (result > 0) CORD_put(out, stdout);
     return(result);