From ca094da678c67fad1c30b362aa30cb40d3f84aad Mon Sep 17 00:00:00 2001
From: Jerome Duval <jerome.duval@gmail.com>
Date: Wed, 4 Jun 2014 19:20:57 +0000
Subject: gcc2 patch

[cdesai: update for v2.22]

diff --git a/src/dfa.c b/src/dfa.c
index 856a886..5853c09 100644
--- a/src/dfa.c
+++ b/src/dfa.c
@@ -3481,7 +3481,8 @@ dfainit (struct dfa *d)
 static bool _GL_ATTRIBUTE_PURE
 dfa_supported (struct dfa const *d)
 {
-  for (size_t i = 0; i < d->tindex; i++)
+  size_t i;
+  for (i = 0; i < d->tindex; i++)
     {
       switch (d->tokens[i])
         {
@@ -3934,6 +3935,7 @@ freemust (must *mp)
 struct dfamust *
 dfamust (struct dfa const *d)
 {
+  struct dfamust *dm = NULL;
   must *mp = NULL;
   char const *result = "";
   size_t i;
@@ -3943,8 +3945,10 @@ dfamust (struct dfa const *d)
   bool need_begline = false;
   bool need_endline = false;
   bool case_fold_unibyte = case_fold && MB_CUR_MAX == 1;
+  size_t ri;
+  size_t rj;
 
-  for (size_t ri = 0; ri < d->tindex; ++ri)
+  for (ri = 0; ri < d->tindex; ++ri)
     {
       token t = d->tokens[ri];
       switch (t)
@@ -4119,7 +4123,7 @@ dfamust (struct dfa const *d)
                 }
             }
 
-          size_t rj = ri + 2;
+          rj = ri + 2;
           if (d->tokens[ri + 1] == CAT)
             {
               for (; rj < d->tindex - 1; rj += 2)
@@ -4148,7 +4152,6 @@ dfamust (struct dfa const *d)
     }
  done:;
 
-  struct dfamust *dm = NULL;
   if (*result)
     {
       dm = xmalloc (sizeof *dm);
diff --git a/src/dfasearch.c b/src/dfasearch.c
index de51321..e731b5f 100644
--- a/src/dfasearch.c
+++ b/src/dfasearch.c
@@ -95,11 +95,11 @@ kwsmusts (void)
       /* Prepare a substring whose presence implies a match.
          The kwset matcher will return the index of the matching
          string that it chooses. */
-      ++kwset_exact_matches;
       size_t old_len = strlen (dm->must);
       size_t new_len = old_len + dm->begline + dm->endline;
       char *must = xmalloc (new_len);
       char *mp = must;
+      ++kwset_exact_matches;
       *mp = eolbyte;
       mp += dm->begline;
       begline |= dm->begline;
@@ -122,6 +122,7 @@ kwsmusts (void)
 void
 GEAcompile (char const *pattern, size_t size, reg_syntax_t syntax_bits)
 {
+  char const *p;
   size_t total = size;
   char *motif;
 
@@ -134,9 +135,10 @@ GEAcompile (char const *pattern, size_t size, reg_syntax_t syntax_bits)
      "[\nallo\n]\n", where the patterns are "[", "allo" and "]", and
      this should be a syntax error.  The same for backref, where the
      backref should be local to each pattern.  */
-  char const *p = pattern;
+  p = pattern;
   do
     {
+      char const *err;
       size_t len;
       char const *sep = memchr (p, '\n', total);
       if (sep)
@@ -154,7 +156,7 @@ GEAcompile (char const *pattern, size_t size, reg_syntax_t syntax_bits)
       patterns = xnrealloc (patterns, pcount + 1, sizeof *patterns);
       patterns[pcount] = patterns0;
 
-      char const *err = re_compile_pattern (p, len,
+      err = re_compile_pattern (p, len,
                                             &(patterns[pcount].regexbuf));
       if (err)
         error (EXIT_TROUBLE, 0, "%s", err);
@@ -213,6 +215,7 @@ EGexecute (char const *buf, size_t size, size_t *match_size,
   size_t i;
   struct dfa *superset = dfasuperset (dfa);
   bool dfafast = dfaisfast (dfa);
+  size_t off;
 
   mb_start = buf;
   buflim = buf + size;
@@ -444,7 +447,7 @@ EGexecute (char const *buf, size_t size, size_t *match_size,
  success:
   len = end - beg;
  success_in_len:;
-  size_t off = beg - buf;
+  off = beg - buf;
   *match_size = len;
   return off;
 }
diff --git a/src/dosbuf.c b/src/dosbuf.c
index 0e8f6f7..b7bef57 100644
--- a/src/dosbuf.c
+++ b/src/dosbuf.c
@@ -95,11 +95,11 @@ guess_type (char *buf, size_t buflen)
 static size_t
 undossify_input (char *buf, size_t buflen)
 {
+  size_t bytes_left = 0;
+
   if (! O_BINARY)
     return buflen;
 
-  size_t bytes_left = 0;
-
   if (totalcc == 0)
     {
       /* New file: forget everything we knew about character
@@ -186,12 +186,12 @@ undossify_input (char *buf, size_t buflen)
 static off_t
 dossified_pos (off_t byteno)
 {
-  if (! O_BINARY)
-    return byteno;
-
   off_t pos_lo;
   off_t pos_hi;
 
+  if (! O_BINARY)
+    return byteno;
+
   if (dos_file_type != DOS_TEXT || dos_report_unix_offset)
     return byteno;
 
diff --git a/src/grep.c b/src/grep.c
index 2c5e09a..4f8a3df 100644
--- a/src/grep.c
+++ b/src/grep.c
@@ -497,8 +497,9 @@ static bool easy_encoding;
 static void
 init_easy_encoding (void)
 {
+  int i;
   easy_encoding = true;
-  for (int i = 0; i < HIBYTE; i++)
+  for (i = 0; i < HIBYTE; i++)
     easy_encoding &= mbclen_cache[i] == 1;
 }
 
@@ -527,20 +528,23 @@ typedef uintmax_t uword;
 static char const * _GL_ATTRIBUTE_PURE
 skip_easy_bytes (char const *buf)
 {
+  uword uword_max;
+  uword hibyte_mask;
+  char const *p;
+  uword const *s;
+
   if (!easy_encoding)
     return buf;
 
-  uword uword_max = -1;
+  uword_max = -1;
 
   /* 0x8080..., extended to be wide enough for uword.  */
-  uword hibyte_mask = uword_max / UCHAR_MAX * HIBYTE;
+  hibyte_mask = uword_max / UCHAR_MAX * HIBYTE;
 
   /* Search a byte at a time until the pointer is aligned, then a
      uword at a time until a match is found, then a byte at a time to
      identify the exact byte.  The uword search may go slightly past
      the buffer end, but that's benign.  */
-  char const *p;
-  uword const *s;
   for (p = buf; (uintptr_t) p % sizeof (uword) != 0; p++)
     if (*p & HIBYTE)
       return p;
@@ -597,6 +601,7 @@ file_textbin (char *buf, size_t size, int fd, struct stat const *st)
       /* If the file has holes, it must contain a null byte somewhere.  */
       if (SEEK_HOLE != SEEK_SET && eolbyte)
         {
+          off_t hole_start;
           off_t cur = size;
           if (O_BINARY || fd == STDIN_FILENO)
             {
@@ -606,7 +611,7 @@ file_textbin (char *buf, size_t size, int fd, struct stat const *st)
             }
 
           /* Look for a hole after the current location.  */
-          off_t hole_start = lseek (fd, cur, SEEK_HOLE);
+          hole_start = lseek (fd, cur, SEEK_HOLE);
           if (0 <= hole_start)
             {
               if (lseek (fd, cur, SEEK_SET) < 0)
@@ -697,7 +702,8 @@ add_count (uintmax_t a, uintmax_t b)
 static bool
 all_zeros (char const *buf, size_t size)
 {
-  for (char const *p = buf; p < buf + size; p++)
+  char const *p;
+  for (p = buf; p < buf + size; p++)
     if (*p)
       return false;
   return true;
@@ -1177,11 +1183,13 @@ prtext (char const *beg, char const *lim)
 {
   static bool used;	/* Avoid printing SEP_STR_GROUP before any output.  */
   char eol = eolbyte;
+  char const *p;
+  intmax_t n;
 
   if (!out_quiet && pending > 0)
     prpending (beg);
 
-  char const *p = beg;
+  p = beg;
 
   if (!out_quiet)
     {
@@ -1214,7 +1222,6 @@ prtext (char const *beg, char const *lim)
         }
     }
 
-  intmax_t n;
   if (out_invert)
     {
       /* One or more lines are output.  */
@@ -1275,6 +1282,7 @@ grepbuf (char const *beg, char const *lim)
 
   for (p = beg; p < lim; p = endp)
     {
+      char const *b;
       size_t match_size;
       size_t match_offset = execute (p, lim - p, &match_size, NULL);
       if (match_offset == (size_t) -1)
@@ -1284,7 +1292,7 @@ grepbuf (char const *beg, char const *lim)
           match_offset = lim - p;
           match_size = 0;
         }
-      char const *b = p + match_offset;
+      b = p + match_offset;
       endp = b + match_size;
       /* Avoid matching the empty line at the end of the buffer. */
       if (!out_invert && b == lim)
@@ -2163,6 +2171,8 @@ fgrep_to_grep_pattern (size_t len, char const *keys,
 int
 main (int argc, char **argv)
 {
+  bool status = true;
+  char *const *files;
   char *keys;
   size_t keycc, oldcc, keyalloc;
   bool with_filenames;
@@ -2172,6 +2182,9 @@ main (int argc, char **argv)
   int fread_errno;
   intmax_t default_context;
   FILE *fp;
+  struct stat tmp_stat;
+  char eolbytes[3];
+  size_t match_size;
   exit_failure = EXIT_TROUBLE;
   initialize_main (&argc, &argv);
   set_program_name (argv[0]);
@@ -2533,7 +2546,6 @@ main (int argc, char **argv)
   if (show_help)
     usage (EXIT_SUCCESS);
 
-  struct stat tmp_stat;
   if (fstat (STDOUT_FILENO, &tmp_stat) == 0 && S_ISREG (tmp_stat.st_mode))
     out_stat = tmp_stat;
 
@@ -2585,8 +2597,9 @@ main (int argc, char **argv)
   compile (keys, keycc);
   free (keys);
   /* We need one byte prior and one after.  */
-  char eolbytes[3] = { 0, eolbyte, 0 };
-  size_t match_size;
+  eolbytes[0] = 0;
+  eolbytes[1] = eolbyte;
+  eolbytes[2] = 0;
   skip_empty_lines = ((execute (eolbytes + 1, 1, &match_size, NULL) == 0)
                       == out_invert);
 
@@ -2606,7 +2619,6 @@ main (int argc, char **argv)
   if (fts_options & FTS_LOGICAL && devices == READ_COMMAND_LINE_DEVICES)
     devices = READ_DEVICES;
 
-  char *const *files;
   if (optind < argc)
     {
       files = argv + optind;
@@ -2623,7 +2635,6 @@ main (int argc, char **argv)
       files = stdin_only;
     }
 
-  bool status = true;
   do
     status &= grep_command_line_arg (*files++);
   while (*files != NULL);
diff --git a/src/kwsearch.c b/src/kwsearch.c
index 2997ae1..2b4577b 100644
--- a/src/kwsearch.c
+++ b/src/kwsearch.c
@@ -37,13 +37,14 @@ void
 Fcompile (char const *pattern, size_t size)
 {
   size_t total = size;
+  char const *p = pattern;
 
   kwsinit (&kwset);
 
-  char const *p = pattern;
   do
     {
       size_t len;
+      char *buf = NULL;
       char const *sep = memchr (p, '\n', total);
       if (sep)
         {
@@ -57,7 +58,6 @@ Fcompile (char const *pattern, size_t size)
           total = 0;
         }
 
-      char *buf = NULL;
       if (match_lines)
         {
           buf = xmalloc (len + 2);
@@ -86,6 +86,7 @@ Fexecute (char const *buf, size_t size, size_t *match_size,
   char eol = eolbyte;
   struct kwsmatch kwsmatch;
   size_t ret_val;
+  size_t off;
 
   for (mb_start = beg = start_ptr ? start_ptr : buf; beg <= buf + size; beg++)
     {
@@ -157,7 +158,7 @@ Fexecute (char const *buf, size_t size, size_t *match_size,
   beg = beg ? beg + 1 : buf;
   len = end - beg;
  success_in_beg_and_len:;
-  size_t off = beg - buf;
+  off = beg - buf;
 
   *match_size = len;
   ret_val = off;
diff --git a/src/kwset.c b/src/kwset.c
index ad7a89e..c0f43c8 100644
--- a/src/kwset.c
+++ b/src/kwset.c
@@ -162,6 +162,7 @@ kwsincr (kwset_t kwset, char const *text, size_t len)
      installing new nodes when necessary. */
   while (len--)
     {
+	  int depth = 1;
       unsigned char uc = *--text;
       unsigned char label = trans ? trans[uc] : uc;
 
@@ -173,7 +174,6 @@ kwsincr (kwset_t kwset, char const *text, size_t len)
       enum { L, R } dirs[DEPTH_SIZE];
       links[0] = (struct tree *) &trie->links;
       dirs[0] = L;
-      int depth = 1;
 
       while (link && label != link->label)
         {
@@ -392,10 +392,13 @@ treenext (struct tree const *tree, struct trie *next[])
 void
 kwsprep (kwset_t kwset)
 {
+  struct trie *curr, *last;
   char const *trans = kwset->trans;
   int i;
   unsigned char deltabuf[NCHAR];
   unsigned char *delta = trans ? deltabuf : kwset->delta;
+  struct trie *nextbuf[NCHAR];
+  struct trie **next;
 
   /* Initial values for the delta table; will be changed later.  The
      delta entry for a given character is the smallest depth of any
@@ -404,9 +407,10 @@ kwsprep (kwset_t kwset)
 
   /* Traverse the nodes of the trie in level order, simultaneously
      computing the delta table, failure function, and shift function.  */
-  struct trie *curr, *last;
   for (curr = last = kwset->trie; curr; curr = curr->next)
     {
+      struct trie *fail;
+
       /* Enqueue the immediate descendants in the level order queue.  */
       enqueue (curr->links, &last);
 
@@ -421,7 +425,6 @@ kwsprep (kwset_t kwset)
 
       /* Update the shifts at each node in the current node's chain
          of fails back to the root.  */
-      struct trie *fail;
       for (fail = curr->fail; fail; fail = fail->fail)
         {
           /* If the current node has some outgoing edge that the fail
@@ -451,8 +454,7 @@ kwsprep (kwset_t kwset)
 
   /* Create a vector, indexed by character code, of the outgoing links
      from the root node.  */
-  struct trie *nextbuf[NCHAR];
-  struct trie **next = trans ? nextbuf : kwset->next;
+  next = trans ? nextbuf : kwset->next;
   memset (next, 0, sizeof nextbuf);
   treenext (kwset->trie->links, next);
   if (trans)
@@ -463,6 +465,8 @@ kwsprep (kwset_t kwset)
      of the hairy commentz-walter algorithm. */
   if (kwset->words == 1)
     {
+      char gc1;
+      int gc1help = -1;
       /* Looking for just one string.  Extract it from the trie. */
       kwset->target = obstack_alloc (&kwset->obstack, kwset->mind);
       for (i = kwset->mind - 1, curr = kwset->trie; i >= 0; --i)
@@ -484,11 +488,10 @@ kwsprep (kwset_t kwset)
             }
         }
 
-      char gc1 = tr (trans, kwset->target[kwset->mind - 1]);
+      gc1 = tr (trans, kwset->target[kwset->mind - 1]);
 
       /* Set GC1HELP according to whether exactly one, exactly two, or
          three-or-more characters match GC1.  */
-      int gc1help = -1;
       if (trans)
         {
           char const *equiv1 = memchr (trans, gc1, NCHAR);
@@ -570,13 +573,16 @@ bm_delta2_search (char const **tpp, char const *ep, char const *sp, int len,
 static char const *
 memchr_kwset (char const *s, size_t n, kwset_t kwset)
 {
+  int small_heuristic = 2;
+  int small;
+  size_t ntrans;
+  char const *slim;
   if (kwset->gc1help < 0)
     return memchr (s, kwset->gc1, n);
-  int small_heuristic = 2;
-  int small = (- (uintptr_t) s % sizeof (long)
+  small = (- (uintptr_t) s % sizeof (long)
                + small_heuristic * sizeof (long));
-  size_t ntrans = kwset->gc1help < NCHAR && small < n ? small : n;
-  char const *slim = s + ntrans;
+  ntrans = kwset->gc1help < NCHAR && small < n ? small : n;
+  slim = s + ntrans;
   for (; s < slim; s++)
     if (kwset->trans[U(*s)] == kwset->gc1)
       return s;
@@ -593,6 +599,7 @@ bmexec_trans (kwset_t kwset, char const *text, size_t size)
   int d;
   int len = kwset->mind;
   char const *trans = kwset->trans;
+  char gc1, gc2;
 
   if (len == 0)
     return 0;
@@ -607,8 +614,8 @@ bmexec_trans (kwset_t kwset, char const *text, size_t size)
   d1 = kwset->delta;
   sp = kwset->target + len;
   tp = text + len;
-  char gc1 = kwset->gc1;
-  char gc2 = kwset->gc2;
+  gc1 = kwset->gc1;
+  gc2 = kwset->gc2;
 
   /* Significance of 12: 1 (initial offset) + 10 (skip loop) + 1 (md2). */
   if (size > 12 * len)
@@ -630,12 +637,12 @@ bmexec_trans (kwset_t kwset, char const *text, size_t size)
                 d = d1[U(tp[-1])], tp += d;
                 if (d != 0)
                   {
+                    int advance_heuristic = 16 * sizeof (long);
                     d = d1[U(tp[-1])], tp += d;
                     d = d1[U(tp[-1])], tp += d;
 
                     /* As a heuristic, prefer memchr to seeking by
                        delta1 when the latter doesn't advance much.  */
-                    int advance_heuristic = 16 * sizeof (long);
                     if (advance_heuristic <= tp - tp0)
                       continue;
                     tp--;
diff --git a/src/searchutils.c b/src/searchutils.c
index dd42451..84ba3bd 100644
--- a/src/searchutils.c
+++ b/src/searchutils.c
@@ -272,9 +272,10 @@ mb_goback (char const **mb_start, char const *cur, char const *end)
 wint_t
 mb_prev_wc (char const *buf, char const *cur, char const *end)
 {
+  char const *p;
   if (cur == buf)
     return WEOF;
-  char const *p = buf;
+  p = buf;
   cur--;
   cur -= mb_goback (&p, cur, end);
   return mb_next_wc (cur, end);
-- 
2.2.2

