Subject: bug#18800: closed (Re: [PATCH 1/2] dfa: prefer bool at DFA interfaces)

From: [email-masked] (GNU bug Tracking System)
Date: Mon, 02 May 2016 06:03:02 +0000

Your bug report

#18800: [PATCH 1/2] dfa: prefer bool at DFA interfaces

which was filed against the grep package, has been closed.

The explanation is attached below, along with your original report.
If you require more details, please reply to [email-masked].

-- 
18800: http://debbugs.gnu.org/cgi/bugreport.cgi?bug=18800
GNU Bug Tracking System
Contact [email-masked] with problems

Subject: Re: [PATCH 1/2] dfa: prefer bool at DFA interfaces
From: Paul Eggert <[email-masked]>
To: [email-masked]
Date: Sun, 1 May 2016 23:02:00 -0700
List-Id: <debbugs-submit.debbugs.gnu.org>

I installed these patches, along with the attached further patch along the same
lines.
>From e5654c5e82a9d412ea3a43c18dd647dce7f96c4d Mon Sep 17 00:00:00 2001
From: Paul Eggert <[email-masked]>
Date: Sun, 1 May 2016 22:55:18 -0700
Subject: [PATCH] dfa: prefer bool for boolean

* src/dfa.c (syntax_bits_set, dfasyntax, using_utf8, FETCH_WC)
(POP_LEX_STATE, State_transition):
* src/dfa.h (using_utf_8):
Use bool for boolean.
---
 src/dfa.c | 13 +++++++------
 src/dfa.h |  2 +-
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/dfa.c b/src/dfa.c
index a2aee29..c57b33a 100644
--- a/src/dfa.c
+++ b/src/dfa.c
@@ -641,7 +641,8 @@ charclass_index (charclass const s)
 }
 
 /* Syntax bits controlling the behavior of the lexical analyzer.  */
-static reg_syntax_t syntax_bits, syntax_bits_set;
+static reg_syntax_t syntax_bits;
+static bool syntax_bits_set;
 
 /* Flag for case-folding letters into sets.  */
 static bool case_fold;
