diff --git a/_examples/q/fp.go b/_examples/q/fp.go index b1e6f05f..25ebb26e 100644 --- a/_examples/q/fp.go +++ b/_examples/q/fp.go @@ -4,7 +4,6 @@ package main import ( "dns" "fmt" - "os" "strconv" "strings" ) @@ -64,7 +63,7 @@ func sendProbe(c *dns.Client, addr string, f *fingerprint, q dns.Question) *fing // This leads to strings like: "QUERY,NOERROR,qr,aa,tc,RD,ad,cd,z,1,0,0,1,DO,4096,NSID" type fingerprint struct { - Error os.Error + Error error Opcode int Rcode int Response bool @@ -81,7 +80,7 @@ type fingerprint struct { Extra int Do bool UDPSize int - Nsid bool + Nsid bool } // String creates a (short) string representation of a dns message. @@ -187,10 +186,10 @@ func (f *fingerprint) error() string { if f.Error == nil { panic("error is nil") } - return f.Error.String() + return f.Error.Error() } -func errorToFingerprint(e os.Error) *fingerprint { +func errorToFingerprint(e error) *fingerprint { f := new(fingerprint) f.Error = e return f @@ -226,10 +225,10 @@ func msgToFingerprint(m *dns.Msg) *fingerprint { // version is always 0 - and I cannot set it anyway f.Do = r.(*dns.RR_OPT).Do() f.UDPSize = int(r.(*dns.RR_OPT).UDPSize()) - if len(r.(*dns.RR_OPT).Option) == 1 { - // Only support NSID atm - f.Nsid = r.(*dns.RR_OPT).Option[0].Code == dns.OptionCodeNSID - } + if len(r.(*dns.RR_OPT).Option) == 1 { + // Only support NSID atm + f.Nsid = r.(*dns.RR_OPT).Option[0].Code == dns.OptionCodeNSID + } } } return f @@ -258,9 +257,9 @@ func (f *fingerprint) toProbe(q dns.Question) *dns.Msg { m.SetEdns0(0, true) // We have added an OPT RR, set the size. m.Extra[0].(*dns.RR_OPT).SetUDPSize(uint16(f.UDPSize)) - if f.Nsid { - m.Extra[0].(*dns.RR_OPT).SetNsid("") - } + if f.Nsid { + m.Extra[0].(*dns.RR_OPT).SetNsid("") + } } return m } diff --git a/client.go b/client.go index 711fefdd..68a8487a 100644 --- a/client.go +++ b/client.go @@ -8,7 +8,6 @@ package dns // when the query returns. import ( - "os" "io" "net" ) @@ -22,10 +21,10 @@ type QueryHandler interface { // construct a DNS request. type RequestWriter interface { Write(*Msg) - Send(*Msg) os.Error - Receive() (*Msg, os.Error) - Close() os.Error - Dial() os.Error + Send(*Msg) error + Receive() (*Msg, error) + Close() error + Dial() error } // hijacked connections...? @@ -124,8 +123,8 @@ type Client struct { Net string // if "tcp" a TCP query will be initiated, otherwise an UDP one Attempts int // number of attempts Retry bool // retry with TCP - QueryChan chan *Request // read DNS request from this channel - ReplyChan chan *Exchange // write the reply (together with the DNS request) to this channel + QueryChan chan *Request // read DNS request from this channel + ReplyChan chan *Exchange // write the reply (together with the DNS request) to this channel ReadTimeout int64 // the net.Conn.SetReadTimeout value for new connections (ns) WriteTimeout int64 // the net.Conn.SetWriteTimeout value for new connections (ns) TsigSecret map[string]string // secret(s) for Tsig map[] @@ -140,8 +139,8 @@ func NewClient() *Client { c := new(Client) c.Net = "udp" c.Attempts = 1 - c.ReplyChan = DefaultReplyChan - c.QueryChan = DefaultQueryChan + c.ReplyChan = DefaultReplyChan + c.QueryChan = DefaultQueryChan c.ReadTimeout = 1 * 1e9 c.WriteTimeout = 1 * 1e9 return c @@ -149,10 +148,10 @@ func NewClient() *Client { type Query struct { QueryChan chan *Request // read DNS request from this channel - Handler QueryHandler // handler to invoke, dns.DefaultQueryMux if nil + Handler QueryHandler // handler to invoke, dns.DefaultQueryMux if nil } -func (q *Query) Query() os.Error { +func (q *Query) Query() error { handler := q.Handler if handler == nil { handler = DefaultQueryMux @@ -171,7 +170,7 @@ func (q *Query) Query() os.Error { return nil } -func (q *Query) ListenAndQuery() os.Error { +func (q *Query) ListenAndQuery() error { if q.QueryChan == nil { q.QueryChan = DefaultQueryChan } @@ -195,12 +194,12 @@ func (w *reply) Write(m *Msg) { // Do performs an asynchronous query. The result is returned on the // QueryChan channel set in the Client c. func (c *Client) Do(m *Msg, a string) { - c.QueryChan <- &Request{Client: c, Addr: a, Request: m} + c.QueryChan <- &Request{Client: c, Addr: a, Request: m} } // ExchangeBuffer performs a synchronous query. It sends the buffer m to the // address (net.Addr?) contained in a -func (c *Client) ExchangeBuffer(inbuf []byte, a string, outbuf []byte) (n int, err os.Error) { +func (c *Client) ExchangeBuffer(inbuf []byte, a string, outbuf []byte) (n int, err error) { w := new(reply) w.client = c w.addr = a @@ -224,7 +223,7 @@ func (c *Client) ExchangeBuffer(inbuf []byte, a string, outbuf []byte) (n int, e // Exchange performs an synchronous query. It sends the message m to the address // contained in a and waits for an reply. -func (c *Client) Exchange(m *Msg, a string) (r *Msg, err os.Error) { +func (c *Client) Exchange(m *Msg, a string) (r *Msg, err error) { var n int out, ok := m.Pack() if !ok { @@ -248,7 +247,7 @@ func (c *Client) Exchange(m *Msg, a string) (r *Msg, err os.Error) { } // Dial connects to the address addr for the network set in c.Net -func (w *reply) Dial() os.Error { +func (w *reply) Dial() error { conn, err := net.Dial(w.Client().Net, w.addr) if err != nil { return err @@ -258,7 +257,7 @@ func (w *reply) Dial() os.Error { } // UDP/TCP stuff big TODO -func (w *reply) Close() (err os.Error) { +func (w *reply) Close() (err error) { return w.conn.Close() } @@ -270,7 +269,7 @@ func (w *reply) Request() *Msg { return w.req } -func (w *reply) Receive() (*Msg, os.Error) { +func (w *reply) Receive() (*Msg, error) { var p []byte m := new(Msg) switch w.Client().Net { @@ -294,8 +293,8 @@ func (w *reply) Receive() (*Msg, os.Error) { if !ok { return m, ErrSecret } - // Need to work on the original message p, as that was used - // to calculate the tsig. + // Need to work on the original message p, as that was used + // to calculate the tsig. err := TsigVerify(p, w.Client().TsigSecret[secret], w.tsigRequestMAC, w.tsigTimersOnly) if err != nil { return m, err @@ -304,9 +303,9 @@ func (w *reply) Receive() (*Msg, os.Error) { return m, nil } -func (w *reply) readClient(p []byte) (n int, err os.Error) { +func (w *reply) readClient(p []byte) (n int, err error) { if w.conn == nil { - return 0, ErrConnEmpty + return 0, ErrConnEmpty //panic("no connection") } switch w.Client().Net { @@ -350,16 +349,16 @@ func (w *reply) readClient(p []byte) (n int, err os.Error) { // Send sends a dns msg to the address specified in w. // If the message m contains a TSIG record the transaction // signature is calculated. -func (w *reply) Send(m *Msg) os.Error { +func (w *reply) Send(m *Msg) error { if m.IsTsig() { secret := m.Extra[len(m.Extra)-1].(*RR_TSIG).Hdr.Name _, ok := w.Client().TsigSecret[secret] if !ok { return ErrSecret } - if err := TsigGenerate(m, w.Client().TsigSecret[secret], w.tsigRequestMAC, w.tsigTimersOnly); err != nil { - return err - } + if err := TsigGenerate(m, w.Client().TsigSecret[secret], w.tsigRequestMAC, w.tsigTimersOnly); err != nil { + return err + } w.tsigRequestMAC = m.Extra[len(m.Extra)-1].(*RR_TSIG).MAC // Save the requestMAC for the next packet } out, ok := m.Pack() @@ -373,7 +372,7 @@ func (w *reply) Send(m *Msg) os.Error { return nil } -func (w *reply) writeClient(p []byte) (n int, err os.Error) { +func (w *reply) writeClient(p []byte) (n int, err error) { if w.Client().Attempts == 0 { panic("c.Attempts 0") } @@ -384,8 +383,8 @@ func (w *reply) writeClient(p []byte) (n int, err os.Error) { if err = w.Dial(); err != nil { return 0, err } - w.conn.SetWriteTimeout(w.Client().WriteTimeout) - w.conn.SetReadTimeout(w.Client().ReadTimeout) + w.conn.SetWriteTimeout(w.Client().WriteTimeout) + w.conn.SetReadTimeout(w.Client().ReadTimeout) } switch w.Client().Net { diff --git a/clientconfig.go b/clientconfig.go index 750c5e55..64c2e7d0 100644 --- a/clientconfig.go +++ b/clientconfig.go @@ -28,7 +28,7 @@ type ClientConfig struct { // See resolv.conf(5) on a Linux machine. // Parse a /etc/resolv.conf like file and return a filled out ClientConfig. Note // that all nameservers will have the default port number appended (:53) -func ClientConfigFromFile(conf string) (*ClientConfig, os.Error) { +func ClientConfigFromFile(conf string) (*ClientConfig, error) { file, err := os.Open(conf) defer file.Close() if err != nil { diff --git a/dns.go b/dns.go index beef78e3..d21cacdc 100644 --- a/dns.go +++ b/dns.go @@ -52,7 +52,6 @@ package dns import ( "net" - "os" "strconv" ) @@ -65,17 +64,17 @@ const ( // Error represents a DNS error type Error struct { - Error string + Err string Name string Server net.Addr Timeout bool } -func (e *Error) String() string { +func (e *Error) Error() string { if e == nil { return "" } - return e.Error + return e.Err } type RR interface { @@ -153,9 +152,9 @@ func (s RRset) Ok() bool { // Exchange is used in communicating with the resolver. type Exchange struct { - Request *Msg // The question sent. - Reply *Msg // The answer to the question that was sent. - Error os.Error // If something when wrong, this contains the error. + Request *Msg // The question sent. + Reply *Msg // The answer to the question that was sent. + Error error // If something when wrong, this contains the error. } // DNS resource records. @@ -230,10 +229,10 @@ func zoneMatch(pattern, zone string) (ok bool) { // DnameLength returns the length of a packed dname. func DomainNameLength(s string) int { // TODO better name - // Special case for '.' - if s == "." { - return 1 - } + // Special case for '.' + if s == "." { + return 1 + } // Add trailing dot to canonicalize name. if n := len(s); n == 0 || s[n-1] != '.' { diff --git a/dnssec.go b/dnssec.go index 63b25bb1..2becf8fe 100644 --- a/dnssec.go +++ b/dnssec.go @@ -18,7 +18,6 @@ import ( "big" "sort" "strings" - "os" ) // DNSSEC encryption algorithm codes. @@ -172,7 +171,7 @@ func (k *RR_DNSKEY) ToDS(h int) *RR_DS { // otherwise false. // The signature data in the RRSIG is filled by this method. // There is no check if RRSet is a proper (RFC 2181) RRSet. -func (s *RR_RRSIG) Sign(k PrivateKey, rrset RRset) os.Error { +func (s *RR_RRSIG) Sign(k PrivateKey, rrset RRset) error { if k == nil { return ErrPrivKey } @@ -263,7 +262,7 @@ func (s *RR_RRSIG) Sign(k PrivateKey, rrset RRset) os.Error { // Verify validates an RRSet with the signature and key. This is only the // cryptographic test, the signature validity period most be checked separately. -func (s *RR_RRSIG) Verify(k *RR_DNSKEY, rrset RRset) os.Error { +func (s *RR_RRSIG) Verify(k *RR_DNSKEY, rrset RRset) error { // Frist the easy checks if s.KeyTag != k.KeyTag() { return ErrKey @@ -337,7 +336,7 @@ func (s *RR_RRSIG) Verify(k *RR_DNSKEY, rrset RRset) os.Error { return rsa.VerifyPKCS1v15(pubkey, ch, sighash, sigbuf) } // Unknown alg - return ErrAlg + return ErrAlg } // ValidityPeriod uses RFC1982 serial arithmetic to calculate diff --git a/keygen.go b/keygen.go index 9f664a78..0d8cf367 100644 --- a/keygen.go +++ b/keygen.go @@ -1,7 +1,6 @@ package dns import ( - "os" "io" "big" "strconv" @@ -21,9 +20,9 @@ type PrivateKey interface{} // what kind of DNSKEY will be generated. // The ECDSA algorithms imply a fixed keysize, in that case // bits should be set to the size of the algorithm. -func (r *RR_DNSKEY) Generate(bits int) (PrivateKey, os.Error) { +func (r *RR_DNSKEY) Generate(bits int) (PrivateKey, error) { switch r.Algorithm { - case RSAMD5, RSASHA1, RSASHA256, RSASHA1NSEC3SHA1: + case RSAMD5, RSASHA1, RSASHA256, RSASHA1NSEC3SHA1: if bits < 512 || bits > 4096 { return nil, ErrKeySize } @@ -42,7 +41,7 @@ func (r *RR_DNSKEY) Generate(bits int) (PrivateKey, os.Error) { } switch r.Algorithm { - case RSAMD5, RSASHA1, RSASHA256, RSASHA512, RSASHA1NSEC3SHA1: + case RSAMD5, RSASHA1, RSASHA256, RSASHA512, RSASHA1NSEC3SHA1: priv, err := rsa.GenerateKey(rand.Reader, bits) if err != nil { return nil, err @@ -113,7 +112,7 @@ func (r *RR_DNSKEY) PrivateKeyString(p PrivateKey) (s string) { } // Read reads a DNSKEY from the io.Reader q. -func (k *RR_DNSKEY) Read(q io.Reader) os.Error { +func (k *RR_DNSKEY) Read(q io.Reader) error { p := NewParser(q) r, err := p.First() if err != nil { @@ -131,12 +130,12 @@ func (k *RR_DNSKEY) Read(q io.Reader) os.Error { } // ReadPrivateKey reads a private key from the io.Reader q. -func (k *RR_DNSKEY) ReadPrivateKey(q io.Reader) (PrivateKey, os.Error) { +func (k *RR_DNSKEY) ReadPrivateKey(q io.Reader) (PrivateKey, error) { p := NewParser(q) kv, _ := p.PrivateKey() - if kv == nil { - return nil, ErrPrivKey - } + if kv == nil { + return nil, ErrPrivKey + } if _, ok := kv["private-key-format"]; !ok { return nil, ErrPrivKey } @@ -153,7 +152,7 @@ func (k *RR_DNSKEY) ReadPrivateKey(q io.Reader) (PrivateKey, os.Error) { } // Read a private key (file) string and create a public key. Return the private key. -func (k *RR_DNSKEY) readPrivateKeyRSA(kv map[string]string) (PrivateKey, os.Error) { +func (k *RR_DNSKEY) readPrivateKeyRSA(kv map[string]string) (PrivateKey, error) { p := new(rsa.PrivateKey) p.Primes = []*big.Int{nil, nil} for k, v := range kv { @@ -190,7 +189,7 @@ func (k *RR_DNSKEY) readPrivateKeyRSA(kv map[string]string) (PrivateKey, os.Erro return p, nil } -func (k *RR_DNSKEY) readPrivateKeyECDSA(kv map[string]string) (PrivateKey, os.Error) { +func (k *RR_DNSKEY) readPrivateKeyECDSA(kv map[string]string) (PrivateKey, error) { p := new(ecdsa.PrivateKey) p.D = big.NewInt(0) // Need to check if we have everything diff --git a/kparse.go b/kparse.go index f9e79435..7f03c3d5 100644 --- a/kparse.go +++ b/kparse.go @@ -3,11 +3,7 @@ package dns // Parse private key files -import ( - "os" // "strings" -) - // line 14 "kparse.go" var k_start int = 111 @@ -16,2426 +12,2424 @@ var k_error int = 0 var k_en_main int = 111 - // line 13 "kparse.rl" - // PrivateKey parses a private key file as defined in XXX. // A map[string]string is returned with the values. All the keys are // converted to lowercase. All values are returned as-is, except // the algorithm [e.g. 5 (RSASHA1)] is returned as: m[algorithm] = "RSASHA1" -func (kp *Parser) PrivateKey() (m map[string]string, err os.Error) { -//off Ragel generate illegal code now - /* - m = make(map[string]string) - var ( - k, data string - cs, p, pe int - ) - lines := strings.SplitAfter(string(kp.buf), "\n") - for _, data := range lines { - cs, p, pe = 0, 0, len(data) - mark := 0 +func (kp *Parser) PrivateKey() (m map[string]string, err error) { + //off Ragel generate illegal code now + /* + m = make(map[string]string) + var ( + k, data string + cs, p, pe int + ) + lines := strings.SplitAfter(string(kp.buf), "\n") + for _, data := range lines { + cs, p, pe = 0, 0, len(data) + mark := 0 - // line 41 "kparse.go" - cs = k_start + // line 41 "kparse.go" + cs = k_start - // line 44 "kparse.go" - { - if p == pe { - goto _test_eof - } - switch cs { - case -666: // i am a hack D: - tr13: - // line 33 "kparse.rl" - { - m[k] = data[mark:p] - } - goto st111 - tr28: - // line 34 "kparse.rl" - { - m[k] = strings.ToUpper(data[mark : p-1]) - } - goto st111 - tr40: - // line 33 "kparse.rl" - { - m[k] = data[mark:p] - } - // line 34 "kparse.rl" - { - m[k] = strings.ToUpper(data[mark : p-1]) - } - goto st111 - st111: - p++ + // line 44 "kparse.go" + { if p == pe { - goto _test_eof111 + goto _test_eof } - fallthrough - case 111: - // line 68 "kparse.go" - switch data[p] { - case 65: - goto tr110 - case 67: - goto tr111 - case 69: - goto tr112 - case 71: - goto tr113 - case 77: - goto tr114 - case 80: - goto tr115 - case 94: - goto st109 - case 97: - goto tr110 - case 99: - goto tr111 - case 101: - goto tr112 - case 103: - goto tr113 - case 109: - goto tr114 - case 112: - goto tr115 - } - goto st0 - st0: - cs = 0 - goto _out - tr110: - // line 31 "kparse.rl" - { - mark = p - } - goto st1 - st1: - p++ - if p == pe { - goto _test_eof1 - } - fallthrough - case 1: - // line 97 "kparse.go" - switch data[p] { - case 67: - goto st2 - case 76: - goto st37 - case 99: - goto st2 - case 108: - goto st37 - } - goto st0 - st2: - p++ - if p == pe { - goto _test_eof2 - } - fallthrough - case 2: - switch data[p] { - case 84: - goto st3 - case 116: - goto st3 - } - goto st0 - st3: - p++ - if p == pe { - goto _test_eof3 - } - fallthrough - case 3: - switch data[p] { - case 73: - goto st4 - case 105: - goto st4 - } - goto st0 - st4: - p++ - if p == pe { - goto _test_eof4 - } - fallthrough - case 4: - switch data[p] { - case 86: - goto st5 - case 118: - goto st5 - } - goto st0 - st5: - p++ - if p == pe { - goto _test_eof5 - } - fallthrough - case 5: - switch data[p] { - case 65: - goto st6 - case 97: - goto st6 - } - goto st0 - st6: - p++ - if p == pe { - goto _test_eof6 - } - fallthrough - case 6: - switch data[p] { - case 84: - goto st7 - case 116: - goto st7 - } - goto st0 - st7: - p++ - if p == pe { - goto _test_eof7 - } - fallthrough - case 7: - switch data[p] { - case 69: - goto st8 - case 101: - goto st8 - } - goto st0 - st8: - p++ - if p == pe { - goto _test_eof8 - } - fallthrough - case 8: - if data[p] == 58 { - goto tr9 - } - goto st0 - tr9: - // line 32 "kparse.rl" - { - k = strings.ToLower(data[mark:p]) - } - goto st9 - st9: - p++ - if p == pe { - goto _test_eof9 - } - fallthrough - case 9: - // line 181 "kparse.go" - if data[p] == 32 { - goto st10 - } - goto st0 - st10: - p++ - if p == pe { - goto _test_eof10 - } - fallthrough - case 10: - switch data[p] { - case 32: - goto tr11 - case 43: - goto tr11 - case 61: - goto tr11 - case 92: - goto tr11 - } - if data[p] < 48 { - if data[p] > 41 { - if 46 <= data[p] && data[p] <= 47 { - goto tr11 - } - } else if data[p] >= 40 { - goto tr11 + switch cs { + case -666: // i am a hack D: + tr13: + // line 33 "kparse.rl" + { + m[k] = data[mark:p] } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto tr11 - } - } else if data[p] >= 65 { - goto tr11 - } - } else { - goto tr12 - } - goto st0 - tr11: - // line 31 "kparse.rl" - { - mark = p - } - goto st11 - st11: - p++ - if p == pe { - goto _test_eof11 - } - fallthrough - case 11: - // line 220 "kparse.go" - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 61: - goto st11 - case 92: - goto st11 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st11 - } - goto st0 - tr12: - // line 31 "kparse.rl" - { - mark = p - } - goto st12 - st12: - p++ - if p == pe { - goto _test_eof12 - } - fallthrough - case 12: - // line 249 "kparse.go" - switch data[p] { - case 9: - goto st13 - case 10: - goto tr13 - case 32: - goto st25 - case 43: - goto st11 - case 61: - goto st11 - case 92: - goto st11 - } - if data[p] < 48 { - if data[p] > 41 { - if 46 <= data[p] && data[p] <= 47 { - goto st11 - } - } else if data[p] >= 40 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st12 - } - goto st0 - st13: - p++ - if p == pe { - goto _test_eof13 - } - fallthrough - case 13: - switch data[p] { - case 9: - goto st13 - case 32: - goto st13 - case 40: - goto st14 - } - goto st0 - st14: - p++ - if p == pe { - goto _test_eof14 - } - fallthrough - case 14: - switch data[p] { - case 82: - goto tr19 - case 114: - goto tr19 - } - goto st0 - tr19: - // line 31 "kparse.rl" - { - mark = p - } - goto st15 - st15: - p++ - if p == pe { - goto _test_eof15 - } - fallthrough - case 15: - // line 304 "kparse.go" - switch data[p] { - case 83: - goto st16 - case 115: - goto st16 - } - goto st0 - st16: - p++ - if p == pe { - goto _test_eof16 - } - fallthrough - case 16: - switch data[p] { - case 65: - goto st17 - case 97: - goto st17 - } - goto st0 - st17: - p++ - if p == pe { - goto _test_eof17 - } - fallthrough - case 17: - switch data[p] { - case 83: - goto st18 - case 115: - goto st18 - } - goto st0 - st18: - p++ - if p == pe { - goto _test_eof18 - } - fallthrough - case 18: - switch data[p] { - case 72: - goto st19 - case 104: - goto st19 - } - goto st0 - st19: - p++ - if p == pe { - goto _test_eof19 - } - fallthrough - case 19: - switch data[p] { - case 65: - goto st20 - case 97: - goto st20 - } - goto st0 - st20: - p++ - if p == pe { - goto _test_eof20 - } - fallthrough - case 20: - switch data[p] { - case 49: - goto st21 - case 50: - goto st23 - } - goto st0 - st21: - p++ - if p == pe { - goto _test_eof21 - } - fallthrough - case 21: - if data[p] == 41 { - goto st22 - } - goto st0 - st22: - p++ - if p == pe { - goto _test_eof22 - } - fallthrough - case 22: - if data[p] == 10 { - goto tr28 - } - goto st0 - st23: - p++ - if p == pe { - goto _test_eof23 - } - fallthrough - case 23: - if data[p] == 53 { - goto st24 - } - goto st0 - st24: - p++ - if p == pe { - goto _test_eof24 - } - fallthrough - case 24: - if data[p] == 54 { - goto st21 - } - goto st0 - st25: - p++ - if p == pe { - goto _test_eof25 - } - fallthrough - case 25: - switch data[p] { - case 9: - goto st13 - case 10: - goto tr13 - case 32: - goto st25 - case 40: - goto st26 - case 41: - goto st11 - case 43: - goto st11 - case 61: - goto st11 - case 92: - goto st11 - } - if data[p] < 65 { - if 46 <= data[p] && data[p] <= 57 { - goto st11 - } - } else if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st26: - p++ - if p == pe { - goto _test_eof26 - } - fallthrough - case 26: - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 61: - goto st11 - case 82: - goto tr31 - case 92: - goto st11 - case 114: - goto tr31 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st11 - } - goto st0 - tr31: - // line 31 "kparse.rl" - { - mark = p - } - goto st27 - st27: - p++ - if p == pe { - goto _test_eof27 - } - fallthrough - case 27: - // line 446 "kparse.go" - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 61: - goto st11 - case 83: - goto st28 - case 92: - goto st11 - case 115: - goto st28 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st28: - p++ - if p == pe { - goto _test_eof28 - } - fallthrough - case 28: - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 61: - goto st11 - case 65: - goto st29 - case 92: - goto st11 - case 97: - goto st29 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 98 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 66 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st29: - p++ - if p == pe { - goto _test_eof29 - } - fallthrough - case 29: - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 61: - goto st11 - case 83: - goto st30 - case 92: - goto st11 - case 115: - goto st30 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st30: - p++ - if p == pe { - goto _test_eof30 - } - fallthrough - case 30: - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 61: - goto st11 - case 72: - goto st31 - case 92: - goto st11 - case 104: - goto st31 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st31: - p++ - if p == pe { - goto _test_eof31 - } - fallthrough - case 31: - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 61: - goto st11 - case 65: - goto st32 - case 92: - goto st11 - case 97: - goto st32 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 98 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 66 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st32: - p++ - if p == pe { - goto _test_eof32 - } - fallthrough - case 32: - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 49: - goto st33 - case 50: - goto st35 - case 61: - goto st11 - case 92: - goto st11 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st33: - p++ - if p == pe { - goto _test_eof33 - } - fallthrough - case 33: - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 40: - goto st11 - case 41: - goto st34 - case 43: - goto st11 - case 61: - goto st11 - case 92: - goto st11 - } - if data[p] < 65 { - if 46 <= data[p] && data[p] <= 57 { - goto st11 - } - } else if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st34: - p++ - if p == pe { - goto _test_eof34 - } - fallthrough - case 34: - switch data[p] { - case 10: - goto tr40 - case 32: - goto st11 - case 43: - goto st11 - case 61: - goto st11 - case 92: - goto st11 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st35: - p++ - if p == pe { - goto _test_eof35 - } - fallthrough - case 35: - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 53: - goto st36 - case 61: - goto st11 - case 92: - goto st11 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st36: - p++ - if p == pe { - goto _test_eof36 - } - fallthrough - case 36: - switch data[p] { - case 10: - goto tr13 - case 32: - goto st11 - case 43: - goto st11 - case 54: - goto st33 - case 61: - goto st11 - case 92: - goto st11 - } - if data[p] < 46 { - if 40 <= data[p] && data[p] <= 41 { - goto st11 - } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { - goto st11 - } - } else if data[p] >= 65 { - goto st11 - } - } else { - goto st11 - } - goto st0 - st37: - p++ - if p == pe { - goto _test_eof37 - } - fallthrough - case 37: - switch data[p] { - case 71: - goto st38 - case 103: - goto st38 - } - goto st0 - st38: - p++ - if p == pe { - goto _test_eof38 - } - fallthrough - case 38: - switch data[p] { - case 79: - goto st39 - case 111: - goto st39 - } - goto st0 - st39: - p++ - if p == pe { - goto _test_eof39 - } - fallthrough - case 39: - switch data[p] { - case 82: - goto st40 - case 114: - goto st40 - } - goto st0 - st40: - p++ - if p == pe { - goto _test_eof40 - } - fallthrough - case 40: - switch data[p] { - case 73: - goto st41 - case 105: - goto st41 - } - goto st0 - st41: - p++ - if p == pe { - goto _test_eof41 - } - fallthrough - case 41: - switch data[p] { - case 84: - goto st42 - case 116: - goto st42 - } - goto st0 - st42: - p++ - if p == pe { - goto _test_eof42 - } - fallthrough - case 42: - switch data[p] { - case 72: - goto st43 - case 104: - goto st43 - } - goto st0 - st43: - p++ - if p == pe { - goto _test_eof43 - } - fallthrough - case 43: - switch data[p] { - case 77: - goto st8 - case 109: - goto st8 - } - goto st0 - tr111: - // line 31 "kparse.rl" - { - mark = p - } - goto st44 - st44: - p++ - if p == pe { - goto _test_eof44 - } - fallthrough - case 44: - // line 773 "kparse.go" - switch data[p] { - case 79: - goto st45 - case 82: - goto st54 - case 111: - goto st45 - case 114: - goto st54 - } - goto st0 - st45: - p++ - if p == pe { - goto _test_eof45 - } - fallthrough - case 45: - switch data[p] { - case 69: - goto st46 - case 101: - goto st46 - } - goto st0 - st46: - p++ - if p == pe { - goto _test_eof46 - } - fallthrough - case 46: - switch data[p] { - case 70: - goto st47 - case 102: - goto st47 - } - goto st0 - st47: - p++ - if p == pe { - goto _test_eof47 - } - fallthrough - case 47: - switch data[p] { - case 70: - goto st48 - case 102: - goto st48 - } - goto st0 - st48: - p++ - if p == pe { - goto _test_eof48 - } - fallthrough - case 48: - switch data[p] { - case 73: - goto st49 - case 105: - goto st49 - } - goto st0 - st49: - p++ - if p == pe { - goto _test_eof49 - } - fallthrough - case 49: - switch data[p] { - case 67: - goto st50 - case 99: - goto st50 - } - goto st0 - st50: - p++ - if p == pe { - goto _test_eof50 - } - fallthrough - case 50: - switch data[p] { - case 73: - goto st51 - case 105: - goto st51 - } - goto st0 - st51: - p++ - if p == pe { - goto _test_eof51 - } - fallthrough - case 51: - switch data[p] { - case 69: - goto st52 - case 101: - goto st52 - } - goto st0 - st52: - p++ - if p == pe { - goto _test_eof52 - } - fallthrough - case 52: - switch data[p] { - case 78: - goto st53 - case 110: - goto st53 - } - goto st0 - st53: - p++ - if p == pe { - goto _test_eof53 - } - fallthrough - case 53: - switch data[p] { - case 84: - goto st8 - case 116: - goto st8 - } - goto st0 - st54: - p++ - if p == pe { - goto _test_eof54 - } - fallthrough - case 54: - switch data[p] { - case 69: - goto st55 - case 101: - goto st55 - } - goto st0 - st55: - p++ - if p == pe { - goto _test_eof55 - } - fallthrough - case 55: - switch data[p] { - case 65: - goto st56 - case 97: - goto st56 - } - goto st0 - st56: - p++ - if p == pe { - goto _test_eof56 - } - fallthrough - case 56: - switch data[p] { - case 84: - goto st57 - case 116: - goto st57 - } - goto st0 - st57: - p++ - if p == pe { - goto _test_eof57 - } - fallthrough - case 57: - switch data[p] { - case 69: - goto st58 - case 101: - goto st58 - } - goto st0 - st58: - p++ - if p == pe { - goto _test_eof58 - } - fallthrough - case 58: - switch data[p] { - case 68: - goto st8 - case 100: - goto st8 - } - goto st0 - tr112: - // line 31 "kparse.rl" - { - mark = p - } - goto st59 - st59: - p++ - if p == pe { - goto _test_eof59 - } - fallthrough - case 59: - // line 930 "kparse.go" - switch data[p] { - case 88: - goto st60 - case 120: - goto st60 - } - goto st0 - st60: - p++ - if p == pe { - goto _test_eof60 - } - fallthrough - case 60: - switch data[p] { - case 80: - goto st61 - case 112: - goto st61 - } - goto st0 - st61: - p++ - if p == pe { - goto _test_eof61 - } - fallthrough - case 61: - switch data[p] { - case 79: - goto st62 - case 111: - goto st62 - } - goto st0 - st62: - p++ - if p == pe { - goto _test_eof62 - } - fallthrough - case 62: - switch data[p] { - case 78: - goto st63 - case 110: - goto st63 - } - goto st0 - st63: - p++ - if p == pe { - goto _test_eof63 - } - fallthrough - case 63: - switch data[p] { - case 69: - goto st64 - case 101: - goto st64 - } - goto st0 - st64: - p++ - if p == pe { - goto _test_eof64 - } - fallthrough - case 64: - switch data[p] { - case 78: - goto st65 - case 110: - goto st65 - } - goto st0 - st65: - p++ - if p == pe { - goto _test_eof65 - } - fallthrough - case 65: - switch data[p] { - case 84: - goto st66 - case 116: - goto st66 - } - goto st0 - st66: - p++ - if p == pe { - goto _test_eof66 - } - fallthrough - case 66: - if 49 <= data[p] && data[p] <= 50 { - goto st8 - } - goto st0 - tr113: - // line 31 "kparse.rl" - { - mark = p - } - goto st67 - st67: - p++ - if p == pe { - goto _test_eof67 - } - fallthrough - case 67: - // line 1012 "kparse.go" - switch data[p] { - case 79: - goto st68 - case 111: - goto st68 - } - goto st0 - st68: - p++ - if p == pe { - goto _test_eof68 - } - fallthrough - case 68: - switch data[p] { - case 83: - goto st69 - case 115: - goto st69 - } - goto st0 - st69: - p++ - if p == pe { - goto _test_eof69 - } - fallthrough - case 69: - switch data[p] { - case 84: - goto st70 - case 116: - goto st70 - } - goto st0 - st70: - p++ - if p == pe { - goto _test_eof70 - } - fallthrough - case 70: - switch data[p] { - case 65: - goto st71 - case 97: - goto st71 - } - goto st0 - st71: - p++ - if p == pe { - goto _test_eof71 - } - fallthrough - case 71: - switch data[p] { - case 83: - goto st72 - case 115: - goto st72 - } - goto st0 - st72: - p++ - if p == pe { - goto _test_eof72 - } - fallthrough - case 72: - switch data[p] { - case 78: - goto st73 - case 110: - goto st73 - } - goto st0 - st73: - p++ - if p == pe { - goto _test_eof73 - } - fallthrough - case 73: - if data[p] == 49 { - goto st8 - } - goto st0 - tr114: - // line 31 "kparse.rl" - { - mark = p - } - goto st74 - st74: - p++ - if p == pe { - goto _test_eof74 - } - fallthrough - case 74: - // line 1084 "kparse.go" - switch data[p] { - case 79: - goto st75 - case 111: - goto st75 - } - goto st0 - st75: - p++ - if p == pe { - goto _test_eof75 - } - fallthrough - case 75: - switch data[p] { - case 68: - goto st76 - case 100: - goto st76 - } - goto st0 - st76: - p++ - if p == pe { - goto _test_eof76 - } - fallthrough - case 76: - switch data[p] { - case 85: - goto st77 - case 117: - goto st77 - } - goto st0 - st77: - p++ - if p == pe { - goto _test_eof77 - } - fallthrough - case 77: - switch data[p] { - case 76: - goto st78 - case 108: - goto st78 - } - goto st0 - st78: - p++ - if p == pe { - goto _test_eof78 - } - fallthrough - case 78: - switch data[p] { - case 85: - goto st79 - case 117: - goto st79 - } - goto st0 - st79: - p++ - if p == pe { - goto _test_eof79 - } - fallthrough - case 79: - switch data[p] { - case 83: - goto st8 - case 115: - goto st8 - } - goto st0 - tr115: - // line 31 "kparse.rl" - { - mark = p - } - goto st80 - st80: - p++ - if p == pe { - goto _test_eof80 - } - fallthrough - case 80: - // line 1149 "kparse.go" - switch data[p] { - case 82: - goto st81 - case 85: - goto st103 - case 114: - goto st81 - case 117: - goto st103 - } - goto st0 - st81: - p++ - if p == pe { - goto _test_eof81 - } - fallthrough - case 81: - switch data[p] { - case 73: - goto st82 - case 105: - goto st82 - } - goto st0 - st82: - p++ - if p == pe { - goto _test_eof82 - } - fallthrough - case 82: - switch data[p] { - case 77: - goto st83 - case 86: - goto st84 - case 109: - goto st83 - case 118: - goto st84 - } - goto st0 - st83: - p++ - if p == pe { - goto _test_eof83 - } - fallthrough - case 83: - switch data[p] { - case 69: - goto st66 - case 101: - goto st66 - } - goto st0 - st84: - p++ - if p == pe { - goto _test_eof84 - } - fallthrough - case 84: - switch data[p] { - case 65: - goto st85 - case 97: - goto st85 - } - goto st0 - st85: - p++ - if p == pe { - goto _test_eof85 - } - fallthrough - case 85: - switch data[p] { - case 84: - goto st86 - case 116: - goto st86 - } - goto st0 - st86: - p++ - if p == pe { - goto _test_eof86 - } - fallthrough - case 86: - switch data[p] { - case 69: - goto st87 - case 101: - goto st87 - } - goto st0 - st87: - p++ - if p == pe { - goto _test_eof87 - } - fallthrough - case 87: - switch data[p] { - case 45: - goto st88 - case 69: - goto st97 - case 75: - goto st101 - case 101: - goto st97 - case 107: - goto st101 - } - goto st0 - st88: - p++ - if p == pe { - goto _test_eof88 - } - fallthrough - case 88: - switch data[p] { - case 75: - goto st89 - case 107: - goto st89 - } - goto st0 - st89: - p++ - if p == pe { - goto _test_eof89 - } - fallthrough - case 89: - switch data[p] { - case 69: - goto st90 - case 101: - goto st90 - } - goto st0 - st90: - p++ - if p == pe { - goto _test_eof90 - } - fallthrough - case 90: - switch data[p] { - case 89: - goto st91 - case 121: - goto st91 - } - goto st0 - st91: - p++ - if p == pe { - goto _test_eof91 - } - fallthrough - case 91: - if data[p] == 45 { - goto st92 - } - goto st0 - st92: - p++ - if p == pe { - goto _test_eof92 - } - fallthrough - case 92: - switch data[p] { - case 70: - goto st93 - case 102: - goto st93 - } - goto st0 - st93: - p++ - if p == pe { - goto _test_eof93 - } - fallthrough - case 93: - switch data[p] { - case 79: - goto st94 - case 111: - goto st94 - } - goto st0 - st94: - p++ - if p == pe { - goto _test_eof94 - } - fallthrough - case 94: - switch data[p] { - case 82: - goto st95 - case 114: - goto st95 - } - goto st0 - st95: - p++ - if p == pe { - goto _test_eof95 - } - fallthrough - case 95: - switch data[p] { - case 77: - goto st96 - case 109: - goto st96 - } - goto st0 - st96: - p++ - if p == pe { - goto _test_eof96 - } - fallthrough - case 96: - switch data[p] { - case 65: - goto st53 - case 97: - goto st53 - } - goto st0 - st97: - p++ - if p == pe { - goto _test_eof97 - } - fallthrough - case 97: - switch data[p] { - case 88: - goto st98 - case 120: - goto st98 - } - goto st0 - st98: - p++ - if p == pe { - goto _test_eof98 - } - fallthrough - case 98: - switch data[p] { - case 80: - goto st99 - case 112: - goto st99 - } - goto st0 - st99: - p++ - if p == pe { - goto _test_eof99 - } - fallthrough - case 99: - switch data[p] { - case 79: - goto st100 - case 111: - goto st100 - } - goto st0 - st100: - p++ - if p == pe { - goto _test_eof100 - } - fallthrough - case 100: - switch data[p] { - case 78: - goto st51 - case 110: - goto st51 - } - goto st0 - st101: - p++ - if p == pe { - goto _test_eof101 - } - fallthrough - case 101: - switch data[p] { - case 69: - goto st102 - case 101: - goto st102 - } - goto st0 - st102: - p++ - if p == pe { - goto _test_eof102 - } - fallthrough - case 102: - switch data[p] { - case 89: - goto st8 - case 121: - goto st8 - } - goto st0 - st103: - p++ - if p == pe { - goto _test_eof103 - } - fallthrough - case 103: - switch data[p] { - case 66: - goto st104 - case 98: - goto st104 - } - goto st0 - st104: - p++ - if p == pe { - goto _test_eof104 - } - fallthrough - case 104: - switch data[p] { - case 76: - goto st105 - case 108: - goto st105 - } - goto st0 - st105: - p++ - if p == pe { - goto _test_eof105 - } - fallthrough - case 105: - switch data[p] { - case 73: - goto st106 - case 105: - goto st106 - } - goto st0 - st106: - p++ - if p == pe { - goto _test_eof106 - } - fallthrough - case 106: - switch data[p] { - case 67: - goto st107 - case 83: - goto st108 - case 99: - goto st107 - case 115: - goto st108 - } - goto st0 - st107: - p++ - if p == pe { - goto _test_eof107 - } - fallthrough - case 107: - switch data[p] { - case 69: - goto st97 - case 101: - goto st97 - } - goto st0 - st108: - p++ - if p == pe { - goto _test_eof108 - } - fallthrough - case 108: - switch data[p] { - case 72: - goto st8 - case 104: - goto st8 - } - goto st0 - st109: - p++ - if p == pe { - goto _test_eof109 - } - fallthrough - case 109: - if data[p] == 59 { - goto st110 - } - goto st0 - st110: - p++ - if p == pe { - goto _test_eof110 - } - fallthrough - case 110: - if data[p] == 10 { goto st111 + tr28: + // line 34 "kparse.rl" + { + m[k] = strings.ToUpper(data[mark : p-1]) + } + goto st111 + tr40: + // line 33 "kparse.rl" + { + m[k] = data[mark:p] + } + // line 34 "kparse.rl" + { + m[k] = strings.ToUpper(data[mark : p-1]) + } + goto st111 + st111: + p++ + if p == pe { + goto _test_eof111 + } + fallthrough + case 111: + // line 68 "kparse.go" + switch data[p] { + case 65: + goto tr110 + case 67: + goto tr111 + case 69: + goto tr112 + case 71: + goto tr113 + case 77: + goto tr114 + case 80: + goto tr115 + case 94: + goto st109 + case 97: + goto tr110 + case 99: + goto tr111 + case 101: + goto tr112 + case 103: + goto tr113 + case 109: + goto tr114 + case 112: + goto tr115 + } + goto st0 + st0: + cs = 0 + goto _out + tr110: + // line 31 "kparse.rl" + { + mark = p + } + goto st1 + st1: + p++ + if p == pe { + goto _test_eof1 + } + fallthrough + case 1: + // line 97 "kparse.go" + switch data[p] { + case 67: + goto st2 + case 76: + goto st37 + case 99: + goto st2 + case 108: + goto st37 + } + goto st0 + st2: + p++ + if p == pe { + goto _test_eof2 + } + fallthrough + case 2: + switch data[p] { + case 84: + goto st3 + case 116: + goto st3 + } + goto st0 + st3: + p++ + if p == pe { + goto _test_eof3 + } + fallthrough + case 3: + switch data[p] { + case 73: + goto st4 + case 105: + goto st4 + } + goto st0 + st4: + p++ + if p == pe { + goto _test_eof4 + } + fallthrough + case 4: + switch data[p] { + case 86: + goto st5 + case 118: + goto st5 + } + goto st0 + st5: + p++ + if p == pe { + goto _test_eof5 + } + fallthrough + case 5: + switch data[p] { + case 65: + goto st6 + case 97: + goto st6 + } + goto st0 + st6: + p++ + if p == pe { + goto _test_eof6 + } + fallthrough + case 6: + switch data[p] { + case 84: + goto st7 + case 116: + goto st7 + } + goto st0 + st7: + p++ + if p == pe { + goto _test_eof7 + } + fallthrough + case 7: + switch data[p] { + case 69: + goto st8 + case 101: + goto st8 + } + goto st0 + st8: + p++ + if p == pe { + goto _test_eof8 + } + fallthrough + case 8: + if data[p] == 58 { + goto tr9 + } + goto st0 + tr9: + // line 32 "kparse.rl" + { + k = strings.ToLower(data[mark:p]) + } + goto st9 + st9: + p++ + if p == pe { + goto _test_eof9 + } + fallthrough + case 9: + // line 181 "kparse.go" + if data[p] == 32 { + goto st10 + } + goto st0 + st10: + p++ + if p == pe { + goto _test_eof10 + } + fallthrough + case 10: + switch data[p] { + case 32: + goto tr11 + case 43: + goto tr11 + case 61: + goto tr11 + case 92: + goto tr11 + } + if data[p] < 48 { + if data[p] > 41 { + if 46 <= data[p] && data[p] <= 47 { + goto tr11 + } + } else if data[p] >= 40 { + goto tr11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto tr11 + } + } else if data[p] >= 65 { + goto tr11 + } + } else { + goto tr12 + } + goto st0 + tr11: + // line 31 "kparse.rl" + { + mark = p + } + goto st11 + st11: + p++ + if p == pe { + goto _test_eof11 + } + fallthrough + case 11: + // line 220 "kparse.go" + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 61: + goto st11 + case 92: + goto st11 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st11 + } + goto st0 + tr12: + // line 31 "kparse.rl" + { + mark = p + } + goto st12 + st12: + p++ + if p == pe { + goto _test_eof12 + } + fallthrough + case 12: + // line 249 "kparse.go" + switch data[p] { + case 9: + goto st13 + case 10: + goto tr13 + case 32: + goto st25 + case 43: + goto st11 + case 61: + goto st11 + case 92: + goto st11 + } + if data[p] < 48 { + if data[p] > 41 { + if 46 <= data[p] && data[p] <= 47 { + goto st11 + } + } else if data[p] >= 40 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st12 + } + goto st0 + st13: + p++ + if p == pe { + goto _test_eof13 + } + fallthrough + case 13: + switch data[p] { + case 9: + goto st13 + case 32: + goto st13 + case 40: + goto st14 + } + goto st0 + st14: + p++ + if p == pe { + goto _test_eof14 + } + fallthrough + case 14: + switch data[p] { + case 82: + goto tr19 + case 114: + goto tr19 + } + goto st0 + tr19: + // line 31 "kparse.rl" + { + mark = p + } + goto st15 + st15: + p++ + if p == pe { + goto _test_eof15 + } + fallthrough + case 15: + // line 304 "kparse.go" + switch data[p] { + case 83: + goto st16 + case 115: + goto st16 + } + goto st0 + st16: + p++ + if p == pe { + goto _test_eof16 + } + fallthrough + case 16: + switch data[p] { + case 65: + goto st17 + case 97: + goto st17 + } + goto st0 + st17: + p++ + if p == pe { + goto _test_eof17 + } + fallthrough + case 17: + switch data[p] { + case 83: + goto st18 + case 115: + goto st18 + } + goto st0 + st18: + p++ + if p == pe { + goto _test_eof18 + } + fallthrough + case 18: + switch data[p] { + case 72: + goto st19 + case 104: + goto st19 + } + goto st0 + st19: + p++ + if p == pe { + goto _test_eof19 + } + fallthrough + case 19: + switch data[p] { + case 65: + goto st20 + case 97: + goto st20 + } + goto st0 + st20: + p++ + if p == pe { + goto _test_eof20 + } + fallthrough + case 20: + switch data[p] { + case 49: + goto st21 + case 50: + goto st23 + } + goto st0 + st21: + p++ + if p == pe { + goto _test_eof21 + } + fallthrough + case 21: + if data[p] == 41 { + goto st22 + } + goto st0 + st22: + p++ + if p == pe { + goto _test_eof22 + } + fallthrough + case 22: + if data[p] == 10 { + goto tr28 + } + goto st0 + st23: + p++ + if p == pe { + goto _test_eof23 + } + fallthrough + case 23: + if data[p] == 53 { + goto st24 + } + goto st0 + st24: + p++ + if p == pe { + goto _test_eof24 + } + fallthrough + case 24: + if data[p] == 54 { + goto st21 + } + goto st0 + st25: + p++ + if p == pe { + goto _test_eof25 + } + fallthrough + case 25: + switch data[p] { + case 9: + goto st13 + case 10: + goto tr13 + case 32: + goto st25 + case 40: + goto st26 + case 41: + goto st11 + case 43: + goto st11 + case 61: + goto st11 + case 92: + goto st11 + } + if data[p] < 65 { + if 46 <= data[p] && data[p] <= 57 { + goto st11 + } + } else if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st26: + p++ + if p == pe { + goto _test_eof26 + } + fallthrough + case 26: + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 61: + goto st11 + case 82: + goto tr31 + case 92: + goto st11 + case 114: + goto tr31 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st11 + } + goto st0 + tr31: + // line 31 "kparse.rl" + { + mark = p + } + goto st27 + st27: + p++ + if p == pe { + goto _test_eof27 + } + fallthrough + case 27: + // line 446 "kparse.go" + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 61: + goto st11 + case 83: + goto st28 + case 92: + goto st11 + case 115: + goto st28 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st28: + p++ + if p == pe { + goto _test_eof28 + } + fallthrough + case 28: + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 61: + goto st11 + case 65: + goto st29 + case 92: + goto st11 + case 97: + goto st29 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 98 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 66 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st29: + p++ + if p == pe { + goto _test_eof29 + } + fallthrough + case 29: + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 61: + goto st11 + case 83: + goto st30 + case 92: + goto st11 + case 115: + goto st30 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st30: + p++ + if p == pe { + goto _test_eof30 + } + fallthrough + case 30: + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 61: + goto st11 + case 72: + goto st31 + case 92: + goto st11 + case 104: + goto st31 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st31: + p++ + if p == pe { + goto _test_eof31 + } + fallthrough + case 31: + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 61: + goto st11 + case 65: + goto st32 + case 92: + goto st11 + case 97: + goto st32 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 98 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 66 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st32: + p++ + if p == pe { + goto _test_eof32 + } + fallthrough + case 32: + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 49: + goto st33 + case 50: + goto st35 + case 61: + goto st11 + case 92: + goto st11 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st33: + p++ + if p == pe { + goto _test_eof33 + } + fallthrough + case 33: + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 40: + goto st11 + case 41: + goto st34 + case 43: + goto st11 + case 61: + goto st11 + case 92: + goto st11 + } + if data[p] < 65 { + if 46 <= data[p] && data[p] <= 57 { + goto st11 + } + } else if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st34: + p++ + if p == pe { + goto _test_eof34 + } + fallthrough + case 34: + switch data[p] { + case 10: + goto tr40 + case 32: + goto st11 + case 43: + goto st11 + case 61: + goto st11 + case 92: + goto st11 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st35: + p++ + if p == pe { + goto _test_eof35 + } + fallthrough + case 35: + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 53: + goto st36 + case 61: + goto st11 + case 92: + goto st11 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st36: + p++ + if p == pe { + goto _test_eof36 + } + fallthrough + case 36: + switch data[p] { + case 10: + goto tr13 + case 32: + goto st11 + case 43: + goto st11 + case 54: + goto st33 + case 61: + goto st11 + case 92: + goto st11 + } + if data[p] < 46 { + if 40 <= data[p] && data[p] <= 41 { + goto st11 + } + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st11 + } + } else if data[p] >= 65 { + goto st11 + } + } else { + goto st11 + } + goto st0 + st37: + p++ + if p == pe { + goto _test_eof37 + } + fallthrough + case 37: + switch data[p] { + case 71: + goto st38 + case 103: + goto st38 + } + goto st0 + st38: + p++ + if p == pe { + goto _test_eof38 + } + fallthrough + case 38: + switch data[p] { + case 79: + goto st39 + case 111: + goto st39 + } + goto st0 + st39: + p++ + if p == pe { + goto _test_eof39 + } + fallthrough + case 39: + switch data[p] { + case 82: + goto st40 + case 114: + goto st40 + } + goto st0 + st40: + p++ + if p == pe { + goto _test_eof40 + } + fallthrough + case 40: + switch data[p] { + case 73: + goto st41 + case 105: + goto st41 + } + goto st0 + st41: + p++ + if p == pe { + goto _test_eof41 + } + fallthrough + case 41: + switch data[p] { + case 84: + goto st42 + case 116: + goto st42 + } + goto st0 + st42: + p++ + if p == pe { + goto _test_eof42 + } + fallthrough + case 42: + switch data[p] { + case 72: + goto st43 + case 104: + goto st43 + } + goto st0 + st43: + p++ + if p == pe { + goto _test_eof43 + } + fallthrough + case 43: + switch data[p] { + case 77: + goto st8 + case 109: + goto st8 + } + goto st0 + tr111: + // line 31 "kparse.rl" + { + mark = p + } + goto st44 + st44: + p++ + if p == pe { + goto _test_eof44 + } + fallthrough + case 44: + // line 773 "kparse.go" + switch data[p] { + case 79: + goto st45 + case 82: + goto st54 + case 111: + goto st45 + case 114: + goto st54 + } + goto st0 + st45: + p++ + if p == pe { + goto _test_eof45 + } + fallthrough + case 45: + switch data[p] { + case 69: + goto st46 + case 101: + goto st46 + } + goto st0 + st46: + p++ + if p == pe { + goto _test_eof46 + } + fallthrough + case 46: + switch data[p] { + case 70: + goto st47 + case 102: + goto st47 + } + goto st0 + st47: + p++ + if p == pe { + goto _test_eof47 + } + fallthrough + case 47: + switch data[p] { + case 70: + goto st48 + case 102: + goto st48 + } + goto st0 + st48: + p++ + if p == pe { + goto _test_eof48 + } + fallthrough + case 48: + switch data[p] { + case 73: + goto st49 + case 105: + goto st49 + } + goto st0 + st49: + p++ + if p == pe { + goto _test_eof49 + } + fallthrough + case 49: + switch data[p] { + case 67: + goto st50 + case 99: + goto st50 + } + goto st0 + st50: + p++ + if p == pe { + goto _test_eof50 + } + fallthrough + case 50: + switch data[p] { + case 73: + goto st51 + case 105: + goto st51 + } + goto st0 + st51: + p++ + if p == pe { + goto _test_eof51 + } + fallthrough + case 51: + switch data[p] { + case 69: + goto st52 + case 101: + goto st52 + } + goto st0 + st52: + p++ + if p == pe { + goto _test_eof52 + } + fallthrough + case 52: + switch data[p] { + case 78: + goto st53 + case 110: + goto st53 + } + goto st0 + st53: + p++ + if p == pe { + goto _test_eof53 + } + fallthrough + case 53: + switch data[p] { + case 84: + goto st8 + case 116: + goto st8 + } + goto st0 + st54: + p++ + if p == pe { + goto _test_eof54 + } + fallthrough + case 54: + switch data[p] { + case 69: + goto st55 + case 101: + goto st55 + } + goto st0 + st55: + p++ + if p == pe { + goto _test_eof55 + } + fallthrough + case 55: + switch data[p] { + case 65: + goto st56 + case 97: + goto st56 + } + goto st0 + st56: + p++ + if p == pe { + goto _test_eof56 + } + fallthrough + case 56: + switch data[p] { + case 84: + goto st57 + case 116: + goto st57 + } + goto st0 + st57: + p++ + if p == pe { + goto _test_eof57 + } + fallthrough + case 57: + switch data[p] { + case 69: + goto st58 + case 101: + goto st58 + } + goto st0 + st58: + p++ + if p == pe { + goto _test_eof58 + } + fallthrough + case 58: + switch data[p] { + case 68: + goto st8 + case 100: + goto st8 + } + goto st0 + tr112: + // line 31 "kparse.rl" + { + mark = p + } + goto st59 + st59: + p++ + if p == pe { + goto _test_eof59 + } + fallthrough + case 59: + // line 930 "kparse.go" + switch data[p] { + case 88: + goto st60 + case 120: + goto st60 + } + goto st0 + st60: + p++ + if p == pe { + goto _test_eof60 + } + fallthrough + case 60: + switch data[p] { + case 80: + goto st61 + case 112: + goto st61 + } + goto st0 + st61: + p++ + if p == pe { + goto _test_eof61 + } + fallthrough + case 61: + switch data[p] { + case 79: + goto st62 + case 111: + goto st62 + } + goto st0 + st62: + p++ + if p == pe { + goto _test_eof62 + } + fallthrough + case 62: + switch data[p] { + case 78: + goto st63 + case 110: + goto st63 + } + goto st0 + st63: + p++ + if p == pe { + goto _test_eof63 + } + fallthrough + case 63: + switch data[p] { + case 69: + goto st64 + case 101: + goto st64 + } + goto st0 + st64: + p++ + if p == pe { + goto _test_eof64 + } + fallthrough + case 64: + switch data[p] { + case 78: + goto st65 + case 110: + goto st65 + } + goto st0 + st65: + p++ + if p == pe { + goto _test_eof65 + } + fallthrough + case 65: + switch data[p] { + case 84: + goto st66 + case 116: + goto st66 + } + goto st0 + st66: + p++ + if p == pe { + goto _test_eof66 + } + fallthrough + case 66: + if 49 <= data[p] && data[p] <= 50 { + goto st8 + } + goto st0 + tr113: + // line 31 "kparse.rl" + { + mark = p + } + goto st67 + st67: + p++ + if p == pe { + goto _test_eof67 + } + fallthrough + case 67: + // line 1012 "kparse.go" + switch data[p] { + case 79: + goto st68 + case 111: + goto st68 + } + goto st0 + st68: + p++ + if p == pe { + goto _test_eof68 + } + fallthrough + case 68: + switch data[p] { + case 83: + goto st69 + case 115: + goto st69 + } + goto st0 + st69: + p++ + if p == pe { + goto _test_eof69 + } + fallthrough + case 69: + switch data[p] { + case 84: + goto st70 + case 116: + goto st70 + } + goto st0 + st70: + p++ + if p == pe { + goto _test_eof70 + } + fallthrough + case 70: + switch data[p] { + case 65: + goto st71 + case 97: + goto st71 + } + goto st0 + st71: + p++ + if p == pe { + goto _test_eof71 + } + fallthrough + case 71: + switch data[p] { + case 83: + goto st72 + case 115: + goto st72 + } + goto st0 + st72: + p++ + if p == pe { + goto _test_eof72 + } + fallthrough + case 72: + switch data[p] { + case 78: + goto st73 + case 110: + goto st73 + } + goto st0 + st73: + p++ + if p == pe { + goto _test_eof73 + } + fallthrough + case 73: + if data[p] == 49 { + goto st8 + } + goto st0 + tr114: + // line 31 "kparse.rl" + { + mark = p + } + goto st74 + st74: + p++ + if p == pe { + goto _test_eof74 + } + fallthrough + case 74: + // line 1084 "kparse.go" + switch data[p] { + case 79: + goto st75 + case 111: + goto st75 + } + goto st0 + st75: + p++ + if p == pe { + goto _test_eof75 + } + fallthrough + case 75: + switch data[p] { + case 68: + goto st76 + case 100: + goto st76 + } + goto st0 + st76: + p++ + if p == pe { + goto _test_eof76 + } + fallthrough + case 76: + switch data[p] { + case 85: + goto st77 + case 117: + goto st77 + } + goto st0 + st77: + p++ + if p == pe { + goto _test_eof77 + } + fallthrough + case 77: + switch data[p] { + case 76: + goto st78 + case 108: + goto st78 + } + goto st0 + st78: + p++ + if p == pe { + goto _test_eof78 + } + fallthrough + case 78: + switch data[p] { + case 85: + goto st79 + case 117: + goto st79 + } + goto st0 + st79: + p++ + if p == pe { + goto _test_eof79 + } + fallthrough + case 79: + switch data[p] { + case 83: + goto st8 + case 115: + goto st8 + } + goto st0 + tr115: + // line 31 "kparse.rl" + { + mark = p + } + goto st80 + st80: + p++ + if p == pe { + goto _test_eof80 + } + fallthrough + case 80: + // line 1149 "kparse.go" + switch data[p] { + case 82: + goto st81 + case 85: + goto st103 + case 114: + goto st81 + case 117: + goto st103 + } + goto st0 + st81: + p++ + if p == pe { + goto _test_eof81 + } + fallthrough + case 81: + switch data[p] { + case 73: + goto st82 + case 105: + goto st82 + } + goto st0 + st82: + p++ + if p == pe { + goto _test_eof82 + } + fallthrough + case 82: + switch data[p] { + case 77: + goto st83 + case 86: + goto st84 + case 109: + goto st83 + case 118: + goto st84 + } + goto st0 + st83: + p++ + if p == pe { + goto _test_eof83 + } + fallthrough + case 83: + switch data[p] { + case 69: + goto st66 + case 101: + goto st66 + } + goto st0 + st84: + p++ + if p == pe { + goto _test_eof84 + } + fallthrough + case 84: + switch data[p] { + case 65: + goto st85 + case 97: + goto st85 + } + goto st0 + st85: + p++ + if p == pe { + goto _test_eof85 + } + fallthrough + case 85: + switch data[p] { + case 84: + goto st86 + case 116: + goto st86 + } + goto st0 + st86: + p++ + if p == pe { + goto _test_eof86 + } + fallthrough + case 86: + switch data[p] { + case 69: + goto st87 + case 101: + goto st87 + } + goto st0 + st87: + p++ + if p == pe { + goto _test_eof87 + } + fallthrough + case 87: + switch data[p] { + case 45: + goto st88 + case 69: + goto st97 + case 75: + goto st101 + case 101: + goto st97 + case 107: + goto st101 + } + goto st0 + st88: + p++ + if p == pe { + goto _test_eof88 + } + fallthrough + case 88: + switch data[p] { + case 75: + goto st89 + case 107: + goto st89 + } + goto st0 + st89: + p++ + if p == pe { + goto _test_eof89 + } + fallthrough + case 89: + switch data[p] { + case 69: + goto st90 + case 101: + goto st90 + } + goto st0 + st90: + p++ + if p == pe { + goto _test_eof90 + } + fallthrough + case 90: + switch data[p] { + case 89: + goto st91 + case 121: + goto st91 + } + goto st0 + st91: + p++ + if p == pe { + goto _test_eof91 + } + fallthrough + case 91: + if data[p] == 45 { + goto st92 + } + goto st0 + st92: + p++ + if p == pe { + goto _test_eof92 + } + fallthrough + case 92: + switch data[p] { + case 70: + goto st93 + case 102: + goto st93 + } + goto st0 + st93: + p++ + if p == pe { + goto _test_eof93 + } + fallthrough + case 93: + switch data[p] { + case 79: + goto st94 + case 111: + goto st94 + } + goto st0 + st94: + p++ + if p == pe { + goto _test_eof94 + } + fallthrough + case 94: + switch data[p] { + case 82: + goto st95 + case 114: + goto st95 + } + goto st0 + st95: + p++ + if p == pe { + goto _test_eof95 + } + fallthrough + case 95: + switch data[p] { + case 77: + goto st96 + case 109: + goto st96 + } + goto st0 + st96: + p++ + if p == pe { + goto _test_eof96 + } + fallthrough + case 96: + switch data[p] { + case 65: + goto st53 + case 97: + goto st53 + } + goto st0 + st97: + p++ + if p == pe { + goto _test_eof97 + } + fallthrough + case 97: + switch data[p] { + case 88: + goto st98 + case 120: + goto st98 + } + goto st0 + st98: + p++ + if p == pe { + goto _test_eof98 + } + fallthrough + case 98: + switch data[p] { + case 80: + goto st99 + case 112: + goto st99 + } + goto st0 + st99: + p++ + if p == pe { + goto _test_eof99 + } + fallthrough + case 99: + switch data[p] { + case 79: + goto st100 + case 111: + goto st100 + } + goto st0 + st100: + p++ + if p == pe { + goto _test_eof100 + } + fallthrough + case 100: + switch data[p] { + case 78: + goto st51 + case 110: + goto st51 + } + goto st0 + st101: + p++ + if p == pe { + goto _test_eof101 + } + fallthrough + case 101: + switch data[p] { + case 69: + goto st102 + case 101: + goto st102 + } + goto st0 + st102: + p++ + if p == pe { + goto _test_eof102 + } + fallthrough + case 102: + switch data[p] { + case 89: + goto st8 + case 121: + goto st8 + } + goto st0 + st103: + p++ + if p == pe { + goto _test_eof103 + } + fallthrough + case 103: + switch data[p] { + case 66: + goto st104 + case 98: + goto st104 + } + goto st0 + st104: + p++ + if p == pe { + goto _test_eof104 + } + fallthrough + case 104: + switch data[p] { + case 76: + goto st105 + case 108: + goto st105 + } + goto st0 + st105: + p++ + if p == pe { + goto _test_eof105 + } + fallthrough + case 105: + switch data[p] { + case 73: + goto st106 + case 105: + goto st106 + } + goto st0 + st106: + p++ + if p == pe { + goto _test_eof106 + } + fallthrough + case 106: + switch data[p] { + case 67: + goto st107 + case 83: + goto st108 + case 99: + goto st107 + case 115: + goto st108 + } + goto st0 + st107: + p++ + if p == pe { + goto _test_eof107 + } + fallthrough + case 107: + switch data[p] { + case 69: + goto st97 + case 101: + goto st97 + } + goto st0 + st108: + p++ + if p == pe { + goto _test_eof108 + } + fallthrough + case 108: + switch data[p] { + case 72: + goto st8 + case 104: + goto st8 + } + goto st0 + st109: + p++ + if p == pe { + goto _test_eof109 + } + fallthrough + case 109: + if data[p] == 59 { + goto st110 + } + goto st0 + st110: + p++ + if p == pe { + goto _test_eof110 + } + fallthrough + case 110: + if data[p] == 10 { + goto st111 + } + goto st0 } - goto st0 - } - _test_eof111: - cs = 111 - goto _test_eof - _test_eof1: - cs = 1 - goto _test_eof - _test_eof2: - cs = 2 - goto _test_eof - _test_eof3: - cs = 3 - goto _test_eof - _test_eof4: - cs = 4 - goto _test_eof - _test_eof5: - cs = 5 - goto _test_eof - _test_eof6: - cs = 6 - goto _test_eof - _test_eof7: - cs = 7 - goto _test_eof - _test_eof8: - cs = 8 - goto _test_eof - _test_eof9: - cs = 9 - goto _test_eof - _test_eof10: - cs = 10 - goto _test_eof - _test_eof11: - cs = 11 - goto _test_eof - _test_eof12: - cs = 12 - goto _test_eof - _test_eof13: - cs = 13 - goto _test_eof - _test_eof14: - cs = 14 - goto _test_eof - _test_eof15: - cs = 15 - goto _test_eof - _test_eof16: - cs = 16 - goto _test_eof - _test_eof17: - cs = 17 - goto _test_eof - _test_eof18: - cs = 18 - goto _test_eof - _test_eof19: - cs = 19 - goto _test_eof - _test_eof20: - cs = 20 - goto _test_eof - _test_eof21: - cs = 21 - goto _test_eof - _test_eof22: - cs = 22 - goto _test_eof - _test_eof23: - cs = 23 - goto _test_eof - _test_eof24: - cs = 24 - goto _test_eof - _test_eof25: - cs = 25 - goto _test_eof - _test_eof26: - cs = 26 - goto _test_eof - _test_eof27: - cs = 27 - goto _test_eof - _test_eof28: - cs = 28 - goto _test_eof - _test_eof29: - cs = 29 - goto _test_eof - _test_eof30: - cs = 30 - goto _test_eof - _test_eof31: - cs = 31 - goto _test_eof - _test_eof32: - cs = 32 - goto _test_eof - _test_eof33: - cs = 33 - goto _test_eof - _test_eof34: - cs = 34 - goto _test_eof - _test_eof35: - cs = 35 - goto _test_eof - _test_eof36: - cs = 36 - goto _test_eof - _test_eof37: - cs = 37 - goto _test_eof - _test_eof38: - cs = 38 - goto _test_eof - _test_eof39: - cs = 39 - goto _test_eof - _test_eof40: - cs = 40 - goto _test_eof - _test_eof41: - cs = 41 - goto _test_eof - _test_eof42: - cs = 42 - goto _test_eof - _test_eof43: - cs = 43 - goto _test_eof - _test_eof44: - cs = 44 - goto _test_eof - _test_eof45: - cs = 45 - goto _test_eof - _test_eof46: - cs = 46 - goto _test_eof - _test_eof47: - cs = 47 - goto _test_eof - _test_eof48: - cs = 48 - goto _test_eof - _test_eof49: - cs = 49 - goto _test_eof - _test_eof50: - cs = 50 - goto _test_eof - _test_eof51: - cs = 51 - goto _test_eof - _test_eof52: - cs = 52 - goto _test_eof - _test_eof53: - cs = 53 - goto _test_eof - _test_eof54: - cs = 54 - goto _test_eof - _test_eof55: - cs = 55 - goto _test_eof - _test_eof56: - cs = 56 - goto _test_eof - _test_eof57: - cs = 57 - goto _test_eof - _test_eof58: - cs = 58 - goto _test_eof - _test_eof59: - cs = 59 - goto _test_eof - _test_eof60: - cs = 60 - goto _test_eof - _test_eof61: - cs = 61 - goto _test_eof - _test_eof62: - cs = 62 - goto _test_eof - _test_eof63: - cs = 63 - goto _test_eof - _test_eof64: - cs = 64 - goto _test_eof - _test_eof65: - cs = 65 - goto _test_eof - _test_eof66: - cs = 66 - goto _test_eof - _test_eof67: - cs = 67 - goto _test_eof - _test_eof68: - cs = 68 - goto _test_eof - _test_eof69: - cs = 69 - goto _test_eof - _test_eof70: - cs = 70 - goto _test_eof - _test_eof71: - cs = 71 - goto _test_eof - _test_eof72: - cs = 72 - goto _test_eof - _test_eof73: - cs = 73 - goto _test_eof - _test_eof74: - cs = 74 - goto _test_eof - _test_eof75: - cs = 75 - goto _test_eof - _test_eof76: - cs = 76 - goto _test_eof - _test_eof77: - cs = 77 - goto _test_eof - _test_eof78: - cs = 78 - goto _test_eof - _test_eof79: - cs = 79 - goto _test_eof - _test_eof80: - cs = 80 - goto _test_eof - _test_eof81: - cs = 81 - goto _test_eof - _test_eof82: - cs = 82 - goto _test_eof - _test_eof83: - cs = 83 - goto _test_eof - _test_eof84: - cs = 84 - goto _test_eof - _test_eof85: - cs = 85 - goto _test_eof - _test_eof86: - cs = 86 - goto _test_eof - _test_eof87: - cs = 87 - goto _test_eof - _test_eof88: - cs = 88 - goto _test_eof - _test_eof89: - cs = 89 - goto _test_eof - _test_eof90: - cs = 90 - goto _test_eof - _test_eof91: - cs = 91 - goto _test_eof - _test_eof92: - cs = 92 - goto _test_eof - _test_eof93: - cs = 93 - goto _test_eof - _test_eof94: - cs = 94 - goto _test_eof - _test_eof95: - cs = 95 - goto _test_eof - _test_eof96: - cs = 96 - goto _test_eof - _test_eof97: - cs = 97 - goto _test_eof - _test_eof98: - cs = 98 - goto _test_eof - _test_eof99: - cs = 99 - goto _test_eof - _test_eof100: - cs = 100 - goto _test_eof - _test_eof101: - cs = 101 - goto _test_eof - _test_eof102: - cs = 102 - goto _test_eof - _test_eof103: - cs = 103 - goto _test_eof - _test_eof104: - cs = 104 - goto _test_eof - _test_eof105: - cs = 105 - goto _test_eof - _test_eof106: - cs = 106 - goto _test_eof - _test_eof107: - cs = 107 - goto _test_eof - _test_eof108: - cs = 108 - goto _test_eof - _test_eof109: - cs = 109 - goto _test_eof - _test_eof110: - cs = 110 - goto _test_eof + _test_eof111: + cs = 111 + goto _test_eof + _test_eof1: + cs = 1 + goto _test_eof + _test_eof2: + cs = 2 + goto _test_eof + _test_eof3: + cs = 3 + goto _test_eof + _test_eof4: + cs = 4 + goto _test_eof + _test_eof5: + cs = 5 + goto _test_eof + _test_eof6: + cs = 6 + goto _test_eof + _test_eof7: + cs = 7 + goto _test_eof + _test_eof8: + cs = 8 + goto _test_eof + _test_eof9: + cs = 9 + goto _test_eof + _test_eof10: + cs = 10 + goto _test_eof + _test_eof11: + cs = 11 + goto _test_eof + _test_eof12: + cs = 12 + goto _test_eof + _test_eof13: + cs = 13 + goto _test_eof + _test_eof14: + cs = 14 + goto _test_eof + _test_eof15: + cs = 15 + goto _test_eof + _test_eof16: + cs = 16 + goto _test_eof + _test_eof17: + cs = 17 + goto _test_eof + _test_eof18: + cs = 18 + goto _test_eof + _test_eof19: + cs = 19 + goto _test_eof + _test_eof20: + cs = 20 + goto _test_eof + _test_eof21: + cs = 21 + goto _test_eof + _test_eof22: + cs = 22 + goto _test_eof + _test_eof23: + cs = 23 + goto _test_eof + _test_eof24: + cs = 24 + goto _test_eof + _test_eof25: + cs = 25 + goto _test_eof + _test_eof26: + cs = 26 + goto _test_eof + _test_eof27: + cs = 27 + goto _test_eof + _test_eof28: + cs = 28 + goto _test_eof + _test_eof29: + cs = 29 + goto _test_eof + _test_eof30: + cs = 30 + goto _test_eof + _test_eof31: + cs = 31 + goto _test_eof + _test_eof32: + cs = 32 + goto _test_eof + _test_eof33: + cs = 33 + goto _test_eof + _test_eof34: + cs = 34 + goto _test_eof + _test_eof35: + cs = 35 + goto _test_eof + _test_eof36: + cs = 36 + goto _test_eof + _test_eof37: + cs = 37 + goto _test_eof + _test_eof38: + cs = 38 + goto _test_eof + _test_eof39: + cs = 39 + goto _test_eof + _test_eof40: + cs = 40 + goto _test_eof + _test_eof41: + cs = 41 + goto _test_eof + _test_eof42: + cs = 42 + goto _test_eof + _test_eof43: + cs = 43 + goto _test_eof + _test_eof44: + cs = 44 + goto _test_eof + _test_eof45: + cs = 45 + goto _test_eof + _test_eof46: + cs = 46 + goto _test_eof + _test_eof47: + cs = 47 + goto _test_eof + _test_eof48: + cs = 48 + goto _test_eof + _test_eof49: + cs = 49 + goto _test_eof + _test_eof50: + cs = 50 + goto _test_eof + _test_eof51: + cs = 51 + goto _test_eof + _test_eof52: + cs = 52 + goto _test_eof + _test_eof53: + cs = 53 + goto _test_eof + _test_eof54: + cs = 54 + goto _test_eof + _test_eof55: + cs = 55 + goto _test_eof + _test_eof56: + cs = 56 + goto _test_eof + _test_eof57: + cs = 57 + goto _test_eof + _test_eof58: + cs = 58 + goto _test_eof + _test_eof59: + cs = 59 + goto _test_eof + _test_eof60: + cs = 60 + goto _test_eof + _test_eof61: + cs = 61 + goto _test_eof + _test_eof62: + cs = 62 + goto _test_eof + _test_eof63: + cs = 63 + goto _test_eof + _test_eof64: + cs = 64 + goto _test_eof + _test_eof65: + cs = 65 + goto _test_eof + _test_eof66: + cs = 66 + goto _test_eof + _test_eof67: + cs = 67 + goto _test_eof + _test_eof68: + cs = 68 + goto _test_eof + _test_eof69: + cs = 69 + goto _test_eof + _test_eof70: + cs = 70 + goto _test_eof + _test_eof71: + cs = 71 + goto _test_eof + _test_eof72: + cs = 72 + goto _test_eof + _test_eof73: + cs = 73 + goto _test_eof + _test_eof74: + cs = 74 + goto _test_eof + _test_eof75: + cs = 75 + goto _test_eof + _test_eof76: + cs = 76 + goto _test_eof + _test_eof77: + cs = 77 + goto _test_eof + _test_eof78: + cs = 78 + goto _test_eof + _test_eof79: + cs = 79 + goto _test_eof + _test_eof80: + cs = 80 + goto _test_eof + _test_eof81: + cs = 81 + goto _test_eof + _test_eof82: + cs = 82 + goto _test_eof + _test_eof83: + cs = 83 + goto _test_eof + _test_eof84: + cs = 84 + goto _test_eof + _test_eof85: + cs = 85 + goto _test_eof + _test_eof86: + cs = 86 + goto _test_eof + _test_eof87: + cs = 87 + goto _test_eof + _test_eof88: + cs = 88 + goto _test_eof + _test_eof89: + cs = 89 + goto _test_eof + _test_eof90: + cs = 90 + goto _test_eof + _test_eof91: + cs = 91 + goto _test_eof + _test_eof92: + cs = 92 + goto _test_eof + _test_eof93: + cs = 93 + goto _test_eof + _test_eof94: + cs = 94 + goto _test_eof + _test_eof95: + cs = 95 + goto _test_eof + _test_eof96: + cs = 96 + goto _test_eof + _test_eof97: + cs = 97 + goto _test_eof + _test_eof98: + cs = 98 + goto _test_eof + _test_eof99: + cs = 99 + goto _test_eof + _test_eof100: + cs = 100 + goto _test_eof + _test_eof101: + cs = 101 + goto _test_eof + _test_eof102: + cs = 102 + goto _test_eof + _test_eof103: + cs = 103 + goto _test_eof + _test_eof104: + cs = 104 + goto _test_eof + _test_eof105: + cs = 105 + goto _test_eof + _test_eof106: + cs = 106 + goto _test_eof + _test_eof107: + cs = 107 + goto _test_eof + _test_eof108: + cs = 108 + goto _test_eof + _test_eof109: + cs = 109 + goto _test_eof + _test_eof110: + cs = 110 + goto _test_eof - _test_eof: - { - } - _out: - { + _test_eof: + { + } + _out: + { + } } + + // line 66 "kparse.rl" + } - // line 66 "kparse.rl" - - } - - if cs < k_first_final { - if p == pe { - //return nil, os.ErrorString("unexpected eof") - println("err unexp eof") - return m, nil - } else { - //return nil, os.ErrorString(fmt.Sprintf("error at position %d", p)) - println("err ", p, "data:", data[p]) - return nil, nil + if cs < k_first_final { + if p == pe { + //return nil, os.ErrorString("unexpected eof") + println("err unexp eof") + return m, nil + } else { + //return nil, os.ErrorString(fmt.Sprintf("error at position %d", p)) + println("err ", p, "data:", data[p]) + return nil, nil + } } - } - */ + */ return m, nil } diff --git a/msg.go b/msg.go index d95755ea..6580798b 100644 --- a/msg.go +++ b/msg.go @@ -15,7 +15,6 @@ package dns import ( - "os" "reflect" "net" "rand" @@ -27,31 +26,31 @@ import ( ) var ( - ErrUnpack os.Error = &Error{Error: "unpacking failed"} - ErrPack os.Error = &Error{Error: "packing failed"} - ErrId os.Error = &Error{Error: "id mismatch"} - ErrShortRead os.Error = &Error{Error: "short read"} - ErrConn os.Error = &Error{Error: "conn holds both UDP and TCP connection"} - ErrConnEmpty os.Error = &Error{Error: "conn has no connection"} - ErrServ os.Error = &Error{Error: "no servers could be reached"} - ErrKey os.Error = &Error{Error: "bad key"} - ErrPrivKey os.Error = &Error{Error: "bad private key"} - ErrKeySize os.Error = &Error{Error: "bad key size"} - ErrKeyAlg os.Error = &Error{Error: "bad key algorithm"} - ErrAlg os.Error = &Error{Error: "bad algorithm"} - ErrTime os.Error = &Error{Error: "bad time"} - ErrNoSig os.Error = &Error{Error: "no signature found"} - ErrSig os.Error = &Error{Error: "bad signature"} - ErrSecret os.Error = &Error{Error: "no secret defined"} - ErrSigGen os.Error = &Error{Error: "bad signature generation"} - ErrAuth os.Error = &Error{Error: "bad authentication"} - ErrXfrSoa os.Error = &Error{Error: "no SOA seen"} - ErrXfrLast os.Error = &Error{Error: "last SOA"} - ErrXfrType os.Error = &Error{Error: "no ixfr, nor axfr"} - ErrHandle os.Error = &Error{Error: "handle is nil"} - ErrChan os.Error = &Error{Error: "channel is nil"} - ErrName os.Error = &Error{Error: "type not found for name"} - ErrRRset os.Error = &Error{Error: "invalid rrset"} + ErrUnpack error = &Error{Err: "unpacking failed"} + ErrPack error = &Error{Err: "packing failed"} + ErrId error = &Error{Err: "id mismatch"} + ErrShortRead error = &Error{Err: "short read"} + ErrConn error = &Error{Err: "conn holds both UDP and TCP connection"} + ErrConnEmpty error = &Error{Err: "conn has no connection"} + ErrServ error = &Error{Err: "no servers could be reached"} + ErrKey error = &Error{Err: "bad key"} + ErrPrivKey error = &Error{Err: "bad private key"} + ErrKeySize error = &Error{Err: "bad key size"} + ErrKeyAlg error = &Error{Err: "bad key algorithm"} + ErrAlg error = &Error{Err: "bad algorithm"} + ErrTime error = &Error{Err: "bad time"} + ErrNoSig error = &Error{Err: "no signature found"} + ErrSig error = &Error{Err: "bad signature"} + ErrSecret error = &Error{Err: "no secret defined"} + ErrSigGen error = &Error{Err: "bad signature generation"} + ErrAuth error = &Error{Err: "bad authentication"} + ErrXfrSoa error = &Error{Err: "no SOA seen"} + ErrXfrLast error = &Error{Err: "last SOA"} + ErrXfrType error = &Error{Err: "no ixfr, nor axfr"} + ErrHandle error = &Error{Err: "handle is nil"} + ErrChan error = &Error{Err: "channel is nil"} + ErrName error = &Error{Err: "type not found for name"} + ErrRRset error = &Error{Err: "invalid rrset"} ) // A manually-unpacked version of (id, bits). @@ -317,7 +316,7 @@ func packStructValue(val reflect.Value, msg []byte, off int) (off1 int, ok bool) //fmt.Fprintf(os.Stderr, "dns: unknown packing slice tag %v\n", f.Tag) return lenmsg, false case "OPT": // edns - // Length of the entire option section + // Length of the entire option section for j := 0; j < val.Field(i).Len(); j++ { element := val.Field(i).Index(j) // for each code we should do something else @@ -330,7 +329,7 @@ func packStructValue(val reflect.Value, msg []byte, off int) (off1 int, ok bool) msg[off], msg[off+1] = packUint16(code) // Length msg[off+2], msg[off+3] = packUint16(uint16(len(string(h)))) - off += 4 + off += 4 copy(msg[off:off+len(string(h))], h) off += len(string(h)) @@ -793,7 +792,7 @@ func packUint16(i uint16) (byte, byte) { return byte(i >> 8), byte(i) } -func packBase64(s []byte) ([]byte, os.Error) { +func packBase64(s []byte) ([]byte, error) { b64len := base64.StdEncoding.DecodedLen(len(s)) buf := make([]byte, b64len) n, err := base64.StdEncoding.Decode(buf, []byte(s)) @@ -805,7 +804,7 @@ func packBase64(s []byte) ([]byte, os.Error) { } // Helper function for packing, mostly used in dnssec.go -func packBase32(s []byte) ([]byte, os.Error) { +func packBase32(s []byte) ([]byte, error) { b32len := base32.HexEncoding.DecodedLen(len(s)) buf := make([]byte, b32len) n, err := base32.HexEncoding.Decode(buf, []byte(s)) diff --git a/nsec3.go b/nsec3.go index a072e8dd..f726b1c5 100644 --- a/nsec3.go +++ b/nsec3.go @@ -5,7 +5,6 @@ import ( "hash" "strings" "crypto/sha1" - "os" ) type saltWireFmt struct { @@ -63,13 +62,13 @@ func (nsec3 *RR_NSEC3) HashNames() { // the message m. // NsecVerify returns nil when the NSECs in the message contain // the correct proof. This function does not validates the NSECs -func (m *Msg) NsecVerify(q Question) os.Error { +func (m *Msg) NsecVerify(q Question) error { - return nil + return nil } // Nsec3Verify verifies ... -func (m *Msg) Nsec3Verify(q Question) os.Error { +func (m *Msg) Nsec3Verify(q Question) error { - return nil + return nil } diff --git a/server.go b/server.go index ca8ae50d..7bbfaaf2 100644 --- a/server.go +++ b/server.go @@ -8,7 +8,6 @@ package dns import ( "io" - "os" "net" ) @@ -26,7 +25,7 @@ type ResponseWriter interface { // RemoteAddr returns the net.Addr of the client that sent the current request. RemoteAddr() net.Addr // Write a reply back to the client. - Write([]byte) (int, os.Error) + Write([]byte) (int, error) } // port? @@ -73,8 +72,8 @@ func (f HandlerFunc) ServeDNS(w ResponseWriter, r *Msg) { // RCODE = refused for every request. func Refused(w ResponseWriter, r *Msg) { m := new(Msg) - m.SetRcode(r, RcodeRefused) - buf, _ := m.Pack() + m.SetRcode(r, RcodeRefused) + buf, _ := m.Pack() w.Write(buf) } @@ -82,7 +81,7 @@ func Refused(w ResponseWriter, r *Msg) { func RefusedHandler() Handler { return HandlerFunc(Refused) } // ... -func ListenAndServe(addr string, network string, handler Handler) os.Error { +func ListenAndServe(addr string, network string, handler Handler) error { server := &Server{Addr: addr, Net: network, Handler: handler} return server.ListenAndServe() } @@ -148,7 +147,7 @@ type Server struct { } // ... -func (srv *Server) ListenAndServe() os.Error { +func (srv *Server) ListenAndServe() error { addr := srv.Addr if addr == "" { addr = ":domain" @@ -178,7 +177,7 @@ func (srv *Server) ListenAndServe() os.Error { return nil // os.Error with wrong network } -func (srv *Server) ServeTCP(l *net.TCPListener) os.Error { +func (srv *Server) ServeTCP(l *net.TCPListener) error { defer l.Close() handler := srv.Handler if handler == nil { @@ -228,7 +227,7 @@ forever: panic("not reached") } -func (srv *Server) ServeUDP(l *net.UDPConn) os.Error { +func (srv *Server) ServeUDP(l *net.UDPConn) error { defer l.Close() handler := srv.Handler if handler == nil { @@ -257,7 +256,7 @@ func (srv *Server) ServeUDP(l *net.UDPConn) os.Error { panic("not reached") } -func newConn(t *net.TCPConn, u *net.UDPConn, a net.Addr, buf []byte, handler Handler) (*conn, os.Error) { +func newConn(t *net.TCPConn, u *net.UDPConn, a net.Addr, buf []byte, handler Handler) (*conn, error) { c := new(conn) c.handler = handler c._TCP = t @@ -267,7 +266,6 @@ func newConn(t *net.TCPConn, u *net.UDPConn, a net.Addr, buf []byte, handler Han return c, nil } - // Close the connection. func (c *conn) close() { switch { @@ -288,11 +286,11 @@ func (c *conn) serve() { w.conn = c req := new(Msg) if !req.Unpack(c.request) { - // Send a format error back - x := new(Msg) - x.SetRcodeFormatError(req) - buf, _ := x.Pack() - w.Write(buf) + // Send a format error back + x := new(Msg) + x.SetRcodeFormatError(req) + buf, _ := x.Pack() + w.Write(buf) break } w.req = req @@ -307,13 +305,12 @@ func (c *conn) serve() { } } - -func (w *response) Write(data []byte) (n int, err os.Error) { +func (w *response) Write(data []byte) (n int, err error) { switch { case w.conn._UDP != nil: n, err = w.conn._UDP.WriteTo(data, w.conn.remoteAddr) if err != nil { - println(err.String()) + println(err.Error()) return 0, err } case w.conn._TCP != nil: diff --git a/tsig.go b/tsig.go index c57de8ec..90f4f884 100644 --- a/tsig.go +++ b/tsig.go @@ -34,7 +34,6 @@ package dns import ( "io" - "os" "time" "strings" "crypto/hmac" @@ -82,16 +81,16 @@ type timerWireFmt struct { // in the Tsig RR that is added. When TsigGenerate is called for the // first time requestMAC is set to the empty string. // If something goes wrong an error is returned, otherwise it is nil. -func TsigGenerate(m *Msg, secret, requestMAC string, timersOnly bool) os.Error { +func TsigGenerate(m *Msg, secret, requestMAC string, timersOnly bool) error { if !m.IsTsig() { - // panic? panic? + // panic? panic? panic("TSIG not last RR in additional") } - // If we barf here, the caller is to blame + // If we barf here, the caller is to blame rawsecret, err := packBase64([]byte(secret)) - if err != nil { - return err - } + if err != nil { + return err + } rr := m.Extra[len(m.Extra)-1].(*RR_TSIG) m.Extra = m.Extra[0 : len(m.Extra)-1] // kill the TSIG from the msg @@ -119,7 +118,7 @@ func TsigGenerate(m *Msg, secret, requestMAC string, timersOnly bool) os.Error { // TsigVerify verifies the TSIG on a message. // If the signature does not validate err contains the // error, otherwise it is nil. -func TsigVerify(msg []byte, secret, requestMAC string, timersOnly bool) os.Error { +func TsigVerify(msg []byte, secret, requestMAC string, timersOnly bool) error { rawsecret, err := packBase64([]byte(secret)) if err != nil { return err @@ -132,17 +131,17 @@ func TsigVerify(msg []byte, secret, requestMAC string, timersOnly bool) os.Error buf := tsigBuffer(stripped, tsig, requestMAC, timersOnly) - ti := uint64(time.Seconds()) - tsig.TimeSigned - if uint64(tsig.Fudge) < ti { - return ErrTime - } + ti := uint64(time.Seconds()) - tsig.TimeSigned + if uint64(tsig.Fudge) < ti { + return ErrTime + } h := hmac.NewMD5([]byte(rawsecret)) io.WriteString(h, string(buf)) - if (strings.ToUpper(hex.EncodeToString(h.Sum())) != strings.ToUpper(tsig.MAC)) { - return ErrSig - } - return nil + if strings.ToUpper(hex.EncodeToString(h.Sum())) != strings.ToUpper(tsig.MAC) { + return ErrSig + } + return nil } // Create a wiredata buffer for the MAC calculation. @@ -155,7 +154,7 @@ func tsigBuffer(msgbuf []byte, rr *RR_TSIG, requestMAC string, timersOnly bool) rr.TimeSigned = uint64(time.Seconds()) } if rr.Fudge == 0 { - rr.Fudge = 300 // Standard (RFC) default. + rr.Fudge = 300 // Standard (RFC) default. } if requestMAC != "" { @@ -198,7 +197,7 @@ func tsigBuffer(msgbuf []byte, rr *RR_TSIG, requestMAC string, timersOnly bool) } // Strip the TSIG from the raw message -func stripTsig(msg []byte) ([]byte, *RR_TSIG, os.Error) { +func stripTsig(msg []byte) ([]byte, *RR_TSIG, error) { // Copied from msg.go's Unpack() // Header. var dh Header diff --git a/types.go b/types.go index ea4d2bf0..d41af031 100644 --- a/types.go +++ b/types.go @@ -6,7 +6,6 @@ package dns import ( - "os" "net" "time" "strconv" @@ -148,7 +147,7 @@ func (q *Question) String() string { } // NewRRString returns the last RR contained in s. -func NewRRString(s string) (RR, os.Error) { +func NewRRString(s string) (RR, error) { p := NewParser(strings.NewReader(s)) return p.First() } @@ -162,8 +161,8 @@ func NewRR(i uint16) RR { } type RR_ANY struct { - Hdr RR_Header - // Does not have any rdata + Hdr RR_Header + // Does not have any rdata } func (rr *RR_ANY) Header() *RR_Header { @@ -792,7 +791,7 @@ func (rr *RR_TSIG) String() string { " " + strconv.Itoa(int(rr.MACSize)) + " " + strings.ToUpper(rr.MAC) + " " + strconv.Itoa(int(rr.OrigId)) + - " " + strconv.Itoa(int(rr.Error)) + // BIND prints NOERROR + " " + strconv.Itoa(int(rr.Error)) + // BIND prints NOERROR " " + strconv.Itoa(int(rr.OtherLen)) + " " + rr.OtherData } diff --git a/xfr.go b/xfr.go index b93b7de8..a9f935af 100644 --- a/xfr.go +++ b/xfr.go @@ -1,15 +1,11 @@ package dns -import ( - "os" -) - // XfrReceives requests an incoming Ixfr or Axfr. If the message q's question // section contains an AXFR type an Axfr is performed, if it is IXFR it does an Ixfr. // Each message will be send along the Client's reply channel as it is received. // The last message send has Exchange.Error set to ErrXfrLast // to signal there is nothing more to come. -func (c *Client) XfrReceive(q *Msg, a string) os.Error { +func (c *Client) XfrReceive(q *Msg, a string) error { w := new(reply) w.client = c w.addr = a @@ -117,10 +113,10 @@ func (w *reply) ixfrReceive() { // XfrSend performs an outgoing Ixfr or Axfr. The function is xfr agnostic, it is // up to the caller to correctly send the sequence of messages. -func XfrSend(w ResponseWriter, q *Msg, a string) os.Error { +func XfrSend(w ResponseWriter, q *Msg, a string) error { switch q.Question[0].Qtype { - case TypeAXFR, TypeIXFR: -// go d.xfrWrite(q, m, e) + case TypeAXFR, TypeIXFR: + // go d.xfrWrite(q, m, e) default: return ErrXfrType } diff --git a/zparse.go b/zparse.go index 23230352..7cca8701 100644 --- a/zparse.go +++ b/zparse.go @@ -5,9 +5,8 @@ package dns // With the thankful help of gdnsd and the Go examples for Ragel. import ( - "os" "io" -// "net" + // "net" "time" "strings" "strconv" @@ -23,20 +22,20 @@ type Parser struct { } type ParseError struct { - Error string - name string - line int + Err string + name string + line int } -func (e *ParseError) String() string { - s := e.Error + ": \"" + e.name + "\" at line: " + strconv.Itoa(e.line) +func (e *ParseError) Error() string { + s := e.Err + ": \"" + e.name + "\" at line: " + strconv.Itoa(e.line) return s } // First will return the first RR found when parsing. -func (zp *Parser) First() (RR, os.Error) { - // defer close something - return nil, nil +func (zp *Parser) First() (RR, error) { + // defer close something + return nil, nil } // NewParser creates a new DNS file parser from r. @@ -59,7 +58,7 @@ func NewParser(r io.Reader) *Parser { // Translate the RRSIG's incep. and expir. times from // string values ("20110403154150") to an integer. // Taking into account serial arithmetic (RFC 1982) -func dateToTime(s string) (uint32, os.Error) { +func dateToTime(s string) (uint32, error) { t, e := time.Parse("20060102150405", s) if e != nil { return 0, e @@ -86,7 +85,6 @@ func fields(s string, i int) (rdf []string) { return } - // line 86 "zparse.go" var z_start int = 141 var z_first_final int = 141 @@ -94,3716 +92,3715 @@ var z_error int = 0 var z_en_main int = 141 - // line 85 "zparse.rl" // Zone parses an DNS master zone file. -func (zp *Parser) Zone() (err os.Error) { - /* - z = NewZone() - data := string(zp.buf) - cs, p, pe := 0, 0, len(data) - eof := len(data) +func (zp *Parser) Zone() (err error) { + /* + z = NewZone() + data := string(zp.buf) + cs, p, pe := 0, 0, len(data) + eof := len(data) - // brace := false - l := 1 // or... 0? - mark := 0 - var hdr RR_Header + // brace := false + l := 1 // or... 0? + mark := 0 + var hdr RR_Header - // line 119 "zparse.go" - cs = z_start + // line 119 "zparse.go" + cs = z_start - // line 122 "zparse.go" - { - if p == pe { - goto _test_eof - } - switch cs { - case -666: // i am a hack D: - tr33: - // line 3 "types.rl" - { - rdf := fields(data[mark:p], 1) - rr := new(RR_A) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeA - rr.A = net.ParseIP(rdf[0]) - if rr.A == nil { - return z, &ParseError{Error: "bad A", name: rdf[0], line: l} - } - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr40: - // line 15 "types.rl" - { - rdf := fields(data[mark:p], 1) - rr := new(RR_AAAA) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeAAAA - rr.AAAA = net.ParseIP(rdf[0]) - if rr.AAAA == nil { - return z, &ParseError{Error: "bad AAAA", name: rdf[0], line: l} - } - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr50: - // line 342 "types.rl" - { - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr61: - // line 53 "types.rl" - { - rdf := fields(data[mark:p], 1) - rr := new(RR_CNAME) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeCNAME - rr.Cname = rdf[0] - if !IsDomainName(rdf[0]) { - return z, &ParseError{Error: "bad CNAME", name: rdf[0], line: l} - } - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr70: - // line 122 "types.rl" - { - var ( - i uint - e os.Error - ) - rdf := fields(data[mark:p], 4) - rr := new(RR_DLV) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeDLV - if i, e = strconv.Atoui(rdf[0]); e != nil { - return z, &ParseError{Error: "bad DS", name: rdf[0], line: l} - } - rr.KeyTag = uint16(i) - if i, e = strconv.Atoui(rdf[1]); e != nil { - return z, &ParseError{Error: "bad DS", name: rdf[1], line: l} - } - rr.Algorithm = uint8(i) - if i, e = strconv.Atoui(rdf[2]); e != nil { - return z, &ParseError{Error: "bad DS", name: rdf[2], line: l} - } - rr.DigestType = uint8(i) - rr.Digest = rdf[3] - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr79: - // line 348 "types.rl" - { - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr87: - // line 172 "types.rl" - { - var ( - i uint - e os.Error - ) - rdf := fields(data[mark:p], 4) - rr := new(RR_DNSKEY) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeDNSKEY - - if i, e = strconv.Atoui(rdf[0]); e != nil { - return z, &ParseError{Error: "bad DNSKEY", name: rdf[0], line: l} - } - rr.Flags = uint16(i) - if i, e = strconv.Atoui(rdf[1]); e != nil { - return z, &ParseError{Error: "bad DNSKEY", name: rdf[1], line: l} - } - rr.Protocol = uint8(i) - if i, e = strconv.Atoui(rdf[2]); e != nil { - return z, &ParseError{Error: "bad DNSKEY", name: rdf[2], line: l} - } - rr.Algorithm = uint8(i) - rr.PublicKey = rdf[3] - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr92: - // line 97 "types.rl" - { - var ( - i uint - e os.Error - ) - rdf := fields(data[mark:p], 4) - rr := new(RR_DS) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeDS - if i, e = strconv.Atoui(rdf[0]); e != nil { - return z, &ParseError{Error: "bad DS", name: rdf[0], line: l} - } - rr.KeyTag = uint16(i) - if i, e = strconv.Atoui(rdf[1]); e != nil { - return z, &ParseError{Error: "bad DS", name: rdf[1], line: l} - } - rr.Algorithm = uint8(i) - if i, e = strconv.Atoui(rdf[2]); e != nil { - return z, &ParseError{Error: "bad DS", name: rdf[2], line: l} - } - rr.DigestType = uint8(i) - rr.Digest = rdf[3] - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr98: - // line 39 "types.rl" - { - rdf := fields(data[mark:p], 2) - rr := new(RR_MX) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeMX - i, err := strconv.Atoui(rdf[0]) - rr.Pref = uint16(i) - rr.Mx = rdf[1] - if err != nil { - return z, &ParseError{Error: "bad MX", name: rdf[0], line: l} - } - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr108: - // line 351 "types.rl" - { - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr114: - // line 27 "types.rl" - { - rdf := fields(data[mark:p], 1) - rr := new(RR_NS) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeNS - rr.Ns = rdf[0] - if !IsDomainName(rdf[0]) { - return z, &ParseError{Error: "bad NS", name: rdf[0], line: l} - } - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr121: - // line 250 "types.rl" - { - rdf := fields(data[mark:p], 0) - rr := new(RR_NSEC) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeNSEC - rr.NextDomain = rdf[0] - rr.TypeBitMap = make([]uint16, len(rdf)-1) - // Fill the Type Bit Map - for i := 1; i < len(rdf); i++ { - // Check if its there in the map TODO - rr.TypeBitMap[i-1] = str_rr[strings.ToUpper(rdf[i])] - } - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr127: - // line 265 "types.rl" - { - var ( - i uint - e os.Error - ) - rdf := fields(data[mark:p], 0) - rr := new(RR_NSEC3) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeNSEC3 - - if i, e = strconv.Atoui(rdf[0]); e != nil { - return z, &ParseError{Error: "bad NSEC3", name: rdf[0], line: l} - } - rr.Hash = uint8(i) - if i, e = strconv.Atoui(rdf[1]); e != nil { - return z, &ParseError{Error: "bad NSEC3", name: rdf[1], line: l} - } - rr.Flags = uint8(i) - if i, e = strconv.Atoui(rdf[2]); e != nil { - return z, &ParseError{Error: "bad NSEC3", name: rdf[2], line: l} - } - rr.Iterations = uint16(i) - rr.SaltLength = uint8(len(rdf[3])) - rr.Salt = rdf[3] - - rr.HashLength = uint8(len(rdf[4])) - rr.NextDomain = rdf[4] - rr.TypeBitMap = make([]uint16, len(rdf)-5) - // Fill the Type Bit Map - for i := 5; i < len(rdf); i++ { - // Check if its there in the map TODO - rr.TypeBitMap[i-5] = str_rr[strings.ToUpper(rdf[i])] - } - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr136: - // line 301 "types.rl" - { - var ( - i int - e os.Error - ) - rdf := fields(data[mark:p], 4) - rr := new(RR_NSEC3PARAM) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeNSEC3PARAM - if i, e = strconv.Atoi(rdf[0]); e != nil { - return z, &ParseError{Error: "bad NSEC3PARAM", name: rdf[0], line: l} - } - rr.Hash = uint8(i) - if i, e = strconv.Atoi(rdf[1]); e != nil { - return z, &ParseError{Error: "bad NSEC3PARAM", name: rdf[1], line: l} - } - rr.Flags = uint8(i) - if i, e = strconv.Atoi(rdf[2]); e != nil { - return z, &ParseError{Error: "bad NSEC3PARAM", name: rdf[2], line: l} - } - rr.Iterations = uint16(i) - rr.Salt = rdf[3] - rr.SaltLength = uint8(len(rr.Salt)) - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr143: - // line 345 "types.rl" - { - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr152: - // line 198 "types.rl" - { - var ( - i uint - j uint32 - err os.Error - ) - rdf := fields(data[mark:p], 9) - rr := new(RR_RRSIG) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeRRSIG - - if _, ok := str_rr[strings.ToUpper(rdf[0])]; !ok { - return z, &ParseError{Error: "bad RRSIG", name: rdf[0], line: l} - } - rr.TypeCovered = str_rr[strings.ToUpper(rdf[0])] - - if i, err = strconv.Atoui(rdf[1]); err != nil { - return z, &ParseError{Error: "bad RRSIG", name: rdf[1], line: l} - } - rr.Algorithm = uint8(i) - if i, err = strconv.Atoui(rdf[2]); err != nil { - return z, &ParseError{Error: "bad RRSIG", name: rdf[2], line: l} - } - rr.Labels = uint8(i) - if i, err = strconv.Atoui(rdf[3]); err != nil { - return z, &ParseError{Error: "bad RRSIG", name: rdf[3], line: l} - } - rr.OrigTtl = uint32(i) - - if j, err = dateToTime(rdf[4]); err != nil { - return z, &ParseError{Error: "bad RRSIG", name: rdf[4], line: l} - } - rr.Expiration = j - if j, err = dateToTime(rdf[5]); err != nil { - return z, &ParseError{Error: "bad RRSIG", name: rdf[5], line: l} - } - rr.Inception = j - - if i, err = strconv.Atoui(rdf[6]); err != nil { - return z, &ParseError{Error: "bad RRSIG", name: rdf[3], line: l} - } - rr.KeyTag = uint16(i) - - rr.SignerName = rdf[7] - if !IsDomainName(rdf[7]) { - return z, &ParseError{Error: "bad RRSIG", name: rdf[7], line: l} - } - // Check base64 TODO - rr.Signature = rdf[8] - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr161: - // line 65 "types.rl" - { - var ( - i uint - err os.Error - ) - rdf := fields(data[mark:p], 7) - rr := new(RR_SOA) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeSOA - rr.Ns = rdf[0] - rr.Mbox = rdf[1] - if !IsDomainName(rdf[0]) { - return z, &ParseError{Error: "bad SOA", name: rdf[0], line: l} - } - if !IsDomainName(rdf[1]) { - return z, &ParseError{Error: "bad SOA", name: rdf[1], line: l} - } - for j, s := range rdf[2:7] { - if i, err = strconv.Atoui(s); err != nil { - return z, &ParseError{Error: "bad SOA", name: s, line: l} - } - switch j { - case 0: - rr.Serial = uint32(i) - case 1: - rr.Refresh = uint32(i) - case 2: - rr.Retry = uint32(i) - case 3: - rr.Expire = uint32(i) - case 4: - rr.Minttl = uint32(i) - } - } - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr167: - // line 339 "types.rl" - { - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr175: - // line 354 "types.rl" - { - var ( - i int - e os.Error - ) - rdf := fields(data[mark:p], 3) - rr := new(RR_SSHFP) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeSSHFP - if i, e = strconv.Atoi(rdf[0]); e != nil { - return z, &ParseError{Error: "bad SSHFP", name: rdf[0], line: l} - } - rr.Algorithm = uint8(i) - if i, e = strconv.Atoi(rdf[1]); e != nil { - return z, &ParseError{Error: "bad SSHFP", name: rdf[1], line: l} - } - rr.Type = uint8(i) - rr.FingerPrint = rdf[2] - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr182: - // line 147 "types.rl" - { - var ( - i uint - e os.Error - ) - rdf := fields(data[mark:p], 4) - rr := new(RR_TA) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeTA - if i, e = strconv.Atoui(rdf[0]); e != nil { - return z, &ParseError{Error: "bad DS", name: rdf[0], line: l} - } - rr.KeyTag = uint16(i) - if i, e = strconv.Atoui(rdf[1]); e != nil { - return z, &ParseError{Error: "bad DS", name: rdf[1], line: l} - } - rr.Algorithm = uint8(i) - if i, e = strconv.Atoui(rdf[2]); e != nil { - return z, &ParseError{Error: "bad DS", name: rdf[2], line: l} - } - rr.DigestType = uint8(i) - rr.Digest = rdf[3] - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr188: - // line 330 "types.rl" - { - rdf := fields(data[mark:p], 1) - rr := new(RR_TXT) - rr.Hdr = hdr - rr.Hdr.Rrtype = TypeTXT - rr.Txt = rdf[0] - z.PushRR(rr) - } - // line 112 "zparse.rl" - { - l++ - } - goto st141 - tr198: - // line 112 "zparse.rl" - { - l++ - } - goto st141 - st141: - p++ + // line 122 "zparse.go" + { if p == pe { - goto _test_eof141 + goto _test_eof } - fallthrough - case 141: - // line 589 "zparse.go" - switch data[p] { - case 9: - goto st1 - case 10: - goto tr198 - case 32: - goto st1 - case 42: - goto tr199 - case 59: - goto st140 - case 95: - goto tr199 - } - if data[p] < 48 { - if 45 <= data[p] && data[p] <= 46 { + switch cs { + case -666: // i am a hack D: + tr33: + // line 3 "types.rl" + { + rdf := fields(data[mark:p], 1) + rr := new(RR_A) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeA + rr.A = net.ParseIP(rdf[0]) + if rr.A == nil { + return z, &ParseError{Error: "bad A", name: rdf[0], line: l} + } + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr40: + // line 15 "types.rl" + { + rdf := fields(data[mark:p], 1) + rr := new(RR_AAAA) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeAAAA + rr.AAAA = net.ParseIP(rdf[0]) + if rr.AAAA == nil { + return z, &ParseError{Error: "bad AAAA", name: rdf[0], line: l} + } + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr50: + // line 342 "types.rl" + { + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr61: + // line 53 "types.rl" + { + rdf := fields(data[mark:p], 1) + rr := new(RR_CNAME) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeCNAME + rr.Cname = rdf[0] + if !IsDomainName(rdf[0]) { + return z, &ParseError{Error: "bad CNAME", name: rdf[0], line: l} + } + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr70: + // line 122 "types.rl" + { + var ( + i uint + e os.Error + ) + rdf := fields(data[mark:p], 4) + rr := new(RR_DLV) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeDLV + if i, e = strconv.Atoui(rdf[0]); e != nil { + return z, &ParseError{Error: "bad DS", name: rdf[0], line: l} + } + rr.KeyTag = uint16(i) + if i, e = strconv.Atoui(rdf[1]); e != nil { + return z, &ParseError{Error: "bad DS", name: rdf[1], line: l} + } + rr.Algorithm = uint8(i) + if i, e = strconv.Atoui(rdf[2]); e != nil { + return z, &ParseError{Error: "bad DS", name: rdf[2], line: l} + } + rr.DigestType = uint8(i) + rr.Digest = rdf[3] + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr79: + // line 348 "types.rl" + { + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr87: + // line 172 "types.rl" + { + var ( + i uint + e os.Error + ) + rdf := fields(data[mark:p], 4) + rr := new(RR_DNSKEY) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeDNSKEY + + if i, e = strconv.Atoui(rdf[0]); e != nil { + return z, &ParseError{Error: "bad DNSKEY", name: rdf[0], line: l} + } + rr.Flags = uint16(i) + if i, e = strconv.Atoui(rdf[1]); e != nil { + return z, &ParseError{Error: "bad DNSKEY", name: rdf[1], line: l} + } + rr.Protocol = uint8(i) + if i, e = strconv.Atoui(rdf[2]); e != nil { + return z, &ParseError{Error: "bad DNSKEY", name: rdf[2], line: l} + } + rr.Algorithm = uint8(i) + rr.PublicKey = rdf[3] + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr92: + // line 97 "types.rl" + { + var ( + i uint + e os.Error + ) + rdf := fields(data[mark:p], 4) + rr := new(RR_DS) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeDS + if i, e = strconv.Atoui(rdf[0]); e != nil { + return z, &ParseError{Error: "bad DS", name: rdf[0], line: l} + } + rr.KeyTag = uint16(i) + if i, e = strconv.Atoui(rdf[1]); e != nil { + return z, &ParseError{Error: "bad DS", name: rdf[1], line: l} + } + rr.Algorithm = uint8(i) + if i, e = strconv.Atoui(rdf[2]); e != nil { + return z, &ParseError{Error: "bad DS", name: rdf[2], line: l} + } + rr.DigestType = uint8(i) + rr.Digest = rdf[3] + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr98: + // line 39 "types.rl" + { + rdf := fields(data[mark:p], 2) + rr := new(RR_MX) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeMX + i, err := strconv.Atoui(rdf[0]) + rr.Pref = uint16(i) + rr.Mx = rdf[1] + if err != nil { + return z, &ParseError{Error: "bad MX", name: rdf[0], line: l} + } + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr108: + // line 351 "types.rl" + { + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr114: + // line 27 "types.rl" + { + rdf := fields(data[mark:p], 1) + rr := new(RR_NS) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeNS + rr.Ns = rdf[0] + if !IsDomainName(rdf[0]) { + return z, &ParseError{Error: "bad NS", name: rdf[0], line: l} + } + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr121: + // line 250 "types.rl" + { + rdf := fields(data[mark:p], 0) + rr := new(RR_NSEC) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeNSEC + rr.NextDomain = rdf[0] + rr.TypeBitMap = make([]uint16, len(rdf)-1) + // Fill the Type Bit Map + for i := 1; i < len(rdf); i++ { + // Check if its there in the map TODO + rr.TypeBitMap[i-1] = str_rr[strings.ToUpper(rdf[i])] + } + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr127: + // line 265 "types.rl" + { + var ( + i uint + e os.Error + ) + rdf := fields(data[mark:p], 0) + rr := new(RR_NSEC3) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeNSEC3 + + if i, e = strconv.Atoui(rdf[0]); e != nil { + return z, &ParseError{Error: "bad NSEC3", name: rdf[0], line: l} + } + rr.Hash = uint8(i) + if i, e = strconv.Atoui(rdf[1]); e != nil { + return z, &ParseError{Error: "bad NSEC3", name: rdf[1], line: l} + } + rr.Flags = uint8(i) + if i, e = strconv.Atoui(rdf[2]); e != nil { + return z, &ParseError{Error: "bad NSEC3", name: rdf[2], line: l} + } + rr.Iterations = uint16(i) + rr.SaltLength = uint8(len(rdf[3])) + rr.Salt = rdf[3] + + rr.HashLength = uint8(len(rdf[4])) + rr.NextDomain = rdf[4] + rr.TypeBitMap = make([]uint16, len(rdf)-5) + // Fill the Type Bit Map + for i := 5; i < len(rdf); i++ { + // Check if its there in the map TODO + rr.TypeBitMap[i-5] = str_rr[strings.ToUpper(rdf[i])] + } + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr136: + // line 301 "types.rl" + { + var ( + i int + e os.Error + ) + rdf := fields(data[mark:p], 4) + rr := new(RR_NSEC3PARAM) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeNSEC3PARAM + if i, e = strconv.Atoi(rdf[0]); e != nil { + return z, &ParseError{Error: "bad NSEC3PARAM", name: rdf[0], line: l} + } + rr.Hash = uint8(i) + if i, e = strconv.Atoi(rdf[1]); e != nil { + return z, &ParseError{Error: "bad NSEC3PARAM", name: rdf[1], line: l} + } + rr.Flags = uint8(i) + if i, e = strconv.Atoi(rdf[2]); e != nil { + return z, &ParseError{Error: "bad NSEC3PARAM", name: rdf[2], line: l} + } + rr.Iterations = uint16(i) + rr.Salt = rdf[3] + rr.SaltLength = uint8(len(rr.Salt)) + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr143: + // line 345 "types.rl" + { + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr152: + // line 198 "types.rl" + { + var ( + i uint + j uint32 + err os.Error + ) + rdf := fields(data[mark:p], 9) + rr := new(RR_RRSIG) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeRRSIG + + if _, ok := str_rr[strings.ToUpper(rdf[0])]; !ok { + return z, &ParseError{Error: "bad RRSIG", name: rdf[0], line: l} + } + rr.TypeCovered = str_rr[strings.ToUpper(rdf[0])] + + if i, err = strconv.Atoui(rdf[1]); err != nil { + return z, &ParseError{Error: "bad RRSIG", name: rdf[1], line: l} + } + rr.Algorithm = uint8(i) + if i, err = strconv.Atoui(rdf[2]); err != nil { + return z, &ParseError{Error: "bad RRSIG", name: rdf[2], line: l} + } + rr.Labels = uint8(i) + if i, err = strconv.Atoui(rdf[3]); err != nil { + return z, &ParseError{Error: "bad RRSIG", name: rdf[3], line: l} + } + rr.OrigTtl = uint32(i) + + if j, err = dateToTime(rdf[4]); err != nil { + return z, &ParseError{Error: "bad RRSIG", name: rdf[4], line: l} + } + rr.Expiration = j + if j, err = dateToTime(rdf[5]); err != nil { + return z, &ParseError{Error: "bad RRSIG", name: rdf[5], line: l} + } + rr.Inception = j + + if i, err = strconv.Atoui(rdf[6]); err != nil { + return z, &ParseError{Error: "bad RRSIG", name: rdf[3], line: l} + } + rr.KeyTag = uint16(i) + + rr.SignerName = rdf[7] + if !IsDomainName(rdf[7]) { + return z, &ParseError{Error: "bad RRSIG", name: rdf[7], line: l} + } + // Check base64 TODO + rr.Signature = rdf[8] + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr161: + // line 65 "types.rl" + { + var ( + i uint + err os.Error + ) + rdf := fields(data[mark:p], 7) + rr := new(RR_SOA) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeSOA + rr.Ns = rdf[0] + rr.Mbox = rdf[1] + if !IsDomainName(rdf[0]) { + return z, &ParseError{Error: "bad SOA", name: rdf[0], line: l} + } + if !IsDomainName(rdf[1]) { + return z, &ParseError{Error: "bad SOA", name: rdf[1], line: l} + } + for j, s := range rdf[2:7] { + if i, err = strconv.Atoui(s); err != nil { + return z, &ParseError{Error: "bad SOA", name: s, line: l} + } + switch j { + case 0: + rr.Serial = uint32(i) + case 1: + rr.Refresh = uint32(i) + case 2: + rr.Retry = uint32(i) + case 3: + rr.Expire = uint32(i) + case 4: + rr.Minttl = uint32(i) + } + } + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr167: + // line 339 "types.rl" + { + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr175: + // line 354 "types.rl" + { + var ( + i int + e os.Error + ) + rdf := fields(data[mark:p], 3) + rr := new(RR_SSHFP) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeSSHFP + if i, e = strconv.Atoi(rdf[0]); e != nil { + return z, &ParseError{Error: "bad SSHFP", name: rdf[0], line: l} + } + rr.Algorithm = uint8(i) + if i, e = strconv.Atoi(rdf[1]); e != nil { + return z, &ParseError{Error: "bad SSHFP", name: rdf[1], line: l} + } + rr.Type = uint8(i) + rr.FingerPrint = rdf[2] + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr182: + // line 147 "types.rl" + { + var ( + i uint + e os.Error + ) + rdf := fields(data[mark:p], 4) + rr := new(RR_TA) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeTA + if i, e = strconv.Atoui(rdf[0]); e != nil { + return z, &ParseError{Error: "bad DS", name: rdf[0], line: l} + } + rr.KeyTag = uint16(i) + if i, e = strconv.Atoui(rdf[1]); e != nil { + return z, &ParseError{Error: "bad DS", name: rdf[1], line: l} + } + rr.Algorithm = uint8(i) + if i, e = strconv.Atoui(rdf[2]); e != nil { + return z, &ParseError{Error: "bad DS", name: rdf[2], line: l} + } + rr.DigestType = uint8(i) + rr.Digest = rdf[3] + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr188: + // line 330 "types.rl" + { + rdf := fields(data[mark:p], 1) + rr := new(RR_TXT) + rr.Hdr = hdr + rr.Hdr.Rrtype = TypeTXT + rr.Txt = rdf[0] + z.PushRR(rr) + } + // line 112 "zparse.rl" + { + l++ + } + goto st141 + tr198: + // line 112 "zparse.rl" + { + l++ + } + goto st141 + st141: + p++ + if p == pe { + goto _test_eof141 + } + fallthrough + case 141: + // line 589 "zparse.go" + switch data[p] { + case 9: + goto st1 + case 10: + goto tr198 + case 32: + goto st1 + case 42: + goto tr199 + case 59: + goto st140 + case 95: goto tr199 } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { + if data[p] < 48 { + if 45 <= data[p] && data[p] <= 46 { goto tr199 } - } else if data[p] >= 65 { + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto tr199 + } + } else if data[p] >= 65 { + goto tr199 + } + } else { goto tr199 } - } else { - goto tr199 - } - goto st0 - st0: - cs = 0 - goto _out - tr195: - // line 113 "zparse.rl" - { - if !IsDomainName(data[mark:p]) { - return z, &ParseError{Error: "bad qname: " + data[mark:p], line: l} + goto st0 + st0: + cs = 0 + goto _out + tr195: + // line 113 "zparse.rl" + { + if !IsDomainName(data[mark:p]) { + return z, &ParseError{Error: "bad qname: " + data[mark:p], line: l} + } + hdr.Name = data[mark:p] } - hdr.Name = data[mark:p] - } - goto st1 - st1: - p++ - if p == pe { - goto _test_eof1 - } - fallthrough - case 1: - // line 626 "zparse.go" - switch data[p] { - case 9: goto st1 - case 32: - goto st1 - case 65: - goto tr3 - case 67: - goto tr4 - case 68: - goto tr5 - case 72: - goto tr6 - case 73: - goto tr7 - case 77: - goto tr8 - case 78: - goto tr9 - case 80: - goto tr10 - case 82: - goto tr11 - case 83: - goto tr12 - case 84: - goto tr13 - case 97: - goto tr3 - case 99: - goto tr4 - case 100: - goto tr5 - case 104: - goto tr6 - case 105: - goto tr7 - case 109: - goto tr8 - case 110: - goto tr9 - case 112: - goto tr10 - case 114: - goto tr11 - case 115: - goto tr12 - case 116: - goto tr13 - } - if 48 <= data[p] && data[p] <= 57 { - goto tr2 - } - goto st0 - tr2: - // line 120 "zparse.rl" - { // ... - } - // line 111 "zparse.rl" - { - mark = p - } - goto st2 - st2: - p++ - if p == pe { - goto _test_eof2 - } - fallthrough - case 2: - // line 666 "zparse.go" - switch data[p] { - case 9: - goto tr14 - case 32: - goto tr14 - } - if 48 <= data[p] && data[p] <= 57 { + st1: + p++ + if p == pe { + goto _test_eof1 + } + fallthrough + case 1: + // line 626 "zparse.go" + switch data[p] { + case 9: + goto st1 + case 32: + goto st1 + case 65: + goto tr3 + case 67: + goto tr4 + case 68: + goto tr5 + case 72: + goto tr6 + case 73: + goto tr7 + case 77: + goto tr8 + case 78: + goto tr9 + case 80: + goto tr10 + case 82: + goto tr11 + case 83: + goto tr12 + case 84: + goto tr13 + case 97: + goto tr3 + case 99: + goto tr4 + case 100: + goto tr5 + case 104: + goto tr6 + case 105: + goto tr7 + case 109: + goto tr8 + case 110: + goto tr9 + case 112: + goto tr10 + case 114: + goto tr11 + case 115: + goto tr12 + case 116: + goto tr13 + } + if 48 <= data[p] && data[p] <= 57 { + goto tr2 + } + goto st0 + tr2: + // line 120 "zparse.rl" + { // ... + } + // line 111 "zparse.rl" + { + mark = p + } goto st2 - } - goto st0 - tr14: - // line 122 "zparse.rl" - { - i, _ := strconv.Atoui(data[mark:p]) - hdr.Ttl = uint32(i) - } - goto st3 - st3: - p++ - if p == pe { - goto _test_eof3 - } - fallthrough - case 3: - // line 682 "zparse.go" - switch data[p] { - case 9: + st2: + p++ + if p == pe { + goto _test_eof2 + } + fallthrough + case 2: + // line 666 "zparse.go" + switch data[p] { + case 9: + goto tr14 + case 32: + goto tr14 + } + if 48 <= data[p] && data[p] <= 57 { + goto st2 + } + goto st0 + tr14: + // line 122 "zparse.rl" + { + i, _ := strconv.Atoui(data[mark:p]) + hdr.Ttl = uint32(i) + } goto st3 - case 32: - goto st3 - case 65: + st3: + p++ + if p == pe { + goto _test_eof3 + } + fallthrough + case 3: + // line 682 "zparse.go" + switch data[p] { + case 9: + goto st3 + case 32: + goto st3 + case 65: + goto st4 + case 67: + goto tr18 + case 68: + goto st31 + case 72: + goto tr20 + case 73: + goto tr21 + case 77: + goto st55 + case 78: + goto st60 + case 80: + goto st89 + case 82: + goto st95 + case 83: + goto st103 + case 84: + goto st121 + case 97: + goto st4 + case 99: + goto tr18 + case 100: + goto st31 + case 104: + goto tr20 + case 105: + goto tr21 + case 109: + goto st55 + case 110: + goto st60 + case 112: + goto st89 + case 114: + goto st95 + case 115: + goto st103 + case 116: + goto st121 + } + goto st0 + tr3: + // line 120 "zparse.rl" + { // ... + } goto st4 - case 67: - goto tr18 - case 68: - goto st31 - case 72: - goto tr20 - case 73: - goto tr21 - case 77: - goto st55 - case 78: - goto st60 - case 80: - goto st89 - case 82: - goto st95 - case 83: - goto st103 - case 84: - goto st121 - case 97: - goto st4 - case 99: - goto tr18 - case 100: - goto st31 - case 104: - goto tr20 - case 105: - goto tr21 - case 109: - goto st55 - case 110: - goto st60 - case 112: - goto st89 - case 114: - goto st95 - case 115: - goto st103 - case 116: - goto st121 - } - goto st0 - tr3: - // line 120 "zparse.rl" - { // ... - } - goto st4 - st4: - p++ - if p == pe { - goto _test_eof4 - } - fallthrough - case 4: - // line 719 "zparse.go" - switch data[p] { - case 9: - goto st5 - case 32: - goto st5 - case 65: - goto st8 - case 97: - goto st8 - } - goto st0 - st5: - p++ - if p == pe { - goto _test_eof5 - } - fallthrough - case 5: - switch data[p] { - case 9: - goto tr31 - case 10: + st4: + p++ + if p == pe { + goto _test_eof4 + } + fallthrough + case 4: + // line 719 "zparse.go" + switch data[p] { + case 9: + goto st5 + case 32: + goto st5 + case 65: + goto st8 + case 97: + goto st8 + } goto st0 - case 32: - goto tr31 - } - goto tr30 - tr30: - // line 111 "zparse.rl" - { - mark = p - } - goto st6 - st6: - p++ - if p == pe { - goto _test_eof6 - } - fallthrough - case 6: - // line 747 "zparse.go" - if data[p] == 10 { - goto tr33 - } - goto st6 - tr31: - // line 111 "zparse.rl" - { - mark = p - } - goto st7 - st7: - p++ - if p == pe { - goto _test_eof7 - } - fallthrough - case 7: - // line 759 "zparse.go" - switch data[p] { - case 9: - goto tr31 - case 10: - goto tr33 - case 32: - goto tr31 - } - goto tr30 - st8: - p++ - if p == pe { - goto _test_eof8 - } - fallthrough - case 8: - switch data[p] { - case 65: - goto st9 - case 97: - goto st9 - } - goto st0 - st9: - p++ - if p == pe { - goto _test_eof9 - } - fallthrough - case 9: - switch data[p] { - case 65: - goto st10 - case 97: - goto st10 - } - goto st0 - st10: - p++ - if p == pe { - goto _test_eof10 - } - fallthrough - case 10: - switch data[p] { - case 9: - goto st11 - case 32: - goto st11 - } - goto st0 - st11: - p++ - if p == pe { - goto _test_eof11 - } - fallthrough - case 11: - switch data[p] { - case 9: - goto tr38 - case 10: + st5: + p++ + if p == pe { + goto _test_eof5 + } + fallthrough + case 5: + switch data[p] { + case 9: + goto tr31 + case 10: + goto st0 + case 32: + goto tr31 + } + goto tr30 + tr30: + // line 111 "zparse.rl" + { + mark = p + } + goto st6 + st6: + p++ + if p == pe { + goto _test_eof6 + } + fallthrough + case 6: + // line 747 "zparse.go" + if data[p] == 10 { + goto tr33 + } + goto st6 + tr31: + // line 111 "zparse.rl" + { + mark = p + } + goto st7 + st7: + p++ + if p == pe { + goto _test_eof7 + } + fallthrough + case 7: + // line 759 "zparse.go" + switch data[p] { + case 9: + goto tr31 + case 10: + goto tr33 + case 32: + goto tr31 + } + goto tr30 + st8: + p++ + if p == pe { + goto _test_eof8 + } + fallthrough + case 8: + switch data[p] { + case 65: + goto st9 + case 97: + goto st9 + } goto st0 - case 32: - goto tr38 - } - goto tr37 - tr37: - // line 111 "zparse.rl" - { - mark = p - } - goto st12 - st12: - p++ - if p == pe { - goto _test_eof12 - } - fallthrough - case 12: - // line 816 "zparse.go" - if data[p] == 10 { - goto tr40 - } - goto st12 - tr38: - // line 111 "zparse.rl" - { - mark = p - } - goto st13 - st13: - p++ - if p == pe { - goto _test_eof13 - } - fallthrough - case 13: - // line 828 "zparse.go" - switch data[p] { + st9: + p++ + if p == pe { + goto _test_eof9 + } + fallthrough case 9: - goto tr38 - case 10: - goto tr40 - case 32: - goto tr38 - } - goto tr37 - tr18: - // line 111 "zparse.rl" - { - mark = p - } - goto st14 - st14: - p++ - if p == pe { - goto _test_eof14 - } - fallthrough - case 14: - // line 844 "zparse.go" - switch data[p] { - case 69: - goto st15 - case 72: - goto st21 - case 78: - goto st24 - case 101: - goto st15 - case 104: - goto st21 - case 110: - goto st24 - } - goto st0 - st15: - p++ - if p == pe { - goto _test_eof15 - } - fallthrough - case 15: - switch data[p] { - case 82: - goto st16 - case 114: - goto st16 - } - goto st0 - st16: - p++ - if p == pe { - goto _test_eof16 - } - fallthrough - case 16: - switch data[p] { - case 84: - goto st17 - case 116: - goto st17 - } - goto st0 - st17: - p++ - if p == pe { - goto _test_eof17 - } - fallthrough - case 17: - switch data[p] { - case 9: - goto st18 - case 32: - goto st18 - } - goto st0 - st18: - p++ - if p == pe { - goto _test_eof18 - } - fallthrough - case 18: - switch data[p] { - case 9: - goto tr48 - case 10: + switch data[p] { + case 65: + goto st10 + case 97: + goto st10 + } goto st0 - case 32: - goto tr48 - } - goto tr47 - tr47: - // line 111 "zparse.rl" - { - mark = p - } - goto st19 - st19: - p++ - if p == pe { - goto _test_eof19 - } - fallthrough - case 19: - // line 904 "zparse.go" - if data[p] == 10 { - goto tr50 - } - goto st19 - tr48: - // line 111 "zparse.rl" - { - mark = p - } - goto st20 - st20: - p++ - if p == pe { - goto _test_eof20 - } - fallthrough - case 20: - // line 916 "zparse.go" - switch data[p] { - case 9: - goto tr48 + st10: + p++ + if p == pe { + goto _test_eof10 + } + fallthrough case 10: - goto tr50 - case 32: - goto tr48 - } - goto tr47 - st21: - p++ - if p == pe { - goto _test_eof21 - } - fallthrough - case 21: - switch data[p] { - case 9: - goto tr51 - case 32: - goto tr51 - } - goto st0 - tr193: - // line 122 "zparse.rl" - { - i, _ := strconv.Atoui(data[mark:p]) - hdr.Ttl = uint32(i) - } - goto st22 - tr51: - // line 119 "zparse.rl" - { - hdr.Class = str_class[data[mark:p]] - } - goto st22 - st22: - p++ - if p == pe { - goto _test_eof22 - } - fallthrough - case 22: - // line 946 "zparse.go" - switch data[p] { - case 9: + switch data[p] { + case 9: + goto st11 + case 32: + goto st11 + } + goto st0 + st11: + p++ + if p == pe { + goto _test_eof11 + } + fallthrough + case 11: + switch data[p] { + case 9: + goto tr38 + case 10: + goto st0 + case 32: + goto tr38 + } + goto tr37 + tr37: + // line 111 "zparse.rl" + { + mark = p + } + goto st12 + st12: + p++ + if p == pe { + goto _test_eof12 + } + fallthrough + case 12: + // line 816 "zparse.go" + if data[p] == 10 { + goto tr40 + } + goto st12 + tr38: + // line 111 "zparse.rl" + { + mark = p + } + goto st13 + st13: + p++ + if p == pe { + goto _test_eof13 + } + fallthrough + case 13: + // line 828 "zparse.go" + switch data[p] { + case 9: + goto tr38 + case 10: + goto tr40 + case 32: + goto tr38 + } + goto tr37 + tr18: + // line 111 "zparse.rl" + { + mark = p + } + goto st14 + st14: + p++ + if p == pe { + goto _test_eof14 + } + fallthrough + case 14: + // line 844 "zparse.go" + switch data[p] { + case 69: + goto st15 + case 72: + goto st21 + case 78: + goto st24 + case 101: + goto st15 + case 104: + goto st21 + case 110: + goto st24 + } + goto st0 + st15: + p++ + if p == pe { + goto _test_eof15 + } + fallthrough + case 15: + switch data[p] { + case 82: + goto st16 + case 114: + goto st16 + } + goto st0 + st16: + p++ + if p == pe { + goto _test_eof16 + } + fallthrough + case 16: + switch data[p] { + case 84: + goto st17 + case 116: + goto st17 + } + goto st0 + st17: + p++ + if p == pe { + goto _test_eof17 + } + fallthrough + case 17: + switch data[p] { + case 9: + goto st18 + case 32: + goto st18 + } + goto st0 + st18: + p++ + if p == pe { + goto _test_eof18 + } + fallthrough + case 18: + switch data[p] { + case 9: + goto tr48 + case 10: + goto st0 + case 32: + goto tr48 + } + goto tr47 + tr47: + // line 111 "zparse.rl" + { + mark = p + } + goto st19 + st19: + p++ + if p == pe { + goto _test_eof19 + } + fallthrough + case 19: + // line 904 "zparse.go" + if data[p] == 10 { + goto tr50 + } + goto st19 + tr48: + // line 111 "zparse.rl" + { + mark = p + } + goto st20 + st20: + p++ + if p == pe { + goto _test_eof20 + } + fallthrough + case 20: + // line 916 "zparse.go" + switch data[p] { + case 9: + goto tr48 + case 10: + goto tr50 + case 32: + goto tr48 + } + goto tr47 + st21: + p++ + if p == pe { + goto _test_eof21 + } + fallthrough + case 21: + switch data[p] { + case 9: + goto tr51 + case 32: + goto tr51 + } + goto st0 + tr193: + // line 122 "zparse.rl" + { + i, _ := strconv.Atoui(data[mark:p]) + hdr.Ttl = uint32(i) + } goto st22 - case 32: + tr51: + // line 119 "zparse.rl" + { + hdr.Class = str_class[data[mark:p]] + } goto st22 - case 65: - goto st4 - case 67: - goto st23 - case 68: + st22: + p++ + if p == pe { + goto _test_eof22 + } + fallthrough + case 22: + // line 946 "zparse.go" + switch data[p] { + case 9: + goto st22 + case 32: + goto st22 + case 65: + goto st4 + case 67: + goto st23 + case 68: + goto st31 + case 77: + goto st55 + case 78: + goto st60 + case 80: + goto st89 + case 82: + goto st95 + case 83: + goto st103 + case 84: + goto st121 + case 97: + goto st4 + case 99: + goto st23 + case 100: + goto st31 + case 109: + goto st55 + case 110: + goto st60 + case 112: + goto st89 + case 114: + goto st95 + case 115: + goto st103 + case 116: + goto st121 + } + goto st0 + st23: + p++ + if p == pe { + goto _test_eof23 + } + fallthrough + case 23: + switch data[p] { + case 69: + goto st15 + case 78: + goto st24 + case 101: + goto st15 + case 110: + goto st24 + } + goto st0 + st24: + p++ + if p == pe { + goto _test_eof24 + } + fallthrough + case 24: + switch data[p] { + case 65: + goto st25 + case 97: + goto st25 + } + goto st0 + st25: + p++ + if p == pe { + goto _test_eof25 + } + fallthrough + case 25: + switch data[p] { + case 77: + goto st26 + case 109: + goto st26 + } + goto st0 + st26: + p++ + if p == pe { + goto _test_eof26 + } + fallthrough + case 26: + switch data[p] { + case 69: + goto st27 + case 101: + goto st27 + } + goto st0 + st27: + p++ + if p == pe { + goto _test_eof27 + } + fallthrough + case 27: + switch data[p] { + case 9: + goto st28 + case 32: + goto st28 + } + goto st0 + st28: + p++ + if p == pe { + goto _test_eof28 + } + fallthrough + case 28: + switch data[p] { + case 9: + goto tr59 + case 10: + goto st0 + case 32: + goto tr59 + } + goto tr58 + tr58: + // line 111 "zparse.rl" + { + mark = p + } + goto st29 + st29: + p++ + if p == pe { + goto _test_eof29 + } + fallthrough + case 29: + // line 1042 "zparse.go" + if data[p] == 10 { + goto tr61 + } + goto st29 + tr59: + // line 111 "zparse.rl" + { + mark = p + } + goto st30 + st30: + p++ + if p == pe { + goto _test_eof30 + } + fallthrough + case 30: + // line 1054 "zparse.go" + switch data[p] { + case 9: + goto tr59 + case 10: + goto tr61 + case 32: + goto tr59 + } + goto tr58 + tr5: + // line 120 "zparse.rl" + { // ... + } goto st31 - case 77: - goto st55 - case 78: - goto st60 - case 80: - goto st89 - case 82: - goto st95 - case 83: - goto st103 - case 84: - goto st121 - case 97: - goto st4 - case 99: - goto st23 - case 100: - goto st31 - case 109: - goto st55 - case 110: - goto st60 - case 112: - goto st89 - case 114: - goto st95 - case 115: - goto st103 - case 116: - goto st121 - } - goto st0 - st23: - p++ - if p == pe { - goto _test_eof23 - } - fallthrough - case 23: - switch data[p] { - case 69: - goto st15 - case 78: - goto st24 - case 101: - goto st15 - case 110: - goto st24 - } - goto st0 - st24: - p++ - if p == pe { - goto _test_eof24 - } - fallthrough - case 24: - switch data[p] { - case 65: - goto st25 - case 97: - goto st25 - } - goto st0 - st25: - p++ - if p == pe { - goto _test_eof25 - } - fallthrough - case 25: - switch data[p] { - case 77: - goto st26 - case 109: - goto st26 - } - goto st0 - st26: - p++ - if p == pe { - goto _test_eof26 - } - fallthrough - case 26: - switch data[p] { - case 69: - goto st27 - case 101: - goto st27 - } - goto st0 - st27: - p++ - if p == pe { - goto _test_eof27 - } - fallthrough - case 27: - switch data[p] { - case 9: - goto st28 - case 32: - goto st28 - } - goto st0 - st28: - p++ - if p == pe { - goto _test_eof28 - } - fallthrough - case 28: - switch data[p] { - case 9: - goto tr59 - case 10: + st31: + p++ + if p == pe { + goto _test_eof31 + } + fallthrough + case 31: + // line 1070 "zparse.go" + switch data[p] { + case 76: + goto st32 + case 78: + goto st37 + case 83: + goto st51 + case 108: + goto st32 + case 110: + goto st37 + case 115: + goto st51 + } goto st0 + st32: + p++ + if p == pe { + goto _test_eof32 + } + fallthrough case 32: - goto tr59 - } - goto tr58 - tr58: - // line 111 "zparse.rl" - { - mark = p - } - goto st29 - st29: - p++ - if p == pe { - goto _test_eof29 - } - fallthrough - case 29: - // line 1042 "zparse.go" - if data[p] == 10 { - goto tr61 - } - goto st29 - tr59: - // line 111 "zparse.rl" - { - mark = p - } - goto st30 - st30: - p++ - if p == pe { - goto _test_eof30 - } - fallthrough - case 30: - // line 1054 "zparse.go" - switch data[p] { - case 9: - goto tr59 - case 10: - goto tr61 - case 32: - goto tr59 - } - goto tr58 - tr5: - // line 120 "zparse.rl" - { // ... - } - goto st31 - st31: - p++ - if p == pe { - goto _test_eof31 - } - fallthrough - case 31: - // line 1070 "zparse.go" - switch data[p] { - case 76: - goto st32 - case 78: - goto st37 - case 83: - goto st51 - case 108: - goto st32 - case 110: - goto st37 - case 115: - goto st51 - } - goto st0 - st32: - p++ - if p == pe { - goto _test_eof32 - } - fallthrough - case 32: - switch data[p] { - case 86: - goto st33 - case 118: - goto st33 - } - goto st0 - st33: - p++ - if p == pe { - goto _test_eof33 - } - fallthrough - case 33: - switch data[p] { - case 9: - goto st34 - case 32: - goto st34 - } - goto st0 - st34: - p++ - if p == pe { - goto _test_eof34 - } - fallthrough - case 34: - switch data[p] { - case 9: - goto tr68 - case 10: + switch data[p] { + case 86: + goto st33 + case 118: + goto st33 + } goto st0 - case 32: - goto tr68 - } - goto tr67 - tr67: - // line 111 "zparse.rl" - { - mark = p - } - goto st35 - st35: - p++ - if p == pe { - goto _test_eof35 - } - fallthrough - case 35: - // line 1120 "zparse.go" - if data[p] == 10 { - goto tr70 - } - goto st35 - tr68: - // line 111 "zparse.rl" - { - mark = p - } - goto st36 - st36: - p++ - if p == pe { - goto _test_eof36 - } - fallthrough - case 36: - // line 1132 "zparse.go" - switch data[p] { - case 9: - goto tr68 - case 10: - goto tr70 - case 32: - goto tr68 - } - goto tr67 - st37: - p++ - if p == pe { - goto _test_eof37 - } - fallthrough - case 37: - switch data[p] { - case 65: - goto st38 - case 83: - goto st44 - case 97: - goto st38 - case 115: - goto st44 - } - goto st0 - st38: - p++ - if p == pe { - goto _test_eof38 - } - fallthrough - case 38: - switch data[p] { - case 77: - goto st39 - case 109: - goto st39 - } - goto st0 - st39: - p++ - if p == pe { - goto _test_eof39 - } - fallthrough - case 39: - switch data[p] { - case 69: - goto st40 - case 101: - goto st40 - } - goto st0 - st40: - p++ - if p == pe { - goto _test_eof40 - } - fallthrough - case 40: - switch data[p] { - case 9: - goto st41 - case 32: - goto st41 - } - goto st0 - st41: - p++ - if p == pe { - goto _test_eof41 - } - fallthrough - case 41: - switch data[p] { - case 9: - goto tr77 - case 10: + st33: + p++ + if p == pe { + goto _test_eof33 + } + fallthrough + case 33: + switch data[p] { + case 9: + goto st34 + case 32: + goto st34 + } goto st0 - case 32: - goto tr77 - } - goto tr76 - tr76: - // line 111 "zparse.rl" - { - mark = p - } - goto st42 - st42: - p++ - if p == pe { - goto _test_eof42 - } - fallthrough - case 42: - // line 1201 "zparse.go" - if data[p] == 10 { - goto tr79 - } - goto st42 - tr77: - // line 111 "zparse.rl" - { - mark = p - } - goto st43 - st43: - p++ - if p == pe { - goto _test_eof43 - } - fallthrough - case 43: - // line 1213 "zparse.go" - switch data[p] { - case 9: - goto tr77 - case 10: - goto tr79 - case 32: - goto tr77 - } - goto tr76 - st44: - p++ - if p == pe { - goto _test_eof44 - } - fallthrough - case 44: - switch data[p] { - case 75: - goto st45 - case 107: - goto st45 - } - goto st0 - st45: - p++ - if p == pe { - goto _test_eof45 - } - fallthrough - case 45: - switch data[p] { - case 69: - goto st46 - case 101: - goto st46 - } - goto st0 - st46: - p++ - if p == pe { - goto _test_eof46 - } - fallthrough - case 46: - switch data[p] { - case 89: - goto st47 - case 121: - goto st47 - } - goto st0 - st47: - p++ - if p == pe { - goto _test_eof47 - } - fallthrough - case 47: - switch data[p] { - case 9: - goto st48 - case 32: - goto st48 - } - goto st0 - st48: - p++ - if p == pe { - goto _test_eof48 - } - fallthrough - case 48: - switch data[p] { - case 9: - goto tr85 - case 10: + st34: + p++ + if p == pe { + goto _test_eof34 + } + fallthrough + case 34: + switch data[p] { + case 9: + goto tr68 + case 10: + goto st0 + case 32: + goto tr68 + } + goto tr67 + tr67: + // line 111 "zparse.rl" + { + mark = p + } + goto st35 + st35: + p++ + if p == pe { + goto _test_eof35 + } + fallthrough + case 35: + // line 1120 "zparse.go" + if data[p] == 10 { + goto tr70 + } + goto st35 + tr68: + // line 111 "zparse.rl" + { + mark = p + } + goto st36 + st36: + p++ + if p == pe { + goto _test_eof36 + } + fallthrough + case 36: + // line 1132 "zparse.go" + switch data[p] { + case 9: + goto tr68 + case 10: + goto tr70 + case 32: + goto tr68 + } + goto tr67 + st37: + p++ + if p == pe { + goto _test_eof37 + } + fallthrough + case 37: + switch data[p] { + case 65: + goto st38 + case 83: + goto st44 + case 97: + goto st38 + case 115: + goto st44 + } goto st0 - case 32: - goto tr85 - } - goto tr84 - tr84: - // line 111 "zparse.rl" - { - mark = p - } - goto st49 - st49: - p++ - if p == pe { - goto _test_eof49 - } - fallthrough - case 49: - // line 1280 "zparse.go" - if data[p] == 10 { - goto tr87 - } - goto st49 - tr85: - // line 111 "zparse.rl" - { - mark = p - } - goto st50 - st50: - p++ - if p == pe { - goto _test_eof50 - } - fallthrough - case 50: - // line 1292 "zparse.go" - switch data[p] { - case 9: - goto tr85 - case 10: - goto tr87 - case 32: - goto tr85 - } - goto tr84 - st51: - p++ - if p == pe { - goto _test_eof51 - } - fallthrough - case 51: - switch data[p] { - case 9: - goto st52 - case 32: - goto st52 - } - goto st0 - st52: - p++ - if p == pe { - goto _test_eof52 - } - fallthrough - case 52: - switch data[p] { - case 9: - goto tr90 - case 10: + st38: + p++ + if p == pe { + goto _test_eof38 + } + fallthrough + case 38: + switch data[p] { + case 77: + goto st39 + case 109: + goto st39 + } goto st0 - case 32: - goto tr90 - } - goto tr89 - tr89: - // line 111 "zparse.rl" - { - mark = p - } - goto st53 - st53: - p++ - if p == pe { - goto _test_eof53 - } - fallthrough - case 53: - // line 1329 "zparse.go" - if data[p] == 10 { - goto tr92 - } - goto st53 - tr90: - // line 111 "zparse.rl" - { - mark = p - } - goto st54 - st54: - p++ - if p == pe { - goto _test_eof54 - } - fallthrough - case 54: - // line 1341 "zparse.go" - switch data[p] { - case 9: - goto tr90 - case 10: - goto tr92 - case 32: - goto tr90 - } - goto tr89 - tr8: - // line 120 "zparse.rl" - { // ... - } - goto st55 - st55: - p++ - if p == pe { - goto _test_eof55 - } - fallthrough - case 55: - // line 1357 "zparse.go" - switch data[p] { - case 88: - goto st56 - case 120: - goto st56 - } - goto st0 - st56: - p++ - if p == pe { - goto _test_eof56 - } - fallthrough - case 56: - switch data[p] { - case 9: - goto st57 - case 32: - goto st57 - } - goto st0 - st57: - p++ - if p == pe { - goto _test_eof57 - } - fallthrough - case 57: - switch data[p] { - case 9: - goto tr96 - case 10: + st39: + p++ + if p == pe { + goto _test_eof39 + } + fallthrough + case 39: + switch data[p] { + case 69: + goto st40 + case 101: + goto st40 + } goto st0 - case 32: - goto tr96 - } - goto tr95 - tr95: - // line 111 "zparse.rl" - { - mark = p - } - goto st58 - st58: - p++ - if p == pe { - goto _test_eof58 - } - fallthrough - case 58: - // line 1393 "zparse.go" - if data[p] == 10 { - goto tr98 - } - goto st58 - tr96: - // line 111 "zparse.rl" - { - mark = p - } - goto st59 - st59: - p++ - if p == pe { - goto _test_eof59 - } - fallthrough - case 59: - // line 1405 "zparse.go" - switch data[p] { - case 9: - goto tr96 - case 10: - goto tr98 - case 32: - goto tr96 - } - goto tr95 - tr9: - // line 120 "zparse.rl" - { // ... - } - goto st60 - st60: - p++ - if p == pe { - goto _test_eof60 - } - fallthrough - case 60: - // line 1421 "zparse.go" - switch data[p] { - case 65: - goto st61 - case 83: - goto st68 - case 97: - goto st61 - case 115: - goto st68 - } - goto st0 - st61: - p++ - if p == pe { - goto _test_eof61 - } - fallthrough - case 61: - switch data[p] { - case 80: - goto st62 - case 112: - goto st62 - } - goto st0 - st62: - p++ - if p == pe { - goto _test_eof62 - } - fallthrough - case 62: - switch data[p] { - case 84: - goto st63 - case 116: - goto st63 - } - goto st0 - st63: - p++ - if p == pe { - goto _test_eof63 - } - fallthrough - case 63: - switch data[p] { - case 82: - goto st64 - case 114: - goto st64 - } - goto st0 - st64: - p++ - if p == pe { - goto _test_eof64 - } - fallthrough - case 64: - switch data[p] { - case 9: - goto st65 - case 32: - goto st65 - } - goto st0 - st65: - p++ - if p == pe { - goto _test_eof65 - } - fallthrough - case 65: - switch data[p] { - case 9: - goto tr106 - case 10: + st40: + p++ + if p == pe { + goto _test_eof40 + } + fallthrough + case 40: + switch data[p] { + case 9: + goto st41 + case 32: + goto st41 + } goto st0 - case 32: - goto tr106 - } - goto tr105 - tr105: - // line 111 "zparse.rl" - { - mark = p - } - goto st66 - st66: - p++ - if p == pe { - goto _test_eof66 - } - fallthrough - case 66: - // line 1489 "zparse.go" - if data[p] == 10 { - goto tr108 - } - goto st66 - tr106: - // line 111 "zparse.rl" - { - mark = p - } - goto st67 - st67: - p++ - if p == pe { - goto _test_eof67 - } - fallthrough - case 67: - // line 1501 "zparse.go" - switch data[p] { - case 9: - goto tr106 - case 10: - goto tr108 - case 32: - goto tr106 - } - goto tr105 - st68: - p++ - if p == pe { - goto _test_eof68 - } - fallthrough - case 68: - switch data[p] { - case 9: - goto st69 - case 32: - goto st69 - case 69: - goto st72 - case 101: - goto st72 - } - goto st0 - st69: - p++ - if p == pe { - goto _test_eof69 - } - fallthrough - case 69: - switch data[p] { - case 9: - goto tr112 - case 10: - goto st0 - case 32: - goto tr112 - } - goto tr111 - tr111: - // line 111 "zparse.rl" - { - mark = p - } - goto st70 - st70: - p++ - if p == pe { - goto _test_eof70 - } - fallthrough - case 70: - // line 1540 "zparse.go" - if data[p] == 10 { - goto tr114 - } - goto st70 - tr112: - // line 111 "zparse.rl" - { - mark = p - } - goto st71 - st71: - p++ - if p == pe { - goto _test_eof71 - } - fallthrough - case 71: - // line 1552 "zparse.go" - switch data[p] { - case 9: - goto tr112 - case 10: - goto tr114 - case 32: - goto tr112 - } - goto tr111 - st72: - p++ - if p == pe { - goto _test_eof72 - } - fallthrough - case 72: - switch data[p] { - case 67: - goto st73 - case 99: - goto st73 - } - goto st0 - st73: - p++ - if p == pe { - goto _test_eof73 - } - fallthrough - case 73: - switch data[p] { - case 9: - goto st74 - case 32: - goto st74 - case 51: - goto st77 - } - goto st0 - st74: - p++ - if p == pe { - goto _test_eof74 - } - fallthrough - case 74: - switch data[p] { - case 9: - goto tr119 - case 10: - goto st0 - case 32: - goto tr119 - } - goto tr118 - tr118: - // line 111 "zparse.rl" - { - mark = p - } - goto st75 - st75: - p++ - if p == pe { - goto _test_eof75 - } - fallthrough - case 75: - // line 1600 "zparse.go" - if data[p] == 10 { - goto tr121 - } - goto st75 - tr119: - // line 111 "zparse.rl" - { - mark = p - } - goto st76 - st76: - p++ - if p == pe { - goto _test_eof76 - } - fallthrough - case 76: - // line 1612 "zparse.go" - switch data[p] { - case 9: - goto tr119 - case 10: - goto tr121 - case 32: - goto tr119 - } - goto tr118 - st77: - p++ - if p == pe { - goto _test_eof77 - } - fallthrough - case 77: - switch data[p] { - case 9: - goto st78 - case 32: - goto st78 - case 80: - goto st81 - case 112: - goto st81 - } - goto st0 - st78: - p++ - if p == pe { - goto _test_eof78 - } - fallthrough - case 78: - switch data[p] { - case 9: - goto tr125 - case 10: - goto st0 - case 32: - goto tr125 - } - goto tr124 - tr124: - // line 111 "zparse.rl" - { - mark = p - } - goto st79 - st79: - p++ - if p == pe { - goto _test_eof79 - } - fallthrough - case 79: - // line 1651 "zparse.go" - if data[p] == 10 { - goto tr127 - } - goto st79 - tr125: - // line 111 "zparse.rl" - { - mark = p - } - goto st80 - st80: - p++ - if p == pe { - goto _test_eof80 - } - fallthrough - case 80: - // line 1663 "zparse.go" - switch data[p] { - case 9: - goto tr125 - case 10: - goto tr127 - case 32: - goto tr125 - } - goto tr124 - st81: - p++ - if p == pe { - goto _test_eof81 - } - fallthrough - case 81: - switch data[p] { - case 65: - goto st82 - case 97: - goto st82 - } - goto st0 - st82: - p++ - if p == pe { - goto _test_eof82 - } - fallthrough - case 82: - switch data[p] { - case 82: - goto st83 - case 114: - goto st83 - } - goto st0 - st83: - p++ - if p == pe { - goto _test_eof83 - } - fallthrough - case 83: - switch data[p] { - case 65: - goto st84 - case 97: - goto st84 - } - goto st0 - st84: - p++ - if p == pe { - goto _test_eof84 - } - fallthrough - case 84: - switch data[p] { - case 77: - goto st85 - case 109: - goto st85 - } - goto st0 - st85: - p++ - if p == pe { - goto _test_eof85 - } - fallthrough - case 85: - switch data[p] { - case 9: - goto st86 - case 32: - goto st86 - } - goto st0 - st86: - p++ - if p == pe { - goto _test_eof86 - } - fallthrough - case 86: - switch data[p] { - case 9: - goto tr134 - case 10: - goto st0 - case 32: - goto tr134 - } - goto tr133 - tr133: - // line 111 "zparse.rl" - { - mark = p - } - goto st87 - st87: - p++ - if p == pe { - goto _test_eof87 - } - fallthrough - case 87: - // line 1740 "zparse.go" - if data[p] == 10 { - goto tr136 - } - goto st87 - tr134: - // line 111 "zparse.rl" - { - mark = p - } - goto st88 - st88: - p++ - if p == pe { - goto _test_eof88 - } - fallthrough - case 88: - // line 1752 "zparse.go" - switch data[p] { - case 9: - goto tr134 - case 10: - goto tr136 - case 32: - goto tr134 - } - goto tr133 - tr10: - // line 120 "zparse.rl" - { // ... - } - goto st89 - st89: - p++ - if p == pe { - goto _test_eof89 - } - fallthrough - case 89: - // line 1768 "zparse.go" - switch data[p] { - case 84: - goto st90 - case 116: - goto st90 - } - goto st0 - st90: - p++ - if p == pe { - goto _test_eof90 - } - fallthrough - case 90: - switch data[p] { - case 82: - goto st91 - case 114: - goto st91 - } - goto st0 - st91: - p++ - if p == pe { - goto _test_eof91 - } - fallthrough - case 91: - switch data[p] { - case 9: - goto st92 - case 32: - goto st92 - } - goto st0 - st92: - p++ - if p == pe { - goto _test_eof92 - } - fallthrough - case 92: - switch data[p] { - case 9: - goto tr141 - case 10: - goto st0 - case 32: - goto tr141 - } - goto tr140 - tr140: - // line 111 "zparse.rl" - { - mark = p - } - goto st93 - st93: - p++ - if p == pe { - goto _test_eof93 - } - fallthrough - case 93: - // line 1814 "zparse.go" - if data[p] == 10 { - goto tr143 - } - goto st93 - tr141: - // line 111 "zparse.rl" - { - mark = p - } - goto st94 - st94: - p++ - if p == pe { - goto _test_eof94 - } - fallthrough - case 94: - // line 1826 "zparse.go" - switch data[p] { - case 9: - goto tr141 - case 10: - goto tr143 - case 32: - goto tr141 - } - goto tr140 - tr11: - // line 120 "zparse.rl" - { // ... - } - goto st95 - st95: - p++ - if p == pe { - goto _test_eof95 - } - fallthrough - case 95: - // line 1842 "zparse.go" - switch data[p] { - case 82: - goto st96 - case 114: - goto st96 - } - goto st0 - st96: - p++ - if p == pe { - goto _test_eof96 - } - fallthrough - case 96: - switch data[p] { - case 83: - goto st97 - case 115: - goto st97 - } - goto st0 - st97: - p++ - if p == pe { - goto _test_eof97 - } - fallthrough - case 97: - switch data[p] { - case 73: - goto st98 - case 105: - goto st98 - } - goto st0 - st98: - p++ - if p == pe { - goto _test_eof98 - } - fallthrough - case 98: - switch data[p] { - case 71: - goto st99 - case 103: - goto st99 - } - goto st0 - st99: - p++ - if p == pe { - goto _test_eof99 - } - fallthrough - case 99: - switch data[p] { - case 9: - goto st100 - case 32: - goto st100 - } - goto st0 - st100: - p++ - if p == pe { - goto _test_eof100 - } - fallthrough - case 100: - switch data[p] { - case 9: - goto tr150 - case 10: - goto st0 - case 32: - goto tr150 - } - goto tr149 - tr149: - // line 111 "zparse.rl" - { - mark = p - } - goto st101 - st101: - p++ - if p == pe { - goto _test_eof101 - } - fallthrough - case 101: - // line 1908 "zparse.go" - if data[p] == 10 { - goto tr152 - } - goto st101 - tr150: - // line 111 "zparse.rl" - { - mark = p - } - goto st102 - st102: - p++ - if p == pe { - goto _test_eof102 - } - fallthrough - case 102: - // line 1920 "zparse.go" - switch data[p] { - case 9: - goto tr150 - case 10: - goto tr152 - case 32: - goto tr150 - } - goto tr149 - tr12: - // line 120 "zparse.rl" - { // ... - } - goto st103 - st103: - p++ - if p == pe { - goto _test_eof103 - } - fallthrough - case 103: - // line 1936 "zparse.go" - switch data[p] { - case 79: - goto st104 - case 82: - goto st109 - case 83: - goto st114 - case 111: - goto st104 - case 114: - goto st109 - case 115: - goto st114 - } - goto st0 - st104: - p++ - if p == pe { - goto _test_eof104 - } - fallthrough - case 104: - switch data[p] { - case 65: - goto st105 - case 97: - goto st105 - } - goto st0 - st105: - p++ - if p == pe { - goto _test_eof105 - } - fallthrough - case 105: - switch data[p] { - case 9: - goto st106 - case 32: - goto st106 - } - goto st0 - st106: - p++ - if p == pe { - goto _test_eof106 - } - fallthrough - case 106: - switch data[p] { - case 9: - goto tr159 - case 10: - goto st0 - case 32: - goto tr159 - } - goto tr158 - tr158: - // line 111 "zparse.rl" - { - mark = p - } - goto st107 - st107: - p++ - if p == pe { - goto _test_eof107 - } - fallthrough - case 107: - // line 1986 "zparse.go" - if data[p] == 10 { - goto tr161 - } - goto st107 - tr159: - // line 111 "zparse.rl" - { - mark = p - } - goto st108 - st108: - p++ - if p == pe { - goto _test_eof108 - } - fallthrough - case 108: - // line 1998 "zparse.go" - switch data[p] { - case 9: - goto tr159 - case 10: - goto tr161 - case 32: - goto tr159 - } - goto tr158 - st109: - p++ - if p == pe { - goto _test_eof109 - } - fallthrough - case 109: - switch data[p] { - case 86: - goto st110 - case 118: - goto st110 - } - goto st0 - st110: - p++ - if p == pe { - goto _test_eof110 - } - fallthrough - case 110: - switch data[p] { - case 9: - goto st111 - case 32: - goto st111 - } - goto st0 - st111: - p++ - if p == pe { - goto _test_eof111 - } - fallthrough - case 111: - switch data[p] { - case 9: - goto tr165 - case 10: - goto st0 - case 32: - goto tr165 - } - goto tr164 - tr164: - // line 111 "zparse.rl" - { - mark = p - } - goto st112 - st112: - p++ - if p == pe { - goto _test_eof112 - } - fallthrough - case 112: - // line 2045 "zparse.go" - if data[p] == 10 { - goto tr167 - } - goto st112 - tr165: - // line 111 "zparse.rl" - { - mark = p - } - goto st113 - st113: - p++ - if p == pe { - goto _test_eof113 - } - fallthrough - case 113: - // line 2057 "zparse.go" - switch data[p] { - case 9: - goto tr165 - case 10: - goto tr167 - case 32: - goto tr165 - } - goto tr164 - st114: - p++ - if p == pe { - goto _test_eof114 - } - fallthrough - case 114: - switch data[p] { - case 72: - goto st115 - case 104: - goto st115 - } - goto st0 - st115: - p++ - if p == pe { - goto _test_eof115 - } - fallthrough - case 115: - switch data[p] { - case 70: - goto st116 - case 102: - goto st116 - } - goto st0 - st116: - p++ - if p == pe { - goto _test_eof116 - } - fallthrough - case 116: - switch data[p] { - case 80: - goto st117 - case 112: - goto st117 - } - goto st0 - st117: - p++ - if p == pe { - goto _test_eof117 - } - fallthrough - case 117: - switch data[p] { - case 9: - goto st118 - case 32: - goto st118 - } - goto st0 - st118: - p++ - if p == pe { - goto _test_eof118 - } - fallthrough - case 118: - switch data[p] { - case 9: - goto tr173 - case 10: - goto st0 - case 32: - goto tr173 - } - goto tr172 - tr172: - // line 111 "zparse.rl" - { - mark = p - } - goto st119 - st119: - p++ - if p == pe { - goto _test_eof119 - } - fallthrough - case 119: - // line 2124 "zparse.go" - if data[p] == 10 { - goto tr175 - } - goto st119 - tr173: - // line 111 "zparse.rl" - { - mark = p - } - goto st120 - st120: - p++ - if p == pe { - goto _test_eof120 - } - fallthrough - case 120: - // line 2136 "zparse.go" - switch data[p] { - case 9: - goto tr173 - case 10: - goto tr175 - case 32: - goto tr173 - } - goto tr172 - tr13: - // line 120 "zparse.rl" - { // ... - } - goto st121 - st121: - p++ - if p == pe { - goto _test_eof121 - } - fallthrough - case 121: - // line 2152 "zparse.go" - switch data[p] { - case 65: - goto st122 - case 88: - goto st126 - case 97: - goto st122 - case 120: - goto st126 - } - goto st0 - st122: - p++ - if p == pe { - goto _test_eof122 - } - fallthrough - case 122: - switch data[p] { - case 9: - goto st123 - case 32: - goto st123 - } - goto st0 - st123: - p++ - if p == pe { - goto _test_eof123 - } - fallthrough - case 123: - switch data[p] { - case 9: - goto tr180 - case 10: - goto st0 - case 32: - goto tr180 - } - goto tr179 - tr179: - // line 111 "zparse.rl" - { - mark = p - } - goto st124 - st124: - p++ - if p == pe { - goto _test_eof124 - } - fallthrough - case 124: - // line 2190 "zparse.go" - if data[p] == 10 { - goto tr182 - } - goto st124 - tr180: - // line 111 "zparse.rl" - { - mark = p - } - goto st125 - st125: - p++ - if p == pe { - goto _test_eof125 - } - fallthrough - case 125: - // line 2202 "zparse.go" - switch data[p] { - case 9: - goto tr180 - case 10: - goto tr182 - case 32: - goto tr180 - } - goto tr179 - st126: - p++ - if p == pe { - goto _test_eof126 - } - fallthrough - case 126: - switch data[p] { - case 84: - goto st127 - case 116: - goto st127 - } - goto st0 - st127: - p++ - if p == pe { - goto _test_eof127 - } - fallthrough - case 127: - switch data[p] { - case 9: - goto st128 - case 32: - goto st128 - } - goto st0 - st128: - p++ - if p == pe { - goto _test_eof128 - } - fallthrough - case 128: - switch data[p] { - case 9: - goto tr186 - case 10: - goto st0 - case 32: - goto tr186 - } - goto tr185 - tr185: - // line 111 "zparse.rl" - { - mark = p - } - goto st129 - st129: - p++ - if p == pe { - goto _test_eof129 - } - fallthrough - case 129: - // line 2249 "zparse.go" - if data[p] == 10 { - goto tr188 - } - goto st129 - tr186: - // line 111 "zparse.rl" - { - mark = p - } - goto st130 - st130: - p++ - if p == pe { - goto _test_eof130 - } - fallthrough - case 130: - // line 2261 "zparse.go" - switch data[p] { - case 9: - goto tr186 - case 10: - goto tr188 - case 32: - goto tr186 - } - goto tr185 - tr20: - // line 111 "zparse.rl" - { - mark = p - } - goto st131 - st131: - p++ - if p == pe { - goto _test_eof131 - } - fallthrough - case 131: - // line 2277 "zparse.go" - switch data[p] { - case 83: - goto st21 - case 115: - goto st21 - } - goto st0 - tr21: - // line 111 "zparse.rl" - { - mark = p - } - goto st132 - st132: - p++ - if p == pe { - goto _test_eof132 - } - fallthrough - case 132: - // line 2292 "zparse.go" - switch data[p] { - case 78: - goto st21 - case 110: - goto st21 - } - goto st0 - tr4: - // line 120 "zparse.rl" - { // ... - } - // line 111 "zparse.rl" - { - mark = p - } - goto st133 - st133: - p++ - if p == pe { - goto _test_eof133 - } - fallthrough - case 133: - // line 2309 "zparse.go" - switch data[p] { - case 69: - goto st15 - case 72: - goto st134 - case 78: - goto st24 - case 101: - goto st15 - case 104: - goto st134 - case 110: - goto st24 - } - goto st0 - st134: - p++ - if p == pe { - goto _test_eof134 - } - fallthrough - case 134: - switch data[p] { - case 9: - goto tr190 - case 32: - goto tr190 - } - goto st0 - tr190: - // line 119 "zparse.rl" - { - hdr.Class = str_class[data[mark:p]] - } - goto st135 - st135: - p++ - if p == pe { - goto _test_eof135 - } - fallthrough - case 135: - // line 2338 "zparse.go" - switch data[p] { - case 9: - goto st135 - case 32: - goto st135 - case 65: - goto st4 - case 67: - goto st23 - case 68: - goto st31 - case 77: - goto st55 - case 78: - goto st60 - case 80: - goto st89 - case 82: - goto st95 - case 83: - goto st103 - case 84: - goto st121 - case 97: - goto st4 - case 99: - goto st23 - case 100: - goto st31 - case 109: - goto st55 - case 110: - goto st60 - case 112: - goto st89 - case 114: - goto st95 - case 115: - goto st103 - case 116: - goto st121 - } - if 48 <= data[p] && data[p] <= 57 { - goto tr192 - } - goto st0 - tr192: - // line 111 "zparse.rl" - { - mark = p - } - goto st136 - st136: - p++ - if p == pe { - goto _test_eof136 - } - fallthrough - case 136: - // line 2372 "zparse.go" - switch data[p] { - case 9: - goto tr193 - case 32: - goto tr193 - } - if 48 <= data[p] && data[p] <= 57 { - goto st136 - } - goto st0 - tr6: - // line 120 "zparse.rl" - { // ... - } - // line 111 "zparse.rl" - { - mark = p - } - goto st137 - st137: - p++ - if p == pe { - goto _test_eof137 - } - fallthrough - case 137: - // line 2390 "zparse.go" - switch data[p] { - case 83: - goto st134 - case 115: - goto st134 - } - goto st0 - tr7: - // line 120 "zparse.rl" - { // ... - } - // line 111 "zparse.rl" - { - mark = p - } - goto st138 - st138: - p++ - if p == pe { - goto _test_eof138 - } - fallthrough - case 138: - // line 2407 "zparse.go" - switch data[p] { - case 78: - goto st134 - case 110: - goto st134 - } - goto st0 - tr199: - // line 111 "zparse.rl" - { - mark = p - } - goto st139 - st139: - p++ - if p == pe { - goto _test_eof139 - } - fallthrough - case 139: - // line 2422 "zparse.go" - switch data[p] { - case 9: - goto tr195 - case 32: - goto tr195 + st41: + p++ + if p == pe { + goto _test_eof41 + } + fallthrough + case 41: + switch data[p] { + case 9: + goto tr77 + case 10: + goto st0 + case 32: + goto tr77 + } + goto tr76 + tr76: + // line 111 "zparse.rl" + { + mark = p + } + goto st42 + st42: + p++ + if p == pe { + goto _test_eof42 + } + fallthrough case 42: - goto st139 + // line 1201 "zparse.go" + if data[p] == 10 { + goto tr79 + } + goto st42 + tr77: + // line 111 "zparse.rl" + { + mark = p + } + goto st43 + st43: + p++ + if p == pe { + goto _test_eof43 + } + fallthrough + case 43: + // line 1213 "zparse.go" + switch data[p] { + case 9: + goto tr77 + case 10: + goto tr79 + case 32: + goto tr77 + } + goto tr76 + st44: + p++ + if p == pe { + goto _test_eof44 + } + fallthrough + case 44: + switch data[p] { + case 75: + goto st45 + case 107: + goto st45 + } + goto st0 + st45: + p++ + if p == pe { + goto _test_eof45 + } + fallthrough + case 45: + switch data[p] { + case 69: + goto st46 + case 101: + goto st46 + } + goto st0 + st46: + p++ + if p == pe { + goto _test_eof46 + } + fallthrough + case 46: + switch data[p] { + case 89: + goto st47 + case 121: + goto st47 + } + goto st0 + st47: + p++ + if p == pe { + goto _test_eof47 + } + fallthrough + case 47: + switch data[p] { + case 9: + goto st48 + case 32: + goto st48 + } + goto st0 + st48: + p++ + if p == pe { + goto _test_eof48 + } + fallthrough + case 48: + switch data[p] { + case 9: + goto tr85 + case 10: + goto st0 + case 32: + goto tr85 + } + goto tr84 + tr84: + // line 111 "zparse.rl" + { + mark = p + } + goto st49 + st49: + p++ + if p == pe { + goto _test_eof49 + } + fallthrough + case 49: + // line 1280 "zparse.go" + if data[p] == 10 { + goto tr87 + } + goto st49 + tr85: + // line 111 "zparse.rl" + { + mark = p + } + goto st50 + st50: + p++ + if p == pe { + goto _test_eof50 + } + fallthrough + case 50: + // line 1292 "zparse.go" + switch data[p] { + case 9: + goto tr85 + case 10: + goto tr87 + case 32: + goto tr85 + } + goto tr84 + st51: + p++ + if p == pe { + goto _test_eof51 + } + fallthrough + case 51: + switch data[p] { + case 9: + goto st52 + case 32: + goto st52 + } + goto st0 + st52: + p++ + if p == pe { + goto _test_eof52 + } + fallthrough + case 52: + switch data[p] { + case 9: + goto tr90 + case 10: + goto st0 + case 32: + goto tr90 + } + goto tr89 + tr89: + // line 111 "zparse.rl" + { + mark = p + } + goto st53 + st53: + p++ + if p == pe { + goto _test_eof53 + } + fallthrough + case 53: + // line 1329 "zparse.go" + if data[p] == 10 { + goto tr92 + } + goto st53 + tr90: + // line 111 "zparse.rl" + { + mark = p + } + goto st54 + st54: + p++ + if p == pe { + goto _test_eof54 + } + fallthrough + case 54: + // line 1341 "zparse.go" + switch data[p] { + case 9: + goto tr90 + case 10: + goto tr92 + case 32: + goto tr90 + } + goto tr89 + tr8: + // line 120 "zparse.rl" + { // ... + } + goto st55 + st55: + p++ + if p == pe { + goto _test_eof55 + } + fallthrough + case 55: + // line 1357 "zparse.go" + switch data[p] { + case 88: + goto st56 + case 120: + goto st56 + } + goto st0 + st56: + p++ + if p == pe { + goto _test_eof56 + } + fallthrough + case 56: + switch data[p] { + case 9: + goto st57 + case 32: + goto st57 + } + goto st0 + st57: + p++ + if p == pe { + goto _test_eof57 + } + fallthrough + case 57: + switch data[p] { + case 9: + goto tr96 + case 10: + goto st0 + case 32: + goto tr96 + } + goto tr95 + tr95: + // line 111 "zparse.rl" + { + mark = p + } + goto st58 + st58: + p++ + if p == pe { + goto _test_eof58 + } + fallthrough + case 58: + // line 1393 "zparse.go" + if data[p] == 10 { + goto tr98 + } + goto st58 + tr96: + // line 111 "zparse.rl" + { + mark = p + } + goto st59 + st59: + p++ + if p == pe { + goto _test_eof59 + } + fallthrough + case 59: + // line 1405 "zparse.go" + switch data[p] { + case 9: + goto tr96 + case 10: + goto tr98 + case 32: + goto tr96 + } + goto tr95 + tr9: + // line 120 "zparse.rl" + { // ... + } + goto st60 + st60: + p++ + if p == pe { + goto _test_eof60 + } + fallthrough + case 60: + // line 1421 "zparse.go" + switch data[p] { + case 65: + goto st61 + case 83: + goto st68 + case 97: + goto st61 + case 115: + goto st68 + } + goto st0 + st61: + p++ + if p == pe { + goto _test_eof61 + } + fallthrough + case 61: + switch data[p] { + case 80: + goto st62 + case 112: + goto st62 + } + goto st0 + st62: + p++ + if p == pe { + goto _test_eof62 + } + fallthrough + case 62: + switch data[p] { + case 84: + goto st63 + case 116: + goto st63 + } + goto st0 + st63: + p++ + if p == pe { + goto _test_eof63 + } + fallthrough + case 63: + switch data[p] { + case 82: + goto st64 + case 114: + goto st64 + } + goto st0 + st64: + p++ + if p == pe { + goto _test_eof64 + } + fallthrough + case 64: + switch data[p] { + case 9: + goto st65 + case 32: + goto st65 + } + goto st0 + st65: + p++ + if p == pe { + goto _test_eof65 + } + fallthrough + case 65: + switch data[p] { + case 9: + goto tr106 + case 10: + goto st0 + case 32: + goto tr106 + } + goto tr105 + tr105: + // line 111 "zparse.rl" + { + mark = p + } + goto st66 + st66: + p++ + if p == pe { + goto _test_eof66 + } + fallthrough + case 66: + // line 1489 "zparse.go" + if data[p] == 10 { + goto tr108 + } + goto st66 + tr106: + // line 111 "zparse.rl" + { + mark = p + } + goto st67 + st67: + p++ + if p == pe { + goto _test_eof67 + } + fallthrough + case 67: + // line 1501 "zparse.go" + switch data[p] { + case 9: + goto tr106 + case 10: + goto tr108 + case 32: + goto tr106 + } + goto tr105 + st68: + p++ + if p == pe { + goto _test_eof68 + } + fallthrough + case 68: + switch data[p] { + case 9: + goto st69 + case 32: + goto st69 + case 69: + goto st72 + case 101: + goto st72 + } + goto st0 + st69: + p++ + if p == pe { + goto _test_eof69 + } + fallthrough + case 69: + switch data[p] { + case 9: + goto tr112 + case 10: + goto st0 + case 32: + goto tr112 + } + goto tr111 + tr111: + // line 111 "zparse.rl" + { + mark = p + } + goto st70 + st70: + p++ + if p == pe { + goto _test_eof70 + } + fallthrough + case 70: + // line 1540 "zparse.go" + if data[p] == 10 { + goto tr114 + } + goto st70 + tr112: + // line 111 "zparse.rl" + { + mark = p + } + goto st71 + st71: + p++ + if p == pe { + goto _test_eof71 + } + fallthrough + case 71: + // line 1552 "zparse.go" + switch data[p] { + case 9: + goto tr112 + case 10: + goto tr114 + case 32: + goto tr112 + } + goto tr111 + st72: + p++ + if p == pe { + goto _test_eof72 + } + fallthrough + case 72: + switch data[p] { + case 67: + goto st73 + case 99: + goto st73 + } + goto st0 + st73: + p++ + if p == pe { + goto _test_eof73 + } + fallthrough + case 73: + switch data[p] { + case 9: + goto st74 + case 32: + goto st74 + case 51: + goto st77 + } + goto st0 + st74: + p++ + if p == pe { + goto _test_eof74 + } + fallthrough + case 74: + switch data[p] { + case 9: + goto tr119 + case 10: + goto st0 + case 32: + goto tr119 + } + goto tr118 + tr118: + // line 111 "zparse.rl" + { + mark = p + } + goto st75 + st75: + p++ + if p == pe { + goto _test_eof75 + } + fallthrough + case 75: + // line 1600 "zparse.go" + if data[p] == 10 { + goto tr121 + } + goto st75 + tr119: + // line 111 "zparse.rl" + { + mark = p + } + goto st76 + st76: + p++ + if p == pe { + goto _test_eof76 + } + fallthrough + case 76: + // line 1612 "zparse.go" + switch data[p] { + case 9: + goto tr119 + case 10: + goto tr121 + case 32: + goto tr119 + } + goto tr118 + st77: + p++ + if p == pe { + goto _test_eof77 + } + fallthrough + case 77: + switch data[p] { + case 9: + goto st78 + case 32: + goto st78 + case 80: + goto st81 + case 112: + goto st81 + } + goto st0 + st78: + p++ + if p == pe { + goto _test_eof78 + } + fallthrough + case 78: + switch data[p] { + case 9: + goto tr125 + case 10: + goto st0 + case 32: + goto tr125 + } + goto tr124 + tr124: + // line 111 "zparse.rl" + { + mark = p + } + goto st79 + st79: + p++ + if p == pe { + goto _test_eof79 + } + fallthrough + case 79: + // line 1651 "zparse.go" + if data[p] == 10 { + goto tr127 + } + goto st79 + tr125: + // line 111 "zparse.rl" + { + mark = p + } + goto st80 + st80: + p++ + if p == pe { + goto _test_eof80 + } + fallthrough + case 80: + // line 1663 "zparse.go" + switch data[p] { + case 9: + goto tr125 + case 10: + goto tr127 + case 32: + goto tr125 + } + goto tr124 + st81: + p++ + if p == pe { + goto _test_eof81 + } + fallthrough + case 81: + switch data[p] { + case 65: + goto st82 + case 97: + goto st82 + } + goto st0 + st82: + p++ + if p == pe { + goto _test_eof82 + } + fallthrough + case 82: + switch data[p] { + case 82: + goto st83 + case 114: + goto st83 + } + goto st0 + st83: + p++ + if p == pe { + goto _test_eof83 + } + fallthrough + case 83: + switch data[p] { + case 65: + goto st84 + case 97: + goto st84 + } + goto st0 + st84: + p++ + if p == pe { + goto _test_eof84 + } + fallthrough + case 84: + switch data[p] { + case 77: + goto st85 + case 109: + goto st85 + } + goto st0 + st85: + p++ + if p == pe { + goto _test_eof85 + } + fallthrough + case 85: + switch data[p] { + case 9: + goto st86 + case 32: + goto st86 + } + goto st0 + st86: + p++ + if p == pe { + goto _test_eof86 + } + fallthrough + case 86: + switch data[p] { + case 9: + goto tr134 + case 10: + goto st0 + case 32: + goto tr134 + } + goto tr133 + tr133: + // line 111 "zparse.rl" + { + mark = p + } + goto st87 + st87: + p++ + if p == pe { + goto _test_eof87 + } + fallthrough + case 87: + // line 1740 "zparse.go" + if data[p] == 10 { + goto tr136 + } + goto st87 + tr134: + // line 111 "zparse.rl" + { + mark = p + } + goto st88 + st88: + p++ + if p == pe { + goto _test_eof88 + } + fallthrough + case 88: + // line 1752 "zparse.go" + switch data[p] { + case 9: + goto tr134 + case 10: + goto tr136 + case 32: + goto tr134 + } + goto tr133 + tr10: + // line 120 "zparse.rl" + { // ... + } + goto st89 + st89: + p++ + if p == pe { + goto _test_eof89 + } + fallthrough + case 89: + // line 1768 "zparse.go" + switch data[p] { + case 84: + goto st90 + case 116: + goto st90 + } + goto st0 + st90: + p++ + if p == pe { + goto _test_eof90 + } + fallthrough + case 90: + switch data[p] { + case 82: + goto st91 + case 114: + goto st91 + } + goto st0 + st91: + p++ + if p == pe { + goto _test_eof91 + } + fallthrough + case 91: + switch data[p] { + case 9: + goto st92 + case 32: + goto st92 + } + goto st0 + st92: + p++ + if p == pe { + goto _test_eof92 + } + fallthrough + case 92: + switch data[p] { + case 9: + goto tr141 + case 10: + goto st0 + case 32: + goto tr141 + } + goto tr140 + tr140: + // line 111 "zparse.rl" + { + mark = p + } + goto st93 + st93: + p++ + if p == pe { + goto _test_eof93 + } + fallthrough + case 93: + // line 1814 "zparse.go" + if data[p] == 10 { + goto tr143 + } + goto st93 + tr141: + // line 111 "zparse.rl" + { + mark = p + } + goto st94 + st94: + p++ + if p == pe { + goto _test_eof94 + } + fallthrough + case 94: + // line 1826 "zparse.go" + switch data[p] { + case 9: + goto tr141 + case 10: + goto tr143 + case 32: + goto tr141 + } + goto tr140 + tr11: + // line 120 "zparse.rl" + { // ... + } + goto st95 + st95: + p++ + if p == pe { + goto _test_eof95 + } + fallthrough case 95: + // line 1842 "zparse.go" + switch data[p] { + case 82: + goto st96 + case 114: + goto st96 + } + goto st0 + st96: + p++ + if p == pe { + goto _test_eof96 + } + fallthrough + case 96: + switch data[p] { + case 83: + goto st97 + case 115: + goto st97 + } + goto st0 + st97: + p++ + if p == pe { + goto _test_eof97 + } + fallthrough + case 97: + switch data[p] { + case 73: + goto st98 + case 105: + goto st98 + } + goto st0 + st98: + p++ + if p == pe { + goto _test_eof98 + } + fallthrough + case 98: + switch data[p] { + case 71: + goto st99 + case 103: + goto st99 + } + goto st0 + st99: + p++ + if p == pe { + goto _test_eof99 + } + fallthrough + case 99: + switch data[p] { + case 9: + goto st100 + case 32: + goto st100 + } + goto st0 + st100: + p++ + if p == pe { + goto _test_eof100 + } + fallthrough + case 100: + switch data[p] { + case 9: + goto tr150 + case 10: + goto st0 + case 32: + goto tr150 + } + goto tr149 + tr149: + // line 111 "zparse.rl" + { + mark = p + } + goto st101 + st101: + p++ + if p == pe { + goto _test_eof101 + } + fallthrough + case 101: + // line 1908 "zparse.go" + if data[p] == 10 { + goto tr152 + } + goto st101 + tr150: + // line 111 "zparse.rl" + { + mark = p + } + goto st102 + st102: + p++ + if p == pe { + goto _test_eof102 + } + fallthrough + case 102: + // line 1920 "zparse.go" + switch data[p] { + case 9: + goto tr150 + case 10: + goto tr152 + case 32: + goto tr150 + } + goto tr149 + tr12: + // line 120 "zparse.rl" + { // ... + } + goto st103 + st103: + p++ + if p == pe { + goto _test_eof103 + } + fallthrough + case 103: + // line 1936 "zparse.go" + switch data[p] { + case 79: + goto st104 + case 82: + goto st109 + case 83: + goto st114 + case 111: + goto st104 + case 114: + goto st109 + case 115: + goto st114 + } + goto st0 + st104: + p++ + if p == pe { + goto _test_eof104 + } + fallthrough + case 104: + switch data[p] { + case 65: + goto st105 + case 97: + goto st105 + } + goto st0 + st105: + p++ + if p == pe { + goto _test_eof105 + } + fallthrough + case 105: + switch data[p] { + case 9: + goto st106 + case 32: + goto st106 + } + goto st0 + st106: + p++ + if p == pe { + goto _test_eof106 + } + fallthrough + case 106: + switch data[p] { + case 9: + goto tr159 + case 10: + goto st0 + case 32: + goto tr159 + } + goto tr158 + tr158: + // line 111 "zparse.rl" + { + mark = p + } + goto st107 + st107: + p++ + if p == pe { + goto _test_eof107 + } + fallthrough + case 107: + // line 1986 "zparse.go" + if data[p] == 10 { + goto tr161 + } + goto st107 + tr159: + // line 111 "zparse.rl" + { + mark = p + } + goto st108 + st108: + p++ + if p == pe { + goto _test_eof108 + } + fallthrough + case 108: + // line 1998 "zparse.go" + switch data[p] { + case 9: + goto tr159 + case 10: + goto tr161 + case 32: + goto tr159 + } + goto tr158 + st109: + p++ + if p == pe { + goto _test_eof109 + } + fallthrough + case 109: + switch data[p] { + case 86: + goto st110 + case 118: + goto st110 + } + goto st0 + st110: + p++ + if p == pe { + goto _test_eof110 + } + fallthrough + case 110: + switch data[p] { + case 9: + goto st111 + case 32: + goto st111 + } + goto st0 + st111: + p++ + if p == pe { + goto _test_eof111 + } + fallthrough + case 111: + switch data[p] { + case 9: + goto tr165 + case 10: + goto st0 + case 32: + goto tr165 + } + goto tr164 + tr164: + // line 111 "zparse.rl" + { + mark = p + } + goto st112 + st112: + p++ + if p == pe { + goto _test_eof112 + } + fallthrough + case 112: + // line 2045 "zparse.go" + if data[p] == 10 { + goto tr167 + } + goto st112 + tr165: + // line 111 "zparse.rl" + { + mark = p + } + goto st113 + st113: + p++ + if p == pe { + goto _test_eof113 + } + fallthrough + case 113: + // line 2057 "zparse.go" + switch data[p] { + case 9: + goto tr165 + case 10: + goto tr167 + case 32: + goto tr165 + } + goto tr164 + st114: + p++ + if p == pe { + goto _test_eof114 + } + fallthrough + case 114: + switch data[p] { + case 72: + goto st115 + case 104: + goto st115 + } + goto st0 + st115: + p++ + if p == pe { + goto _test_eof115 + } + fallthrough + case 115: + switch data[p] { + case 70: + goto st116 + case 102: + goto st116 + } + goto st0 + st116: + p++ + if p == pe { + goto _test_eof116 + } + fallthrough + case 116: + switch data[p] { + case 80: + goto st117 + case 112: + goto st117 + } + goto st0 + st117: + p++ + if p == pe { + goto _test_eof117 + } + fallthrough + case 117: + switch data[p] { + case 9: + goto st118 + case 32: + goto st118 + } + goto st0 + st118: + p++ + if p == pe { + goto _test_eof118 + } + fallthrough + case 118: + switch data[p] { + case 9: + goto tr173 + case 10: + goto st0 + case 32: + goto tr173 + } + goto tr172 + tr172: + // line 111 "zparse.rl" + { + mark = p + } + goto st119 + st119: + p++ + if p == pe { + goto _test_eof119 + } + fallthrough + case 119: + // line 2124 "zparse.go" + if data[p] == 10 { + goto tr175 + } + goto st119 + tr173: + // line 111 "zparse.rl" + { + mark = p + } + goto st120 + st120: + p++ + if p == pe { + goto _test_eof120 + } + fallthrough + case 120: + // line 2136 "zparse.go" + switch data[p] { + case 9: + goto tr173 + case 10: + goto tr175 + case 32: + goto tr173 + } + goto tr172 + tr13: + // line 120 "zparse.rl" + { // ... + } + goto st121 + st121: + p++ + if p == pe { + goto _test_eof121 + } + fallthrough + case 121: + // line 2152 "zparse.go" + switch data[p] { + case 65: + goto st122 + case 88: + goto st126 + case 97: + goto st122 + case 120: + goto st126 + } + goto st0 + st122: + p++ + if p == pe { + goto _test_eof122 + } + fallthrough + case 122: + switch data[p] { + case 9: + goto st123 + case 32: + goto st123 + } + goto st0 + st123: + p++ + if p == pe { + goto _test_eof123 + } + fallthrough + case 123: + switch data[p] { + case 9: + goto tr180 + case 10: + goto st0 + case 32: + goto tr180 + } + goto tr179 + tr179: + // line 111 "zparse.rl" + { + mark = p + } + goto st124 + st124: + p++ + if p == pe { + goto _test_eof124 + } + fallthrough + case 124: + // line 2190 "zparse.go" + if data[p] == 10 { + goto tr182 + } + goto st124 + tr180: + // line 111 "zparse.rl" + { + mark = p + } + goto st125 + st125: + p++ + if p == pe { + goto _test_eof125 + } + fallthrough + case 125: + // line 2202 "zparse.go" + switch data[p] { + case 9: + goto tr180 + case 10: + goto tr182 + case 32: + goto tr180 + } + goto tr179 + st126: + p++ + if p == pe { + goto _test_eof126 + } + fallthrough + case 126: + switch data[p] { + case 84: + goto st127 + case 116: + goto st127 + } + goto st0 + st127: + p++ + if p == pe { + goto _test_eof127 + } + fallthrough + case 127: + switch data[p] { + case 9: + goto st128 + case 32: + goto st128 + } + goto st0 + st128: + p++ + if p == pe { + goto _test_eof128 + } + fallthrough + case 128: + switch data[p] { + case 9: + goto tr186 + case 10: + goto st0 + case 32: + goto tr186 + } + goto tr185 + tr185: + // line 111 "zparse.rl" + { + mark = p + } + goto st129 + st129: + p++ + if p == pe { + goto _test_eof129 + } + fallthrough + case 129: + // line 2249 "zparse.go" + if data[p] == 10 { + goto tr188 + } + goto st129 + tr186: + // line 111 "zparse.rl" + { + mark = p + } + goto st130 + st130: + p++ + if p == pe { + goto _test_eof130 + } + fallthrough + case 130: + // line 2261 "zparse.go" + switch data[p] { + case 9: + goto tr186 + case 10: + goto tr188 + case 32: + goto tr186 + } + goto tr185 + tr20: + // line 111 "zparse.rl" + { + mark = p + } + goto st131 + st131: + p++ + if p == pe { + goto _test_eof131 + } + fallthrough + case 131: + // line 2277 "zparse.go" + switch data[p] { + case 83: + goto st21 + case 115: + goto st21 + } + goto st0 + tr21: + // line 111 "zparse.rl" + { + mark = p + } + goto st132 + st132: + p++ + if p == pe { + goto _test_eof132 + } + fallthrough + case 132: + // line 2292 "zparse.go" + switch data[p] { + case 78: + goto st21 + case 110: + goto st21 + } + goto st0 + tr4: + // line 120 "zparse.rl" + { // ... + } + // line 111 "zparse.rl" + { + mark = p + } + goto st133 + st133: + p++ + if p == pe { + goto _test_eof133 + } + fallthrough + case 133: + // line 2309 "zparse.go" + switch data[p] { + case 69: + goto st15 + case 72: + goto st134 + case 78: + goto st24 + case 101: + goto st15 + case 104: + goto st134 + case 110: + goto st24 + } + goto st0 + st134: + p++ + if p == pe { + goto _test_eof134 + } + fallthrough + case 134: + switch data[p] { + case 9: + goto tr190 + case 32: + goto tr190 + } + goto st0 + tr190: + // line 119 "zparse.rl" + { + hdr.Class = str_class[data[mark:p]] + } + goto st135 + st135: + p++ + if p == pe { + goto _test_eof135 + } + fallthrough + case 135: + // line 2338 "zparse.go" + switch data[p] { + case 9: + goto st135 + case 32: + goto st135 + case 65: + goto st4 + case 67: + goto st23 + case 68: + goto st31 + case 77: + goto st55 + case 78: + goto st60 + case 80: + goto st89 + case 82: + goto st95 + case 83: + goto st103 + case 84: + goto st121 + case 97: + goto st4 + case 99: + goto st23 + case 100: + goto st31 + case 109: + goto st55 + case 110: + goto st60 + case 112: + goto st89 + case 114: + goto st95 + case 115: + goto st103 + case 116: + goto st121 + } + if 48 <= data[p] && data[p] <= 57 { + goto tr192 + } + goto st0 + tr192: + // line 111 "zparse.rl" + { + mark = p + } + goto st136 + st136: + p++ + if p == pe { + goto _test_eof136 + } + fallthrough + case 136: + // line 2372 "zparse.go" + switch data[p] { + case 9: + goto tr193 + case 32: + goto tr193 + } + if 48 <= data[p] && data[p] <= 57 { + goto st136 + } + goto st0 + tr6: + // line 120 "zparse.rl" + { // ... + } + // line 111 "zparse.rl" + { + mark = p + } + goto st137 + st137: + p++ + if p == pe { + goto _test_eof137 + } + fallthrough + case 137: + // line 2390 "zparse.go" + switch data[p] { + case 83: + goto st134 + case 115: + goto st134 + } + goto st0 + tr7: + // line 120 "zparse.rl" + { // ... + } + // line 111 "zparse.rl" + { + mark = p + } + goto st138 + st138: + p++ + if p == pe { + goto _test_eof138 + } + fallthrough + case 138: + // line 2407 "zparse.go" + switch data[p] { + case 78: + goto st134 + case 110: + goto st134 + } + goto st0 + tr199: + // line 111 "zparse.rl" + { + mark = p + } goto st139 - } - if data[p] < 48 { - if 45 <= data[p] && data[p] <= 46 { + st139: + p++ + if p == pe { + goto _test_eof139 + } + fallthrough + case 139: + // line 2422 "zparse.go" + switch data[p] { + case 9: + goto tr195 + case 32: + goto tr195 + case 42: + goto st139 + case 95: goto st139 } - } else if data[p] > 57 { - if data[p] > 90 { - if 97 <= data[p] && data[p] <= 122 { + if data[p] < 48 { + if 45 <= data[p] && data[p] <= 46 { goto st139 } - } else if data[p] >= 65 { + } else if data[p] > 57 { + if data[p] > 90 { + if 97 <= data[p] && data[p] <= 122 { + goto st139 + } + } else if data[p] >= 65 { + goto st139 + } + } else { goto st139 } - } else { - goto st139 + goto st0 + st140: + p++ + if p == pe { + goto _test_eof140 + } + fallthrough + case 140: + if data[p] == 10 { + goto tr198 + } + goto st140 } - goto st0 - st140: - p++ - if p == pe { - goto _test_eof140 + _test_eof141: + cs = 141 + goto _test_eof + _test_eof1: + cs = 1 + goto _test_eof + _test_eof2: + cs = 2 + goto _test_eof + _test_eof3: + cs = 3 + goto _test_eof + _test_eof4: + cs = 4 + goto _test_eof + _test_eof5: + cs = 5 + goto _test_eof + _test_eof6: + cs = 6 + goto _test_eof + _test_eof7: + cs = 7 + goto _test_eof + _test_eof8: + cs = 8 + goto _test_eof + _test_eof9: + cs = 9 + goto _test_eof + _test_eof10: + cs = 10 + goto _test_eof + _test_eof11: + cs = 11 + goto _test_eof + _test_eof12: + cs = 12 + goto _test_eof + _test_eof13: + cs = 13 + goto _test_eof + _test_eof14: + cs = 14 + goto _test_eof + _test_eof15: + cs = 15 + goto _test_eof + _test_eof16: + cs = 16 + goto _test_eof + _test_eof17: + cs = 17 + goto _test_eof + _test_eof18: + cs = 18 + goto _test_eof + _test_eof19: + cs = 19 + goto _test_eof + _test_eof20: + cs = 20 + goto _test_eof + _test_eof21: + cs = 21 + goto _test_eof + _test_eof22: + cs = 22 + goto _test_eof + _test_eof23: + cs = 23 + goto _test_eof + _test_eof24: + cs = 24 + goto _test_eof + _test_eof25: + cs = 25 + goto _test_eof + _test_eof26: + cs = 26 + goto _test_eof + _test_eof27: + cs = 27 + goto _test_eof + _test_eof28: + cs = 28 + goto _test_eof + _test_eof29: + cs = 29 + goto _test_eof + _test_eof30: + cs = 30 + goto _test_eof + _test_eof31: + cs = 31 + goto _test_eof + _test_eof32: + cs = 32 + goto _test_eof + _test_eof33: + cs = 33 + goto _test_eof + _test_eof34: + cs = 34 + goto _test_eof + _test_eof35: + cs = 35 + goto _test_eof + _test_eof36: + cs = 36 + goto _test_eof + _test_eof37: + cs = 37 + goto _test_eof + _test_eof38: + cs = 38 + goto _test_eof + _test_eof39: + cs = 39 + goto _test_eof + _test_eof40: + cs = 40 + goto _test_eof + _test_eof41: + cs = 41 + goto _test_eof + _test_eof42: + cs = 42 + goto _test_eof + _test_eof43: + cs = 43 + goto _test_eof + _test_eof44: + cs = 44 + goto _test_eof + _test_eof45: + cs = 45 + goto _test_eof + _test_eof46: + cs = 46 + goto _test_eof + _test_eof47: + cs = 47 + goto _test_eof + _test_eof48: + cs = 48 + goto _test_eof + _test_eof49: + cs = 49 + goto _test_eof + _test_eof50: + cs = 50 + goto _test_eof + _test_eof51: + cs = 51 + goto _test_eof + _test_eof52: + cs = 52 + goto _test_eof + _test_eof53: + cs = 53 + goto _test_eof + _test_eof54: + cs = 54 + goto _test_eof + _test_eof55: + cs = 55 + goto _test_eof + _test_eof56: + cs = 56 + goto _test_eof + _test_eof57: + cs = 57 + goto _test_eof + _test_eof58: + cs = 58 + goto _test_eof + _test_eof59: + cs = 59 + goto _test_eof + _test_eof60: + cs = 60 + goto _test_eof + _test_eof61: + cs = 61 + goto _test_eof + _test_eof62: + cs = 62 + goto _test_eof + _test_eof63: + cs = 63 + goto _test_eof + _test_eof64: + cs = 64 + goto _test_eof + _test_eof65: + cs = 65 + goto _test_eof + _test_eof66: + cs = 66 + goto _test_eof + _test_eof67: + cs = 67 + goto _test_eof + _test_eof68: + cs = 68 + goto _test_eof + _test_eof69: + cs = 69 + goto _test_eof + _test_eof70: + cs = 70 + goto _test_eof + _test_eof71: + cs = 71 + goto _test_eof + _test_eof72: + cs = 72 + goto _test_eof + _test_eof73: + cs = 73 + goto _test_eof + _test_eof74: + cs = 74 + goto _test_eof + _test_eof75: + cs = 75 + goto _test_eof + _test_eof76: + cs = 76 + goto _test_eof + _test_eof77: + cs = 77 + goto _test_eof + _test_eof78: + cs = 78 + goto _test_eof + _test_eof79: + cs = 79 + goto _test_eof + _test_eof80: + cs = 80 + goto _test_eof + _test_eof81: + cs = 81 + goto _test_eof + _test_eof82: + cs = 82 + goto _test_eof + _test_eof83: + cs = 83 + goto _test_eof + _test_eof84: + cs = 84 + goto _test_eof + _test_eof85: + cs = 85 + goto _test_eof + _test_eof86: + cs = 86 + goto _test_eof + _test_eof87: + cs = 87 + goto _test_eof + _test_eof88: + cs = 88 + goto _test_eof + _test_eof89: + cs = 89 + goto _test_eof + _test_eof90: + cs = 90 + goto _test_eof + _test_eof91: + cs = 91 + goto _test_eof + _test_eof92: + cs = 92 + goto _test_eof + _test_eof93: + cs = 93 + goto _test_eof + _test_eof94: + cs = 94 + goto _test_eof + _test_eof95: + cs = 95 + goto _test_eof + _test_eof96: + cs = 96 + goto _test_eof + _test_eof97: + cs = 97 + goto _test_eof + _test_eof98: + cs = 98 + goto _test_eof + _test_eof99: + cs = 99 + goto _test_eof + _test_eof100: + cs = 100 + goto _test_eof + _test_eof101: + cs = 101 + goto _test_eof + _test_eof102: + cs = 102 + goto _test_eof + _test_eof103: + cs = 103 + goto _test_eof + _test_eof104: + cs = 104 + goto _test_eof + _test_eof105: + cs = 105 + goto _test_eof + _test_eof106: + cs = 106 + goto _test_eof + _test_eof107: + cs = 107 + goto _test_eof + _test_eof108: + cs = 108 + goto _test_eof + _test_eof109: + cs = 109 + goto _test_eof + _test_eof110: + cs = 110 + goto _test_eof + _test_eof111: + cs = 111 + goto _test_eof + _test_eof112: + cs = 112 + goto _test_eof + _test_eof113: + cs = 113 + goto _test_eof + _test_eof114: + cs = 114 + goto _test_eof + _test_eof115: + cs = 115 + goto _test_eof + _test_eof116: + cs = 116 + goto _test_eof + _test_eof117: + cs = 117 + goto _test_eof + _test_eof118: + cs = 118 + goto _test_eof + _test_eof119: + cs = 119 + goto _test_eof + _test_eof120: + cs = 120 + goto _test_eof + _test_eof121: + cs = 121 + goto _test_eof + _test_eof122: + cs = 122 + goto _test_eof + _test_eof123: + cs = 123 + goto _test_eof + _test_eof124: + cs = 124 + goto _test_eof + _test_eof125: + cs = 125 + goto _test_eof + _test_eof126: + cs = 126 + goto _test_eof + _test_eof127: + cs = 127 + goto _test_eof + _test_eof128: + cs = 128 + goto _test_eof + _test_eof129: + cs = 129 + goto _test_eof + _test_eof130: + cs = 130 + goto _test_eof + _test_eof131: + cs = 131 + goto _test_eof + _test_eof132: + cs = 132 + goto _test_eof + _test_eof133: + cs = 133 + goto _test_eof + _test_eof134: + cs = 134 + goto _test_eof + _test_eof135: + cs = 135 + goto _test_eof + _test_eof136: + cs = 136 + goto _test_eof + _test_eof137: + cs = 137 + goto _test_eof + _test_eof138: + cs = 138 + goto _test_eof + _test_eof139: + cs = 139 + goto _test_eof + _test_eof140: + cs = 140 + goto _test_eof + + _test_eof: + { } - fallthrough - case 140: - if data[p] == 10 { - goto tr198 - } - goto st140 - } - _test_eof141: - cs = 141 - goto _test_eof - _test_eof1: - cs = 1 - goto _test_eof - _test_eof2: - cs = 2 - goto _test_eof - _test_eof3: - cs = 3 - goto _test_eof - _test_eof4: - cs = 4 - goto _test_eof - _test_eof5: - cs = 5 - goto _test_eof - _test_eof6: - cs = 6 - goto _test_eof - _test_eof7: - cs = 7 - goto _test_eof - _test_eof8: - cs = 8 - goto _test_eof - _test_eof9: - cs = 9 - goto _test_eof - _test_eof10: - cs = 10 - goto _test_eof - _test_eof11: - cs = 11 - goto _test_eof - _test_eof12: - cs = 12 - goto _test_eof - _test_eof13: - cs = 13 - goto _test_eof - _test_eof14: - cs = 14 - goto _test_eof - _test_eof15: - cs = 15 - goto _test_eof - _test_eof16: - cs = 16 - goto _test_eof - _test_eof17: - cs = 17 - goto _test_eof - _test_eof18: - cs = 18 - goto _test_eof - _test_eof19: - cs = 19 - goto _test_eof - _test_eof20: - cs = 20 - goto _test_eof - _test_eof21: - cs = 21 - goto _test_eof - _test_eof22: - cs = 22 - goto _test_eof - _test_eof23: - cs = 23 - goto _test_eof - _test_eof24: - cs = 24 - goto _test_eof - _test_eof25: - cs = 25 - goto _test_eof - _test_eof26: - cs = 26 - goto _test_eof - _test_eof27: - cs = 27 - goto _test_eof - _test_eof28: - cs = 28 - goto _test_eof - _test_eof29: - cs = 29 - goto _test_eof - _test_eof30: - cs = 30 - goto _test_eof - _test_eof31: - cs = 31 - goto _test_eof - _test_eof32: - cs = 32 - goto _test_eof - _test_eof33: - cs = 33 - goto _test_eof - _test_eof34: - cs = 34 - goto _test_eof - _test_eof35: - cs = 35 - goto _test_eof - _test_eof36: - cs = 36 - goto _test_eof - _test_eof37: - cs = 37 - goto _test_eof - _test_eof38: - cs = 38 - goto _test_eof - _test_eof39: - cs = 39 - goto _test_eof - _test_eof40: - cs = 40 - goto _test_eof - _test_eof41: - cs = 41 - goto _test_eof - _test_eof42: - cs = 42 - goto _test_eof - _test_eof43: - cs = 43 - goto _test_eof - _test_eof44: - cs = 44 - goto _test_eof - _test_eof45: - cs = 45 - goto _test_eof - _test_eof46: - cs = 46 - goto _test_eof - _test_eof47: - cs = 47 - goto _test_eof - _test_eof48: - cs = 48 - goto _test_eof - _test_eof49: - cs = 49 - goto _test_eof - _test_eof50: - cs = 50 - goto _test_eof - _test_eof51: - cs = 51 - goto _test_eof - _test_eof52: - cs = 52 - goto _test_eof - _test_eof53: - cs = 53 - goto _test_eof - _test_eof54: - cs = 54 - goto _test_eof - _test_eof55: - cs = 55 - goto _test_eof - _test_eof56: - cs = 56 - goto _test_eof - _test_eof57: - cs = 57 - goto _test_eof - _test_eof58: - cs = 58 - goto _test_eof - _test_eof59: - cs = 59 - goto _test_eof - _test_eof60: - cs = 60 - goto _test_eof - _test_eof61: - cs = 61 - goto _test_eof - _test_eof62: - cs = 62 - goto _test_eof - _test_eof63: - cs = 63 - goto _test_eof - _test_eof64: - cs = 64 - goto _test_eof - _test_eof65: - cs = 65 - goto _test_eof - _test_eof66: - cs = 66 - goto _test_eof - _test_eof67: - cs = 67 - goto _test_eof - _test_eof68: - cs = 68 - goto _test_eof - _test_eof69: - cs = 69 - goto _test_eof - _test_eof70: - cs = 70 - goto _test_eof - _test_eof71: - cs = 71 - goto _test_eof - _test_eof72: - cs = 72 - goto _test_eof - _test_eof73: - cs = 73 - goto _test_eof - _test_eof74: - cs = 74 - goto _test_eof - _test_eof75: - cs = 75 - goto _test_eof - _test_eof76: - cs = 76 - goto _test_eof - _test_eof77: - cs = 77 - goto _test_eof - _test_eof78: - cs = 78 - goto _test_eof - _test_eof79: - cs = 79 - goto _test_eof - _test_eof80: - cs = 80 - goto _test_eof - _test_eof81: - cs = 81 - goto _test_eof - _test_eof82: - cs = 82 - goto _test_eof - _test_eof83: - cs = 83 - goto _test_eof - _test_eof84: - cs = 84 - goto _test_eof - _test_eof85: - cs = 85 - goto _test_eof - _test_eof86: - cs = 86 - goto _test_eof - _test_eof87: - cs = 87 - goto _test_eof - _test_eof88: - cs = 88 - goto _test_eof - _test_eof89: - cs = 89 - goto _test_eof - _test_eof90: - cs = 90 - goto _test_eof - _test_eof91: - cs = 91 - goto _test_eof - _test_eof92: - cs = 92 - goto _test_eof - _test_eof93: - cs = 93 - goto _test_eof - _test_eof94: - cs = 94 - goto _test_eof - _test_eof95: - cs = 95 - goto _test_eof - _test_eof96: - cs = 96 - goto _test_eof - _test_eof97: - cs = 97 - goto _test_eof - _test_eof98: - cs = 98 - goto _test_eof - _test_eof99: - cs = 99 - goto _test_eof - _test_eof100: - cs = 100 - goto _test_eof - _test_eof101: - cs = 101 - goto _test_eof - _test_eof102: - cs = 102 - goto _test_eof - _test_eof103: - cs = 103 - goto _test_eof - _test_eof104: - cs = 104 - goto _test_eof - _test_eof105: - cs = 105 - goto _test_eof - _test_eof106: - cs = 106 - goto _test_eof - _test_eof107: - cs = 107 - goto _test_eof - _test_eof108: - cs = 108 - goto _test_eof - _test_eof109: - cs = 109 - goto _test_eof - _test_eof110: - cs = 110 - goto _test_eof - _test_eof111: - cs = 111 - goto _test_eof - _test_eof112: - cs = 112 - goto _test_eof - _test_eof113: - cs = 113 - goto _test_eof - _test_eof114: - cs = 114 - goto _test_eof - _test_eof115: - cs = 115 - goto _test_eof - _test_eof116: - cs = 116 - goto _test_eof - _test_eof117: - cs = 117 - goto _test_eof - _test_eof118: - cs = 118 - goto _test_eof - _test_eof119: - cs = 119 - goto _test_eof - _test_eof120: - cs = 120 - goto _test_eof - _test_eof121: - cs = 121 - goto _test_eof - _test_eof122: - cs = 122 - goto _test_eof - _test_eof123: - cs = 123 - goto _test_eof - _test_eof124: - cs = 124 - goto _test_eof - _test_eof125: - cs = 125 - goto _test_eof - _test_eof126: - cs = 126 - goto _test_eof - _test_eof127: - cs = 127 - goto _test_eof - _test_eof128: - cs = 128 - goto _test_eof - _test_eof129: - cs = 129 - goto _test_eof - _test_eof130: - cs = 130 - goto _test_eof - _test_eof131: - cs = 131 - goto _test_eof - _test_eof132: - cs = 132 - goto _test_eof - _test_eof133: - cs = 133 - goto _test_eof - _test_eof134: - cs = 134 - goto _test_eof - _test_eof135: - cs = 135 - goto _test_eof - _test_eof136: - cs = 136 - goto _test_eof - _test_eof137: - cs = 137 - goto _test_eof - _test_eof138: - cs = 138 - goto _test_eof - _test_eof139: - cs = 139 - goto _test_eof - _test_eof140: - cs = 140 - goto _test_eof - - _test_eof: - { - } - _out: - { - } - } - - // line 178 "zparse.rl" - - - if eof > -1 { - if cs < z_first_final { - // No clue what I'm doing what so ever - if p == pe { - println("p", p, "pe", pe) - println("cs", cs, "z_first_final", z_first_final) - println("unexpected eof at line ", l) - return nil - } else { - println("error at position ", p, "\"", data[mark:p], "\" at line ", l) - return nil + _out: + { } } - } - */ + + // line 178 "zparse.rl" + + + if eof > -1 { + if cs < z_first_final { + // No clue what I'm doing what so ever + if p == pe { + println("p", p, "pe", pe) + println("cs", cs, "z_first_final", z_first_final) + println("unexpected eof at line ", l) + return nil + } else { + println("error at position ", p, "\"", data[mark:p], "\" at line ", l) + return nil + } + } + } + */ return nil }