Add query to find number of subexpressions.

This was convenient for me to have without being forced
to parse the regexp myself. I'd understand if it's not
really wanted, but I also think that some meta information
about compiled regexps would be fine.

R=r, rsc
CC=golang-dev
https://golang.org/cl/183044

diff --git a/src/pkg/regexp/all_test.go b/src/pkg/regexp/all_test.go
index 0c274139b687e891ea8ab6c8fa1afc228d8a993c..05bba73765ed23d3768f4f52b7d0be86c9e0d9a5 100644 (file)
--- a/src/pkg/regexp/all_test.go
+++ b/src/pkg/regexp/all_test.go
@@ -454,6 +454,34 @@ func TestAllMatches(t *testing.T) {
        }
 }
 
+type numSubexpCase struct {
+       input    string
+       expected int
+}
+
+var numSubexpCases = []numSubexpCase{
+       numSubexpCase{``, 0},
+       numSubexpCase{`.*`, 0},
+       numSubexpCase{`abba`, 0},
+       numSubexpCase{`ab(b)a`, 1},
+       numSubexpCase{`ab(.*)a`, 1},
+       numSubexpCase{`(.*)ab(.*)a`, 2},
+       numSubexpCase{`(.*)(ab)(.*)a`, 3},
+       numSubexpCase{`(.*)((a)b)(.*)a`, 4},
+       numSubexpCase{`(.*)(\(ab)(.*)a`, 3},
+       numSubexpCase{`(.*)(\(a\)b)(.*)a`, 3},
+}
+
+func TestNumSubexp(t *testing.T) {
+       for _, c := range numSubexpCases {
+               re, _ := Compile(c.input)
+               n := re.NumSubexp()
+               if n != c.expected {
+                       t.Errorf("NumSubexp for %q returned %d, expected %d", c.input, n, c.expected)
+               }
+       }
+}
+
 func BenchmarkLiteral(b *testing.B) {
        x := strings.Repeat("x", 50)
        b.StopTimer()

diff --git a/src/pkg/regexp/regexp.go b/src/pkg/regexp/regexp.go
index fd6fbefee8fb22351b939503d4f604a0d04bcea9..373d6b1af1d143053c1930c112407cd2512a733d 100644 (file)
--- a/src/pkg/regexp/regexp.go
+++ b/src/pkg/regexp/regexp.go
@@ -677,6 +677,9 @@ func MustCompile(str string) *Regexp {
        return regexp
 }
 
+// NumSubexp returns the number of parenthesized subexpressions in this Regexp.
+func (re *Regexp) NumSubexp() int { return re.nbra }
+
 // The match arena allows us to reduce the garbage generated by tossing
 // match vectors away as we execute.  Matches are ref counted and returned
 // to a free list when no longer active.  Increases a simple benchmark by 22X.