@@ -693,7 +694,7 @@ void
 dfasyntax (reg_syntax_t bits, bool fold, unsigned char eol)
 {
   int i;
-  syntax_bits_set = 1;
+  syntax_bits_set = true;
   syntax_bits = bits;
   case_fold = fold;
   eolbyte = eol;
@@ -757,7 +758,7 @@ setbit_case_fold_c (int b, charclass c)
 
 /* UTF-8 encoding allows some optimizations that we can't otherwise
    assume in a multibyte encoding.  */
-int
+bool
 using_utf8 (void)
 {
   static int utf8 = -1;
@@ -858,7 +859,7 @@ static wint_t wctok;		/* Wide character representation of the current
         lexptr += nbytes;			\
         lexleft -= nbytes;			\
       }						\
-  } while (0)
+  } while (false)
 
 #ifndef MIN
 # define MIN(a,b) ((a) < (b) ? (a) : (b))
@@ -1211,7 +1212,7 @@ parse_bracket_exp (void)
       lexptr = lexptr_saved;			\
       lexleft = lexleft_saved;			\
     }						\
-  while (0)
+  while (false)
 
 static token
 lex (void)
@@ -3327,7 +3328,7 @@ dfaexec_main (struct dfa *d, char const *begin, char *end, bool allow_nl,
                                                                         \
               mbp = p;                                                  \
               trans = d->trans;                                         \
-  } while (0)
+  } while (false)
 
               State_transition();
             }
diff --git a/src/dfa.h b/src/dfa.h
index ce267ec..60da0e4 100644
--- a/src/dfa.h
+++ b/src/dfa.h
@@ -100,4 +100,4 @@ extern void dfawarn (const char *);
    The user must supply a dfaerror.  */
 extern _Noreturn void dfaerror (const char *);
 
-extern int using_utf8 (void);
+extern bool using_utf8 (void);
-- 
2.5.5

Subject: [PATCH 1/2] dfa: prefer bool at DFA interfaces
From: Norihiro Tanaka <[email-masked]>
To: [email-masked]
Date: Thu, 23 Oct 2014 08:02:49 +0900
List-Id: <debbugs-submit.debbugs.gnu.org>

This change is use bool for booleans at DFA interfaces.  Callers in Gawk
have already used bool instead of int for them.  Second patch changes
caller with change in first patch.
From 43297a649ff42404261ab1e16d4d04101af8fde4 Mon Sep 17 00:00:00 2001
From: Norihiro Tanaka <[email-masked]>
Date: Sat, 18 Oct 2014 23:57:33 +0900
Subject: [PATCH 1/2] dfa: prefer bool at DFA interfaces

* (src/dfa.c) dfasyntax: Use bool for `fold'.
dfaanalyze, dfacomp: Use bool for `searchflag'.
dfaexec_main, dfaexec_mb, dfaexec_sb, dfaexec: IUse bool for `allow_nl'.
* (src/dfa.h): Update prototype.
---
 src/dfa.c | 18 +++++++++---------
 src/dfa.h |  8 ++++----
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/dfa.c b/src/dfa.c
index 58a4b83..f0dc74c 100644
--- a/src/dfa.c
+++ b/src/dfa.c
@@ -720,13 +720,13 @@ wchar_context (wint_t wc)
 
 /* Entry point to set syntax options.  */
 void
-dfasyntax (reg_syntax_t bits, int fold, unsigned char eol)
+dfasyntax (reg_syntax_t bits, bool fold, unsigned char eol)
 {
   unsigned int i;
 
   syntax_bits_set = 1;
   syntax_bits = bits;
-  case_fold = fold != 0;
+  case_fold = fold;
   eolbyte = eol;
 
   for (i = 0; i < NOTCHAR; ++i)
@@ -2320,7 +2320,7 @@ state_separate_contexts (position_set const *s)
    scheme; the number of elements in each set deeper in the stack can be
    used to determine the address of a particular set's array.  */
 void
-dfaanalyze (struct dfa *d, int searchflag)
+dfaanalyze (struct dfa *d, bool searchflag)
 {
   /* Array allocated to hold position sets.  */
   position *posalloc = xnmalloc (d->nleaves, 2 * sizeof *posalloc);
@@ -2356,7 +2356,7 @@ dfaanalyze (struct dfa *d, int searchflag)
   putc ('\n', stderr);
 #endif
 
-  d->searchflag = searchflag != 0;
+  d->searchflag = searchflag;
   alloc_position_set (&merged, d->nleaves);
   d->follows = xcalloc (d->tindex, sizeof *d->follows);
 
@@ -3276,7 +3276,7 @@ skip_remains_mb (struct dfa *d, unsigned char const *p,
    characters.  */
 static inline char *
 dfaexec_main (struct dfa *d, char const *begin, char *end,
-             int allow_nl, size_t *count, int *backref, bool multibyte)
+             bool allow_nl, size_t *count, int *backref, bool multibyte)
 {
   state_num s, s1;              /* Current state.  */
   unsigned char const *p, *mbp; /* Current input character.  */
@@ -3466,14 +3466,14 @@ dfaexec_main (struct dfa *d, char const *begin, char *end,
 
 static char *
 dfaexec_mb (struct dfa *d, char const *begin, char *end,
-            int allow_nl, size_t *count, int *backref)
+            bool allow_nl, size_t *count, int *backref)
 {
   return dfaexec_main (d, begin, end, allow_nl, count, backref, true);
 }
 
 static char *
 dfaexec_sb (struct dfa *d, char const *begin, char *end,
-            int allow_nl, size_t *count, int *backref)
+            bool allow_nl, size_t *count, int *backref)
 {
   return dfaexec_main (d, begin, end, allow_nl, count, backref, false);
 }
@@ -3483,7 +3483,7 @@ dfaexec_sb (struct dfa *d, char const *begin, char *end,
 
 char *
 dfaexec (struct dfa *d, char const *begin, char *end,
-         int allow_nl, size_t *count, int *backref)
+         bool allow_nl, size_t *count, int *backref)
 {
   return d->dfaexec (d, begin, end, allow_nl, count, backref);
 }
@@ -3663,7 +3663,7 @@ dfassbuild (struct dfa *d)
 
 /* Parse and analyze a single string of the given length.  */
 void
-dfacomp (char const *s, size_t len, struct dfa *d, int searchflag)
+dfacomp (char const *s, size_t len, struct dfa *d, bool searchflag)
 {
   dfainit (d);
   dfambcache (d);
diff --git a/src/dfa.h b/src/dfa.h
index f30c3cb..ab2e8ea 100644
--- a/src/dfa.h
+++ b/src/dfa.h
@@ -49,12 +49,12 @@ extern struct dfamust *dfamusts (struct dfa const *);
 /* dfasyntax() takes three arguments; the first sets the syntax bits described
    earlier in this file, the second sets the case-folding flag, and the
    third specifies the line terminator. */
-extern void dfasyntax (reg_syntax_t, int, unsigned char);
+extern void dfasyntax (reg_syntax_t, bool, unsigned char);
 
 /* Compile the given string of the given length into the given struct dfa.
    Final argument is a flag specifying whether to build a searching or an
    exact matcher. */
-extern void dfacomp (char const *, size_t, struct dfa *, int);
+extern void dfacomp (char const *, size_t, struct dfa *, bool);
 
 /* Search through a buffer looking for a match to the given struct dfa.
    Find the first occurrence of a string matching the regexp in the
@@ -63,13 +63,13 @@ extern void dfacomp (char const *, size_t, struct dfa *, int);
    points to the beginning of the buffer, and END points to the first byte
    after its end.  Note however that we store a sentinel byte (usually
    newline) in *END, so the actual buffer must be one byte longer.
-   When NEWLINE is nonzero, newlines may appear in the matching string.
+   When ALLOW_NL is true, newlines may appear in the matching string.
    If COUNT is non-NULL, increment *COUNT once for each newline processed.
    Finally, if BACKREF is non-NULL set *BACKREF to indicate whether we
    encountered a back-reference (1) or not (0).  The caller may use this
    to decide whether to fall back on a backtracking matcher. */
 extern char *dfaexec (struct dfa *d, char const *begin, char *end,
-                      int newline, size_t *count, int *backref);
+                      bool allow_nl, size_t *count, int *backref);
 
 /* Return a superset for D.  The superset matches everything that D
    matches, along with some other strings (though the latter should be
-- 
2.1.1

From 8db86d864616316ac534d47c0a876c45c1aaeebd Mon Sep 17 00:00:00 2001
From: Norihiro Tanaka <[email-masked]>
Date: Thu, 23 Oct 2014 07:50:15 +0900
Subject: [PATCH 2/2] grep: change caller for previous change

* (src/dfasearch.c) GEAcompile: Use bool for boolean.
---
 src/dfasearch.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/dfasearch.c b/src/dfasearch.c
index 77b4e3e..d667470 100644
--- a/src/dfasearch.c
+++ b/src/dfasearch.c
@@ -199,7 +199,7 @@ GEAcompile (char const *pattern, size_t size, reg_syntax_t syntax_bits)
     motif = NULL;
 
   dfa = dfaalloc ();
-  dfacomp (pattern, size, dfa, 1);
+  dfacomp (pattern, size, dfa, true);
   kwsmusts ();
 
   free(motif);
@@ -287,8 +287,8 @@ EGexecute (char const *buf, size_t size, size_t *match_size,
               /* Keep using the superset while it reports multiline
                  potential matches; this is more likely to be fast
                  than falling back to KWset would be.  */
-              while ((next_beg = dfaexec (superset, dfa_beg, (char *) end, 1,
-                                          &count, NULL))
+              while ((next_beg = dfaexec (superset, dfa_beg, (char *) end,
+                                          true, &count, NULL))
                      && next_beg != end
                      && count != 0)
                 {
@@ -307,7 +307,8 @@ EGexecute (char const *buf, size_t size, size_t *match_size,
             }
 
           /* Try matching with DFA.  */
-          next_beg = dfaexec (dfa, dfa_beg, (char *) end, 0, &count, &backref);
+          next_beg = dfaexec (dfa, dfa_beg, (char *) end, false, &count,
+                              &backref);
 
           /* If there's no match, or if we've matched the sentinel,
              we're done.  */
-- 
2.1.1