github.com/gopherd/gonum@v0.0.4/graph/formats/rdf/parse.go (about) 1 2 //line parse.rl:1 3 // Go code generated by go generate github.com/gopherd/gonum/graph/formats/rdf; DO NOT EDIT. 4 5 // Copyright ©2020 The Gonum Authors. All rights reserved. 6 // Use of this source code is governed by a BSD-style 7 // license that can be found in the LICENSE file. 8 9 package rdf 10 11 import ( 12 "fmt" 13 "net/url" 14 "unicode" 15 ) 16 17 18 //line parse.go:19 19 const nquads_start int = 1 20 const nquads_first_final int = 87 21 const nquads_error int = 0 22 23 const nquads_en_statement int = 1 24 25 26 //line parse.rl:31 27 28 29 func parse(data []rune) (Statement, error) { 30 var ( 31 cs, p int 32 pe = len(data) 33 eof = pe 34 35 subject = -1 36 predicate = -1 37 object = -1 38 label = -1 39 iri = -1 40 41 s Statement 42 ) 43 44 45 //line parse.go:46 46 { 47 cs = nquads_start 48 } 49 50 //line parse.rl:49 51 52 53 //line parse.go:54 54 { 55 if p == pe { 56 goto _test_eof 57 } 58 switch cs { 59 case 1: 60 goto st_case_1 61 case 0: 62 goto st_case_0 63 case 2: 64 goto st_case_2 65 case 3: 66 goto st_case_3 67 case 4: 68 goto st_case_4 69 case 5: 70 goto st_case_5 71 case 6: 72 goto st_case_6 73 case 7: 74 goto st_case_7 75 case 8: 76 goto st_case_8 77 case 9: 78 goto st_case_9 79 case 10: 80 goto st_case_10 81 case 11: 82 goto st_case_11 83 case 12: 84 goto st_case_12 85 case 87: 86 goto st_case_87 87 case 88: 88 goto st_case_88 89 case 13: 90 goto st_case_13 91 case 14: 92 goto st_case_14 93 case 15: 94 goto st_case_15 95 case 16: 96 goto st_case_16 97 case 17: 98 goto st_case_17 99 case 18: 100 goto st_case_18 101 case 19: 102 goto st_case_19 103 case 20: 104 goto st_case_20 105 case 21: 106 goto st_case_21 107 case 22: 108 goto st_case_22 109 case 23: 110 goto st_case_23 111 case 24: 112 goto st_case_24 113 case 25: 114 goto st_case_25 115 case 26: 116 goto st_case_26 117 case 27: 118 goto st_case_27 119 case 28: 120 goto st_case_28 121 case 89: 122 goto st_case_89 123 case 29: 124 goto st_case_29 125 case 30: 126 goto st_case_30 127 case 31: 128 goto st_case_31 129 case 32: 130 goto st_case_32 131 case 33: 132 goto st_case_33 133 case 34: 134 goto st_case_34 135 case 35: 136 goto st_case_35 137 case 36: 138 goto st_case_36 139 case 37: 140 goto st_case_37 141 case 38: 142 goto st_case_38 143 case 39: 144 goto st_case_39 145 case 40: 146 goto st_case_40 147 case 41: 148 goto st_case_41 149 case 42: 150 goto st_case_42 151 case 43: 152 goto st_case_43 153 case 44: 154 goto st_case_44 155 case 45: 156 goto st_case_45 157 case 46: 158 goto st_case_46 159 case 47: 160 goto st_case_47 161 case 48: 162 goto st_case_48 163 case 49: 164 goto st_case_49 165 case 50: 166 goto st_case_50 167 case 51: 168 goto st_case_51 169 case 52: 170 goto st_case_52 171 case 53: 172 goto st_case_53 173 case 54: 174 goto st_case_54 175 case 55: 176 goto st_case_55 177 case 56: 178 goto st_case_56 179 case 57: 180 goto st_case_57 181 case 58: 182 goto st_case_58 183 case 59: 184 goto st_case_59 185 case 90: 186 goto st_case_90 187 case 60: 188 goto st_case_60 189 case 61: 190 goto st_case_61 191 case 62: 192 goto st_case_62 193 case 63: 194 goto st_case_63 195 case 91: 196 goto st_case_91 197 case 64: 198 goto st_case_64 199 case 65: 200 goto st_case_65 201 case 66: 202 goto st_case_66 203 case 67: 204 goto st_case_67 205 case 68: 206 goto st_case_68 207 case 69: 208 goto st_case_69 209 case 70: 210 goto st_case_70 211 case 71: 212 goto st_case_71 213 case 72: 214 goto st_case_72 215 case 73: 216 goto st_case_73 217 case 74: 218 goto st_case_74 219 case 75: 220 goto st_case_75 221 case 76: 222 goto st_case_76 223 case 77: 224 goto st_case_77 225 case 78: 226 goto st_case_78 227 case 79: 228 goto st_case_79 229 case 80: 230 goto st_case_80 231 case 81: 232 goto st_case_81 233 case 82: 234 goto st_case_82 235 case 83: 236 goto st_case_83 237 case 84: 238 goto st_case_84 239 case 85: 240 goto st_case_85 241 case 86: 242 goto st_case_86 243 } 244 goto st_out 245 st1: 246 if p++; p == pe { 247 goto _test_eof1 248 } 249 st_case_1: 250 switch data[p] { 251 case 9: 252 goto st1 253 case 32: 254 goto st1 255 case 60: 256 goto tr2 257 case 95: 258 goto tr3 259 } 260 goto tr0 261 tr0: 262 //line parse_actions.rl:75 263 264 if p < len(data) { 265 if r := data[p]; r < unicode.MaxASCII { 266 return s, fmt.Errorf("%w: unexpected rune %q at %d", ErrInvalid, data[p], p) 267 } else { 268 return s, fmt.Errorf("%w: unexpected rune %q (\\u%04[2]x) at %d", ErrInvalid, data[p], p) 269 } 270 } 271 return s, ErrIncomplete 272 273 goto st0 274 //line parse.go:275 275 st_case_0: 276 st0: 277 cs = 0 278 goto _out 279 tr2: 280 //line parse_actions.rl:8 281 282 subject = p 283 284 goto st2 285 st2: 286 if p++; p == pe { 287 goto _test_eof2 288 } 289 st_case_2: 290 //line parse.go:291 291 switch data[p] { 292 case 62: 293 goto tr5 294 case 92: 295 goto tr6 296 case 95: 297 goto tr4 298 case 126: 299 goto tr4 300 } 301 switch { 302 case data[p] < 61: 303 if 33 <= data[p] && data[p] <= 59 { 304 goto tr4 305 } 306 case data[p] > 93: 307 switch { 308 case data[p] > 122: 309 if 128 <= data[p] && data[p] <= 1114111 { 310 goto tr4 311 } 312 case data[p] >= 97: 313 goto tr4 314 } 315 default: 316 goto tr4 317 } 318 goto tr0 319 tr4: 320 //line parse_actions.rl:24 321 322 iri = p 323 324 goto st3 325 st3: 326 if p++; p == pe { 327 goto _test_eof3 328 } 329 st_case_3: 330 //line parse.go:331 331 switch data[p] { 332 case 62: 333 goto tr8 334 case 92: 335 goto st74 336 case 95: 337 goto st3 338 case 126: 339 goto st3 340 } 341 switch { 342 case data[p] < 61: 343 if 33 <= data[p] && data[p] <= 59 { 344 goto st3 345 } 346 case data[p] > 93: 347 switch { 348 case data[p] > 122: 349 if 128 <= data[p] && data[p] <= 1114111 { 350 goto st3 351 } 352 case data[p] >= 97: 353 goto st3 354 } 355 default: 356 goto st3 357 } 358 goto tr0 359 tr5: 360 //line parse_actions.rl:24 361 362 iri = p 363 364 //line parse_actions.rl:56 365 366 if iri < 0 { 367 panic("unexpected parser state: iri start not set") 368 } 369 switch u, err := url.Parse(string(data[iri:p])); { 370 case err != nil: 371 return s, err 372 case !u.IsAbs(): 373 return s, fmt.Errorf("%w: relative IRI ref %q", ErrInvalid, string(data[iri:p])) 374 } 375 376 goto st4 377 tr8: 378 //line parse_actions.rl:56 379 380 if iri < 0 { 381 panic("unexpected parser state: iri start not set") 382 } 383 switch u, err := url.Parse(string(data[iri:p])); { 384 case err != nil: 385 return s, err 386 case !u.IsAbs(): 387 return s, fmt.Errorf("%w: relative IRI ref %q", ErrInvalid, string(data[iri:p])) 388 } 389 390 goto st4 391 st4: 392 if p++; p == pe { 393 goto _test_eof4 394 } 395 st_case_4: 396 //line parse.go:397 397 switch data[p] { 398 case 9: 399 goto tr10 400 case 32: 401 goto tr10 402 case 60: 403 goto tr11 404 } 405 goto tr0 406 tr10: 407 //line parse_actions.rl:28 408 409 if subject < 0 { 410 panic("unexpected parser state: subject start not set") 411 } 412 s.Subject.Value = string(data[subject:p]) 413 414 goto st5 415 st5: 416 if p++; p == pe { 417 goto _test_eof5 418 } 419 st_case_5: 420 //line parse.go:421 421 switch data[p] { 422 case 9: 423 goto st5 424 case 32: 425 goto st5 426 case 60: 427 goto tr13 428 } 429 goto tr0 430 tr11: 431 //line parse_actions.rl:28 432 433 if subject < 0 { 434 panic("unexpected parser state: subject start not set") 435 } 436 s.Subject.Value = string(data[subject:p]) 437 438 //line parse_actions.rl:12 439 440 predicate = p 441 442 goto st6 443 tr13: 444 //line parse_actions.rl:12 445 446 predicate = p 447 448 goto st6 449 st6: 450 if p++; p == pe { 451 goto _test_eof6 452 } 453 st_case_6: 454 //line parse.go:455 455 switch data[p] { 456 case 62: 457 goto tr15 458 case 92: 459 goto tr16 460 case 95: 461 goto tr14 462 case 126: 463 goto tr14 464 } 465 switch { 466 case data[p] < 61: 467 if 33 <= data[p] && data[p] <= 59 { 468 goto tr14 469 } 470 case data[p] > 93: 471 switch { 472 case data[p] > 122: 473 if 128 <= data[p] && data[p] <= 1114111 { 474 goto tr14 475 } 476 case data[p] >= 97: 477 goto tr14 478 } 479 default: 480 goto tr14 481 } 482 goto tr0 483 tr14: 484 //line parse_actions.rl:24 485 486 iri = p 487 488 goto st7 489 st7: 490 if p++; p == pe { 491 goto _test_eof7 492 } 493 st_case_7: 494 //line parse.go:495 495 switch data[p] { 496 case 62: 497 goto tr18 498 case 92: 499 goto st65 500 case 95: 501 goto st7 502 case 126: 503 goto st7 504 } 505 switch { 506 case data[p] < 61: 507 if 33 <= data[p] && data[p] <= 59 { 508 goto st7 509 } 510 case data[p] > 93: 511 switch { 512 case data[p] > 122: 513 if 128 <= data[p] && data[p] <= 1114111 { 514 goto st7 515 } 516 case data[p] >= 97: 517 goto st7 518 } 519 default: 520 goto st7 521 } 522 goto tr0 523 tr15: 524 //line parse_actions.rl:24 525 526 iri = p 527 528 //line parse_actions.rl:56 529 530 if iri < 0 { 531 panic("unexpected parser state: iri start not set") 532 } 533 switch u, err := url.Parse(string(data[iri:p])); { 534 case err != nil: 535 return s, err 536 case !u.IsAbs(): 537 return s, fmt.Errorf("%w: relative IRI ref %q", ErrInvalid, string(data[iri:p])) 538 } 539 540 goto st8 541 tr18: 542 //line parse_actions.rl:56 543 544 if iri < 0 { 545 panic("unexpected parser state: iri start not set") 546 } 547 switch u, err := url.Parse(string(data[iri:p])); { 548 case err != nil: 549 return s, err 550 case !u.IsAbs(): 551 return s, fmt.Errorf("%w: relative IRI ref %q", ErrInvalid, string(data[iri:p])) 552 } 553 554 goto st8 555 st8: 556 if p++; p == pe { 557 goto _test_eof8 558 } 559 st_case_8: 560 //line parse.go:561 561 switch data[p] { 562 case 9: 563 goto tr20 564 case 32: 565 goto tr20 566 case 34: 567 goto tr21 568 case 60: 569 goto tr22 570 case 95: 571 goto tr23 572 } 573 goto tr0 574 tr20: 575 //line parse_actions.rl:35 576 577 if predicate < 0 { 578 panic("unexpected parser state: predicate start not set") 579 } 580 s.Predicate.Value = string(data[predicate:p]) 581 582 goto st9 583 st9: 584 if p++; p == pe { 585 goto _test_eof9 586 } 587 st_case_9: 588 //line parse.go:589 589 switch data[p] { 590 case 9: 591 goto st9 592 case 32: 593 goto st9 594 case 34: 595 goto tr25 596 case 60: 597 goto tr26 598 case 95: 599 goto tr27 600 } 601 goto tr0 602 tr21: 603 //line parse_actions.rl:35 604 605 if predicate < 0 { 606 panic("unexpected parser state: predicate start not set") 607 } 608 s.Predicate.Value = string(data[predicate:p]) 609 610 //line parse_actions.rl:16 611 612 object = p 613 614 goto st10 615 tr25: 616 //line parse_actions.rl:16 617 618 object = p 619 620 goto st10 621 st10: 622 if p++; p == pe { 623 goto _test_eof10 624 } 625 st_case_10: 626 //line parse.go:627 627 switch data[p] { 628 case 34: 629 goto st11 630 case 92: 631 goto st48 632 } 633 switch { 634 case data[p] < 11: 635 if 0 <= data[p] && data[p] <= 9 { 636 goto st10 637 } 638 case data[p] > 12: 639 if 14 <= data[p] && data[p] <= 1114111 { 640 goto st10 641 } 642 default: 643 goto st10 644 } 645 goto tr0 646 st11: 647 if p++; p == pe { 648 goto _test_eof11 649 } 650 st_case_11: 651 switch data[p] { 652 case 9: 653 goto tr31 654 case 32: 655 goto tr31 656 case 46: 657 goto tr32 658 case 60: 659 goto tr33 660 case 64: 661 goto st30 662 case 94: 663 goto st34 664 case 95: 665 goto tr36 666 } 667 goto tr0 668 tr31: 669 //line parse_actions.rl:42 670 671 if object < 0 { 672 panic("unexpected parser state: object start not set") 673 } 674 s.Object.Value = string(data[object:p]) 675 676 goto st12 677 tr97: 678 //line parse_actions.rl:42 679 680 if object < 0 { 681 panic("unexpected parser state: object start not set") 682 } 683 s.Object.Value = string(data[object:p]) 684 685 //line parse_actions.rl:49 686 687 if label < 0 { 688 panic("unexpected parser state: label start not set") 689 } 690 s.Label.Value = string(data[label:p]) 691 692 goto st12 693 st12: 694 if p++; p == pe { 695 goto _test_eof12 696 } 697 st_case_12: 698 //line parse.go:699 699 switch data[p] { 700 case 9: 701 goto st12 702 case 32: 703 goto st12 704 case 46: 705 goto st87 706 case 60: 707 goto tr39 708 case 95: 709 goto tr40 710 } 711 goto tr0 712 tr32: 713 //line parse_actions.rl:42 714 715 if object < 0 { 716 panic("unexpected parser state: object start not set") 717 } 718 s.Object.Value = string(data[object:p]) 719 720 goto st87 721 tr48: 722 //line parse_actions.rl:49 723 724 if label < 0 { 725 panic("unexpected parser state: label start not set") 726 } 727 s.Label.Value = string(data[label:p]) 728 729 goto st87 730 st87: 731 if p++; p == pe { 732 goto _test_eof87 733 } 734 st_case_87: 735 //line parse.go:736 736 switch data[p] { 737 case 9: 738 goto st87 739 case 32: 740 goto st87 741 case 35: 742 goto tr120 743 } 744 goto st0 745 tr120: 746 //line parse_actions.rl:72 747 748 749 goto st88 750 st88: 751 if p++; p == pe { 752 goto _test_eof88 753 } 754 st_case_88: 755 //line parse.go:756 756 goto st88 757 tr33: 758 //line parse_actions.rl:42 759 760 if object < 0 { 761 panic("unexpected parser state: object start not set") 762 } 763 s.Object.Value = string(data[object:p]) 764 765 //line parse_actions.rl:20 766 767 label = p 768 769 goto st13 770 tr39: 771 //line parse_actions.rl:20 772 773 label = p 774 775 goto st13 776 st13: 777 if p++; p == pe { 778 goto _test_eof13 779 } 780 st_case_13: 781 //line parse.go:782 782 switch data[p] { 783 case 62: 784 goto tr42 785 case 92: 786 goto tr43 787 case 95: 788 goto tr41 789 case 126: 790 goto tr41 791 } 792 switch { 793 case data[p] < 61: 794 if 33 <= data[p] && data[p] <= 59 { 795 goto tr41 796 } 797 case data[p] > 93: 798 switch { 799 case data[p] > 122: 800 if 128 <= data[p] && data[p] <= 1114111 { 801 goto tr41 802 } 803 case data[p] >= 97: 804 goto tr41 805 } 806 default: 807 goto tr41 808 } 809 goto tr0 810 tr41: 811 //line parse_actions.rl:24 812 813 iri = p 814 815 goto st14 816 st14: 817 if p++; p == pe { 818 goto _test_eof14 819 } 820 st_case_14: 821 //line parse.go:822 822 switch data[p] { 823 case 62: 824 goto tr45 825 case 92: 826 goto st17 827 case 95: 828 goto st14 829 case 126: 830 goto st14 831 } 832 switch { 833 case data[p] < 61: 834 if 33 <= data[p] && data[p] <= 59 { 835 goto st14 836 } 837 case data[p] > 93: 838 switch { 839 case data[p] > 122: 840 if 128 <= data[p] && data[p] <= 1114111 { 841 goto st14 842 } 843 case data[p] >= 97: 844 goto st14 845 } 846 default: 847 goto st14 848 } 849 goto tr0 850 tr42: 851 //line parse_actions.rl:24 852 853 iri = p 854 855 //line parse_actions.rl:56 856 857 if iri < 0 { 858 panic("unexpected parser state: iri start not set") 859 } 860 switch u, err := url.Parse(string(data[iri:p])); { 861 case err != nil: 862 return s, err 863 case !u.IsAbs(): 864 return s, fmt.Errorf("%w: relative IRI ref %q", ErrInvalid, string(data[iri:p])) 865 } 866 867 goto st15 868 tr45: 869 //line parse_actions.rl:56 870 871 if iri < 0 { 872 panic("unexpected parser state: iri start not set") 873 } 874 switch u, err := url.Parse(string(data[iri:p])); { 875 case err != nil: 876 return s, err 877 case !u.IsAbs(): 878 return s, fmt.Errorf("%w: relative IRI ref %q", ErrInvalid, string(data[iri:p])) 879 } 880 881 goto st15 882 st15: 883 if p++; p == pe { 884 goto _test_eof15 885 } 886 st_case_15: 887 //line parse.go:888 888 switch data[p] { 889 case 9: 890 goto tr47 891 case 32: 892 goto tr47 893 case 46: 894 goto tr48 895 } 896 goto tr0 897 tr47: 898 //line parse_actions.rl:49 899 900 if label < 0 { 901 panic("unexpected parser state: label start not set") 902 } 903 s.Label.Value = string(data[label:p]) 904 905 goto st16 906 st16: 907 if p++; p == pe { 908 goto _test_eof16 909 } 910 st_case_16: 911 //line parse.go:912 912 switch data[p] { 913 case 9: 914 goto st16 915 case 32: 916 goto st16 917 case 46: 918 goto st87 919 } 920 goto tr0 921 tr43: 922 //line parse_actions.rl:24 923 924 iri = p 925 926 goto st17 927 st17: 928 if p++; p == pe { 929 goto _test_eof17 930 } 931 st_case_17: 932 //line parse.go:933 933 switch data[p] { 934 case 85: 935 goto st18 936 case 117: 937 goto st22 938 } 939 goto tr0 940 st18: 941 if p++; p == pe { 942 goto _test_eof18 943 } 944 st_case_18: 945 switch { 946 case data[p] < 65: 947 if 48 <= data[p] && data[p] <= 57 { 948 goto st19 949 } 950 case data[p] > 70: 951 if 97 <= data[p] && data[p] <= 102 { 952 goto st19 953 } 954 default: 955 goto st19 956 } 957 goto tr0 958 st19: 959 if p++; p == pe { 960 goto _test_eof19 961 } 962 st_case_19: 963 switch { 964 case data[p] < 65: 965 if 48 <= data[p] && data[p] <= 57 { 966 goto st20 967 } 968 case data[p] > 70: 969 if 97 <= data[p] && data[p] <= 102 { 970 goto st20 971 } 972 default: 973 goto st20 974 } 975 goto tr0 976 st20: 977 if p++; p == pe { 978 goto _test_eof20 979 } 980 st_case_20: 981 switch { 982 case data[p] < 65: 983 if 48 <= data[p] && data[p] <= 57 { 984 goto st21 985 } 986 case data[p] > 70: 987 if 97 <= data[p] && data[p] <= 102 { 988 goto st21 989 } 990 default: 991 goto st21 992 } 993 goto tr0 994 st21: 995 if p++; p == pe { 996 goto _test_eof21 997 } 998 st_case_21: 999 switch { 1000 case data[p] < 65: 1001 if 48 <= data[p] && data[p] <= 57 { 1002 goto st22 1003 } 1004 case data[p] > 70: 1005 if 97 <= data[p] && data[p] <= 102 { 1006 goto st22 1007 } 1008 default: 1009 goto st22 1010 } 1011 goto tr0 1012 st22: 1013 if p++; p == pe { 1014 goto _test_eof22 1015 } 1016 st_case_22: 1017 switch { 1018 case data[p] < 65: 1019 if 48 <= data[p] && data[p] <= 57 { 1020 goto st23 1021 } 1022 case data[p] > 70: 1023 if 97 <= data[p] && data[p] <= 102 { 1024 goto st23 1025 } 1026 default: 1027 goto st23 1028 } 1029 goto tr0 1030 st23: 1031 if p++; p == pe { 1032 goto _test_eof23 1033 } 1034 st_case_23: 1035 switch { 1036 case data[p] < 65: 1037 if 48 <= data[p] && data[p] <= 57 { 1038 goto st24 1039 } 1040 case data[p] > 70: 1041 if 97 <= data[p] && data[p] <= 102 { 1042 goto st24 1043 } 1044 default: 1045 goto st24 1046 } 1047 goto tr0 1048 st24: 1049 if p++; p == pe { 1050 goto _test_eof24 1051 } 1052 st_case_24: 1053 switch { 1054 case data[p] < 65: 1055 if 48 <= data[p] && data[p] <= 57 { 1056 goto st25 1057 } 1058 case data[p] > 70: 1059 if 97 <= data[p] && data[p] <= 102 { 1060 goto st25 1061 } 1062 default: 1063 goto st25 1064 } 1065 goto tr0 1066 st25: 1067 if p++; p == pe { 1068 goto _test_eof25 1069 } 1070 st_case_25: 1071 switch { 1072 case data[p] < 65: 1073 if 48 <= data[p] && data[p] <= 57 { 1074 goto st14 1075 } 1076 case data[p] > 70: 1077 if 97 <= data[p] && data[p] <= 102 { 1078 goto st14 1079 } 1080 default: 1081 goto st14 1082 } 1083 goto tr0 1084 tr36: 1085 //line parse_actions.rl:42 1086 1087 if object < 0 { 1088 panic("unexpected parser state: object start not set") 1089 } 1090 s.Object.Value = string(data[object:p]) 1091 1092 //line parse_actions.rl:20 1093 1094 label = p 1095 1096 goto st26 1097 tr40: 1098 //line parse_actions.rl:20 1099 1100 label = p 1101 1102 goto st26 1103 st26: 1104 if p++; p == pe { 1105 goto _test_eof26 1106 } 1107 st_case_26: 1108 //line parse.go:1109 1109 if data[p] == 58 { 1110 goto st27 1111 } 1112 goto tr0 1113 st27: 1114 if p++; p == pe { 1115 goto _test_eof27 1116 } 1117 st_case_27: 1118 if data[p] == 95 { 1119 goto st28 1120 } 1121 switch { 1122 case data[p] < 895: 1123 switch { 1124 case data[p] < 192: 1125 switch { 1126 case data[p] < 65: 1127 if 48 <= data[p] && data[p] <= 58 { 1128 goto st28 1129 } 1130 case data[p] > 90: 1131 if 97 <= data[p] && data[p] <= 122 { 1132 goto st28 1133 } 1134 default: 1135 goto st28 1136 } 1137 case data[p] > 214: 1138 switch { 1139 case data[p] < 248: 1140 if 216 <= data[p] && data[p] <= 246 { 1141 goto st28 1142 } 1143 case data[p] > 767: 1144 if 880 <= data[p] && data[p] <= 893 { 1145 goto st28 1146 } 1147 default: 1148 goto st28 1149 } 1150 default: 1151 goto st28 1152 } 1153 case data[p] > 8191: 1154 switch { 1155 case data[p] < 12289: 1156 switch { 1157 case data[p] < 8304: 1158 if 8204 <= data[p] && data[p] <= 8205 { 1159 goto st28 1160 } 1161 case data[p] > 8591: 1162 if 11264 <= data[p] && data[p] <= 12271 { 1163 goto st28 1164 } 1165 default: 1166 goto st28 1167 } 1168 case data[p] > 55295: 1169 switch { 1170 case data[p] < 65008: 1171 if 63744 <= data[p] && data[p] <= 64975 { 1172 goto st28 1173 } 1174 case data[p] > 65533: 1175 if 65536 <= data[p] && data[p] <= 983039 { 1176 goto st28 1177 } 1178 default: 1179 goto st28 1180 } 1181 default: 1182 goto st28 1183 } 1184 default: 1185 goto st28 1186 } 1187 goto tr0 1188 st28: 1189 if p++; p == pe { 1190 goto _test_eof28 1191 } 1192 st_case_28: 1193 switch data[p] { 1194 case 9: 1195 goto tr47 1196 case 32: 1197 goto tr47 1198 case 45: 1199 goto st28 1200 case 46: 1201 goto tr60 1202 case 95: 1203 goto st28 1204 case 183: 1205 goto st28 1206 } 1207 switch { 1208 case data[p] < 8204: 1209 switch { 1210 case data[p] < 192: 1211 switch { 1212 case data[p] < 65: 1213 if 48 <= data[p] && data[p] <= 58 { 1214 goto st28 1215 } 1216 case data[p] > 90: 1217 if 97 <= data[p] && data[p] <= 122 { 1218 goto st28 1219 } 1220 default: 1221 goto st28 1222 } 1223 case data[p] > 214: 1224 switch { 1225 case data[p] < 248: 1226 if 216 <= data[p] && data[p] <= 246 { 1227 goto st28 1228 } 1229 case data[p] > 893: 1230 if 895 <= data[p] && data[p] <= 8191 { 1231 goto st28 1232 } 1233 default: 1234 goto st28 1235 } 1236 default: 1237 goto st28 1238 } 1239 case data[p] > 8205: 1240 switch { 1241 case data[p] < 12289: 1242 switch { 1243 case data[p] < 8304: 1244 if 8255 <= data[p] && data[p] <= 8256 { 1245 goto st28 1246 } 1247 case data[p] > 8591: 1248 if 11264 <= data[p] && data[p] <= 12271 { 1249 goto st28 1250 } 1251 default: 1252 goto st28 1253 } 1254 case data[p] > 55295: 1255 switch { 1256 case data[p] < 65008: 1257 if 63744 <= data[p] && data[p] <= 64975 { 1258 goto st28 1259 } 1260 case data[p] > 65533: 1261 if 65536 <= data[p] && data[p] <= 983039 { 1262 goto st28 1263 } 1264 default: 1265 goto st28 1266 } 1267 default: 1268 goto st28 1269 } 1270 default: 1271 goto st28 1272 } 1273 goto tr0 1274 tr60: 1275 //line parse_actions.rl:49 1276 1277 if label < 0 { 1278 panic("unexpected parser state: label start not set") 1279 } 1280 s.Label.Value = string(data[label:p]) 1281 1282 goto st89 1283 st89: 1284 if p++; p == pe { 1285 goto _test_eof89 1286 } 1287 st_case_89: 1288 //line parse.go:1289 1289 switch data[p] { 1290 case 9: 1291 goto st87 1292 case 32: 1293 goto st87 1294 case 35: 1295 goto tr120 1296 case 45: 1297 goto st28 1298 case 46: 1299 goto st29 1300 case 95: 1301 goto st28 1302 case 183: 1303 goto st28 1304 } 1305 switch { 1306 case data[p] < 8204: 1307 switch { 1308 case data[p] < 192: 1309 switch { 1310 case data[p] < 65: 1311 if 48 <= data[p] && data[p] <= 58 { 1312 goto st28 1313 } 1314 case data[p] > 90: 1315 if 97 <= data[p] && data[p] <= 122 { 1316 goto st28 1317 } 1318 default: 1319 goto st28 1320 } 1321 case data[p] > 214: 1322 switch { 1323 case data[p] < 248: 1324 if 216 <= data[p] && data[p] <= 246 { 1325 goto st28 1326 } 1327 case data[p] > 893: 1328 if 895 <= data[p] && data[p] <= 8191 { 1329 goto st28 1330 } 1331 default: 1332 goto st28 1333 } 1334 default: 1335 goto st28 1336 } 1337 case data[p] > 8205: 1338 switch { 1339 case data[p] < 12289: 1340 switch { 1341 case data[p] < 8304: 1342 if 8255 <= data[p] && data[p] <= 8256 { 1343 goto st28 1344 } 1345 case data[p] > 8591: 1346 if 11264 <= data[p] && data[p] <= 12271 { 1347 goto st28 1348 } 1349 default: 1350 goto st28 1351 } 1352 case data[p] > 55295: 1353 switch { 1354 case data[p] < 65008: 1355 if 63744 <= data[p] && data[p] <= 64975 { 1356 goto st28 1357 } 1358 case data[p] > 65533: 1359 if 65536 <= data[p] && data[p] <= 983039 { 1360 goto st28 1361 } 1362 default: 1363 goto st28 1364 } 1365 default: 1366 goto st28 1367 } 1368 default: 1369 goto st28 1370 } 1371 goto st0 1372 st29: 1373 if p++; p == pe { 1374 goto _test_eof29 1375 } 1376 st_case_29: 1377 switch data[p] { 1378 case 45: 1379 goto st28 1380 case 46: 1381 goto st29 1382 case 95: 1383 goto st28 1384 case 183: 1385 goto st28 1386 } 1387 switch { 1388 case data[p] < 8204: 1389 switch { 1390 case data[p] < 192: 1391 switch { 1392 case data[p] < 65: 1393 if 48 <= data[p] && data[p] <= 58 { 1394 goto st28 1395 } 1396 case data[p] > 90: 1397 if 97 <= data[p] && data[p] <= 122 { 1398 goto st28 1399 } 1400 default: 1401 goto st28 1402 } 1403 case data[p] > 214: 1404 switch { 1405 case data[p] < 248: 1406 if 216 <= data[p] && data[p] <= 246 { 1407 goto st28 1408 } 1409 case data[p] > 893: 1410 if 895 <= data[p] && data[p] <= 8191 { 1411 goto st28 1412 } 1413 default: 1414 goto st28 1415 } 1416 default: 1417 goto st28 1418 } 1419 case data[p] > 8205: 1420 switch { 1421 case data[p] < 12289: 1422 switch { 1423 case data[p] < 8304: 1424 if 8255 <= data[p] && data[p] <= 8256 { 1425 goto st28 1426 } 1427 case data[p] > 8591: 1428 if 11264 <= data[p] && data[p] <= 12271 { 1429 goto st28 1430 } 1431 default: 1432 goto st28 1433 } 1434 case data[p] > 55295: 1435 switch { 1436 case data[p] < 65008: 1437 if 63744 <= data[p] && data[p] <= 64975 { 1438 goto st28 1439 } 1440 case data[p] > 65533: 1441 if 65536 <= data[p] && data[p] <= 983039 { 1442 goto st28 1443 } 1444 default: 1445 goto st28 1446 } 1447 default: 1448 goto st28 1449 } 1450 default: 1451 goto st28 1452 } 1453 goto tr0 1454 st30: 1455 if p++; p == pe { 1456 goto _test_eof30 1457 } 1458 st_case_30: 1459 switch { 1460 case data[p] > 90: 1461 if 97 <= data[p] && data[p] <= 122 { 1462 goto st31 1463 } 1464 case data[p] >= 65: 1465 goto st31 1466 } 1467 goto tr0 1468 st31: 1469 if p++; p == pe { 1470 goto _test_eof31 1471 } 1472 st_case_31: 1473 switch data[p] { 1474 case 9: 1475 goto tr31 1476 case 32: 1477 goto tr31 1478 case 45: 1479 goto st32 1480 case 46: 1481 goto tr32 1482 case 60: 1483 goto tr33 1484 case 95: 1485 goto tr36 1486 } 1487 switch { 1488 case data[p] > 90: 1489 if 97 <= data[p] && data[p] <= 122 { 1490 goto st31 1491 } 1492 case data[p] >= 65: 1493 goto st31 1494 } 1495 goto tr0 1496 st32: 1497 if p++; p == pe { 1498 goto _test_eof32 1499 } 1500 st_case_32: 1501 switch { 1502 case data[p] < 65: 1503 if 48 <= data[p] && data[p] <= 57 { 1504 goto st33 1505 } 1506 case data[p] > 90: 1507 if 97 <= data[p] && data[p] <= 122 { 1508 goto st33 1509 } 1510 default: 1511 goto st33 1512 } 1513 goto tr0 1514 st33: 1515 if p++; p == pe { 1516 goto _test_eof33 1517 } 1518 st_case_33: 1519 switch data[p] { 1520 case 9: 1521 goto tr31 1522 case 32: 1523 goto tr31 1524 case 45: 1525 goto st32 1526 case 46: 1527 goto tr32 1528 case 60: 1529 goto tr33 1530 case 95: 1531 goto tr36 1532 } 1533 switch { 1534 case data[p] < 65: 1535 if 48 <= data[p] && data[p] <= 57 { 1536 goto st33 1537 } 1538 case data[p] > 90: 1539 if 97 <= data[p] && data[p] <= 122 { 1540 goto st33 1541 } 1542 default: 1543 goto st33 1544 } 1545 goto tr0 1546 st34: 1547 if p++; p == pe { 1548 goto _test_eof34 1549 } 1550 st_case_34: 1551 if data[p] == 94 { 1552 goto st35 1553 } 1554 goto tr0 1555 st35: 1556 if p++; p == pe { 1557 goto _test_eof35 1558 } 1559 st_case_35: 1560 if data[p] == 60 { 1561 goto st36 1562 } 1563 goto tr0 1564 tr22: 1565 //line parse_actions.rl:35 1566 1567 if predicate < 0 { 1568 panic("unexpected parser state: predicate start not set") 1569 } 1570 s.Predicate.Value = string(data[predicate:p]) 1571 1572 //line parse_actions.rl:16 1573 1574 object = p 1575 1576 goto st36 1577 tr26: 1578 //line parse_actions.rl:16 1579 1580 object = p 1581 1582 goto st36 1583 st36: 1584 if p++; p == pe { 1585 goto _test_eof36 1586 } 1587 st_case_36: 1588 //line parse.go:1589 1589 switch data[p] { 1590 case 62: 1591 goto tr68 1592 case 92: 1593 goto tr69 1594 case 95: 1595 goto tr67 1596 case 126: 1597 goto tr67 1598 } 1599 switch { 1600 case data[p] < 61: 1601 if 33 <= data[p] && data[p] <= 59 { 1602 goto tr67 1603 } 1604 case data[p] > 93: 1605 switch { 1606 case data[p] > 122: 1607 if 128 <= data[p] && data[p] <= 1114111 { 1608 goto tr67 1609 } 1610 case data[p] >= 97: 1611 goto tr67 1612 } 1613 default: 1614 goto tr67 1615 } 1616 goto tr0 1617 tr67: 1618 //line parse_actions.rl:24 1619 1620 iri = p 1621 1622 goto st37 1623 st37: 1624 if p++; p == pe { 1625 goto _test_eof37 1626 } 1627 st_case_37: 1628 //line parse.go:1629 1629 switch data[p] { 1630 case 62: 1631 goto tr71 1632 case 92: 1633 goto st39 1634 case 95: 1635 goto st37 1636 case 126: 1637 goto st37 1638 } 1639 switch { 1640 case data[p] < 61: 1641 if 33 <= data[p] && data[p] <= 59 { 1642 goto st37 1643 } 1644 case data[p] > 93: 1645 switch { 1646 case data[p] > 122: 1647 if 128 <= data[p] && data[p] <= 1114111 { 1648 goto st37 1649 } 1650 case data[p] >= 97: 1651 goto st37 1652 } 1653 default: 1654 goto st37 1655 } 1656 goto tr0 1657 tr68: 1658 //line parse_actions.rl:24 1659 1660 iri = p 1661 1662 //line parse_actions.rl:56 1663 1664 if iri < 0 { 1665 panic("unexpected parser state: iri start not set") 1666 } 1667 switch u, err := url.Parse(string(data[iri:p])); { 1668 case err != nil: 1669 return s, err 1670 case !u.IsAbs(): 1671 return s, fmt.Errorf("%w: relative IRI ref %q", ErrInvalid, string(data[iri:p])) 1672 } 1673 1674 goto st38 1675 tr71: 1676 //line parse_actions.rl:56 1677 1678 if iri < 0 { 1679 panic("unexpected parser state: iri start not set") 1680 } 1681 switch u, err := url.Parse(string(data[iri:p])); { 1682 case err != nil: 1683 return s, err 1684 case !u.IsAbs(): 1685 return s, fmt.Errorf("%w: relative IRI ref %q", ErrInvalid, string(data[iri:p])) 1686 } 1687 1688 goto st38 1689 st38: 1690 if p++; p == pe { 1691 goto _test_eof38 1692 } 1693 st_case_38: 1694 //line parse.go:1695 1695 switch data[p] { 1696 case 9: 1697 goto tr31 1698 case 32: 1699 goto tr31 1700 case 46: 1701 goto tr32 1702 case 60: 1703 goto tr33 1704 case 95: 1705 goto tr36 1706 } 1707 goto tr0 1708 tr69: 1709 //line parse_actions.rl:24 1710 1711 iri = p 1712 1713 goto st39 1714 st39: 1715 if p++; p == pe { 1716 goto _test_eof39 1717 } 1718 st_case_39: 1719 //line parse.go:1720 1720 switch data[p] { 1721 case 85: 1722 goto st40 1723 case 117: 1724 goto st44 1725 } 1726 goto tr0 1727 st40: 1728 if p++; p == pe { 1729 goto _test_eof40 1730 } 1731 st_case_40: 1732 switch { 1733 case data[p] < 65: 1734 if 48 <= data[p] && data[p] <= 57 { 1735 goto st41 1736 } 1737 case data[p] > 70: 1738 if 97 <= data[p] && data[p] <= 102 { 1739 goto st41 1740 } 1741 default: 1742 goto st41 1743 } 1744 goto tr0 1745 st41: 1746 if p++; p == pe { 1747 goto _test_eof41 1748 } 1749 st_case_41: 1750 switch { 1751 case data[p] < 65: 1752 if 48 <= data[p] && data[p] <= 57 { 1753 goto st42 1754 } 1755 case data[p] > 70: 1756 if 97 <= data[p] && data[p] <= 102 { 1757 goto st42 1758 } 1759 default: 1760 goto st42 1761 } 1762 goto tr0 1763 st42: 1764 if p++; p == pe { 1765 goto _test_eof42 1766 } 1767 st_case_42: 1768 switch { 1769 case data[p] < 65: 1770 if 48 <= data[p] && data[p] <= 57 { 1771 goto st43 1772 } 1773 case data[p] > 70: 1774 if 97 <= data[p] && data[p] <= 102 { 1775 goto st43 1776 } 1777 default: 1778 goto st43 1779 } 1780 goto tr0 1781 st43: 1782 if p++; p == pe { 1783 goto _test_eof43 1784 } 1785 st_case_43: 1786 switch { 1787 case data[p] < 65: 1788 if 48 <= data[p] && data[p] <= 57 { 1789 goto st44 1790 } 1791 case data[p] > 70: 1792 if 97 <= data[p] && data[p] <= 102 { 1793 goto st44 1794 } 1795 default: 1796 goto st44 1797 } 1798 goto tr0 1799 st44: 1800 if p++; p == pe { 1801 goto _test_eof44 1802 } 1803 st_case_44: 1804 switch { 1805 case data[p] < 65: 1806 if 48 <= data[p] && data[p] <= 57 { 1807 goto st45 1808 } 1809 case data[p] > 70: 1810 if 97 <= data[p] && data[p] <= 102 { 1811 goto st45 1812 } 1813 default: 1814 goto st45 1815 } 1816 goto tr0 1817 st45: 1818 if p++; p == pe { 1819 goto _test_eof45 1820 } 1821 st_case_45: 1822 switch { 1823 case data[p] < 65: 1824 if 48 <= data[p] && data[p] <= 57 { 1825 goto st46 1826 } 1827 case data[p] > 70: 1828 if 97 <= data[p] && data[p] <= 102 { 1829 goto st46 1830 } 1831 default: 1832 goto st46 1833 } 1834 goto tr0 1835 st46: 1836 if p++; p == pe { 1837 goto _test_eof46 1838 } 1839 st_case_46: 1840 switch { 1841 case data[p] < 65: 1842 if 48 <= data[p] && data[p] <= 57 { 1843 goto st47 1844 } 1845 case data[p] > 70: 1846 if 97 <= data[p] && data[p] <= 102 { 1847 goto st47 1848 } 1849 default: 1850 goto st47 1851 } 1852 goto tr0 1853 st47: 1854 if p++; p == pe { 1855 goto _test_eof47 1856 } 1857 st_case_47: 1858 switch { 1859 case data[p] < 65: 1860 if 48 <= data[p] && data[p] <= 57 { 1861 goto st37 1862 } 1863 case data[p] > 70: 1864 if 97 <= data[p] && data[p] <= 102 { 1865 goto st37 1866 } 1867 default: 1868 goto st37 1869 } 1870 goto tr0 1871 st48: 1872 if p++; p == pe { 1873 goto _test_eof48 1874 } 1875 st_case_48: 1876 switch data[p] { 1877 case 34: 1878 goto st10 1879 case 39: 1880 goto st10 1881 case 85: 1882 goto st49 1883 case 92: 1884 goto st10 1885 case 98: 1886 goto st10 1887 case 102: 1888 goto st10 1889 case 110: 1890 goto st10 1891 case 114: 1892 goto st10 1893 case 116: 1894 goto st10 1895 case 117: 1896 goto st53 1897 } 1898 goto tr0 1899 st49: 1900 if p++; p == pe { 1901 goto _test_eof49 1902 } 1903 st_case_49: 1904 switch { 1905 case data[p] < 65: 1906 if 48 <= data[p] && data[p] <= 57 { 1907 goto st50 1908 } 1909 case data[p] > 70: 1910 if 97 <= data[p] && data[p] <= 102 { 1911 goto st50 1912 } 1913 default: 1914 goto st50 1915 } 1916 goto tr0 1917 st50: 1918 if p++; p == pe { 1919 goto _test_eof50 1920 } 1921 st_case_50: 1922 switch { 1923 case data[p] < 65: 1924 if 48 <= data[p] && data[p] <= 57 { 1925 goto st51 1926 } 1927 case data[p] > 70: 1928 if 97 <= data[p] && data[p] <= 102 { 1929 goto st51 1930 } 1931 default: 1932 goto st51 1933 } 1934 goto tr0 1935 st51: 1936 if p++; p == pe { 1937 goto _test_eof51 1938 } 1939 st_case_51: 1940 switch { 1941 case data[p] < 65: 1942 if 48 <= data[p] && data[p] <= 57 { 1943 goto st52 1944 } 1945 case data[p] > 70: 1946 if 97 <= data[p] && data[p] <= 102 { 1947 goto st52 1948 } 1949 default: 1950 goto st52 1951 } 1952 goto tr0 1953 st52: 1954 if p++; p == pe { 1955 goto _test_eof52 1956 } 1957 st_case_52: 1958 switch { 1959 case data[p] < 65: 1960 if 48 <= data[p] && data[p] <= 57 { 1961 goto st53 1962 } 1963 case data[p] > 70: 1964 if 97 <= data[p] && data[p] <= 102 { 1965 goto st53 1966 } 1967 default: 1968 goto st53 1969 } 1970 goto tr0 1971 st53: 1972 if p++; p == pe { 1973 goto _test_eof53 1974 } 1975 st_case_53: 1976 switch { 1977 case data[p] < 65: 1978 if 48 <= data[p] && data[p] <= 57 { 1979 goto st54 1980 } 1981 case data[p] > 70: 1982 if 97 <= data[p] && data[p] <= 102 { 1983 goto st54 1984 } 1985 default: 1986 goto st54 1987 } 1988 goto tr0 1989 st54: 1990 if p++; p == pe { 1991 goto _test_eof54 1992 } 1993 st_case_54: 1994 switch { 1995 case data[p] < 65: 1996 if 48 <= data[p] && data[p] <= 57 { 1997 goto st55 1998 } 1999 case data[p] > 70: 2000 if 97 <= data[p] && data[p] <= 102 { 2001 goto st55 2002 } 2003 default: 2004 goto st55 2005 } 2006 goto tr0 2007 st55: 2008 if p++; p == pe { 2009 goto _test_eof55 2010 } 2011 st_case_55: 2012 switch { 2013 case data[p] < 65: 2014 if 48 <= data[p] && data[p] <= 57 { 2015 goto st56 2016 } 2017 case data[p] > 70: 2018 if 97 <= data[p] && data[p] <= 102 { 2019 goto st56 2020 } 2021 default: 2022 goto st56 2023 } 2024 goto tr0 2025 st56: 2026 if p++; p == pe { 2027 goto _test_eof56 2028 } 2029 st_case_56: 2030 switch { 2031 case data[p] < 65: 2032 if 48 <= data[p] && data[p] <= 57 { 2033 goto st10 2034 } 2035 case data[p] > 70: 2036 if 97 <= data[p] && data[p] <= 102 { 2037 goto st10 2038 } 2039 default: 2040 goto st10 2041 } 2042 goto tr0 2043 tr23: 2044 //line parse_actions.rl:35 2045 2046 if predicate < 0 { 2047 panic("unexpected parser state: predicate start not set") 2048 } 2049 s.Predicate.Value = string(data[predicate:p]) 2050 2051 //line parse_actions.rl:16 2052 2053 object = p 2054 2055 goto st57 2056 tr27: 2057 //line parse_actions.rl:16 2058 2059 object = p 2060 2061 goto st57 2062 st57: 2063 if p++; p == pe { 2064 goto _test_eof57 2065 } 2066 st_case_57: 2067 //line parse.go:2068 2068 if data[p] == 58 { 2069 goto st58 2070 } 2071 goto tr0 2072 st58: 2073 if p++; p == pe { 2074 goto _test_eof58 2075 } 2076 st_case_58: 2077 if data[p] == 95 { 2078 goto st59 2079 } 2080 switch { 2081 case data[p] < 895: 2082 switch { 2083 case data[p] < 192: 2084 switch { 2085 case data[p] < 65: 2086 if 48 <= data[p] && data[p] <= 58 { 2087 goto st59 2088 } 2089 case data[p] > 90: 2090 if 97 <= data[p] && data[p] <= 122 { 2091 goto st59 2092 } 2093 default: 2094 goto st59 2095 } 2096 case data[p] > 214: 2097 switch { 2098 case data[p] < 248: 2099 if 216 <= data[p] && data[p] <= 246 { 2100 goto st59 2101 } 2102 case data[p] > 767: 2103 if 880 <= data[p] && data[p] <= 893 { 2104 goto st59 2105 } 2106 default: 2107 goto st59 2108 } 2109 default: 2110 goto st59 2111 } 2112 case data[p] > 8191: 2113 switch { 2114 case data[p] < 12289: 2115 switch { 2116 case data[p] < 8304: 2117 if 8204 <= data[p] && data[p] <= 8205 { 2118 goto st59 2119 } 2120 case data[p] > 8591: 2121 if 11264 <= data[p] && data[p] <= 12271 { 2122 goto st59 2123 } 2124 default: 2125 goto st59 2126 } 2127 case data[p] > 55295: 2128 switch { 2129 case data[p] < 65008: 2130 if 63744 <= data[p] && data[p] <= 64975 { 2131 goto st59 2132 } 2133 case data[p] > 65533: 2134 if 65536 <= data[p] && data[p] <= 983039 { 2135 goto st59 2136 } 2137 default: 2138 goto st59 2139 } 2140 default: 2141 goto st59 2142 } 2143 default: 2144 goto st59 2145 } 2146 goto tr0 2147 st59: 2148 if p++; p == pe { 2149 goto _test_eof59 2150 } 2151 st_case_59: 2152 switch data[p] { 2153 case 9: 2154 goto tr31 2155 case 32: 2156 goto tr31 2157 case 45: 2158 goto st59 2159 case 46: 2160 goto tr91 2161 case 60: 2162 goto tr33 2163 case 95: 2164 goto tr92 2165 case 183: 2166 goto st59 2167 } 2168 switch { 2169 case data[p] < 8204: 2170 switch { 2171 case data[p] < 192: 2172 switch { 2173 case data[p] < 65: 2174 if 48 <= data[p] && data[p] <= 58 { 2175 goto st59 2176 } 2177 case data[p] > 90: 2178 if 97 <= data[p] && data[p] <= 122 { 2179 goto st59 2180 } 2181 default: 2182 goto st59 2183 } 2184 case data[p] > 214: 2185 switch { 2186 case data[p] < 248: 2187 if 216 <= data[p] && data[p] <= 246 { 2188 goto st59 2189 } 2190 case data[p] > 893: 2191 if 895 <= data[p] && data[p] <= 8191 { 2192 goto st59 2193 } 2194 default: 2195 goto st59 2196 } 2197 default: 2198 goto st59 2199 } 2200 case data[p] > 8205: 2201 switch { 2202 case data[p] < 12289: 2203 switch { 2204 case data[p] < 8304: 2205 if 8255 <= data[p] && data[p] <= 8256 { 2206 goto st59 2207 } 2208 case data[p] > 8591: 2209 if 11264 <= data[p] && data[p] <= 12271 { 2210 goto st59 2211 } 2212 default: 2213 goto st59 2214 } 2215 case data[p] > 55295: 2216 switch { 2217 case data[p] < 65008: 2218 if 63744 <= data[p] && data[p] <= 64975 { 2219 goto st59 2220 } 2221 case data[p] > 65533: 2222 if 65536 <= data[p] && data[p] <= 983039 { 2223 goto st59 2224 } 2225 default: 2226 goto st59 2227 } 2228 default: 2229 goto st59 2230 } 2231 default: 2232 goto st59 2233 } 2234 goto tr0 2235 tr91: 2236 //line parse_actions.rl:42 2237 2238 if object < 0 { 2239 panic("unexpected parser state: object start not set") 2240 } 2241 s.Object.Value = string(data[object:p]) 2242 2243 goto st90 2244 st90: 2245 if p++; p == pe { 2246 goto _test_eof90 2247 } 2248 st_case_90: 2249 //line parse.go:2250 2250 switch data[p] { 2251 case 9: 2252 goto st87 2253 case 32: 2254 goto st87 2255 case 35: 2256 goto tr120 2257 case 45: 2258 goto st59 2259 case 46: 2260 goto st60 2261 case 95: 2262 goto st59 2263 case 183: 2264 goto st59 2265 } 2266 switch { 2267 case data[p] < 8204: 2268 switch { 2269 case data[p] < 192: 2270 switch { 2271 case data[p] < 65: 2272 if 48 <= data[p] && data[p] <= 58 { 2273 goto st59 2274 } 2275 case data[p] > 90: 2276 if 97 <= data[p] && data[p] <= 122 { 2277 goto st59 2278 } 2279 default: 2280 goto st59 2281 } 2282 case data[p] > 214: 2283 switch { 2284 case data[p] < 248: 2285 if 216 <= data[p] && data[p] <= 246 { 2286 goto st59 2287 } 2288 case data[p] > 893: 2289 if 895 <= data[p] && data[p] <= 8191 { 2290 goto st59 2291 } 2292 default: 2293 goto st59 2294 } 2295 default: 2296 goto st59 2297 } 2298 case data[p] > 8205: 2299 switch { 2300 case data[p] < 12289: 2301 switch { 2302 case data[p] < 8304: 2303 if 8255 <= data[p] && data[p] <= 8256 { 2304 goto st59 2305 } 2306 case data[p] > 8591: 2307 if 11264 <= data[p] && data[p] <= 12271 { 2308 goto st59 2309 } 2310 default: 2311 goto st59 2312 } 2313 case data[p] > 55295: 2314 switch { 2315 case data[p] < 65008: 2316 if 63744 <= data[p] && data[p] <= 64975 { 2317 goto st59 2318 } 2319 case data[p] > 65533: 2320 if 65536 <= data[p] && data[p] <= 983039 { 2321 goto st59 2322 } 2323 default: 2324 goto st59 2325 } 2326 default: 2327 goto st59 2328 } 2329 default: 2330 goto st59 2331 } 2332 goto st0 2333 st60: 2334 if p++; p == pe { 2335 goto _test_eof60 2336 } 2337 st_case_60: 2338 switch data[p] { 2339 case 45: 2340 goto st59 2341 case 46: 2342 goto st60 2343 case 95: 2344 goto st59 2345 case 183: 2346 goto st59 2347 } 2348 switch { 2349 case data[p] < 8204: 2350 switch { 2351 case data[p] < 192: 2352 switch { 2353 case data[p] < 65: 2354 if 48 <= data[p] && data[p] <= 58 { 2355 goto st59 2356 } 2357 case data[p] > 90: 2358 if 97 <= data[p] && data[p] <= 122 { 2359 goto st59 2360 } 2361 default: 2362 goto st59 2363 } 2364 case data[p] > 214: 2365 switch { 2366 case data[p] < 248: 2367 if 216 <= data[p] && data[p] <= 246 { 2368 goto st59 2369 } 2370 case data[p] > 893: 2371 if 895 <= data[p] && data[p] <= 8191 { 2372 goto st59 2373 } 2374 default: 2375 goto st59 2376 } 2377 default: 2378 goto st59 2379 } 2380 case data[p] > 8205: 2381 switch { 2382 case data[p] < 12289: 2383 switch { 2384 case data[p] < 8304: 2385 if 8255 <= data[p] && data[p] <= 8256 { 2386 goto st59 2387 } 2388 case data[p] > 8591: 2389 if 11264 <= data[p] && data[p] <= 12271 { 2390 goto st59 2391 } 2392 default: 2393 goto st59 2394 } 2395 case data[p] > 55295: 2396 switch { 2397 case data[p] < 65008: 2398 if 63744 <= data[p] && data[p] <= 64975 { 2399 goto st59 2400 } 2401 case data[p] > 65533: 2402 if 65536 <= data[p] && data[p] <= 983039 { 2403 goto st59 2404 } 2405 default: 2406 goto st59 2407 } 2408 default: 2409 goto st59 2410 } 2411 default: 2412 goto st59 2413 } 2414 goto tr0 2415 tr92: 2416 //line parse_actions.rl:42 2417 2418 if object < 0 { 2419 panic("unexpected parser state: object start not set") 2420 } 2421 s.Object.Value = string(data[object:p]) 2422 2423 //line parse_actions.rl:20 2424 2425 label = p 2426 2427 goto st61 2428 st61: 2429 if p++; p == pe { 2430 goto _test_eof61 2431 } 2432 st_case_61: 2433 //line parse.go:2434 2434 switch data[p] { 2435 case 9: 2436 goto tr31 2437 case 32: 2438 goto tr31 2439 case 45: 2440 goto st59 2441 case 46: 2442 goto tr91 2443 case 58: 2444 goto st62 2445 case 60: 2446 goto tr33 2447 case 95: 2448 goto tr92 2449 case 183: 2450 goto st59 2451 } 2452 switch { 2453 case data[p] < 8204: 2454 switch { 2455 case data[p] < 192: 2456 switch { 2457 case data[p] < 65: 2458 if 48 <= data[p] && data[p] <= 57 { 2459 goto st59 2460 } 2461 case data[p] > 90: 2462 if 97 <= data[p] && data[p] <= 122 { 2463 goto st59 2464 } 2465 default: 2466 goto st59 2467 } 2468 case data[p] > 214: 2469 switch { 2470 case data[p] < 248: 2471 if 216 <= data[p] && data[p] <= 246 { 2472 goto st59 2473 } 2474 case data[p] > 893: 2475 if 895 <= data[p] && data[p] <= 8191 { 2476 goto st59 2477 } 2478 default: 2479 goto st59 2480 } 2481 default: 2482 goto st59 2483 } 2484 case data[p] > 8205: 2485 switch { 2486 case data[p] < 12289: 2487 switch { 2488 case data[p] < 8304: 2489 if 8255 <= data[p] && data[p] <= 8256 { 2490 goto st59 2491 } 2492 case data[p] > 8591: 2493 if 11264 <= data[p] && data[p] <= 12271 { 2494 goto st59 2495 } 2496 default: 2497 goto st59 2498 } 2499 case data[p] > 55295: 2500 switch { 2501 case data[p] < 65008: 2502 if 63744 <= data[p] && data[p] <= 64975 { 2503 goto st59 2504 } 2505 case data[p] > 65533: 2506 if 65536 <= data[p] && data[p] <= 983039 { 2507 goto st59 2508 } 2509 default: 2510 goto st59 2511 } 2512 default: 2513 goto st59 2514 } 2515 default: 2516 goto st59 2517 } 2518 goto tr0 2519 st62: 2520 if p++; p == pe { 2521 goto _test_eof62 2522 } 2523 st_case_62: 2524 switch data[p] { 2525 case 9: 2526 goto tr31 2527 case 32: 2528 goto tr31 2529 case 45: 2530 goto st59 2531 case 46: 2532 goto tr91 2533 case 60: 2534 goto tr33 2535 case 95: 2536 goto tr96 2537 case 183: 2538 goto st59 2539 } 2540 switch { 2541 case data[p] < 895: 2542 switch { 2543 case data[p] < 192: 2544 switch { 2545 case data[p] < 65: 2546 if 48 <= data[p] && data[p] <= 58 { 2547 goto st63 2548 } 2549 case data[p] > 90: 2550 if 97 <= data[p] && data[p] <= 122 { 2551 goto st63 2552 } 2553 default: 2554 goto st63 2555 } 2556 case data[p] > 214: 2557 switch { 2558 case data[p] < 248: 2559 if 216 <= data[p] && data[p] <= 246 { 2560 goto st63 2561 } 2562 case data[p] > 767: 2563 switch { 2564 case data[p] > 879: 2565 if 880 <= data[p] && data[p] <= 893 { 2566 goto st63 2567 } 2568 case data[p] >= 768: 2569 goto st59 2570 } 2571 default: 2572 goto st63 2573 } 2574 default: 2575 goto st63 2576 } 2577 case data[p] > 8191: 2578 switch { 2579 case data[p] < 11264: 2580 switch { 2581 case data[p] < 8255: 2582 if 8204 <= data[p] && data[p] <= 8205 { 2583 goto st63 2584 } 2585 case data[p] > 8256: 2586 if 8304 <= data[p] && data[p] <= 8591 { 2587 goto st63 2588 } 2589 default: 2590 goto st59 2591 } 2592 case data[p] > 12271: 2593 switch { 2594 case data[p] < 63744: 2595 if 12289 <= data[p] && data[p] <= 55295 { 2596 goto st63 2597 } 2598 case data[p] > 64975: 2599 switch { 2600 case data[p] > 65533: 2601 if 65536 <= data[p] && data[p] <= 983039 { 2602 goto st63 2603 } 2604 case data[p] >= 65008: 2605 goto st63 2606 } 2607 default: 2608 goto st63 2609 } 2610 default: 2611 goto st63 2612 } 2613 default: 2614 goto st63 2615 } 2616 goto tr0 2617 tr96: 2618 //line parse_actions.rl:42 2619 2620 if object < 0 { 2621 panic("unexpected parser state: object start not set") 2622 } 2623 s.Object.Value = string(data[object:p]) 2624 2625 //line parse_actions.rl:20 2626 2627 label = p 2628 2629 goto st63 2630 st63: 2631 if p++; p == pe { 2632 goto _test_eof63 2633 } 2634 st_case_63: 2635 //line parse.go:2636 2636 switch data[p] { 2637 case 9: 2638 goto tr97 2639 case 32: 2640 goto tr97 2641 case 45: 2642 goto st63 2643 case 46: 2644 goto tr98 2645 case 60: 2646 goto tr33 2647 case 95: 2648 goto tr96 2649 case 183: 2650 goto st63 2651 } 2652 switch { 2653 case data[p] < 8204: 2654 switch { 2655 case data[p] < 192: 2656 switch { 2657 case data[p] < 65: 2658 if 48 <= data[p] && data[p] <= 58 { 2659 goto st63 2660 } 2661 case data[p] > 90: 2662 if 97 <= data[p] && data[p] <= 122 { 2663 goto st63 2664 } 2665 default: 2666 goto st63 2667 } 2668 case data[p] > 214: 2669 switch { 2670 case data[p] < 248: 2671 if 216 <= data[p] && data[p] <= 246 { 2672 goto st63 2673 } 2674 case data[p] > 893: 2675 if 895 <= data[p] && data[p] <= 8191 { 2676 goto st63 2677 } 2678 default: 2679 goto st63 2680 } 2681 default: 2682 goto st63 2683 } 2684 case data[p] > 8205: 2685 switch { 2686 case data[p] < 12289: 2687 switch { 2688 case data[p] < 8304: 2689 if 8255 <= data[p] && data[p] <= 8256 { 2690 goto st63 2691 } 2692 case data[p] > 8591: 2693 if 11264 <= data[p] && data[p] <= 12271 { 2694 goto st63 2695 } 2696 default: 2697 goto st63 2698 } 2699 case data[p] > 55295: 2700 switch { 2701 case data[p] < 65008: 2702 if 63744 <= data[p] && data[p] <= 64975 { 2703 goto st63 2704 } 2705 case data[p] > 65533: 2706 if 65536 <= data[p] && data[p] <= 983039 { 2707 goto st63 2708 } 2709 default: 2710 goto st63 2711 } 2712 default: 2713 goto st63 2714 } 2715 default: 2716 goto st63 2717 } 2718 goto tr0 2719 tr98: 2720 //line parse_actions.rl:42 2721 2722 if object < 0 { 2723 panic("unexpected parser state: object start not set") 2724 } 2725 s.Object.Value = string(data[object:p]) 2726 2727 //line parse_actions.rl:49 2728 2729 if label < 0 { 2730 panic("unexpected parser state: label start not set") 2731 } 2732 s.Label.Value = string(data[label:p]) 2733 2734 goto st91 2735 st91: 2736 if p++; p == pe { 2737 goto _test_eof91 2738 } 2739 st_case_91: 2740 //line parse.go:2741 2741 switch data[p] { 2742 case 9: 2743 goto st87 2744 case 32: 2745 goto st87 2746 case 35: 2747 goto tr120 2748 case 45: 2749 goto st63 2750 case 46: 2751 goto st64 2752 case 95: 2753 goto st63 2754 case 183: 2755 goto st63 2756 } 2757 switch { 2758 case data[p] < 8204: 2759 switch { 2760 case data[p] < 192: 2761 switch { 2762 case data[p] < 65: 2763 if 48 <= data[p] && data[p] <= 58 { 2764 goto st63 2765 } 2766 case data[p] > 90: 2767 if 97 <= data[p] && data[p] <= 122 { 2768 goto st63 2769 } 2770 default: 2771 goto st63 2772 } 2773 case data[p] > 214: 2774 switch { 2775 case data[p] < 248: 2776 if 216 <= data[p] && data[p] <= 246 { 2777 goto st63 2778 } 2779 case data[p] > 893: 2780 if 895 <= data[p] && data[p] <= 8191 { 2781 goto st63 2782 } 2783 default: 2784 goto st63 2785 } 2786 default: 2787 goto st63 2788 } 2789 case data[p] > 8205: 2790 switch { 2791 case data[p] < 12289: 2792 switch { 2793 case data[p] < 8304: 2794 if 8255 <= data[p] && data[p] <= 8256 { 2795 goto st63 2796 } 2797 case data[p] > 8591: 2798 if 11264 <= data[p] && data[p] <= 12271 { 2799 goto st63 2800 } 2801 default: 2802 goto st63 2803 } 2804 case data[p] > 55295: 2805 switch { 2806 case data[p] < 65008: 2807 if 63744 <= data[p] && data[p] <= 64975 { 2808 goto st63 2809 } 2810 case data[p] > 65533: 2811 if 65536 <= data[p] && data[p] <= 983039 { 2812 goto st63 2813 } 2814 default: 2815 goto st63 2816 } 2817 default: 2818 goto st63 2819 } 2820 default: 2821 goto st63 2822 } 2823 goto st0 2824 st64: 2825 if p++; p == pe { 2826 goto _test_eof64 2827 } 2828 st_case_64: 2829 switch data[p] { 2830 case 45: 2831 goto st63 2832 case 46: 2833 goto st64 2834 case 95: 2835 goto st63 2836 case 183: 2837 goto st63 2838 } 2839 switch { 2840 case data[p] < 8204: 2841 switch { 2842 case data[p] < 192: 2843 switch { 2844 case data[p] < 65: 2845 if 48 <= data[p] && data[p] <= 58 { 2846 goto st63 2847 } 2848 case data[p] > 90: 2849 if 97 <= data[p] && data[p] <= 122 { 2850 goto st63 2851 } 2852 default: 2853 goto st63 2854 } 2855 case data[p] > 214: 2856 switch { 2857 case data[p] < 248: 2858 if 216 <= data[p] && data[p] <= 246 { 2859 goto st63 2860 } 2861 case data[p] > 893: 2862 if 895 <= data[p] && data[p] <= 8191 { 2863 goto st63 2864 } 2865 default: 2866 goto st63 2867 } 2868 default: 2869 goto st63 2870 } 2871 case data[p] > 8205: 2872 switch { 2873 case data[p] < 12289: 2874 switch { 2875 case data[p] < 8304: 2876 if 8255 <= data[p] && data[p] <= 8256 { 2877 goto st63 2878 } 2879 case data[p] > 8591: 2880 if 11264 <= data[p] && data[p] <= 12271 { 2881 goto st63 2882 } 2883 default: 2884 goto st63 2885 } 2886 case data[p] > 55295: 2887 switch { 2888 case data[p] < 65008: 2889 if 63744 <= data[p] && data[p] <= 64975 { 2890 goto st63 2891 } 2892 case data[p] > 65533: 2893 if 65536 <= data[p] && data[p] <= 983039 { 2894 goto st63 2895 } 2896 default: 2897 goto st63 2898 } 2899 default: 2900 goto st63 2901 } 2902 default: 2903 goto st63 2904 } 2905 goto tr0 2906 tr16: 2907 //line parse_actions.rl:24 2908 2909 iri = p 2910 2911 goto st65 2912 st65: 2913 if p++; p == pe { 2914 goto _test_eof65 2915 } 2916 st_case_65: 2917 //line parse.go:2918 2918 switch data[p] { 2919 case 85: 2920 goto st66 2921 case 117: 2922 goto st70 2923 } 2924 goto tr0 2925 st66: 2926 if p++; p == pe { 2927 goto _test_eof66 2928 } 2929 st_case_66: 2930 switch { 2931 case data[p] < 65: 2932 if 48 <= data[p] && data[p] <= 57 { 2933 goto st67 2934 } 2935 case data[p] > 70: 2936 if 97 <= data[p] && data[p] <= 102 { 2937 goto st67 2938 } 2939 default: 2940 goto st67 2941 } 2942 goto tr0 2943 st67: 2944 if p++; p == pe { 2945 goto _test_eof67 2946 } 2947 st_case_67: 2948 switch { 2949 case data[p] < 65: 2950 if 48 <= data[p] && data[p] <= 57 { 2951 goto st68 2952 } 2953 case data[p] > 70: 2954 if 97 <= data[p] && data[p] <= 102 { 2955 goto st68 2956 } 2957 default: 2958 goto st68 2959 } 2960 goto tr0 2961 st68: 2962 if p++; p == pe { 2963 goto _test_eof68 2964 } 2965 st_case_68: 2966 switch { 2967 case data[p] < 65: 2968 if 48 <= data[p] && data[p] <= 57 { 2969 goto st69 2970 } 2971 case data[p] > 70: 2972 if 97 <= data[p] && data[p] <= 102 { 2973 goto st69 2974 } 2975 default: 2976 goto st69 2977 } 2978 goto tr0 2979 st69: 2980 if p++; p == pe { 2981 goto _test_eof69 2982 } 2983 st_case_69: 2984 switch { 2985 case data[p] < 65: 2986 if 48 <= data[p] && data[p] <= 57 { 2987 goto st70 2988 } 2989 case data[p] > 70: 2990 if 97 <= data[p] && data[p] <= 102 { 2991 goto st70 2992 } 2993 default: 2994 goto st70 2995 } 2996 goto tr0 2997 st70: 2998 if p++; p == pe { 2999 goto _test_eof70 3000 } 3001 st_case_70: 3002 switch { 3003 case data[p] < 65: 3004 if 48 <= data[p] && data[p] <= 57 { 3005 goto st71 3006 } 3007 case data[p] > 70: 3008 if 97 <= data[p] && data[p] <= 102 { 3009 goto st71 3010 } 3011 default: 3012 goto st71 3013 } 3014 goto tr0 3015 st71: 3016 if p++; p == pe { 3017 goto _test_eof71 3018 } 3019 st_case_71: 3020 switch { 3021 case data[p] < 65: 3022 if 48 <= data[p] && data[p] <= 57 { 3023 goto st72 3024 } 3025 case data[p] > 70: 3026 if 97 <= data[p] && data[p] <= 102 { 3027 goto st72 3028 } 3029 default: 3030 goto st72 3031 } 3032 goto tr0 3033 st72: 3034 if p++; p == pe { 3035 goto _test_eof72 3036 } 3037 st_case_72: 3038 switch { 3039 case data[p] < 65: 3040 if 48 <= data[p] && data[p] <= 57 { 3041 goto st73 3042 } 3043 case data[p] > 70: 3044 if 97 <= data[p] && data[p] <= 102 { 3045 goto st73 3046 } 3047 default: 3048 goto st73 3049 } 3050 goto tr0 3051 st73: 3052 if p++; p == pe { 3053 goto _test_eof73 3054 } 3055 st_case_73: 3056 switch { 3057 case data[p] < 65: 3058 if 48 <= data[p] && data[p] <= 57 { 3059 goto st7 3060 } 3061 case data[p] > 70: 3062 if 97 <= data[p] && data[p] <= 102 { 3063 goto st7 3064 } 3065 default: 3066 goto st7 3067 } 3068 goto tr0 3069 tr6: 3070 //line parse_actions.rl:24 3071 3072 iri = p 3073 3074 goto st74 3075 st74: 3076 if p++; p == pe { 3077 goto _test_eof74 3078 } 3079 st_case_74: 3080 //line parse.go:3081 3081 switch data[p] { 3082 case 85: 3083 goto st75 3084 case 117: 3085 goto st79 3086 } 3087 goto tr0 3088 st75: 3089 if p++; p == pe { 3090 goto _test_eof75 3091 } 3092 st_case_75: 3093 switch { 3094 case data[p] < 65: 3095 if 48 <= data[p] && data[p] <= 57 { 3096 goto st76 3097 } 3098 case data[p] > 70: 3099 if 97 <= data[p] && data[p] <= 102 { 3100 goto st76 3101 } 3102 default: 3103 goto st76 3104 } 3105 goto tr0 3106 st76: 3107 if p++; p == pe { 3108 goto _test_eof76 3109 } 3110 st_case_76: 3111 switch { 3112 case data[p] < 65: 3113 if 48 <= data[p] && data[p] <= 57 { 3114 goto st77 3115 } 3116 case data[p] > 70: 3117 if 97 <= data[p] && data[p] <= 102 { 3118 goto st77 3119 } 3120 default: 3121 goto st77 3122 } 3123 goto tr0 3124 st77: 3125 if p++; p == pe { 3126 goto _test_eof77 3127 } 3128 st_case_77: 3129 switch { 3130 case data[p] < 65: 3131 if 48 <= data[p] && data[p] <= 57 { 3132 goto st78 3133 } 3134 case data[p] > 70: 3135 if 97 <= data[p] && data[p] <= 102 { 3136 goto st78 3137 } 3138 default: 3139 goto st78 3140 } 3141 goto tr0 3142 st78: 3143 if p++; p == pe { 3144 goto _test_eof78 3145 } 3146 st_case_78: 3147 switch { 3148 case data[p] < 65: 3149 if 48 <= data[p] && data[p] <= 57 { 3150 goto st79 3151 } 3152 case data[p] > 70: 3153 if 97 <= data[p] && data[p] <= 102 { 3154 goto st79 3155 } 3156 default: 3157 goto st79 3158 } 3159 goto tr0 3160 st79: 3161 if p++; p == pe { 3162 goto _test_eof79 3163 } 3164 st_case_79: 3165 switch { 3166 case data[p] < 65: 3167 if 48 <= data[p] && data[p] <= 57 { 3168 goto st80 3169 } 3170 case data[p] > 70: 3171 if 97 <= data[p] && data[p] <= 102 { 3172 goto st80 3173 } 3174 default: 3175 goto st80 3176 } 3177 goto tr0 3178 st80: 3179 if p++; p == pe { 3180 goto _test_eof80 3181 } 3182 st_case_80: 3183 switch { 3184 case data[p] < 65: 3185 if 48 <= data[p] && data[p] <= 57 { 3186 goto st81 3187 } 3188 case data[p] > 70: 3189 if 97 <= data[p] && data[p] <= 102 { 3190 goto st81 3191 } 3192 default: 3193 goto st81 3194 } 3195 goto tr0 3196 st81: 3197 if p++; p == pe { 3198 goto _test_eof81 3199 } 3200 st_case_81: 3201 switch { 3202 case data[p] < 65: 3203 if 48 <= data[p] && data[p] <= 57 { 3204 goto st82 3205 } 3206 case data[p] > 70: 3207 if 97 <= data[p] && data[p] <= 102 { 3208 goto st82 3209 } 3210 default: 3211 goto st82 3212 } 3213 goto tr0 3214 st82: 3215 if p++; p == pe { 3216 goto _test_eof82 3217 } 3218 st_case_82: 3219 switch { 3220 case data[p] < 65: 3221 if 48 <= data[p] && data[p] <= 57 { 3222 goto st3 3223 } 3224 case data[p] > 70: 3225 if 97 <= data[p] && data[p] <= 102 { 3226 goto st3 3227 } 3228 default: 3229 goto st3 3230 } 3231 goto tr0 3232 tr3: 3233 //line parse_actions.rl:8 3234 3235 subject = p 3236 3237 goto st83 3238 st83: 3239 if p++; p == pe { 3240 goto _test_eof83 3241 } 3242 st_case_83: 3243 //line parse.go:3244 3244 if data[p] == 58 { 3245 goto st84 3246 } 3247 goto tr0 3248 st84: 3249 if p++; p == pe { 3250 goto _test_eof84 3251 } 3252 st_case_84: 3253 if data[p] == 95 { 3254 goto st85 3255 } 3256 switch { 3257 case data[p] < 895: 3258 switch { 3259 case data[p] < 192: 3260 switch { 3261 case data[p] < 65: 3262 if 48 <= data[p] && data[p] <= 58 { 3263 goto st85 3264 } 3265 case data[p] > 90: 3266 if 97 <= data[p] && data[p] <= 122 { 3267 goto st85 3268 } 3269 default: 3270 goto st85 3271 } 3272 case data[p] > 214: 3273 switch { 3274 case data[p] < 248: 3275 if 216 <= data[p] && data[p] <= 246 { 3276 goto st85 3277 } 3278 case data[p] > 767: 3279 if 880 <= data[p] && data[p] <= 893 { 3280 goto st85 3281 } 3282 default: 3283 goto st85 3284 } 3285 default: 3286 goto st85 3287 } 3288 case data[p] > 8191: 3289 switch { 3290 case data[p] < 12289: 3291 switch { 3292 case data[p] < 8304: 3293 if 8204 <= data[p] && data[p] <= 8205 { 3294 goto st85 3295 } 3296 case data[p] > 8591: 3297 if 11264 <= data[p] && data[p] <= 12271 { 3298 goto st85 3299 } 3300 default: 3301 goto st85 3302 } 3303 case data[p] > 55295: 3304 switch { 3305 case data[p] < 65008: 3306 if 63744 <= data[p] && data[p] <= 64975 { 3307 goto st85 3308 } 3309 case data[p] > 65533: 3310 if 65536 <= data[p] && data[p] <= 983039 { 3311 goto st85 3312 } 3313 default: 3314 goto st85 3315 } 3316 default: 3317 goto st85 3318 } 3319 default: 3320 goto st85 3321 } 3322 goto tr0 3323 st85: 3324 if p++; p == pe { 3325 goto _test_eof85 3326 } 3327 st_case_85: 3328 switch data[p] { 3329 case 9: 3330 goto tr10 3331 case 32: 3332 goto tr10 3333 case 45: 3334 goto st85 3335 case 46: 3336 goto st86 3337 case 60: 3338 goto tr11 3339 case 95: 3340 goto st85 3341 case 183: 3342 goto st85 3343 } 3344 switch { 3345 case data[p] < 8204: 3346 switch { 3347 case data[p] < 192: 3348 switch { 3349 case data[p] < 65: 3350 if 48 <= data[p] && data[p] <= 58 { 3351 goto st85 3352 } 3353 case data[p] > 90: 3354 if 97 <= data[p] && data[p] <= 122 { 3355 goto st85 3356 } 3357 default: 3358 goto st85 3359 } 3360 case data[p] > 214: 3361 switch { 3362 case data[p] < 248: 3363 if 216 <= data[p] && data[p] <= 246 { 3364 goto st85 3365 } 3366 case data[p] > 893: 3367 if 895 <= data[p] && data[p] <= 8191 { 3368 goto st85 3369 } 3370 default: 3371 goto st85 3372 } 3373 default: 3374 goto st85 3375 } 3376 case data[p] > 8205: 3377 switch { 3378 case data[p] < 12289: 3379 switch { 3380 case data[p] < 8304: 3381 if 8255 <= data[p] && data[p] <= 8256 { 3382 goto st85 3383 } 3384 case data[p] > 8591: 3385 if 11264 <= data[p] && data[p] <= 12271 { 3386 goto st85 3387 } 3388 default: 3389 goto st85 3390 } 3391 case data[p] > 55295: 3392 switch { 3393 case data[p] < 65008: 3394 if 63744 <= data[p] && data[p] <= 64975 { 3395 goto st85 3396 } 3397 case data[p] > 65533: 3398 if 65536 <= data[p] && data[p] <= 983039 { 3399 goto st85 3400 } 3401 default: 3402 goto st85 3403 } 3404 default: 3405 goto st85 3406 } 3407 default: 3408 goto st85 3409 } 3410 goto tr0 3411 st86: 3412 if p++; p == pe { 3413 goto _test_eof86 3414 } 3415 st_case_86: 3416 switch data[p] { 3417 case 45: 3418 goto st85 3419 case 46: 3420 goto st86 3421 case 95: 3422 goto st85 3423 case 183: 3424 goto st85 3425 } 3426 switch { 3427 case data[p] < 8204: 3428 switch { 3429 case data[p] < 192: 3430 switch { 3431 case data[p] < 65: 3432 if 48 <= data[p] && data[p] <= 58 { 3433 goto st85 3434 } 3435 case data[p] > 90: 3436 if 97 <= data[p] && data[p] <= 122 { 3437 goto st85 3438 } 3439 default: 3440 goto st85 3441 } 3442 case data[p] > 214: 3443 switch { 3444 case data[p] < 248: 3445 if 216 <= data[p] && data[p] <= 246 { 3446 goto st85 3447 } 3448 case data[p] > 893: 3449 if 895 <= data[p] && data[p] <= 8191 { 3450 goto st85 3451 } 3452 default: 3453 goto st85 3454 } 3455 default: 3456 goto st85 3457 } 3458 case data[p] > 8205: 3459 switch { 3460 case data[p] < 12289: 3461 switch { 3462 case data[p] < 8304: 3463 if 8255 <= data[p] && data[p] <= 8256 { 3464 goto st85 3465 } 3466 case data[p] > 8591: 3467 if 11264 <= data[p] && data[p] <= 12271 { 3468 goto st85 3469 } 3470 default: 3471 goto st85 3472 } 3473 case data[p] > 55295: 3474 switch { 3475 case data[p] < 65008: 3476 if 63744 <= data[p] && data[p] <= 64975 { 3477 goto st85 3478 } 3479 case data[p] > 65533: 3480 if 65536 <= data[p] && data[p] <= 983039 { 3481 goto st85 3482 } 3483 default: 3484 goto st85 3485 } 3486 default: 3487 goto st85 3488 } 3489 default: 3490 goto st85 3491 } 3492 goto tr0 3493 st_out: 3494 _test_eof1: cs = 1; goto _test_eof 3495 _test_eof2: cs = 2; goto _test_eof 3496 _test_eof3: cs = 3; goto _test_eof 3497 _test_eof4: cs = 4; goto _test_eof 3498 _test_eof5: cs = 5; goto _test_eof 3499 _test_eof6: cs = 6; goto _test_eof 3500 _test_eof7: cs = 7; goto _test_eof 3501 _test_eof8: cs = 8; goto _test_eof 3502 _test_eof9: cs = 9; goto _test_eof 3503 _test_eof10: cs = 10; goto _test_eof 3504 _test_eof11: cs = 11; goto _test_eof 3505 _test_eof12: cs = 12; goto _test_eof 3506 _test_eof87: cs = 87; goto _test_eof 3507 _test_eof88: cs = 88; goto _test_eof 3508 _test_eof13: cs = 13; goto _test_eof 3509 _test_eof14: cs = 14; goto _test_eof 3510 _test_eof15: cs = 15; goto _test_eof 3511 _test_eof16: cs = 16; goto _test_eof 3512 _test_eof17: cs = 17; goto _test_eof 3513 _test_eof18: cs = 18; goto _test_eof 3514 _test_eof19: cs = 19; goto _test_eof 3515 _test_eof20: cs = 20; goto _test_eof 3516 _test_eof21: cs = 21; goto _test_eof 3517 _test_eof22: cs = 22; goto _test_eof 3518 _test_eof23: cs = 23; goto _test_eof 3519 _test_eof24: cs = 24; goto _test_eof 3520 _test_eof25: cs = 25; goto _test_eof 3521 _test_eof26: cs = 26; goto _test_eof 3522 _test_eof27: cs = 27; goto _test_eof 3523 _test_eof28: cs = 28; goto _test_eof 3524 _test_eof89: cs = 89; goto _test_eof 3525 _test_eof29: cs = 29; goto _test_eof 3526 _test_eof30: cs = 30; goto _test_eof 3527 _test_eof31: cs = 31; goto _test_eof 3528 _test_eof32: cs = 32; goto _test_eof 3529 _test_eof33: cs = 33; goto _test_eof 3530 _test_eof34: cs = 34; goto _test_eof 3531 _test_eof35: cs = 35; goto _test_eof 3532 _test_eof36: cs = 36; goto _test_eof 3533 _test_eof37: cs = 37; goto _test_eof 3534 _test_eof38: cs = 38; goto _test_eof 3535 _test_eof39: cs = 39; goto _test_eof 3536 _test_eof40: cs = 40; goto _test_eof 3537 _test_eof41: cs = 41; goto _test_eof 3538 _test_eof42: cs = 42; goto _test_eof 3539 _test_eof43: cs = 43; goto _test_eof 3540 _test_eof44: cs = 44; goto _test_eof 3541 _test_eof45: cs = 45; goto _test_eof 3542 _test_eof46: cs = 46; goto _test_eof 3543 _test_eof47: cs = 47; goto _test_eof 3544 _test_eof48: cs = 48; goto _test_eof 3545 _test_eof49: cs = 49; goto _test_eof 3546 _test_eof50: cs = 50; goto _test_eof 3547 _test_eof51: cs = 51; goto _test_eof 3548 _test_eof52: cs = 52; goto _test_eof 3549 _test_eof53: cs = 53; goto _test_eof 3550 _test_eof54: cs = 54; goto _test_eof 3551 _test_eof55: cs = 55; goto _test_eof 3552 _test_eof56: cs = 56; goto _test_eof 3553 _test_eof57: cs = 57; goto _test_eof 3554 _test_eof58: cs = 58; goto _test_eof 3555 _test_eof59: cs = 59; goto _test_eof 3556 _test_eof90: cs = 90; goto _test_eof 3557 _test_eof60: cs = 60; goto _test_eof 3558 _test_eof61: cs = 61; goto _test_eof 3559 _test_eof62: cs = 62; goto _test_eof 3560 _test_eof63: cs = 63; goto _test_eof 3561 _test_eof91: cs = 91; goto _test_eof 3562 _test_eof64: cs = 64; goto _test_eof 3563 _test_eof65: cs = 65; goto _test_eof 3564 _test_eof66: cs = 66; goto _test_eof 3565 _test_eof67: cs = 67; goto _test_eof 3566 _test_eof68: cs = 68; goto _test_eof 3567 _test_eof69: cs = 69; goto _test_eof 3568 _test_eof70: cs = 70; goto _test_eof 3569 _test_eof71: cs = 71; goto _test_eof 3570 _test_eof72: cs = 72; goto _test_eof 3571 _test_eof73: cs = 73; goto _test_eof 3572 _test_eof74: cs = 74; goto _test_eof 3573 _test_eof75: cs = 75; goto _test_eof 3574 _test_eof76: cs = 76; goto _test_eof 3575 _test_eof77: cs = 77; goto _test_eof 3576 _test_eof78: cs = 78; goto _test_eof 3577 _test_eof79: cs = 79; goto _test_eof 3578 _test_eof80: cs = 80; goto _test_eof 3579 _test_eof81: cs = 81; goto _test_eof 3580 _test_eof82: cs = 82; goto _test_eof 3581 _test_eof83: cs = 83; goto _test_eof 3582 _test_eof84: cs = 84; goto _test_eof 3583 _test_eof85: cs = 85; goto _test_eof 3584 _test_eof86: cs = 86; goto _test_eof 3585 3586 _test_eof: {} 3587 if p == eof { 3588 switch cs { 3589 case 88: 3590 //line parse_actions.rl:68 3591 3592 return s, nil 3593 3594 case 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86: 3595 //line parse_actions.rl:75 3596 3597 if p < len(data) { 3598 if r := data[p]; r < unicode.MaxASCII { 3599 return s, fmt.Errorf("%w: unexpected rune %q at %d", ErrInvalid, data[p], p) 3600 } else { 3601 return s, fmt.Errorf("%w: unexpected rune %q (\\u%04[2]x) at %d", ErrInvalid, data[p], p) 3602 } 3603 } 3604 return s, ErrIncomplete 3605 3606 case 87, 89, 90, 91: 3607 //line parse_actions.rl:72 3608 3609 3610 //line parse_actions.rl:68 3611 3612 return s, nil 3613 3614 //line parse.go:3615 3615 } 3616 } 3617 3618 _out: {} 3619 } 3620 3621 //line parse.rl:51 3622 3623 return Statement{}, ErrInvalid 3624 }