1//! This file was generated automatically by the Snowball to Go compiler 2//! http://snowballstem.org/ 3 4package english 5 6import ( 7 snowballRuntime "github.com/blevesearch/snowballstem" 8) 9 10var A_0 = []*snowballRuntime.Among{ 11 {Str: "arsen", A: -1, B: -1, F: nil}, 12 {Str: "commun", A: -1, B: -1, F: nil}, 13 {Str: "gener", A: -1, B: -1, F: nil}, 14} 15 16var A_1 = []*snowballRuntime.Among{ 17 {Str: "'", A: -1, B: 1, F: nil}, 18 {Str: "'s'", A: 0, B: 1, F: nil}, 19 {Str: "'s", A: -1, B: 1, F: nil}, 20} 21 22var A_2 = []*snowballRuntime.Among{ 23 {Str: "ied", A: -1, B: 2, F: nil}, 24 {Str: "s", A: -1, B: 3, F: nil}, 25 {Str: "ies", A: 1, B: 2, F: nil}, 26 {Str: "sses", A: 1, B: 1, F: nil}, 27 {Str: "ss", A: 1, B: -1, F: nil}, 28 {Str: "us", A: 1, B: -1, F: nil}, 29} 30 31var A_3 = []*snowballRuntime.Among{ 32 {Str: "", A: -1, B: 3, F: nil}, 33 {Str: "bb", A: 0, B: 2, F: nil}, 34 {Str: "dd", A: 0, B: 2, F: nil}, 35 {Str: "ff", A: 0, B: 2, F: nil}, 36 {Str: "gg", A: 0, B: 2, F: nil}, 37 {Str: "bl", A: 0, B: 1, F: nil}, 38 {Str: "mm", A: 0, B: 2, F: nil}, 39 {Str: "nn", A: 0, B: 2, F: nil}, 40 {Str: "pp", A: 0, B: 2, F: nil}, 41 {Str: "rr", A: 0, B: 2, F: nil}, 42 {Str: "at", A: 0, B: 1, F: nil}, 43 {Str: "tt", A: 0, B: 2, F: nil}, 44 {Str: "iz", A: 0, B: 1, F: nil}, 45} 46 47var A_4 = []*snowballRuntime.Among{ 48 {Str: "ed", A: -1, B: 2, F: nil}, 49 {Str: "eed", A: 0, B: 1, F: nil}, 50 {Str: "ing", A: -1, B: 2, F: nil}, 51 {Str: "edly", A: -1, B: 2, F: nil}, 52 {Str: "eedly", A: 3, B: 1, F: nil}, 53 {Str: "ingly", A: -1, B: 2, F: nil}, 54} 55 56var A_5 = []*snowballRuntime.Among{ 57 {Str: "anci", A: -1, B: 3, F: nil}, 58 {Str: "enci", A: -1, B: 2, F: nil}, 59 {Str: "ogi", A: -1, B: 13, F: nil}, 60 {Str: "li", A: -1, B: 16, F: nil}, 61 {Str: "bli", A: 3, B: 12, F: nil}, 62 {Str: "abli", A: 4, B: 4, F: nil}, 63 {Str: "alli", A: 3, B: 8, F: nil}, 64 {Str: "fulli", A: 3, B: 14, F: nil}, 65 {Str: "lessli", A: 3, B: 15, F: nil}, 66 {Str: "ousli", A: 3, B: 10, F: nil}, 67 {Str: "entli", A: 3, B: 5, F: nil}, 68 {Str: "aliti", A: -1, B: 8, F: nil}, 69 {Str: "biliti", A: -1, B: 12, F: nil}, 70 {Str: "iviti", A: -1, B: 11, F: nil}, 71 {Str: "tional", A: -1, B: 1, F: nil}, 72 {Str: "ational", A: 14, B: 7, F: nil}, 73 {Str: "alism", A: -1, B: 8, F: nil}, 74 {Str: "ation", A: -1, B: 7, F: nil}, 75 {Str: "ization", A: 17, B: 6, F: nil}, 76 {Str: "izer", A: -1, B: 6, F: nil}, 77 {Str: "ator", A: -1, B: 7, F: nil}, 78 {Str: "iveness", A: -1, B: 11, F: nil}, 79 {Str: "fulness", A: -1, B: 9, F: nil}, 80 {Str: "ousness", A: -1, B: 10, F: nil}, 81} 82 83var A_6 = []*snowballRuntime.Among{ 84 {Str: "icate", A: -1, B: 4, F: nil}, 85 {Str: "ative", A: -1, B: 6, F: nil}, 86 {Str: "alize", A: -1, B: 3, F: nil}, 87 {Str: "iciti", A: -1, B: 4, F: nil}, 88 {Str: "ical", A: -1, B: 4, F: nil}, 89 {Str: "tional", A: -1, B: 1, F: nil}, 90 {Str: "ational", A: 5, B: 2, F: nil}, 91 {Str: "ful", A: -1, B: 5, F: nil}, 92 {Str: "ness", A: -1, B: 5, F: nil}, 93} 94 95var A_7 = []*snowballRuntime.Among{ 96 {Str: "ic", A: -1, B: 1, F: nil}, 97 {Str: "ance", A: -1, B: 1, F: nil}, 98 {Str: "ence", A: -1, B: 1, F: nil}, 99 {Str: "able", A: -1, B: 1, F: nil}, 100 {Str: "ible", A: -1, B: 1, F: nil}, 101 {Str: "ate", A: -1, B: 1, F: nil}, 102 {Str: "ive", A: -1, B: 1, F: nil}, 103 {Str: "ize", A: -1, B: 1, F: nil}, 104 {Str: "iti", A: -1, B: 1, F: nil}, 105 {Str: "al", A: -1, B: 1, F: nil}, 106 {Str: "ism", A: -1, B: 1, F: nil}, 107 {Str: "ion", A: -1, B: 2, F: nil}, 108 {Str: "er", A: -1, B: 1, F: nil}, 109 {Str: "ous", A: -1, B: 1, F: nil}, 110 {Str: "ant", A: -1, B: 1, F: nil}, 111 {Str: "ent", A: -1, B: 1, F: nil}, 112 {Str: "ment", A: 15, B: 1, F: nil}, 113 {Str: "ement", A: 16, B: 1, F: nil}, 114} 115 116var A_8 = []*snowballRuntime.Among{ 117 {Str: "e", A: -1, B: 1, F: nil}, 118 {Str: "l", A: -1, B: 2, F: nil}, 119} 120 121var A_9 = []*snowballRuntime.Among{ 122 {Str: "succeed", A: -1, B: -1, F: nil}, 123 {Str: "proceed", A: -1, B: -1, F: nil}, 124 {Str: "exceed", A: -1, B: -1, F: nil}, 125 {Str: "canning", A: -1, B: -1, F: nil}, 126 {Str: "inning", A: -1, B: -1, F: nil}, 127 {Str: "earring", A: -1, B: -1, F: nil}, 128 {Str: "herring", A: -1, B: -1, F: nil}, 129 {Str: "outing", A: -1, B: -1, F: nil}, 130} 131 132var A_10 = []*snowballRuntime.Among{ 133 {Str: "andes", A: -1, B: -1, F: nil}, 134 {Str: "atlas", A: -1, B: -1, F: nil}, 135 {Str: "bias", A: -1, B: -1, F: nil}, 136 {Str: "cosmos", A: -1, B: -1, F: nil}, 137 {Str: "dying", A: -1, B: 3, F: nil}, 138 {Str: "early", A: -1, B: 9, F: nil}, 139 {Str: "gently", A: -1, B: 7, F: nil}, 140 {Str: "howe", A: -1, B: -1, F: nil}, 141 {Str: "idly", A: -1, B: 6, F: nil}, 142 {Str: "lying", A: -1, B: 4, F: nil}, 143 {Str: "news", A: -1, B: -1, F: nil}, 144 {Str: "only", A: -1, B: 10, F: nil}, 145 {Str: "singly", A: -1, B: 11, F: nil}, 146 {Str: "skies", A: -1, B: 2, F: nil}, 147 {Str: "skis", A: -1, B: 1, F: nil}, 148 {Str: "sky", A: -1, B: -1, F: nil}, 149 {Str: "tying", A: -1, B: 5, F: nil}, 150 {Str: "ugly", A: -1, B: 8, F: nil}, 151} 152 153var G_v = []byte{17, 65, 16, 1} 154 155var G_v_WXY = []byte{1, 17, 65, 208, 1} 156 157var G_valid_LI = []byte{55, 141, 2} 158 159type Context struct { 160 b_Y_found bool 161 i_p2 int 162 i_p1 int 163} 164 165func r_prelude(env *snowballRuntime.Env, ctx interface{}) bool { 166 context := ctx.(*Context) 167 _ = context 168 // (, line 25 169 // unset Y_found, line 26 170 context.b_Y_found = false 171 // do, line 27 172 var v_1 = env.Cursor 173lab0: 174 for { 175 // (, line 27 176 // [, line 27 177 env.Bra = env.Cursor 178 // literal, line 27 179 if !env.EqS("'") { 180 break lab0 181 } 182 // ], line 27 183 env.Ket = env.Cursor 184 // delete, line 27 185 if !env.SliceDel() { 186 return false 187 } 188 break lab0 189 } 190 env.Cursor = v_1 191 // do, line 28 192 var v_2 = env.Cursor 193lab1: 194 for { 195 // (, line 28 196 // [, line 28 197 env.Bra = env.Cursor 198 // literal, line 28 199 if !env.EqS("y") { 200 break lab1 201 } 202 // ], line 28 203 env.Ket = env.Cursor 204 // <-, line 28 205 if !env.SliceFrom("Y") { 206 return false 207 } 208 // set Y_found, line 28 209 context.b_Y_found = true 210 break lab1 211 } 212 env.Cursor = v_2 213 // do, line 29 214 var v_3 = env.Cursor 215lab2: 216 for { 217 // repeat, line 29 218 replab3: 219 for { 220 var v_4 = env.Cursor 221 lab4: 222 for range [2]struct{}{} { 223 // (, line 29 224 // goto, line 29 225 golab5: 226 for { 227 var v_5 = env.Cursor 228 lab6: 229 for { 230 // (, line 29 231 if !env.InGrouping(G_v, 97, 121) { 232 break lab6 233 } 234 // [, line 29 235 env.Bra = env.Cursor 236 // literal, line 29 237 if !env.EqS("y") { 238 break lab6 239 } 240 // ], line 29 241 env.Ket = env.Cursor 242 env.Cursor = v_5 243 break golab5 244 } 245 env.Cursor = v_5 246 if env.Cursor >= env.Limit { 247 break lab4 248 } 249 env.NextChar() 250 } 251 // <-, line 29 252 if !env.SliceFrom("Y") { 253 return false 254 } 255 // set Y_found, line 29 256 context.b_Y_found = true 257 continue replab3 258 } 259 env.Cursor = v_4 260 break replab3 261 } 262 break lab2 263 } 264 env.Cursor = v_3 265 return true 266} 267 268func r_mark_regions(env *snowballRuntime.Env, ctx interface{}) bool { 269 context := ctx.(*Context) 270 _ = context 271 // (, line 32 272 context.i_p1 = env.Limit 273 context.i_p2 = env.Limit 274 // do, line 35 275 var v_1 = env.Cursor 276lab0: 277 for { 278 // (, line 35 279 // or, line 41 280 lab1: 281 for { 282 var v_2 = env.Cursor 283 lab2: 284 for { 285 // among, line 36 286 if env.FindAmong(A_0, context) == 0 { 287 break lab2 288 } 289 break lab1 290 } 291 env.Cursor = v_2 292 // (, line 41 293 // gopast, line 41 294 golab3: 295 for { 296 lab4: 297 for { 298 if !env.InGrouping(G_v, 97, 121) { 299 break lab4 300 } 301 break golab3 302 } 303 if env.Cursor >= env.Limit { 304 break lab0 305 } 306 env.NextChar() 307 } 308 // gopast, line 41 309 golab5: 310 for { 311 lab6: 312 for { 313 if !env.OutGrouping(G_v, 97, 121) { 314 break lab6 315 } 316 break golab5 317 } 318 if env.Cursor >= env.Limit { 319 break lab0 320 } 321 env.NextChar() 322 } 323 break lab1 324 } 325 // setmark p1, line 42 326 context.i_p1 = env.Cursor 327 // gopast, line 43 328 golab7: 329 for { 330 lab8: 331 for { 332 if !env.InGrouping(G_v, 97, 121) { 333 break lab8 334 } 335 break golab7 336 } 337 if env.Cursor >= env.Limit { 338 break lab0 339 } 340 env.NextChar() 341 } 342 // gopast, line 43 343 golab9: 344 for { 345 lab10: 346 for { 347 if !env.OutGrouping(G_v, 97, 121) { 348 break lab10 349 } 350 break golab9 351 } 352 if env.Cursor >= env.Limit { 353 break lab0 354 } 355 env.NextChar() 356 } 357 // setmark p2, line 43 358 context.i_p2 = env.Cursor 359 break lab0 360 } 361 env.Cursor = v_1 362 return true 363} 364 365func r_shortv(env *snowballRuntime.Env, ctx interface{}) bool { 366 context := ctx.(*Context) 367 _ = context 368 // (, line 49 369 // or, line 51 370lab0: 371 for { 372 var v_1 = env.Limit - env.Cursor 373 lab1: 374 for { 375 // (, line 50 376 if !env.OutGroupingB(G_v_WXY, 89, 121) { 377 break lab1 378 } 379 if !env.InGroupingB(G_v, 97, 121) { 380 break lab1 381 } 382 if !env.OutGroupingB(G_v, 97, 121) { 383 break lab1 384 } 385 break lab0 386 } 387 env.Cursor = env.Limit - v_1 388 // (, line 52 389 if !env.OutGroupingB(G_v, 97, 121) { 390 return false 391 } 392 if !env.InGroupingB(G_v, 97, 121) { 393 return false 394 } 395 // atlimit, line 52 396 if env.Cursor > env.LimitBackward { 397 return false 398 } 399 break lab0 400 } 401 return true 402} 403 404func r_R1(env *snowballRuntime.Env, ctx interface{}) bool { 405 context := ctx.(*Context) 406 _ = context 407 if !(context.i_p1 <= env.Cursor) { 408 return false 409 } 410 return true 411} 412 413func r_R2(env *snowballRuntime.Env, ctx interface{}) bool { 414 context := ctx.(*Context) 415 _ = context 416 if !(context.i_p2 <= env.Cursor) { 417 return false 418 } 419 return true 420} 421 422func r_Step_1a(env *snowballRuntime.Env, ctx interface{}) bool { 423 context := ctx.(*Context) 424 _ = context 425 var among_var int32 426 // (, line 58 427 // try, line 59 428 var v_1 = env.Limit - env.Cursor 429lab0: 430 for { 431 // (, line 59 432 // [, line 60 433 env.Ket = env.Cursor 434 // substring, line 60 435 among_var = env.FindAmongB(A_1, context) 436 if among_var == 0 { 437 env.Cursor = env.Limit - v_1 438 break lab0 439 } 440 // ], line 60 441 env.Bra = env.Cursor 442 if among_var == 0 { 443 env.Cursor = env.Limit - v_1 444 break lab0 445 } else if among_var == 1 { 446 // (, line 62 447 // delete, line 62 448 if !env.SliceDel() { 449 return false 450 } 451 } 452 break lab0 453 } 454 // [, line 65 455 env.Ket = env.Cursor 456 // substring, line 65 457 among_var = env.FindAmongB(A_2, context) 458 if among_var == 0 { 459 return false 460 } 461 // ], line 65 462 env.Bra = env.Cursor 463 if among_var == 0 { 464 return false 465 } else if among_var == 1 { 466 // (, line 66 467 // <-, line 66 468 if !env.SliceFrom("ss") { 469 return false 470 } 471 } else if among_var == 2 { 472 // (, line 68 473 // or, line 68 474 lab1: 475 for { 476 var v_2 = env.Limit - env.Cursor 477 lab2: 478 for { 479 // (, line 68 480 { 481 // hop, line 68 482 var c = env.ByteIndexForHop(-(2)) 483 if int32(env.LimitBackward) > c || c > int32(env.Limit) { 484 break lab2 485 } 486 env.Cursor = int(c) 487 } 488 // <-, line 68 489 if !env.SliceFrom("i") { 490 return false 491 } 492 break lab1 493 } 494 env.Cursor = env.Limit - v_2 495 // <-, line 68 496 if !env.SliceFrom("ie") { 497 return false 498 } 499 break lab1 500 } 501 } else if among_var == 3 { 502 // (, line 69 503 // next, line 69 504 if env.Cursor <= env.LimitBackward { 505 return false 506 } 507 env.PrevChar() 508 // gopast, line 69 509 golab3: 510 for { 511 lab4: 512 for { 513 if !env.InGroupingB(G_v, 97, 121) { 514 break lab4 515 } 516 break golab3 517 } 518 if env.Cursor <= env.LimitBackward { 519 return false 520 } 521 env.PrevChar() 522 } 523 // delete, line 69 524 if !env.SliceDel() { 525 return false 526 } 527 } 528 return true 529} 530 531func r_Step_1b(env *snowballRuntime.Env, ctx interface{}) bool { 532 context := ctx.(*Context) 533 _ = context 534 var among_var int32 535 // (, line 74 536 // [, line 75 537 env.Ket = env.Cursor 538 // substring, line 75 539 among_var = env.FindAmongB(A_4, context) 540 if among_var == 0 { 541 return false 542 } 543 // ], line 75 544 env.Bra = env.Cursor 545 if among_var == 0 { 546 return false 547 } else if among_var == 1 { 548 // (, line 77 549 // call R1, line 77 550 if !r_R1(env, context) { 551 return false 552 } 553 // <-, line 77 554 if !env.SliceFrom("ee") { 555 return false 556 } 557 } else if among_var == 2 { 558 // (, line 79 559 // test, line 80 560 var v_1 = env.Limit - env.Cursor 561 // gopast, line 80 562 golab0: 563 for { 564 lab1: 565 for { 566 if !env.InGroupingB(G_v, 97, 121) { 567 break lab1 568 } 569 break golab0 570 } 571 if env.Cursor <= env.LimitBackward { 572 return false 573 } 574 env.PrevChar() 575 } 576 env.Cursor = env.Limit - v_1 577 // delete, line 80 578 if !env.SliceDel() { 579 return false 580 } 581 // test, line 81 582 var v_3 = env.Limit - env.Cursor 583 // substring, line 81 584 among_var = env.FindAmongB(A_3, context) 585 if among_var == 0 { 586 return false 587 } 588 env.Cursor = env.Limit - v_3 589 if among_var == 0 { 590 return false 591 } else if among_var == 1 { 592 // (, line 83 593 { 594 // <+, line 83 595 var c = env.Cursor 596 bra, ket := env.Cursor, env.Cursor 597 env.Insert(bra, ket, "e") 598 env.Cursor = c 599 } 600 } else if among_var == 2 { 601 // (, line 86 602 // [, line 86 603 env.Ket = env.Cursor 604 // next, line 86 605 if env.Cursor <= env.LimitBackward { 606 return false 607 } 608 env.PrevChar() 609 // ], line 86 610 env.Bra = env.Cursor 611 // delete, line 86 612 if !env.SliceDel() { 613 return false 614 } 615 } else if among_var == 3 { 616 // (, line 87 617 // atmark, line 87 618 if env.Cursor != context.i_p1 { 619 return false 620 } 621 // test, line 87 622 var v_4 = env.Limit - env.Cursor 623 // call shortv, line 87 624 if !r_shortv(env, context) { 625 return false 626 } 627 env.Cursor = env.Limit - v_4 628 { 629 // <+, line 87 630 var c = env.Cursor 631 bra, ket := env.Cursor, env.Cursor 632 env.Insert(bra, ket, "e") 633 env.Cursor = c 634 } 635 } 636 } 637 return true 638} 639 640func r_Step_1c(env *snowballRuntime.Env, ctx interface{}) bool { 641 context := ctx.(*Context) 642 _ = context 643 // (, line 93 644 // [, line 94 645 env.Ket = env.Cursor 646 // or, line 94 647lab0: 648 for { 649 var v_1 = env.Limit - env.Cursor 650 lab1: 651 for { 652 // literal, line 94 653 if !env.EqSB("y") { 654 break lab1 655 } 656 break lab0 657 } 658 env.Cursor = env.Limit - v_1 659 // literal, line 94 660 if !env.EqSB("Y") { 661 return false 662 } 663 break lab0 664 } 665 // ], line 94 666 env.Bra = env.Cursor 667 if !env.OutGroupingB(G_v, 97, 121) { 668 return false 669 } 670 // not, line 95 671 var v_2 = env.Limit - env.Cursor 672lab2: 673 for { 674 // atlimit, line 95 675 if env.Cursor > env.LimitBackward { 676 break lab2 677 } 678 return false 679 } 680 env.Cursor = env.Limit - v_2 681 // <-, line 96 682 if !env.SliceFrom("i") { 683 return false 684 } 685 return true 686} 687 688func r_Step_2(env *snowballRuntime.Env, ctx interface{}) bool { 689 context := ctx.(*Context) 690 _ = context 691 var among_var int32 692 // (, line 99 693 // [, line 100 694 env.Ket = env.Cursor 695 // substring, line 100 696 among_var = env.FindAmongB(A_5, context) 697 if among_var == 0 { 698 return false 699 } 700 // ], line 100 701 env.Bra = env.Cursor 702 // call R1, line 100 703 if !r_R1(env, context) { 704 return false 705 } 706 if among_var == 0 { 707 return false 708 } else if among_var == 1 { 709 // (, line 101 710 // <-, line 101 711 if !env.SliceFrom("tion") { 712 return false 713 } 714 } else if among_var == 2 { 715 // (, line 102 716 // <-, line 102 717 if !env.SliceFrom("ence") { 718 return false 719 } 720 } else if among_var == 3 { 721 // (, line 103 722 // <-, line 103 723 if !env.SliceFrom("ance") { 724 return false 725 } 726 } else if among_var == 4 { 727 // (, line 104 728 // <-, line 104 729 if !env.SliceFrom("able") { 730 return false 731 } 732 } else if among_var == 5 { 733 // (, line 105 734 // <-, line 105 735 if !env.SliceFrom("ent") { 736 return false 737 } 738 } else if among_var == 6 { 739 // (, line 107 740 // <-, line 107 741 if !env.SliceFrom("ize") { 742 return false 743 } 744 } else if among_var == 7 { 745 // (, line 109 746 // <-, line 109 747 if !env.SliceFrom("ate") { 748 return false 749 } 750 } else if among_var == 8 { 751 // (, line 111 752 // <-, line 111 753 if !env.SliceFrom("al") { 754 return false 755 } 756 } else if among_var == 9 { 757 // (, line 112 758 // <-, line 112 759 if !env.SliceFrom("ful") { 760 return false 761 } 762 } else if among_var == 10 { 763 // (, line 114 764 // <-, line 114 765 if !env.SliceFrom("ous") { 766 return false 767 } 768 } else if among_var == 11 { 769 // (, line 116 770 // <-, line 116 771 if !env.SliceFrom("ive") { 772 return false 773 } 774 } else if among_var == 12 { 775 // (, line 118 776 // <-, line 118 777 if !env.SliceFrom("ble") { 778 return false 779 } 780 } else if among_var == 13 { 781 // (, line 119 782 // literal, line 119 783 if !env.EqSB("l") { 784 return false 785 } 786 // <-, line 119 787 if !env.SliceFrom("og") { 788 return false 789 } 790 } else if among_var == 14 { 791 // (, line 120 792 // <-, line 120 793 if !env.SliceFrom("ful") { 794 return false 795 } 796 } else if among_var == 15 { 797 // (, line 121 798 // <-, line 121 799 if !env.SliceFrom("less") { 800 return false 801 } 802 } else if among_var == 16 { 803 // (, line 122 804 if !env.InGroupingB(G_valid_LI, 99, 116) { 805 return false 806 } 807 // delete, line 122 808 if !env.SliceDel() { 809 return false 810 } 811 } 812 return true 813} 814 815func r_Step_3(env *snowballRuntime.Env, ctx interface{}) bool { 816 context := ctx.(*Context) 817 _ = context 818 var among_var int32 819 // (, line 126 820 // [, line 127 821 env.Ket = env.Cursor 822 // substring, line 127 823 among_var = env.FindAmongB(A_6, context) 824 if among_var == 0 { 825 return false 826 } 827 // ], line 127 828 env.Bra = env.Cursor 829 // call R1, line 127 830 if !r_R1(env, context) { 831 return false 832 } 833 if among_var == 0 { 834 return false 835 } else if among_var == 1 { 836 // (, line 128 837 // <-, line 128 838 if !env.SliceFrom("tion") { 839 return false 840 } 841 } else if among_var == 2 { 842 // (, line 129 843 // <-, line 129 844 if !env.SliceFrom("ate") { 845 return false 846 } 847 } else if among_var == 3 { 848 // (, line 130 849 // <-, line 130 850 if !env.SliceFrom("al") { 851 return false 852 } 853 } else if among_var == 4 { 854 // (, line 132 855 // <-, line 132 856 if !env.SliceFrom("ic") { 857 return false 858 } 859 } else if among_var == 5 { 860 // (, line 134 861 // delete, line 134 862 if !env.SliceDel() { 863 return false 864 } 865 } else if among_var == 6 { 866 // (, line 136 867 // call R2, line 136 868 if !r_R2(env, context) { 869 return false 870 } 871 // delete, line 136 872 if !env.SliceDel() { 873 return false 874 } 875 } 876 return true 877} 878 879func r_Step_4(env *snowballRuntime.Env, ctx interface{}) bool { 880 context := ctx.(*Context) 881 _ = context 882 var among_var int32 883 // (, line 140 884 // [, line 141 885 env.Ket = env.Cursor 886 // substring, line 141 887 among_var = env.FindAmongB(A_7, context) 888 if among_var == 0 { 889 return false 890 } 891 // ], line 141 892 env.Bra = env.Cursor 893 // call R2, line 141 894 if !r_R2(env, context) { 895 return false 896 } 897 if among_var == 0 { 898 return false 899 } else if among_var == 1 { 900 // (, line 144 901 // delete, line 144 902 if !env.SliceDel() { 903 return false 904 } 905 } else if among_var == 2 { 906 // (, line 145 907 // or, line 145 908 lab0: 909 for { 910 var v_1 = env.Limit - env.Cursor 911 lab1: 912 for { 913 // literal, line 145 914 if !env.EqSB("s") { 915 break lab1 916 } 917 break lab0 918 } 919 env.Cursor = env.Limit - v_1 920 // literal, line 145 921 if !env.EqSB("t") { 922 return false 923 } 924 break lab0 925 } 926 // delete, line 145 927 if !env.SliceDel() { 928 return false 929 } 930 } 931 return true 932} 933 934func r_Step_5(env *snowballRuntime.Env, ctx interface{}) bool { 935 context := ctx.(*Context) 936 _ = context 937 var among_var int32 938 // (, line 149 939 // [, line 150 940 env.Ket = env.Cursor 941 // substring, line 150 942 among_var = env.FindAmongB(A_8, context) 943 if among_var == 0 { 944 return false 945 } 946 // ], line 150 947 env.Bra = env.Cursor 948 if among_var == 0 { 949 return false 950 } else if among_var == 1 { 951 // (, line 151 952 // or, line 151 953 lab0: 954 for { 955 var v_1 = env.Limit - env.Cursor 956 lab1: 957 for { 958 // call R2, line 151 959 if !r_R2(env, context) { 960 break lab1 961 } 962 break lab0 963 } 964 env.Cursor = env.Limit - v_1 965 // (, line 151 966 // call R1, line 151 967 if !r_R1(env, context) { 968 return false 969 } 970 // not, line 151 971 var v_2 = env.Limit - env.Cursor 972 lab2: 973 for { 974 // call shortv, line 151 975 if !r_shortv(env, context) { 976 break lab2 977 } 978 return false 979 } 980 env.Cursor = env.Limit - v_2 981 break lab0 982 } 983 // delete, line 151 984 if !env.SliceDel() { 985 return false 986 } 987 } else if among_var == 2 { 988 // (, line 152 989 // call R2, line 152 990 if !r_R2(env, context) { 991 return false 992 } 993 // literal, line 152 994 if !env.EqSB("l") { 995 return false 996 } 997 // delete, line 152 998 if !env.SliceDel() { 999 return false 1000 } 1001 } 1002 return true 1003} 1004 1005func r_exception2(env *snowballRuntime.Env, ctx interface{}) bool { 1006 context := ctx.(*Context) 1007 _ = context 1008 // (, line 156 1009 // [, line 158 1010 env.Ket = env.Cursor 1011 // substring, line 158 1012 if env.FindAmongB(A_9, context) == 0 { 1013 return false 1014 } 1015 // ], line 158 1016 env.Bra = env.Cursor 1017 // atlimit, line 158 1018 if env.Cursor > env.LimitBackward { 1019 return false 1020 } 1021 return true 1022} 1023 1024func r_exception1(env *snowballRuntime.Env, ctx interface{}) bool { 1025 context := ctx.(*Context) 1026 _ = context 1027 var among_var int32 1028 // (, line 168 1029 // [, line 170 1030 env.Bra = env.Cursor 1031 // substring, line 170 1032 among_var = env.FindAmong(A_10, context) 1033 if among_var == 0 { 1034 return false 1035 } 1036 // ], line 170 1037 env.Ket = env.Cursor 1038 // atlimit, line 170 1039 if env.Cursor < env.Limit { 1040 return false 1041 } 1042 if among_var == 0 { 1043 return false 1044 } else if among_var == 1 { 1045 // (, line 174 1046 // <-, line 174 1047 if !env.SliceFrom("ski") { 1048 return false 1049 } 1050 } else if among_var == 2 { 1051 // (, line 175 1052 // <-, line 175 1053 if !env.SliceFrom("sky") { 1054 return false 1055 } 1056 } else if among_var == 3 { 1057 // (, line 176 1058 // <-, line 176 1059 if !env.SliceFrom("die") { 1060 return false 1061 } 1062 } else if among_var == 4 { 1063 // (, line 177 1064 // <-, line 177 1065 if !env.SliceFrom("lie") { 1066 return false 1067 } 1068 } else if among_var == 5 { 1069 // (, line 178 1070 // <-, line 178 1071 if !env.SliceFrom("tie") { 1072 return false 1073 } 1074 } else if among_var == 6 { 1075 // (, line 182 1076 // <-, line 182 1077 if !env.SliceFrom("idl") { 1078 return false 1079 } 1080 } else if among_var == 7 { 1081 // (, line 183 1082 // <-, line 183 1083 if !env.SliceFrom("gentl") { 1084 return false 1085 } 1086 } else if among_var == 8 { 1087 // (, line 184 1088 // <-, line 184 1089 if !env.SliceFrom("ugli") { 1090 return false 1091 } 1092 } else if among_var == 9 { 1093 // (, line 185 1094 // <-, line 185 1095 if !env.SliceFrom("earli") { 1096 return false 1097 } 1098 } else if among_var == 10 { 1099 // (, line 186 1100 // <-, line 186 1101 if !env.SliceFrom("onli") { 1102 return false 1103 } 1104 } else if among_var == 11 { 1105 // (, line 187 1106 // <-, line 187 1107 if !env.SliceFrom("singl") { 1108 return false 1109 } 1110 } 1111 return true 1112} 1113 1114func r_postlude(env *snowballRuntime.Env, ctx interface{}) bool { 1115 context := ctx.(*Context) 1116 _ = context 1117 // (, line 203 1118 // Boolean test Y_found, line 203 1119 if !context.b_Y_found { 1120 return false 1121 } 1122 // repeat, line 203 1123replab0: 1124 for { 1125 var v_1 = env.Cursor 1126 lab1: 1127 for range [2]struct{}{} { 1128 // (, line 203 1129 // goto, line 203 1130 golab2: 1131 for { 1132 var v_2 = env.Cursor 1133 lab3: 1134 for { 1135 // (, line 203 1136 // [, line 203 1137 env.Bra = env.Cursor 1138 // literal, line 203 1139 if !env.EqS("Y") { 1140 break lab3 1141 } 1142 // ], line 203 1143 env.Ket = env.Cursor 1144 env.Cursor = v_2 1145 break golab2 1146 } 1147 env.Cursor = v_2 1148 if env.Cursor >= env.Limit { 1149 break lab1 1150 } 1151 env.NextChar() 1152 } 1153 // <-, line 203 1154 if !env.SliceFrom("y") { 1155 return false 1156 } 1157 continue replab0 1158 } 1159 env.Cursor = v_1 1160 break replab0 1161 } 1162 return true 1163} 1164 1165func Stem(env *snowballRuntime.Env) bool { 1166 var context = &Context{ 1167 b_Y_found: false, 1168 i_p2: 0, 1169 i_p1: 0, 1170 } 1171 _ = context 1172 // (, line 205 1173 // or, line 207 1174lab0: 1175 for { 1176 var v_1 = env.Cursor 1177 lab1: 1178 for { 1179 // call exception1, line 207 1180 if !r_exception1(env, context) { 1181 break lab1 1182 } 1183 break lab0 1184 } 1185 env.Cursor = v_1 1186 lab2: 1187 for { 1188 // not, line 208 1189 var v_2 = env.Cursor 1190 lab3: 1191 for { 1192 { 1193 // hop, line 208 1194 var c = env.ByteIndexForHop((3)) 1195 if int32(0) > c || c > int32(env.Limit) { 1196 break lab3 1197 } 1198 env.Cursor = int(c) 1199 } 1200 break lab2 1201 } 1202 env.Cursor = v_2 1203 break lab0 1204 } 1205 env.Cursor = v_1 1206 // (, line 208 1207 // do, line 209 1208 var v_3 = env.Cursor 1209 lab4: 1210 for { 1211 // call prelude, line 209 1212 if !r_prelude(env, context) { 1213 break lab4 1214 } 1215 break lab4 1216 } 1217 env.Cursor = v_3 1218 // do, line 210 1219 var v_4 = env.Cursor 1220 lab5: 1221 for { 1222 // call mark_regions, line 210 1223 if !r_mark_regions(env, context) { 1224 break lab5 1225 } 1226 break lab5 1227 } 1228 env.Cursor = v_4 1229 // backwards, line 211 1230 env.LimitBackward = env.Cursor 1231 env.Cursor = env.Limit 1232 // (, line 211 1233 // do, line 213 1234 var v_5 = env.Limit - env.Cursor 1235 lab6: 1236 for { 1237 // call Step_1a, line 213 1238 if !r_Step_1a(env, context) { 1239 break lab6 1240 } 1241 break lab6 1242 } 1243 env.Cursor = env.Limit - v_5 1244 // or, line 215 1245 lab7: 1246 for { 1247 var v_6 = env.Limit - env.Cursor 1248 lab8: 1249 for { 1250 // call exception2, line 215 1251 if !r_exception2(env, context) { 1252 break lab8 1253 } 1254 break lab7 1255 } 1256 env.Cursor = env.Limit - v_6 1257 // (, line 215 1258 // do, line 217 1259 var v_7 = env.Limit - env.Cursor 1260 lab9: 1261 for { 1262 // call Step_1b, line 217 1263 if !r_Step_1b(env, context) { 1264 break lab9 1265 } 1266 break lab9 1267 } 1268 env.Cursor = env.Limit - v_7 1269 // do, line 218 1270 var v_8 = env.Limit - env.Cursor 1271 lab10: 1272 for { 1273 // call Step_1c, line 218 1274 if !r_Step_1c(env, context) { 1275 break lab10 1276 } 1277 break lab10 1278 } 1279 env.Cursor = env.Limit - v_8 1280 // do, line 220 1281 var v_9 = env.Limit - env.Cursor 1282 lab11: 1283 for { 1284 // call Step_2, line 220 1285 if !r_Step_2(env, context) { 1286 break lab11 1287 } 1288 break lab11 1289 } 1290 env.Cursor = env.Limit - v_9 1291 // do, line 221 1292 var v_10 = env.Limit - env.Cursor 1293 lab12: 1294 for { 1295 // call Step_3, line 221 1296 if !r_Step_3(env, context) { 1297 break lab12 1298 } 1299 break lab12 1300 } 1301 env.Cursor = env.Limit - v_10 1302 // do, line 222 1303 var v_11 = env.Limit - env.Cursor 1304 lab13: 1305 for { 1306 // call Step_4, line 222 1307 if !r_Step_4(env, context) { 1308 break lab13 1309 } 1310 break lab13 1311 } 1312 env.Cursor = env.Limit - v_11 1313 // do, line 224 1314 var v_12 = env.Limit - env.Cursor 1315 lab14: 1316 for { 1317 // call Step_5, line 224 1318 if !r_Step_5(env, context) { 1319 break lab14 1320 } 1321 break lab14 1322 } 1323 env.Cursor = env.Limit - v_12 1324 break lab7 1325 } 1326 env.Cursor = env.LimitBackward 1327 // do, line 227 1328 var v_13 = env.Cursor 1329 lab15: 1330 for { 1331 // call postlude, line 227 1332 if !r_postlude(env, context) { 1333 break lab15 1334 } 1335 break lab15 1336 } 1337 env.Cursor = v_13 1338 break lab0 1339 } 1340 return true 1341} 1342