Make scan_rr much smaller

parse_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"strings"
 	"testing"
+	"text/scanner"
 	"time"
 )
 
@@ -166,34 +167,6 @@ func TestParseBrace(t *testing.T) {
 	}
 }
 
-/*
-func TestLexerBrace(t *testing.T) {
-        aaaa := `(miek.nl.) (
-                        (IN) 
-                        (AAAA)
-                        ::1)`
-
-//        aaaa = `miek.nl. (
-//                        IN 
-//                        AAAA
-//                        ::1 ))`
-//
-        var s scanner.Scanner
-        c := make(chan lex)
-        s.Init(strings.NewReader(aaaa))
-        s.Mode = 0
-        s.Whitespace = 0
-        go zlexer(s, c)
-        for l := range c {
-                if l.err != "" {
-                        t.Logf("E: %s\n", l.err)
-                        continue
-                }
-                t.Logf("%s ", l)
-        }
-}
-*/
-
 func TestParseFailure(t *testing.T) {
 	tests := []string{"miek.nl. IN A 327.0.0.1",
 		"miek.nl. IN AAAA ::x",
@@ -213,7 +186,7 @@ func TestParseFailure(t *testing.T) {
 	}
 }
 
-// A bit useless
+// A bit useless, how to use b.N?
 func BenchmarkZoneParsing(b *testing.B) {
 	f, err := os.Open("miek.nl.signed_test")
 	if err != nil {
@@ -285,3 +258,24 @@ func TestZoneParsingBigZone(t *testing.T) {
 	t.Logf("%d RRs parsed in %.2f s (%.2f RR/s)", i, float32(delta)/1e9, float32(i)/(float32(delta)/1e9))
 }
 */
+
+func TestLexerBrace(t *testing.T) {
+	f, err := os.Open("/home/miekg/src/tmp/small")
+	if err != nil {
+		return
+	}
+	defer f.Close()
+        var s scanner.Scanner
+        c := make(chan lex)
+        s.Init(f)
+        s.Mode = 0
+        s.Whitespace = 0
+        go zlexer(s, c)
+        for l := range c {
+                if l.err != "" {
+                        t.Logf("E: %s\n", l.err)
+                        continue
+                }
+                t.Logf("%s ", l)
+        }
+}

zscan_rr.go

@@ -17,83 +17,54 @@ func setRR(h RR_Header, c chan lex) (RR, *ParseError) {
 	var r RR
 	e := new(ParseError)
 	switch h.Rrtype {
-	// goto Slurpremainder
 	case TypeA:
 		r, e = setA(h, c)
-		if e != nil {
-			return nil, e
-		}
-		if se := slurpRemainder(c); se != nil {
-			return nil, se
-		}
+		goto Slurp
 	case TypeAAAA:
 		r, e = setAAAA(h, c)
-		if e != nil {
-			return nil, e
-		}
-		if se := slurpRemainder(c); se != nil {
-			return nil, se
-		}
+		goto Slurp
 	case TypeNS:
 		r, e = setNS(h, c)
-		if e != nil {
-			return nil, e
-		}
-		if se := slurpRemainder(c); se != nil {
-			return nil, se
-		}
+		goto Slurp
 	case TypeMX:
 		r, e = setMX(h, c)
-		if e != nil {
-			return nil, e
-		}
-		if se := slurpRemainder(c); se != nil {
-			return nil, se
-		}
+		goto Slurp
 	case TypeCNAME:
 		r, e = setCNAME(h, c)
-		if e != nil {
-			return nil, e
-		}
-		if se := slurpRemainder(c); se != nil {
-			return nil, se
-		}
+		goto Slurp
 	case TypeSOA:
 		r, e = setSOA(h, c)
-		if e != nil {
-			return nil, e
-		}
-		if se := slurpRemainder(c); se != nil {
-			return nil, se
-		}
+		goto Slurp
 	case TypeSSHFP:
 		r, e = setSSHFP(h, c)
-		if e != nil {
-			return nil, e
-		}
-		if se := slurpRemainder(c); se != nil {
-			return nil, se
-		}
+		goto Slurp
+	case TypeDNSKEY:
 		// These types have a variable ending either chunks of txt or chunks/base64 or hex.
 		// They need to search for the end of the RR themselves, hence they look for the ending
 		// newline. Thus there is no need to slurp the remainder, because there is none.
-	case TypeDNSKEY:
-		r, e = setDNSKEY(h, c)
+		return setDNSKEY(h, c)
 	case TypeRRSIG:
-		r, e = setRRSIG(h, c)
+		return setRRSIG(h, c)
 	case TypeNSEC:
-		r, e = setNSEC(h, c)
+		return setNSEC(h, c)
 	case TypeNSEC3:
-		r, e = setNSEC3(h, c)
+		return setNSEC3(h, c)
 	case TypeDS:
-		r, e = setDS(h, c)
+		return setDS(h, c)
 	case TypeTXT:
-		r, e = setTXT(h, c)
+		return setTXT(h, c)
 	default:
 		// Don't the have the token the holds the RRtype, but we substitute that in the
 		// calling function when lex is empty.
 		return nil, &ParseError{"Unknown RR type", lex{}}
 	}
+Slurp:
+	if e != nil {
+		return nil, e
+	}
+	if se := slurpRemainder(c); se != nil {
+		return nil, se
+	}
 	return r, e
 }