github.com/google/syzkaller@v0.0.0-20240517125934-c0f1611a36d6/tools/syz-trace2syz/parser/lex.go (about) 1 //line straceLex.rl:1 2 // Copyright 2018 syzkaller project authors. All rights reserved. 3 // Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file. 4 5 //go:build !codeanalysis 6 7 package parser 8 9 import ( 10 "encoding/hex" 11 "fmt" 12 "github.com/google/syzkaller/pkg/log" 13 "strconv" 14 "strings" 15 ) 16 17 //line lex.go:20 18 const strace_start int = 157 19 const strace_first_final int = 157 20 const strace_error int = 0 21 22 const strace_en_comment int = 207 23 const strace_en_main int = 157 24 25 //line straceLex.rl:22 26 27 type Stracelexer struct { 28 result *Syscall 29 data []byte 30 p, pe, cs int 31 ts, te, act int 32 } 33 34 func newStraceLexer(data []byte) *Stracelexer { 35 lex := &Stracelexer{ 36 data: data, 37 pe: len(data), 38 } 39 40 //line lex.go:46 41 { 42 lex.cs = strace_start 43 lex.ts = 0 44 lex.te = 0 45 lex.act = 0 46 } 47 48 //line straceLex.rl:38 49 return lex 50 } 51 52 func (lex *Stracelexer) Lex(out *StraceSymType) int { 53 eof := lex.pe 54 tok := 0 55 56 //line lex.go:62 57 { 58 if (lex.p) == (lex.pe) { 59 goto _test_eof 60 } 61 switch lex.cs { 62 case 157: 63 goto st_case_157 64 case 0: 65 goto st_case_0 66 case 1: 67 goto st_case_1 68 case 2: 69 goto st_case_2 70 case 158: 71 goto st_case_158 72 case 3: 73 goto st_case_3 74 case 4: 75 goto st_case_4 76 case 5: 77 goto st_case_5 78 case 6: 79 goto st_case_6 80 case 7: 81 goto st_case_7 82 case 8: 83 goto st_case_8 84 case 159: 85 goto st_case_159 86 case 160: 87 goto st_case_160 88 case 9: 89 goto st_case_9 90 case 161: 91 goto st_case_161 92 case 162: 93 goto st_case_162 94 case 10: 95 goto st_case_10 96 case 11: 97 goto st_case_11 98 case 12: 99 goto st_case_12 100 case 13: 101 goto st_case_13 102 case 14: 103 goto st_case_14 104 case 15: 105 goto st_case_15 106 case 16: 107 goto st_case_16 108 case 17: 109 goto st_case_17 110 case 18: 111 goto st_case_18 112 case 19: 113 goto st_case_19 114 case 20: 115 goto st_case_20 116 case 21: 117 goto st_case_21 118 case 22: 119 goto st_case_22 120 case 23: 121 goto st_case_23 122 case 24: 123 goto st_case_24 124 case 25: 125 goto st_case_25 126 case 26: 127 goto st_case_26 128 case 163: 129 goto st_case_163 130 case 27: 131 goto st_case_27 132 case 164: 133 goto st_case_164 134 case 165: 135 goto st_case_165 136 case 166: 137 goto st_case_166 138 case 167: 139 goto st_case_167 140 case 28: 141 goto st_case_28 142 case 29: 143 goto st_case_29 144 case 30: 145 goto st_case_30 146 case 168: 147 goto st_case_168 148 case 169: 149 goto st_case_169 150 case 31: 151 goto st_case_31 152 case 32: 153 goto st_case_32 154 case 170: 155 goto st_case_170 156 case 171: 157 goto st_case_171 158 case 172: 159 goto st_case_172 160 case 173: 161 goto st_case_173 162 case 33: 163 goto st_case_33 164 case 34: 165 goto st_case_34 166 case 35: 167 goto st_case_35 168 case 36: 169 goto st_case_36 170 case 174: 171 goto st_case_174 172 case 175: 173 goto st_case_175 174 case 37: 175 goto st_case_37 176 case 38: 177 goto st_case_38 178 case 39: 179 goto st_case_39 180 case 40: 181 goto st_case_40 182 case 41: 183 goto st_case_41 184 case 42: 185 goto st_case_42 186 case 43: 187 goto st_case_43 188 case 44: 189 goto st_case_44 190 case 45: 191 goto st_case_45 192 case 46: 193 goto st_case_46 194 case 47: 195 goto st_case_47 196 case 48: 197 goto st_case_48 198 case 49: 199 goto st_case_49 200 case 50: 201 goto st_case_50 202 case 176: 203 goto st_case_176 204 case 51: 205 goto st_case_51 206 case 52: 207 goto st_case_52 208 case 53: 209 goto st_case_53 210 case 54: 211 goto st_case_54 212 case 177: 213 goto st_case_177 214 case 55: 215 goto st_case_55 216 case 178: 217 goto st_case_178 218 case 179: 219 goto st_case_179 220 case 56: 221 goto st_case_56 222 case 57: 223 goto st_case_57 224 case 58: 225 goto st_case_58 226 case 59: 227 goto st_case_59 228 case 60: 229 goto st_case_60 230 case 61: 231 goto st_case_61 232 case 62: 233 goto st_case_62 234 case 63: 235 goto st_case_63 236 case 64: 237 goto st_case_64 238 case 65: 239 goto st_case_65 240 case 66: 241 goto st_case_66 242 case 67: 243 goto st_case_67 244 case 68: 245 goto st_case_68 246 case 69: 247 goto st_case_69 248 case 70: 249 goto st_case_70 250 case 71: 251 goto st_case_71 252 case 180: 253 goto st_case_180 254 case 181: 255 goto st_case_181 256 case 72: 257 goto st_case_72 258 case 73: 259 goto st_case_73 260 case 74: 261 goto st_case_74 262 case 75: 263 goto st_case_75 264 case 76: 265 goto st_case_76 266 case 77: 267 goto st_case_77 268 case 78: 269 goto st_case_78 270 case 79: 271 goto st_case_79 272 case 80: 273 goto st_case_80 274 case 81: 275 goto st_case_81 276 case 82: 277 goto st_case_82 278 case 83: 279 goto st_case_83 280 case 84: 281 goto st_case_84 282 case 85: 283 goto st_case_85 284 case 182: 285 goto st_case_182 286 case 86: 287 goto st_case_86 288 case 87: 289 goto st_case_87 290 case 88: 291 goto st_case_88 292 case 89: 293 goto st_case_89 294 case 90: 295 goto st_case_90 296 case 91: 297 goto st_case_91 298 case 92: 299 goto st_case_92 300 case 93: 301 goto st_case_93 302 case 94: 303 goto st_case_94 304 case 95: 305 goto st_case_95 306 case 96: 307 goto st_case_96 308 case 97: 309 goto st_case_97 310 case 98: 311 goto st_case_98 312 case 99: 313 goto st_case_99 314 case 100: 315 goto st_case_100 316 case 101: 317 goto st_case_101 318 case 102: 319 goto st_case_102 320 case 103: 321 goto st_case_103 322 case 104: 323 goto st_case_104 324 case 105: 325 goto st_case_105 326 case 106: 327 goto st_case_106 328 case 107: 329 goto st_case_107 330 case 108: 331 goto st_case_108 332 case 109: 333 goto st_case_109 334 case 110: 335 goto st_case_110 336 case 111: 337 goto st_case_111 338 case 112: 339 goto st_case_112 340 case 113: 341 goto st_case_113 342 case 114: 343 goto st_case_114 344 case 115: 345 goto st_case_115 346 case 116: 347 goto st_case_116 348 case 117: 349 goto st_case_117 350 case 118: 351 goto st_case_118 352 case 119: 353 goto st_case_119 354 case 120: 355 goto st_case_120 356 case 121: 357 goto st_case_121 358 case 122: 359 goto st_case_122 360 case 123: 361 goto st_case_123 362 case 124: 363 goto st_case_124 364 case 125: 365 goto st_case_125 366 case 126: 367 goto st_case_126 368 case 127: 369 goto st_case_127 370 case 128: 371 goto st_case_128 372 case 129: 373 goto st_case_129 374 case 130: 375 goto st_case_130 376 case 131: 377 goto st_case_131 378 case 132: 379 goto st_case_132 380 case 133: 381 goto st_case_133 382 case 134: 383 goto st_case_134 384 case 135: 385 goto st_case_135 386 case 136: 387 goto st_case_136 388 case 137: 389 goto st_case_137 390 case 138: 391 goto st_case_138 392 case 139: 393 goto st_case_139 394 case 140: 395 goto st_case_140 396 case 141: 397 goto st_case_141 398 case 142: 399 goto st_case_142 400 case 143: 401 goto st_case_143 402 case 144: 403 goto st_case_144 404 case 145: 405 goto st_case_145 406 case 146: 407 goto st_case_146 408 case 147: 409 goto st_case_147 410 case 148: 411 goto st_case_148 412 case 149: 413 goto st_case_149 414 case 150: 415 goto st_case_150 416 case 151: 417 goto st_case_151 418 case 152: 419 goto st_case_152 420 case 153: 421 goto st_case_153 422 case 154: 423 goto st_case_154 424 case 183: 425 goto st_case_183 426 case 155: 427 goto st_case_155 428 case 184: 429 goto st_case_184 430 case 185: 431 goto st_case_185 432 case 186: 433 goto st_case_186 434 case 187: 435 goto st_case_187 436 case 188: 437 goto st_case_188 438 case 189: 439 goto st_case_189 440 case 190: 441 goto st_case_190 442 case 191: 443 goto st_case_191 444 case 192: 445 goto st_case_192 446 case 193: 447 goto st_case_193 448 case 194: 449 goto st_case_194 450 case 195: 451 goto st_case_195 452 case 196: 453 goto st_case_196 454 case 197: 455 goto st_case_197 456 case 198: 457 goto st_case_198 458 case 199: 459 goto st_case_199 460 case 200: 461 goto st_case_200 462 case 201: 463 goto st_case_201 464 case 202: 465 goto st_case_202 466 case 203: 467 goto st_case_203 468 case 204: 469 goto st_case_204 470 case 205: 471 goto st_case_205 472 case 156: 473 goto st_case_156 474 case 206: 475 goto st_case_206 476 case 207: 477 goto st_case_207 478 case 208: 479 goto st_case_208 480 } 481 goto st_out 482 tr9: 483 //line NONE:1 484 switch lex.act { 485 case 0: 486 { 487 { 488 goto st0 489 } 490 } 491 case 3: 492 { 493 (lex.p) = (lex.te) - 1 494 out.val_int, _ = strconv.ParseInt(string(lex.data[lex.ts:lex.te]), 0, 64) 495 tok = INT 496 { 497 (lex.p)++ 498 lex.cs = 157 499 goto _out 500 } 501 } 502 case 4: 503 { 504 (lex.p) = (lex.te) - 1 505 out.val_double, _ = strconv.ParseFloat(string(lex.data[lex.ts:lex.te]), 64) 506 tok = DOUBLE 507 { 508 (lex.p)++ 509 lex.cs = 157 510 goto _out 511 } 512 } 513 case 7: 514 { 515 (lex.p) = (lex.te) - 1 516 tok = NULL 517 { 518 (lex.p)++ 519 lex.cs = 157 520 goto _out 521 } 522 } 523 case 8: 524 { 525 (lex.p) = (lex.te) - 1 526 out.data = string(lex.data[lex.ts:lex.te]) 527 tok = FLAG 528 { 529 (lex.p)++ 530 lex.cs = 157 531 goto _out 532 } 533 } 534 case 10: 535 { 536 (lex.p) = (lex.te) - 1 537 out.data = string(lex.data[lex.ts:lex.te]) 538 tok = IDENTIFIER 539 { 540 (lex.p)++ 541 lex.cs = 157 542 goto _out 543 } 544 } 545 case 32: 546 { 547 (lex.p) = (lex.te) - 1 548 tok = COMMA 549 { 550 (lex.p)++ 551 lex.cs = 157 552 goto _out 553 } 554 } 555 } 556 557 goto st157 558 tr11: 559 //line straceLex.rl:99 560 (lex.p) = (lex.te) - 1 561 { 562 tok = COMMA 563 { 564 (lex.p)++ 565 lex.cs = 157 566 goto _out 567 } 568 } 569 goto st157 570 tr28: 571 //line straceLex.rl:78 572 lex.te = (lex.p) + 1 573 { 574 tok = UNFINISHED 575 { 576 (lex.p)++ 577 lex.cs = 157 578 goto _out 579 } 580 } 581 goto st157 582 tr30: 583 //line straceLex.rl:89 584 lex.te = (lex.p) + 1 585 { 586 tok = RBRACKET 587 { 588 (lex.p)++ 589 lex.cs = 157 590 goto _out 591 } 592 } 593 goto st157 594 tr36: 595 //line straceLex.rl:70 596 (lex.p) = (lex.te) - 1 597 { 598 out.val_int, _ = strconv.ParseInt(string(lex.data[lex.ts:lex.te]), 0, 64) 599 tok = INT 600 { 601 (lex.p)++ 602 lex.cs = 157 603 goto _out 604 } 605 } 606 goto st157 607 tr55: 608 //line straceLex.rl:103 609 (lex.p) = (lex.te) - 1 610 { 611 out.data = string(lex.data[lex.ts:lex.te]) 612 tok = DATETIME 613 { 614 (lex.p)++ 615 lex.cs = 157 616 goto _out 617 } 618 } 619 goto st157 620 tr74: 621 //line straceLex.rl:80 622 lex.te = (lex.p) + 1 623 { 624 out.data = string(lex.data[lex.ts:lex.te]) 625 tok = MAC 626 { 627 (lex.p)++ 628 lex.cs = 157 629 goto _out 630 } 631 } 632 goto st157 633 tr78: 634 //line straceLex.rl:95 635 lex.te = (lex.p) + 1 636 { 637 tok = LSHIFT 638 { 639 (lex.p)++ 640 lex.cs = 157 641 goto _out 642 } 643 } 644 goto st157 645 tr94: 646 //line straceLex.rl:79 647 (lex.p) = (lex.te) - 1 648 { 649 tok = RESUMED 650 { 651 (lex.p)++ 652 lex.cs = 157 653 goto _out 654 } 655 } 656 goto st157 657 tr95: 658 //line straceLex.rl:79 659 lex.te = (lex.p) + 1 660 { 661 tok = RESUMED 662 { 663 (lex.p)++ 664 lex.cs = 157 665 goto _out 666 } 667 } 668 goto st157 669 tr162: 670 //line straceLex.rl:96 671 lex.te = (lex.p) + 1 672 { 673 tok = RSHIFT 674 { 675 (lex.p)++ 676 lex.cs = 157 677 goto _out 678 } 679 } 680 goto st157 681 tr165: 682 //line straceLex.rl:106 683 lex.te = (lex.p) + 1 684 685 goto st157 686 tr166: 687 //line straceLex.rl:93 688 lex.te = (lex.p) + 1 689 { 690 tok = NOT 691 { 692 (lex.p)++ 693 lex.cs = 157 694 goto _out 695 } 696 } 697 goto st157 698 tr168: 699 //line straceLex.rl:92 700 lex.te = (lex.p) + 1 701 { 702 tok = AND 703 { 704 (lex.p)++ 705 lex.cs = 157 706 goto _out 707 } 708 } 709 goto st157 710 tr170: 711 //line straceLex.rl:82 712 lex.te = (lex.p) + 1 713 { 714 tok = LPAREN 715 { 716 (lex.p)++ 717 lex.cs = 157 718 goto _out 719 } 720 } 721 goto st157 722 tr171: 723 //line straceLex.rl:84 724 lex.te = (lex.p) + 1 725 { 726 tok = RPAREN 727 { 728 (lex.p)++ 729 lex.cs = 157 730 goto _out 731 } 732 } 733 goto st157 734 tr172: 735 //line straceLex.rl:87 736 lex.te = (lex.p) + 1 737 { 738 tok = TIMES 739 { 740 (lex.p)++ 741 lex.cs = 157 742 goto _out 743 } 744 } 745 goto st157 746 tr173: 747 //line straceLex.rl:101 748 lex.te = (lex.p) + 1 749 { 750 tok = PLUS 751 { 752 (lex.p)++ 753 lex.cs = 157 754 goto _out 755 } 756 } 757 goto st157 758 tr183: 759 //line straceLex.rl:105 760 lex.te = (lex.p) + 1 761 { 762 tok = QUESTION 763 { 764 (lex.p)++ 765 lex.cs = 157 766 goto _out 767 } 768 } 769 goto st157 770 tr187: 771 //line straceLex.rl:85 772 lex.te = (lex.p) + 1 773 { 774 tok = LBRACKET_SQUARE 775 { 776 (lex.p)++ 777 lex.cs = 157 778 goto _out 779 } 780 } 781 goto st157 782 tr188: 783 //line straceLex.rl:86 784 lex.te = (lex.p) + 1 785 { 786 tok = RBRACKET_SQUARE 787 { 788 (lex.p)++ 789 lex.cs = 157 790 goto _out 791 } 792 } 793 goto st157 794 tr190: 795 //line straceLex.rl:88 796 lex.te = (lex.p) + 1 797 { 798 tok = LBRACKET 799 { 800 (lex.p)++ 801 lex.cs = 157 802 goto _out 803 } 804 } 805 goto st157 806 tr191: 807 //line straceLex.rl:90 808 lex.te = (lex.p) + 1 809 { 810 tok = OR 811 { 812 (lex.p)++ 813 lex.cs = 157 814 goto _out 815 } 816 } 817 goto st157 818 tr192: 819 //line straceLex.rl:94 820 lex.te = (lex.p) + 1 821 { 822 tok = ONESCOMP 823 { 824 (lex.p)++ 825 lex.cs = 157 826 goto _out 827 } 828 } 829 goto st157 830 tr193: 831 //line straceLex.rl:73 832 lex.te = (lex.p) 833 (lex.p)-- 834 { 835 out.data = ParseString(string(lex.data[lex.ts+1 : lex.te-1])) 836 tok = STRING_LITERAL 837 { 838 (lex.p)++ 839 lex.cs = 157 840 goto _out 841 } 842 } 843 goto st157 844 tr194: 845 //line straceLex.rl:77 846 lex.te = (lex.p) 847 (lex.p)-- 848 { 849 out.data = string(lex.data[lex.ts:lex.te]) 850 tok = IDENTIFIER 851 { 852 (lex.p)++ 853 lex.cs = 157 854 goto _out 855 } 856 } 857 goto st157 858 tr195: 859 //line straceLex.rl:99 860 lex.te = (lex.p) 861 (lex.p)-- 862 { 863 tok = COMMA 864 { 865 (lex.p)++ 866 lex.cs = 157 867 goto _out 868 } 869 } 870 goto st157 871 tr197: 872 //line straceLex.rl:100 873 lex.te = (lex.p) 874 (lex.p)-- 875 { 876 tok = MINUS 877 { 878 (lex.p)++ 879 lex.cs = 157 880 goto _out 881 } 882 } 883 goto st157 884 tr198: 885 //line straceLex.rl:97 886 lex.te = (lex.p) + 1 887 { 888 tok = ARROW 889 { 890 (lex.p)++ 891 lex.cs = 157 892 goto _out 893 } 894 } 895 goto st157 896 tr199: 897 //line straceLex.rl:102 898 lex.te = (lex.p) 899 (lex.p)-- 900 { 901 tok = FORWARDSLASH 902 { 903 (lex.p)++ 904 lex.cs = 157 905 goto _out 906 } 907 } 908 goto st157 909 tr200: 910 //line straceLex.rl:104 911 lex.te = (lex.p) + 1 912 { 913 { 914 goto st207 915 } 916 } 917 goto st157 918 tr201: 919 //line straceLex.rl:70 920 lex.te = (lex.p) 921 (lex.p)-- 922 { 923 out.val_int, _ = strconv.ParseInt(string(lex.data[lex.ts:lex.te]), 0, 64) 924 tok = INT 925 { 926 (lex.p)++ 927 lex.cs = 157 928 goto _out 929 } 930 } 931 goto st157 932 tr206: 933 //line straceLex.rl:71 934 lex.te = (lex.p) 935 (lex.p)-- 936 { 937 out.val_double, _ = strconv.ParseFloat(string(lex.data[lex.ts:lex.te]), 64) 938 tok = DOUBLE 939 { 940 (lex.p)++ 941 lex.cs = 157 942 goto _out 943 } 944 } 945 goto st157 946 tr210: 947 //line straceLex.rl:77 948 lex.te = (lex.p) + 1 949 { 950 out.data = string(lex.data[lex.ts:lex.te]) 951 tok = IDENTIFIER 952 { 953 (lex.p)++ 954 lex.cs = 157 955 goto _out 956 } 957 } 958 goto st157 959 tr218: 960 //line straceLex.rl:103 961 lex.te = (lex.p) 962 (lex.p)-- 963 { 964 out.data = string(lex.data[lex.ts:lex.te]) 965 tok = DATETIME 966 { 967 (lex.p)++ 968 lex.cs = 157 969 goto _out 970 } 971 } 972 goto st157 973 tr221: 974 //line straceLex.rl:72 975 lex.te = (lex.p) 976 (lex.p)-- 977 { 978 out.val_uint, _ = strconv.ParseUint(string(lex.data[lex.ts:lex.te]), 0, 64) 979 tok = UINT 980 { 981 (lex.p)++ 982 lex.cs = 157 983 goto _out 984 } 985 } 986 goto st157 987 tr222: 988 //line straceLex.rl:79 989 lex.te = (lex.p) 990 (lex.p)-- 991 { 992 tok = RESUMED 993 { 994 (lex.p)++ 995 lex.cs = 157 996 goto _out 997 } 998 } 999 goto st157 1000 tr224: 1001 //line straceLex.rl:81 1002 lex.te = (lex.p) 1003 (lex.p)-- 1004 { 1005 tok = EQUALS 1006 { 1007 (lex.p)++ 1008 lex.cs = 157 1009 goto _out 1010 } 1011 } 1012 goto st157 1013 tr225: 1014 //line straceLex.rl:98 1015 lex.te = (lex.p) + 1 1016 { 1017 tok = ARROW 1018 { 1019 (lex.p)++ 1020 lex.cs = 157 1021 goto _out 1022 } 1023 } 1024 goto st157 1025 tr226: 1026 //line straceLex.rl:83 1027 lex.te = (lex.p) + 1 1028 { 1029 tok = EQUALAT 1030 { 1031 (lex.p)++ 1032 lex.cs = 157 1033 goto _out 1034 } 1035 } 1036 goto st157 1037 tr231: 1038 //line straceLex.rl:75 1039 lex.te = (lex.p) 1040 (lex.p)-- 1041 { 1042 out.data = string(lex.data[lex.ts:lex.te]) 1043 tok = FLAG 1044 { 1045 (lex.p)++ 1046 lex.cs = 157 1047 goto _out 1048 } 1049 } 1050 goto st157 1051 st157: 1052 //line NONE:1 1053 lex.ts = 0 1054 1055 //line NONE:1 1056 lex.act = 0 1057 1058 if (lex.p)++; (lex.p) == (lex.pe) { 1059 goto _test_eof157 1060 } 1061 st_case_157: 1062 //line NONE:1 1063 lex.ts = (lex.p) 1064 1065 //line lex.go:740 1066 switch lex.data[(lex.p)] { 1067 case 32: 1068 goto tr165 1069 case 33: 1070 goto tr166 1071 case 34: 1072 goto st1 1073 case 38: 1074 goto tr168 1075 case 39: 1076 goto tr169 1077 case 40: 1078 goto tr170 1079 case 41: 1080 goto tr171 1081 case 42: 1082 goto tr172 1083 case 43: 1084 goto tr173 1085 case 44: 1086 goto tr174 1087 case 45: 1088 goto st163 1089 case 46: 1090 goto st27 1091 case 47: 1092 goto st164 1093 case 48: 1094 goto tr177 1095 case 58: 1096 goto st160 1097 case 60: 1098 goto st72 1099 case 61: 1100 goto st183 1101 case 62: 1102 goto st155 1103 case 63: 1104 goto tr183 1105 case 78: 1106 goto st203 1107 case 91: 1108 goto tr187 1109 case 93: 1110 goto tr188 1111 case 95: 1112 goto st156 1113 case 123: 1114 goto tr190 1115 case 124: 1116 goto tr191 1117 case 125: 1118 goto tr30 1119 case 126: 1120 goto tr192 1121 } 1122 switch { 1123 case lex.data[(lex.p)] < 65: 1124 switch { 1125 case lex.data[(lex.p)] > 13: 1126 if 49 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1127 goto tr178 1128 } 1129 case lex.data[(lex.p)] >= 9: 1130 goto tr165 1131 } 1132 case lex.data[(lex.p)] > 70: 1133 switch { 1134 case lex.data[(lex.p)] < 97: 1135 if 71 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 90 { 1136 goto tr185 1137 } 1138 case lex.data[(lex.p)] > 102: 1139 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1140 goto st160 1141 } 1142 default: 1143 goto tr189 1144 } 1145 default: 1146 goto st184 1147 } 1148 goto st0 1149 st_case_0: 1150 st0: 1151 lex.cs = 0 1152 goto _out 1153 st1: 1154 if (lex.p)++; (lex.p) == (lex.pe) { 1155 goto _test_eof1 1156 } 1157 st_case_1: 1158 switch lex.data[(lex.p)] { 1159 case 32: 1160 goto st2 1161 case 34: 1162 goto st158 1163 case 35: 1164 goto st2 1165 case 39: 1166 goto st3 1167 case 78: 1168 goto st6 1169 case 92: 1170 goto st2 1171 case 95: 1172 goto st3 1173 } 1174 switch { 1175 case lex.data[(lex.p)] < 46: 1176 if 40 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 42 { 1177 goto st2 1178 } 1179 case lex.data[(lex.p)] > 58: 1180 switch { 1181 case lex.data[(lex.p)] > 90: 1182 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1183 goto st2 1184 } 1185 case lex.data[(lex.p)] >= 65: 1186 goto st4 1187 } 1188 default: 1189 goto st2 1190 } 1191 goto st0 1192 st2: 1193 if (lex.p)++; (lex.p) == (lex.pe) { 1194 goto _test_eof2 1195 } 1196 st_case_2: 1197 switch lex.data[(lex.p)] { 1198 case 32: 1199 goto st2 1200 case 34: 1201 goto st158 1202 case 35: 1203 goto st2 1204 case 92: 1205 goto st2 1206 case 95: 1207 goto st2 1208 } 1209 switch { 1210 case lex.data[(lex.p)] < 46: 1211 if 39 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 42 { 1212 goto st2 1213 } 1214 case lex.data[(lex.p)] > 58: 1215 switch { 1216 case lex.data[(lex.p)] > 90: 1217 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1218 goto st2 1219 } 1220 case lex.data[(lex.p)] >= 65: 1221 goto st2 1222 } 1223 default: 1224 goto st2 1225 } 1226 goto st0 1227 st158: 1228 if (lex.p)++; (lex.p) == (lex.pe) { 1229 goto _test_eof158 1230 } 1231 st_case_158: 1232 switch lex.data[(lex.p)] { 1233 case 39: 1234 goto st158 1235 case 46: 1236 goto st158 1237 } 1238 goto tr193 1239 st3: 1240 if (lex.p)++; (lex.p) == (lex.pe) { 1241 goto _test_eof3 1242 } 1243 st_case_3: 1244 switch lex.data[(lex.p)] { 1245 case 32: 1246 goto st2 1247 case 34: 1248 goto st158 1249 case 35: 1250 goto st2 1251 case 39: 1252 goto st3 1253 case 92: 1254 goto st2 1255 case 95: 1256 goto st3 1257 } 1258 switch { 1259 case lex.data[(lex.p)] < 46: 1260 if 40 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 42 { 1261 goto st2 1262 } 1263 case lex.data[(lex.p)] > 58: 1264 switch { 1265 case lex.data[(lex.p)] > 90: 1266 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1267 goto st2 1268 } 1269 case lex.data[(lex.p)] >= 65: 1270 goto st4 1271 } 1272 default: 1273 goto st2 1274 } 1275 goto st0 1276 st4: 1277 if (lex.p)++; (lex.p) == (lex.pe) { 1278 goto _test_eof4 1279 } 1280 st_case_4: 1281 switch lex.data[(lex.p)] { 1282 case 32: 1283 goto st2 1284 case 34: 1285 goto st158 1286 case 35: 1287 goto st2 1288 case 39: 1289 goto st5 1290 case 58: 1291 goto st2 1292 case 92: 1293 goto st2 1294 case 95: 1295 goto st5 1296 } 1297 switch { 1298 case lex.data[(lex.p)] < 48: 1299 switch { 1300 case lex.data[(lex.p)] > 42: 1301 if 46 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 47 { 1302 goto st2 1303 } 1304 case lex.data[(lex.p)] >= 40: 1305 goto st2 1306 } 1307 case lex.data[(lex.p)] > 57: 1308 switch { 1309 case lex.data[(lex.p)] > 90: 1310 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1311 goto st2 1312 } 1313 case lex.data[(lex.p)] >= 65: 1314 goto st5 1315 } 1316 default: 1317 goto st5 1318 } 1319 goto st0 1320 st5: 1321 if (lex.p)++; (lex.p) == (lex.pe) { 1322 goto _test_eof5 1323 } 1324 st_case_5: 1325 switch lex.data[(lex.p)] { 1326 case 32: 1327 goto st2 1328 case 34: 1329 goto st158 1330 case 35: 1331 goto st2 1332 case 39: 1333 goto st5 1334 case 58: 1335 goto st2 1336 case 92: 1337 goto st2 1338 case 95: 1339 goto st5 1340 } 1341 switch { 1342 case lex.data[(lex.p)] < 48: 1343 switch { 1344 case lex.data[(lex.p)] > 42: 1345 if 46 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 47 { 1346 goto st2 1347 } 1348 case lex.data[(lex.p)] >= 40: 1349 goto st2 1350 } 1351 case lex.data[(lex.p)] > 57: 1352 switch { 1353 case lex.data[(lex.p)] > 90: 1354 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1355 goto st2 1356 } 1357 case lex.data[(lex.p)] >= 65: 1358 goto st5 1359 } 1360 default: 1361 goto st5 1362 } 1363 goto st0 1364 st6: 1365 if (lex.p)++; (lex.p) == (lex.pe) { 1366 goto _test_eof6 1367 } 1368 st_case_6: 1369 switch lex.data[(lex.p)] { 1370 case 32: 1371 goto st2 1372 case 34: 1373 goto st158 1374 case 35: 1375 goto st2 1376 case 39: 1377 goto st5 1378 case 58: 1379 goto st2 1380 case 85: 1381 goto st7 1382 case 92: 1383 goto st2 1384 case 95: 1385 goto st5 1386 } 1387 switch { 1388 case lex.data[(lex.p)] < 48: 1389 switch { 1390 case lex.data[(lex.p)] > 42: 1391 if 46 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 47 { 1392 goto st2 1393 } 1394 case lex.data[(lex.p)] >= 40: 1395 goto st2 1396 } 1397 case lex.data[(lex.p)] > 57: 1398 switch { 1399 case lex.data[(lex.p)] > 90: 1400 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1401 goto st2 1402 } 1403 case lex.data[(lex.p)] >= 65: 1404 goto st5 1405 } 1406 default: 1407 goto st5 1408 } 1409 goto st0 1410 st7: 1411 if (lex.p)++; (lex.p) == (lex.pe) { 1412 goto _test_eof7 1413 } 1414 st_case_7: 1415 switch lex.data[(lex.p)] { 1416 case 32: 1417 goto st2 1418 case 34: 1419 goto st158 1420 case 35: 1421 goto st2 1422 case 39: 1423 goto st5 1424 case 58: 1425 goto st2 1426 case 76: 1427 goto st8 1428 case 92: 1429 goto st2 1430 case 95: 1431 goto st5 1432 } 1433 switch { 1434 case lex.data[(lex.p)] < 48: 1435 switch { 1436 case lex.data[(lex.p)] > 42: 1437 if 46 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 47 { 1438 goto st2 1439 } 1440 case lex.data[(lex.p)] >= 40: 1441 goto st2 1442 } 1443 case lex.data[(lex.p)] > 57: 1444 switch { 1445 case lex.data[(lex.p)] > 90: 1446 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1447 goto st2 1448 } 1449 case lex.data[(lex.p)] >= 65: 1450 goto st5 1451 } 1452 default: 1453 goto st5 1454 } 1455 goto st0 1456 st8: 1457 if (lex.p)++; (lex.p) == (lex.pe) { 1458 goto _test_eof8 1459 } 1460 st_case_8: 1461 switch lex.data[(lex.p)] { 1462 case 32: 1463 goto st2 1464 case 34: 1465 goto st158 1466 case 35: 1467 goto st2 1468 case 39: 1469 goto st5 1470 case 58: 1471 goto st2 1472 case 76: 1473 goto st4 1474 case 92: 1475 goto st2 1476 case 95: 1477 goto st5 1478 } 1479 switch { 1480 case lex.data[(lex.p)] < 48: 1481 switch { 1482 case lex.data[(lex.p)] > 42: 1483 if 46 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 47 { 1484 goto st2 1485 } 1486 case lex.data[(lex.p)] >= 40: 1487 goto st2 1488 } 1489 case lex.data[(lex.p)] > 57: 1490 switch { 1491 case lex.data[(lex.p)] > 90: 1492 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1493 goto st2 1494 } 1495 case lex.data[(lex.p)] >= 65: 1496 goto st5 1497 } 1498 default: 1499 goto st5 1500 } 1501 goto st0 1502 tr169: 1503 //line NONE:1 1504 lex.te = (lex.p) + 1 1505 1506 //line straceLex.rl:77 1507 lex.act = 10 1508 goto st159 1509 st159: 1510 if (lex.p)++; (lex.p) == (lex.pe) { 1511 goto _test_eof159 1512 } 1513 st_case_159: 1514 //line lex.go:1189 1515 switch lex.data[(lex.p)] { 1516 case 39: 1517 goto tr169 1518 case 42: 1519 goto st160 1520 case 95: 1521 goto tr169 1522 } 1523 switch { 1524 case lex.data[(lex.p)] < 48: 1525 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 1526 goto st160 1527 } 1528 case lex.data[(lex.p)] > 58: 1529 switch { 1530 case lex.data[(lex.p)] > 90: 1531 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1532 goto st160 1533 } 1534 case lex.data[(lex.p)] >= 65: 1535 goto st9 1536 } 1537 default: 1538 goto st160 1539 } 1540 goto tr194 1541 st160: 1542 if (lex.p)++; (lex.p) == (lex.pe) { 1543 goto _test_eof160 1544 } 1545 st_case_160: 1546 switch lex.data[(lex.p)] { 1547 case 39: 1548 goto st160 1549 case 42: 1550 goto st160 1551 case 95: 1552 goto st160 1553 } 1554 switch { 1555 case lex.data[(lex.p)] < 48: 1556 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 1557 goto st160 1558 } 1559 case lex.data[(lex.p)] > 58: 1560 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 1561 goto st160 1562 } 1563 default: 1564 goto st160 1565 } 1566 goto tr194 1567 st9: 1568 if (lex.p)++; (lex.p) == (lex.pe) { 1569 goto _test_eof9 1570 } 1571 st_case_9: 1572 switch lex.data[(lex.p)] { 1573 case 39: 1574 goto tr10 1575 case 95: 1576 goto tr10 1577 } 1578 switch { 1579 case lex.data[(lex.p)] > 57: 1580 if 65 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 90 { 1581 goto tr10 1582 } 1583 case lex.data[(lex.p)] >= 48: 1584 goto tr10 1585 } 1586 goto tr9 1587 tr10: 1588 //line NONE:1 1589 lex.te = (lex.p) + 1 1590 1591 //line straceLex.rl:75 1592 lex.act = 8 1593 goto st161 1594 tr248: 1595 //line NONE:1 1596 lex.te = (lex.p) + 1 1597 1598 //line straceLex.rl:74 1599 lex.act = 7 1600 goto st161 1601 st161: 1602 if (lex.p)++; (lex.p) == (lex.pe) { 1603 goto _test_eof161 1604 } 1605 st_case_161: 1606 //line lex.go:1281 1607 switch lex.data[(lex.p)] { 1608 case 39: 1609 goto tr10 1610 case 95: 1611 goto tr10 1612 } 1613 switch { 1614 case lex.data[(lex.p)] > 57: 1615 if 65 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 90 { 1616 goto tr10 1617 } 1618 case lex.data[(lex.p)] >= 48: 1619 goto tr10 1620 } 1621 goto tr9 1622 tr174: 1623 //line NONE:1 1624 lex.te = (lex.p) + 1 1625 1626 //line straceLex.rl:99 1627 lex.act = 32 1628 goto st162 1629 st162: 1630 if (lex.p)++; (lex.p) == (lex.pe) { 1631 goto _test_eof162 1632 } 1633 st_case_162: 1634 //line lex.go:1309 1635 if lex.data[(lex.p)] == 32 { 1636 goto st10 1637 } 1638 goto tr195 1639 st10: 1640 if (lex.p)++; (lex.p) == (lex.pe) { 1641 goto _test_eof10 1642 } 1643 st_case_10: 1644 if lex.data[(lex.p)] == 32 { 1645 goto st11 1646 } 1647 goto tr11 1648 st11: 1649 if (lex.p)++; (lex.p) == (lex.pe) { 1650 goto _test_eof11 1651 } 1652 st_case_11: 1653 if lex.data[(lex.p)] == 60 { 1654 goto st12 1655 } 1656 goto tr11 1657 st12: 1658 if (lex.p)++; (lex.p) == (lex.pe) { 1659 goto _test_eof12 1660 } 1661 st_case_12: 1662 if lex.data[(lex.p)] == 117 { 1663 goto st13 1664 } 1665 goto tr11 1666 st13: 1667 if (lex.p)++; (lex.p) == (lex.pe) { 1668 goto _test_eof13 1669 } 1670 st_case_13: 1671 if lex.data[(lex.p)] == 110 { 1672 goto st14 1673 } 1674 goto tr9 1675 st14: 1676 if (lex.p)++; (lex.p) == (lex.pe) { 1677 goto _test_eof14 1678 } 1679 st_case_14: 1680 if lex.data[(lex.p)] == 102 { 1681 goto st15 1682 } 1683 goto tr9 1684 st15: 1685 if (lex.p)++; (lex.p) == (lex.pe) { 1686 goto _test_eof15 1687 } 1688 st_case_15: 1689 if lex.data[(lex.p)] == 105 { 1690 goto st16 1691 } 1692 goto tr9 1693 st16: 1694 if (lex.p)++; (lex.p) == (lex.pe) { 1695 goto _test_eof16 1696 } 1697 st_case_16: 1698 if lex.data[(lex.p)] == 110 { 1699 goto st17 1700 } 1701 goto tr9 1702 st17: 1703 if (lex.p)++; (lex.p) == (lex.pe) { 1704 goto _test_eof17 1705 } 1706 st_case_17: 1707 if lex.data[(lex.p)] == 105 { 1708 goto st18 1709 } 1710 goto tr9 1711 st18: 1712 if (lex.p)++; (lex.p) == (lex.pe) { 1713 goto _test_eof18 1714 } 1715 st_case_18: 1716 if lex.data[(lex.p)] == 115 { 1717 goto st19 1718 } 1719 goto tr9 1720 st19: 1721 if (lex.p)++; (lex.p) == (lex.pe) { 1722 goto _test_eof19 1723 } 1724 st_case_19: 1725 if lex.data[(lex.p)] == 104 { 1726 goto st20 1727 } 1728 goto tr9 1729 st20: 1730 if (lex.p)++; (lex.p) == (lex.pe) { 1731 goto _test_eof20 1732 } 1733 st_case_20: 1734 if lex.data[(lex.p)] == 101 { 1735 goto st21 1736 } 1737 goto tr9 1738 st21: 1739 if (lex.p)++; (lex.p) == (lex.pe) { 1740 goto _test_eof21 1741 } 1742 st_case_21: 1743 if lex.data[(lex.p)] == 100 { 1744 goto st22 1745 } 1746 goto tr9 1747 st22: 1748 if (lex.p)++; (lex.p) == (lex.pe) { 1749 goto _test_eof22 1750 } 1751 st_case_22: 1752 if lex.data[(lex.p)] == 32 { 1753 goto st23 1754 } 1755 goto tr9 1756 st23: 1757 if (lex.p)++; (lex.p) == (lex.pe) { 1758 goto _test_eof23 1759 } 1760 st_case_23: 1761 if lex.data[(lex.p)] == 46 { 1762 goto st24 1763 } 1764 goto tr9 1765 st24: 1766 if (lex.p)++; (lex.p) == (lex.pe) { 1767 goto _test_eof24 1768 } 1769 st_case_24: 1770 if lex.data[(lex.p)] == 46 { 1771 goto st25 1772 } 1773 goto tr9 1774 st25: 1775 if (lex.p)++; (lex.p) == (lex.pe) { 1776 goto _test_eof25 1777 } 1778 st_case_25: 1779 if lex.data[(lex.p)] == 46 { 1780 goto st26 1781 } 1782 goto tr9 1783 st26: 1784 if (lex.p)++; (lex.p) == (lex.pe) { 1785 goto _test_eof26 1786 } 1787 st_case_26: 1788 if lex.data[(lex.p)] == 62 { 1789 goto tr28 1790 } 1791 goto tr9 1792 st163: 1793 if (lex.p)++; (lex.p) == (lex.pe) { 1794 goto _test_eof163 1795 } 1796 st_case_163: 1797 if lex.data[(lex.p)] == 62 { 1798 goto tr198 1799 } 1800 goto tr197 1801 st27: 1802 if (lex.p)++; (lex.p) == (lex.pe) { 1803 goto _test_eof27 1804 } 1805 st_case_27: 1806 switch lex.data[(lex.p)] { 1807 case 46: 1808 goto st27 1809 case 125: 1810 goto tr30 1811 } 1812 goto st0 1813 st164: 1814 if (lex.p)++; (lex.p) == (lex.pe) { 1815 goto _test_eof164 1816 } 1817 st_case_164: 1818 if lex.data[(lex.p)] == 42 { 1819 goto tr200 1820 } 1821 goto tr199 1822 tr177: 1823 //line NONE:1 1824 lex.te = (lex.p) + 1 1825 1826 //line straceLex.rl:70 1827 lex.act = 3 1828 goto st165 1829 st165: 1830 if (lex.p)++; (lex.p) == (lex.pe) { 1831 goto _test_eof165 1832 } 1833 st_case_165: 1834 //line lex.go:1509 1835 switch lex.data[(lex.p)] { 1836 case 46: 1837 goto st166 1838 case 120: 1839 goto st71 1840 } 1841 switch { 1842 case lex.data[(lex.p)] < 65: 1843 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1844 goto tr203 1845 } 1846 case lex.data[(lex.p)] > 70: 1847 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 1848 goto st70 1849 } 1850 default: 1851 goto st70 1852 } 1853 goto tr201 1854 st166: 1855 if (lex.p)++; (lex.p) == (lex.pe) { 1856 goto _test_eof166 1857 } 1858 st_case_166: 1859 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1860 goto tr207 1861 } 1862 goto tr206 1863 tr207: 1864 //line NONE:1 1865 lex.te = (lex.p) + 1 1866 1867 //line straceLex.rl:71 1868 lex.act = 4 1869 goto st167 1870 st167: 1871 if (lex.p)++; (lex.p) == (lex.pe) { 1872 goto _test_eof167 1873 } 1874 st_case_167: 1875 //line lex.go:1550 1876 if lex.data[(lex.p)] == 46 { 1877 goto st28 1878 } 1879 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1880 goto tr208 1881 } 1882 goto tr206 1883 st28: 1884 if (lex.p)++; (lex.p) == (lex.pe) { 1885 goto _test_eof28 1886 } 1887 st_case_28: 1888 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1889 goto st29 1890 } 1891 goto tr9 1892 st29: 1893 if (lex.p)++; (lex.p) == (lex.pe) { 1894 goto _test_eof29 1895 } 1896 st_case_29: 1897 if lex.data[(lex.p)] == 46 { 1898 goto st30 1899 } 1900 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1901 goto st31 1902 } 1903 goto tr9 1904 st30: 1905 if (lex.p)++; (lex.p) == (lex.pe) { 1906 goto _test_eof30 1907 } 1908 st_case_30: 1909 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1910 goto st168 1911 } 1912 goto tr9 1913 st168: 1914 if (lex.p)++; (lex.p) == (lex.pe) { 1915 goto _test_eof168 1916 } 1917 st_case_168: 1918 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1919 goto st169 1920 } 1921 goto tr194 1922 st169: 1923 if (lex.p)++; (lex.p) == (lex.pe) { 1924 goto _test_eof169 1925 } 1926 st_case_169: 1927 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1928 goto tr210 1929 } 1930 goto tr194 1931 st31: 1932 if (lex.p)++; (lex.p) == (lex.pe) { 1933 goto _test_eof31 1934 } 1935 st_case_31: 1936 if lex.data[(lex.p)] == 46 { 1937 goto st30 1938 } 1939 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1940 goto st32 1941 } 1942 goto tr9 1943 st32: 1944 if (lex.p)++; (lex.p) == (lex.pe) { 1945 goto _test_eof32 1946 } 1947 st_case_32: 1948 if lex.data[(lex.p)] == 46 { 1949 goto st30 1950 } 1951 goto tr9 1952 tr208: 1953 //line NONE:1 1954 lex.te = (lex.p) + 1 1955 1956 //line straceLex.rl:71 1957 lex.act = 4 1958 goto st170 1959 st170: 1960 if (lex.p)++; (lex.p) == (lex.pe) { 1961 goto _test_eof170 1962 } 1963 st_case_170: 1964 //line lex.go:1639 1965 if lex.data[(lex.p)] == 46 { 1966 goto st28 1967 } 1968 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1969 goto tr211 1970 } 1971 goto tr206 1972 tr211: 1973 //line NONE:1 1974 lex.te = (lex.p) + 1 1975 1976 //line straceLex.rl:71 1977 lex.act = 4 1978 goto st171 1979 st171: 1980 if (lex.p)++; (lex.p) == (lex.pe) { 1981 goto _test_eof171 1982 } 1983 st_case_171: 1984 //line lex.go:1659 1985 if lex.data[(lex.p)] == 46 { 1986 goto st28 1987 } 1988 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1989 goto st172 1990 } 1991 goto tr206 1992 st172: 1993 if (lex.p)++; (lex.p) == (lex.pe) { 1994 goto _test_eof172 1995 } 1996 st_case_172: 1997 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 1998 goto st172 1999 } 2000 goto tr206 2001 tr203: 2002 //line NONE:1 2003 lex.te = (lex.p) + 1 2004 2005 //line straceLex.rl:70 2006 lex.act = 3 2007 goto st173 2008 st173: 2009 if (lex.p)++; (lex.p) == (lex.pe) { 2010 goto _test_eof173 2011 } 2012 st_case_173: 2013 //line lex.go:1688 2014 switch lex.data[(lex.p)] { 2015 case 46: 2016 goto st33 2017 case 58: 2018 goto st56 2019 } 2020 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2021 goto tr214 2022 } 2023 goto tr201 2024 st33: 2025 if (lex.p)++; (lex.p) == (lex.pe) { 2026 goto _test_eof33 2027 } 2028 st_case_33: 2029 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2030 goto st34 2031 } 2032 goto tr36 2033 st34: 2034 if (lex.p)++; (lex.p) == (lex.pe) { 2035 goto _test_eof34 2036 } 2037 st_case_34: 2038 if lex.data[(lex.p)] == 46 { 2039 goto st28 2040 } 2041 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2042 goto st35 2043 } 2044 goto tr36 2045 st35: 2046 if (lex.p)++; (lex.p) == (lex.pe) { 2047 goto _test_eof35 2048 } 2049 st_case_35: 2050 if lex.data[(lex.p)] == 46 { 2051 goto st28 2052 } 2053 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2054 goto st36 2055 } 2056 goto tr36 2057 st36: 2058 if (lex.p)++; (lex.p) == (lex.pe) { 2059 goto _test_eof36 2060 } 2061 st_case_36: 2062 if lex.data[(lex.p)] == 46 { 2063 goto st28 2064 } 2065 goto tr36 2066 tr214: 2067 //line NONE:1 2068 lex.te = (lex.p) + 1 2069 2070 //line straceLex.rl:70 2071 lex.act = 3 2072 goto st174 2073 st174: 2074 if (lex.p)++; (lex.p) == (lex.pe) { 2075 goto _test_eof174 2076 } 2077 st_case_174: 2078 //line lex.go:1753 2079 if lex.data[(lex.p)] == 46 { 2080 goto st33 2081 } 2082 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2083 goto tr215 2084 } 2085 goto tr201 2086 tr215: 2087 //line NONE:1 2088 lex.te = (lex.p) + 1 2089 2090 goto st175 2091 st175: 2092 if (lex.p)++; (lex.p) == (lex.pe) { 2093 goto _test_eof175 2094 } 2095 st_case_175: 2096 //line lex.go:1771 2097 switch lex.data[(lex.p)] { 2098 case 45: 2099 goto st37 2100 case 47: 2101 goto st37 2102 } 2103 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2104 goto st179 2105 } 2106 goto tr201 2107 st37: 2108 if (lex.p)++; (lex.p) == (lex.pe) { 2109 goto _test_eof37 2110 } 2111 st_case_37: 2112 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2113 goto st38 2114 } 2115 goto tr36 2116 st38: 2117 if (lex.p)++; (lex.p) == (lex.pe) { 2118 goto _test_eof38 2119 } 2120 st_case_38: 2121 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2122 goto st39 2123 } 2124 goto tr36 2125 st39: 2126 if (lex.p)++; (lex.p) == (lex.pe) { 2127 goto _test_eof39 2128 } 2129 st_case_39: 2130 switch lex.data[(lex.p)] { 2131 case 45: 2132 goto st40 2133 case 47: 2134 goto st40 2135 } 2136 goto tr36 2137 st40: 2138 if (lex.p)++; (lex.p) == (lex.pe) { 2139 goto _test_eof40 2140 } 2141 st_case_40: 2142 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2143 goto st41 2144 } 2145 goto tr36 2146 st41: 2147 if (lex.p)++; (lex.p) == (lex.pe) { 2148 goto _test_eof41 2149 } 2150 st_case_41: 2151 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2152 goto st42 2153 } 2154 goto tr36 2155 st42: 2156 if (lex.p)++; (lex.p) == (lex.pe) { 2157 goto _test_eof42 2158 } 2159 st_case_42: 2160 switch lex.data[(lex.p)] { 2161 case 45: 2162 goto st43 2163 case 84: 2164 goto st43 2165 } 2166 goto tr36 2167 st43: 2168 if (lex.p)++; (lex.p) == (lex.pe) { 2169 goto _test_eof43 2170 } 2171 st_case_43: 2172 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2173 goto st44 2174 } 2175 goto tr36 2176 st44: 2177 if (lex.p)++; (lex.p) == (lex.pe) { 2178 goto _test_eof44 2179 } 2180 st_case_44: 2181 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2182 goto st45 2183 } 2184 goto tr36 2185 st45: 2186 if (lex.p)++; (lex.p) == (lex.pe) { 2187 goto _test_eof45 2188 } 2189 st_case_45: 2190 if lex.data[(lex.p)] == 58 { 2191 goto st46 2192 } 2193 goto tr36 2194 st46: 2195 if (lex.p)++; (lex.p) == (lex.pe) { 2196 goto _test_eof46 2197 } 2198 st_case_46: 2199 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2200 goto st47 2201 } 2202 goto tr36 2203 st47: 2204 if (lex.p)++; (lex.p) == (lex.pe) { 2205 goto _test_eof47 2206 } 2207 st_case_47: 2208 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2209 goto st48 2210 } 2211 goto tr36 2212 st48: 2213 if (lex.p)++; (lex.p) == (lex.pe) { 2214 goto _test_eof48 2215 } 2216 st_case_48: 2217 if lex.data[(lex.p)] == 58 { 2218 goto st49 2219 } 2220 goto tr36 2221 st49: 2222 if (lex.p)++; (lex.p) == (lex.pe) { 2223 goto _test_eof49 2224 } 2225 st_case_49: 2226 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2227 goto st50 2228 } 2229 goto tr36 2230 st50: 2231 if (lex.p)++; (lex.p) == (lex.pe) { 2232 goto _test_eof50 2233 } 2234 st_case_50: 2235 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2236 goto tr54 2237 } 2238 goto tr36 2239 tr54: 2240 //line NONE:1 2241 lex.te = (lex.p) + 1 2242 2243 goto st176 2244 st176: 2245 if (lex.p)++; (lex.p) == (lex.pe) { 2246 goto _test_eof176 2247 } 2248 st_case_176: 2249 //line lex.go:1924 2250 switch lex.data[(lex.p)] { 2251 case 43: 2252 goto st51 2253 case 45: 2254 goto st51 2255 case 46: 2256 goto st55 2257 } 2258 goto tr218 2259 st51: 2260 if (lex.p)++; (lex.p) == (lex.pe) { 2261 goto _test_eof51 2262 } 2263 st_case_51: 2264 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2265 goto st52 2266 } 2267 goto tr55 2268 st52: 2269 if (lex.p)++; (lex.p) == (lex.pe) { 2270 goto _test_eof52 2271 } 2272 st_case_52: 2273 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2274 goto st53 2275 } 2276 goto tr55 2277 st53: 2278 if (lex.p)++; (lex.p) == (lex.pe) { 2279 goto _test_eof53 2280 } 2281 st_case_53: 2282 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2283 goto st54 2284 } 2285 goto tr55 2286 st54: 2287 if (lex.p)++; (lex.p) == (lex.pe) { 2288 goto _test_eof54 2289 } 2290 st_case_54: 2291 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2292 goto tr59 2293 } 2294 goto tr55 2295 tr59: 2296 //line NONE:1 2297 lex.te = (lex.p) + 1 2298 2299 goto st177 2300 st177: 2301 if (lex.p)++; (lex.p) == (lex.pe) { 2302 goto _test_eof177 2303 } 2304 st_case_177: 2305 //line lex.go:1980 2306 if lex.data[(lex.p)] == 46 { 2307 goto st55 2308 } 2309 goto tr218 2310 st55: 2311 if (lex.p)++; (lex.p) == (lex.pe) { 2312 goto _test_eof55 2313 } 2314 st_case_55: 2315 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2316 goto st178 2317 } 2318 goto tr55 2319 st178: 2320 if (lex.p)++; (lex.p) == (lex.pe) { 2321 goto _test_eof178 2322 } 2323 st_case_178: 2324 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2325 goto st178 2326 } 2327 goto tr218 2328 st179: 2329 if (lex.p)++; (lex.p) == (lex.pe) { 2330 goto _test_eof179 2331 } 2332 st_case_179: 2333 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2334 goto st179 2335 } 2336 goto tr201 2337 st56: 2338 if (lex.p)++; (lex.p) == (lex.pe) { 2339 goto _test_eof56 2340 } 2341 st_case_56: 2342 switch { 2343 case lex.data[(lex.p)] < 65: 2344 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2345 goto st57 2346 } 2347 case lex.data[(lex.p)] > 70: 2348 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2349 goto st57 2350 } 2351 default: 2352 goto st57 2353 } 2354 goto tr9 2355 st57: 2356 if (lex.p)++; (lex.p) == (lex.pe) { 2357 goto _test_eof57 2358 } 2359 st_case_57: 2360 switch { 2361 case lex.data[(lex.p)] < 65: 2362 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2363 goto st58 2364 } 2365 case lex.data[(lex.p)] > 70: 2366 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2367 goto st58 2368 } 2369 default: 2370 goto st58 2371 } 2372 goto tr9 2373 st58: 2374 if (lex.p)++; (lex.p) == (lex.pe) { 2375 goto _test_eof58 2376 } 2377 st_case_58: 2378 if lex.data[(lex.p)] == 58 { 2379 goto st59 2380 } 2381 goto tr9 2382 st59: 2383 if (lex.p)++; (lex.p) == (lex.pe) { 2384 goto _test_eof59 2385 } 2386 st_case_59: 2387 switch { 2388 case lex.data[(lex.p)] < 65: 2389 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2390 goto st60 2391 } 2392 case lex.data[(lex.p)] > 70: 2393 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2394 goto st60 2395 } 2396 default: 2397 goto st60 2398 } 2399 goto tr9 2400 st60: 2401 if (lex.p)++; (lex.p) == (lex.pe) { 2402 goto _test_eof60 2403 } 2404 st_case_60: 2405 switch { 2406 case lex.data[(lex.p)] < 65: 2407 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2408 goto st61 2409 } 2410 case lex.data[(lex.p)] > 70: 2411 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2412 goto st61 2413 } 2414 default: 2415 goto st61 2416 } 2417 goto tr9 2418 st61: 2419 if (lex.p)++; (lex.p) == (lex.pe) { 2420 goto _test_eof61 2421 } 2422 st_case_61: 2423 if lex.data[(lex.p)] == 58 { 2424 goto st62 2425 } 2426 goto tr9 2427 st62: 2428 if (lex.p)++; (lex.p) == (lex.pe) { 2429 goto _test_eof62 2430 } 2431 st_case_62: 2432 switch { 2433 case lex.data[(lex.p)] < 65: 2434 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2435 goto st63 2436 } 2437 case lex.data[(lex.p)] > 70: 2438 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2439 goto st63 2440 } 2441 default: 2442 goto st63 2443 } 2444 goto tr9 2445 st63: 2446 if (lex.p)++; (lex.p) == (lex.pe) { 2447 goto _test_eof63 2448 } 2449 st_case_63: 2450 switch { 2451 case lex.data[(lex.p)] < 65: 2452 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2453 goto st64 2454 } 2455 case lex.data[(lex.p)] > 70: 2456 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2457 goto st64 2458 } 2459 default: 2460 goto st64 2461 } 2462 goto tr9 2463 st64: 2464 if (lex.p)++; (lex.p) == (lex.pe) { 2465 goto _test_eof64 2466 } 2467 st_case_64: 2468 if lex.data[(lex.p)] == 58 { 2469 goto st65 2470 } 2471 goto tr9 2472 st65: 2473 if (lex.p)++; (lex.p) == (lex.pe) { 2474 goto _test_eof65 2475 } 2476 st_case_65: 2477 switch { 2478 case lex.data[(lex.p)] < 65: 2479 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2480 goto st66 2481 } 2482 case lex.data[(lex.p)] > 70: 2483 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2484 goto st66 2485 } 2486 default: 2487 goto st66 2488 } 2489 goto tr9 2490 st66: 2491 if (lex.p)++; (lex.p) == (lex.pe) { 2492 goto _test_eof66 2493 } 2494 st_case_66: 2495 switch { 2496 case lex.data[(lex.p)] < 65: 2497 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2498 goto st67 2499 } 2500 case lex.data[(lex.p)] > 70: 2501 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2502 goto st67 2503 } 2504 default: 2505 goto st67 2506 } 2507 goto tr9 2508 st67: 2509 if (lex.p)++; (lex.p) == (lex.pe) { 2510 goto _test_eof67 2511 } 2512 st_case_67: 2513 if lex.data[(lex.p)] == 58 { 2514 goto st68 2515 } 2516 goto tr9 2517 st68: 2518 if (lex.p)++; (lex.p) == (lex.pe) { 2519 goto _test_eof68 2520 } 2521 st_case_68: 2522 switch { 2523 case lex.data[(lex.p)] < 65: 2524 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2525 goto st69 2526 } 2527 case lex.data[(lex.p)] > 70: 2528 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2529 goto st69 2530 } 2531 default: 2532 goto st69 2533 } 2534 goto tr9 2535 st69: 2536 if (lex.p)++; (lex.p) == (lex.pe) { 2537 goto _test_eof69 2538 } 2539 st_case_69: 2540 switch { 2541 case lex.data[(lex.p)] < 65: 2542 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2543 goto tr74 2544 } 2545 case lex.data[(lex.p)] > 70: 2546 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2547 goto tr74 2548 } 2549 default: 2550 goto tr74 2551 } 2552 goto tr9 2553 st70: 2554 if (lex.p)++; (lex.p) == (lex.pe) { 2555 goto _test_eof70 2556 } 2557 st_case_70: 2558 if lex.data[(lex.p)] == 58 { 2559 goto st56 2560 } 2561 goto tr9 2562 st71: 2563 if (lex.p)++; (lex.p) == (lex.pe) { 2564 goto _test_eof71 2565 } 2566 st_case_71: 2567 switch { 2568 case lex.data[(lex.p)] < 65: 2569 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2570 goto st180 2571 } 2572 case lex.data[(lex.p)] > 70: 2573 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2574 goto st180 2575 } 2576 default: 2577 goto st180 2578 } 2579 goto tr36 2580 st180: 2581 if (lex.p)++; (lex.p) == (lex.pe) { 2582 goto _test_eof180 2583 } 2584 st_case_180: 2585 switch { 2586 case lex.data[(lex.p)] < 65: 2587 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2588 goto st180 2589 } 2590 case lex.data[(lex.p)] > 70: 2591 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2592 goto st180 2593 } 2594 default: 2595 goto st180 2596 } 2597 goto tr221 2598 tr178: 2599 //line NONE:1 2600 lex.te = (lex.p) + 1 2601 2602 //line straceLex.rl:70 2603 lex.act = 3 2604 goto st181 2605 st181: 2606 if (lex.p)++; (lex.p) == (lex.pe) { 2607 goto _test_eof181 2608 } 2609 st_case_181: 2610 //line lex.go:2285 2611 if lex.data[(lex.p)] == 46 { 2612 goto st166 2613 } 2614 switch { 2615 case lex.data[(lex.p)] < 65: 2616 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2617 goto tr203 2618 } 2619 case lex.data[(lex.p)] > 70: 2620 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 102 { 2621 goto st70 2622 } 2623 default: 2624 goto st70 2625 } 2626 goto tr201 2627 st72: 2628 if (lex.p)++; (lex.p) == (lex.pe) { 2629 goto _test_eof72 2630 } 2631 st_case_72: 2632 switch lex.data[(lex.p)] { 2633 case 46: 2634 goto st73 2635 case 60: 2636 goto tr78 2637 case 117: 2638 goto st13 2639 } 2640 goto st0 2641 st73: 2642 if (lex.p)++; (lex.p) == (lex.pe) { 2643 goto _test_eof73 2644 } 2645 st_case_73: 2646 if lex.data[(lex.p)] == 46 { 2647 goto st74 2648 } 2649 goto st0 2650 st74: 2651 if (lex.p)++; (lex.p) == (lex.pe) { 2652 goto _test_eof74 2653 } 2654 st_case_74: 2655 if lex.data[(lex.p)] == 46 { 2656 goto st75 2657 } 2658 goto st0 2659 st75: 2660 if (lex.p)++; (lex.p) == (lex.pe) { 2661 goto _test_eof75 2662 } 2663 st_case_75: 2664 if lex.data[(lex.p)] == 32 { 2665 goto st76 2666 } 2667 goto st0 2668 st76: 2669 if (lex.p)++; (lex.p) == (lex.pe) { 2670 goto _test_eof76 2671 } 2672 st_case_76: 2673 switch lex.data[(lex.p)] { 2674 case 39: 2675 goto st77 2676 case 58: 2677 goto st77 2678 case 114: 2679 goto st102 2680 } 2681 switch { 2682 case lex.data[(lex.p)] < 65: 2683 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2684 goto st87 2685 } 2686 case lex.data[(lex.p)] > 90: 2687 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 2688 goto st77 2689 } 2690 default: 2691 goto st77 2692 } 2693 goto st0 2694 st77: 2695 if (lex.p)++; (lex.p) == (lex.pe) { 2696 goto _test_eof77 2697 } 2698 st_case_77: 2699 switch lex.data[(lex.p)] { 2700 case 32: 2701 goto st78 2702 case 39: 2703 goto st77 2704 case 42: 2705 goto st77 2706 case 95: 2707 goto st77 2708 } 2709 switch { 2710 case lex.data[(lex.p)] < 48: 2711 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 2712 goto st77 2713 } 2714 case lex.data[(lex.p)] > 58: 2715 switch { 2716 case lex.data[(lex.p)] > 90: 2717 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 2718 goto st77 2719 } 2720 case lex.data[(lex.p)] >= 65: 2721 goto st77 2722 } 2723 default: 2724 goto st77 2725 } 2726 goto st0 2727 st78: 2728 if (lex.p)++; (lex.p) == (lex.pe) { 2729 goto _test_eof78 2730 } 2731 st_case_78: 2732 if lex.data[(lex.p)] == 114 { 2733 goto st79 2734 } 2735 goto st0 2736 st79: 2737 if (lex.p)++; (lex.p) == (lex.pe) { 2738 goto _test_eof79 2739 } 2740 st_case_79: 2741 if lex.data[(lex.p)] == 101 { 2742 goto st80 2743 } 2744 goto st0 2745 st80: 2746 if (lex.p)++; (lex.p) == (lex.pe) { 2747 goto _test_eof80 2748 } 2749 st_case_80: 2750 if lex.data[(lex.p)] == 115 { 2751 goto st81 2752 } 2753 goto st0 2754 st81: 2755 if (lex.p)++; (lex.p) == (lex.pe) { 2756 goto _test_eof81 2757 } 2758 st_case_81: 2759 if lex.data[(lex.p)] == 117 { 2760 goto st82 2761 } 2762 goto st0 2763 st82: 2764 if (lex.p)++; (lex.p) == (lex.pe) { 2765 goto _test_eof82 2766 } 2767 st_case_82: 2768 if lex.data[(lex.p)] == 109 { 2769 goto st83 2770 } 2771 goto st0 2772 st83: 2773 if (lex.p)++; (lex.p) == (lex.pe) { 2774 goto _test_eof83 2775 } 2776 st_case_83: 2777 if lex.data[(lex.p)] == 101 { 2778 goto st84 2779 } 2780 goto st0 2781 st84: 2782 if (lex.p)++; (lex.p) == (lex.pe) { 2783 goto _test_eof84 2784 } 2785 st_case_84: 2786 if lex.data[(lex.p)] == 100 { 2787 goto st85 2788 } 2789 goto st0 2790 st85: 2791 if (lex.p)++; (lex.p) == (lex.pe) { 2792 goto _test_eof85 2793 } 2794 st_case_85: 2795 if lex.data[(lex.p)] == 62 { 2796 goto tr93 2797 } 2798 goto st0 2799 tr93: 2800 //line NONE:1 2801 lex.te = (lex.p) + 1 2802 2803 goto st182 2804 st182: 2805 if (lex.p)++; (lex.p) == (lex.pe) { 2806 goto _test_eof182 2807 } 2808 st_case_182: 2809 //line lex.go:2484 2810 if lex.data[(lex.p)] == 32 { 2811 goto st86 2812 } 2813 goto tr222 2814 st86: 2815 if (lex.p)++; (lex.p) == (lex.pe) { 2816 goto _test_eof86 2817 } 2818 st_case_86: 2819 if lex.data[(lex.p)] == 44 { 2820 goto tr95 2821 } 2822 goto tr94 2823 st87: 2824 if (lex.p)++; (lex.p) == (lex.pe) { 2825 goto _test_eof87 2826 } 2827 st_case_87: 2828 if lex.data[(lex.p)] == 46 { 2829 goto st88 2830 } 2831 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2832 goto st100 2833 } 2834 goto st0 2835 st88: 2836 if (lex.p)++; (lex.p) == (lex.pe) { 2837 goto _test_eof88 2838 } 2839 st_case_88: 2840 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2841 goto st89 2842 } 2843 goto st0 2844 st89: 2845 if (lex.p)++; (lex.p) == (lex.pe) { 2846 goto _test_eof89 2847 } 2848 st_case_89: 2849 if lex.data[(lex.p)] == 46 { 2850 goto st90 2851 } 2852 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2853 goto st98 2854 } 2855 goto st0 2856 st90: 2857 if (lex.p)++; (lex.p) == (lex.pe) { 2858 goto _test_eof90 2859 } 2860 st_case_90: 2861 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2862 goto st91 2863 } 2864 goto st0 2865 st91: 2866 if (lex.p)++; (lex.p) == (lex.pe) { 2867 goto _test_eof91 2868 } 2869 st_case_91: 2870 if lex.data[(lex.p)] == 46 { 2871 goto st92 2872 } 2873 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2874 goto st96 2875 } 2876 goto st0 2877 st92: 2878 if (lex.p)++; (lex.p) == (lex.pe) { 2879 goto _test_eof92 2880 } 2881 st_case_92: 2882 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2883 goto st93 2884 } 2885 goto st0 2886 st93: 2887 if (lex.p)++; (lex.p) == (lex.pe) { 2888 goto _test_eof93 2889 } 2890 st_case_93: 2891 switch lex.data[(lex.p)] { 2892 case 32: 2893 goto st78 2894 case 39: 2895 goto st77 2896 case 58: 2897 goto st77 2898 } 2899 switch { 2900 case lex.data[(lex.p)] < 65: 2901 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2902 goto st94 2903 } 2904 case lex.data[(lex.p)] > 90: 2905 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 2906 goto st77 2907 } 2908 default: 2909 goto st77 2910 } 2911 goto st0 2912 st94: 2913 if (lex.p)++; (lex.p) == (lex.pe) { 2914 goto _test_eof94 2915 } 2916 st_case_94: 2917 switch lex.data[(lex.p)] { 2918 case 32: 2919 goto st78 2920 case 39: 2921 goto st77 2922 case 46: 2923 goto st88 2924 case 58: 2925 goto st77 2926 } 2927 switch { 2928 case lex.data[(lex.p)] < 65: 2929 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2930 goto st95 2931 } 2932 case lex.data[(lex.p)] > 90: 2933 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 2934 goto st77 2935 } 2936 default: 2937 goto st77 2938 } 2939 goto st0 2940 st95: 2941 if (lex.p)++; (lex.p) == (lex.pe) { 2942 goto _test_eof95 2943 } 2944 st_case_95: 2945 switch lex.data[(lex.p)] { 2946 case 32: 2947 goto st78 2948 case 39: 2949 goto st77 2950 case 46: 2951 goto st88 2952 case 58: 2953 goto st77 2954 } 2955 switch { 2956 case lex.data[(lex.p)] < 65: 2957 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2958 goto st87 2959 } 2960 case lex.data[(lex.p)] > 90: 2961 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 2962 goto st77 2963 } 2964 default: 2965 goto st77 2966 } 2967 goto st0 2968 st96: 2969 if (lex.p)++; (lex.p) == (lex.pe) { 2970 goto _test_eof96 2971 } 2972 st_case_96: 2973 if lex.data[(lex.p)] == 46 { 2974 goto st92 2975 } 2976 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2977 goto st97 2978 } 2979 goto st0 2980 st97: 2981 if (lex.p)++; (lex.p) == (lex.pe) { 2982 goto _test_eof97 2983 } 2984 st_case_97: 2985 if lex.data[(lex.p)] == 46 { 2986 goto st92 2987 } 2988 goto st0 2989 st98: 2990 if (lex.p)++; (lex.p) == (lex.pe) { 2991 goto _test_eof98 2992 } 2993 st_case_98: 2994 if lex.data[(lex.p)] == 46 { 2995 goto st90 2996 } 2997 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 2998 goto st99 2999 } 3000 goto st0 3001 st99: 3002 if (lex.p)++; (lex.p) == (lex.pe) { 3003 goto _test_eof99 3004 } 3005 st_case_99: 3006 if lex.data[(lex.p)] == 46 { 3007 goto st90 3008 } 3009 goto st0 3010 st100: 3011 if (lex.p)++; (lex.p) == (lex.pe) { 3012 goto _test_eof100 3013 } 3014 st_case_100: 3015 if lex.data[(lex.p)] == 46 { 3016 goto st88 3017 } 3018 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3019 goto st101 3020 } 3021 goto st0 3022 st101: 3023 if (lex.p)++; (lex.p) == (lex.pe) { 3024 goto _test_eof101 3025 } 3026 st_case_101: 3027 if lex.data[(lex.p)] == 46 { 3028 goto st88 3029 } 3030 goto st0 3031 st102: 3032 if (lex.p)++; (lex.p) == (lex.pe) { 3033 goto _test_eof102 3034 } 3035 st_case_102: 3036 switch lex.data[(lex.p)] { 3037 case 32: 3038 goto st78 3039 case 39: 3040 goto st77 3041 case 42: 3042 goto st77 3043 case 95: 3044 goto st77 3045 case 101: 3046 goto st103 3047 } 3048 switch { 3049 case lex.data[(lex.p)] < 48: 3050 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3051 goto st77 3052 } 3053 case lex.data[(lex.p)] > 58: 3054 switch { 3055 case lex.data[(lex.p)] > 90: 3056 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3057 goto st77 3058 } 3059 case lex.data[(lex.p)] >= 65: 3060 goto st77 3061 } 3062 default: 3063 goto st77 3064 } 3065 goto st0 3066 st103: 3067 if (lex.p)++; (lex.p) == (lex.pe) { 3068 goto _test_eof103 3069 } 3070 st_case_103: 3071 switch lex.data[(lex.p)] { 3072 case 32: 3073 goto st78 3074 case 39: 3075 goto st77 3076 case 42: 3077 goto st77 3078 case 95: 3079 goto st77 3080 case 115: 3081 goto st104 3082 } 3083 switch { 3084 case lex.data[(lex.p)] < 48: 3085 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3086 goto st77 3087 } 3088 case lex.data[(lex.p)] > 58: 3089 switch { 3090 case lex.data[(lex.p)] > 90: 3091 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3092 goto st77 3093 } 3094 case lex.data[(lex.p)] >= 65: 3095 goto st77 3096 } 3097 default: 3098 goto st77 3099 } 3100 goto st0 3101 st104: 3102 if (lex.p)++; (lex.p) == (lex.pe) { 3103 goto _test_eof104 3104 } 3105 st_case_104: 3106 switch lex.data[(lex.p)] { 3107 case 32: 3108 goto st78 3109 case 39: 3110 goto st77 3111 case 42: 3112 goto st77 3113 case 95: 3114 goto st77 3115 case 117: 3116 goto st105 3117 } 3118 switch { 3119 case lex.data[(lex.p)] < 48: 3120 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3121 goto st77 3122 } 3123 case lex.data[(lex.p)] > 58: 3124 switch { 3125 case lex.data[(lex.p)] > 90: 3126 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3127 goto st77 3128 } 3129 case lex.data[(lex.p)] >= 65: 3130 goto st77 3131 } 3132 default: 3133 goto st77 3134 } 3135 goto st0 3136 st105: 3137 if (lex.p)++; (lex.p) == (lex.pe) { 3138 goto _test_eof105 3139 } 3140 st_case_105: 3141 switch lex.data[(lex.p)] { 3142 case 32: 3143 goto st78 3144 case 39: 3145 goto st77 3146 case 42: 3147 goto st77 3148 case 95: 3149 goto st77 3150 case 109: 3151 goto st106 3152 } 3153 switch { 3154 case lex.data[(lex.p)] < 48: 3155 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3156 goto st77 3157 } 3158 case lex.data[(lex.p)] > 58: 3159 switch { 3160 case lex.data[(lex.p)] > 90: 3161 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3162 goto st77 3163 } 3164 case lex.data[(lex.p)] >= 65: 3165 goto st77 3166 } 3167 default: 3168 goto st77 3169 } 3170 goto st0 3171 st106: 3172 if (lex.p)++; (lex.p) == (lex.pe) { 3173 goto _test_eof106 3174 } 3175 st_case_106: 3176 switch lex.data[(lex.p)] { 3177 case 32: 3178 goto st78 3179 case 39: 3180 goto st77 3181 case 42: 3182 goto st77 3183 case 95: 3184 goto st77 3185 case 105: 3186 goto st107 3187 } 3188 switch { 3189 case lex.data[(lex.p)] < 48: 3190 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3191 goto st77 3192 } 3193 case lex.data[(lex.p)] > 58: 3194 switch { 3195 case lex.data[(lex.p)] > 90: 3196 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3197 goto st77 3198 } 3199 case lex.data[(lex.p)] >= 65: 3200 goto st77 3201 } 3202 default: 3203 goto st77 3204 } 3205 goto st0 3206 st107: 3207 if (lex.p)++; (lex.p) == (lex.pe) { 3208 goto _test_eof107 3209 } 3210 st_case_107: 3211 switch lex.data[(lex.p)] { 3212 case 32: 3213 goto st78 3214 case 39: 3215 goto st77 3216 case 42: 3217 goto st77 3218 case 95: 3219 goto st77 3220 case 110: 3221 goto st108 3222 } 3223 switch { 3224 case lex.data[(lex.p)] < 48: 3225 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3226 goto st77 3227 } 3228 case lex.data[(lex.p)] > 58: 3229 switch { 3230 case lex.data[(lex.p)] > 90: 3231 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3232 goto st77 3233 } 3234 case lex.data[(lex.p)] >= 65: 3235 goto st77 3236 } 3237 default: 3238 goto st77 3239 } 3240 goto st0 3241 st108: 3242 if (lex.p)++; (lex.p) == (lex.pe) { 3243 goto _test_eof108 3244 } 3245 st_case_108: 3246 switch lex.data[(lex.p)] { 3247 case 32: 3248 goto st78 3249 case 39: 3250 goto st77 3251 case 42: 3252 goto st77 3253 case 95: 3254 goto st77 3255 case 103: 3256 goto st109 3257 } 3258 switch { 3259 case lex.data[(lex.p)] < 48: 3260 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3261 goto st77 3262 } 3263 case lex.data[(lex.p)] > 58: 3264 switch { 3265 case lex.data[(lex.p)] > 90: 3266 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3267 goto st77 3268 } 3269 case lex.data[(lex.p)] >= 65: 3270 goto st77 3271 } 3272 default: 3273 goto st77 3274 } 3275 goto st0 3276 st109: 3277 if (lex.p)++; (lex.p) == (lex.pe) { 3278 goto _test_eof109 3279 } 3280 st_case_109: 3281 switch lex.data[(lex.p)] { 3282 case 32: 3283 goto st110 3284 case 39: 3285 goto st77 3286 case 42: 3287 goto st77 3288 case 95: 3289 goto st77 3290 } 3291 switch { 3292 case lex.data[(lex.p)] < 48: 3293 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3294 goto st77 3295 } 3296 case lex.data[(lex.p)] > 58: 3297 switch { 3298 case lex.data[(lex.p)] > 90: 3299 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3300 goto st77 3301 } 3302 case lex.data[(lex.p)] >= 65: 3303 goto st77 3304 } 3305 default: 3306 goto st77 3307 } 3308 goto st0 3309 st110: 3310 if (lex.p)++; (lex.p) == (lex.pe) { 3311 goto _test_eof110 3312 } 3313 st_case_110: 3314 switch lex.data[(lex.p)] { 3315 case 39: 3316 goto st111 3317 case 58: 3318 goto st111 3319 case 114: 3320 goto st148 3321 } 3322 switch { 3323 case lex.data[(lex.p)] < 65: 3324 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3325 goto st133 3326 } 3327 case lex.data[(lex.p)] > 90: 3328 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3329 goto st111 3330 } 3331 default: 3332 goto st111 3333 } 3334 goto st0 3335 st111: 3336 if (lex.p)++; (lex.p) == (lex.pe) { 3337 goto _test_eof111 3338 } 3339 st_case_111: 3340 switch lex.data[(lex.p)] { 3341 case 32: 3342 goto st112 3343 case 39: 3344 goto st111 3345 case 42: 3346 goto st111 3347 case 95: 3348 goto st111 3349 } 3350 switch { 3351 case lex.data[(lex.p)] < 48: 3352 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3353 goto st111 3354 } 3355 case lex.data[(lex.p)] > 58: 3356 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3357 goto st111 3358 } 3359 default: 3360 goto st111 3361 } 3362 goto st0 3363 st112: 3364 if (lex.p)++; (lex.p) == (lex.pe) { 3365 goto _test_eof112 3366 } 3367 st_case_112: 3368 switch lex.data[(lex.p)] { 3369 case 39: 3370 goto st113 3371 case 58: 3372 goto st113 3373 } 3374 switch { 3375 case lex.data[(lex.p)] < 65: 3376 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3377 goto st118 3378 } 3379 case lex.data[(lex.p)] > 90: 3380 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3381 goto st113 3382 } 3383 default: 3384 goto st113 3385 } 3386 goto st0 3387 st113: 3388 if (lex.p)++; (lex.p) == (lex.pe) { 3389 goto _test_eof113 3390 } 3391 st_case_113: 3392 switch lex.data[(lex.p)] { 3393 case 32: 3394 goto st114 3395 case 39: 3396 goto st113 3397 case 42: 3398 goto st113 3399 case 95: 3400 goto st113 3401 } 3402 switch { 3403 case lex.data[(lex.p)] < 48: 3404 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3405 goto st113 3406 } 3407 case lex.data[(lex.p)] > 58: 3408 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3409 goto st113 3410 } 3411 default: 3412 goto st113 3413 } 3414 goto st0 3415 st114: 3416 if (lex.p)++; (lex.p) == (lex.pe) { 3417 goto _test_eof114 3418 } 3419 st_case_114: 3420 if lex.data[(lex.p)] == 46 { 3421 goto st115 3422 } 3423 goto st0 3424 st115: 3425 if (lex.p)++; (lex.p) == (lex.pe) { 3426 goto _test_eof115 3427 } 3428 st_case_115: 3429 if lex.data[(lex.p)] == 46 { 3430 goto st116 3431 } 3432 goto st0 3433 st116: 3434 if (lex.p)++; (lex.p) == (lex.pe) { 3435 goto _test_eof116 3436 } 3437 st_case_116: 3438 if lex.data[(lex.p)] == 46 { 3439 goto st117 3440 } 3441 goto st0 3442 st117: 3443 if (lex.p)++; (lex.p) == (lex.pe) { 3444 goto _test_eof117 3445 } 3446 st_case_117: 3447 if lex.data[(lex.p)] == 62 { 3448 goto tr95 3449 } 3450 goto st0 3451 st118: 3452 if (lex.p)++; (lex.p) == (lex.pe) { 3453 goto _test_eof118 3454 } 3455 st_case_118: 3456 if lex.data[(lex.p)] == 46 { 3457 goto st119 3458 } 3459 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3460 goto st131 3461 } 3462 goto st0 3463 st119: 3464 if (lex.p)++; (lex.p) == (lex.pe) { 3465 goto _test_eof119 3466 } 3467 st_case_119: 3468 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3469 goto st120 3470 } 3471 goto st0 3472 st120: 3473 if (lex.p)++; (lex.p) == (lex.pe) { 3474 goto _test_eof120 3475 } 3476 st_case_120: 3477 if lex.data[(lex.p)] == 46 { 3478 goto st121 3479 } 3480 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3481 goto st129 3482 } 3483 goto st0 3484 st121: 3485 if (lex.p)++; (lex.p) == (lex.pe) { 3486 goto _test_eof121 3487 } 3488 st_case_121: 3489 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3490 goto st122 3491 } 3492 goto st0 3493 st122: 3494 if (lex.p)++; (lex.p) == (lex.pe) { 3495 goto _test_eof122 3496 } 3497 st_case_122: 3498 if lex.data[(lex.p)] == 46 { 3499 goto st123 3500 } 3501 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3502 goto st127 3503 } 3504 goto st0 3505 st123: 3506 if (lex.p)++; (lex.p) == (lex.pe) { 3507 goto _test_eof123 3508 } 3509 st_case_123: 3510 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3511 goto st124 3512 } 3513 goto st0 3514 st124: 3515 if (lex.p)++; (lex.p) == (lex.pe) { 3516 goto _test_eof124 3517 } 3518 st_case_124: 3519 if lex.data[(lex.p)] == 32 { 3520 goto st114 3521 } 3522 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3523 goto st125 3524 } 3525 goto st0 3526 st125: 3527 if (lex.p)++; (lex.p) == (lex.pe) { 3528 goto _test_eof125 3529 } 3530 st_case_125: 3531 if lex.data[(lex.p)] == 32 { 3532 goto st114 3533 } 3534 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3535 goto st126 3536 } 3537 goto st0 3538 st126: 3539 if (lex.p)++; (lex.p) == (lex.pe) { 3540 goto _test_eof126 3541 } 3542 st_case_126: 3543 if lex.data[(lex.p)] == 32 { 3544 goto st114 3545 } 3546 goto st0 3547 st127: 3548 if (lex.p)++; (lex.p) == (lex.pe) { 3549 goto _test_eof127 3550 } 3551 st_case_127: 3552 if lex.data[(lex.p)] == 46 { 3553 goto st123 3554 } 3555 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3556 goto st128 3557 } 3558 goto st0 3559 st128: 3560 if (lex.p)++; (lex.p) == (lex.pe) { 3561 goto _test_eof128 3562 } 3563 st_case_128: 3564 if lex.data[(lex.p)] == 46 { 3565 goto st123 3566 } 3567 goto st0 3568 st129: 3569 if (lex.p)++; (lex.p) == (lex.pe) { 3570 goto _test_eof129 3571 } 3572 st_case_129: 3573 if lex.data[(lex.p)] == 46 { 3574 goto st121 3575 } 3576 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3577 goto st130 3578 } 3579 goto st0 3580 st130: 3581 if (lex.p)++; (lex.p) == (lex.pe) { 3582 goto _test_eof130 3583 } 3584 st_case_130: 3585 if lex.data[(lex.p)] == 46 { 3586 goto st121 3587 } 3588 goto st0 3589 st131: 3590 if (lex.p)++; (lex.p) == (lex.pe) { 3591 goto _test_eof131 3592 } 3593 st_case_131: 3594 if lex.data[(lex.p)] == 46 { 3595 goto st119 3596 } 3597 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3598 goto st132 3599 } 3600 goto st0 3601 st132: 3602 if (lex.p)++; (lex.p) == (lex.pe) { 3603 goto _test_eof132 3604 } 3605 st_case_132: 3606 if lex.data[(lex.p)] == 46 { 3607 goto st119 3608 } 3609 goto st0 3610 st133: 3611 if (lex.p)++; (lex.p) == (lex.pe) { 3612 goto _test_eof133 3613 } 3614 st_case_133: 3615 if lex.data[(lex.p)] == 46 { 3616 goto st134 3617 } 3618 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3619 goto st146 3620 } 3621 goto st0 3622 st134: 3623 if (lex.p)++; (lex.p) == (lex.pe) { 3624 goto _test_eof134 3625 } 3626 st_case_134: 3627 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3628 goto st135 3629 } 3630 goto st0 3631 st135: 3632 if (lex.p)++; (lex.p) == (lex.pe) { 3633 goto _test_eof135 3634 } 3635 st_case_135: 3636 if lex.data[(lex.p)] == 46 { 3637 goto st136 3638 } 3639 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3640 goto st144 3641 } 3642 goto st0 3643 st136: 3644 if (lex.p)++; (lex.p) == (lex.pe) { 3645 goto _test_eof136 3646 } 3647 st_case_136: 3648 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3649 goto st137 3650 } 3651 goto st0 3652 st137: 3653 if (lex.p)++; (lex.p) == (lex.pe) { 3654 goto _test_eof137 3655 } 3656 st_case_137: 3657 if lex.data[(lex.p)] == 46 { 3658 goto st138 3659 } 3660 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3661 goto st142 3662 } 3663 goto st0 3664 st138: 3665 if (lex.p)++; (lex.p) == (lex.pe) { 3666 goto _test_eof138 3667 } 3668 st_case_138: 3669 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3670 goto st139 3671 } 3672 goto st0 3673 st139: 3674 if (lex.p)++; (lex.p) == (lex.pe) { 3675 goto _test_eof139 3676 } 3677 st_case_139: 3678 if lex.data[(lex.p)] == 32 { 3679 goto st112 3680 } 3681 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3682 goto st140 3683 } 3684 goto st0 3685 st140: 3686 if (lex.p)++; (lex.p) == (lex.pe) { 3687 goto _test_eof140 3688 } 3689 st_case_140: 3690 if lex.data[(lex.p)] == 32 { 3691 goto st112 3692 } 3693 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3694 goto st141 3695 } 3696 goto st0 3697 st141: 3698 if (lex.p)++; (lex.p) == (lex.pe) { 3699 goto _test_eof141 3700 } 3701 st_case_141: 3702 if lex.data[(lex.p)] == 32 { 3703 goto st112 3704 } 3705 goto st0 3706 st142: 3707 if (lex.p)++; (lex.p) == (lex.pe) { 3708 goto _test_eof142 3709 } 3710 st_case_142: 3711 if lex.data[(lex.p)] == 46 { 3712 goto st138 3713 } 3714 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3715 goto st143 3716 } 3717 goto st0 3718 st143: 3719 if (lex.p)++; (lex.p) == (lex.pe) { 3720 goto _test_eof143 3721 } 3722 st_case_143: 3723 if lex.data[(lex.p)] == 46 { 3724 goto st138 3725 } 3726 goto st0 3727 st144: 3728 if (lex.p)++; (lex.p) == (lex.pe) { 3729 goto _test_eof144 3730 } 3731 st_case_144: 3732 if lex.data[(lex.p)] == 46 { 3733 goto st136 3734 } 3735 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3736 goto st145 3737 } 3738 goto st0 3739 st145: 3740 if (lex.p)++; (lex.p) == (lex.pe) { 3741 goto _test_eof145 3742 } 3743 st_case_145: 3744 if lex.data[(lex.p)] == 46 { 3745 goto st136 3746 } 3747 goto st0 3748 st146: 3749 if (lex.p)++; (lex.p) == (lex.pe) { 3750 goto _test_eof146 3751 } 3752 st_case_146: 3753 if lex.data[(lex.p)] == 46 { 3754 goto st134 3755 } 3756 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 3757 goto st147 3758 } 3759 goto st0 3760 st147: 3761 if (lex.p)++; (lex.p) == (lex.pe) { 3762 goto _test_eof147 3763 } 3764 st_case_147: 3765 if lex.data[(lex.p)] == 46 { 3766 goto st134 3767 } 3768 goto st0 3769 st148: 3770 if (lex.p)++; (lex.p) == (lex.pe) { 3771 goto _test_eof148 3772 } 3773 st_case_148: 3774 switch lex.data[(lex.p)] { 3775 case 32: 3776 goto st112 3777 case 39: 3778 goto st111 3779 case 42: 3780 goto st111 3781 case 95: 3782 goto st111 3783 case 101: 3784 goto st149 3785 } 3786 switch { 3787 case lex.data[(lex.p)] < 48: 3788 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3789 goto st111 3790 } 3791 case lex.data[(lex.p)] > 58: 3792 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3793 goto st111 3794 } 3795 default: 3796 goto st111 3797 } 3798 goto st0 3799 st149: 3800 if (lex.p)++; (lex.p) == (lex.pe) { 3801 goto _test_eof149 3802 } 3803 st_case_149: 3804 switch lex.data[(lex.p)] { 3805 case 32: 3806 goto st112 3807 case 39: 3808 goto st111 3809 case 42: 3810 goto st111 3811 case 95: 3812 goto st111 3813 case 115: 3814 goto st150 3815 } 3816 switch { 3817 case lex.data[(lex.p)] < 48: 3818 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3819 goto st111 3820 } 3821 case lex.data[(lex.p)] > 58: 3822 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3823 goto st111 3824 } 3825 default: 3826 goto st111 3827 } 3828 goto st0 3829 st150: 3830 if (lex.p)++; (lex.p) == (lex.pe) { 3831 goto _test_eof150 3832 } 3833 st_case_150: 3834 switch lex.data[(lex.p)] { 3835 case 32: 3836 goto st112 3837 case 39: 3838 goto st111 3839 case 42: 3840 goto st111 3841 case 95: 3842 goto st111 3843 case 117: 3844 goto st151 3845 } 3846 switch { 3847 case lex.data[(lex.p)] < 48: 3848 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3849 goto st111 3850 } 3851 case lex.data[(lex.p)] > 58: 3852 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3853 goto st111 3854 } 3855 default: 3856 goto st111 3857 } 3858 goto st0 3859 st151: 3860 if (lex.p)++; (lex.p) == (lex.pe) { 3861 goto _test_eof151 3862 } 3863 st_case_151: 3864 switch lex.data[(lex.p)] { 3865 case 32: 3866 goto st112 3867 case 39: 3868 goto st111 3869 case 42: 3870 goto st111 3871 case 95: 3872 goto st111 3873 case 109: 3874 goto st152 3875 } 3876 switch { 3877 case lex.data[(lex.p)] < 48: 3878 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3879 goto st111 3880 } 3881 case lex.data[(lex.p)] > 58: 3882 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3883 goto st111 3884 } 3885 default: 3886 goto st111 3887 } 3888 goto st0 3889 st152: 3890 if (lex.p)++; (lex.p) == (lex.pe) { 3891 goto _test_eof152 3892 } 3893 st_case_152: 3894 switch lex.data[(lex.p)] { 3895 case 32: 3896 goto st112 3897 case 39: 3898 goto st111 3899 case 42: 3900 goto st111 3901 case 95: 3902 goto st111 3903 case 101: 3904 goto st153 3905 } 3906 switch { 3907 case lex.data[(lex.p)] < 48: 3908 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3909 goto st111 3910 } 3911 case lex.data[(lex.p)] > 58: 3912 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3913 goto st111 3914 } 3915 default: 3916 goto st111 3917 } 3918 goto st0 3919 st153: 3920 if (lex.p)++; (lex.p) == (lex.pe) { 3921 goto _test_eof153 3922 } 3923 st_case_153: 3924 switch lex.data[(lex.p)] { 3925 case 32: 3926 goto st112 3927 case 39: 3928 goto st111 3929 case 42: 3930 goto st111 3931 case 95: 3932 goto st111 3933 case 100: 3934 goto st154 3935 } 3936 switch { 3937 case lex.data[(lex.p)] < 48: 3938 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3939 goto st111 3940 } 3941 case lex.data[(lex.p)] > 58: 3942 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3943 goto st111 3944 } 3945 default: 3946 goto st111 3947 } 3948 goto st0 3949 st154: 3950 if (lex.p)++; (lex.p) == (lex.pe) { 3951 goto _test_eof154 3952 } 3953 st_case_154: 3954 switch lex.data[(lex.p)] { 3955 case 32: 3956 goto st112 3957 case 39: 3958 goto st111 3959 case 42: 3960 goto st111 3961 case 62: 3962 goto tr93 3963 case 95: 3964 goto st111 3965 } 3966 switch { 3967 case lex.data[(lex.p)] < 48: 3968 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 3969 goto st111 3970 } 3971 case lex.data[(lex.p)] > 58: 3972 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 3973 goto st111 3974 } 3975 default: 3976 goto st111 3977 } 3978 goto st0 3979 st183: 3980 if (lex.p)++; (lex.p) == (lex.pe) { 3981 goto _test_eof183 3982 } 3983 st_case_183: 3984 switch lex.data[(lex.p)] { 3985 case 62: 3986 goto tr225 3987 case 64: 3988 goto tr226 3989 } 3990 goto tr224 3991 st155: 3992 if (lex.p)++; (lex.p) == (lex.pe) { 3993 goto _test_eof155 3994 } 3995 st_case_155: 3996 if lex.data[(lex.p)] == 62 { 3997 goto tr162 3998 } 3999 goto st0 4000 st184: 4001 if (lex.p)++; (lex.p) == (lex.pe) { 4002 goto _test_eof184 4003 } 4004 st_case_184: 4005 switch lex.data[(lex.p)] { 4006 case 39: 4007 goto tr227 4008 case 42: 4009 goto st160 4010 case 58: 4011 goto st160 4012 case 95: 4013 goto tr227 4014 } 4015 switch { 4016 case lex.data[(lex.p)] < 65: 4017 switch { 4018 case lex.data[(lex.p)] > 46: 4019 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4020 goto st186 4021 } 4022 case lex.data[(lex.p)] >= 45: 4023 goto st160 4024 } 4025 case lex.data[(lex.p)] > 70: 4026 switch { 4027 case lex.data[(lex.p)] < 97: 4028 if 71 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 90 { 4029 goto tr10 4030 } 4031 case lex.data[(lex.p)] > 102: 4032 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4033 goto st160 4034 } 4035 default: 4036 goto st202 4037 } 4038 default: 4039 goto tr229 4040 } 4041 goto tr194 4042 tr227: 4043 //line NONE:1 4044 lex.te = (lex.p) + 1 4045 4046 //line straceLex.rl:75 4047 lex.act = 8 4048 goto st185 4049 tr185: 4050 //line NONE:1 4051 lex.te = (lex.p) + 1 4052 4053 //line straceLex.rl:77 4054 lex.act = 10 4055 goto st185 4056 st185: 4057 if (lex.p)++; (lex.p) == (lex.pe) { 4058 goto _test_eof185 4059 } 4060 st_case_185: 4061 //line lex.go:3736 4062 switch lex.data[(lex.p)] { 4063 case 39: 4064 goto tr227 4065 case 42: 4066 goto st160 4067 case 58: 4068 goto st160 4069 case 95: 4070 goto tr227 4071 } 4072 switch { 4073 case lex.data[(lex.p)] < 48: 4074 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 4075 goto st160 4076 } 4077 case lex.data[(lex.p)] > 57: 4078 switch { 4079 case lex.data[(lex.p)] > 90: 4080 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4081 goto st160 4082 } 4083 case lex.data[(lex.p)] >= 65: 4084 goto tr10 4085 } 4086 default: 4087 goto tr227 4088 } 4089 goto tr9 4090 st186: 4091 if (lex.p)++; (lex.p) == (lex.pe) { 4092 goto _test_eof186 4093 } 4094 st_case_186: 4095 switch lex.data[(lex.p)] { 4096 case 39: 4097 goto tr227 4098 case 42: 4099 goto st160 4100 case 58: 4101 goto tr232 4102 case 95: 4103 goto tr227 4104 } 4105 switch { 4106 case lex.data[(lex.p)] < 48: 4107 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 4108 goto st160 4109 } 4110 case lex.data[(lex.p)] > 57: 4111 switch { 4112 case lex.data[(lex.p)] > 90: 4113 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4114 goto st160 4115 } 4116 case lex.data[(lex.p)] >= 65: 4117 goto tr10 4118 } 4119 default: 4120 goto tr227 4121 } 4122 goto tr231 4123 tr232: 4124 //line NONE:1 4125 lex.te = (lex.p) + 1 4126 4127 //line straceLex.rl:77 4128 lex.act = 10 4129 goto st187 4130 st187: 4131 if (lex.p)++; (lex.p) == (lex.pe) { 4132 goto _test_eof187 4133 } 4134 st_case_187: 4135 //line lex.go:3810 4136 switch lex.data[(lex.p)] { 4137 case 39: 4138 goto st160 4139 case 42: 4140 goto st160 4141 case 58: 4142 goto st160 4143 case 95: 4144 goto st160 4145 } 4146 switch { 4147 case lex.data[(lex.p)] < 65: 4148 switch { 4149 case lex.data[(lex.p)] > 46: 4150 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4151 goto tr233 4152 } 4153 case lex.data[(lex.p)] >= 45: 4154 goto st160 4155 } 4156 case lex.data[(lex.p)] > 70: 4157 switch { 4158 case lex.data[(lex.p)] > 102: 4159 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4160 goto st160 4161 } 4162 case lex.data[(lex.p)] >= 97: 4163 goto tr233 4164 } 4165 default: 4166 goto st57 4167 } 4168 goto tr194 4169 tr233: 4170 //line NONE:1 4171 lex.te = (lex.p) + 1 4172 4173 //line straceLex.rl:77 4174 lex.act = 10 4175 goto st188 4176 st188: 4177 if (lex.p)++; (lex.p) == (lex.pe) { 4178 goto _test_eof188 4179 } 4180 st_case_188: 4181 //line lex.go:3856 4182 switch lex.data[(lex.p)] { 4183 case 39: 4184 goto st160 4185 case 42: 4186 goto st160 4187 case 58: 4188 goto st160 4189 case 95: 4190 goto st160 4191 } 4192 switch { 4193 case lex.data[(lex.p)] < 65: 4194 switch { 4195 case lex.data[(lex.p)] > 46: 4196 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4197 goto st189 4198 } 4199 case lex.data[(lex.p)] >= 45: 4200 goto st160 4201 } 4202 case lex.data[(lex.p)] > 70: 4203 switch { 4204 case lex.data[(lex.p)] > 102: 4205 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4206 goto st160 4207 } 4208 case lex.data[(lex.p)] >= 97: 4209 goto st189 4210 } 4211 default: 4212 goto st58 4213 } 4214 goto tr194 4215 st189: 4216 if (lex.p)++; (lex.p) == (lex.pe) { 4217 goto _test_eof189 4218 } 4219 st_case_189: 4220 switch lex.data[(lex.p)] { 4221 case 39: 4222 goto st160 4223 case 42: 4224 goto st160 4225 case 58: 4226 goto tr235 4227 case 95: 4228 goto st160 4229 } 4230 switch { 4231 case lex.data[(lex.p)] < 48: 4232 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 4233 goto st160 4234 } 4235 case lex.data[(lex.p)] > 57: 4236 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4237 goto st160 4238 } 4239 default: 4240 goto st160 4241 } 4242 goto tr194 4243 tr235: 4244 //line NONE:1 4245 lex.te = (lex.p) + 1 4246 4247 //line straceLex.rl:77 4248 lex.act = 10 4249 goto st190 4250 st190: 4251 if (lex.p)++; (lex.p) == (lex.pe) { 4252 goto _test_eof190 4253 } 4254 st_case_190: 4255 //line lex.go:3930 4256 switch lex.data[(lex.p)] { 4257 case 39: 4258 goto st160 4259 case 42: 4260 goto st160 4261 case 58: 4262 goto st160 4263 case 95: 4264 goto st160 4265 } 4266 switch { 4267 case lex.data[(lex.p)] < 65: 4268 switch { 4269 case lex.data[(lex.p)] > 46: 4270 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4271 goto tr236 4272 } 4273 case lex.data[(lex.p)] >= 45: 4274 goto st160 4275 } 4276 case lex.data[(lex.p)] > 70: 4277 switch { 4278 case lex.data[(lex.p)] > 102: 4279 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4280 goto st160 4281 } 4282 case lex.data[(lex.p)] >= 97: 4283 goto tr236 4284 } 4285 default: 4286 goto st60 4287 } 4288 goto tr194 4289 tr236: 4290 //line NONE:1 4291 lex.te = (lex.p) + 1 4292 4293 //line straceLex.rl:77 4294 lex.act = 10 4295 goto st191 4296 st191: 4297 if (lex.p)++; (lex.p) == (lex.pe) { 4298 goto _test_eof191 4299 } 4300 st_case_191: 4301 //line lex.go:3976 4302 switch lex.data[(lex.p)] { 4303 case 39: 4304 goto st160 4305 case 42: 4306 goto st160 4307 case 58: 4308 goto st160 4309 case 95: 4310 goto st160 4311 } 4312 switch { 4313 case lex.data[(lex.p)] < 65: 4314 switch { 4315 case lex.data[(lex.p)] > 46: 4316 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4317 goto st192 4318 } 4319 case lex.data[(lex.p)] >= 45: 4320 goto st160 4321 } 4322 case lex.data[(lex.p)] > 70: 4323 switch { 4324 case lex.data[(lex.p)] > 102: 4325 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4326 goto st160 4327 } 4328 case lex.data[(lex.p)] >= 97: 4329 goto st192 4330 } 4331 default: 4332 goto st61 4333 } 4334 goto tr194 4335 st192: 4336 if (lex.p)++; (lex.p) == (lex.pe) { 4337 goto _test_eof192 4338 } 4339 st_case_192: 4340 switch lex.data[(lex.p)] { 4341 case 39: 4342 goto st160 4343 case 42: 4344 goto st160 4345 case 58: 4346 goto tr238 4347 case 95: 4348 goto st160 4349 } 4350 switch { 4351 case lex.data[(lex.p)] < 48: 4352 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 4353 goto st160 4354 } 4355 case lex.data[(lex.p)] > 57: 4356 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4357 goto st160 4358 } 4359 default: 4360 goto st160 4361 } 4362 goto tr194 4363 tr238: 4364 //line NONE:1 4365 lex.te = (lex.p) + 1 4366 4367 //line straceLex.rl:77 4368 lex.act = 10 4369 goto st193 4370 st193: 4371 if (lex.p)++; (lex.p) == (lex.pe) { 4372 goto _test_eof193 4373 } 4374 st_case_193: 4375 //line lex.go:4050 4376 switch lex.data[(lex.p)] { 4377 case 39: 4378 goto st160 4379 case 42: 4380 goto st160 4381 case 58: 4382 goto st160 4383 case 95: 4384 goto st160 4385 } 4386 switch { 4387 case lex.data[(lex.p)] < 65: 4388 switch { 4389 case lex.data[(lex.p)] > 46: 4390 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4391 goto tr239 4392 } 4393 case lex.data[(lex.p)] >= 45: 4394 goto st160 4395 } 4396 case lex.data[(lex.p)] > 70: 4397 switch { 4398 case lex.data[(lex.p)] > 102: 4399 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4400 goto st160 4401 } 4402 case lex.data[(lex.p)] >= 97: 4403 goto tr239 4404 } 4405 default: 4406 goto st63 4407 } 4408 goto tr194 4409 tr239: 4410 //line NONE:1 4411 lex.te = (lex.p) + 1 4412 4413 //line straceLex.rl:77 4414 lex.act = 10 4415 goto st194 4416 st194: 4417 if (lex.p)++; (lex.p) == (lex.pe) { 4418 goto _test_eof194 4419 } 4420 st_case_194: 4421 //line lex.go:4096 4422 switch lex.data[(lex.p)] { 4423 case 39: 4424 goto st160 4425 case 42: 4426 goto st160 4427 case 58: 4428 goto st160 4429 case 95: 4430 goto st160 4431 } 4432 switch { 4433 case lex.data[(lex.p)] < 65: 4434 switch { 4435 case lex.data[(lex.p)] > 46: 4436 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4437 goto st195 4438 } 4439 case lex.data[(lex.p)] >= 45: 4440 goto st160 4441 } 4442 case lex.data[(lex.p)] > 70: 4443 switch { 4444 case lex.data[(lex.p)] > 102: 4445 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4446 goto st160 4447 } 4448 case lex.data[(lex.p)] >= 97: 4449 goto st195 4450 } 4451 default: 4452 goto st64 4453 } 4454 goto tr194 4455 st195: 4456 if (lex.p)++; (lex.p) == (lex.pe) { 4457 goto _test_eof195 4458 } 4459 st_case_195: 4460 switch lex.data[(lex.p)] { 4461 case 39: 4462 goto st160 4463 case 42: 4464 goto st160 4465 case 58: 4466 goto tr241 4467 case 95: 4468 goto st160 4469 } 4470 switch { 4471 case lex.data[(lex.p)] < 48: 4472 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 4473 goto st160 4474 } 4475 case lex.data[(lex.p)] > 57: 4476 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4477 goto st160 4478 } 4479 default: 4480 goto st160 4481 } 4482 goto tr194 4483 tr241: 4484 //line NONE:1 4485 lex.te = (lex.p) + 1 4486 4487 //line straceLex.rl:77 4488 lex.act = 10 4489 goto st196 4490 st196: 4491 if (lex.p)++; (lex.p) == (lex.pe) { 4492 goto _test_eof196 4493 } 4494 st_case_196: 4495 //line lex.go:4170 4496 switch lex.data[(lex.p)] { 4497 case 39: 4498 goto st160 4499 case 42: 4500 goto st160 4501 case 58: 4502 goto st160 4503 case 95: 4504 goto st160 4505 } 4506 switch { 4507 case lex.data[(lex.p)] < 65: 4508 switch { 4509 case lex.data[(lex.p)] > 46: 4510 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4511 goto tr242 4512 } 4513 case lex.data[(lex.p)] >= 45: 4514 goto st160 4515 } 4516 case lex.data[(lex.p)] > 70: 4517 switch { 4518 case lex.data[(lex.p)] > 102: 4519 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4520 goto st160 4521 } 4522 case lex.data[(lex.p)] >= 97: 4523 goto tr242 4524 } 4525 default: 4526 goto st66 4527 } 4528 goto tr194 4529 tr242: 4530 //line NONE:1 4531 lex.te = (lex.p) + 1 4532 4533 //line straceLex.rl:77 4534 lex.act = 10 4535 goto st197 4536 st197: 4537 if (lex.p)++; (lex.p) == (lex.pe) { 4538 goto _test_eof197 4539 } 4540 st_case_197: 4541 //line lex.go:4216 4542 switch lex.data[(lex.p)] { 4543 case 39: 4544 goto st160 4545 case 42: 4546 goto st160 4547 case 58: 4548 goto st160 4549 case 95: 4550 goto st160 4551 } 4552 switch { 4553 case lex.data[(lex.p)] < 65: 4554 switch { 4555 case lex.data[(lex.p)] > 46: 4556 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4557 goto st198 4558 } 4559 case lex.data[(lex.p)] >= 45: 4560 goto st160 4561 } 4562 case lex.data[(lex.p)] > 70: 4563 switch { 4564 case lex.data[(lex.p)] > 102: 4565 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4566 goto st160 4567 } 4568 case lex.data[(lex.p)] >= 97: 4569 goto st198 4570 } 4571 default: 4572 goto st67 4573 } 4574 goto tr194 4575 st198: 4576 if (lex.p)++; (lex.p) == (lex.pe) { 4577 goto _test_eof198 4578 } 4579 st_case_198: 4580 switch lex.data[(lex.p)] { 4581 case 39: 4582 goto st160 4583 case 42: 4584 goto st160 4585 case 58: 4586 goto tr244 4587 case 95: 4588 goto st160 4589 } 4590 switch { 4591 case lex.data[(lex.p)] < 48: 4592 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 4593 goto st160 4594 } 4595 case lex.data[(lex.p)] > 57: 4596 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4597 goto st160 4598 } 4599 default: 4600 goto st160 4601 } 4602 goto tr194 4603 tr244: 4604 //line NONE:1 4605 lex.te = (lex.p) + 1 4606 4607 //line straceLex.rl:77 4608 lex.act = 10 4609 goto st199 4610 st199: 4611 if (lex.p)++; (lex.p) == (lex.pe) { 4612 goto _test_eof199 4613 } 4614 st_case_199: 4615 //line lex.go:4290 4616 switch lex.data[(lex.p)] { 4617 case 39: 4618 goto st160 4619 case 42: 4620 goto st160 4621 case 58: 4622 goto st160 4623 case 95: 4624 goto st160 4625 } 4626 switch { 4627 case lex.data[(lex.p)] < 65: 4628 switch { 4629 case lex.data[(lex.p)] > 46: 4630 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4631 goto st200 4632 } 4633 case lex.data[(lex.p)] >= 45: 4634 goto st160 4635 } 4636 case lex.data[(lex.p)] > 70: 4637 switch { 4638 case lex.data[(lex.p)] > 102: 4639 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4640 goto st160 4641 } 4642 case lex.data[(lex.p)] >= 97: 4643 goto st200 4644 } 4645 default: 4646 goto st69 4647 } 4648 goto tr194 4649 st200: 4650 if (lex.p)++; (lex.p) == (lex.pe) { 4651 goto _test_eof200 4652 } 4653 st_case_200: 4654 switch lex.data[(lex.p)] { 4655 case 39: 4656 goto st160 4657 case 42: 4658 goto st160 4659 case 95: 4660 goto st160 4661 } 4662 switch { 4663 case lex.data[(lex.p)] < 48: 4664 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 4665 goto st160 4666 } 4667 case lex.data[(lex.p)] > 58: 4668 switch { 4669 case lex.data[(lex.p)] > 70: 4670 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4671 goto st160 4672 } 4673 case lex.data[(lex.p)] >= 65: 4674 goto tr74 4675 } 4676 default: 4677 goto st160 4678 } 4679 goto tr194 4680 tr229: 4681 //line NONE:1 4682 lex.te = (lex.p) + 1 4683 4684 //line straceLex.rl:75 4685 lex.act = 8 4686 goto st201 4687 st201: 4688 if (lex.p)++; (lex.p) == (lex.pe) { 4689 goto _test_eof201 4690 } 4691 st_case_201: 4692 //line lex.go:4367 4693 switch lex.data[(lex.p)] { 4694 case 39: 4695 goto tr10 4696 case 58: 4697 goto st56 4698 case 95: 4699 goto tr10 4700 } 4701 switch { 4702 case lex.data[(lex.p)] > 57: 4703 if 65 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 90 { 4704 goto tr10 4705 } 4706 case lex.data[(lex.p)] >= 48: 4707 goto tr10 4708 } 4709 goto tr231 4710 st202: 4711 if (lex.p)++; (lex.p) == (lex.pe) { 4712 goto _test_eof202 4713 } 4714 st_case_202: 4715 switch lex.data[(lex.p)] { 4716 case 39: 4717 goto st160 4718 case 42: 4719 goto st160 4720 case 58: 4721 goto tr232 4722 case 95: 4723 goto st160 4724 } 4725 switch { 4726 case lex.data[(lex.p)] < 48: 4727 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 4728 goto st160 4729 } 4730 case lex.data[(lex.p)] > 57: 4731 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4732 goto st160 4733 } 4734 default: 4735 goto st160 4736 } 4737 goto tr194 4738 st203: 4739 if (lex.p)++; (lex.p) == (lex.pe) { 4740 goto _test_eof203 4741 } 4742 st_case_203: 4743 switch lex.data[(lex.p)] { 4744 case 39: 4745 goto tr227 4746 case 42: 4747 goto st160 4748 case 58: 4749 goto st160 4750 case 85: 4751 goto st204 4752 case 95: 4753 goto tr227 4754 } 4755 switch { 4756 case lex.data[(lex.p)] < 48: 4757 if 45 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 46 { 4758 goto st160 4759 } 4760 case lex.data[(lex.p)] > 57: 4761 switch { 4762 case lex.data[(lex.p)] > 90: 4763 if 97 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4764 goto st160 4765 } 4766 case lex.data[(lex.p)] >= 65: 4767 goto tr10 4768 } 4769 default: 4770 goto tr227 4771 } 4772 goto tr194 4773 st204: 4774 if (lex.p)++; (lex.p) == (lex.pe) { 4775 goto _test_eof204 4776 } 4777 st_case_204: 4778 switch lex.data[(lex.p)] { 4779 case 39: 4780 goto tr10 4781 case 76: 4782 goto st205 4783 case 95: 4784 goto tr10 4785 } 4786 switch { 4787 case lex.data[(lex.p)] > 57: 4788 if 65 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 90 { 4789 goto tr10 4790 } 4791 case lex.data[(lex.p)] >= 48: 4792 goto tr10 4793 } 4794 goto tr231 4795 st205: 4796 if (lex.p)++; (lex.p) == (lex.pe) { 4797 goto _test_eof205 4798 } 4799 st_case_205: 4800 switch lex.data[(lex.p)] { 4801 case 39: 4802 goto tr10 4803 case 76: 4804 goto tr248 4805 case 95: 4806 goto tr10 4807 } 4808 switch { 4809 case lex.data[(lex.p)] > 57: 4810 if 65 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 90 { 4811 goto tr10 4812 } 4813 case lex.data[(lex.p)] >= 48: 4814 goto tr10 4815 } 4816 goto tr231 4817 st156: 4818 if (lex.p)++; (lex.p) == (lex.pe) { 4819 goto _test_eof156 4820 } 4821 st_case_156: 4822 switch lex.data[(lex.p)] { 4823 case 39: 4824 goto st156 4825 case 95: 4826 goto st156 4827 } 4828 if 65 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 90 { 4829 goto st9 4830 } 4831 goto st0 4832 tr189: 4833 //line NONE:1 4834 lex.te = (lex.p) + 1 4835 4836 //line straceLex.rl:77 4837 lex.act = 10 4838 goto st206 4839 st206: 4840 if (lex.p)++; (lex.p) == (lex.pe) { 4841 goto _test_eof206 4842 } 4843 st_case_206: 4844 //line lex.go:4519 4845 switch lex.data[(lex.p)] { 4846 case 39: 4847 goto st160 4848 case 42: 4849 goto st160 4850 case 58: 4851 goto st160 4852 case 95: 4853 goto st160 4854 } 4855 switch { 4856 case lex.data[(lex.p)] < 65: 4857 switch { 4858 case lex.data[(lex.p)] > 46: 4859 if 48 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 57 { 4860 goto st202 4861 } 4862 case lex.data[(lex.p)] >= 45: 4863 goto st160 4864 } 4865 case lex.data[(lex.p)] > 70: 4866 switch { 4867 case lex.data[(lex.p)] > 102: 4868 if 103 <= lex.data[(lex.p)] && lex.data[(lex.p)] <= 122 { 4869 goto st160 4870 } 4871 case lex.data[(lex.p)] >= 97: 4872 goto st202 4873 } 4874 default: 4875 goto st70 4876 } 4877 goto tr194 4878 tr249: 4879 //line straceLex.rl:65 4880 lex.te = (lex.p) + 1 4881 4882 goto st207 4883 tr251: 4884 //line straceLex.rl:65 4885 lex.te = (lex.p) 4886 (lex.p)-- 4887 4888 goto st207 4889 tr252: 4890 //line straceLex.rl:66 4891 lex.te = (lex.p) + 1 4892 { 4893 { 4894 goto st157 4895 } 4896 } 4897 goto st207 4898 st207: 4899 //line NONE:1 4900 lex.ts = 0 4901 4902 if (lex.p)++; (lex.p) == (lex.pe) { 4903 goto _test_eof207 4904 } 4905 st_case_207: 4906 //line NONE:1 4907 lex.ts = (lex.p) 4908 4909 //line lex.go:4580 4910 if lex.data[(lex.p)] == 42 { 4911 goto st208 4912 } 4913 goto tr249 4914 st208: 4915 if (lex.p)++; (lex.p) == (lex.pe) { 4916 goto _test_eof208 4917 } 4918 st_case_208: 4919 if lex.data[(lex.p)] == 47 { 4920 goto tr252 4921 } 4922 goto tr251 4923 st_out: 4924 _test_eof157: 4925 lex.cs = 157 4926 goto _test_eof 4927 _test_eof1: 4928 lex.cs = 1 4929 goto _test_eof 4930 _test_eof2: 4931 lex.cs = 2 4932 goto _test_eof 4933 _test_eof158: 4934 lex.cs = 158 4935 goto _test_eof 4936 _test_eof3: 4937 lex.cs = 3 4938 goto _test_eof 4939 _test_eof4: 4940 lex.cs = 4 4941 goto _test_eof 4942 _test_eof5: 4943 lex.cs = 5 4944 goto _test_eof 4945 _test_eof6: 4946 lex.cs = 6 4947 goto _test_eof 4948 _test_eof7: 4949 lex.cs = 7 4950 goto _test_eof 4951 _test_eof8: 4952 lex.cs = 8 4953 goto _test_eof 4954 _test_eof159: 4955 lex.cs = 159 4956 goto _test_eof 4957 _test_eof160: 4958 lex.cs = 160 4959 goto _test_eof 4960 _test_eof9: 4961 lex.cs = 9 4962 goto _test_eof 4963 _test_eof161: 4964 lex.cs = 161 4965 goto _test_eof 4966 _test_eof162: 4967 lex.cs = 162 4968 goto _test_eof 4969 _test_eof10: 4970 lex.cs = 10 4971 goto _test_eof 4972 _test_eof11: 4973 lex.cs = 11 4974 goto _test_eof 4975 _test_eof12: 4976 lex.cs = 12 4977 goto _test_eof 4978 _test_eof13: 4979 lex.cs = 13 4980 goto _test_eof 4981 _test_eof14: 4982 lex.cs = 14 4983 goto _test_eof 4984 _test_eof15: 4985 lex.cs = 15 4986 goto _test_eof 4987 _test_eof16: 4988 lex.cs = 16 4989 goto _test_eof 4990 _test_eof17: 4991 lex.cs = 17 4992 goto _test_eof 4993 _test_eof18: 4994 lex.cs = 18 4995 goto _test_eof 4996 _test_eof19: 4997 lex.cs = 19 4998 goto _test_eof 4999 _test_eof20: 5000 lex.cs = 20 5001 goto _test_eof 5002 _test_eof21: 5003 lex.cs = 21 5004 goto _test_eof 5005 _test_eof22: 5006 lex.cs = 22 5007 goto _test_eof 5008 _test_eof23: 5009 lex.cs = 23 5010 goto _test_eof 5011 _test_eof24: 5012 lex.cs = 24 5013 goto _test_eof 5014 _test_eof25: 5015 lex.cs = 25 5016 goto _test_eof 5017 _test_eof26: 5018 lex.cs = 26 5019 goto _test_eof 5020 _test_eof163: 5021 lex.cs = 163 5022 goto _test_eof 5023 _test_eof27: 5024 lex.cs = 27 5025 goto _test_eof 5026 _test_eof164: 5027 lex.cs = 164 5028 goto _test_eof 5029 _test_eof165: 5030 lex.cs = 165 5031 goto _test_eof 5032 _test_eof166: 5033 lex.cs = 166 5034 goto _test_eof 5035 _test_eof167: 5036 lex.cs = 167 5037 goto _test_eof 5038 _test_eof28: 5039 lex.cs = 28 5040 goto _test_eof 5041 _test_eof29: 5042 lex.cs = 29 5043 goto _test_eof 5044 _test_eof30: 5045 lex.cs = 30 5046 goto _test_eof 5047 _test_eof168: 5048 lex.cs = 168 5049 goto _test_eof 5050 _test_eof169: 5051 lex.cs = 169 5052 goto _test_eof 5053 _test_eof31: 5054 lex.cs = 31 5055 goto _test_eof 5056 _test_eof32: 5057 lex.cs = 32 5058 goto _test_eof 5059 _test_eof170: 5060 lex.cs = 170 5061 goto _test_eof 5062 _test_eof171: 5063 lex.cs = 171 5064 goto _test_eof 5065 _test_eof172: 5066 lex.cs = 172 5067 goto _test_eof 5068 _test_eof173: 5069 lex.cs = 173 5070 goto _test_eof 5071 _test_eof33: 5072 lex.cs = 33 5073 goto _test_eof 5074 _test_eof34: 5075 lex.cs = 34 5076 goto _test_eof 5077 _test_eof35: 5078 lex.cs = 35 5079 goto _test_eof 5080 _test_eof36: 5081 lex.cs = 36 5082 goto _test_eof 5083 _test_eof174: 5084 lex.cs = 174 5085 goto _test_eof 5086 _test_eof175: 5087 lex.cs = 175 5088 goto _test_eof 5089 _test_eof37: 5090 lex.cs = 37 5091 goto _test_eof 5092 _test_eof38: 5093 lex.cs = 38 5094 goto _test_eof 5095 _test_eof39: 5096 lex.cs = 39 5097 goto _test_eof 5098 _test_eof40: 5099 lex.cs = 40 5100 goto _test_eof 5101 _test_eof41: 5102 lex.cs = 41 5103 goto _test_eof 5104 _test_eof42: 5105 lex.cs = 42 5106 goto _test_eof 5107 _test_eof43: 5108 lex.cs = 43 5109 goto _test_eof 5110 _test_eof44: 5111 lex.cs = 44 5112 goto _test_eof 5113 _test_eof45: 5114 lex.cs = 45 5115 goto _test_eof 5116 _test_eof46: 5117 lex.cs = 46 5118 goto _test_eof 5119 _test_eof47: 5120 lex.cs = 47 5121 goto _test_eof 5122 _test_eof48: 5123 lex.cs = 48 5124 goto _test_eof 5125 _test_eof49: 5126 lex.cs = 49 5127 goto _test_eof 5128 _test_eof50: 5129 lex.cs = 50 5130 goto _test_eof 5131 _test_eof176: 5132 lex.cs = 176 5133 goto _test_eof 5134 _test_eof51: 5135 lex.cs = 51 5136 goto _test_eof 5137 _test_eof52: 5138 lex.cs = 52 5139 goto _test_eof 5140 _test_eof53: 5141 lex.cs = 53 5142 goto _test_eof 5143 _test_eof54: 5144 lex.cs = 54 5145 goto _test_eof 5146 _test_eof177: 5147 lex.cs = 177 5148 goto _test_eof 5149 _test_eof55: 5150 lex.cs = 55 5151 goto _test_eof 5152 _test_eof178: 5153 lex.cs = 178 5154 goto _test_eof 5155 _test_eof179: 5156 lex.cs = 179 5157 goto _test_eof 5158 _test_eof56: 5159 lex.cs = 56 5160 goto _test_eof 5161 _test_eof57: 5162 lex.cs = 57 5163 goto _test_eof 5164 _test_eof58: 5165 lex.cs = 58 5166 goto _test_eof 5167 _test_eof59: 5168 lex.cs = 59 5169 goto _test_eof 5170 _test_eof60: 5171 lex.cs = 60 5172 goto _test_eof 5173 _test_eof61: 5174 lex.cs = 61 5175 goto _test_eof 5176 _test_eof62: 5177 lex.cs = 62 5178 goto _test_eof 5179 _test_eof63: 5180 lex.cs = 63 5181 goto _test_eof 5182 _test_eof64: 5183 lex.cs = 64 5184 goto _test_eof 5185 _test_eof65: 5186 lex.cs = 65 5187 goto _test_eof 5188 _test_eof66: 5189 lex.cs = 66 5190 goto _test_eof 5191 _test_eof67: 5192 lex.cs = 67 5193 goto _test_eof 5194 _test_eof68: 5195 lex.cs = 68 5196 goto _test_eof 5197 _test_eof69: 5198 lex.cs = 69 5199 goto _test_eof 5200 _test_eof70: 5201 lex.cs = 70 5202 goto _test_eof 5203 _test_eof71: 5204 lex.cs = 71 5205 goto _test_eof 5206 _test_eof180: 5207 lex.cs = 180 5208 goto _test_eof 5209 _test_eof181: 5210 lex.cs = 181 5211 goto _test_eof 5212 _test_eof72: 5213 lex.cs = 72 5214 goto _test_eof 5215 _test_eof73: 5216 lex.cs = 73 5217 goto _test_eof 5218 _test_eof74: 5219 lex.cs = 74 5220 goto _test_eof 5221 _test_eof75: 5222 lex.cs = 75 5223 goto _test_eof 5224 _test_eof76: 5225 lex.cs = 76 5226 goto _test_eof 5227 _test_eof77: 5228 lex.cs = 77 5229 goto _test_eof 5230 _test_eof78: 5231 lex.cs = 78 5232 goto _test_eof 5233 _test_eof79: 5234 lex.cs = 79 5235 goto _test_eof 5236 _test_eof80: 5237 lex.cs = 80 5238 goto _test_eof 5239 _test_eof81: 5240 lex.cs = 81 5241 goto _test_eof 5242 _test_eof82: 5243 lex.cs = 82 5244 goto _test_eof 5245 _test_eof83: 5246 lex.cs = 83 5247 goto _test_eof 5248 _test_eof84: 5249 lex.cs = 84 5250 goto _test_eof 5251 _test_eof85: 5252 lex.cs = 85 5253 goto _test_eof 5254 _test_eof182: 5255 lex.cs = 182 5256 goto _test_eof 5257 _test_eof86: 5258 lex.cs = 86 5259 goto _test_eof 5260 _test_eof87: 5261 lex.cs = 87 5262 goto _test_eof 5263 _test_eof88: 5264 lex.cs = 88 5265 goto _test_eof 5266 _test_eof89: 5267 lex.cs = 89 5268 goto _test_eof 5269 _test_eof90: 5270 lex.cs = 90 5271 goto _test_eof 5272 _test_eof91: 5273 lex.cs = 91 5274 goto _test_eof 5275 _test_eof92: 5276 lex.cs = 92 5277 goto _test_eof 5278 _test_eof93: 5279 lex.cs = 93 5280 goto _test_eof 5281 _test_eof94: 5282 lex.cs = 94 5283 goto _test_eof 5284 _test_eof95: 5285 lex.cs = 95 5286 goto _test_eof 5287 _test_eof96: 5288 lex.cs = 96 5289 goto _test_eof 5290 _test_eof97: 5291 lex.cs = 97 5292 goto _test_eof 5293 _test_eof98: 5294 lex.cs = 98 5295 goto _test_eof 5296 _test_eof99: 5297 lex.cs = 99 5298 goto _test_eof 5299 _test_eof100: 5300 lex.cs = 100 5301 goto _test_eof 5302 _test_eof101: 5303 lex.cs = 101 5304 goto _test_eof 5305 _test_eof102: 5306 lex.cs = 102 5307 goto _test_eof 5308 _test_eof103: 5309 lex.cs = 103 5310 goto _test_eof 5311 _test_eof104: 5312 lex.cs = 104 5313 goto _test_eof 5314 _test_eof105: 5315 lex.cs = 105 5316 goto _test_eof 5317 _test_eof106: 5318 lex.cs = 106 5319 goto _test_eof 5320 _test_eof107: 5321 lex.cs = 107 5322 goto _test_eof 5323 _test_eof108: 5324 lex.cs = 108 5325 goto _test_eof 5326 _test_eof109: 5327 lex.cs = 109 5328 goto _test_eof 5329 _test_eof110: 5330 lex.cs = 110 5331 goto _test_eof 5332 _test_eof111: 5333 lex.cs = 111 5334 goto _test_eof 5335 _test_eof112: 5336 lex.cs = 112 5337 goto _test_eof 5338 _test_eof113: 5339 lex.cs = 113 5340 goto _test_eof 5341 _test_eof114: 5342 lex.cs = 114 5343 goto _test_eof 5344 _test_eof115: 5345 lex.cs = 115 5346 goto _test_eof 5347 _test_eof116: 5348 lex.cs = 116 5349 goto _test_eof 5350 _test_eof117: 5351 lex.cs = 117 5352 goto _test_eof 5353 _test_eof118: 5354 lex.cs = 118 5355 goto _test_eof 5356 _test_eof119: 5357 lex.cs = 119 5358 goto _test_eof 5359 _test_eof120: 5360 lex.cs = 120 5361 goto _test_eof 5362 _test_eof121: 5363 lex.cs = 121 5364 goto _test_eof 5365 _test_eof122: 5366 lex.cs = 122 5367 goto _test_eof 5368 _test_eof123: 5369 lex.cs = 123 5370 goto _test_eof 5371 _test_eof124: 5372 lex.cs = 124 5373 goto _test_eof 5374 _test_eof125: 5375 lex.cs = 125 5376 goto _test_eof 5377 _test_eof126: 5378 lex.cs = 126 5379 goto _test_eof 5380 _test_eof127: 5381 lex.cs = 127 5382 goto _test_eof 5383 _test_eof128: 5384 lex.cs = 128 5385 goto _test_eof 5386 _test_eof129: 5387 lex.cs = 129 5388 goto _test_eof 5389 _test_eof130: 5390 lex.cs = 130 5391 goto _test_eof 5392 _test_eof131: 5393 lex.cs = 131 5394 goto _test_eof 5395 _test_eof132: 5396 lex.cs = 132 5397 goto _test_eof 5398 _test_eof133: 5399 lex.cs = 133 5400 goto _test_eof 5401 _test_eof134: 5402 lex.cs = 134 5403 goto _test_eof 5404 _test_eof135: 5405 lex.cs = 135 5406 goto _test_eof 5407 _test_eof136: 5408 lex.cs = 136 5409 goto _test_eof 5410 _test_eof137: 5411 lex.cs = 137 5412 goto _test_eof 5413 _test_eof138: 5414 lex.cs = 138 5415 goto _test_eof 5416 _test_eof139: 5417 lex.cs = 139 5418 goto _test_eof 5419 _test_eof140: 5420 lex.cs = 140 5421 goto _test_eof 5422 _test_eof141: 5423 lex.cs = 141 5424 goto _test_eof 5425 _test_eof142: 5426 lex.cs = 142 5427 goto _test_eof 5428 _test_eof143: 5429 lex.cs = 143 5430 goto _test_eof 5431 _test_eof144: 5432 lex.cs = 144 5433 goto _test_eof 5434 _test_eof145: 5435 lex.cs = 145 5436 goto _test_eof 5437 _test_eof146: 5438 lex.cs = 146 5439 goto _test_eof 5440 _test_eof147: 5441 lex.cs = 147 5442 goto _test_eof 5443 _test_eof148: 5444 lex.cs = 148 5445 goto _test_eof 5446 _test_eof149: 5447 lex.cs = 149 5448 goto _test_eof 5449 _test_eof150: 5450 lex.cs = 150 5451 goto _test_eof 5452 _test_eof151: 5453 lex.cs = 151 5454 goto _test_eof 5455 _test_eof152: 5456 lex.cs = 152 5457 goto _test_eof 5458 _test_eof153: 5459 lex.cs = 153 5460 goto _test_eof 5461 _test_eof154: 5462 lex.cs = 154 5463 goto _test_eof 5464 _test_eof183: 5465 lex.cs = 183 5466 goto _test_eof 5467 _test_eof155: 5468 lex.cs = 155 5469 goto _test_eof 5470 _test_eof184: 5471 lex.cs = 184 5472 goto _test_eof 5473 _test_eof185: 5474 lex.cs = 185 5475 goto _test_eof 5476 _test_eof186: 5477 lex.cs = 186 5478 goto _test_eof 5479 _test_eof187: 5480 lex.cs = 187 5481 goto _test_eof 5482 _test_eof188: 5483 lex.cs = 188 5484 goto _test_eof 5485 _test_eof189: 5486 lex.cs = 189 5487 goto _test_eof 5488 _test_eof190: 5489 lex.cs = 190 5490 goto _test_eof 5491 _test_eof191: 5492 lex.cs = 191 5493 goto _test_eof 5494 _test_eof192: 5495 lex.cs = 192 5496 goto _test_eof 5497 _test_eof193: 5498 lex.cs = 193 5499 goto _test_eof 5500 _test_eof194: 5501 lex.cs = 194 5502 goto _test_eof 5503 _test_eof195: 5504 lex.cs = 195 5505 goto _test_eof 5506 _test_eof196: 5507 lex.cs = 196 5508 goto _test_eof 5509 _test_eof197: 5510 lex.cs = 197 5511 goto _test_eof 5512 _test_eof198: 5513 lex.cs = 198 5514 goto _test_eof 5515 _test_eof199: 5516 lex.cs = 199 5517 goto _test_eof 5518 _test_eof200: 5519 lex.cs = 200 5520 goto _test_eof 5521 _test_eof201: 5522 lex.cs = 201 5523 goto _test_eof 5524 _test_eof202: 5525 lex.cs = 202 5526 goto _test_eof 5527 _test_eof203: 5528 lex.cs = 203 5529 goto _test_eof 5530 _test_eof204: 5531 lex.cs = 204 5532 goto _test_eof 5533 _test_eof205: 5534 lex.cs = 205 5535 goto _test_eof 5536 _test_eof156: 5537 lex.cs = 156 5538 goto _test_eof 5539 _test_eof206: 5540 lex.cs = 206 5541 goto _test_eof 5542 _test_eof207: 5543 lex.cs = 207 5544 goto _test_eof 5545 _test_eof208: 5546 lex.cs = 208 5547 goto _test_eof 5548 5549 _test_eof: 5550 { 5551 } 5552 if (lex.p) == eof { 5553 switch lex.cs { 5554 case 158: 5555 goto tr193 5556 case 159: 5557 goto tr194 5558 case 160: 5559 goto tr194 5560 case 9: 5561 goto tr9 5562 case 161: 5563 goto tr9 5564 case 162: 5565 goto tr195 5566 case 10: 5567 goto tr11 5568 case 11: 5569 goto tr11 5570 case 12: 5571 goto tr11 5572 case 13: 5573 goto tr9 5574 case 14: 5575 goto tr9 5576 case 15: 5577 goto tr9 5578 case 16: 5579 goto tr9 5580 case 17: 5581 goto tr9 5582 case 18: 5583 goto tr9 5584 case 19: 5585 goto tr9 5586 case 20: 5587 goto tr9 5588 case 21: 5589 goto tr9 5590 case 22: 5591 goto tr9 5592 case 23: 5593 goto tr9 5594 case 24: 5595 goto tr9 5596 case 25: 5597 goto tr9 5598 case 26: 5599 goto tr9 5600 case 163: 5601 goto tr197 5602 case 164: 5603 goto tr199 5604 case 165: 5605 goto tr201 5606 case 166: 5607 goto tr206 5608 case 167: 5609 goto tr206 5610 case 28: 5611 goto tr9 5612 case 29: 5613 goto tr9 5614 case 30: 5615 goto tr9 5616 case 168: 5617 goto tr194 5618 case 169: 5619 goto tr194 5620 case 31: 5621 goto tr9 5622 case 32: 5623 goto tr9 5624 case 170: 5625 goto tr206 5626 case 171: 5627 goto tr206 5628 case 172: 5629 goto tr206 5630 case 173: 5631 goto tr201 5632 case 33: 5633 goto tr36 5634 case 34: 5635 goto tr36 5636 case 35: 5637 goto tr36 5638 case 36: 5639 goto tr36 5640 case 174: 5641 goto tr201 5642 case 175: 5643 goto tr201 5644 case 37: 5645 goto tr36 5646 case 38: 5647 goto tr36 5648 case 39: 5649 goto tr36 5650 case 40: 5651 goto tr36 5652 case 41: 5653 goto tr36 5654 case 42: 5655 goto tr36 5656 case 43: 5657 goto tr36 5658 case 44: 5659 goto tr36 5660 case 45: 5661 goto tr36 5662 case 46: 5663 goto tr36 5664 case 47: 5665 goto tr36 5666 case 48: 5667 goto tr36 5668 case 49: 5669 goto tr36 5670 case 50: 5671 goto tr36 5672 case 176: 5673 goto tr218 5674 case 51: 5675 goto tr55 5676 case 52: 5677 goto tr55 5678 case 53: 5679 goto tr55 5680 case 54: 5681 goto tr55 5682 case 177: 5683 goto tr218 5684 case 55: 5685 goto tr55 5686 case 178: 5687 goto tr218 5688 case 179: 5689 goto tr201 5690 case 56: 5691 goto tr9 5692 case 57: 5693 goto tr9 5694 case 58: 5695 goto tr9 5696 case 59: 5697 goto tr9 5698 case 60: 5699 goto tr9 5700 case 61: 5701 goto tr9 5702 case 62: 5703 goto tr9 5704 case 63: 5705 goto tr9 5706 case 64: 5707 goto tr9 5708 case 65: 5709 goto tr9 5710 case 66: 5711 goto tr9 5712 case 67: 5713 goto tr9 5714 case 68: 5715 goto tr9 5716 case 69: 5717 goto tr9 5718 case 70: 5719 goto tr9 5720 case 71: 5721 goto tr36 5722 case 180: 5723 goto tr221 5724 case 181: 5725 goto tr201 5726 case 182: 5727 goto tr222 5728 case 86: 5729 goto tr94 5730 case 183: 5731 goto tr224 5732 case 184: 5733 goto tr194 5734 case 185: 5735 goto tr9 5736 case 186: 5737 goto tr231 5738 case 187: 5739 goto tr194 5740 case 188: 5741 goto tr194 5742 case 189: 5743 goto tr194 5744 case 190: 5745 goto tr194 5746 case 191: 5747 goto tr194 5748 case 192: 5749 goto tr194 5750 case 193: 5751 goto tr194 5752 case 194: 5753 goto tr194 5754 case 195: 5755 goto tr194 5756 case 196: 5757 goto tr194 5758 case 197: 5759 goto tr194 5760 case 198: 5761 goto tr194 5762 case 199: 5763 goto tr194 5764 case 200: 5765 goto tr194 5766 case 201: 5767 goto tr231 5768 case 202: 5769 goto tr194 5770 case 203: 5771 goto tr194 5772 case 204: 5773 goto tr231 5774 case 205: 5775 goto tr231 5776 case 206: 5777 goto tr194 5778 case 208: 5779 goto tr251 5780 } 5781 } 5782 5783 _out: 5784 { 5785 } 5786 } 5787 5788 //line straceLex.rl:110 5789 5790 return tok 5791 } 5792 5793 func (lex *Stracelexer) Error(e string) { 5794 fmt.Println("error:", e) 5795 } 5796 5797 func ParseString(s string) string { 5798 var decoded []byte 5799 var err error 5800 var strippedStr string 5801 strippedStr = strings.Replace(s, `\x`, "", -1) 5802 strippedStr = strings.Replace(strippedStr, `"`, "", -1) 5803 5804 if decoded, err = hex.DecodeString(strippedStr); err != nil { 5805 log.Logf(2, "failed to decode string: %s, with error: %s", s, err.Error()) 5806 decoded = []byte(strippedStr) 5807 } 5808 return string(decoded) 5809 }