Rename globals buffer and buffer_size to have G_ prefix

to avoid shadowing local variables.

diff --git a/src/tac.c b/src/tac.c
index 6b166d7d186f38d4b1824ad6f3cd1ee9d221987c..2b59b478bca5a6fe0d19887acffaadd87f7f6726 100644 (file)
--- a/src/tac.c
+++ b/src/tac.c
@@ -90,15 +90,15 @@ static int sentinel_length;
 static int match_length;
 
 /* The input buffer. */
-static char *buffer;
+static char *G_buffer;
 
 /* The number of bytes to read at once into `buffer'. */
 static unsigned read_size;
 
 /* The size of `buffer'.  This is read_size * 2 + sentinel_length + 2.
    The extra 2 bytes allow `past_end' to have a value beyond the
-   end of `buffer' and `match_start' to run off the front of `buffer'. */
-static unsigned buffer_size;
+   end of `G_buffer' and `match_start' to run off the front of `G_buffer'. */
+static unsigned G_buffer_size;
 
 /* The compiled regular expression representing `separator'. */
 static struct re_pattern_buffer compiled_separator;
@@ -258,13 +258,13 @@ output (const char *start, const char *past_end)
 static int
 tac (int fd, const char *file)
 {
-  /* Pointer to the location in `buffer' where the search for
+  /* Pointer to the location in `G_buffer' where the search for
      the next separator will begin. */
   char *match_start;
-  /* Pointer to one past the rightmost character in `buffer' that
+  /* Pointer to one past the rightmost character in `G_buffer' that
      has not been printed yet. */
   char *past_end;
-  unsigned saved_record_size;  /* Length of the record growing in `buffer'. */
+  unsigned saved_record_size;  /* Length of the record growing in `G_buffer'. */
   off_t file_pos;              /* Offset in the file of the next read. */
   /* Nonzero if `output' has not been called yet for any file.
      Only used when the separator is attached to the preceding record. */
@@ -292,33 +292,33 @@ tac (int fd, const char *file)
      in the input file. */
 
   lseek (fd, file_pos, SEEK_SET);
-  if (safe_read (fd, buffer, saved_record_size) != saved_record_size)
+  if (safe_read (fd, G_buffer, saved_record_size) != saved_record_size)
     {
       error (0, errno, "%s", file);
       return 1;
     }
 
-  match_start = past_end = buffer + saved_record_size;
+  match_start = past_end = G_buffer + saved_record_size;
   /* For non-regexp search, move past impossible positions for a match. */
   if (sentinel_length)
     match_start -= match_length1;
 
   for (;;)
     {
-      /* Search backward from `match_start' - 1 to `buffer' for a match
+      /* Search backward from `match_start' - 1 to `G_buffer' for a match
         with `separator'; for speed, use strncmp if `separator' contains no
         metacharacters.
         If the match succeeds, set `match_start' to point to the start of
         the match and `match_length' to the length of the match.
-        Otherwise, make `match_start' < `buffer'. */
+        Otherwise, make `match_start' < `G_buffer'. */
       if (sentinel_length == 0)
        {
-         int i = match_start - buffer;
+         int i = match_start - G_buffer;
          int ret;
 
-         ret = re_search (&compiled_separator, buffer, i, i - 1, -i, &regs);
+         ret = re_search (&compiled_separator, G_buffer, i, i - 1, -i, &regs);
          if (ret == -1)
-           match_start = buffer - 1;
+           match_start = G_buffer - 1;
          else if (ret == -2)
            {
              error (0, 0, _("error in regular expression search"));
@@ -326,7 +326,7 @@ tac (int fd, const char *file)
            }
          else
            {
-             match_start = buffer + regs.start[0];
+             match_start = G_buffer + regs.start[0];
              match_length = regs.end[0] - regs.start[0];
            }
        }
@@ -339,34 +339,34 @@ tac (int fd, const char *file)
            /* Do nothing. */ ;
        }
 
-      /* Check whether we backed off the front of `buffer' without finding
+      /* Check whether we backed off the front of `G_buffer' without finding
          a match for `separator'. */
-      if (match_start < buffer)
+      if (match_start < G_buffer)
        {
          if (file_pos == 0)
            {
              /* Hit the beginning of the file; print the remaining record. */
-             output (buffer, past_end);
+             output (G_buffer, past_end);
              return 0;
            }
 
-         saved_record_size = past_end - buffer;
+         saved_record_size = past_end - G_buffer;
          if (saved_record_size > read_size)
            {
-             /* `buffer_size' is about twice `read_size', so since
+             /* `G_buffer_size' is about twice `read_size', so since
                 we want to read in another `read_size' bytes before
-                the data already in `buffer', we need to increase
-                `buffer_size'. */
+                the data already in `G_buffer', we need to increase
+                `G_buffer_size'. */
              char *newbuffer;
              int offset = sentinel_length ? sentinel_length : 1;
 
              read_size *= 2;
-             buffer_size = read_size * 2 + sentinel_length + 2;
-             newbuffer = xrealloc (buffer - offset, buffer_size) + offset;
+             G_buffer_size = read_size * 2 + sentinel_length + 2;
+             newbuffer = xrealloc (G_buffer - offset, G_buffer_size) + offset;
              /* Adjust the pointers for the new buffer location.  */
-             match_start += newbuffer - buffer;
-             past_end += newbuffer - buffer;
-             buffer = newbuffer;
+             match_start += newbuffer - G_buffer;
+             past_end += newbuffer - G_buffer;
+             G_buffer = newbuffer;
            }
 
          /* Back up to the start of the next bufferfull of the file.  */
@@ -381,15 +381,15 @@ tac (int fd, const char *file)
 
          /* Shift the pending record data right to make room for the new.
             The source and destination regions probably overlap.  */
-         memmove (buffer + read_size, buffer, saved_record_size);
-         past_end = buffer + read_size + saved_record_size;
+         memmove (G_buffer + read_size, G_buffer, saved_record_size);
+         past_end = G_buffer + read_size + saved_record_size;
          /* For non-regexp searches, avoid unneccessary scanning. */
          if (sentinel_length)
-           match_start = buffer + read_size;
+           match_start = G_buffer + read_size;
          else
            match_start = past_end;
 
-         if (safe_read (fd, buffer, read_size) != read_size)
+         if (safe_read (fd, G_buffer, read_size) != read_size)
            {
              error (0, errno, "%s", file);
              return 1;
@@ -468,8 +468,8 @@ save_stdin (void)
       error (0, errno, "%s", tempfile);
       cleanup_fatal ();
     }
-  while ((bytes_read = safe_read (0, buffer, read_size)) > 0)
-    if (full_write (fd, buffer, bytes_read) < 0)
+  while ((bytes_read = safe_read (0, G_buffer, read_size)) > 0)
+    if (full_write (fd, G_buffer, bytes_read) < 0)
       {
        error (0, errno, "%s", tempfile);
        cleanup_fatal ();
@@ -647,15 +647,15 @@ main (int argc, char **argv)
   /* A precaution that will probably never be needed. */
   while (sentinel_length * 2 >= read_size)
     read_size *= 2;
-  buffer_size = read_size * 2 + sentinel_length + 2;
-  buffer = xmalloc (buffer_size);
+  G_buffer_size = read_size * 2 + sentinel_length + 2;
+  G_buffer = xmalloc (G_buffer_size);
   if (sentinel_length)
     {
-      strcpy (buffer, separator);
-      buffer += sentinel_length;
+      strcpy (G_buffer, separator);
+      G_buffer += sentinel_length;
     }
   else
-    ++buffer;
+    ++G_buffer;
 
   if (optind == argc)
     {