code review 4538123: exp/regexp/syntax: syntax data structures, parser

src/pkg/exp/regexp/syntax/parse_test.go

 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package syntax
 
 import (
         "bytes"
         "fmt"
         "testing"
         "unicode"
 )
 
 var parseTests = []struct {
         Regexp string
         Dump   string
 }{
         // Base cases
         {"a", "lit{a}"},
         {"a.", "cat{lit{a}dot{}}"},
         {"a.b", "cat{lit{a}dot{}lit{b}}"},
         //      { "ab", "str{ab}" },

[Sam, 2011/06/10 00:14:55]

won't these str{} cases work - as just an extension of lit{} to >1 char?

[rsc, 2011/06/10 00:27:38]

That's the plan, but for now they compile into the next line below:
cat{lit{a}lit{b}} instead of lit{ab}.  The alternate and concat methods
will get much more complicated before all this is done, and one
of the complications is turning cat{lit{a}lit{b}} into str{ab}.

         {"ab", "cat{lit{a}lit{b}}"},
         {"a.b.c", "cat{lit{a}dot{}lit{b}dot{}lit{c}}"},
         //      { "abc", "str{abc}" },
         {"abc", "cat{lit{a}lit{b}lit{c}}"},
         {"a|^", "alt{lit{a}bol{}}"},
         //      { "a|b", "cc{0x61-0x62}" },
         {"a|b", "alt{lit{a}lit{b}}"},
         {"(a)", "cap{lit{a}}"},
         {"(a)|b", "alt{cap{lit{a}}lit{b}}"},
         {"a*", "star{lit{a}}"},
@@ skipping 65 matching lines @@
         // More interesting regular expressions.
         //      { "a{,2}", "str{a{,2}}" },
         //      { "\\.\\^\\$\\\\", "str{.^$\\}" },
         {"[a-zABC]", "cc{0x41-0x43 0x61-0x7a}"},
         {"[^a]", "cc{0x0-0x60 0x62-0x10ffff}"},
         {"[\xce\xb1-\xce\xb5\xe2\x98\xba]", "cc{0x3b1-0x3b5 0x263a}"}, // utf-8
         //      { "a*{", "cat{star{lit{a}}lit{{}}" },
 
         // Test precedences
         //      { "(?:ab)*", "star{str{ab}}" },
         //      { "(ab)*", "star{cap{str{ab}}}" },

[Sam, 2011/06/10 00:14:55]

I think this one should work now

[rsc, 2011/06/10 00:27:38]

Same thing as above: the uncommented copy a few lines from
now is the current parse tree, because nothing generates str yet.

         //      { "ab|cd", "alt{str{ab}str{cd}}" },
         //      { "a(b|c)d", "cat{lit{a}cap{cc{0x62-0x63}}lit{d}}" },
         {"(?:ab)*", "star{cat{lit{a}lit{b}}}"},
         {"(ab)*", "star{cap{cat{lit{a}lit{b}}}}"},
         {"ab|cd", "alt{cat{lit{a}lit{b}}cat{lit{c}lit{d}}}"},
         {"a(b|c)d", "cat{lit{a}cap{alt{lit{b}lit{c}}}lit{d}}"},
 
         // Test flattening.
         //      { "(?:a)", "lit{a}" },
         //      { "(?:ab)(?:cd)", "str{abcd}" },
@@ skipping 68 matching lines @@
         OpNoWordBoundary: "nwb",
         OpCapture:        "cap",
         OpStar:           "star",
         OpPlus:           "plus",
         OpQuest:          "que",
         OpRepeat:         "rep",
         OpConcat:         "cat",
         OpAlternate:      "alt",
 }
 
+// dumpRegexp writes an encoding of the syntax tree for the regexp re to b.
+// It is used during testing to distinguish between parses that might print
+// the same using re's String method.
 func dumpRegexp(b *bytes.Buffer, re *Regexp) {
         if int(re.Op) >= len(opNames) || opNames[re.Op] == "" {
                 fmt.Fprintf(b, "op%d", re.Op)
         } else {
                 switch re.Op {
                 default:
                         b.WriteString(opNames[re.Op])
                 case OpStar, OpPlus, OpQuest, OpRepeat:
                         if re.Flags&NonGreedy != 0 {
                                 b.WriteByte('n')
@@ skipping 47 matching lines @@
                         lo, hi := re.Rune[i], re.Rune[i+1]
                         if lo == hi {
                                 fmt.Fprintf(b, "%#x", lo)
                         } else {
                                 fmt.Fprintf(b, "%#x-%#x", lo, hi)
                         }
                 }
         }
         b.WriteByte('}')
 }