diff --git a/sip/addr.go b/sip/addr.go index c1e2565..43a44f0 100755 --- a/sip/addr.go +++ b/sip/addr.go @@ -2,16 +2,16 @@ // // For example: // -// "J.A. Roberts Tunney" ;tag=deadbeef +// "Justine Tunney" ;tag=feedabee // // Roughly equates to: // -// {Display: "J.A. Roberts Tunney", -// Params: {"tag": "deadbeef"}, +// {Display: "Justine Tunney", +// Params: {"tag": "feedabee"}, // Uri: {Scheme: "sip", -// User: "jtunney", +// User: "jart", // Pass: "", -// Host: "bsdtelecom.net", +// Host: "example.test", // Port: "", // Params: {"isup-oli": "29"}}} // @@ -31,7 +31,21 @@ type Addr struct { Next *Addr // for comma separated lists of addresses } -//go:generate ragel -Z -G2 -o addr_parse.go addr_parse.rl +func ParseAddr(s string) (addr *Addr, err error) { + return ParseAddrBytes([]byte(s)) +} + +func ParseAddrBytes(s []byte) (addr *Addr, err error) { + var b bytes.Buffer + b.WriteString("SIP/2.0 900 ParseAddr()\r\nContact:") + b.Write(s) + b.WriteString("\r\n\r\n") + msg, err := ParseMsgBytes(b.Bytes()) + if err != nil { + return nil, err + } + return msg.Contact, nil +} func (addr *Addr) String() string { if addr == nil { diff --git a/sip/addr_parse.go b/sip/addr_parse.go deleted file mode 100644 index 67904d8..0000000 --- a/sip/addr_parse.go +++ /dev/null @@ -1,2779 +0,0 @@ - -//line addr_parse.rl:1 -// -*-go-*- - -package sip - -import ( - "errors" - "fmt" - "strings" -) - - -//line addr_parse.rl:12 - -//line addr_parse.go:17 -const addr_start int = 1 -const addr_first_final int = 68 -const addr_error int = 0 - -const addr_en_params int = 69 -const addr_en_name_addr int = 35 -const addr_en_bare_addr int = 65 -const addr_en_addr int = 1 - - -//line addr_parse.rl:13 - -// ParseAddr turns a SIP address into a data structure. -func ParseAddr(s string) (addr *Addr, err error) { - if s == "" { - return nil, errors.New("Empty SIP message") - } - return ParseAddrBytes([]byte(s), nil) -} - -// ParseAddr turns a SIP address slice into a data structure. -func ParseAddrBytes(data []byte, next *Addr) (addr *Addr, err error) { - if data == nil { - return nil, nil - } - addr = new(Addr) - result := addr - cs := 0 - p := 0 - pe := len(data) - eof := len(data) - buf := make([]byte, len(data)) - amt := 0 - mark := 0 - var name string - - -//line addr_parse.go:55 - { - cs = addr_start - } - -//line addr_parse.go:60 - { - var _widec int16 - if p == pe { - goto _test_eof - } - switch cs { - case 1: - goto st_case_1 - case 68: - goto st_case_68 - case 35: - goto st_case_35 - case 0: - goto st_case_0 - case 36: - goto st_case_36 - case 37: - goto st_case_37 - case 38: - goto st_case_38 - case 39: - goto st_case_39 - case 40: - goto st_case_40 - case 41: - goto st_case_41 - case 74: - goto st_case_74 - case 75: - goto st_case_75 - case 42: - goto st_case_42 - case 43: - goto st_case_43 - case 76: - goto st_case_76 - case 44: - goto st_case_44 - case 45: - goto st_case_45 - case 46: - goto st_case_46 - case 47: - goto st_case_47 - case 48: - goto st_case_48 - case 49: - goto st_case_49 - case 50: - goto st_case_50 - case 51: - goto st_case_51 - case 52: - goto st_case_52 - case 53: - goto st_case_53 - case 54: - goto st_case_54 - case 55: - goto st_case_55 - case 56: - goto st_case_56 - case 57: - goto st_case_57 - case 58: - goto st_case_58 - case 59: - goto st_case_59 - case 60: - goto st_case_60 - case 61: - goto st_case_61 - case 62: - goto st_case_62 - case 63: - goto st_case_63 - case 64: - goto st_case_64 - case 65: - goto st_case_65 - case 66: - goto st_case_66 - case 67: - goto st_case_67 - case 77: - goto st_case_77 - case 78: - goto st_case_78 - case 69: - goto st_case_69 - case 2: - goto st_case_2 - case 3: - goto st_case_3 - case 70: - goto st_case_70 - case 4: - goto st_case_4 - case 5: - goto st_case_5 - case 6: - goto st_case_6 - case 7: - goto st_case_7 - case 71: - goto st_case_71 - case 8: - goto st_case_8 - case 9: - goto st_case_9 - case 72: - goto st_case_72 - case 10: - goto st_case_10 - case 11: - goto st_case_11 - case 12: - goto st_case_12 - case 13: - goto st_case_13 - case 14: - goto st_case_14 - case 73: - goto st_case_73 - case 15: - goto st_case_15 - case 16: - goto st_case_16 - case 17: - goto st_case_17 - case 18: - goto st_case_18 - case 19: - goto st_case_19 - case 20: - goto st_case_20 - case 21: - goto st_case_21 - case 22: - goto st_case_22 - case 23: - goto st_case_23 - case 24: - goto st_case_24 - case 25: - goto st_case_25 - case 26: - goto st_case_26 - case 27: - goto st_case_27 - case 28: - goto st_case_28 - case 29: - goto st_case_29 - case 30: - goto st_case_30 - case 31: - goto st_case_31 - case 32: - goto st_case_32 - case 33: - goto st_case_33 - case 34: - goto st_case_34 - } - goto st_out - st1: - if p++; p == pe { - goto _test_eof1 - } - st_case_1: - switch data[p] { - case 59: - goto tr1 - case 60: - goto tr2 - } - goto tr0 -tr109: -//line addr_parse.rl:79 - - p = mark - p-- - - {goto st35 } - - goto st68 -tr0: -//line addr_parse.rl:39 - - mark = p - - goto st68 -tr1: -//line addr_parse.rl:39 - - mark = p - -//line addr_parse.rl:85 - - p = mark - p-- - - {goto st65 } - - goto st68 -tr2: -//line addr_parse.rl:39 - - mark = p - -//line addr_parse.rl:79 - - p = mark - p-- - - {goto st35 } - - goto st68 -tr108: -//line addr_parse.rl:85 - - p = mark - p-- - - {goto st65 } - - goto st68 - st68: - if p++; p == pe { - goto _test_eof68 - } - st_case_68: -//line addr_parse.go:294 - switch data[p] { - case 59: - goto tr108 - case 60: - goto tr109 - } - goto st68 -tr50: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st35 - st35: - if p++; p == pe { - goto _test_eof35 - } - st_case_35: -//line addr_parse.go:318 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr50 - case 32: - goto tr50 - case 33: - goto tr51 - case 34: - goto st50 - case 37: - goto tr51 - case 39: - goto tr51 - case 60: - goto tr53 - case 126: - goto tr51 - case 525: - goto tr54 - } - switch { - case _widec < 48: - switch { - case _widec > 43: - if 45 <= _widec && _widec <= 46 { - goto tr51 - } - case _widec >= 42: - goto tr51 - } - case _widec > 57: - switch { - case _widec > 90: - if 95 <= _widec && _widec <= 122 { - goto tr51 - } - case _widec >= 65: - goto tr51 - } - default: - goto tr51 - } - goto st0 -st_case_0: - st0: - cs = 0 - goto _out -tr56: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st36 -tr51: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st36 - st36: - if p++; p == pe { - goto _test_eof36 - } - st_case_36: -//line addr_parse.go:396 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr55 - case 32: - goto tr55 - case 33: - goto tr56 - case 37: - goto tr56 - case 39: - goto tr56 - case 126: - goto tr56 - case 525: - goto tr57 - } - switch { - case _widec < 48: - switch { - case _widec > 43: - if 45 <= _widec && _widec <= 46 { - goto tr56 - } - case _widec >= 42: - goto tr56 - } - case _widec > 57: - switch { - case _widec > 90: - if 95 <= _widec && _widec <= 122 { - goto tr56 - } - case _widec >= 65: - goto tr56 - } - default: - goto tr56 - } - goto st0 -tr55: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st37 -tr58: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st37 - st37: - if p++; p == pe { - goto _test_eof37 - } - st_case_37: -//line addr_parse.go:467 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr58 - case 32: - goto tr58 - case 33: - goto tr56 - case 37: - goto tr56 - case 39: - goto tr56 - case 60: - goto tr59 - case 126: - goto tr56 - case 525: - goto tr60 - } - switch { - case _widec < 48: - switch { - case _widec > 43: - if 45 <= _widec && _widec <= 46 { - goto tr56 - } - case _widec >= 42: - goto tr56 - } - case _widec > 57: - switch { - case _widec > 90: - if 95 <= _widec && _widec <= 122 { - goto tr56 - } - case _widec >= 65: - goto tr56 - } - default: - goto tr56 - } - goto st0 -tr53: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st38 -tr59: -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st38 -tr94: -//line addr_parse.rl:61 - - addr.Display = string(buf[0:amt]) - - goto st38 - st38: - if p++; p == pe { - goto _test_eof38 - } - st_case_38: -//line addr_parse.go:545 - switch { - case data[p] > 90: - if 97 <= data[p] && data[p] <= 122 { - goto tr61 - } - case data[p] >= 65: - goto tr61 - } - goto st0 -tr61: -//line addr_parse.rl:39 - - mark = p - - goto st39 - st39: - if p++; p == pe { - goto _test_eof39 - } - st_case_39: -//line addr_parse.go:566 - switch data[p] { - case 43: - goto st39 - case 58: - goto st40 - } - switch { - case data[p] < 48: - if 45 <= data[p] && data[p] <= 46 { - goto st39 - } - case data[p] > 57: - switch { - case data[p] > 90: - if 97 <= data[p] && data[p] <= 122 { - goto st39 - } - case data[p] >= 65: - goto st39 - } - default: - goto st39 - } - goto st0 - st40: - if p++; p == pe { - goto _test_eof40 - } - st_case_40: - switch data[p] { - case 33: - goto st41 - case 61: - goto st41 - case 93: - goto st41 - case 95: - goto st41 - case 126: - goto st41 - } - switch { - case data[p] < 63: - if 36 <= data[p] && data[p] <= 59 { - goto st41 - } - case data[p] > 91: - if 97 <= data[p] && data[p] <= 122 { - goto st41 - } - default: - goto st41 - } - goto st0 - st41: - if p++; p == pe { - goto _test_eof41 - } - st_case_41: - switch data[p] { - case 33: - goto st41 - case 62: - goto tr65 - case 93: - goto st41 - case 95: - goto st41 - case 126: - goto st41 - } - switch { - case data[p] < 61: - if 36 <= data[p] && data[p] <= 59 { - goto st41 - } - case data[p] > 91: - if 97 <= data[p] && data[p] <= 122 { - goto st41 - } - default: - goto st41 - } - goto st0 -tr65: -//line addr_parse.rl:65 - - addr.Uri, err = ParseURIBytes(data[mark:p]) - if err != nil { return nil, err } - - goto st74 - st74: - if p++; p == pe { - goto _test_eof74 - } - st_case_74: -//line addr_parse.go:663 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto st74 - case 32: - goto st74 - case 269: - goto tr120 - case 525: - goto st42 - } - switch { - case _widec > 12: - if 14 <= _widec { - goto tr120 - } - default: - goto tr120 - } - goto st0 -tr120: -//line addr_parse.rl:91 - - p-- - - {goto st69 } - - goto st75 - st75: - if p++; p == pe { - goto _test_eof75 - } - st_case_75: -//line addr_parse.go:703 - goto st0 - st42: - if p++; p == pe { - goto _test_eof42 - } - st_case_42: - if data[p] == 10 { - goto st43 - } - goto st0 - st43: - if p++; p == pe { - goto _test_eof43 - } - st_case_43: - switch data[p] { - case 9: - goto st76 - case 32: - goto st76 - } - goto st0 - st76: - if p++; p == pe { - goto _test_eof76 - } - st_case_76: - switch data[p] { - case 9: - goto st76 - case 32: - goto st76 - } - goto tr120 -tr57: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st44 -tr60: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st44 - st44: - if p++; p == pe { - goto _test_eof44 - } - st_case_44: -//line addr_parse.go:762 - if data[p] == 10 { - goto tr68 - } - goto st0 -tr68: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st45 - st45: - if p++; p == pe { - goto _test_eof45 - } - st_case_45: -//line addr_parse.go:779 - switch data[p] { - case 9: - goto tr69 - case 32: - goto tr69 - } - goto st0 -tr69: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st46 -tr70: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st46 - st46: - if p++; p == pe { - goto _test_eof46 - } - st_case_46: -//line addr_parse.go:811 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr70 - case 32: - goto tr70 - case 33: - goto tr56 - case 37: - goto tr56 - case 39: - goto tr56 - case 60: - goto tr59 - case 126: - goto tr56 - case 525: - goto tr71 - } - switch { - case _widec < 48: - switch { - case _widec > 43: - if 45 <= _widec && _widec <= 46 { - goto tr56 - } - case _widec >= 42: - goto tr56 - } - case _widec > 57: - switch { - case _widec > 90: - if 95 <= _widec && _widec <= 122 { - goto tr56 - } - case _widec >= 65: - goto tr56 - } - default: - goto tr56 - } - goto st0 -tr102: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st47 -tr71: -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st47 -tr95: -//line addr_parse.rl:61 - - addr.Display = string(buf[0:amt]) - - goto st47 - st47: - if p++; p == pe { - goto _test_eof47 - } - st_case_47: -//line addr_parse.go:889 - if data[p] == 10 { - goto st48 - } - goto st0 - st48: - if p++; p == pe { - goto _test_eof48 - } - st_case_48: - switch data[p] { - case 9: - goto st49 - case 32: - goto st49 - } - goto st0 - st49: - if p++; p == pe { - goto _test_eof49 - } - st_case_49: - switch data[p] { - case 9: - goto st49 - case 32: - goto st49 - case 60: - goto st38 - } - goto st0 - st50: - if p++; p == pe { - goto _test_eof50 - } - st_case_50: - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr75 - case 34: - goto tr76 - case 92: - goto tr77 - case 525: - goto tr83 - } - switch { - case _widec < 224: - switch { - case _widec > 126: - if 192 <= _widec && _widec <= 223 { - goto tr78 - } - case _widec >= 32: - goto tr75 - } - case _widec > 239: - switch { - case _widec < 248: - if 240 <= _widec && _widec <= 247 { - goto tr80 - } - case _widec > 251: - if 252 <= _widec && _widec <= 253 { - goto tr82 - } - default: - goto tr81 - } - default: - goto tr79 - } - goto st0 -tr84: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st51 -tr75: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st51 - st51: - if p++; p == pe { - goto _test_eof51 - } - st_case_51: -//line addr_parse.go:992 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr84 - case 34: - goto st52 - case 92: - goto st54 - case 525: - goto tr92 - } - switch { - case _widec < 224: - switch { - case _widec > 126: - if 192 <= _widec && _widec <= 223 { - goto tr87 - } - case _widec >= 32: - goto tr84 - } - case _widec > 239: - switch { - case _widec < 248: - if 240 <= _widec && _widec <= 247 { - goto tr89 - } - case _widec > 251: - if 252 <= _widec && _widec <= 253 { - goto tr91 - } - default: - goto tr90 - } - default: - goto tr88 - } - goto st0 -tr76: -//line addr_parse.rl:43 - - amt = 0 - - goto st52 - st52: - if p++; p == pe { - goto _test_eof52 - } - st_case_52: -//line addr_parse.go:1048 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr93 - case 32: - goto tr93 - case 60: - goto tr94 - case 525: - goto tr95 - } - goto st0 -tr93: -//line addr_parse.rl:61 - - addr.Display = string(buf[0:amt]) - - goto st53 - st53: - if p++; p == pe { - goto _test_eof53 - } - st_case_53: -//line addr_parse.go:1078 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto st53 - case 32: - goto st53 - case 60: - goto st38 - case 525: - goto st47 - } - goto st0 -tr77: -//line addr_parse.rl:43 - - amt = 0 - - goto st54 - st54: - if p++; p == pe { - goto _test_eof54 - } - st_case_54: -//line addr_parse.go:1108 - switch { - case data[p] < 11: - if data[p] <= 9 { - goto tr84 - } - case data[p] > 12: - if 14 <= data[p] && data[p] <= 127 { - goto tr84 - } - default: - goto tr84 - } - goto st0 -tr87: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st55 -tr78: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st55 - st55: - if p++; p == pe { - goto _test_eof55 - } - st_case_55: -//line addr_parse.go:1145 - if 128 <= data[p] && data[p] <= 191 { - goto tr84 - } - goto st0 -tr88: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st56 -tr79: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st56 - st56: - if p++; p == pe { - goto _test_eof56 - } - st_case_56: -//line addr_parse.go:1173 - if 128 <= data[p] && data[p] <= 191 { - goto tr87 - } - goto st0 -tr89: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st57 -tr80: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st57 - st57: - if p++; p == pe { - goto _test_eof57 - } - st_case_57: -//line addr_parse.go:1201 - if 128 <= data[p] && data[p] <= 191 { - goto tr88 - } - goto st0 -tr90: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st58 -tr81: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st58 - st58: - if p++; p == pe { - goto _test_eof58 - } - st_case_58: -//line addr_parse.go:1229 - if 128 <= data[p] && data[p] <= 191 { - goto tr89 - } - goto st0 -tr91: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st59 -tr82: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st59 - st59: - if p++; p == pe { - goto _test_eof59 - } - st_case_59: -//line addr_parse.go:1257 - if 128 <= data[p] && data[p] <= 191 { - goto tr90 - } - goto st0 -tr92: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st60 -tr83: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st60 - st60: - if p++; p == pe { - goto _test_eof60 - } - st_case_60: -//line addr_parse.go:1285 - if data[p] == 10 { - goto tr98 - } - goto st0 -tr98: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st61 - st61: - if p++; p == pe { - goto _test_eof61 - } - st_case_61: -//line addr_parse.go:1302 - switch data[p] { - case 9: - goto tr84 - case 32: - goto tr84 - } - goto st0 -tr54: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st62 - st62: - if p++; p == pe { - goto _test_eof62 - } - st_case_62: -//line addr_parse.go:1326 - if data[p] == 10 { - goto st63 - } - goto st0 - st63: - if p++; p == pe { - goto _test_eof63 - } - st_case_63: - switch data[p] { - case 9: - goto st64 - case 32: - goto st64 - } - goto st0 -tr101: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:56 - - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - - goto st64 - st64: - if p++; p == pe { - goto _test_eof64 - } - st_case_64: -//line addr_parse.go:1359 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr101 - case 32: - goto tr101 - case 33: - goto tr51 - case 34: - goto st50 - case 37: - goto tr51 - case 39: - goto tr51 - case 60: - goto tr53 - case 126: - goto tr51 - case 525: - goto tr102 - } - switch { - case _widec < 48: - switch { - case _widec > 43: - if 45 <= _widec && _widec <= 46 { - goto tr51 - } - case _widec >= 42: - goto tr51 - } - case _widec > 57: - switch { - case _widec > 90: - if 95 <= _widec && _widec <= 122 { - goto tr51 - } - case _widec >= 65: - goto tr51 - } - default: - goto tr51 - } - goto st0 - st65: - if p++; p == pe { - goto _test_eof65 - } - st_case_65: - switch { - case data[p] > 90: - if 97 <= data[p] && data[p] <= 122 { - goto tr103 - } - case data[p] >= 65: - goto tr103 - } - goto st0 -tr103: -//line addr_parse.rl:39 - - mark = p - - goto st66 - st66: - if p++; p == pe { - goto _test_eof66 - } - st_case_66: -//line addr_parse.go:1435 - switch data[p] { - case 43: - goto st66 - case 58: - goto st67 - } - switch { - case data[p] < 48: - if 45 <= data[p] && data[p] <= 46 { - goto st66 - } - case data[p] > 57: - switch { - case data[p] > 90: - if 97 <= data[p] && data[p] <= 122 { - goto st66 - } - case data[p] >= 65: - goto st66 - } - default: - goto st66 - } - goto st0 - st67: - if p++; p == pe { - goto _test_eof67 - } - st_case_67: - switch data[p] { - case 33: - goto st77 - case 61: - goto st77 - case 93: - goto st77 - case 95: - goto st77 - case 126: - goto st77 - } - switch { - case data[p] < 63: - if 36 <= data[p] && data[p] <= 58 { - goto st77 - } - case data[p] > 91: - if 97 <= data[p] && data[p] <= 122 { - goto st77 - } - default: - goto st77 - } - goto st0 - st77: - if p++; p == pe { - goto _test_eof77 - } - st_case_77: - switch data[p] { - case 33: - goto st77 - case 61: - goto st77 - case 93: - goto st77 - case 95: - goto st77 - case 126: - goto st77 - } - switch { - case data[p] < 63: - if 36 <= data[p] && data[p] <= 58 { - goto st77 - } - case data[p] > 91: - if 97 <= data[p] && data[p] <= 122 { - goto st77 - } - default: - goto st77 - } - goto tr123 -tr123: -//line addr_parse.rl:65 - - addr.Uri, err = ParseURIBytes(data[mark:p]) - if err != nil { return nil, err } - -//line addr_parse.rl:91 - - p-- - - {goto st69 } - - goto st78 - st78: - if p++; p == pe { - goto _test_eof78 - } - st_case_78: -//line addr_parse.go:1538 - goto st0 - st69: - if p++; p == pe { - goto _test_eof69 - } - st_case_69: - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto st2 - case 32: - goto st2 - case 44: - goto st3 - case 59: - goto st7 - case 525: - goto st10 - } - goto st0 -tr116: -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - - goto st2 - st2: - if p++; p == pe { - goto _test_eof2 - } - st_case_2: -//line addr_parse.go:1579 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto st2 - case 32: - goto st2 - case 44: - goto st3 - case 59: - goto st7 - case 525: - goto st10 - } - goto st0 -tr112: -//line addr_parse.rl:52 - - name = string(data[mark:p]) - -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - - goto st3 -tr117: -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - - goto st3 - st3: - if p++; p == pe { - goto _test_eof3 - } - st_case_3: -//line addr_parse.go:1627 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto st3 - case 32: - goto st3 - case 269: - goto tr8 - case 525: - goto st4 - } - switch { - case _widec > 12: - if 14 <= _widec { - goto tr8 - } - default: - goto tr8 - } - goto st0 -tr8: -//line addr_parse.rl:96 - - addr.Next = new(Addr) - addr = addr.Next - p-- - - {goto st1 } - - goto st70 - st70: - if p++; p == pe { - goto _test_eof70 - } - st_case_70: -//line addr_parse.go:1669 - goto st0 - st4: - if p++; p == pe { - goto _test_eof4 - } - st_case_4: - if data[p] == 10 { - goto st5 - } - goto st0 - st5: - if p++; p == pe { - goto _test_eof5 - } - st_case_5: - switch data[p] { - case 9: - goto st6 - case 32: - goto st6 - } - goto st0 - st6: - if p++; p == pe { - goto _test_eof6 - } - st_case_6: - switch data[p] { - case 9: - goto st6 - case 32: - goto st6 - } - goto tr8 -tr113: -//line addr_parse.rl:52 - - name = string(data[mark:p]) - -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - - goto st7 -tr118: -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - - goto st7 - st7: - if p++; p == pe { - goto _test_eof7 - } - st_case_7: -//line addr_parse.go:1731 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto st7 - case 32: - goto st7 - case 33: - goto tr12 - case 37: - goto tr12 - case 39: - goto tr12 - case 126: - goto tr12 - case 525: - goto st32 - } - switch { - case _widec < 48: - switch { - case _widec > 43: - if 45 <= _widec && _widec <= 46 { - goto tr12 - } - case _widec >= 42: - goto tr12 - } - case _widec > 57: - switch { - case _widec > 90: - if 95 <= _widec && _widec <= 122 { - goto tr12 - } - case _widec >= 65: - goto tr12 - } - default: - goto tr12 - } - goto st0 -tr12: -//line addr_parse.rl:39 - - mark = p - -//line addr_parse.rl:43 - - amt = 0 - - goto st71 - st71: - if p++; p == pe { - goto _test_eof71 - } - st_case_71: -//line addr_parse.go:1793 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr110 - case 32: - goto tr110 - case 33: - goto st71 - case 37: - goto st71 - case 39: - goto st71 - case 44: - goto tr112 - case 59: - goto tr113 - case 61: - goto tr114 - case 126: - goto st71 - case 525: - goto tr115 - } - switch { - case _widec < 48: - if 42 <= _widec && _widec <= 46 { - goto st71 - } - case _widec > 57: - switch { - case _widec > 90: - if 95 <= _widec && _widec <= 122 { - goto st71 - } - case _widec >= 65: - goto st71 - } - default: - goto st71 - } - goto st0 -tr110: -//line addr_parse.rl:52 - - name = string(data[mark:p]) - -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - - goto st8 - st8: - if p++; p == pe { - goto _test_eof8 - } - st_case_8: -//line addr_parse.go:1859 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto st8 - case 32: - goto st8 - case 44: - goto st3 - case 59: - goto st7 - case 61: - goto st9 - case 525: - goto st29 - } - goto st0 -tr114: -//line addr_parse.rl:52 - - name = string(data[mark:p]) - - goto st9 - st9: - if p++; p == pe { - goto _test_eof9 - } - st_case_9: -//line addr_parse.go:1893 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto st9 - case 32: - goto st9 - case 33: - goto tr17 - case 34: - goto st13 - case 37: - goto tr17 - case 39: - goto tr17 - case 93: - goto tr17 - case 126: - goto tr17 - case 525: - goto st23 - } - switch { - case _widec < 48: - switch { - case _widec > 43: - if 45 <= _widec && _widec <= 46 { - goto tr17 - } - case _widec >= 42: - goto tr17 - } - case _widec > 58: - switch { - case _widec > 91: - if 95 <= _widec && _widec <= 122 { - goto tr17 - } - case _widec >= 65: - goto tr17 - } - default: - goto tr17 - } - goto st0 -tr17: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st72 - st72: - if p++; p == pe { - goto _test_eof72 - } - st_case_72: -//line addr_parse.go:1956 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr116 - case 32: - goto tr116 - case 33: - goto tr17 - case 37: - goto tr17 - case 39: - goto tr17 - case 44: - goto tr117 - case 59: - goto tr118 - case 93: - goto tr17 - case 126: - goto tr17 - case 525: - goto tr119 - } - switch { - case _widec < 48: - if 42 <= _widec && _widec <= 46 { - goto tr17 - } - case _widec > 58: - switch { - case _widec > 91: - if 95 <= _widec && _widec <= 122 { - goto tr17 - } - case _widec >= 65: - goto tr17 - } - default: - goto tr17 - } - goto st0 -tr119: -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - - goto st10 - st10: - if p++; p == pe { - goto _test_eof10 - } - st_case_10: -//line addr_parse.go:2018 - if data[p] == 10 { - goto st11 - } - goto st0 - st11: - if p++; p == pe { - goto _test_eof11 - } - st_case_11: - switch data[p] { - case 9: - goto st12 - case 32: - goto st12 - } - goto st0 - st12: - if p++; p == pe { - goto _test_eof12 - } - st_case_12: - switch data[p] { - case 9: - goto st12 - case 32: - goto st12 - case 44: - goto st3 - case 59: - goto st7 - } - goto st0 - st13: - if p++; p == pe { - goto _test_eof13 - } - st_case_13: - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr22 - case 34: - goto tr23 - case 92: - goto tr24 - case 525: - goto tr30 - } - switch { - case _widec < 224: - switch { - case _widec > 126: - if 192 <= _widec && _widec <= 223 { - goto tr25 - } - case _widec >= 32: - goto tr22 - } - case _widec > 239: - switch { - case _widec < 248: - if 240 <= _widec && _widec <= 247 { - goto tr27 - } - case _widec > 251: - if 252 <= _widec && _widec <= 253 { - goto tr29 - } - default: - goto tr28 - } - default: - goto tr26 - } - goto st0 -tr31: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st14 -tr22: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st14 - st14: - if p++; p == pe { - goto _test_eof14 - } - st_case_14: -//line addr_parse.go:2123 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr31 - case 34: - goto st73 - case 92: - goto st15 - case 525: - goto tr39 - } - switch { - case _widec < 224: - switch { - case _widec > 126: - if 192 <= _widec && _widec <= 223 { - goto tr34 - } - case _widec >= 32: - goto tr31 - } - case _widec > 239: - switch { - case _widec < 248: - if 240 <= _widec && _widec <= 247 { - goto tr36 - } - case _widec > 251: - if 252 <= _widec && _widec <= 253 { - goto tr38 - } - default: - goto tr37 - } - default: - goto tr35 - } - goto st0 -tr23: -//line addr_parse.rl:43 - - amt = 0 - - goto st73 - st73: - if p++; p == pe { - goto _test_eof73 - } - st_case_73: -//line addr_parse.go:2179 - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto tr116 - case 32: - goto tr116 - case 44: - goto tr117 - case 59: - goto tr118 - case 525: - goto tr119 - } - goto st0 -tr24: -//line addr_parse.rl:43 - - amt = 0 - - goto st15 - st15: - if p++; p == pe { - goto _test_eof15 - } - st_case_15: -//line addr_parse.go:2211 - switch { - case data[p] < 11: - if data[p] <= 9 { - goto tr31 - } - case data[p] > 12: - if 14 <= data[p] && data[p] <= 127 { - goto tr31 - } - default: - goto tr31 - } - goto st0 -tr34: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st16 -tr25: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st16 - st16: - if p++; p == pe { - goto _test_eof16 - } - st_case_16: -//line addr_parse.go:2248 - if 128 <= data[p] && data[p] <= 191 { - goto tr31 - } - goto st0 -tr35: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st17 -tr26: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st17 - st17: - if p++; p == pe { - goto _test_eof17 - } - st_case_17: -//line addr_parse.go:2276 - if 128 <= data[p] && data[p] <= 191 { - goto tr34 - } - goto st0 -tr36: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st18 -tr27: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st18 - st18: - if p++; p == pe { - goto _test_eof18 - } - st_case_18: -//line addr_parse.go:2304 - if 128 <= data[p] && data[p] <= 191 { - goto tr35 - } - goto st0 -tr37: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st19 -tr28: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st19 - st19: - if p++; p == pe { - goto _test_eof19 - } - st_case_19: -//line addr_parse.go:2332 - if 128 <= data[p] && data[p] <= 191 { - goto tr36 - } - goto st0 -tr38: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st20 -tr29: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st20 - st20: - if p++; p == pe { - goto _test_eof20 - } - st_case_20: -//line addr_parse.go:2360 - if 128 <= data[p] && data[p] <= 191 { - goto tr37 - } - goto st0 -tr39: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st21 -tr30: -//line addr_parse.rl:43 - - amt = 0 - -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st21 - st21: - if p++; p == pe { - goto _test_eof21 - } - st_case_21: -//line addr_parse.go:2388 - if data[p] == 10 { - goto tr40 - } - goto st0 -tr40: -//line addr_parse.rl:47 - - buf[amt] = data[p] - amt++ - - goto st22 - st22: - if p++; p == pe { - goto _test_eof22 - } - st_case_22: -//line addr_parse.go:2405 - switch data[p] { - case 9: - goto tr31 - case 32: - goto tr31 - } - goto st0 - st23: - if p++; p == pe { - goto _test_eof23 - } - st_case_23: - if data[p] == 10 { - goto st24 - } - goto st0 - st24: - if p++; p == pe { - goto _test_eof24 - } - st_case_24: - switch data[p] { - case 9: - goto st25 - case 32: - goto st25 - } - goto st0 - st25: - if p++; p == pe { - goto _test_eof25 - } - st_case_25: - _widec = int16(data[p]) - if 13 <= data[p] && data[p] <= 13 { - _widec = 256 + (int16(data[p]) - 0) - if p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') { - _widec += 256 - } - } - switch _widec { - case 9: - goto st25 - case 32: - goto st25 - case 33: - goto tr17 - case 34: - goto st13 - case 37: - goto tr17 - case 39: - goto tr17 - case 93: - goto tr17 - case 126: - goto tr17 - case 525: - goto st26 - } - switch { - case _widec < 48: - switch { - case _widec > 43: - if 45 <= _widec && _widec <= 46 { - goto tr17 - } - case _widec >= 42: - goto tr17 - } - case _widec > 58: - switch { - case _widec > 91: - if 95 <= _widec && _widec <= 122 { - goto tr17 - } - case _widec >= 65: - goto tr17 - } - default: - goto tr17 - } - goto st0 - st26: - if p++; p == pe { - goto _test_eof26 - } - st_case_26: - if data[p] == 10 { - goto st27 - } - goto st0 - st27: - if p++; p == pe { - goto _test_eof27 - } - st_case_27: - switch data[p] { - case 9: - goto st28 - case 32: - goto st28 - } - goto st0 - st28: - if p++; p == pe { - goto _test_eof28 - } - st_case_28: - switch data[p] { - case 9: - goto st28 - case 32: - goto st28 - case 34: - goto st13 - } - goto st0 -tr115: -//line addr_parse.rl:52 - - name = string(data[mark:p]) - -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - - goto st29 - st29: - if p++; p == pe { - goto _test_eof29 - } - st_case_29: -//line addr_parse.go:2542 - if data[p] == 10 { - goto st30 - } - goto st0 - st30: - if p++; p == pe { - goto _test_eof30 - } - st_case_30: - switch data[p] { - case 9: - goto st31 - case 32: - goto st31 - } - goto st0 - st31: - if p++; p == pe { - goto _test_eof31 - } - st_case_31: - switch data[p] { - case 9: - goto st31 - case 32: - goto st31 - case 44: - goto st3 - case 59: - goto st7 - case 61: - goto st9 - } - goto st0 - st32: - if p++; p == pe { - goto _test_eof32 - } - st_case_32: - if data[p] == 10 { - goto st33 - } - goto st0 - st33: - if p++; p == pe { - goto _test_eof33 - } - st_case_33: - switch data[p] { - case 9: - goto st34 - case 32: - goto st34 - } - goto st0 - st34: - if p++; p == pe { - goto _test_eof34 - } - st_case_34: - switch data[p] { - case 9: - goto st34 - case 32: - goto st34 - case 33: - goto tr12 - case 37: - goto tr12 - case 39: - goto tr12 - case 126: - goto tr12 - } - switch { - case data[p] < 48: - switch { - case data[p] > 43: - if 45 <= data[p] && data[p] <= 46 { - goto tr12 - } - case data[p] >= 42: - goto tr12 - } - case data[p] > 57: - switch { - case data[p] > 90: - if 95 <= data[p] && data[p] <= 122 { - goto tr12 - } - case data[p] >= 65: - goto tr12 - } - default: - goto tr12 - } - goto st0 - st_out: - _test_eof1: cs = 1; goto _test_eof - _test_eof68: cs = 68; 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_eof74: cs = 74; goto _test_eof - _test_eof75: cs = 75; goto _test_eof - _test_eof42: cs = 42; goto _test_eof - _test_eof43: cs = 43; goto _test_eof - _test_eof76: cs = 76; 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_eof77: cs = 77; goto _test_eof - _test_eof78: cs = 78; goto _test_eof - _test_eof69: cs = 69; goto _test_eof - _test_eof2: cs = 2; goto _test_eof - _test_eof3: cs = 3; goto _test_eof - _test_eof70: cs = 70; 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_eof71: cs = 71; goto _test_eof - _test_eof8: cs = 8; goto _test_eof - _test_eof9: cs = 9; goto _test_eof - _test_eof72: cs = 72; 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_eof73: cs = 73; 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_eof: {} - if p == eof { - switch cs { - case 77: -//line addr_parse.rl:65 - - addr.Uri, err = ParseURIBytes(data[mark:p]) - if err != nil { return nil, err } - - case 72, 73: -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - - case 1, 68: -//line addr_parse.rl:79 - - p = mark - p-- - - {goto st35 } - - case 71: -//line addr_parse.rl:52 - - name = string(data[mark:p]) - -//line addr_parse.rl:70 - - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - -//line addr_parse.go:2757 - } - } - - _out: {} - } - -//line addr_parse.rl:199 - - - if cs < addr_first_final { - if p == pe { - return nil, errors.New(fmt.Sprintf("Incomplete SIP address: %s", data)) - } else { - return nil, errors.New(fmt.Sprintf("Error in SIP address at offset %d: %s", p, string(data))) - } - } - - if next != nil { - next.Last().Next = result - return next, nil - } - return result, nil -} diff --git a/sip/addr_parse.rl b/sip/addr_parse.rl deleted file mode 100644 index ecb9bff..0000000 --- a/sip/addr_parse.rl +++ /dev/null @@ -1,214 +0,0 @@ -// -*-go-*- - -package sip - -import ( - "errors" - "fmt" - "strings" -) - -%% machine addr; -%% write data; - -// ParseAddr turns a SIP address into a data structure. -func ParseAddr(s string) (addr *Addr, err error) { - if s == "" { - return nil, errors.New("Empty SIP message") - } - return ParseAddrBytes([]byte(s), nil) -} - -// ParseAddr turns a SIP address slice into a data structure. -func ParseAddrBytes(data []byte, next *Addr) (addr *Addr, err error) { - if data == nil { - return nil, nil - } - addr = new(Addr) - result := addr - cs := 0 - p := 0 - pe := len(data) - eof := len(data) - buf := make([]byte, len(data)) - amt := 0 - mark := 0 - var name string - - %%{ - action mark { - mark = p - } - - action start { - amt = 0 - } - - action append { - buf[amt] = fc - amt++ - } - - action name { - name = string(data[mark:p]) - } - - action display { - // TODO: Collapse this string. - addr.Display = strings.TrimRight(string(buf[0:amt]), " \t\r\n") - } - - action qdisplay { - addr.Display = string(buf[0:amt]) - } - - action uri { - addr.Uri, err = ParseURIBytes(data[mark:p]) - if err != nil { return nil, err } - } - - action param { - if addr.Params == nil { - addr.Params = Params{} - } - addr.Params[name] = string(buf[0:amt]) - } - - action lookAheadWSP { p + 2 < pe && (data[p+2] == ' ' || data[p+2] == '\t') } - - action goto_name_addr { - p = mark - fhold; - fgoto name_addr; - } - - action goto_bare_addr { - p = mark - fhold; - fgoto bare_addr; - } - - action goto_params { - fhold; - fgoto params; - } - - action goto_addr { - addr.Next = new(Addr) - addr = addr.Next - fhold; - fgoto addr; - } - - # https://tools.ietf.org/html/rfc2234 - SP = " "; - HTAB = "\t"; - CR = "\r"; - LF = "\n"; - DQUOTE = "\""; - CRLF = CR LF; - WSP = SP | HTAB; - LWS = ( WSP* ( CR when lookAheadWSP ) LF )? WSP+; - SWS = LWS?; - UTF8_CONT = 0x80..0xBF @append; - UTF8_NONASCII = 0xC0..0xDF @append UTF8_CONT {1} - | 0xE0..0xEF @append UTF8_CONT {2} - | 0xF0..0xF7 @append UTF8_CONT {3} - | 0xF8..0xFb @append UTF8_CONT {4} - | 0xFC..0xFD @append UTF8_CONT {5}; - UTF8 = 0x21..0x7F @append | UTF8_NONASCII; - - LWSCRLF_append = ( CR when lookAheadWSP ) @append LF @append; - LWS_append = ( WSP* @append LWSCRLF_append )? WSP+ @append; - - # https://tools.ietf.org/html/rfc3261#section-25.1 - reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | "," ; - mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")" ; - unreserved = alnum | mark ; - tokenc = alnum | "-" | "." | "!" | "%" | "*" | "_" | "+" | "`" - | "'" | "~" ; - separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" - | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP - | HTAB ; - wordc = alnum | "-" | "." | "!" | "%" | "*" | "_" | "+" | "`" - | "'" | "~" | "(" | ")" | "<" | ">" | ":" | "\\" | "\"" - | "/" | "[" | "]" | "?" | "{" | "}" ; - word = wordc+; - STAR = SWS "*" SWS; - SLASH = SWS "/" SWS; - EQUAL = SWS "=" SWS; - LPAREN = SWS "(" SWS; - RPAREN = SWS ")" SWS; - RAQUOT = ">" SWS; - LAQUOT = SWS "<"; - COMMA = SWS "," SWS; - SEMI = SWS ";" SWS; - COLON = SWS ":" SWS; - HCOLON = WSP* ":" SWS; - LDQUOT = SWS "\""; - RDQUOT = "\"" SWS; - - # The RFC BNF for SIP addresses is a bit nuts; we'll try our best. - token = tokenc+; - tokenhost = ( tokenc | "[" | "]" | ":" )+; - schemec = alnum | "+" | "-" | "."; - scheme = alpha schemec*; - uric = reserved | unreserved | "%" | "[" | "]"; - uri = scheme ":" uric+; - - # Quoted strings can have just about anything, including backslash escapes, - # which aren't quite as fancy as the ones you'd see in programming. - qdtextc = 0x21 | 0x23..0x5B | 0x5D..0x7E; - qdtext = UTF8_NONASCII | LWS_append | qdtextc @append; - quoted_pair = "\\" ( 0x00..0x09 | 0x0B..0x0C | 0x0E..0x7F ) @append; - quoted_content = ( qdtext | quoted_pair )* >start; - quoted_string = SWS DQUOTE quoted_content DQUOTE; - - # The display name can either be quoted or unquoted. The unquoted form is - # much more limited in what it may contain, although it does permit spaces. - display_name = quoted_string %qdisplay - | SWS ( token @append LWS_append )* >start %display - ; - - # Parameter parsing is pretty straightforward. Unlike URI parameters, the - # values on these can be quoted. The only thing that's weird is if the URI - # doesn't appear in angle brackets, the parameters need to be owned by the - # Addr object, not the URI. This has been placed in its own machine so it - # doesn't have to be duplicated in the two machines below. - param_name = token >mark >start %name; - param_content = tokenhost @append; - param_value = param_content | quoted_string; - param = ( param_name ( EQUAL param_value )? ) %param; - params := ( SEMI param )* ( COMMA <: any @goto_addr )?; - - # Now we're going to define two separate machines. The first is for - # addresses with angle brackets and the second is for ones without. - addr_spec = uri >mark %uri; - name_addr := display_name? LAQUOT addr_spec RAQUOT <: ( any @goto_params )?; - bare_addr := ( addr_spec -- ";" ) <: ( any @goto_params )?; - - # Now we perform lookahead to determine which machine we should use. - look = [^;<] - | ";" @goto_bare_addr - | "<" @goto_name_addr - ; - addr := look+ >mark $eof(goto_name_addr); - - write init; - write exec; - }%% - - if cs < addr_first_final { - if p == pe { - return nil, errors.New(fmt.Sprintf("Incomplete SIP address: %s", data)) - } else { - return nil, errors.New(fmt.Sprintf("Error in SIP address at offset %d: %s", p, string(data))) - } - } - - if next != nil { - next.Last().Next = result - return next, nil - } - return result, nil -} diff --git a/sip/msg_parse.go b/sip/msg_parse.go index 7add2f5..dba66cc 100644 --- a/sip/msg_parse.go +++ b/sip/msg_parse.go @@ -79,6 +79,9 @@ func ParseMsgBytes(data []byte) (msg *Msg, err error) { //line msg_parse.go:80 { var _widec int16 + if p == pe { + goto _test_eof + } switch cs { case 1: goto st_case_1 @@ -1692,7 +1695,7 @@ tr416: {goto st273 } goto st0 -//line msg_parse.go:1696 +//line msg_parse.go:1699 st_case_0: st0: cs = 0 @@ -1704,9 +1707,11 @@ tr0: goto st2 st2: - p++ + if p++; p == pe { + goto _test_eof2 + } st_case_2: -//line msg_parse.go:1710 +//line msg_parse.go:1715 switch data[p] { case 32: goto tr3 @@ -1749,9 +1754,11 @@ tr3: goto st3 st3: - p++ + if p++; p == pe { + goto _test_eof3 + } st_case_3: -//line msg_parse.go:1755 +//line msg_parse.go:1762 if data[p] == 32 { goto st0 } @@ -1763,9 +1770,11 @@ tr5: goto st4 st4: - p++ + if p++; p == pe { + goto _test_eof4 + } st_case_4: -//line msg_parse.go:1769 +//line msg_parse.go:1778 if data[p] == 32 { goto tr7 } @@ -1778,36 +1787,46 @@ tr7: goto st5 st5: - p++ + if p++; p == pe { + goto _test_eof5 + } st_case_5: -//line msg_parse.go:1784 +//line msg_parse.go:1795 if data[p] == 83 { goto st6 } goto st0 st6: - p++ + if p++; p == pe { + goto _test_eof6 + } st_case_6: if data[p] == 73 { goto st7 } goto st0 st7: - p++ + if p++; p == pe { + goto _test_eof7 + } st_case_7: if data[p] == 80 { goto st8 } goto st0 st8: - p++ + if p++; p == pe { + goto _test_eof8 + } st_case_8: if data[p] == 47 { goto st9 } goto st0 st9: - p++ + if p++; p == pe { + goto _test_eof9 + } st_case_9: if 48 <= data[p] && data[p] <= 57 { goto tr12 @@ -1820,9 +1839,11 @@ tr12: goto st10 st10: - p++ + if p++; p == pe { + goto _test_eof10 + } st_case_10: -//line msg_parse.go:1826 +//line msg_parse.go:1847 if data[p] == 46 { goto st11 } @@ -1831,7 +1852,9 @@ tr12: } goto st0 st11: - p++ + if p++; p == pe { + goto _test_eof11 + } st_case_11: if 48 <= data[p] && data[p] <= 57 { goto tr14 @@ -1844,9 +1867,11 @@ tr14: goto st12 st12: - p++ + if p++; p == pe { + goto _test_eof12 + } st_case_12: -//line msg_parse.go:1850 +//line msg_parse.go:1875 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -1868,9 +1893,11 @@ tr42: goto st13 st13: - p++ + if p++; p == pe { + goto _test_eof13 + } st_case_13: -//line msg_parse.go:1874 +//line msg_parse.go:1901 if data[p] == 10 { goto tr16 } @@ -1880,9 +1907,11 @@ tr16: {goto st280 } goto st765 st765: - p++ + if p++; p == pe { + goto _test_eof765 + } st_case_765: -//line msg_parse.go:1886 +//line msg_parse.go:1915 goto st0 tr2: //line sip.rl:62 @@ -1891,9 +1920,11 @@ tr2: goto st14 st14: - p++ + if p++; p == pe { + goto _test_eof14 + } st_case_14: -//line msg_parse.go:1897 +//line msg_parse.go:1928 switch data[p] { case 32: goto tr3 @@ -1932,7 +1963,9 @@ tr2: } goto st0 st15: - p++ + if p++; p == pe { + goto _test_eof15 + } st_case_15: switch data[p] { case 32: @@ -1972,7 +2005,9 @@ tr2: } goto st0 st16: - p++ + if p++; p == pe { + goto _test_eof16 + } st_case_16: switch data[p] { case 32: @@ -2007,7 +2042,9 @@ tr2: } goto st0 st17: - p++ + if p++; p == pe { + goto _test_eof17 + } st_case_17: if 48 <= data[p] && data[p] <= 57 { goto tr20 @@ -2020,9 +2057,11 @@ tr20: goto st18 st18: - p++ + if p++; p == pe { + goto _test_eof18 + } st_case_18: -//line msg_parse.go:2026 +//line msg_parse.go:2065 if data[p] == 46 { goto st19 } @@ -2031,7 +2070,9 @@ tr20: } goto st0 st19: - p++ + if p++; p == pe { + goto _test_eof19 + } st_case_19: if 48 <= data[p] && data[p] <= 57 { goto tr22 @@ -2044,9 +2085,11 @@ tr22: goto st20 st20: - p++ + if p++; p == pe { + goto _test_eof20 + } st_case_20: -//line msg_parse.go:2050 +//line msg_parse.go:2093 if data[p] == 32 { goto st21 } @@ -2055,7 +2098,9 @@ tr22: } goto st0 st21: - p++ + if p++; p == pe { + goto _test_eof21 + } st_case_21: if 48 <= data[p] && data[p] <= 57 { goto tr24 @@ -2068,9 +2113,11 @@ tr24: goto st22 st22: - p++ + if p++; p == pe { + goto _test_eof22 + } st_case_22: -//line msg_parse.go:2074 +//line msg_parse.go:2121 if 48 <= data[p] && data[p] <= 57 { goto tr25 } @@ -2082,9 +2129,11 @@ tr25: goto st23 st23: - p++ + if p++; p == pe { + goto _test_eof23 + } st_case_23: -//line msg_parse.go:2088 +//line msg_parse.go:2137 if 48 <= data[p] && data[p] <= 57 { goto tr26 } @@ -2096,15 +2145,19 @@ tr26: goto st24 st24: - p++ + if p++; p == pe { + goto _test_eof24 + } st_case_24: -//line msg_parse.go:2102 +//line msg_parse.go:2153 if data[p] == 32 { goto st25 } goto st0 st25: - p++ + if p++; p == pe { + goto _test_eof25 + } st_case_25: switch data[p] { case 9: @@ -2186,9 +2239,11 @@ tr44: goto st26 st26: - p++ + if p++; p == pe { + goto _test_eof26 + } st_case_26: -//line msg_parse.go:2192 +//line msg_parse.go:2247 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -2258,9 +2313,11 @@ tr29: goto st27 st27: - p++ + if p++; p == pe { + goto _test_eof27 + } st_case_27: -//line msg_parse.go:2264 +//line msg_parse.go:2321 switch { case data[p] < 65: if 48 <= data[p] && data[p] <= 57 { @@ -2281,9 +2338,11 @@ tr43: goto st28 st28: - p++ + if p++; p == pe { + goto _test_eof28 + } st_case_28: -//line msg_parse.go:2287 +//line msg_parse.go:2346 switch { case data[p] < 65: if 48 <= data[p] && data[p] <= 57 { @@ -2316,9 +2375,11 @@ tr37: goto st29 st29: - p++ + if p++; p == pe { + goto _test_eof29 + } st_case_29: -//line msg_parse.go:2322 +//line msg_parse.go:2383 if 128 <= data[p] && data[p] <= 191 { goto tr35 } @@ -2342,9 +2403,11 @@ tr38: goto st30 st30: - p++ + if p++; p == pe { + goto _test_eof30 + } st_case_30: -//line msg_parse.go:2348 +//line msg_parse.go:2411 if 128 <= data[p] && data[p] <= 191 { goto tr37 } @@ -2368,9 +2431,11 @@ tr39: goto st31 st31: - p++ + if p++; p == pe { + goto _test_eof31 + } st_case_31: -//line msg_parse.go:2374 +//line msg_parse.go:2439 if 128 <= data[p] && data[p] <= 191 { goto tr38 } @@ -2394,9 +2459,11 @@ tr40: goto st32 st32: - p++ + if p++; p == pe { + goto _test_eof32 + } st_case_32: -//line msg_parse.go:2400 +//line msg_parse.go:2467 if 128 <= data[p] && data[p] <= 191 { goto tr39 } @@ -2420,15 +2487,19 @@ tr41: goto st33 st33: - p++ + if p++; p == pe { + goto _test_eof33 + } st_case_33: -//line msg_parse.go:2426 +//line msg_parse.go:2495 if 128 <= data[p] && data[p] <= 191 { goto tr40 } goto st0 st34: - p++ + if p++; p == pe { + goto _test_eof34 + } st_case_34: switch data[p] { case 33: @@ -2470,9 +2541,11 @@ tr45: goto st35 st35: - p++ + if p++; p == pe { + goto _test_eof35 + } st_case_35: -//line msg_parse.go:2476 +//line msg_parse.go:2549 switch data[p] { case 33: goto st35 @@ -2504,7 +2577,9 @@ tr45: } goto st0 st36: - p++ + if p++; p == pe { + goto _test_eof36 + } st_case_36: switch data[p] { case 33: @@ -2540,7 +2615,9 @@ tr45: } goto st0 st37: - p++ + if p++; p == pe { + goto _test_eof37 + } st_case_37: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -2599,9 +2676,11 @@ tr49: goto st38 st38: - p++ + if p++; p == pe { + goto _test_eof38 + } st_case_38: -//line msg_parse.go:2605 +//line msg_parse.go:2684 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -2627,9 +2706,11 @@ tr50: goto st39 st39: - p++ + if p++; p == pe { + goto _test_eof39 + } st_case_39: -//line msg_parse.go:2633 +//line msg_parse.go:2714 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -2677,7 +2758,9 @@ tr50: } goto st0 st40: - p++ + if p++; p == pe { + goto _test_eof40 + } st_case_40: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -2728,7 +2811,9 @@ tr50: } goto st0 st41: - p++ + if p++; p == pe { + goto _test_eof41 + } st_case_41: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -2749,7 +2834,9 @@ tr50: } goto st0 st42: - p++ + if p++; p == pe { + goto _test_eof42 + } st_case_42: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -2800,7 +2887,9 @@ tr50: } goto st0 st43: - p++ + if p++; p == pe { + goto _test_eof43 + } st_case_43: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -2859,9 +2948,11 @@ tr51: goto st44 st44: - p++ + if p++; p == pe { + goto _test_eof44 + } st_case_44: -//line msg_parse.go:2865 +//line msg_parse.go:2956 if data[p] == 10 { goto tr65 } @@ -2871,9 +2962,11 @@ tr65: {goto st280 } goto st766 st766: - p++ + if p++; p == pe { + goto _test_eof766 + } st_case_766: -//line msg_parse.go:2877 +//line msg_parse.go:2970 goto st0 tr52: //line sip.rl:219 @@ -2882,15 +2975,19 @@ tr52: goto st45 st45: - p++ + if p++; p == pe { + goto _test_eof45 + } st_case_45: -//line msg_parse.go:2888 +//line msg_parse.go:2983 if data[p] == 10 { goto st46 } goto st0 st46: - p++ + if p++; p == pe { + goto _test_eof46 + } st_case_46: switch data[p] { case 9: @@ -2900,7 +2997,9 @@ tr52: } goto st0 st47: - p++ + if p++; p == pe { + goto _test_eof47 + } st_case_47: switch data[p] { case 9: @@ -2912,7 +3011,9 @@ tr52: } goto st0 st48: - p++ + if p++; p == pe { + goto _test_eof48 + } st_case_48: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -2977,9 +3078,11 @@ tr77: goto st49 st49: - p++ + if p++; p == pe { + goto _test_eof49 + } st_case_49: -//line msg_parse.go:2983 +//line msg_parse.go:3086 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -3031,9 +3134,11 @@ tr69: goto st50 st50: - p++ + if p++; p == pe { + goto _test_eof50 + } st_case_50: -//line msg_parse.go:3037 +//line msg_parse.go:3142 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -3061,9 +3166,11 @@ tr70: goto st51 st51: - p++ + if p++; p == pe { + goto _test_eof51 + } st_case_51: -//line msg_parse.go:3067 +//line msg_parse.go:3174 switch { case data[p] < 11: if data[p] <= 9 { @@ -3096,9 +3203,11 @@ tr80: goto st52 st52: - p++ + if p++; p == pe { + goto _test_eof52 + } st_case_52: -//line msg_parse.go:3102 +//line msg_parse.go:3211 if 128 <= data[p] && data[p] <= 191 { goto tr77 } @@ -3122,9 +3231,11 @@ tr81: goto st53 st53: - p++ + if p++; p == pe { + goto _test_eof53 + } st_case_53: -//line msg_parse.go:3128 +//line msg_parse.go:3239 if 128 <= data[p] && data[p] <= 191 { goto tr80 } @@ -3148,9 +3259,11 @@ tr82: goto st54 st54: - p++ + if p++; p == pe { + goto _test_eof54 + } st_case_54: -//line msg_parse.go:3154 +//line msg_parse.go:3267 if 128 <= data[p] && data[p] <= 191 { goto tr81 } @@ -3174,9 +3287,11 @@ tr83: goto st55 st55: - p++ + if p++; p == pe { + goto _test_eof55 + } st_case_55: -//line msg_parse.go:3180 +//line msg_parse.go:3295 if 128 <= data[p] && data[p] <= 191 { goto tr82 } @@ -3200,9 +3315,11 @@ tr84: goto st56 st56: - p++ + if p++; p == pe { + goto _test_eof56 + } st_case_56: -//line msg_parse.go:3206 +//line msg_parse.go:3323 if 128 <= data[p] && data[p] <= 191 { goto tr83 } @@ -3226,9 +3343,11 @@ tr85: goto st57 st57: - p++ + if p++; p == pe { + goto _test_eof57 + } st_case_57: -//line msg_parse.go:3232 +//line msg_parse.go:3351 if data[p] == 10 { goto tr86 } @@ -3241,9 +3360,11 @@ tr86: goto st58 st58: - p++ + if p++; p == pe { + goto _test_eof58 + } st_case_58: -//line msg_parse.go:3247 +//line msg_parse.go:3368 switch data[p] { case 9: goto tr77 @@ -3252,14 +3373,18 @@ tr86: } goto st0 st59: - p++ + if p++; p == pe { + goto _test_eof59 + } st_case_59: if data[p] == 10 { goto st60 } goto st0 st60: - p++ + if p++; p == pe { + goto _test_eof60 + } st_case_60: switch data[p] { case 9: @@ -3269,7 +3394,9 @@ tr86: } goto st0 st61: - p++ + if p++; p == pe { + goto _test_eof61 + } st_case_61: switch data[p] { case 9: @@ -3311,14 +3438,18 @@ tr86: } goto st0 st62: - p++ + if p++; p == pe { + goto _test_eof62 + } st_case_62: if data[p] == 10 { goto st63 } goto st0 st63: - p++ + if p++; p == pe { + goto _test_eof63 + } st_case_63: switch data[p] { case 9: @@ -3328,7 +3459,9 @@ tr86: } goto st0 st64: - p++ + if p++; p == pe { + goto _test_eof64 + } st_case_64: switch data[p] { case 9: @@ -3340,14 +3473,18 @@ tr86: } goto st0 st65: - p++ + if p++; p == pe { + goto _test_eof65 + } st_case_65: if data[p] == 10 { goto st66 } goto st0 st66: - p++ + if p++; p == pe { + goto _test_eof66 + } st_case_66: switch data[p] { case 9: @@ -3357,7 +3494,9 @@ tr86: } goto st0 st67: - p++ + if p++; p == pe { + goto _test_eof67 + } st_case_67: switch data[p] { case 9: @@ -3397,7 +3536,9 @@ tr86: } goto st0 st68: - p++ + if p++; p == pe { + goto _test_eof68 + } st_case_68: switch data[p] { case 33: @@ -3443,9 +3584,11 @@ tr93: goto st69 st69: - p++ + if p++; p == pe { + goto _test_eof69 + } st_case_69: -//line msg_parse.go:3449 +//line msg_parse.go:3592 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -3502,9 +3645,11 @@ tr94: goto st70 st70: - p++ + if p++; p == pe { + goto _test_eof70 + } st_case_70: -//line msg_parse.go:3508 +//line msg_parse.go:3653 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -3534,9 +3679,11 @@ tr96: goto st71 st71: - p++ + if p++; p == pe { + goto _test_eof71 + } st_case_71: -//line msg_parse.go:3540 +//line msg_parse.go:3687 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -3627,19 +3774,25 @@ tr122: {goto st280 } goto st767 st767: - p++ + if p++; p == pe { + goto _test_eof767 + } st_case_767: -//line msg_parse.go:3633 +//line msg_parse.go:3782 goto st0 st72: - p++ + if p++; p == pe { + goto _test_eof72 + } st_case_72: if data[p] == 10 { goto st73 } goto st0 st73: - p++ + if p++; p == pe { + goto _test_eof73 + } st_case_73: switch data[p] { case 9: @@ -3649,7 +3802,9 @@ tr122: } goto st0 st74: - p++ + if p++; p == pe { + goto _test_eof74 + } st_case_74: switch data[p] { case 9: @@ -3665,9 +3820,11 @@ tr97: goto st75 st75: - p++ + if p++; p == pe { + goto _test_eof75 + } st_case_75: -//line msg_parse.go:3671 +//line msg_parse.go:3828 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -3695,14 +3852,18 @@ tr97: } goto st0 st76: - p++ + if p++; p == pe { + goto _test_eof76 + } st_case_76: if data[p] == 10 { goto st77 } goto st0 st77: - p++ + if p++; p == pe { + goto _test_eof77 + } st_case_77: switch data[p] { case 9: @@ -3712,7 +3873,9 @@ tr97: } goto st0 st78: - p++ + if p++; p == pe { + goto _test_eof78 + } st_case_78: switch data[p] { case 9: @@ -3728,9 +3891,11 @@ tr98: goto st79 st79: - p++ + if p++; p == pe { + goto _test_eof79 + } st_case_79: -//line msg_parse.go:3734 +//line msg_parse.go:3899 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -3789,9 +3954,11 @@ tr114: goto st80 st80: - p++ + if p++; p == pe { + goto _test_eof80 + } st_case_80: -//line msg_parse.go:3795 +//line msg_parse.go:3962 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -3842,7 +4009,9 @@ tr114: } goto st0 st81: - p++ + if p++; p == pe { + goto _test_eof81 + } st_case_81: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -3865,14 +4034,18 @@ tr114: } goto st0 st82: - p++ + if p++; p == pe { + goto _test_eof82 + } st_case_82: if data[p] == 10 { goto st83 } goto st0 st83: - p++ + if p++; p == pe { + goto _test_eof83 + } st_case_83: switch data[p] { case 9: @@ -3882,7 +4055,9 @@ tr114: } goto st0 st84: - p++ + if p++; p == pe { + goto _test_eof84 + } st_case_84: switch data[p] { case 9: @@ -3902,15 +4077,19 @@ tr99: goto st85 st85: - p++ + if p++; p == pe { + goto _test_eof85 + } st_case_85: -//line msg_parse.go:3908 +//line msg_parse.go:4085 if data[p] == 10 { goto tr122 } goto st0 st86: - p++ + if p++; p == pe { + goto _test_eof86 + } st_case_86: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -3975,9 +4154,11 @@ tr132: goto st87 st87: - p++ + if p++; p == pe { + goto _test_eof87 + } st_case_87: -//line msg_parse.go:3981 +//line msg_parse.go:4162 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4029,9 +4210,11 @@ tr124: goto st88 st88: - p++ + if p++; p == pe { + goto _test_eof88 + } st_case_88: -//line msg_parse.go:4035 +//line msg_parse.go:4218 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4061,9 +4244,11 @@ tr125: goto st89 st89: - p++ + if p++; p == pe { + goto _test_eof89 + } st_case_89: -//line msg_parse.go:4067 +//line msg_parse.go:4252 switch { case data[p] < 11: if data[p] <= 9 { @@ -4096,9 +4281,11 @@ tr135: goto st90 st90: - p++ + if p++; p == pe { + goto _test_eof90 + } st_case_90: -//line msg_parse.go:4102 +//line msg_parse.go:4289 if 128 <= data[p] && data[p] <= 191 { goto tr132 } @@ -4122,9 +4309,11 @@ tr136: goto st91 st91: - p++ + if p++; p == pe { + goto _test_eof91 + } st_case_91: -//line msg_parse.go:4128 +//line msg_parse.go:4317 if 128 <= data[p] && data[p] <= 191 { goto tr135 } @@ -4148,9 +4337,11 @@ tr137: goto st92 st92: - p++ + if p++; p == pe { + goto _test_eof92 + } st_case_92: -//line msg_parse.go:4154 +//line msg_parse.go:4345 if 128 <= data[p] && data[p] <= 191 { goto tr136 } @@ -4174,9 +4365,11 @@ tr138: goto st93 st93: - p++ + if p++; p == pe { + goto _test_eof93 + } st_case_93: -//line msg_parse.go:4180 +//line msg_parse.go:4373 if 128 <= data[p] && data[p] <= 191 { goto tr137 } @@ -4200,9 +4393,11 @@ tr139: goto st94 st94: - p++ + if p++; p == pe { + goto _test_eof94 + } st_case_94: -//line msg_parse.go:4206 +//line msg_parse.go:4401 if 128 <= data[p] && data[p] <= 191 { goto tr138 } @@ -4226,9 +4421,11 @@ tr140: goto st95 st95: - p++ + if p++; p == pe { + goto _test_eof95 + } st_case_95: -//line msg_parse.go:4232 +//line msg_parse.go:4429 if data[p] == 10 { goto tr141 } @@ -4241,9 +4438,11 @@ tr141: goto st96 st96: - p++ + if p++; p == pe { + goto _test_eof96 + } st_case_96: -//line msg_parse.go:4247 +//line msg_parse.go:4446 switch data[p] { case 9: goto tr132 @@ -4252,14 +4451,18 @@ tr141: } goto st0 st97: - p++ + if p++; p == pe { + goto _test_eof97 + } st_case_97: if data[p] == 10 { goto st98 } goto st0 st98: - p++ + if p++; p == pe { + goto _test_eof98 + } st_case_98: switch data[p] { case 9: @@ -4269,7 +4472,9 @@ tr141: } goto st0 st99: - p++ + if p++; p == pe { + goto _test_eof99 + } st_case_99: switch data[p] { case 9: @@ -4319,15 +4524,19 @@ tr100: goto st100 st100: - p++ + if p++; p == pe { + goto _test_eof100 + } st_case_100: -//line msg_parse.go:4325 +//line msg_parse.go:4532 if data[p] == 10 { goto st101 } goto st0 st101: - p++ + if p++; p == pe { + goto _test_eof101 + } st_case_101: switch data[p] { case 9: @@ -4337,7 +4546,9 @@ tr100: } goto st0 st102: - p++ + if p++; p == pe { + goto _test_eof102 + } st_case_102: switch data[p] { case 9: @@ -4353,7 +4564,9 @@ tr100: } goto st0 st103: - p++ + if p++; p == pe { + goto _test_eof103 + } st_case_103: switch data[p] { case 33: @@ -4395,9 +4608,11 @@ tr146: goto st104 st104: - p++ + if p++; p == pe { + goto _test_eof104 + } st_case_104: -//line msg_parse.go:4401 +//line msg_parse.go:4616 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4448,9 +4663,11 @@ tr147: goto st105 st105: - p++ + if p++; p == pe { + goto _test_eof105 + } st_case_105: -//line msg_parse.go:4454 +//line msg_parse.go:4671 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4476,9 +4693,11 @@ tr149: goto st106 st106: - p++ + if p++; p == pe { + goto _test_eof106 + } st_case_106: -//line msg_parse.go:4482 +//line msg_parse.go:4701 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4532,9 +4751,11 @@ tr154: goto st107 st107: - p++ + if p++; p == pe { + goto _test_eof107 + } st_case_107: -//line msg_parse.go:4538 +//line msg_parse.go:4759 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4585,9 +4806,11 @@ tr156: goto st108 st108: - p++ + if p++; p == pe { + goto _test_eof108 + } st_case_108: -//line msg_parse.go:4591 +//line msg_parse.go:4814 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4613,9 +4836,11 @@ tr158: goto st109 st109: - p++ + if p++; p == pe { + goto _test_eof109 + } st_case_109: -//line msg_parse.go:4619 +//line msg_parse.go:4844 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4669,9 +4894,11 @@ tr163: goto st110 st110: - p++ + if p++; p == pe { + goto _test_eof110 + } st_case_110: -//line msg_parse.go:4675 +//line msg_parse.go:4902 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4725,9 +4952,11 @@ tr165: goto st111 st111: - p++ + if p++; p == pe { + goto _test_eof111 + } st_case_111: -//line msg_parse.go:4731 +//line msg_parse.go:4960 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4770,9 +4999,11 @@ tr169: goto st112 st112: - p++ + if p++; p == pe { + goto _test_eof112 + } st_case_112: -//line msg_parse.go:4776 +//line msg_parse.go:5007 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4821,9 +5052,11 @@ tr172: goto st113 st113: - p++ + if p++; p == pe { + goto _test_eof113 + } st_case_113: -//line msg_parse.go:4827 +//line msg_parse.go:5060 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4853,9 +5086,11 @@ tr173: goto st114 st114: - p++ + if p++; p == pe { + goto _test_eof114 + } st_case_114: -//line msg_parse.go:4859 +//line msg_parse.go:5094 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4925,19 +5160,25 @@ tr199: {goto st280 } goto st768 st768: - p++ + if p++; p == pe { + goto _test_eof768 + } st_case_768: -//line msg_parse.go:4931 +//line msg_parse.go:5168 goto st0 st115: - p++ + if p++; p == pe { + goto _test_eof115 + } st_case_115: if data[p] == 10 { goto st116 } goto st0 st116: - p++ + if p++; p == pe { + goto _test_eof116 + } st_case_116: switch data[p] { case 9: @@ -4947,7 +5188,9 @@ tr199: } goto st0 st117: - p++ + if p++; p == pe { + goto _test_eof117 + } st_case_117: switch data[p] { case 9: @@ -4963,9 +5206,11 @@ tr175: goto st118 st118: - p++ + if p++; p == pe { + goto _test_eof118 + } st_case_118: -//line msg_parse.go:4969 +//line msg_parse.go:5214 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -4992,9 +5237,11 @@ tr188: goto st119 st119: - p++ + if p++; p == pe { + goto _test_eof119 + } st_case_119: -//line msg_parse.go:4998 +//line msg_parse.go:5245 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -5021,7 +5268,9 @@ tr188: } goto st0 st120: - p++ + if p++; p == pe { + goto _test_eof120 + } st_case_120: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -5050,9 +5299,11 @@ tr176: goto st121 st121: - p++ + if p++; p == pe { + goto _test_eof121 + } st_case_121: -//line msg_parse.go:5056 +//line msg_parse.go:5307 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -5080,14 +5331,18 @@ tr176: } goto st0 st122: - p++ + if p++; p == pe { + goto _test_eof122 + } st_case_122: if data[p] == 10 { goto st123 } goto st0 st123: - p++ + if p++; p == pe { + goto _test_eof123 + } st_case_123: switch data[p] { case 9: @@ -5097,7 +5352,9 @@ tr176: } goto st0 st124: - p++ + if p++; p == pe { + goto _test_eof124 + } st_case_124: switch data[p] { case 9: @@ -5107,14 +5364,18 @@ tr176: } goto tr193 st125: - p++ + if p++; p == pe { + goto _test_eof125 + } st_case_125: if data[p] == 10 { goto st126 } goto st0 st126: - p++ + if p++; p == pe { + goto _test_eof126 + } st_case_126: switch data[p] { case 9: @@ -5124,7 +5385,9 @@ tr176: } goto st0 st127: - p++ + if p++; p == pe { + goto _test_eof127 + } st_case_127: switch data[p] { case 9: @@ -5144,22 +5407,28 @@ tr177: goto st128 st128: - p++ + if p++; p == pe { + goto _test_eof128 + } st_case_128: -//line msg_parse.go:5150 +//line msg_parse.go:5415 if data[p] == 10 { goto tr199 } goto st0 st129: - p++ + if p++; p == pe { + goto _test_eof129 + } st_case_129: if data[p] == 10 { goto st130 } goto st0 st130: - p++ + if p++; p == pe { + goto _test_eof130 + } st_case_130: switch data[p] { case 9: @@ -5169,7 +5438,9 @@ tr177: } goto st0 st131: - p++ + if p++; p == pe { + goto _test_eof131 + } st_case_131: switch data[p] { case 9: @@ -5188,15 +5459,19 @@ tr178: goto st132 st132: - p++ + if p++; p == pe { + goto _test_eof132 + } st_case_132: -//line msg_parse.go:5194 +//line msg_parse.go:5467 if data[p] == 10 { goto st133 } goto st0 st133: - p++ + if p++; p == pe { + goto _test_eof133 + } st_case_133: switch data[p] { case 9: @@ -5206,7 +5481,9 @@ tr178: } goto st0 st134: - p++ + if p++; p == pe { + goto _test_eof134 + } st_case_134: switch data[p] { case 9: @@ -5222,7 +5499,9 @@ tr178: } goto st0 st135: - p++ + if p++; p == pe { + goto _test_eof135 + } st_case_135: if data[p] == 46 { goto tr204 @@ -5247,9 +5526,11 @@ tr204: goto st136 st136: - p++ + if p++; p == pe { + goto _test_eof136 + } st_case_136: -//line msg_parse.go:5253 +//line msg_parse.go:5534 switch data[p] { case 46: goto st136 @@ -5276,9 +5557,11 @@ tr206: goto st137 st137: - p++ + if p++; p == pe { + goto _test_eof137 + } st_case_137: -//line msg_parse.go:5282 +//line msg_parse.go:5565 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -5310,15 +5593,19 @@ tr167: goto st138 st138: - p++ + if p++; p == pe { + goto _test_eof138 + } st_case_138: -//line msg_parse.go:5316 +//line msg_parse.go:5601 if data[p] == 10 { goto st139 } goto st0 st139: - p++ + if p++; p == pe { + goto _test_eof139 + } st_case_139: switch data[p] { case 9: @@ -5328,7 +5615,9 @@ tr167: } goto st0 st140: - p++ + if p++; p == pe { + goto _test_eof140 + } st_case_140: switch data[p] { case 9: @@ -5357,14 +5646,18 @@ tr167: } goto st0 st141: - p++ + if p++; p == pe { + goto _test_eof141 + } st_case_141: if data[p] == 10 { goto st142 } goto st0 st142: - p++ + if p++; p == pe { + goto _test_eof142 + } st_case_142: switch data[p] { case 9: @@ -5374,7 +5667,9 @@ tr167: } goto st0 st143: - p++ + if p++; p == pe { + goto _test_eof143 + } st_case_143: switch data[p] { case 9: @@ -5420,15 +5715,19 @@ tr159: goto st144 st144: - p++ + if p++; p == pe { + goto _test_eof144 + } st_case_144: -//line msg_parse.go:5426 +//line msg_parse.go:5723 if data[p] == 10 { goto st145 } goto st0 st145: - p++ + if p++; p == pe { + goto _test_eof145 + } st_case_145: switch data[p] { case 9: @@ -5438,7 +5737,9 @@ tr159: } goto st0 st146: - p++ + if p++; p == pe { + goto _test_eof146 + } st_case_146: switch data[p] { case 9: @@ -5450,14 +5751,18 @@ tr159: } goto st0 st147: - p++ + if p++; p == pe { + goto _test_eof147 + } st_case_147: if data[p] == 10 { goto st148 } goto st0 st148: - p++ + if p++; p == pe { + goto _test_eof148 + } st_case_148: switch data[p] { case 9: @@ -5467,7 +5772,9 @@ tr159: } goto st0 st149: - p++ + if p++; p == pe { + goto _test_eof149 + } st_case_149: switch data[p] { case 9: @@ -5513,15 +5820,19 @@ tr150: goto st150 st150: - p++ + if p++; p == pe { + goto _test_eof150 + } st_case_150: -//line msg_parse.go:5519 +//line msg_parse.go:5828 if data[p] == 10 { goto st151 } goto st0 st151: - p++ + if p++; p == pe { + goto _test_eof151 + } st_case_151: switch data[p] { case 9: @@ -5531,7 +5842,9 @@ tr150: } goto st0 st152: - p++ + if p++; p == pe { + goto _test_eof152 + } st_case_152: switch data[p] { case 9: @@ -5543,7 +5856,9 @@ tr150: } goto st0 st153: - p++ + if p++; p == pe { + goto _test_eof153 + } st_case_153: switch data[p] { case 33: @@ -5589,9 +5904,11 @@ tr217: goto st154 st154: - p++ + if p++; p == pe { + goto _test_eof154 + } st_case_154: -//line msg_parse.go:5595 +//line msg_parse.go:5912 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -5648,9 +5965,11 @@ tr218: goto st155 st155: - p++ + if p++; p == pe { + goto _test_eof155 + } st_case_155: -//line msg_parse.go:5654 +//line msg_parse.go:5973 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -5680,9 +5999,11 @@ tr220: goto st156 st156: - p++ + if p++; p == pe { + goto _test_eof156 + } st_case_156: -//line msg_parse.go:5686 +//line msg_parse.go:6007 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -5765,19 +6086,25 @@ tr246: {goto st280 } goto st769 st769: - p++ + if p++; p == pe { + goto _test_eof769 + } st_case_769: -//line msg_parse.go:5771 +//line msg_parse.go:6094 goto st0 st157: - p++ + if p++; p == pe { + goto _test_eof157 + } st_case_157: if data[p] == 10 { goto st158 } goto st0 st158: - p++ + if p++; p == pe { + goto _test_eof158 + } st_case_158: switch data[p] { case 9: @@ -5787,7 +6114,9 @@ tr246: } goto st0 st159: - p++ + if p++; p == pe { + goto _test_eof159 + } st_case_159: switch data[p] { case 9: @@ -5803,9 +6132,11 @@ tr221: goto st160 st160: - p++ + if p++; p == pe { + goto _test_eof160 + } st_case_160: -//line msg_parse.go:5809 +//line msg_parse.go:6140 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -5833,14 +6164,18 @@ tr221: } goto st0 st161: - p++ + if p++; p == pe { + goto _test_eof161 + } st_case_161: if data[p] == 10 { goto st162 } goto st0 st162: - p++ + if p++; p == pe { + goto _test_eof162 + } st_case_162: switch data[p] { case 9: @@ -5850,7 +6185,9 @@ tr221: } goto st0 st163: - p++ + if p++; p == pe { + goto _test_eof163 + } st_case_163: switch data[p] { case 9: @@ -5866,9 +6203,11 @@ tr222: goto st164 st164: - p++ + if p++; p == pe { + goto _test_eof164 + } st_case_164: -//line msg_parse.go:5872 +//line msg_parse.go:6211 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -5927,9 +6266,11 @@ tr238: goto st165 st165: - p++ + if p++; p == pe { + goto _test_eof165 + } st_case_165: -//line msg_parse.go:5933 +//line msg_parse.go:6274 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -5980,7 +6321,9 @@ tr238: } goto st0 st166: - p++ + if p++; p == pe { + goto _test_eof166 + } st_case_166: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -6003,14 +6346,18 @@ tr238: } goto st0 st167: - p++ + if p++; p == pe { + goto _test_eof167 + } st_case_167: if data[p] == 10 { goto st168 } goto st0 st168: - p++ + if p++; p == pe { + goto _test_eof168 + } st_case_168: switch data[p] { case 9: @@ -6020,7 +6367,9 @@ tr238: } goto st0 st169: - p++ + if p++; p == pe { + goto _test_eof169 + } st_case_169: switch data[p] { case 9: @@ -6040,15 +6389,19 @@ tr223: goto st170 st170: - p++ + if p++; p == pe { + goto _test_eof170 + } st_case_170: -//line msg_parse.go:6046 +//line msg_parse.go:6397 if data[p] == 10 { goto tr246 } goto st0 st171: - p++ + if p++; p == pe { + goto _test_eof171 + } st_case_171: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -6113,9 +6466,11 @@ tr256: goto st172 st172: - p++ + if p++; p == pe { + goto _test_eof172 + } st_case_172: -//line msg_parse.go:6119 +//line msg_parse.go:6474 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -6167,9 +6522,11 @@ tr248: goto st173 st173: - p++ + if p++; p == pe { + goto _test_eof173 + } st_case_173: -//line msg_parse.go:6173 +//line msg_parse.go:6530 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -6199,9 +6556,11 @@ tr249: goto st174 st174: - p++ + if p++; p == pe { + goto _test_eof174 + } st_case_174: -//line msg_parse.go:6205 +//line msg_parse.go:6564 switch { case data[p] < 11: if data[p] <= 9 { @@ -6234,9 +6593,11 @@ tr259: goto st175 st175: - p++ + if p++; p == pe { + goto _test_eof175 + } st_case_175: -//line msg_parse.go:6240 +//line msg_parse.go:6601 if 128 <= data[p] && data[p] <= 191 { goto tr256 } @@ -6260,9 +6621,11 @@ tr260: goto st176 st176: - p++ + if p++; p == pe { + goto _test_eof176 + } st_case_176: -//line msg_parse.go:6266 +//line msg_parse.go:6629 if 128 <= data[p] && data[p] <= 191 { goto tr259 } @@ -6286,9 +6649,11 @@ tr261: goto st177 st177: - p++ + if p++; p == pe { + goto _test_eof177 + } st_case_177: -//line msg_parse.go:6292 +//line msg_parse.go:6657 if 128 <= data[p] && data[p] <= 191 { goto tr260 } @@ -6312,9 +6677,11 @@ tr262: goto st178 st178: - p++ + if p++; p == pe { + goto _test_eof178 + } st_case_178: -//line msg_parse.go:6318 +//line msg_parse.go:6685 if 128 <= data[p] && data[p] <= 191 { goto tr261 } @@ -6338,9 +6705,11 @@ tr263: goto st179 st179: - p++ + if p++; p == pe { + goto _test_eof179 + } st_case_179: -//line msg_parse.go:6344 +//line msg_parse.go:6713 if 128 <= data[p] && data[p] <= 191 { goto tr262 } @@ -6364,9 +6733,11 @@ tr264: goto st180 st180: - p++ + if p++; p == pe { + goto _test_eof180 + } st_case_180: -//line msg_parse.go:6370 +//line msg_parse.go:6741 if data[p] == 10 { goto tr265 } @@ -6379,9 +6750,11 @@ tr265: goto st181 st181: - p++ + if p++; p == pe { + goto _test_eof181 + } st_case_181: -//line msg_parse.go:6385 +//line msg_parse.go:6758 switch data[p] { case 9: goto tr256 @@ -6390,14 +6763,18 @@ tr265: } goto st0 st182: - p++ + if p++; p == pe { + goto _test_eof182 + } st_case_182: if data[p] == 10 { goto st183 } goto st0 st183: - p++ + if p++; p == pe { + goto _test_eof183 + } st_case_183: switch data[p] { case 9: @@ -6407,7 +6784,9 @@ tr265: } goto st0 st184: - p++ + if p++; p == pe { + goto _test_eof184 + } st_case_184: switch data[p] { case 9: @@ -6457,15 +6836,19 @@ tr224: goto st185 st185: - p++ + if p++; p == pe { + goto _test_eof185 + } st_case_185: -//line msg_parse.go:6463 +//line msg_parse.go:6844 if data[p] == 10 { goto st186 } goto st0 st186: - p++ + if p++; p == pe { + goto _test_eof186 + } st_case_186: switch data[p] { case 9: @@ -6475,7 +6858,9 @@ tr224: } goto st0 st187: - p++ + if p++; p == pe { + goto _test_eof187 + } st_case_187: switch data[p] { case 9: @@ -6491,7 +6876,9 @@ tr224: } goto st0 st188: - p++ + if p++; p == pe { + goto _test_eof188 + } st_case_188: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -6550,9 +6937,11 @@ tr329: goto st189 st189: - p++ + if p++; p == pe { + goto _test_eof189 + } st_case_189: -//line msg_parse.go:6556 +//line msg_parse.go:6945 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -6588,9 +6977,11 @@ tr330: goto st190 st190: - p++ + if p++; p == pe { + goto _test_eof190 + } st_case_190: -//line msg_parse.go:6594 +//line msg_parse.go:6985 switch { case data[p] > 90: if 97 <= data[p] && data[p] <= 122 { @@ -6607,9 +6998,11 @@ tr275: goto st191 st191: - p++ + if p++; p == pe { + goto _test_eof191 + } st_case_191: -//line msg_parse.go:6613 +//line msg_parse.go:7006 switch data[p] { case 43: goto st191 @@ -6635,7 +7028,9 @@ tr275: } goto st0 st192: - p++ + if p++; p == pe { + goto _test_eof192 + } st_case_192: switch data[p] { case 33: @@ -6663,7 +7058,9 @@ tr275: } goto st0 st193: - p++ + if p++; p == pe { + goto _test_eof193 + } st_case_193: switch data[p] { case 33: @@ -6698,9 +7095,11 @@ tr279: goto st194 st194: - p++ + if p++; p == pe { + goto _test_eof194 + } st_case_194: -//line msg_parse.go:6704 +//line msg_parse.go:7103 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -6724,7 +7123,9 @@ tr279: } goto st0 st195: - p++ + if p++; p == pe { + goto _test_eof195 + } st_case_195: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -6787,19 +7188,25 @@ tr293: {goto st280 } goto st770 st770: - p++ + if p++; p == pe { + goto _test_eof770 + } st_case_770: -//line msg_parse.go:6793 +//line msg_parse.go:7196 goto st0 st196: - p++ + if p++; p == pe { + goto _test_eof196 + } st_case_196: if data[p] == 10 { goto st197 } goto st0 st197: - p++ + if p++; p == pe { + goto _test_eof197 + } st_case_197: switch data[p] { case 9: @@ -6809,7 +7216,9 @@ tr293: } goto st0 st198: - p++ + if p++; p == pe { + goto _test_eof198 + } st_case_198: switch data[p] { case 9: @@ -6819,7 +7228,9 @@ tr293: } goto tr285 st199: - p++ + if p++; p == pe { + goto _test_eof199 + } st_case_199: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -6848,14 +7259,18 @@ tr293: } goto st0 st200: - p++ + if p++; p == pe { + goto _test_eof200 + } st_case_200: if data[p] == 10 { goto st201 } goto st0 st201: - p++ + if p++; p == pe { + goto _test_eof201 + } st_case_201: switch data[p] { case 9: @@ -6865,7 +7280,9 @@ tr293: } goto st0 st202: - p++ + if p++; p == pe { + goto _test_eof202 + } st_case_202: switch data[p] { case 9: @@ -6875,21 +7292,27 @@ tr293: } goto tr289 st203: - p++ + if p++; p == pe { + goto _test_eof203 + } st_case_203: if data[p] == 10 { goto tr293 } goto st0 st204: - p++ + if p++; p == pe { + goto _test_eof204 + } st_case_204: if data[p] == 10 { goto st205 } goto st0 st205: - p++ + if p++; p == pe { + goto _test_eof205 + } st_case_205: switch data[p] { case 9: @@ -6899,7 +7322,9 @@ tr293: } goto st0 st206: - p++ + if p++; p == pe { + goto _test_eof206 + } st_case_206: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -6924,14 +7349,18 @@ tr293: } goto st0 st207: - p++ + if p++; p == pe { + goto _test_eof207 + } st_case_207: if data[p] == 10 { goto st208 } goto st0 st208: - p++ + if p++; p == pe { + goto _test_eof208 + } st_case_208: switch data[p] { case 9: @@ -6941,7 +7370,9 @@ tr293: } goto st0 st209: - p++ + if p++; p == pe { + goto _test_eof209 + } st_case_209: switch data[p] { case 9: @@ -6971,15 +7402,19 @@ tr331: goto st210 st210: - p++ + if p++; p == pe { + goto _test_eof210 + } st_case_210: -//line msg_parse.go:6977 +//line msg_parse.go:7410 if data[p] == 10 { goto st211 } goto st0 st211: - p++ + if p++; p == pe { + goto _test_eof211 + } st_case_211: switch data[p] { case 9: @@ -6989,7 +7424,9 @@ tr331: } goto st0 st212: - p++ + if p++; p == pe { + goto _test_eof212 + } st_case_212: switch data[p] { case 9: @@ -7007,9 +7444,11 @@ tr271: goto st213 st213: - p++ + if p++; p == pe { + goto _test_eof213 + } st_case_213: -//line msg_parse.go:7013 +//line msg_parse.go:7452 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -7067,9 +7506,11 @@ tr304: } goto st214 st214: - p++ + if p++; p == pe { + goto _test_eof214 + } st_case_214: -//line msg_parse.go:7073 +//line msg_parse.go:7514 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -7129,15 +7570,19 @@ tr306: } goto st215 st215: - p++ + if p++; p == pe { + goto _test_eof215 + } st_case_215: -//line msg_parse.go:7135 +//line msg_parse.go:7578 if data[p] == 10 { goto st216 } goto st0 st216: - p++ + if p++; p == pe { + goto _test_eof216 + } st_case_216: switch data[p] { case 9: @@ -7157,9 +7602,11 @@ tr309: } goto st217 st217: - p++ + if p++; p == pe { + goto _test_eof217 + } st_case_217: -//line msg_parse.go:7163 +//line msg_parse.go:7610 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -7215,9 +7662,11 @@ tr272: goto st218 st218: - p++ + if p++; p == pe { + goto _test_eof218 + } st_case_218: -//line msg_parse.go:7221 +//line msg_parse.go:7670 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -7281,9 +7730,11 @@ tr320: goto st219 st219: - p++ + if p++; p == pe { + goto _test_eof219 + } st_case_219: -//line msg_parse.go:7287 +//line msg_parse.go:7738 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -7335,9 +7786,11 @@ tr312: goto st220 st220: - p++ + if p++; p == pe { + goto _test_eof220 + } st_case_220: -//line msg_parse.go:7341 +//line msg_parse.go:7794 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -7363,9 +7816,11 @@ tr313: goto st221 st221: - p++ + if p++; p == pe { + goto _test_eof221 + } st_case_221: -//line msg_parse.go:7369 +//line msg_parse.go:7824 switch { case data[p] < 11: if data[p] <= 9 { @@ -7398,9 +7853,11 @@ tr323: goto st222 st222: - p++ + if p++; p == pe { + goto _test_eof222 + } st_case_222: -//line msg_parse.go:7404 +//line msg_parse.go:7861 if 128 <= data[p] && data[p] <= 191 { goto tr320 } @@ -7424,9 +7881,11 @@ tr324: goto st223 st223: - p++ + if p++; p == pe { + goto _test_eof223 + } st_case_223: -//line msg_parse.go:7430 +//line msg_parse.go:7889 if 128 <= data[p] && data[p] <= 191 { goto tr323 } @@ -7450,9 +7909,11 @@ tr325: goto st224 st224: - p++ + if p++; p == pe { + goto _test_eof224 + } st_case_224: -//line msg_parse.go:7456 +//line msg_parse.go:7917 if 128 <= data[p] && data[p] <= 191 { goto tr324 } @@ -7476,9 +7937,11 @@ tr326: goto st225 st225: - p++ + if p++; p == pe { + goto _test_eof225 + } st_case_225: -//line msg_parse.go:7482 +//line msg_parse.go:7945 if 128 <= data[p] && data[p] <= 191 { goto tr325 } @@ -7502,9 +7965,11 @@ tr327: goto st226 st226: - p++ + if p++; p == pe { + goto _test_eof226 + } st_case_226: -//line msg_parse.go:7508 +//line msg_parse.go:7973 if 128 <= data[p] && data[p] <= 191 { goto tr326 } @@ -7528,9 +7993,11 @@ tr328: goto st227 st227: - p++ + if p++; p == pe { + goto _test_eof227 + } st_case_227: -//line msg_parse.go:7534 +//line msg_parse.go:8001 if data[p] == 10 { goto tr332 } @@ -7543,9 +8010,11 @@ tr332: goto st228 st228: - p++ + if p++; p == pe { + goto _test_eof228 + } st_case_228: -//line msg_parse.go:7549 +//line msg_parse.go:8018 switch data[p] { case 9: goto tr320 @@ -7554,7 +8023,9 @@ tr332: } goto st0 st229: - p++ + if p++; p == pe { + goto _test_eof229 + } st_case_229: switch { case data[p] > 90: @@ -7566,7 +8037,9 @@ tr332: } goto st0 st230: - p++ + if p++; p == pe { + goto _test_eof230 + } st_case_230: switch data[p] { case 43: @@ -7593,7 +8066,9 @@ tr332: } goto st0 st231: - p++ + if p++; p == pe { + goto _test_eof231 + } st_case_231: switch data[p] { case 33: @@ -7621,7 +8096,9 @@ tr332: } goto st0 st232: - p++ + if p++; p == pe { + goto _test_eof232 + } st_case_232: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -7675,9 +8152,11 @@ tr336: goto st233 st233: - p++ + if p++; p == pe { + goto _test_eof233 + } st_case_233: -//line msg_parse.go:7681 +//line msg_parse.go:8160 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -7699,7 +8178,9 @@ tr336: } goto st0 st234: - p++ + if p++; p == pe { + goto _test_eof234 + } st_case_234: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -7752,19 +8233,25 @@ tr349: {goto st153 } goto st771 st771: - p++ + if p++; p == pe { + goto _test_eof771 + } st_case_771: -//line msg_parse.go:7758 +//line msg_parse.go:8241 goto st0 st235: - p++ + if p++; p == pe { + goto _test_eof235 + } st_case_235: if data[p] == 10 { goto st236 } goto st0 st236: - p++ + if p++; p == pe { + goto _test_eof236 + } st_case_236: switch data[p] { case 9: @@ -7774,7 +8261,9 @@ tr349: } goto st0 st237: - p++ + if p++; p == pe { + goto _test_eof237 + } st_case_237: switch data[p] { case 9: @@ -7784,7 +8273,9 @@ tr349: } goto tr345 st238: - p++ + if p++; p == pe { + goto _test_eof238 + } st_case_238: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -7813,14 +8304,18 @@ tr349: } goto st0 st239: - p++ + if p++; p == pe { + goto _test_eof239 + } st_case_239: if data[p] == 10 { goto st240 } goto st0 st240: - p++ + if p++; p == pe { + goto _test_eof240 + } st_case_240: switch data[p] { case 9: @@ -7830,7 +8325,9 @@ tr349: } goto st0 st241: - p++ + if p++; p == pe { + goto _test_eof241 + } st_case_241: switch data[p] { case 9: @@ -7847,15 +8344,19 @@ tr340: goto st242 st242: - p++ + if p++; p == pe { + goto _test_eof242 + } st_case_242: -//line msg_parse.go:7853 +//line msg_parse.go:8352 if data[p] == 10 { goto st243 } goto st0 st243: - p++ + if p++; p == pe { + goto _test_eof243 + } st_case_243: switch data[p] { case 9: @@ -7865,7 +8366,9 @@ tr340: } goto st0 st244: - p++ + if p++; p == pe { + goto _test_eof244 + } st_case_244: switch data[p] { case 9: @@ -7886,9 +8389,11 @@ tr337: goto st245 st245: - p++ + if p++; p == pe { + goto _test_eof245 + } st_case_245: -//line msg_parse.go:7892 +//line msg_parse.go:8397 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -7950,9 +8455,11 @@ tr355: goto st246 st246: - p++ + if p++; p == pe { + goto _test_eof246 + } st_case_246: -//line msg_parse.go:7956 +//line msg_parse.go:8463 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -7999,9 +8506,11 @@ tr361: {goto st256 } goto st772 st772: - p++ + if p++; p == pe { + goto _test_eof772 + } st_case_772: -//line msg_parse.go:8005 +//line msg_parse.go:8514 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8036,15 +8545,19 @@ tr359: goto st247 st247: - p++ + if p++; p == pe { + goto _test_eof247 + } st_case_247: -//line msg_parse.go:8042 +//line msg_parse.go:8553 if data[p] == 10 { goto st248 } goto st0 st248: - p++ + if p++; p == pe { + goto _test_eof248 + } st_case_248: switch data[p] { case 9: @@ -8054,7 +8567,9 @@ tr359: } goto st0 st249: - p++ + if p++; p == pe { + goto _test_eof249 + } st_case_249: switch data[p] { case 9: @@ -8092,9 +8607,11 @@ tr366: {goto st153 } goto st773 st773: - p++ + if p++; p == pe { + goto _test_eof773 + } st_case_773: -//line msg_parse.go:8098 +//line msg_parse.go:8615 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8147,9 +8664,11 @@ tr338: goto st250 st250: - p++ + if p++; p == pe { + goto _test_eof250 + } st_case_250: -//line msg_parse.go:8153 +//line msg_parse.go:8672 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8211,9 +8730,11 @@ tr365: goto st251 st251: - p++ + if p++; p == pe { + goto _test_eof251 + } st_case_251: -//line msg_parse.go:8217 +//line msg_parse.go:8738 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8254,9 +8775,11 @@ tr371: {goto st153 } goto st774 st774: - p++ + if p++; p == pe { + goto _test_eof774 + } st_case_774: -//line msg_parse.go:8260 +//line msg_parse.go:8783 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8291,15 +8814,19 @@ tr369: goto st252 st252: - p++ + if p++; p == pe { + goto _test_eof252 + } st_case_252: -//line msg_parse.go:8297 +//line msg_parse.go:8822 if data[p] == 10 { goto st253 } goto st0 st253: - p++ + if p++; p == pe { + goto _test_eof253 + } st_case_253: switch data[p] { case 9: @@ -8309,7 +8836,9 @@ tr369: } goto st0 st254: - p++ + if p++; p == pe { + goto _test_eof254 + } st_case_254: switch data[p] { case 9: @@ -8337,9 +8866,11 @@ tr367: {goto st153 } goto st775 st775: - p++ + if p++; p == pe { + goto _test_eof775 + } st_case_775: -//line msg_parse.go:8343 +//line msg_parse.go:8874 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8414,9 +8945,11 @@ tr357: {goto st256 } goto st776 st776: - p++ + if p++; p == pe { + goto _test_eof776 + } st_case_776: -//line msg_parse.go:8420 +//line msg_parse.go:8953 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8505,9 +9038,11 @@ tr368: {goto st153 } goto st777 st777: - p++ + if p++; p == pe { + goto _test_eof777 + } st_case_777: -//line msg_parse.go:8511 +//line msg_parse.go:9046 if data[p] == 10 { goto tr375 } @@ -8517,9 +9052,11 @@ tr375: {goto st280 } goto st778 st778: - p++ + if p++; p == pe { + goto _test_eof778 + } st_case_778: -//line msg_parse.go:8523 +//line msg_parse.go:9060 goto st0 tr339: //line sip.rl:193 @@ -8529,15 +9066,19 @@ tr339: goto st255 st255: - p++ + if p++; p == pe { + goto _test_eof255 + } st_case_255: -//line msg_parse.go:8535 +//line msg_parse.go:9074 if data[p] == 10 { goto tr375 } goto st0 st256: - p++ + if p++; p == pe { + goto _test_eof256 + } st_case_256: switch data[p] { case 33: @@ -8587,9 +9128,11 @@ tr376: goto st257 st257: - p++ + if p++; p == pe { + goto _test_eof257 + } st_case_257: -//line msg_parse.go:8593 +//line msg_parse.go:9136 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8637,7 +9180,9 @@ tr376: } goto st0 st258: - p++ + if p++; p == pe { + goto _test_eof258 + } st_case_258: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -8727,19 +9272,25 @@ tr386: {goto st229 } goto st779 st779: - p++ + if p++; p == pe { + goto _test_eof779 + } st_case_779: -//line msg_parse.go:8733 +//line msg_parse.go:9280 goto st0 st259: - p++ + if p++; p == pe { + goto _test_eof259 + } st_case_259: if data[p] == 10 { goto st260 } goto st0 st260: - p++ + if p++; p == pe { + goto _test_eof260 + } st_case_260: switch data[p] { case 9: @@ -8749,7 +9300,9 @@ tr386: } goto st0 st261: - p++ + if p++; p == pe { + goto _test_eof261 + } st_case_261: switch data[p] { case 9: @@ -8797,9 +9350,11 @@ tr378: goto st262 st262: - p++ + if p++; p == pe { + goto _test_eof262 + } st_case_262: -//line msg_parse.go:8803 +//line msg_parse.go:9358 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8853,7 +9408,9 @@ tr378: } goto st0 st263: - p++ + if p++; p == pe { + goto _test_eof263 + } st_case_263: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -8904,9 +9461,11 @@ tr387: goto st264 st264: - p++ + if p++; p == pe { + goto _test_eof264 + } st_case_264: -//line msg_parse.go:8910 +//line msg_parse.go:9469 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -8956,9 +9515,11 @@ tr388: goto st265 st265: - p++ + if p++; p == pe { + goto _test_eof265 + } st_case_265: -//line msg_parse.go:8962 +//line msg_parse.go:9523 if 128 <= data[p] && data[p] <= 191 { goto st264 } @@ -8970,9 +9531,11 @@ tr389: goto st266 st266: - p++ + if p++; p == pe { + goto _test_eof266 + } st_case_266: -//line msg_parse.go:8976 +//line msg_parse.go:9539 if 128 <= data[p] && data[p] <= 191 { goto st265 } @@ -8984,9 +9547,11 @@ tr390: goto st267 st267: - p++ + if p++; p == pe { + goto _test_eof267 + } st_case_267: -//line msg_parse.go:8990 +//line msg_parse.go:9555 if 128 <= data[p] && data[p] <= 191 { goto st266 } @@ -8998,9 +9563,11 @@ tr391: goto st268 st268: - p++ + if p++; p == pe { + goto _test_eof268 + } st_case_268: -//line msg_parse.go:9004 +//line msg_parse.go:9571 if 128 <= data[p] && data[p] <= 191 { goto st267 } @@ -9012,9 +9579,11 @@ tr392: goto st269 st269: - p++ + if p++; p == pe { + goto _test_eof269 + } st_case_269: -//line msg_parse.go:9018 +//line msg_parse.go:9587 if 128 <= data[p] && data[p] <= 191 { goto st268 } @@ -9026,9 +9595,11 @@ tr393: goto st270 st270: - p++ + if p++; p == pe { + goto _test_eof270 + } st_case_270: -//line msg_parse.go:9032 +//line msg_parse.go:9603 if data[p] == 10 { goto tr403 } @@ -9050,9 +9621,11 @@ tr403: {goto st280 } goto st780 st780: - p++ + if p++; p == pe { + goto _test_eof780 + } st_case_780: -//line msg_parse.go:9056 +//line msg_parse.go:9629 goto st0 tr394: //line sip.rl:62 @@ -9061,15 +9634,19 @@ tr394: goto st271 st271: - p++ + if p++; p == pe { + goto _test_eof271 + } st_case_271: -//line msg_parse.go:9067 +//line msg_parse.go:9642 if data[p] == 10 { goto st272 } goto st0 st272: - p++ + if p++; p == pe { + goto _test_eof272 + } st_case_272: switch data[p] { case 9: @@ -9079,7 +9656,9 @@ tr394: } goto st0 st273: - p++ + if p++; p == pe { + goto _test_eof273 + } st_case_273: switch data[p] { case 33: @@ -9115,7 +9694,9 @@ tr394: } goto st0 st274: - p++ + if p++; p == pe { + goto _test_eof274 + } st_case_274: switch data[p] { case 9: @@ -9163,9 +9744,11 @@ tr406: goto st275 st275: - p++ + if p++; p == pe { + goto _test_eof275 + } st_case_275: -//line msg_parse.go:9169 +//line msg_parse.go:9752 switch data[p] { case 9: goto st275 @@ -9182,9 +9765,11 @@ tr407: goto st276 st276: - p++ + if p++; p == pe { + goto _test_eof276 + } st_case_276: -//line msg_parse.go:9188 +//line msg_parse.go:9773 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -9223,19 +9808,25 @@ value=nil {goto st263 } goto st781 st781: - p++ + if p++; p == pe { + goto _test_eof781 + } st_case_781: -//line msg_parse.go:9229 +//line msg_parse.go:9816 goto st0 st277: - p++ + if p++; p == pe { + goto _test_eof277 + } st_case_277: if data[p] == 10 { goto st278 } goto st0 st278: - p++ + if p++; p == pe { + goto _test_eof278 + } st_case_278: switch data[p] { case 9: @@ -9245,7 +9836,9 @@ value=nil } goto st0 st279: - p++ + if p++; p == pe { + goto _test_eof279 + } st_case_279: switch data[p] { case 9: @@ -9255,7 +9848,9 @@ value=nil } goto tr410 st280: - p++ + if p++; p == pe { + goto _test_eof280 + } st_case_280: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -9311,9 +9906,11 @@ tr414: goto st281 st281: - p++ + if p++; p == pe { + goto _test_eof281 + } st_case_281: -//line msg_parse.go:9317 +//line msg_parse.go:9914 switch data[p] { case 65: goto st282 @@ -9390,7 +9987,9 @@ tr414: } goto tr416 st282: - p++ + if p++; p == pe { + goto _test_eof282 + } st_case_282: switch data[p] { case 9: @@ -9564,9 +10163,11 @@ tr999: value=&msg.WWWAuthenticate goto st283 st283: - p++ + if p++; p == pe { + goto _test_eof283 + } st_case_283: -//line msg_parse.go:9570 +//line msg_parse.go:10171 switch data[p] { case 9: goto st283 @@ -9727,9 +10328,11 @@ tr1000: value=&msg.WWWAuthenticate goto st284 st284: - p++ + if p++; p == pe { + goto _test_eof284 + } st_case_284: -//line msg_parse.go:9733 +//line msg_parse.go:10336 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -9809,19 +10412,25 @@ tr1001: goto st782 st782: - p++ + if p++; p == pe { + goto _test_eof782 + } st_case_782: -//line msg_parse.go:9815 +//line msg_parse.go:10420 goto st0 st285: - p++ + if p++; p == pe { + goto _test_eof285 + } st_case_285: if data[p] == 10 { goto st286 } goto st0 st286: - p++ + if p++; p == pe { + goto _test_eof286 + } st_case_286: switch data[p] { case 9: @@ -9831,7 +10440,9 @@ tr1001: } goto st0 st287: - p++ + if p++; p == pe { + goto _test_eof287 + } st_case_287: switch data[p] { case 9: @@ -9841,7 +10452,9 @@ tr1001: } goto tr442 st288: - p++ + if p++; p == pe { + goto _test_eof288 + } st_case_288: switch data[p] { case 67: @@ -9851,7 +10464,9 @@ tr1001: } goto tr416 st289: - p++ + if p++; p == pe { + goto _test_eof289 + } st_case_289: switch data[p] { case 69: @@ -9861,7 +10476,9 @@ tr1001: } goto tr416 st290: - p++ + if p++; p == pe { + goto _test_eof290 + } st_case_290: switch data[p] { case 80: @@ -9871,7 +10488,9 @@ tr1001: } goto tr416 st291: - p++ + if p++; p == pe { + goto _test_eof291 + } st_case_291: switch data[p] { case 84: @@ -9881,7 +10500,9 @@ tr1001: } goto tr416 st292: - p++ + if p++; p == pe { + goto _test_eof292 + } st_case_292: switch data[p] { case 9: @@ -9895,7 +10516,9 @@ tr1001: } goto tr416 st293: - p++ + if p++; p == pe { + goto _test_eof293 + } st_case_293: switch data[p] { case 67: @@ -9913,7 +10536,9 @@ tr1001: } goto tr416 st294: - p++ + if p++; p == pe { + goto _test_eof294 + } st_case_294: switch data[p] { case 79: @@ -9923,7 +10548,9 @@ tr1001: } goto tr416 st295: - p++ + if p++; p == pe { + goto _test_eof295 + } st_case_295: switch data[p] { case 78: @@ -9933,7 +10560,9 @@ tr1001: } goto tr416 st296: - p++ + if p++; p == pe { + goto _test_eof296 + } st_case_296: switch data[p] { case 84: @@ -9943,7 +10572,9 @@ tr1001: } goto tr416 st297: - p++ + if p++; p == pe { + goto _test_eof297 + } st_case_297: switch data[p] { case 65: @@ -9953,7 +10584,9 @@ tr1001: } goto tr416 st298: - p++ + if p++; p == pe { + goto _test_eof298 + } st_case_298: switch data[p] { case 67: @@ -9963,7 +10596,9 @@ tr1001: } goto tr416 st299: - p++ + if p++; p == pe { + goto _test_eof299 + } st_case_299: switch data[p] { case 84: @@ -9973,7 +10608,9 @@ tr1001: } goto tr416 st300: - p++ + if p++; p == pe { + goto _test_eof300 + } st_case_300: switch data[p] { case 9: @@ -9985,7 +10622,9 @@ tr1001: } goto tr416 st301: - p++ + if p++; p == pe { + goto _test_eof301 + } st_case_301: switch data[p] { case 78: @@ -9995,7 +10634,9 @@ tr1001: } goto tr416 st302: - p++ + if p++; p == pe { + goto _test_eof302 + } st_case_302: switch data[p] { case 67: @@ -10005,7 +10646,9 @@ tr1001: } goto tr416 st303: - p++ + if p++; p == pe { + goto _test_eof303 + } st_case_303: switch data[p] { case 79: @@ -10015,7 +10658,9 @@ tr1001: } goto tr416 st304: - p++ + if p++; p == pe { + goto _test_eof304 + } st_case_304: switch data[p] { case 68: @@ -10025,7 +10670,9 @@ tr1001: } goto tr416 st305: - p++ + if p++; p == pe { + goto _test_eof305 + } st_case_305: switch data[p] { case 73: @@ -10035,7 +10682,9 @@ tr1001: } goto tr416 st306: - p++ + if p++; p == pe { + goto _test_eof306 + } st_case_306: switch data[p] { case 78: @@ -10045,7 +10694,9 @@ tr1001: } goto tr416 st307: - p++ + if p++; p == pe { + goto _test_eof307 + } st_case_307: switch data[p] { case 71: @@ -10055,7 +10706,9 @@ tr1001: } goto tr416 st308: - p++ + if p++; p == pe { + goto _test_eof308 + } st_case_308: switch data[p] { case 9: @@ -10067,7 +10720,9 @@ tr1001: } goto tr416 st309: - p++ + if p++; p == pe { + goto _test_eof309 + } st_case_309: switch data[p] { case 65: @@ -10077,7 +10732,9 @@ tr1001: } goto tr416 st310: - p++ + if p++; p == pe { + goto _test_eof310 + } st_case_310: switch data[p] { case 78: @@ -10087,7 +10744,9 @@ tr1001: } goto tr416 st311: - p++ + if p++; p == pe { + goto _test_eof311 + } st_case_311: switch data[p] { case 71: @@ -10097,7 +10756,9 @@ tr1001: } goto tr416 st312: - p++ + if p++; p == pe { + goto _test_eof312 + } st_case_312: switch data[p] { case 85: @@ -10107,7 +10768,9 @@ tr1001: } goto tr416 st313: - p++ + if p++; p == pe { + goto _test_eof313 + } st_case_313: switch data[p] { case 65: @@ -10117,7 +10780,9 @@ tr1001: } goto tr416 st314: - p++ + if p++; p == pe { + goto _test_eof314 + } st_case_314: switch data[p] { case 71: @@ -10127,7 +10792,9 @@ tr1001: } goto tr416 st315: - p++ + if p++; p == pe { + goto _test_eof315 + } st_case_315: switch data[p] { case 69: @@ -10137,7 +10804,9 @@ tr1001: } goto tr416 st316: - p++ + if p++; p == pe { + goto _test_eof316 + } st_case_316: switch data[p] { case 9: @@ -10149,7 +10818,9 @@ tr1001: } goto tr416 st317: - p++ + if p++; p == pe { + goto _test_eof317 + } st_case_317: switch data[p] { case 69: @@ -10163,7 +10834,9 @@ tr1001: } goto tr416 st318: - p++ + if p++; p == pe { + goto _test_eof318 + } st_case_318: switch data[p] { case 82: @@ -10173,7 +10846,9 @@ tr1001: } goto tr416 st319: - p++ + if p++; p == pe { + goto _test_eof319 + } st_case_319: switch data[p] { case 84: @@ -10183,14 +10858,18 @@ tr1001: } goto tr416 st320: - p++ + if p++; p == pe { + goto _test_eof320 + } st_case_320: if data[p] == 45 { goto st321 } goto tr416 st321: - p++ + if p++; p == pe { + goto _test_eof321 + } st_case_321: switch data[p] { case 73: @@ -10200,7 +10879,9 @@ tr1001: } goto tr416 st322: - p++ + if p++; p == pe { + goto _test_eof322 + } st_case_322: switch data[p] { case 78: @@ -10210,7 +10891,9 @@ tr1001: } goto tr416 st323: - p++ + if p++; p == pe { + goto _test_eof323 + } st_case_323: switch data[p] { case 70: @@ -10220,7 +10903,9 @@ tr1001: } goto tr416 st324: - p++ + if p++; p == pe { + goto _test_eof324 + } st_case_324: switch data[p] { case 79: @@ -10230,7 +10915,9 @@ tr1001: } goto tr416 st325: - p++ + if p++; p == pe { + goto _test_eof325 + } st_case_325: switch data[p] { case 9: @@ -10242,7 +10929,9 @@ tr1001: } goto tr416 st326: - p++ + if p++; p == pe { + goto _test_eof326 + } st_case_326: switch data[p] { case 79: @@ -10252,7 +10941,9 @@ tr1001: } goto tr416 st327: - p++ + if p++; p == pe { + goto _test_eof327 + } st_case_327: switch data[p] { case 87: @@ -10262,7 +10953,9 @@ tr1001: } goto tr416 st328: - p++ + if p++; p == pe { + goto _test_eof328 + } st_case_328: switch data[p] { case 9: @@ -10276,7 +10969,9 @@ tr1001: } goto tr416 st329: - p++ + if p++; p == pe { + goto _test_eof329 + } st_case_329: switch data[p] { case 69: @@ -10286,7 +10981,9 @@ tr1001: } goto tr416 st330: - p++ + if p++; p == pe { + goto _test_eof330 + } st_case_330: switch data[p] { case 86: @@ -10296,7 +10993,9 @@ tr1001: } goto tr416 st331: - p++ + if p++; p == pe { + goto _test_eof331 + } st_case_331: switch data[p] { case 69: @@ -10306,7 +11005,9 @@ tr1001: } goto tr416 st332: - p++ + if p++; p == pe { + goto _test_eof332 + } st_case_332: switch data[p] { case 78: @@ -10316,7 +11017,9 @@ tr1001: } goto tr416 st333: - p++ + if p++; p == pe { + goto _test_eof333 + } st_case_333: switch data[p] { case 84: @@ -10326,7 +11029,9 @@ tr1001: } goto tr416 st334: - p++ + if p++; p == pe { + goto _test_eof334 + } st_case_334: switch data[p] { case 83: @@ -10336,7 +11041,9 @@ tr1001: } goto tr416 st335: - p++ + if p++; p == pe { + goto _test_eof335 + } st_case_335: switch data[p] { case 9: @@ -10348,7 +11055,9 @@ tr1001: } goto tr416 st336: - p++ + if p++; p == pe { + goto _test_eof336 + } st_case_336: switch data[p] { case 84: @@ -10358,7 +11067,9 @@ tr1001: } goto tr416 st337: - p++ + if p++; p == pe { + goto _test_eof337 + } st_case_337: switch data[p] { case 72: @@ -10368,7 +11079,9 @@ tr1001: } goto tr416 st338: - p++ + if p++; p == pe { + goto _test_eof338 + } st_case_338: switch data[p] { case 69: @@ -10382,7 +11095,9 @@ tr1001: } goto tr416 st339: - p++ + if p++; p == pe { + goto _test_eof339 + } st_case_339: switch data[p] { case 78: @@ -10392,7 +11107,9 @@ tr1001: } goto tr416 st340: - p++ + if p++; p == pe { + goto _test_eof340 + } st_case_340: switch data[p] { case 84: @@ -10402,7 +11119,9 @@ tr1001: } goto tr416 st341: - p++ + if p++; p == pe { + goto _test_eof341 + } st_case_341: switch data[p] { case 73: @@ -10412,7 +11131,9 @@ tr1001: } goto tr416 st342: - p++ + if p++; p == pe { + goto _test_eof342 + } st_case_342: switch data[p] { case 67: @@ -10422,7 +11143,9 @@ tr1001: } goto tr416 st343: - p++ + if p++; p == pe { + goto _test_eof343 + } st_case_343: switch data[p] { case 65: @@ -10432,7 +11155,9 @@ tr1001: } goto tr416 st344: - p++ + if p++; p == pe { + goto _test_eof344 + } st_case_344: switch data[p] { case 84: @@ -10442,7 +11167,9 @@ tr1001: } goto tr416 st345: - p++ + if p++; p == pe { + goto _test_eof345 + } st_case_345: switch data[p] { case 73: @@ -10452,7 +11179,9 @@ tr1001: } goto tr416 st346: - p++ + if p++; p == pe { + goto _test_eof346 + } st_case_346: switch data[p] { case 79: @@ -10462,7 +11191,9 @@ tr1001: } goto tr416 st347: - p++ + if p++; p == pe { + goto _test_eof347 + } st_case_347: switch data[p] { case 78: @@ -10472,14 +11203,18 @@ tr1001: } goto tr416 st348: - p++ + if p++; p == pe { + goto _test_eof348 + } st_case_348: if data[p] == 45 { goto st349 } goto tr416 st349: - p++ + if p++; p == pe { + goto _test_eof349 + } st_case_349: switch data[p] { case 73: @@ -10489,7 +11224,9 @@ tr1001: } goto tr416 st350: - p++ + if p++; p == pe { + goto _test_eof350 + } st_case_350: switch data[p] { case 78: @@ -10499,7 +11236,9 @@ tr1001: } goto tr416 st351: - p++ + if p++; p == pe { + goto _test_eof351 + } st_case_351: switch data[p] { case 70: @@ -10509,7 +11248,9 @@ tr1001: } goto tr416 st352: - p++ + if p++; p == pe { + goto _test_eof352 + } st_case_352: switch data[p] { case 79: @@ -10519,7 +11260,9 @@ tr1001: } goto tr416 st353: - p++ + if p++; p == pe { + goto _test_eof353 + } st_case_353: switch data[p] { case 9: @@ -10531,7 +11274,9 @@ tr1001: } goto tr416 st354: - p++ + if p++; p == pe { + goto _test_eof354 + } st_case_354: switch data[p] { case 82: @@ -10541,7 +11286,9 @@ tr1001: } goto tr416 st355: - p++ + if p++; p == pe { + goto _test_eof355 + } st_case_355: switch data[p] { case 73: @@ -10551,7 +11298,9 @@ tr1001: } goto tr416 st356: - p++ + if p++; p == pe { + goto _test_eof356 + } st_case_356: switch data[p] { case 90: @@ -10561,7 +11310,9 @@ tr1001: } goto tr416 st357: - p++ + if p++; p == pe { + goto _test_eof357 + } st_case_357: switch data[p] { case 65: @@ -10571,7 +11322,9 @@ tr1001: } goto tr416 st358: - p++ + if p++; p == pe { + goto _test_eof358 + } st_case_358: switch data[p] { case 84: @@ -10581,7 +11334,9 @@ tr1001: } goto tr416 st359: - p++ + if p++; p == pe { + goto _test_eof359 + } st_case_359: switch data[p] { case 73: @@ -10591,7 +11346,9 @@ tr1001: } goto tr416 st360: - p++ + if p++; p == pe { + goto _test_eof360 + } st_case_360: switch data[p] { case 79: @@ -10601,7 +11358,9 @@ tr1001: } goto tr416 st361: - p++ + if p++; p == pe { + goto _test_eof361 + } st_case_361: switch data[p] { case 78: @@ -10611,7 +11370,9 @@ tr1001: } goto tr416 st362: - p++ + if p++; p == pe { + goto _test_eof362 + } st_case_362: switch data[p] { case 9: @@ -10623,7 +11384,9 @@ tr1001: } goto tr416 st363: - p++ + if p++; p == pe { + goto _test_eof363 + } st_case_363: switch data[p] { case 9: @@ -10635,7 +11398,9 @@ tr1001: } goto tr416 st364: - p++ + if p++; p == pe { + goto _test_eof364 + } st_case_364: switch data[p] { case 9: @@ -10659,7 +11424,9 @@ tr1001: } goto tr416 st365: - p++ + if p++; p == pe { + goto _test_eof365 + } st_case_365: switch data[p] { case 9: @@ -10671,7 +11438,9 @@ tr1001: } goto st0 st366: - p++ + if p++; p == pe { + goto _test_eof366 + } st_case_366: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -10700,14 +11469,18 @@ tr1001: } goto st0 st367: - p++ + if p++; p == pe { + goto _test_eof367 + } st_case_367: if data[p] == 10 { goto st368 } goto st0 st368: - p++ + if p++; p == pe { + goto _test_eof368 + } st_case_368: switch data[p] { case 9: @@ -10717,7 +11490,9 @@ tr1001: } goto st0 st369: - p++ + if p++; p == pe { + goto _test_eof369 + } st_case_369: switch data[p] { case 9: @@ -10727,7 +11502,9 @@ tr1001: } goto tr541 st370: - p++ + if p++; p == pe { + goto _test_eof370 + } st_case_370: switch data[p] { case 76: @@ -10737,7 +11514,9 @@ tr1001: } goto tr416 st371: - p++ + if p++; p == pe { + goto _test_eof371 + } st_case_371: switch data[p] { case 76: @@ -10747,14 +11526,18 @@ tr1001: } goto tr416 st372: - p++ + if p++; p == pe { + goto _test_eof372 + } st_case_372: if data[p] == 45 { goto st373 } goto tr416 st373: - p++ + if p++; p == pe { + goto _test_eof373 + } st_case_373: switch data[p] { case 73: @@ -10764,7 +11547,9 @@ tr1001: } goto tr416 st374: - p++ + if p++; p == pe { + goto _test_eof374 + } st_case_374: switch data[p] { case 68: @@ -10778,7 +11563,9 @@ tr1001: } goto tr416 st375: - p++ + if p++; p == pe { + goto _test_eof375 + } st_case_375: switch data[p] { case 9: @@ -10790,7 +11577,9 @@ tr1001: } goto tr416 st376: - p++ + if p++; p == pe { + goto _test_eof376 + } st_case_376: switch data[p] { case 9: @@ -10802,7 +11591,9 @@ tr1001: } goto st0 st377: - p++ + if p++; p == pe { + goto _test_eof377 + } st_case_377: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -10861,9 +11652,11 @@ tr553: goto st378 st378: - p++ + if p++; p == pe { + goto _test_eof378 + } st_case_378: -//line msg_parse.go:10867 +//line msg_parse.go:11660 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -10909,7 +11702,9 @@ tr553: } goto st0 st379: - p++ + if p++; p == pe { + goto _test_eof379 + } st_case_379: switch data[p] { case 37: @@ -10949,7 +11744,9 @@ tr553: } goto st0 st380: - p++ + if p++; p == pe { + goto _test_eof380 + } st_case_380: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -11010,22 +11807,28 @@ tr643: goto st381 st381: - p++ + if p++; p == pe { + goto _test_eof381 + } st_case_381: -//line msg_parse.go:11016 +//line msg_parse.go:11815 if data[p] == 10 { goto tr559 } goto st0 st382: - p++ + if p++; p == pe { + goto _test_eof382 + } st_case_382: if data[p] == 10 { goto st383 } goto st0 st383: - p++ + if p++; p == pe { + goto _test_eof383 + } st_case_383: switch data[p] { case 9: @@ -11035,7 +11838,9 @@ tr643: } goto st0 st384: - p++ + if p++; p == pe { + goto _test_eof384 + } st_case_384: switch data[p] { case 9: @@ -11079,7 +11884,9 @@ tr643: } goto st0 st385: - p++ + if p++; p == pe { + goto _test_eof385 + } st_case_385: switch data[p] { case 70: @@ -11089,7 +11896,9 @@ tr643: } goto tr416 st386: - p++ + if p++; p == pe { + goto _test_eof386 + } st_case_386: switch data[p] { case 79: @@ -11099,7 +11908,9 @@ tr643: } goto tr416 st387: - p++ + if p++; p == pe { + goto _test_eof387 + } st_case_387: switch data[p] { case 9: @@ -11111,7 +11922,9 @@ tr643: } goto tr416 st388: - p++ + if p++; p == pe { + goto _test_eof388 + } st_case_388: switch data[p] { case 78: @@ -11121,7 +11934,9 @@ tr643: } goto tr416 st389: - p++ + if p++; p == pe { + goto _test_eof389 + } st_case_389: switch data[p] { case 84: @@ -11131,7 +11946,9 @@ tr643: } goto tr416 st390: - p++ + if p++; p == pe { + goto _test_eof390 + } st_case_390: switch data[p] { case 65: @@ -11145,7 +11962,9 @@ tr643: } goto tr416 st391: - p++ + if p++; p == pe { + goto _test_eof391 + } st_case_391: switch data[p] { case 67: @@ -11155,7 +11974,9 @@ tr643: } goto tr416 st392: - p++ + if p++; p == pe { + goto _test_eof392 + } st_case_392: switch data[p] { case 84: @@ -11165,7 +11986,9 @@ tr643: } goto tr416 st393: - p++ + if p++; p == pe { + goto _test_eof393 + } st_case_393: switch data[p] { case 9: @@ -11205,9 +12028,11 @@ tr930: addrp=lastAddr(&msg.To) goto st394 st394: - p++ + if p++; p == pe { + goto _test_eof394 + } st_case_394: -//line msg_parse.go:11211 +//line msg_parse.go:12036 switch data[p] { case 9: goto st394 @@ -11246,9 +12071,11 @@ tr931: addrp=lastAddr(&msg.To) goto st395 st395: - p++ + if p++; p == pe { + goto _test_eof395 + } st_case_395: -//line msg_parse.go:11252 +//line msg_parse.go:12079 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -11276,14 +12103,18 @@ addrp=lastAddr(&msg.To) } goto st0 st396: - p++ + if p++; p == pe { + goto _test_eof396 + } st_case_396: if data[p] == 10 { goto st397 } goto st0 st397: - p++ + if p++; p == pe { + goto _test_eof397 + } st_case_397: switch data[p] { case 9: @@ -11293,7 +12124,9 @@ addrp=lastAddr(&msg.To) } goto st0 st398: - p++ + if p++; p == pe { + goto _test_eof398 + } st_case_398: switch data[p] { case 9: @@ -11303,7 +12136,9 @@ addrp=lastAddr(&msg.To) } goto tr576 st399: - p++ + if p++; p == pe { + goto _test_eof399 + } st_case_399: switch data[p] { case 78: @@ -11313,7 +12148,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st400: - p++ + if p++; p == pe { + goto _test_eof400 + } st_case_400: switch data[p] { case 84: @@ -11323,14 +12160,18 @@ addrp=lastAddr(&msg.To) } goto tr416 st401: - p++ + if p++; p == pe { + goto _test_eof401 + } st_case_401: if data[p] == 45 { goto st402 } goto tr416 st402: - p++ + if p++; p == pe { + goto _test_eof402 + } st_case_402: switch data[p] { case 68: @@ -11352,7 +12193,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st403: - p++ + if p++; p == pe { + goto _test_eof403 + } st_case_403: switch data[p] { case 73: @@ -11362,7 +12205,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st404: - p++ + if p++; p == pe { + goto _test_eof404 + } st_case_404: switch data[p] { case 83: @@ -11372,7 +12217,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st405: - p++ + if p++; p == pe { + goto _test_eof405 + } st_case_405: switch data[p] { case 80: @@ -11382,7 +12229,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st406: - p++ + if p++; p == pe { + goto _test_eof406 + } st_case_406: switch data[p] { case 79: @@ -11392,7 +12241,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st407: - p++ + if p++; p == pe { + goto _test_eof407 + } st_case_407: switch data[p] { case 83: @@ -11402,7 +12253,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st408: - p++ + if p++; p == pe { + goto _test_eof408 + } st_case_408: switch data[p] { case 73: @@ -11412,7 +12265,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st409: - p++ + if p++; p == pe { + goto _test_eof409 + } st_case_409: switch data[p] { case 84: @@ -11422,7 +12277,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st410: - p++ + if p++; p == pe { + goto _test_eof410 + } st_case_410: switch data[p] { case 73: @@ -11432,7 +12289,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st411: - p++ + if p++; p == pe { + goto _test_eof411 + } st_case_411: switch data[p] { case 79: @@ -11442,7 +12301,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st412: - p++ + if p++; p == pe { + goto _test_eof412 + } st_case_412: switch data[p] { case 78: @@ -11452,7 +12313,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st413: - p++ + if p++; p == pe { + goto _test_eof413 + } st_case_413: switch data[p] { case 9: @@ -11464,7 +12327,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st414: - p++ + if p++; p == pe { + goto _test_eof414 + } st_case_414: switch data[p] { case 78: @@ -11474,7 +12339,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st415: - p++ + if p++; p == pe { + goto _test_eof415 + } st_case_415: switch data[p] { case 67: @@ -11484,7 +12351,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st416: - p++ + if p++; p == pe { + goto _test_eof416 + } st_case_416: switch data[p] { case 79: @@ -11494,7 +12363,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st417: - p++ + if p++; p == pe { + goto _test_eof417 + } st_case_417: switch data[p] { case 68: @@ -11504,7 +12375,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st418: - p++ + if p++; p == pe { + goto _test_eof418 + } st_case_418: switch data[p] { case 73: @@ -11514,7 +12387,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st419: - p++ + if p++; p == pe { + goto _test_eof419 + } st_case_419: switch data[p] { case 78: @@ -11524,7 +12399,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st420: - p++ + if p++; p == pe { + goto _test_eof420 + } st_case_420: switch data[p] { case 71: @@ -11534,7 +12411,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st421: - p++ + if p++; p == pe { + goto _test_eof421 + } st_case_421: switch data[p] { case 9: @@ -11546,7 +12425,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st422: - p++ + if p++; p == pe { + goto _test_eof422 + } st_case_422: switch data[p] { case 65: @@ -11560,7 +12441,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st423: - p++ + if p++; p == pe { + goto _test_eof423 + } st_case_423: switch data[p] { case 78: @@ -11570,7 +12453,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st424: - p++ + if p++; p == pe { + goto _test_eof424 + } st_case_424: switch data[p] { case 71: @@ -11580,7 +12465,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st425: - p++ + if p++; p == pe { + goto _test_eof425 + } st_case_425: switch data[p] { case 85: @@ -11590,7 +12477,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st426: - p++ + if p++; p == pe { + goto _test_eof426 + } st_case_426: switch data[p] { case 65: @@ -11600,7 +12489,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st427: - p++ + if p++; p == pe { + goto _test_eof427 + } st_case_427: switch data[p] { case 71: @@ -11610,7 +12501,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st428: - p++ + if p++; p == pe { + goto _test_eof428 + } st_case_428: switch data[p] { case 69: @@ -11620,7 +12513,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st429: - p++ + if p++; p == pe { + goto _test_eof429 + } st_case_429: switch data[p] { case 9: @@ -11632,7 +12527,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st430: - p++ + if p++; p == pe { + goto _test_eof430 + } st_case_430: switch data[p] { case 78: @@ -11642,7 +12539,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st431: - p++ + if p++; p == pe { + goto _test_eof431 + } st_case_431: switch data[p] { case 71: @@ -11652,7 +12551,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st432: - p++ + if p++; p == pe { + goto _test_eof432 + } st_case_432: switch data[p] { case 84: @@ -11662,7 +12563,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st433: - p++ + if p++; p == pe { + goto _test_eof433 + } st_case_433: switch data[p] { case 72: @@ -11672,7 +12575,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st434: - p++ + if p++; p == pe { + goto _test_eof434 + } st_case_434: switch data[p] { case 9: @@ -11684,7 +12589,9 @@ addrp=lastAddr(&msg.To) } goto tr416 st435: - p++ + if p++; p == pe { + goto _test_eof435 + } st_case_435: switch data[p] { case 9: @@ -11696,7 +12603,9 @@ addrp=lastAddr(&msg.To) } goto st0 st436: - p++ + if p++; p == pe { + goto _test_eof436 + } st_case_436: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -11732,9 +12641,11 @@ tr626: goto st437 st437: - p++ + if p++; p == pe { + goto _test_eof437 + } st_case_437: -//line msg_parse.go:11738 +//line msg_parse.go:12649 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -11750,14 +12661,18 @@ tr626: } goto st0 st438: - p++ + if p++; p == pe { + goto _test_eof438 + } st_case_438: if data[p] == 10 { goto st439 } goto st0 st439: - p++ + if p++; p == pe { + goto _test_eof439 + } st_case_439: switch data[p] { case 9: @@ -11767,7 +12682,9 @@ tr626: } goto st0 st440: - p++ + if p++; p == pe { + goto _test_eof440 + } st_case_440: switch data[p] { case 9: @@ -11780,7 +12697,9 @@ tr626: } goto st0 st441: - p++ + if p++; p == pe { + goto _test_eof441 + } st_case_441: switch data[p] { case 89: @@ -11790,7 +12709,9 @@ tr626: } goto tr416 st442: - p++ + if p++; p == pe { + goto _test_eof442 + } st_case_442: switch data[p] { case 80: @@ -11800,7 +12721,9 @@ tr626: } goto tr416 st443: - p++ + if p++; p == pe { + goto _test_eof443 + } st_case_443: switch data[p] { case 69: @@ -11810,7 +12733,9 @@ tr626: } goto tr416 st444: - p++ + if p++; p == pe { + goto _test_eof444 + } st_case_444: switch data[p] { case 9: @@ -11822,7 +12747,9 @@ tr626: } goto tr416 st445: - p++ + if p++; p == pe { + goto _test_eof445 + } st_case_445: switch data[p] { case 69: @@ -11832,7 +12759,9 @@ tr626: } goto tr416 st446: - p++ + if p++; p == pe { + goto _test_eof446 + } st_case_446: switch data[p] { case 81: @@ -11842,7 +12771,9 @@ tr626: } goto tr416 st447: - p++ + if p++; p == pe { + goto _test_eof447 + } st_case_447: switch data[p] { case 9: @@ -11854,7 +12785,9 @@ tr626: } goto tr416 st448: - p++ + if p++; p == pe { + goto _test_eof448 + } st_case_448: switch data[p] { case 9: @@ -11866,7 +12799,9 @@ tr626: } goto st0 st449: - p++ + if p++; p == pe { + goto _test_eof449 + } st_case_449: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -11894,9 +12829,11 @@ tr637: goto st450 st450: - p++ + if p++; p == pe { + goto _test_eof450 + } st_case_450: -//line msg_parse.go:11900 +//line msg_parse.go:12837 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -11917,7 +12854,9 @@ tr637: } goto st0 st451: - p++ + if p++; p == pe { + goto _test_eof451 + } st_case_451: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -11972,9 +12911,11 @@ tr641: goto st452 st452: - p++ + if p++; p == pe { + goto _test_eof452 + } st_case_452: -//line msg_parse.go:11978 +//line msg_parse.go:12919 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -12018,14 +12959,18 @@ tr641: } goto st0 st453: - p++ + if p++; p == pe { + goto _test_eof453 + } st_case_453: if data[p] == 10 { goto st454 } goto st0 st454: - p++ + if p++; p == pe { + goto _test_eof454 + } st_case_454: switch data[p] { case 9: @@ -12035,7 +12980,9 @@ tr641: } goto st0 st455: - p++ + if p++; p == pe { + goto _test_eof455 + } st_case_455: switch data[p] { case 9: @@ -12075,14 +13022,18 @@ tr641: } goto st0 st456: - p++ + if p++; p == pe { + goto _test_eof456 + } st_case_456: if data[p] == 10 { goto st457 } goto st0 st457: - p++ + if p++; p == pe { + goto _test_eof457 + } st_case_457: switch data[p] { case 9: @@ -12092,7 +13043,9 @@ tr641: } goto st0 st458: - p++ + if p++; p == pe { + goto _test_eof458 + } st_case_458: switch data[p] { case 9: @@ -12105,7 +13058,9 @@ tr641: } goto st0 st459: - p++ + if p++; p == pe { + goto _test_eof459 + } st_case_459: switch data[p] { case 65: @@ -12115,7 +13070,9 @@ tr641: } goto tr416 st460: - p++ + if p++; p == pe { + goto _test_eof460 + } st_case_460: switch data[p] { case 84: @@ -12125,7 +13082,9 @@ tr641: } goto tr416 st461: - p++ + if p++; p == pe { + goto _test_eof461 + } st_case_461: switch data[p] { case 69: @@ -12135,7 +13094,9 @@ tr641: } goto tr416 st462: - p++ + if p++; p == pe { + goto _test_eof462 + } st_case_462: switch data[p] { case 9: @@ -12147,7 +13108,9 @@ tr641: } goto tr416 st463: - p++ + if p++; p == pe { + goto _test_eof463 + } st_case_463: switch data[p] { case 9: @@ -12171,7 +13134,9 @@ tr641: } goto tr416 st464: - p++ + if p++; p == pe { + goto _test_eof464 + } st_case_464: switch data[p] { case 82: @@ -12181,7 +13146,9 @@ tr641: } goto tr416 st465: - p++ + if p++; p == pe { + goto _test_eof465 + } st_case_465: switch data[p] { case 79: @@ -12191,7 +13158,9 @@ tr641: } goto tr416 st466: - p++ + if p++; p == pe { + goto _test_eof466 + } st_case_466: switch data[p] { case 82: @@ -12201,14 +13170,18 @@ tr641: } goto tr416 st467: - p++ + if p++; p == pe { + goto _test_eof467 + } st_case_467: if data[p] == 45 { goto st468 } goto tr416 st468: - p++ + if p++; p == pe { + goto _test_eof468 + } st_case_468: switch data[p] { case 73: @@ -12218,7 +13191,9 @@ tr641: } goto tr416 st469: - p++ + if p++; p == pe { + goto _test_eof469 + } st_case_469: switch data[p] { case 78: @@ -12228,7 +13203,9 @@ tr641: } goto tr416 st470: - p++ + if p++; p == pe { + goto _test_eof470 + } st_case_470: switch data[p] { case 70: @@ -12238,7 +13215,9 @@ tr641: } goto tr416 st471: - p++ + if p++; p == pe { + goto _test_eof471 + } st_case_471: switch data[p] { case 79: @@ -12248,7 +13227,9 @@ tr641: } goto tr416 st472: - p++ + if p++; p == pe { + goto _test_eof472 + } st_case_472: switch data[p] { case 9: @@ -12260,7 +13241,9 @@ tr641: } goto tr416 st473: - p++ + if p++; p == pe { + goto _test_eof473 + } st_case_473: switch data[p] { case 69: @@ -12270,7 +13253,9 @@ tr641: } goto tr416 st474: - p++ + if p++; p == pe { + goto _test_eof474 + } st_case_474: switch data[p] { case 78: @@ -12280,7 +13265,9 @@ tr641: } goto tr416 st475: - p++ + if p++; p == pe { + goto _test_eof475 + } st_case_475: switch data[p] { case 84: @@ -12290,7 +13277,9 @@ tr641: } goto tr416 st476: - p++ + if p++; p == pe { + goto _test_eof476 + } st_case_476: switch data[p] { case 9: @@ -12302,7 +13291,9 @@ tr641: } goto tr416 st477: - p++ + if p++; p == pe { + goto _test_eof477 + } st_case_477: switch data[p] { case 80: @@ -12312,7 +13303,9 @@ tr641: } goto tr416 st478: - p++ + if p++; p == pe { + goto _test_eof478 + } st_case_478: switch data[p] { case 73: @@ -12322,7 +13315,9 @@ tr641: } goto tr416 st479: - p++ + if p++; p == pe { + goto _test_eof479 + } st_case_479: switch data[p] { case 82: @@ -12332,7 +13327,9 @@ tr641: } goto tr416 st480: - p++ + if p++; p == pe { + goto _test_eof480 + } st_case_480: switch data[p] { case 69: @@ -12342,7 +13339,9 @@ tr641: } goto tr416 st481: - p++ + if p++; p == pe { + goto _test_eof481 + } st_case_481: switch data[p] { case 83: @@ -12352,7 +13351,9 @@ tr641: } goto tr416 st482: - p++ + if p++; p == pe { + goto _test_eof482 + } st_case_482: switch data[p] { case 9: @@ -12364,7 +13365,9 @@ tr641: } goto tr416 st483: - p++ + if p++; p == pe { + goto _test_eof483 + } st_case_483: switch data[p] { case 9: @@ -12376,7 +13379,9 @@ tr641: } goto st0 st484: - p++ + if p++; p == pe { + goto _test_eof484 + } st_case_484: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -12412,9 +13417,11 @@ tr680: goto st485 st485: - p++ + if p++; p == pe { + goto _test_eof485 + } st_case_485: -//line msg_parse.go:12418 +//line msg_parse.go:13425 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -12430,14 +13437,18 @@ tr680: } goto st0 st486: - p++ + if p++; p == pe { + goto _test_eof486 + } st_case_486: if data[p] == 10 { goto st487 } goto st0 st487: - p++ + if p++; p == pe { + goto _test_eof487 + } st_case_487: switch data[p] { case 9: @@ -12447,7 +13458,9 @@ tr680: } goto st0 st488: - p++ + if p++; p == pe { + goto _test_eof488 + } st_case_488: switch data[p] { case 9: @@ -12460,7 +13473,9 @@ tr680: } goto st0 st489: - p++ + if p++; p == pe { + goto _test_eof489 + } st_case_489: switch data[p] { case 9: @@ -12476,7 +13491,9 @@ tr680: } goto tr416 st490: - p++ + if p++; p == pe { + goto _test_eof490 + } st_case_490: switch data[p] { case 79: @@ -12486,7 +13503,9 @@ tr680: } goto tr416 st491: - p++ + if p++; p == pe { + goto _test_eof491 + } st_case_491: switch data[p] { case 77: @@ -12496,7 +13515,9 @@ tr680: } goto tr416 st492: - p++ + if p++; p == pe { + goto _test_eof492 + } st_case_492: switch data[p] { case 9: @@ -12508,7 +13529,9 @@ tr680: } goto tr416 st493: - p++ + if p++; p == pe { + goto _test_eof493 + } st_case_493: switch data[p] { case 9: @@ -12524,14 +13547,18 @@ tr680: } goto tr416 st494: - p++ + if p++; p == pe { + goto _test_eof494 + } st_case_494: if data[p] == 45 { goto st495 } goto tr416 st495: - p++ + if p++; p == pe { + goto _test_eof495 + } st_case_495: switch data[p] { case 82: @@ -12541,7 +13568,9 @@ tr680: } goto tr416 st496: - p++ + if p++; p == pe { + goto _test_eof496 + } st_case_496: switch data[p] { case 69: @@ -12551,7 +13580,9 @@ tr680: } goto tr416 st497: - p++ + if p++; p == pe { + goto _test_eof497 + } st_case_497: switch data[p] { case 80: @@ -12561,7 +13592,9 @@ tr680: } goto tr416 st498: - p++ + if p++; p == pe { + goto _test_eof498 + } st_case_498: switch data[p] { case 76: @@ -12571,7 +13604,9 @@ tr680: } goto tr416 st499: - p++ + if p++; p == pe { + goto _test_eof499 + } st_case_499: switch data[p] { case 89: @@ -12581,14 +13616,18 @@ tr680: } goto tr416 st500: - p++ + if p++; p == pe { + goto _test_eof500 + } st_case_500: if data[p] == 45 { goto st501 } goto tr416 st501: - p++ + if p++; p == pe { + goto _test_eof501 + } st_case_501: switch data[p] { case 84: @@ -12598,7 +13637,9 @@ tr680: } goto tr416 st502: - p++ + if p++; p == pe { + goto _test_eof502 + } st_case_502: switch data[p] { case 79: @@ -12608,7 +13649,9 @@ tr680: } goto tr416 st503: - p++ + if p++; p == pe { + goto _test_eof503 + } st_case_503: switch data[p] { case 9: @@ -12620,7 +13663,9 @@ tr680: } goto tr416 st504: - p++ + if p++; p == pe { + goto _test_eof504 + } st_case_504: switch data[p] { case 9: @@ -12632,7 +13677,9 @@ tr680: } goto tr416 st505: - p++ + if p++; p == pe { + goto _test_eof505 + } st_case_505: switch data[p] { case 9: @@ -12644,7 +13691,9 @@ tr680: } goto tr416 st506: - p++ + if p++; p == pe { + goto _test_eof506 + } st_case_506: switch data[p] { case 9: @@ -12656,7 +13705,9 @@ tr680: } goto st0 st507: - p++ + if p++; p == pe { + goto _test_eof507 + } st_case_507: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -12722,9 +13773,11 @@ tr706: goto st508 st508: - p++ + if p++; p == pe { + goto _test_eof508 + } st_case_508: -//line msg_parse.go:12728 +//line msg_parse.go:13781 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -12740,14 +13793,18 @@ tr706: } goto st0 st509: - p++ + if p++; p == pe { + goto _test_eof509 + } st_case_509: if data[p] == 10 { goto st510 } goto st0 st510: - p++ + if p++; p == pe { + goto _test_eof510 + } st_case_510: switch data[p] { case 9: @@ -12757,7 +13814,9 @@ tr706: } goto st0 st511: - p++ + if p++; p == pe { + goto _test_eof511 + } st_case_511: switch data[p] { case 9: @@ -12770,7 +13829,9 @@ tr706: } goto st0 st512: - p++ + if p++; p == pe { + goto _test_eof512 + } st_case_512: switch data[p] { case 9: @@ -12790,7 +13851,9 @@ tr706: } goto tr416 st513: - p++ + if p++; p == pe { + goto _test_eof513 + } st_case_513: switch data[p] { case 88: @@ -12800,14 +13863,18 @@ tr706: } goto tr416 st514: - p++ + if p++; p == pe { + goto _test_eof514 + } st_case_514: if data[p] == 45 { goto st515 } goto tr416 st515: - p++ + if p++; p == pe { + goto _test_eof515 + } st_case_515: switch data[p] { case 70: @@ -12817,7 +13884,9 @@ tr706: } goto tr416 st516: - p++ + if p++; p == pe { + goto _test_eof516 + } st_case_516: switch data[p] { case 79: @@ -12827,7 +13896,9 @@ tr706: } goto tr416 st517: - p++ + if p++; p == pe { + goto _test_eof517 + } st_case_517: switch data[p] { case 82: @@ -12837,7 +13908,9 @@ tr706: } goto tr416 st518: - p++ + if p++; p == pe { + goto _test_eof518 + } st_case_518: switch data[p] { case 87: @@ -12847,7 +13920,9 @@ tr706: } goto tr416 st519: - p++ + if p++; p == pe { + goto _test_eof519 + } st_case_519: switch data[p] { case 65: @@ -12857,7 +13932,9 @@ tr706: } goto tr416 st520: - p++ + if p++; p == pe { + goto _test_eof520 + } st_case_520: switch data[p] { case 82: @@ -12867,7 +13944,9 @@ tr706: } goto tr416 st521: - p++ + if p++; p == pe { + goto _test_eof521 + } st_case_521: switch data[p] { case 68: @@ -12877,7 +13956,9 @@ tr706: } goto tr416 st522: - p++ + if p++; p == pe { + goto _test_eof522 + } st_case_522: switch data[p] { case 83: @@ -12887,7 +13968,9 @@ tr706: } goto tr416 st523: - p++ + if p++; p == pe { + goto _test_eof523 + } st_case_523: switch data[p] { case 9: @@ -12899,7 +13982,9 @@ tr706: } goto tr416 st524: - p++ + if p++; p == pe { + goto _test_eof524 + } st_case_524: switch data[p] { case 9: @@ -12911,7 +13996,9 @@ tr706: } goto st0 st525: - p++ + if p++; p == pe { + goto _test_eof525 + } st_case_525: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -12947,9 +14034,11 @@ tr725: goto st526 st526: - p++ + if p++; p == pe { + goto _test_eof526 + } st_case_526: -//line msg_parse.go:12953 +//line msg_parse.go:14042 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -12965,14 +14054,18 @@ tr725: } goto st0 st527: - p++ + if p++; p == pe { + goto _test_eof527 + } st_case_527: if data[p] == 10 { goto st528 } goto st0 st528: - p++ + if p++; p == pe { + goto _test_eof528 + } st_case_528: switch data[p] { case 9: @@ -12982,7 +14075,9 @@ tr725: } goto st0 st529: - p++ + if p++; p == pe { + goto _test_eof529 + } st_case_529: switch data[p] { case 9: @@ -12995,7 +14090,9 @@ tr725: } goto st0 st530: - p++ + if p++; p == pe { + goto _test_eof530 + } st_case_530: switch data[p] { case 77: @@ -13009,7 +14106,9 @@ tr725: } goto tr416 st531: - p++ + if p++; p == pe { + goto _test_eof531 + } st_case_531: switch data[p] { case 69: @@ -13019,14 +14118,18 @@ tr725: } goto tr416 st532: - p++ + if p++; p == pe { + goto _test_eof532 + } st_case_532: if data[p] == 45 { goto st533 } goto tr416 st533: - p++ + if p++; p == pe { + goto _test_eof533 + } st_case_533: switch data[p] { case 86: @@ -13036,7 +14139,9 @@ tr725: } goto tr416 st534: - p++ + if p++; p == pe { + goto _test_eof534 + } st_case_534: switch data[p] { case 69: @@ -13046,7 +14151,9 @@ tr725: } goto tr416 st535: - p++ + if p++; p == pe { + goto _test_eof535 + } st_case_535: switch data[p] { case 82: @@ -13056,7 +14163,9 @@ tr725: } goto tr416 st536: - p++ + if p++; p == pe { + goto _test_eof536 + } st_case_536: switch data[p] { case 83: @@ -13066,7 +14175,9 @@ tr725: } goto tr416 st537: - p++ + if p++; p == pe { + goto _test_eof537 + } st_case_537: switch data[p] { case 73: @@ -13076,7 +14187,9 @@ tr725: } goto tr416 st538: - p++ + if p++; p == pe { + goto _test_eof538 + } st_case_538: switch data[p] { case 79: @@ -13086,7 +14199,9 @@ tr725: } goto tr416 st539: - p++ + if p++; p == pe { + goto _test_eof539 + } st_case_539: switch data[p] { case 78: @@ -13096,7 +14211,9 @@ tr725: } goto tr416 st540: - p++ + if p++; p == pe { + goto _test_eof540 + } st_case_540: switch data[p] { case 9: @@ -13108,14 +14225,18 @@ tr725: } goto tr416 st541: - p++ + if p++; p == pe { + goto _test_eof541 + } st_case_541: if data[p] == 45 { goto st542 } goto tr416 st542: - p++ + if p++; p == pe { + goto _test_eof542 + } st_case_542: switch data[p] { case 69: @@ -13125,7 +14246,9 @@ tr725: } goto tr416 st543: - p++ + if p++; p == pe { + goto _test_eof543 + } st_case_543: switch data[p] { case 88: @@ -13135,7 +14258,9 @@ tr725: } goto tr416 st544: - p++ + if p++; p == pe { + goto _test_eof544 + } st_case_544: switch data[p] { case 80: @@ -13145,7 +14270,9 @@ tr725: } goto tr416 st545: - p++ + if p++; p == pe { + goto _test_eof545 + } st_case_545: switch data[p] { case 73: @@ -13155,7 +14282,9 @@ tr725: } goto tr416 st546: - p++ + if p++; p == pe { + goto _test_eof546 + } st_case_546: switch data[p] { case 82: @@ -13165,7 +14294,9 @@ tr725: } goto tr416 st547: - p++ + if p++; p == pe { + goto _test_eof547 + } st_case_547: switch data[p] { case 69: @@ -13175,7 +14306,9 @@ tr725: } goto tr416 st548: - p++ + if p++; p == pe { + goto _test_eof548 + } st_case_548: switch data[p] { case 83: @@ -13185,7 +14318,9 @@ tr725: } goto tr416 st549: - p++ + if p++; p == pe { + goto _test_eof549 + } st_case_549: switch data[p] { case 9: @@ -13197,7 +14332,9 @@ tr725: } goto tr416 st550: - p++ + if p++; p == pe { + goto _test_eof550 + } st_case_550: switch data[p] { case 9: @@ -13209,7 +14346,9 @@ tr725: } goto st0 st551: - p++ + if p++; p == pe { + goto _test_eof551 + } st_case_551: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -13245,9 +14384,11 @@ tr753: goto st552 st552: - p++ + if p++; p == pe { + goto _test_eof552 + } st_case_552: -//line msg_parse.go:13251 +//line msg_parse.go:14392 _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { _widec = 256 + (int16(data[p]) - 0) @@ -13263,14 +14404,18 @@ tr753: } goto st0 st553: - p++ + if p++; p == pe { + goto _test_eof553 + } st_case_553: if data[p] == 10 { goto st554 } goto st0 st554: - p++ + if p++; p == pe { + goto _test_eof554 + } st_case_554: switch data[p] { case 9: @@ -13280,7 +14425,9 @@ tr753: } goto st0 st555: - p++ + if p++; p == pe { + goto _test_eof555 + } st_case_555: switch data[p] { case 9: @@ -13293,7 +14440,9 @@ tr753: } goto st0 st556: - p++ + if p++; p == pe { + goto _test_eof556 + } st_case_556: switch data[p] { case 9: @@ -13309,7 +14458,9 @@ tr753: } goto tr416 st557: - p++ + if p++; p == pe { + goto _test_eof557 + } st_case_557: switch data[p] { case 71: @@ -13319,7 +14470,9 @@ tr753: } goto tr416 st558: - p++ + if p++; p == pe { + goto _test_eof558 + } st_case_558: switch data[p] { case 65: @@ -13329,7 +14482,9 @@ tr753: } goto tr416 st559: - p++ + if p++; p == pe { + goto _test_eof559 + } st_case_559: switch data[p] { case 78: @@ -13339,7 +14494,9 @@ tr753: } goto tr416 st560: - p++ + if p++; p == pe { + goto _test_eof560 + } st_case_560: switch data[p] { case 73: @@ -13349,7 +14506,9 @@ tr753: } goto tr416 st561: - p++ + if p++; p == pe { + goto _test_eof561 + } st_case_561: switch data[p] { case 90: @@ -13359,7 +14518,9 @@ tr753: } goto tr416 st562: - p++ + if p++; p == pe { + goto _test_eof562 + } st_case_562: switch data[p] { case 65: @@ -13369,7 +14530,9 @@ tr753: } goto tr416 st563: - p++ + if p++; p == pe { + goto _test_eof563 + } st_case_563: switch data[p] { case 84: @@ -13379,7 +14542,9 @@ tr753: } goto tr416 st564: - p++ + if p++; p == pe { + goto _test_eof564 + } st_case_564: switch data[p] { case 73: @@ -13389,7 +14554,9 @@ tr753: } goto tr416 st565: - p++ + if p++; p == pe { + goto _test_eof565 + } st_case_565: switch data[p] { case 79: @@ -13399,7 +14566,9 @@ tr753: } goto tr416 st566: - p++ + if p++; p == pe { + goto _test_eof566 + } st_case_566: switch data[p] { case 78: @@ -13409,7 +14578,9 @@ tr753: } goto tr416 st567: - p++ + if p++; p == pe { + goto _test_eof567 + } st_case_567: switch data[p] { case 9: @@ -13421,7 +14592,9 @@ tr753: } goto tr416 st568: - p++ + if p++; p == pe { + goto _test_eof568 + } st_case_568: switch data[p] { case 45: @@ -13433,7 +14606,9 @@ tr753: } goto tr416 st569: - p++ + if p++; p == pe { + goto _test_eof569 + } st_case_569: switch data[p] { case 65: @@ -13443,7 +14618,9 @@ tr753: } goto tr416 st570: - p++ + if p++; p == pe { + goto _test_eof570 + } st_case_570: switch data[p] { case 83: @@ -13453,7 +14630,9 @@ tr753: } goto tr416 st571: - p++ + if p++; p == pe { + goto _test_eof571 + } st_case_571: switch data[p] { case 83: @@ -13463,7 +14642,9 @@ tr753: } goto tr416 st572: - p++ + if p++; p == pe { + goto _test_eof572 + } st_case_572: switch data[p] { case 69: @@ -13473,7 +14654,9 @@ tr753: } goto tr416 st573: - p++ + if p++; p == pe { + goto _test_eof573 + } st_case_573: switch data[p] { case 82: @@ -13483,7 +14666,9 @@ tr753: } goto tr416 st574: - p++ + if p++; p == pe { + goto _test_eof574 + } st_case_574: switch data[p] { case 84: @@ -13493,7 +14678,9 @@ tr753: } goto tr416 st575: - p++ + if p++; p == pe { + goto _test_eof575 + } st_case_575: switch data[p] { case 69: @@ -13503,7 +14690,9 @@ tr753: } goto tr416 st576: - p++ + if p++; p == pe { + goto _test_eof576 + } st_case_576: switch data[p] { case 68: @@ -13513,14 +14702,18 @@ tr753: } goto tr416 st577: - p++ + if p++; p == pe { + goto _test_eof577 + } st_case_577: if data[p] == 45 { goto st578 } goto tr416 st578: - p++ + if p++; p == pe { + goto _test_eof578 + } st_case_578: switch data[p] { case 73: @@ -13530,7 +14723,9 @@ tr753: } goto tr416 st579: - p++ + if p++; p == pe { + goto _test_eof579 + } st_case_579: switch data[p] { case 68: @@ -13540,7 +14735,9 @@ tr753: } goto tr416 st580: - p++ + if p++; p == pe { + goto _test_eof580 + } st_case_580: switch data[p] { case 69: @@ -13550,7 +14747,9 @@ tr753: } goto tr416 st581: - p++ + if p++; p == pe { + goto _test_eof581 + } st_case_581: switch data[p] { case 78: @@ -13560,7 +14759,9 @@ tr753: } goto tr416 st582: - p++ + if p++; p == pe { + goto _test_eof582 + } st_case_582: switch data[p] { case 84: @@ -13570,7 +14771,9 @@ tr753: } goto tr416 st583: - p++ + if p++; p == pe { + goto _test_eof583 + } st_case_583: switch data[p] { case 73: @@ -13580,7 +14783,9 @@ tr753: } goto tr416 st584: - p++ + if p++; p == pe { + goto _test_eof584 + } st_case_584: switch data[p] { case 84: @@ -13590,7 +14795,9 @@ tr753: } goto tr416 st585: - p++ + if p++; p == pe { + goto _test_eof585 + } st_case_585: switch data[p] { case 89: @@ -13600,7 +14807,9 @@ tr753: } goto tr416 st586: - p++ + if p++; p == pe { + goto _test_eof586 + } st_case_586: switch data[p] { case 9: @@ -13612,7 +14821,9 @@ tr753: } goto tr416 st587: - p++ + if p++; p == pe { + goto _test_eof587 + } st_case_587: switch data[p] { case 73: @@ -13626,7 +14837,9 @@ tr753: } goto tr416 st588: - p++ + if p++; p == pe { + goto _test_eof588 + } st_case_588: switch data[p] { case 79: @@ -13636,7 +14849,9 @@ tr753: } goto tr416 st589: - p++ + if p++; p == pe { + goto _test_eof589 + } st_case_589: switch data[p] { case 82: @@ -13646,7 +14861,9 @@ tr753: } goto tr416 st590: - p++ + if p++; p == pe { + goto _test_eof590 + } st_case_590: switch data[p] { case 73: @@ -13656,7 +14873,9 @@ tr753: } goto tr416 st591: - p++ + if p++; p == pe { + goto _test_eof591 + } st_case_591: switch data[p] { case 84: @@ -13666,7 +14885,9 @@ tr753: } goto tr416 st592: - p++ + if p++; p == pe { + goto _test_eof592 + } st_case_592: switch data[p] { case 89: @@ -13676,7 +14897,9 @@ tr753: } goto tr416 st593: - p++ + if p++; p == pe { + goto _test_eof593 + } st_case_593: switch data[p] { case 9: @@ -13688,7 +14911,9 @@ tr753: } goto tr416 st594: - p++ + if p++; p == pe { + goto _test_eof594 + } st_case_594: switch data[p] { case 88: @@ -13698,7 +14923,9 @@ tr753: } goto tr416 st595: - p++ + if p++; p == pe { + goto _test_eof595 + } st_case_595: switch data[p] { case 89: @@ -13708,14 +14935,18 @@ tr753: } goto tr416 st596: - p++ + if p++; p == pe { + goto _test_eof596 + } st_case_596: if data[p] == 45 { goto st597 } goto tr416 st597: - p++ + if p++; p == pe { + goto _test_eof597 + } st_case_597: switch data[p] { case 65: @@ -13729,7 +14960,9 @@ tr753: } goto tr416 st598: - p++ + if p++; p == pe { + goto _test_eof598 + } st_case_598: switch data[p] { case 85: @@ -13739,7 +14972,9 @@ tr753: } goto tr416 st599: - p++ + if p++; p == pe { + goto _test_eof599 + } st_case_599: switch data[p] { case 84: @@ -13749,7 +14984,9 @@ tr753: } goto tr416 st600: - p++ + if p++; p == pe { + goto _test_eof600 + } st_case_600: switch data[p] { case 72: @@ -13759,7 +14996,9 @@ tr753: } goto tr416 st601: - p++ + if p++; p == pe { + goto _test_eof601 + } st_case_601: switch data[p] { case 69: @@ -13773,7 +15012,9 @@ tr753: } goto tr416 st602: - p++ + if p++; p == pe { + goto _test_eof602 + } st_case_602: switch data[p] { case 78: @@ -13783,7 +15024,9 @@ tr753: } goto tr416 st603: - p++ + if p++; p == pe { + goto _test_eof603 + } st_case_603: switch data[p] { case 84: @@ -13793,7 +15036,9 @@ tr753: } goto tr416 st604: - p++ + if p++; p == pe { + goto _test_eof604 + } st_case_604: switch data[p] { case 73: @@ -13803,7 +15048,9 @@ tr753: } goto tr416 st605: - p++ + if p++; p == pe { + goto _test_eof605 + } st_case_605: switch data[p] { case 67: @@ -13813,7 +15060,9 @@ tr753: } goto tr416 st606: - p++ + if p++; p == pe { + goto _test_eof606 + } st_case_606: switch data[p] { case 65: @@ -13823,7 +15072,9 @@ tr753: } goto tr416 st607: - p++ + if p++; p == pe { + goto _test_eof607 + } st_case_607: switch data[p] { case 84: @@ -13833,7 +15084,9 @@ tr753: } goto tr416 st608: - p++ + if p++; p == pe { + goto _test_eof608 + } st_case_608: switch data[p] { case 69: @@ -13843,7 +15096,9 @@ tr753: } goto tr416 st609: - p++ + if p++; p == pe { + goto _test_eof609 + } st_case_609: switch data[p] { case 9: @@ -13855,7 +15110,9 @@ tr753: } goto tr416 st610: - p++ + if p++; p == pe { + goto _test_eof610 + } st_case_610: switch data[p] { case 82: @@ -13865,7 +15122,9 @@ tr753: } goto tr416 st611: - p++ + if p++; p == pe { + goto _test_eof611 + } st_case_611: switch data[p] { case 73: @@ -13875,7 +15134,9 @@ tr753: } goto tr416 st612: - p++ + if p++; p == pe { + goto _test_eof612 + } st_case_612: switch data[p] { case 90: @@ -13885,7 +15146,9 @@ tr753: } goto tr416 st613: - p++ + if p++; p == pe { + goto _test_eof613 + } st_case_613: switch data[p] { case 65: @@ -13895,7 +15158,9 @@ tr753: } goto tr416 st614: - p++ + if p++; p == pe { + goto _test_eof614 + } st_case_614: switch data[p] { case 84: @@ -13905,7 +15170,9 @@ tr753: } goto tr416 st615: - p++ + if p++; p == pe { + goto _test_eof615 + } st_case_615: switch data[p] { case 73: @@ -13915,7 +15182,9 @@ tr753: } goto tr416 st616: - p++ + if p++; p == pe { + goto _test_eof616 + } st_case_616: switch data[p] { case 79: @@ -13925,7 +15194,9 @@ tr753: } goto tr416 st617: - p++ + if p++; p == pe { + goto _test_eof617 + } st_case_617: switch data[p] { case 78: @@ -13935,7 +15206,9 @@ tr753: } goto tr416 st618: - p++ + if p++; p == pe { + goto _test_eof618 + } st_case_618: switch data[p] { case 9: @@ -13947,7 +15220,9 @@ tr753: } goto tr416 st619: - p++ + if p++; p == pe { + goto _test_eof619 + } st_case_619: switch data[p] { case 69: @@ -13957,7 +15232,9 @@ tr753: } goto tr416 st620: - p++ + if p++; p == pe { + goto _test_eof620 + } st_case_620: switch data[p] { case 81: @@ -13967,7 +15244,9 @@ tr753: } goto tr416 st621: - p++ + if p++; p == pe { + goto _test_eof621 + } st_case_621: switch data[p] { case 85: @@ -13977,7 +15256,9 @@ tr753: } goto tr416 st622: - p++ + if p++; p == pe { + goto _test_eof622 + } st_case_622: switch data[p] { case 73: @@ -13987,7 +15268,9 @@ tr753: } goto tr416 st623: - p++ + if p++; p == pe { + goto _test_eof623 + } st_case_623: switch data[p] { case 82: @@ -13997,7 +15280,9 @@ tr753: } goto tr416 st624: - p++ + if p++; p == pe { + goto _test_eof624 + } st_case_624: switch data[p] { case 69: @@ -14007,7 +15292,9 @@ tr753: } goto tr416 st625: - p++ + if p++; p == pe { + goto _test_eof625 + } st_case_625: switch data[p] { case 9: @@ -14019,7 +15306,9 @@ tr753: } goto tr416 st626: - p++ + if p++; p == pe { + goto _test_eof626 + } st_case_626: switch data[p] { case 9: @@ -14039,7 +15328,9 @@ tr753: } goto tr416 st627: - p++ + if p++; p == pe { + goto _test_eof627 + } st_case_627: switch data[p] { case 67: @@ -14069,7 +15360,9 @@ tr753: } goto tr416 st628: - p++ + if p++; p == pe { + goto _test_eof628 + } st_case_628: switch data[p] { case 79: @@ -14079,7 +15372,9 @@ tr753: } goto tr416 st629: - p++ + if p++; p == pe { + goto _test_eof629 + } st_case_629: switch data[p] { case 82: @@ -14089,7 +15384,9 @@ tr753: } goto tr416 st630: - p++ + if p++; p == pe { + goto _test_eof630 + } st_case_630: switch data[p] { case 68: @@ -14099,14 +15396,18 @@ tr753: } goto tr416 st631: - p++ + if p++; p == pe { + goto _test_eof631 + } st_case_631: if data[p] == 45 { goto st632 } goto tr416 st632: - p++ + if p++; p == pe { + goto _test_eof632 + } st_case_632: switch data[p] { case 82: @@ -14116,7 +15417,9 @@ tr753: } goto tr416 st633: - p++ + if p++; p == pe { + goto _test_eof633 + } st_case_633: switch data[p] { case 79: @@ -14126,7 +15429,9 @@ tr753: } goto tr416 st634: - p++ + if p++; p == pe { + goto _test_eof634 + } st_case_634: switch data[p] { case 85: @@ -14136,7 +15441,9 @@ tr753: } goto tr416 st635: - p++ + if p++; p == pe { + goto _test_eof635 + } st_case_635: switch data[p] { case 84: @@ -14146,7 +15453,9 @@ tr753: } goto tr416 st636: - p++ + if p++; p == pe { + goto _test_eof636 + } st_case_636: switch data[p] { case 69: @@ -14156,7 +15465,9 @@ tr753: } goto tr416 st637: - p++ + if p++; p == pe { + goto _test_eof637 + } st_case_637: switch data[p] { case 9: @@ -14168,7 +15479,9 @@ tr753: } goto tr416 st638: - p++ + if p++; p == pe { + goto _test_eof638 + } st_case_638: switch data[p] { case 69: @@ -14178,7 +15491,9 @@ tr753: } goto tr416 st639: - p++ + if p++; p == pe { + goto _test_eof639 + } st_case_639: switch data[p] { case 82: @@ -14188,7 +15503,9 @@ tr753: } goto tr416 st640: - p++ + if p++; p == pe { + goto _test_eof640 + } st_case_640: switch data[p] { case 45: @@ -14200,7 +15517,9 @@ tr753: } goto tr416 st641: - p++ + if p++; p == pe { + goto _test_eof641 + } st_case_641: switch data[p] { case 84: @@ -14210,7 +15529,9 @@ tr753: } goto tr416 st642: - p++ + if p++; p == pe { + goto _test_eof642 + } st_case_642: switch data[p] { case 79: @@ -14220,7 +15541,9 @@ tr753: } goto tr416 st643: - p++ + if p++; p == pe { + goto _test_eof643 + } st_case_643: switch data[p] { case 9: @@ -14232,7 +15555,9 @@ tr753: } goto tr416 st644: - p++ + if p++; p == pe { + goto _test_eof644 + } st_case_644: switch data[p] { case 69: @@ -14242,7 +15567,9 @@ tr753: } goto tr416 st645: - p++ + if p++; p == pe { + goto _test_eof645 + } st_case_645: switch data[p] { case 68: @@ -14252,14 +15579,18 @@ tr753: } goto tr416 st646: - p++ + if p++; p == pe { + goto _test_eof646 + } st_case_646: if data[p] == 45 { goto st647 } goto tr416 st647: - p++ + if p++; p == pe { + goto _test_eof647 + } st_case_647: switch data[p] { case 66: @@ -14269,7 +15600,9 @@ tr753: } goto tr416 st648: - p++ + if p++; p == pe { + goto _test_eof648 + } st_case_648: switch data[p] { case 89: @@ -14279,7 +15612,9 @@ tr753: } goto tr416 st649: - p++ + if p++; p == pe { + goto _test_eof649 + } st_case_649: switch data[p] { case 79: @@ -14289,7 +15624,9 @@ tr753: } goto tr416 st650: - p++ + if p++; p == pe { + goto _test_eof650 + } st_case_650: switch data[p] { case 84: @@ -14299,7 +15636,9 @@ tr753: } goto tr416 st651: - p++ + if p++; p == pe { + goto _test_eof651 + } st_case_651: switch data[p] { case 69: @@ -14309,14 +15648,18 @@ tr753: } goto tr416 st652: - p++ + if p++; p == pe { + goto _test_eof652 + } st_case_652: if data[p] == 45 { goto st653 } goto tr416 st653: - p++ + if p++; p == pe { + goto _test_eof653 + } st_case_653: switch data[p] { case 80: @@ -14326,7 +15669,9 @@ tr753: } goto tr416 st654: - p++ + if p++; p == pe { + goto _test_eof654 + } st_case_654: switch data[p] { case 65: @@ -14336,7 +15681,9 @@ tr753: } goto tr416 st655: - p++ + if p++; p == pe { + goto _test_eof655 + } st_case_655: switch data[p] { case 82: @@ -14346,7 +15693,9 @@ tr753: } goto tr416 st656: - p++ + if p++; p == pe { + goto _test_eof656 + } st_case_656: switch data[p] { case 84: @@ -14356,7 +15705,9 @@ tr753: } goto tr416 st657: - p++ + if p++; p == pe { + goto _test_eof657 + } st_case_657: switch data[p] { case 89: @@ -14366,14 +15717,18 @@ tr753: } goto tr416 st658: - p++ + if p++; p == pe { + goto _test_eof658 + } st_case_658: if data[p] == 45 { goto st659 } goto tr416 st659: - p++ + if p++; p == pe { + goto _test_eof659 + } st_case_659: switch data[p] { case 73: @@ -14383,7 +15738,9 @@ tr753: } goto tr416 st660: - p++ + if p++; p == pe { + goto _test_eof660 + } st_case_660: switch data[p] { case 68: @@ -14393,7 +15750,9 @@ tr753: } goto tr416 st661: - p++ + if p++; p == pe { + goto _test_eof661 + } st_case_661: switch data[p] { case 9: @@ -14405,7 +15764,9 @@ tr753: } goto tr416 st662: - p++ + if p++; p == pe { + goto _test_eof662 + } st_case_662: switch data[p] { case 76: @@ -14415,7 +15776,9 @@ tr753: } goto tr416 st663: - p++ + if p++; p == pe { + goto _test_eof663 + } st_case_663: switch data[p] { case 89: @@ -14425,14 +15788,18 @@ tr753: } goto tr416 st664: - p++ + if p++; p == pe { + goto _test_eof664 + } st_case_664: if data[p] == 45 { goto st665 } goto tr416 st665: - p++ + if p++; p == pe { + goto _test_eof665 + } st_case_665: switch data[p] { case 84: @@ -14442,7 +15809,9 @@ tr753: } goto tr416 st666: - p++ + if p++; p == pe { + goto _test_eof666 + } st_case_666: switch data[p] { case 79: @@ -14452,7 +15821,9 @@ tr753: } goto tr416 st667: - p++ + if p++; p == pe { + goto _test_eof667 + } st_case_667: switch data[p] { case 9: @@ -14464,7 +15835,9 @@ tr753: } goto tr416 st668: - p++ + if p++; p == pe { + goto _test_eof668 + } st_case_668: switch data[p] { case 85: @@ -14474,7 +15847,9 @@ tr753: } goto tr416 st669: - p++ + if p++; p == pe { + goto _test_eof669 + } st_case_669: switch data[p] { case 73: @@ -14484,7 +15859,9 @@ tr753: } goto tr416 st670: - p++ + if p++; p == pe { + goto _test_eof670 + } st_case_670: switch data[p] { case 82: @@ -14494,7 +15871,9 @@ tr753: } goto tr416 st671: - p++ + if p++; p == pe { + goto _test_eof671 + } st_case_671: switch data[p] { case 69: @@ -14504,7 +15883,9 @@ tr753: } goto tr416 st672: - p++ + if p++; p == pe { + goto _test_eof672 + } st_case_672: switch data[p] { case 9: @@ -14516,7 +15897,9 @@ tr753: } goto tr416 st673: - p++ + if p++; p == pe { + goto _test_eof673 + } st_case_673: switch data[p] { case 82: @@ -14526,7 +15909,9 @@ tr753: } goto tr416 st674: - p++ + if p++; p == pe { + goto _test_eof674 + } st_case_674: switch data[p] { case 89: @@ -14536,14 +15921,18 @@ tr753: } goto tr416 st675: - p++ + if p++; p == pe { + goto _test_eof675 + } st_case_675: if data[p] == 45 { goto st676 } goto tr416 st676: - p++ + if p++; p == pe { + goto _test_eof676 + } st_case_676: switch data[p] { case 65: @@ -14553,7 +15942,9 @@ tr753: } goto tr416 st677: - p++ + if p++; p == pe { + goto _test_eof677 + } st_case_677: switch data[p] { case 70: @@ -14563,7 +15954,9 @@ tr753: } goto tr416 st678: - p++ + if p++; p == pe { + goto _test_eof678 + } st_case_678: switch data[p] { case 84: @@ -14573,7 +15966,9 @@ tr753: } goto tr416 st679: - p++ + if p++; p == pe { + goto _test_eof679 + } st_case_679: switch data[p] { case 69: @@ -14583,7 +15978,9 @@ tr753: } goto tr416 st680: - p++ + if p++; p == pe { + goto _test_eof680 + } st_case_680: switch data[p] { case 82: @@ -14593,7 +15990,9 @@ tr753: } goto tr416 st681: - p++ + if p++; p == pe { + goto _test_eof681 + } st_case_681: switch data[p] { case 9: @@ -14605,7 +16004,9 @@ tr753: } goto tr416 st682: - p++ + if p++; p == pe { + goto _test_eof682 + } st_case_682: switch data[p] { case 85: @@ -14615,7 +16016,9 @@ tr753: } goto tr416 st683: - p++ + if p++; p == pe { + goto _test_eof683 + } st_case_683: switch data[p] { case 84: @@ -14625,7 +16028,9 @@ tr753: } goto tr416 st684: - p++ + if p++; p == pe { + goto _test_eof684 + } st_case_684: switch data[p] { case 69: @@ -14635,7 +16040,9 @@ tr753: } goto tr416 st685: - p++ + if p++; p == pe { + goto _test_eof685 + } st_case_685: switch data[p] { case 9: @@ -14647,7 +16054,9 @@ tr753: } goto tr416 st686: - p++ + if p++; p == pe { + goto _test_eof686 + } st_case_686: switch data[p] { case 9: @@ -14667,7 +16076,9 @@ tr753: } goto tr416 st687: - p++ + if p++; p == pe { + goto _test_eof687 + } st_case_687: switch data[p] { case 82: @@ -14677,7 +16088,9 @@ tr753: } goto tr416 st688: - p++ + if p++; p == pe { + goto _test_eof688 + } st_case_688: switch data[p] { case 86: @@ -14687,7 +16100,9 @@ tr753: } goto tr416 st689: - p++ + if p++; p == pe { + goto _test_eof689 + } st_case_689: switch data[p] { case 69: @@ -14697,7 +16112,9 @@ tr753: } goto tr416 st690: - p++ + if p++; p == pe { + goto _test_eof690 + } st_case_690: switch data[p] { case 82: @@ -14707,7 +16124,9 @@ tr753: } goto tr416 st691: - p++ + if p++; p == pe { + goto _test_eof691 + } st_case_691: switch data[p] { case 9: @@ -14719,7 +16138,9 @@ tr753: } goto tr416 st692: - p++ + if p++; p == pe { + goto _test_eof692 + } st_case_692: switch data[p] { case 66: @@ -14733,7 +16154,9 @@ tr753: } goto tr416 st693: - p++ + if p++; p == pe { + goto _test_eof693 + } st_case_693: switch data[p] { case 74: @@ -14743,7 +16166,9 @@ tr753: } goto tr416 st694: - p++ + if p++; p == pe { + goto _test_eof694 + } st_case_694: switch data[p] { case 69: @@ -14753,7 +16178,9 @@ tr753: } goto tr416 st695: - p++ + if p++; p == pe { + goto _test_eof695 + } st_case_695: switch data[p] { case 67: @@ -14763,7 +16190,9 @@ tr753: } goto tr416 st696: - p++ + if p++; p == pe { + goto _test_eof696 + } st_case_696: switch data[p] { case 84: @@ -14773,7 +16202,9 @@ tr753: } goto tr416 st697: - p++ + if p++; p == pe { + goto _test_eof697 + } st_case_697: switch data[p] { case 9: @@ -14785,7 +16216,9 @@ tr753: } goto tr416 st698: - p++ + if p++; p == pe { + goto _test_eof698 + } st_case_698: switch data[p] { case 80: @@ -14795,7 +16228,9 @@ tr753: } goto tr416 st699: - p++ + if p++; p == pe { + goto _test_eof699 + } st_case_699: switch data[p] { case 79: @@ -14805,7 +16240,9 @@ tr753: } goto tr416 st700: - p++ + if p++; p == pe { + goto _test_eof700 + } st_case_700: switch data[p] { case 82: @@ -14815,7 +16252,9 @@ tr753: } goto tr416 st701: - p++ + if p++; p == pe { + goto _test_eof701 + } st_case_701: switch data[p] { case 84: @@ -14825,7 +16264,9 @@ tr753: } goto tr416 st702: - p++ + if p++; p == pe { + goto _test_eof702 + } st_case_702: switch data[p] { case 69: @@ -14835,7 +16276,9 @@ tr753: } goto tr416 st703: - p++ + if p++; p == pe { + goto _test_eof703 + } st_case_703: switch data[p] { case 68: @@ -14845,7 +16288,9 @@ tr753: } goto tr416 st704: - p++ + if p++; p == pe { + goto _test_eof704 + } st_case_704: switch data[p] { case 9: @@ -14865,7 +16310,9 @@ tr753: } goto tr416 st705: - p++ + if p++; p == pe { + goto _test_eof705 + } st_case_705: switch data[p] { case 77: @@ -14875,7 +16322,9 @@ tr753: } goto tr416 st706: - p++ + if p++; p == pe { + goto _test_eof706 + } st_case_706: switch data[p] { case 69: @@ -14885,7 +16334,9 @@ tr753: } goto tr416 st707: - p++ + if p++; p == pe { + goto _test_eof707 + } st_case_707: switch data[p] { case 83: @@ -14895,7 +16346,9 @@ tr753: } goto tr416 st708: - p++ + if p++; p == pe { + goto _test_eof708 + } st_case_708: switch data[p] { case 84: @@ -14905,7 +16358,9 @@ tr753: } goto tr416 st709: - p++ + if p++; p == pe { + goto _test_eof709 + } st_case_709: switch data[p] { case 65: @@ -14915,7 +16370,9 @@ tr753: } goto tr416 st710: - p++ + if p++; p == pe { + goto _test_eof710 + } st_case_710: switch data[p] { case 77: @@ -14925,7 +16382,9 @@ tr753: } goto tr416 st711: - p++ + if p++; p == pe { + goto _test_eof711 + } st_case_711: switch data[p] { case 80: @@ -14935,7 +16394,9 @@ tr753: } goto tr416 st712: - p++ + if p++; p == pe { + goto _test_eof712 + } st_case_712: switch data[p] { case 9: @@ -14947,7 +16408,9 @@ tr753: } goto tr416 st713: - p++ + if p++; p == pe { + goto _test_eof713 + } st_case_713: switch data[p] { case 9: @@ -14959,7 +16422,9 @@ tr753: } goto tr416 st714: - p++ + if p++; p == pe { + goto _test_eof714 + } st_case_714: switch data[p] { case 9: @@ -14979,7 +16444,9 @@ tr753: } goto tr416 st715: - p++ + if p++; p == pe { + goto _test_eof715 + } st_case_715: switch data[p] { case 83: @@ -14989,7 +16456,9 @@ tr753: } goto tr416 st716: - p++ + if p++; p == pe { + goto _test_eof716 + } st_case_716: switch data[p] { case 85: @@ -14999,7 +16468,9 @@ tr753: } goto tr416 st717: - p++ + if p++; p == pe { + goto _test_eof717 + } st_case_717: switch data[p] { case 80: @@ -15009,7 +16480,9 @@ tr753: } goto tr416 st718: - p++ + if p++; p == pe { + goto _test_eof718 + } st_case_718: switch data[p] { case 80: @@ -15019,7 +16492,9 @@ tr753: } goto tr416 st719: - p++ + if p++; p == pe { + goto _test_eof719 + } st_case_719: switch data[p] { case 79: @@ -15029,7 +16504,9 @@ tr753: } goto tr416 st720: - p++ + if p++; p == pe { + goto _test_eof720 + } st_case_720: switch data[p] { case 82: @@ -15039,7 +16516,9 @@ tr753: } goto tr416 st721: - p++ + if p++; p == pe { + goto _test_eof721 + } st_case_721: switch data[p] { case 84: @@ -15049,7 +16528,9 @@ tr753: } goto tr416 st722: - p++ + if p++; p == pe { + goto _test_eof722 + } st_case_722: switch data[p] { case 69: @@ -15059,7 +16540,9 @@ tr753: } goto tr416 st723: - p++ + if p++; p == pe { + goto _test_eof723 + } st_case_723: switch data[p] { case 68: @@ -15069,7 +16552,9 @@ tr753: } goto tr416 st724: - p++ + if p++; p == pe { + goto _test_eof724 + } st_case_724: switch data[p] { case 9: @@ -15081,7 +16566,9 @@ tr753: } goto tr416 st725: - p++ + if p++; p == pe { + goto _test_eof725 + } st_case_725: switch data[p] { case 69: @@ -15091,7 +16578,9 @@ tr753: } goto tr416 st726: - p++ + if p++; p == pe { + goto _test_eof726 + } st_case_726: switch data[p] { case 82: @@ -15101,14 +16590,18 @@ tr753: } goto tr416 st727: - p++ + if p++; p == pe { + goto _test_eof727 + } st_case_727: if data[p] == 45 { goto st728 } goto tr416 st728: - p++ + if p++; p == pe { + goto _test_eof728 + } st_case_728: switch data[p] { case 65: @@ -15118,7 +16611,9 @@ tr753: } goto tr416 st729: - p++ + if p++; p == pe { + goto _test_eof729 + } st_case_729: switch data[p] { case 71: @@ -15128,7 +16623,9 @@ tr753: } goto tr416 st730: - p++ + if p++; p == pe { + goto _test_eof730 + } st_case_730: switch data[p] { case 69: @@ -15138,7 +16635,9 @@ tr753: } goto tr416 st731: - p++ + if p++; p == pe { + goto _test_eof731 + } st_case_731: switch data[p] { case 78: @@ -15148,7 +16647,9 @@ tr753: } goto tr416 st732: - p++ + if p++; p == pe { + goto _test_eof732 + } st_case_732: switch data[p] { case 84: @@ -15158,7 +16659,9 @@ tr753: } goto tr416 st733: - p++ + if p++; p == pe { + goto _test_eof733 + } st_case_733: switch data[p] { case 9: @@ -15170,7 +16673,9 @@ tr753: } goto tr416 st734: - p++ + if p++; p == pe { + goto _test_eof734 + } st_case_734: switch data[p] { case 9: @@ -15186,7 +16691,9 @@ tr753: } goto tr416 st735: - p++ + if p++; p == pe { + goto _test_eof735 + } st_case_735: switch data[p] { case 9: @@ -15198,7 +16705,9 @@ tr753: } goto st0 st736: - p++ + if p++; p == pe { + goto _test_eof736 + } st_case_736: _widec = int16(data[p]) if 13 <= data[p] && data[p] <= 13 { @@ -15227,14 +16736,18 @@ tr753: } goto st0 st737: - p++ + if p++; p == pe { + goto _test_eof737 + } st_case_737: if data[p] == 10 { goto st738 } goto st0 st738: - p++ + if p++; p == pe { + goto _test_eof738 + } st_case_738: switch data[p] { case 9: @@ -15244,7 +16757,9 @@ tr753: } goto st0 st739: - p++ + if p++; p == pe { + goto _test_eof739 + } st_case_739: switch data[p] { case 9: @@ -15254,7 +16769,9 @@ tr753: } goto tr971 st740: - p++ + if p++; p == pe { + goto _test_eof740 + } st_case_740: switch data[p] { case 65: @@ -15264,7 +16781,9 @@ tr753: } goto tr416 st741: - p++ + if p++; p == pe { + goto _test_eof741 + } st_case_741: switch data[p] { case 9: @@ -15276,7 +16795,9 @@ tr753: } goto tr416 st742: - p++ + if p++; p == pe { + goto _test_eof742 + } st_case_742: switch data[p] { case 65: @@ -15290,7 +16811,9 @@ tr753: } goto tr416 st743: - p++ + if p++; p == pe { + goto _test_eof743 + } st_case_743: switch data[p] { case 82: @@ -15300,7 +16823,9 @@ tr753: } goto tr416 st744: - p++ + if p++; p == pe { + goto _test_eof744 + } st_case_744: switch data[p] { case 78: @@ -15310,7 +16835,9 @@ tr753: } goto tr416 st745: - p++ + if p++; p == pe { + goto _test_eof745 + } st_case_745: switch data[p] { case 73: @@ -15320,7 +16847,9 @@ tr753: } goto tr416 st746: - p++ + if p++; p == pe { + goto _test_eof746 + } st_case_746: switch data[p] { case 78: @@ -15330,7 +16859,9 @@ tr753: } goto tr416 st747: - p++ + if p++; p == pe { + goto _test_eof747 + } st_case_747: switch data[p] { case 71: @@ -15340,7 +16871,9 @@ tr753: } goto tr416 st748: - p++ + if p++; p == pe { + goto _test_eof748 + } st_case_748: switch data[p] { case 9: @@ -15352,7 +16885,9 @@ tr753: } goto tr416 st749: - p++ + if p++; p == pe { + goto _test_eof749 + } st_case_749: switch data[p] { case 87: @@ -15362,14 +16897,18 @@ tr753: } goto tr416 st750: - p++ + if p++; p == pe { + goto _test_eof750 + } st_case_750: if data[p] == 45 { goto st751 } goto tr416 st751: - p++ + if p++; p == pe { + goto _test_eof751 + } st_case_751: switch data[p] { case 65: @@ -15379,7 +16918,9 @@ tr753: } goto tr416 st752: - p++ + if p++; p == pe { + goto _test_eof752 + } st_case_752: switch data[p] { case 85: @@ -15389,7 +16930,9 @@ tr753: } goto tr416 st753: - p++ + if p++; p == pe { + goto _test_eof753 + } st_case_753: switch data[p] { case 84: @@ -15399,7 +16942,9 @@ tr753: } goto tr416 st754: - p++ + if p++; p == pe { + goto _test_eof754 + } st_case_754: switch data[p] { case 72: @@ -15409,7 +16954,9 @@ tr753: } goto tr416 st755: - p++ + if p++; p == pe { + goto _test_eof755 + } st_case_755: switch data[p] { case 69: @@ -15419,7 +16966,9 @@ tr753: } goto tr416 st756: - p++ + if p++; p == pe { + goto _test_eof756 + } st_case_756: switch data[p] { case 78: @@ -15429,7 +16978,9 @@ tr753: } goto tr416 st757: - p++ + if p++; p == pe { + goto _test_eof757 + } st_case_757: switch data[p] { case 84: @@ -15439,7 +16990,9 @@ tr753: } goto tr416 st758: - p++ + if p++; p == pe { + goto _test_eof758 + } st_case_758: switch data[p] { case 73: @@ -15449,7 +17002,9 @@ tr753: } goto tr416 st759: - p++ + if p++; p == pe { + goto _test_eof759 + } st_case_759: switch data[p] { case 67: @@ -15459,7 +17014,9 @@ tr753: } goto tr416 st760: - p++ + if p++; p == pe { + goto _test_eof760 + } st_case_760: switch data[p] { case 65: @@ -15469,7 +17026,9 @@ tr753: } goto tr416 st761: - p++ + if p++; p == pe { + goto _test_eof761 + } st_case_761: switch data[p] { case 84: @@ -15479,7 +17038,9 @@ tr753: } goto tr416 st762: - p++ + if p++; p == pe { + goto _test_eof762 + } st_case_762: switch data[p] { case 69: @@ -15489,7 +17050,9 @@ tr753: } goto tr416 st763: - p++ + if p++; p == pe { + goto _test_eof763 + } st_case_763: switch data[p] { case 9: @@ -15501,14 +17064,798 @@ tr753: } goto tr416 st764: - p++ + if p++; p == pe { + goto _test_eof764 + } st_case_764: if data[p] == 10 { goto tr1001 } goto st0 st_out: - + _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_eof765: cs = 765; 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_eof766: cs = 766; 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_eof767: cs = 767; 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_eof768: cs = 768; 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_eof141: cs = 141; goto _test_eof + _test_eof142: cs = 142; goto _test_eof + _test_eof143: cs = 143; goto _test_eof + _test_eof144: cs = 144; goto _test_eof + _test_eof145: cs = 145; goto _test_eof + _test_eof146: cs = 146; goto _test_eof + _test_eof147: cs = 147; goto _test_eof + _test_eof148: cs = 148; goto _test_eof + _test_eof149: cs = 149; goto _test_eof + _test_eof150: cs = 150; goto _test_eof + _test_eof151: cs = 151; goto _test_eof + _test_eof152: cs = 152; goto _test_eof + _test_eof153: cs = 153; goto _test_eof + _test_eof154: cs = 154; goto _test_eof + _test_eof155: cs = 155; goto _test_eof + _test_eof156: cs = 156; goto _test_eof + _test_eof769: cs = 769; goto _test_eof + _test_eof157: cs = 157; goto _test_eof + _test_eof158: cs = 158; goto _test_eof + _test_eof159: cs = 159; goto _test_eof + _test_eof160: cs = 160; goto _test_eof + _test_eof161: cs = 161; goto _test_eof + _test_eof162: cs = 162; goto _test_eof + _test_eof163: cs = 163; goto _test_eof + _test_eof164: cs = 164; goto _test_eof + _test_eof165: cs = 165; goto _test_eof + _test_eof166: cs = 166; goto _test_eof + _test_eof167: cs = 167; goto _test_eof + _test_eof168: cs = 168; goto _test_eof + _test_eof169: cs = 169; goto _test_eof + _test_eof170: cs = 170; goto _test_eof + _test_eof171: cs = 171; goto _test_eof + _test_eof172: cs = 172; goto _test_eof + _test_eof173: cs = 173; goto _test_eof + _test_eof174: cs = 174; goto _test_eof + _test_eof175: cs = 175; goto _test_eof + _test_eof176: cs = 176; goto _test_eof + _test_eof177: cs = 177; goto _test_eof + _test_eof178: cs = 178; goto _test_eof + _test_eof179: cs = 179; goto _test_eof + _test_eof180: cs = 180; goto _test_eof + _test_eof181: cs = 181; goto _test_eof + _test_eof182: cs = 182; goto _test_eof + _test_eof183: cs = 183; goto _test_eof + _test_eof184: cs = 184; goto _test_eof + _test_eof185: cs = 185; goto _test_eof + _test_eof186: cs = 186; goto _test_eof + _test_eof187: cs = 187; goto _test_eof + _test_eof188: cs = 188; goto _test_eof + _test_eof189: cs = 189; goto _test_eof + _test_eof190: cs = 190; goto _test_eof + _test_eof191: cs = 191; goto _test_eof + _test_eof192: cs = 192; goto _test_eof + _test_eof193: cs = 193; goto _test_eof + _test_eof194: cs = 194; goto _test_eof + _test_eof195: cs = 195; goto _test_eof + _test_eof770: cs = 770; goto _test_eof + _test_eof196: cs = 196; goto _test_eof + _test_eof197: cs = 197; goto _test_eof + _test_eof198: cs = 198; goto _test_eof + _test_eof199: cs = 199; goto _test_eof + _test_eof200: cs = 200; goto _test_eof + _test_eof201: cs = 201; goto _test_eof + _test_eof202: cs = 202; goto _test_eof + _test_eof203: cs = 203; goto _test_eof + _test_eof204: cs = 204; goto _test_eof + _test_eof205: cs = 205; goto _test_eof + _test_eof206: cs = 206; goto _test_eof + _test_eof207: cs = 207; goto _test_eof + _test_eof208: cs = 208; goto _test_eof + _test_eof209: cs = 209; goto _test_eof + _test_eof210: cs = 210; goto _test_eof + _test_eof211: cs = 211; goto _test_eof + _test_eof212: cs = 212; goto _test_eof + _test_eof213: cs = 213; goto _test_eof + _test_eof214: cs = 214; goto _test_eof + _test_eof215: cs = 215; goto _test_eof + _test_eof216: cs = 216; goto _test_eof + _test_eof217: cs = 217; goto _test_eof + _test_eof218: cs = 218; goto _test_eof + _test_eof219: cs = 219; goto _test_eof + _test_eof220: cs = 220; goto _test_eof + _test_eof221: cs = 221; goto _test_eof + _test_eof222: cs = 222; goto _test_eof + _test_eof223: cs = 223; goto _test_eof + _test_eof224: cs = 224; goto _test_eof + _test_eof225: cs = 225; goto _test_eof + _test_eof226: cs = 226; goto _test_eof + _test_eof227: cs = 227; goto _test_eof + _test_eof228: cs = 228; goto _test_eof + _test_eof229: cs = 229; goto _test_eof + _test_eof230: cs = 230; goto _test_eof + _test_eof231: cs = 231; goto _test_eof + _test_eof232: cs = 232; goto _test_eof + _test_eof233: cs = 233; goto _test_eof + _test_eof234: cs = 234; goto _test_eof + _test_eof771: cs = 771; goto _test_eof + _test_eof235: cs = 235; goto _test_eof + _test_eof236: cs = 236; goto _test_eof + _test_eof237: cs = 237; goto _test_eof + _test_eof238: cs = 238; goto _test_eof + _test_eof239: cs = 239; goto _test_eof + _test_eof240: cs = 240; goto _test_eof + _test_eof241: cs = 241; goto _test_eof + _test_eof242: cs = 242; goto _test_eof + _test_eof243: cs = 243; goto _test_eof + _test_eof244: cs = 244; goto _test_eof + _test_eof245: cs = 245; goto _test_eof + _test_eof246: cs = 246; goto _test_eof + _test_eof772: cs = 772; goto _test_eof + _test_eof247: cs = 247; goto _test_eof + _test_eof248: cs = 248; goto _test_eof + _test_eof249: cs = 249; goto _test_eof + _test_eof773: cs = 773; goto _test_eof + _test_eof250: cs = 250; goto _test_eof + _test_eof251: cs = 251; goto _test_eof + _test_eof774: cs = 774; goto _test_eof + _test_eof252: cs = 252; goto _test_eof + _test_eof253: cs = 253; goto _test_eof + _test_eof254: cs = 254; goto _test_eof + _test_eof775: cs = 775; goto _test_eof + _test_eof776: cs = 776; goto _test_eof + _test_eof777: cs = 777; goto _test_eof + _test_eof778: cs = 778; goto _test_eof + _test_eof255: cs = 255; goto _test_eof + _test_eof256: cs = 256; goto _test_eof + _test_eof257: cs = 257; goto _test_eof + _test_eof258: cs = 258; goto _test_eof + _test_eof779: cs = 779; goto _test_eof + _test_eof259: cs = 259; goto _test_eof + _test_eof260: cs = 260; goto _test_eof + _test_eof261: cs = 261; goto _test_eof + _test_eof262: cs = 262; goto _test_eof + _test_eof263: cs = 263; goto _test_eof + _test_eof264: cs = 264; goto _test_eof + _test_eof265: cs = 265; goto _test_eof + _test_eof266: cs = 266; goto _test_eof + _test_eof267: cs = 267; goto _test_eof + _test_eof268: cs = 268; goto _test_eof + _test_eof269: cs = 269; goto _test_eof + _test_eof270: cs = 270; goto _test_eof + _test_eof780: cs = 780; goto _test_eof + _test_eof271: cs = 271; goto _test_eof + _test_eof272: cs = 272; goto _test_eof + _test_eof273: cs = 273; goto _test_eof + _test_eof274: cs = 274; goto _test_eof + _test_eof275: cs = 275; goto _test_eof + _test_eof276: cs = 276; goto _test_eof + _test_eof781: cs = 781; goto _test_eof + _test_eof277: cs = 277; goto _test_eof + _test_eof278: cs = 278; goto _test_eof + _test_eof279: cs = 279; goto _test_eof + _test_eof280: cs = 280; goto _test_eof + _test_eof281: cs = 281; goto _test_eof + _test_eof282: cs = 282; goto _test_eof + _test_eof283: cs = 283; goto _test_eof + _test_eof284: cs = 284; goto _test_eof + _test_eof782: cs = 782; goto _test_eof + _test_eof285: cs = 285; goto _test_eof + _test_eof286: cs = 286; goto _test_eof + _test_eof287: cs = 287; goto _test_eof + _test_eof288: cs = 288; goto _test_eof + _test_eof289: cs = 289; goto _test_eof + _test_eof290: cs = 290; goto _test_eof + _test_eof291: cs = 291; goto _test_eof + _test_eof292: cs = 292; goto _test_eof + _test_eof293: cs = 293; goto _test_eof + _test_eof294: cs = 294; goto _test_eof + _test_eof295: cs = 295; goto _test_eof + _test_eof296: cs = 296; goto _test_eof + _test_eof297: cs = 297; goto _test_eof + _test_eof298: cs = 298; goto _test_eof + _test_eof299: cs = 299; goto _test_eof + _test_eof300: cs = 300; goto _test_eof + _test_eof301: cs = 301; goto _test_eof + _test_eof302: cs = 302; goto _test_eof + _test_eof303: cs = 303; goto _test_eof + _test_eof304: cs = 304; goto _test_eof + _test_eof305: cs = 305; goto _test_eof + _test_eof306: cs = 306; goto _test_eof + _test_eof307: cs = 307; goto _test_eof + _test_eof308: cs = 308; goto _test_eof + _test_eof309: cs = 309; goto _test_eof + _test_eof310: cs = 310; goto _test_eof + _test_eof311: cs = 311; goto _test_eof + _test_eof312: cs = 312; goto _test_eof + _test_eof313: cs = 313; goto _test_eof + _test_eof314: cs = 314; goto _test_eof + _test_eof315: cs = 315; goto _test_eof + _test_eof316: cs = 316; goto _test_eof + _test_eof317: cs = 317; goto _test_eof + _test_eof318: cs = 318; goto _test_eof + _test_eof319: cs = 319; goto _test_eof + _test_eof320: cs = 320; goto _test_eof + _test_eof321: cs = 321; goto _test_eof + _test_eof322: cs = 322; goto _test_eof + _test_eof323: cs = 323; goto _test_eof + _test_eof324: cs = 324; goto _test_eof + _test_eof325: cs = 325; goto _test_eof + _test_eof326: cs = 326; goto _test_eof + _test_eof327: cs = 327; goto _test_eof + _test_eof328: cs = 328; goto _test_eof + _test_eof329: cs = 329; goto _test_eof + _test_eof330: cs = 330; goto _test_eof + _test_eof331: cs = 331; goto _test_eof + _test_eof332: cs = 332; goto _test_eof + _test_eof333: cs = 333; goto _test_eof + _test_eof334: cs = 334; goto _test_eof + _test_eof335: cs = 335; goto _test_eof + _test_eof336: cs = 336; goto _test_eof + _test_eof337: cs = 337; goto _test_eof + _test_eof338: cs = 338; goto _test_eof + _test_eof339: cs = 339; goto _test_eof + _test_eof340: cs = 340; goto _test_eof + _test_eof341: cs = 341; goto _test_eof + _test_eof342: cs = 342; goto _test_eof + _test_eof343: cs = 343; goto _test_eof + _test_eof344: cs = 344; goto _test_eof + _test_eof345: cs = 345; goto _test_eof + _test_eof346: cs = 346; goto _test_eof + _test_eof347: cs = 347; goto _test_eof + _test_eof348: cs = 348; goto _test_eof + _test_eof349: cs = 349; goto _test_eof + _test_eof350: cs = 350; goto _test_eof + _test_eof351: cs = 351; goto _test_eof + _test_eof352: cs = 352; goto _test_eof + _test_eof353: cs = 353; goto _test_eof + _test_eof354: cs = 354; goto _test_eof + _test_eof355: cs = 355; goto _test_eof + _test_eof356: cs = 356; goto _test_eof + _test_eof357: cs = 357; goto _test_eof + _test_eof358: cs = 358; goto _test_eof + _test_eof359: cs = 359; goto _test_eof + _test_eof360: cs = 360; goto _test_eof + _test_eof361: cs = 361; goto _test_eof + _test_eof362: cs = 362; goto _test_eof + _test_eof363: cs = 363; goto _test_eof + _test_eof364: cs = 364; goto _test_eof + _test_eof365: cs = 365; goto _test_eof + _test_eof366: cs = 366; goto _test_eof + _test_eof367: cs = 367; goto _test_eof + _test_eof368: cs = 368; goto _test_eof + _test_eof369: cs = 369; goto _test_eof + _test_eof370: cs = 370; goto _test_eof + _test_eof371: cs = 371; goto _test_eof + _test_eof372: cs = 372; goto _test_eof + _test_eof373: cs = 373; goto _test_eof + _test_eof374: cs = 374; goto _test_eof + _test_eof375: cs = 375; goto _test_eof + _test_eof376: cs = 376; goto _test_eof + _test_eof377: cs = 377; goto _test_eof + _test_eof378: cs = 378; goto _test_eof + _test_eof379: cs = 379; goto _test_eof + _test_eof380: cs = 380; goto _test_eof + _test_eof381: cs = 381; goto _test_eof + _test_eof382: cs = 382; goto _test_eof + _test_eof383: cs = 383; goto _test_eof + _test_eof384: cs = 384; goto _test_eof + _test_eof385: cs = 385; goto _test_eof + _test_eof386: cs = 386; goto _test_eof + _test_eof387: cs = 387; goto _test_eof + _test_eof388: cs = 388; goto _test_eof + _test_eof389: cs = 389; goto _test_eof + _test_eof390: cs = 390; goto _test_eof + _test_eof391: cs = 391; goto _test_eof + _test_eof392: cs = 392; goto _test_eof + _test_eof393: cs = 393; goto _test_eof + _test_eof394: cs = 394; goto _test_eof + _test_eof395: cs = 395; goto _test_eof + _test_eof396: cs = 396; goto _test_eof + _test_eof397: cs = 397; goto _test_eof + _test_eof398: cs = 398; goto _test_eof + _test_eof399: cs = 399; goto _test_eof + _test_eof400: cs = 400; goto _test_eof + _test_eof401: cs = 401; goto _test_eof + _test_eof402: cs = 402; goto _test_eof + _test_eof403: cs = 403; goto _test_eof + _test_eof404: cs = 404; goto _test_eof + _test_eof405: cs = 405; goto _test_eof + _test_eof406: cs = 406; goto _test_eof + _test_eof407: cs = 407; goto _test_eof + _test_eof408: cs = 408; goto _test_eof + _test_eof409: cs = 409; goto _test_eof + _test_eof410: cs = 410; goto _test_eof + _test_eof411: cs = 411; goto _test_eof + _test_eof412: cs = 412; goto _test_eof + _test_eof413: cs = 413; goto _test_eof + _test_eof414: cs = 414; goto _test_eof + _test_eof415: cs = 415; goto _test_eof + _test_eof416: cs = 416; goto _test_eof + _test_eof417: cs = 417; goto _test_eof + _test_eof418: cs = 418; goto _test_eof + _test_eof419: cs = 419; goto _test_eof + _test_eof420: cs = 420; goto _test_eof + _test_eof421: cs = 421; goto _test_eof + _test_eof422: cs = 422; goto _test_eof + _test_eof423: cs = 423; goto _test_eof + _test_eof424: cs = 424; goto _test_eof + _test_eof425: cs = 425; goto _test_eof + _test_eof426: cs = 426; goto _test_eof + _test_eof427: cs = 427; goto _test_eof + _test_eof428: cs = 428; goto _test_eof + _test_eof429: cs = 429; goto _test_eof + _test_eof430: cs = 430; goto _test_eof + _test_eof431: cs = 431; goto _test_eof + _test_eof432: cs = 432; goto _test_eof + _test_eof433: cs = 433; goto _test_eof + _test_eof434: cs = 434; goto _test_eof + _test_eof435: cs = 435; goto _test_eof + _test_eof436: cs = 436; goto _test_eof + _test_eof437: cs = 437; goto _test_eof + _test_eof438: cs = 438; goto _test_eof + _test_eof439: cs = 439; goto _test_eof + _test_eof440: cs = 440; goto _test_eof + _test_eof441: cs = 441; goto _test_eof + _test_eof442: cs = 442; goto _test_eof + _test_eof443: cs = 443; goto _test_eof + _test_eof444: cs = 444; goto _test_eof + _test_eof445: cs = 445; goto _test_eof + _test_eof446: cs = 446; goto _test_eof + _test_eof447: cs = 447; goto _test_eof + _test_eof448: cs = 448; goto _test_eof + _test_eof449: cs = 449; goto _test_eof + _test_eof450: cs = 450; goto _test_eof + _test_eof451: cs = 451; goto _test_eof + _test_eof452: cs = 452; goto _test_eof + _test_eof453: cs = 453; goto _test_eof + _test_eof454: cs = 454; goto _test_eof + _test_eof455: cs = 455; goto _test_eof + _test_eof456: cs = 456; goto _test_eof + _test_eof457: cs = 457; goto _test_eof + _test_eof458: cs = 458; goto _test_eof + _test_eof459: cs = 459; goto _test_eof + _test_eof460: cs = 460; goto _test_eof + _test_eof461: cs = 461; goto _test_eof + _test_eof462: cs = 462; goto _test_eof + _test_eof463: cs = 463; goto _test_eof + _test_eof464: cs = 464; goto _test_eof + _test_eof465: cs = 465; goto _test_eof + _test_eof466: cs = 466; goto _test_eof + _test_eof467: cs = 467; goto _test_eof + _test_eof468: cs = 468; goto _test_eof + _test_eof469: cs = 469; goto _test_eof + _test_eof470: cs = 470; goto _test_eof + _test_eof471: cs = 471; goto _test_eof + _test_eof472: cs = 472; goto _test_eof + _test_eof473: cs = 473; goto _test_eof + _test_eof474: cs = 474; goto _test_eof + _test_eof475: cs = 475; goto _test_eof + _test_eof476: cs = 476; goto _test_eof + _test_eof477: cs = 477; goto _test_eof + _test_eof478: cs = 478; goto _test_eof + _test_eof479: cs = 479; goto _test_eof + _test_eof480: cs = 480; goto _test_eof + _test_eof481: cs = 481; goto _test_eof + _test_eof482: cs = 482; goto _test_eof + _test_eof483: cs = 483; goto _test_eof + _test_eof484: cs = 484; goto _test_eof + _test_eof485: cs = 485; goto _test_eof + _test_eof486: cs = 486; goto _test_eof + _test_eof487: cs = 487; goto _test_eof + _test_eof488: cs = 488; goto _test_eof + _test_eof489: cs = 489; goto _test_eof + _test_eof490: cs = 490; goto _test_eof + _test_eof491: cs = 491; goto _test_eof + _test_eof492: cs = 492; goto _test_eof + _test_eof493: cs = 493; goto _test_eof + _test_eof494: cs = 494; goto _test_eof + _test_eof495: cs = 495; goto _test_eof + _test_eof496: cs = 496; goto _test_eof + _test_eof497: cs = 497; goto _test_eof + _test_eof498: cs = 498; goto _test_eof + _test_eof499: cs = 499; goto _test_eof + _test_eof500: cs = 500; goto _test_eof + _test_eof501: cs = 501; goto _test_eof + _test_eof502: cs = 502; goto _test_eof + _test_eof503: cs = 503; goto _test_eof + _test_eof504: cs = 504; goto _test_eof + _test_eof505: cs = 505; goto _test_eof + _test_eof506: cs = 506; goto _test_eof + _test_eof507: cs = 507; goto _test_eof + _test_eof508: cs = 508; goto _test_eof + _test_eof509: cs = 509; goto _test_eof + _test_eof510: cs = 510; goto _test_eof + _test_eof511: cs = 511; goto _test_eof + _test_eof512: cs = 512; goto _test_eof + _test_eof513: cs = 513; goto _test_eof + _test_eof514: cs = 514; goto _test_eof + _test_eof515: cs = 515; goto _test_eof + _test_eof516: cs = 516; goto _test_eof + _test_eof517: cs = 517; goto _test_eof + _test_eof518: cs = 518; goto _test_eof + _test_eof519: cs = 519; goto _test_eof + _test_eof520: cs = 520; goto _test_eof + _test_eof521: cs = 521; goto _test_eof + _test_eof522: cs = 522; goto _test_eof + _test_eof523: cs = 523; goto _test_eof + _test_eof524: cs = 524; goto _test_eof + _test_eof525: cs = 525; goto _test_eof + _test_eof526: cs = 526; goto _test_eof + _test_eof527: cs = 527; goto _test_eof + _test_eof528: cs = 528; goto _test_eof + _test_eof529: cs = 529; goto _test_eof + _test_eof530: cs = 530; goto _test_eof + _test_eof531: cs = 531; goto _test_eof + _test_eof532: cs = 532; goto _test_eof + _test_eof533: cs = 533; goto _test_eof + _test_eof534: cs = 534; goto _test_eof + _test_eof535: cs = 535; goto _test_eof + _test_eof536: cs = 536; goto _test_eof + _test_eof537: cs = 537; goto _test_eof + _test_eof538: cs = 538; goto _test_eof + _test_eof539: cs = 539; goto _test_eof + _test_eof540: cs = 540; goto _test_eof + _test_eof541: cs = 541; goto _test_eof + _test_eof542: cs = 542; goto _test_eof + _test_eof543: cs = 543; goto _test_eof + _test_eof544: cs = 544; goto _test_eof + _test_eof545: cs = 545; goto _test_eof + _test_eof546: cs = 546; goto _test_eof + _test_eof547: cs = 547; goto _test_eof + _test_eof548: cs = 548; goto _test_eof + _test_eof549: cs = 549; goto _test_eof + _test_eof550: cs = 550; goto _test_eof + _test_eof551: cs = 551; goto _test_eof + _test_eof552: cs = 552; goto _test_eof + _test_eof553: cs = 553; goto _test_eof + _test_eof554: cs = 554; goto _test_eof + _test_eof555: cs = 555; goto _test_eof + _test_eof556: cs = 556; goto _test_eof + _test_eof557: cs = 557; goto _test_eof + _test_eof558: cs = 558; goto _test_eof + _test_eof559: cs = 559; goto _test_eof + _test_eof560: cs = 560; goto _test_eof + _test_eof561: cs = 561; goto _test_eof + _test_eof562: cs = 562; goto _test_eof + _test_eof563: cs = 563; goto _test_eof + _test_eof564: cs = 564; goto _test_eof + _test_eof565: cs = 565; goto _test_eof + _test_eof566: cs = 566; goto _test_eof + _test_eof567: cs = 567; goto _test_eof + _test_eof568: cs = 568; goto _test_eof + _test_eof569: cs = 569; goto _test_eof + _test_eof570: cs = 570; goto _test_eof + _test_eof571: cs = 571; goto _test_eof + _test_eof572: cs = 572; goto _test_eof + _test_eof573: cs = 573; goto _test_eof + _test_eof574: cs = 574; goto _test_eof + _test_eof575: cs = 575; goto _test_eof + _test_eof576: cs = 576; goto _test_eof + _test_eof577: cs = 577; goto _test_eof + _test_eof578: cs = 578; goto _test_eof + _test_eof579: cs = 579; goto _test_eof + _test_eof580: cs = 580; goto _test_eof + _test_eof581: cs = 581; goto _test_eof + _test_eof582: cs = 582; goto _test_eof + _test_eof583: cs = 583; goto _test_eof + _test_eof584: cs = 584; goto _test_eof + _test_eof585: cs = 585; goto _test_eof + _test_eof586: cs = 586; goto _test_eof + _test_eof587: cs = 587; goto _test_eof + _test_eof588: cs = 588; goto _test_eof + _test_eof589: cs = 589; goto _test_eof + _test_eof590: cs = 590; goto _test_eof + _test_eof591: cs = 591; goto _test_eof + _test_eof592: cs = 592; goto _test_eof + _test_eof593: cs = 593; goto _test_eof + _test_eof594: cs = 594; goto _test_eof + _test_eof595: cs = 595; goto _test_eof + _test_eof596: cs = 596; goto _test_eof + _test_eof597: cs = 597; goto _test_eof + _test_eof598: cs = 598; goto _test_eof + _test_eof599: cs = 599; goto _test_eof + _test_eof600: cs = 600; goto _test_eof + _test_eof601: cs = 601; goto _test_eof + _test_eof602: cs = 602; goto _test_eof + _test_eof603: cs = 603; goto _test_eof + _test_eof604: cs = 604; goto _test_eof + _test_eof605: cs = 605; goto _test_eof + _test_eof606: cs = 606; goto _test_eof + _test_eof607: cs = 607; goto _test_eof + _test_eof608: cs = 608; goto _test_eof + _test_eof609: cs = 609; goto _test_eof + _test_eof610: cs = 610; goto _test_eof + _test_eof611: cs = 611; goto _test_eof + _test_eof612: cs = 612; goto _test_eof + _test_eof613: cs = 613; goto _test_eof + _test_eof614: cs = 614; goto _test_eof + _test_eof615: cs = 615; goto _test_eof + _test_eof616: cs = 616; goto _test_eof + _test_eof617: cs = 617; goto _test_eof + _test_eof618: cs = 618; goto _test_eof + _test_eof619: cs = 619; goto _test_eof + _test_eof620: cs = 620; goto _test_eof + _test_eof621: cs = 621; goto _test_eof + _test_eof622: cs = 622; goto _test_eof + _test_eof623: cs = 623; goto _test_eof + _test_eof624: cs = 624; goto _test_eof + _test_eof625: cs = 625; goto _test_eof + _test_eof626: cs = 626; goto _test_eof + _test_eof627: cs = 627; goto _test_eof + _test_eof628: cs = 628; goto _test_eof + _test_eof629: cs = 629; goto _test_eof + _test_eof630: cs = 630; goto _test_eof + _test_eof631: cs = 631; goto _test_eof + _test_eof632: cs = 632; goto _test_eof + _test_eof633: cs = 633; goto _test_eof + _test_eof634: cs = 634; goto _test_eof + _test_eof635: cs = 635; goto _test_eof + _test_eof636: cs = 636; goto _test_eof + _test_eof637: cs = 637; goto _test_eof + _test_eof638: cs = 638; goto _test_eof + _test_eof639: cs = 639; goto _test_eof + _test_eof640: cs = 640; goto _test_eof + _test_eof641: cs = 641; goto _test_eof + _test_eof642: cs = 642; goto _test_eof + _test_eof643: cs = 643; goto _test_eof + _test_eof644: cs = 644; goto _test_eof + _test_eof645: cs = 645; goto _test_eof + _test_eof646: cs = 646; goto _test_eof + _test_eof647: cs = 647; goto _test_eof + _test_eof648: cs = 648; goto _test_eof + _test_eof649: cs = 649; goto _test_eof + _test_eof650: cs = 650; goto _test_eof + _test_eof651: cs = 651; goto _test_eof + _test_eof652: cs = 652; goto _test_eof + _test_eof653: cs = 653; goto _test_eof + _test_eof654: cs = 654; goto _test_eof + _test_eof655: cs = 655; goto _test_eof + _test_eof656: cs = 656; goto _test_eof + _test_eof657: cs = 657; goto _test_eof + _test_eof658: cs = 658; goto _test_eof + _test_eof659: cs = 659; goto _test_eof + _test_eof660: cs = 660; goto _test_eof + _test_eof661: cs = 661; goto _test_eof + _test_eof662: cs = 662; goto _test_eof + _test_eof663: cs = 663; goto _test_eof + _test_eof664: cs = 664; goto _test_eof + _test_eof665: cs = 665; goto _test_eof + _test_eof666: cs = 666; goto _test_eof + _test_eof667: cs = 667; goto _test_eof + _test_eof668: cs = 668; goto _test_eof + _test_eof669: cs = 669; goto _test_eof + _test_eof670: cs = 670; goto _test_eof + _test_eof671: cs = 671; goto _test_eof + _test_eof672: cs = 672; goto _test_eof + _test_eof673: cs = 673; goto _test_eof + _test_eof674: cs = 674; goto _test_eof + _test_eof675: cs = 675; goto _test_eof + _test_eof676: cs = 676; goto _test_eof + _test_eof677: cs = 677; goto _test_eof + _test_eof678: cs = 678; goto _test_eof + _test_eof679: cs = 679; goto _test_eof + _test_eof680: cs = 680; goto _test_eof + _test_eof681: cs = 681; goto _test_eof + _test_eof682: cs = 682; goto _test_eof + _test_eof683: cs = 683; goto _test_eof + _test_eof684: cs = 684; goto _test_eof + _test_eof685: cs = 685; goto _test_eof + _test_eof686: cs = 686; goto _test_eof + _test_eof687: cs = 687; goto _test_eof + _test_eof688: cs = 688; goto _test_eof + _test_eof689: cs = 689; goto _test_eof + _test_eof690: cs = 690; goto _test_eof + _test_eof691: cs = 691; goto _test_eof + _test_eof692: cs = 692; goto _test_eof + _test_eof693: cs = 693; goto _test_eof + _test_eof694: cs = 694; goto _test_eof + _test_eof695: cs = 695; goto _test_eof + _test_eof696: cs = 696; goto _test_eof + _test_eof697: cs = 697; goto _test_eof + _test_eof698: cs = 698; goto _test_eof + _test_eof699: cs = 699; goto _test_eof + _test_eof700: cs = 700; goto _test_eof + _test_eof701: cs = 701; goto _test_eof + _test_eof702: cs = 702; goto _test_eof + _test_eof703: cs = 703; goto _test_eof + _test_eof704: cs = 704; goto _test_eof + _test_eof705: cs = 705; goto _test_eof + _test_eof706: cs = 706; goto _test_eof + _test_eof707: cs = 707; goto _test_eof + _test_eof708: cs = 708; goto _test_eof + _test_eof709: cs = 709; goto _test_eof + _test_eof710: cs = 710; goto _test_eof + _test_eof711: cs = 711; goto _test_eof + _test_eof712: cs = 712; goto _test_eof + _test_eof713: cs = 713; goto _test_eof + _test_eof714: cs = 714; goto _test_eof + _test_eof715: cs = 715; goto _test_eof + _test_eof716: cs = 716; goto _test_eof + _test_eof717: cs = 717; goto _test_eof + _test_eof718: cs = 718; goto _test_eof + _test_eof719: cs = 719; goto _test_eof + _test_eof720: cs = 720; goto _test_eof + _test_eof721: cs = 721; goto _test_eof + _test_eof722: cs = 722; goto _test_eof + _test_eof723: cs = 723; goto _test_eof + _test_eof724: cs = 724; goto _test_eof + _test_eof725: cs = 725; goto _test_eof + _test_eof726: cs = 726; goto _test_eof + _test_eof727: cs = 727; goto _test_eof + _test_eof728: cs = 728; goto _test_eof + _test_eof729: cs = 729; goto _test_eof + _test_eof730: cs = 730; goto _test_eof + _test_eof731: cs = 731; goto _test_eof + _test_eof732: cs = 732; goto _test_eof + _test_eof733: cs = 733; goto _test_eof + _test_eof734: cs = 734; goto _test_eof + _test_eof735: cs = 735; goto _test_eof + _test_eof736: cs = 736; goto _test_eof + _test_eof737: cs = 737; goto _test_eof + _test_eof738: cs = 738; goto _test_eof + _test_eof739: cs = 739; goto _test_eof + _test_eof740: cs = 740; goto _test_eof + _test_eof741: cs = 741; goto _test_eof + _test_eof742: cs = 742; goto _test_eof + _test_eof743: cs = 743; goto _test_eof + _test_eof744: cs = 744; goto _test_eof + _test_eof745: cs = 745; goto _test_eof + _test_eof746: cs = 746; goto _test_eof + _test_eof747: cs = 747; goto _test_eof + _test_eof748: cs = 748; goto _test_eof + _test_eof749: cs = 749; goto _test_eof + _test_eof750: cs = 750; goto _test_eof + _test_eof751: cs = 751; goto _test_eof + _test_eof752: cs = 752; goto _test_eof + _test_eof753: cs = 753; goto _test_eof + _test_eof754: cs = 754; goto _test_eof + _test_eof755: cs = 755; goto _test_eof + _test_eof756: cs = 756; goto _test_eof + _test_eof757: cs = 757; goto _test_eof + _test_eof758: cs = 758; goto _test_eof + _test_eof759: cs = 759; goto _test_eof + _test_eof760: cs = 760; goto _test_eof + _test_eof761: cs = 761; goto _test_eof + _test_eof762: cs = 762; goto _test_eof + _test_eof763: cs = 763; goto _test_eof + _test_eof764: cs = 764; goto _test_eof + + _test_eof: {} if p == eof { switch cs { case 281, 282, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 370, 371, 372, 373, 374, 375, 385, 386, 387, 388, 389, 390, 391, 392, 393, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 441, 442, 443, 444, 445, 446, 447, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763: @@ -15525,7 +17872,7 @@ tr753: addrp = &addr.Next addr = nil -//line msg_parse.go:15529 +//line msg_parse.go:17876 } } diff --git a/sip/msg_parse.rl b/sip/msg_parse.rl index d066be9..623a441 100644 --- a/sip/msg_parse.rl +++ b/sip/msg_parse.rl @@ -45,7 +45,7 @@ func ParseMsgBytes(data []byte) (msg *Msg, err error) { %% main := Message; %% write init; - %% write exec noend; + %% write exec; if cs < msg_first_final { if p == pe { diff --git a/sip/uri.go b/sip/uri.go index af8aa2f..063f694 100755 --- a/sip/uri.go +++ b/sip/uri.go @@ -6,14 +6,14 @@ // // For example: // -// jtunney@bsdtelecom.net;isup-oli=29 +// jart@example.test;isup-oli=29 // // Roughly equates to: // // {Scheme: "sip", -// User: "jtunney", +// User: "jart", // Pass: "", -// Host: "bsdtelecom.net", +// Host: "example.test", // Port: "", // Params: {"isup-oli": "29"}} //