forgejo/vendor/github.com/blevesearch/snowballstem/english/english_stemmer.go
6543 fdf750e4d4
[Vendor] blevesearch v0.8.1 -> v1.0.7 (#11360)
* Update blevesearch v0.8.1 -> v1.0.7

* make vendor

Co-authored-by: zeripath <art27@cantab.net>
2020-05-10 06:40:54 +01:00

1342 lines
25 KiB
Go

//! This file was generated automatically by the Snowball to Go compiler
//! http://snowballstem.org/
package english
import (
snowballRuntime "github.com/blevesearch/snowballstem"
)
var A_0 = []*snowballRuntime.Among{
{Str: "arsen", A: -1, B: -1, F: nil},
{Str: "commun", A: -1, B: -1, F: nil},
{Str: "gener", A: -1, B: -1, F: nil},
}
var A_1 = []*snowballRuntime.Among{
{Str: "'", A: -1, B: 1, F: nil},
{Str: "'s'", A: 0, B: 1, F: nil},
{Str: "'s", A: -1, B: 1, F: nil},
}
var A_2 = []*snowballRuntime.Among{
{Str: "ied", A: -1, B: 2, F: nil},
{Str: "s", A: -1, B: 3, F: nil},
{Str: "ies", A: 1, B: 2, F: nil},
{Str: "sses", A: 1, B: 1, F: nil},
{Str: "ss", A: 1, B: -1, F: nil},
{Str: "us", A: 1, B: -1, F: nil},
}
var A_3 = []*snowballRuntime.Among{
{Str: "", A: -1, B: 3, F: nil},
{Str: "bb", A: 0, B: 2, F: nil},
{Str: "dd", A: 0, B: 2, F: nil},
{Str: "ff", A: 0, B: 2, F: nil},
{Str: "gg", A: 0, B: 2, F: nil},
{Str: "bl", A: 0, B: 1, F: nil},
{Str: "mm", A: 0, B: 2, F: nil},
{Str: "nn", A: 0, B: 2, F: nil},
{Str: "pp", A: 0, B: 2, F: nil},
{Str: "rr", A: 0, B: 2, F: nil},
{Str: "at", A: 0, B: 1, F: nil},
{Str: "tt", A: 0, B: 2, F: nil},
{Str: "iz", A: 0, B: 1, F: nil},
}
var A_4 = []*snowballRuntime.Among{
{Str: "ed", A: -1, B: 2, F: nil},
{Str: "eed", A: 0, B: 1, F: nil},
{Str: "ing", A: -1, B: 2, F: nil},
{Str: "edly", A: -1, B: 2, F: nil},
{Str: "eedly", A: 3, B: 1, F: nil},
{Str: "ingly", A: -1, B: 2, F: nil},
}
var A_5 = []*snowballRuntime.Among{
{Str: "anci", A: -1, B: 3, F: nil},
{Str: "enci", A: -1, B: 2, F: nil},
{Str: "ogi", A: -1, B: 13, F: nil},
{Str: "li", A: -1, B: 16, F: nil},
{Str: "bli", A: 3, B: 12, F: nil},
{Str: "abli", A: 4, B: 4, F: nil},
{Str: "alli", A: 3, B: 8, F: nil},
{Str: "fulli", A: 3, B: 14, F: nil},
{Str: "lessli", A: 3, B: 15, F: nil},
{Str: "ousli", A: 3, B: 10, F: nil},
{Str: "entli", A: 3, B: 5, F: nil},
{Str: "aliti", A: -1, B: 8, F: nil},
{Str: "biliti", A: -1, B: 12, F: nil},
{Str: "iviti", A: -1, B: 11, F: nil},
{Str: "tional", A: -1, B: 1, F: nil},
{Str: "ational", A: 14, B: 7, F: nil},
{Str: "alism", A: -1, B: 8, F: nil},
{Str: "ation", A: -1, B: 7, F: nil},
{Str: "ization", A: 17, B: 6, F: nil},
{Str: "izer", A: -1, B: 6, F: nil},
{Str: "ator", A: -1, B: 7, F: nil},
{Str: "iveness", A: -1, B: 11, F: nil},
{Str: "fulness", A: -1, B: 9, F: nil},
{Str: "ousness", A: -1, B: 10, F: nil},
}
var A_6 = []*snowballRuntime.Among{
{Str: "icate", A: -1, B: 4, F: nil},
{Str: "ative", A: -1, B: 6, F: nil},
{Str: "alize", A: -1, B: 3, F: nil},
{Str: "iciti", A: -1, B: 4, F: nil},
{Str: "ical", A: -1, B: 4, F: nil},
{Str: "tional", A: -1, B: 1, F: nil},
{Str: "ational", A: 5, B: 2, F: nil},
{Str: "ful", A: -1, B: 5, F: nil},
{Str: "ness", A: -1, B: 5, F: nil},
}
var A_7 = []*snowballRuntime.Among{
{Str: "ic", A: -1, B: 1, F: nil},
{Str: "ance", A: -1, B: 1, F: nil},
{Str: "ence", A: -1, B: 1, F: nil},
{Str: "able", A: -1, B: 1, F: nil},
{Str: "ible", A: -1, B: 1, F: nil},
{Str: "ate", A: -1, B: 1, F: nil},
{Str: "ive", A: -1, B: 1, F: nil},
{Str: "ize", A: -1, B: 1, F: nil},
{Str: "iti", A: -1, B: 1, F: nil},
{Str: "al", A: -1, B: 1, F: nil},
{Str: "ism", A: -1, B: 1, F: nil},
{Str: "ion", A: -1, B: 2, F: nil},
{Str: "er", A: -1, B: 1, F: nil},
{Str: "ous", A: -1, B: 1, F: nil},
{Str: "ant", A: -1, B: 1, F: nil},
{Str: "ent", A: -1, B: 1, F: nil},
{Str: "ment", A: 15, B: 1, F: nil},
{Str: "ement", A: 16, B: 1, F: nil},
}
var A_8 = []*snowballRuntime.Among{
{Str: "e", A: -1, B: 1, F: nil},
{Str: "l", A: -1, B: 2, F: nil},
}
var A_9 = []*snowballRuntime.Among{
{Str: "succeed", A: -1, B: -1, F: nil},
{Str: "proceed", A: -1, B: -1, F: nil},
{Str: "exceed", A: -1, B: -1, F: nil},
{Str: "canning", A: -1, B: -1, F: nil},
{Str: "inning", A: -1, B: -1, F: nil},
{Str: "earring", A: -1, B: -1, F: nil},
{Str: "herring", A: -1, B: -1, F: nil},
{Str: "outing", A: -1, B: -1, F: nil},
}
var A_10 = []*snowballRuntime.Among{
{Str: "andes", A: -1, B: -1, F: nil},
{Str: "atlas", A: -1, B: -1, F: nil},
{Str: "bias", A: -1, B: -1, F: nil},
{Str: "cosmos", A: -1, B: -1, F: nil},
{Str: "dying", A: -1, B: 3, F: nil},
{Str: "early", A: -1, B: 9, F: nil},
{Str: "gently", A: -1, B: 7, F: nil},
{Str: "howe", A: -1, B: -1, F: nil},
{Str: "idly", A: -1, B: 6, F: nil},
{Str: "lying", A: -1, B: 4, F: nil},
{Str: "news", A: -1, B: -1, F: nil},
{Str: "only", A: -1, B: 10, F: nil},
{Str: "singly", A: -1, B: 11, F: nil},
{Str: "skies", A: -1, B: 2, F: nil},
{Str: "skis", A: -1, B: 1, F: nil},
{Str: "sky", A: -1, B: -1, F: nil},
{Str: "tying", A: -1, B: 5, F: nil},
{Str: "ugly", A: -1, B: 8, F: nil},
}
var G_v = []byte{17, 65, 16, 1}
var G_v_WXY = []byte{1, 17, 65, 208, 1}
var G_valid_LI = []byte{55, 141, 2}
type Context struct {
b_Y_found bool
i_p2 int
i_p1 int
}
func r_prelude(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
// (, line 25
// unset Y_found, line 26
context.b_Y_found = false
// do, line 27
var v_1 = env.Cursor
lab0:
for {
// (, line 27
// [, line 27
env.Bra = env.Cursor
// literal, line 27
if !env.EqS("'") {
break lab0
}
// ], line 27
env.Ket = env.Cursor
// delete, line 27
if !env.SliceDel() {
return false
}
break lab0
}
env.Cursor = v_1
// do, line 28
var v_2 = env.Cursor
lab1:
for {
// (, line 28
// [, line 28
env.Bra = env.Cursor
// literal, line 28
if !env.EqS("y") {
break lab1
}
// ], line 28
env.Ket = env.Cursor
// <-, line 28
if !env.SliceFrom("Y") {
return false
}
// set Y_found, line 28
context.b_Y_found = true
break lab1
}
env.Cursor = v_2
// do, line 29
var v_3 = env.Cursor
lab2:
for {
// repeat, line 29
replab3:
for {
var v_4 = env.Cursor
lab4:
for range [2]struct{}{} {
// (, line 29
// goto, line 29
golab5:
for {
var v_5 = env.Cursor
lab6:
for {
// (, line 29
if !env.InGrouping(G_v, 97, 121) {
break lab6
}
// [, line 29
env.Bra = env.Cursor
// literal, line 29
if !env.EqS("y") {
break lab6
}
// ], line 29
env.Ket = env.Cursor
env.Cursor = v_5
break golab5
}
env.Cursor = v_5
if env.Cursor >= env.Limit {
break lab4
}
env.NextChar()
}
// <-, line 29
if !env.SliceFrom("Y") {
return false
}
// set Y_found, line 29
context.b_Y_found = true
continue replab3
}
env.Cursor = v_4
break replab3
}
break lab2
}
env.Cursor = v_3
return true
}
func r_mark_regions(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
// (, line 32
context.i_p1 = env.Limit
context.i_p2 = env.Limit
// do, line 35
var v_1 = env.Cursor
lab0:
for {
// (, line 35
// or, line 41
lab1:
for {
var v_2 = env.Cursor
lab2:
for {
// among, line 36
if env.FindAmong(A_0, context) == 0 {
break lab2
}
break lab1
}
env.Cursor = v_2
// (, line 41
// gopast, line 41
golab3:
for {
lab4:
for {
if !env.InGrouping(G_v, 97, 121) {
break lab4
}
break golab3
}
if env.Cursor >= env.Limit {
break lab0
}
env.NextChar()
}
// gopast, line 41
golab5:
for {
lab6:
for {
if !env.OutGrouping(G_v, 97, 121) {
break lab6
}
break golab5
}
if env.Cursor >= env.Limit {
break lab0
}
env.NextChar()
}
break lab1
}
// setmark p1, line 42
context.i_p1 = env.Cursor
// gopast, line 43
golab7:
for {
lab8:
for {
if !env.InGrouping(G_v, 97, 121) {
break lab8
}
break golab7
}
if env.Cursor >= env.Limit {
break lab0
}
env.NextChar()
}
// gopast, line 43
golab9:
for {
lab10:
for {
if !env.OutGrouping(G_v, 97, 121) {
break lab10
}
break golab9
}
if env.Cursor >= env.Limit {
break lab0
}
env.NextChar()
}
// setmark p2, line 43
context.i_p2 = env.Cursor
break lab0
}
env.Cursor = v_1
return true
}
func r_shortv(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
// (, line 49
// or, line 51
lab0:
for {
var v_1 = env.Limit - env.Cursor
lab1:
for {
// (, line 50
if !env.OutGroupingB(G_v_WXY, 89, 121) {
break lab1
}
if !env.InGroupingB(G_v, 97, 121) {
break lab1
}
if !env.OutGroupingB(G_v, 97, 121) {
break lab1
}
break lab0
}
env.Cursor = env.Limit - v_1
// (, line 52
if !env.OutGroupingB(G_v, 97, 121) {
return false
}
if !env.InGroupingB(G_v, 97, 121) {
return false
}
// atlimit, line 52
if env.Cursor > env.LimitBackward {
return false
}
break lab0
}
return true
}
func r_R1(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
if !(context.i_p1 <= env.Cursor) {
return false
}
return true
}
func r_R2(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
if !(context.i_p2 <= env.Cursor) {
return false
}
return true
}
func r_Step_1a(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
var among_var int32
// (, line 58
// try, line 59
var v_1 = env.Limit - env.Cursor
lab0:
for {
// (, line 59
// [, line 60
env.Ket = env.Cursor
// substring, line 60
among_var = env.FindAmongB(A_1, context)
if among_var == 0 {
env.Cursor = env.Limit - v_1
break lab0
}
// ], line 60
env.Bra = env.Cursor
if among_var == 0 {
env.Cursor = env.Limit - v_1
break lab0
} else if among_var == 1 {
// (, line 62
// delete, line 62
if !env.SliceDel() {
return false
}
}
break lab0
}
// [, line 65
env.Ket = env.Cursor
// substring, line 65
among_var = env.FindAmongB(A_2, context)
if among_var == 0 {
return false
}
// ], line 65
env.Bra = env.Cursor
if among_var == 0 {
return false
} else if among_var == 1 {
// (, line 66
// <-, line 66
if !env.SliceFrom("ss") {
return false
}
} else if among_var == 2 {
// (, line 68
// or, line 68
lab1:
for {
var v_2 = env.Limit - env.Cursor
lab2:
for {
// (, line 68
{
// hop, line 68
var c = env.ByteIndexForHop(-(2))
if int32(env.LimitBackward) > c || c > int32(env.Limit) {
break lab2
}
env.Cursor = int(c)
}
// <-, line 68
if !env.SliceFrom("i") {
return false
}
break lab1
}
env.Cursor = env.Limit - v_2
// <-, line 68
if !env.SliceFrom("ie") {
return false
}
break lab1
}
} else if among_var == 3 {
// (, line 69
// next, line 69
if env.Cursor <= env.LimitBackward {
return false
}
env.PrevChar()
// gopast, line 69
golab3:
for {
lab4:
for {
if !env.InGroupingB(G_v, 97, 121) {
break lab4
}
break golab3
}
if env.Cursor <= env.LimitBackward {
return false
}
env.PrevChar()
}
// delete, line 69
if !env.SliceDel() {
return false
}
}
return true
}
func r_Step_1b(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
var among_var int32
// (, line 74
// [, line 75
env.Ket = env.Cursor
// substring, line 75
among_var = env.FindAmongB(A_4, context)
if among_var == 0 {
return false
}
// ], line 75
env.Bra = env.Cursor
if among_var == 0 {
return false
} else if among_var == 1 {
// (, line 77
// call R1, line 77
if !r_R1(env, context) {
return false
}
// <-, line 77
if !env.SliceFrom("ee") {
return false
}
} else if among_var == 2 {
// (, line 79
// test, line 80
var v_1 = env.Limit - env.Cursor
// gopast, line 80
golab0:
for {
lab1:
for {
if !env.InGroupingB(G_v, 97, 121) {
break lab1
}
break golab0
}
if env.Cursor <= env.LimitBackward {
return false
}
env.PrevChar()
}
env.Cursor = env.Limit - v_1
// delete, line 80
if !env.SliceDel() {
return false
}
// test, line 81
var v_3 = env.Limit - env.Cursor
// substring, line 81
among_var = env.FindAmongB(A_3, context)
if among_var == 0 {
return false
}
env.Cursor = env.Limit - v_3
if among_var == 0 {
return false
} else if among_var == 1 {
// (, line 83
{
// <+, line 83
var c = env.Cursor
bra, ket := env.Cursor, env.Cursor
env.Insert(bra, ket, "e")
env.Cursor = c
}
} else if among_var == 2 {
// (, line 86
// [, line 86
env.Ket = env.Cursor
// next, line 86
if env.Cursor <= env.LimitBackward {
return false
}
env.PrevChar()
// ], line 86
env.Bra = env.Cursor
// delete, line 86
if !env.SliceDel() {
return false
}
} else if among_var == 3 {
// (, line 87
// atmark, line 87
if env.Cursor != context.i_p1 {
return false
}
// test, line 87
var v_4 = env.Limit - env.Cursor
// call shortv, line 87
if !r_shortv(env, context) {
return false
}
env.Cursor = env.Limit - v_4
{
// <+, line 87
var c = env.Cursor
bra, ket := env.Cursor, env.Cursor
env.Insert(bra, ket, "e")
env.Cursor = c
}
}
}
return true
}
func r_Step_1c(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
// (, line 93
// [, line 94
env.Ket = env.Cursor
// or, line 94
lab0:
for {
var v_1 = env.Limit - env.Cursor
lab1:
for {
// literal, line 94
if !env.EqSB("y") {
break lab1
}
break lab0
}
env.Cursor = env.Limit - v_1
// literal, line 94
if !env.EqSB("Y") {
return false
}
break lab0
}
// ], line 94
env.Bra = env.Cursor
if !env.OutGroupingB(G_v, 97, 121) {
return false
}
// not, line 95
var v_2 = env.Limit - env.Cursor
lab2:
for {
// atlimit, line 95
if env.Cursor > env.LimitBackward {
break lab2
}
return false
}
env.Cursor = env.Limit - v_2
// <-, line 96
if !env.SliceFrom("i") {
return false
}
return true
}
func r_Step_2(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
var among_var int32
// (, line 99
// [, line 100
env.Ket = env.Cursor
// substring, line 100
among_var = env.FindAmongB(A_5, context)
if among_var == 0 {
return false
}
// ], line 100
env.Bra = env.Cursor
// call R1, line 100
if !r_R1(env, context) {
return false
}
if among_var == 0 {
return false
} else if among_var == 1 {
// (, line 101
// <-, line 101
if !env.SliceFrom("tion") {
return false
}
} else if among_var == 2 {
// (, line 102
// <-, line 102
if !env.SliceFrom("ence") {
return false
}
} else if among_var == 3 {
// (, line 103
// <-, line 103
if !env.SliceFrom("ance") {
return false
}
} else if among_var == 4 {
// (, line 104
// <-, line 104
if !env.SliceFrom("able") {
return false
}
} else if among_var == 5 {
// (, line 105
// <-, line 105
if !env.SliceFrom("ent") {
return false
}
} else if among_var == 6 {
// (, line 107
// <-, line 107
if !env.SliceFrom("ize") {
return false
}
} else if among_var == 7 {
// (, line 109
// <-, line 109
if !env.SliceFrom("ate") {
return false
}
} else if among_var == 8 {
// (, line 111
// <-, line 111
if !env.SliceFrom("al") {
return false
}
} else if among_var == 9 {
// (, line 112
// <-, line 112
if !env.SliceFrom("ful") {
return false
}
} else if among_var == 10 {
// (, line 114
// <-, line 114
if !env.SliceFrom("ous") {
return false
}
} else if among_var == 11 {
// (, line 116
// <-, line 116
if !env.SliceFrom("ive") {
return false
}
} else if among_var == 12 {
// (, line 118
// <-, line 118
if !env.SliceFrom("ble") {
return false
}
} else if among_var == 13 {
// (, line 119
// literal, line 119
if !env.EqSB("l") {
return false
}
// <-, line 119
if !env.SliceFrom("og") {
return false
}
} else if among_var == 14 {
// (, line 120
// <-, line 120
if !env.SliceFrom("ful") {
return false
}
} else if among_var == 15 {
// (, line 121
// <-, line 121
if !env.SliceFrom("less") {
return false
}
} else if among_var == 16 {
// (, line 122
if !env.InGroupingB(G_valid_LI, 99, 116) {
return false
}
// delete, line 122
if !env.SliceDel() {
return false
}
}
return true
}
func r_Step_3(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
var among_var int32
// (, line 126
// [, line 127
env.Ket = env.Cursor
// substring, line 127
among_var = env.FindAmongB(A_6, context)
if among_var == 0 {
return false
}
// ], line 127
env.Bra = env.Cursor
// call R1, line 127
if !r_R1(env, context) {
return false
}
if among_var == 0 {
return false
} else if among_var == 1 {
// (, line 128
// <-, line 128
if !env.SliceFrom("tion") {
return false
}
} else if among_var == 2 {
// (, line 129
// <-, line 129
if !env.SliceFrom("ate") {
return false
}
} else if among_var == 3 {
// (, line 130
// <-, line 130
if !env.SliceFrom("al") {
return false
}
} else if among_var == 4 {
// (, line 132
// <-, line 132
if !env.SliceFrom("ic") {
return false
}
} else if among_var == 5 {
// (, line 134
// delete, line 134
if !env.SliceDel() {
return false
}
} else if among_var == 6 {
// (, line 136
// call R2, line 136
if !r_R2(env, context) {
return false
}
// delete, line 136
if !env.SliceDel() {
return false
}
}
return true
}
func r_Step_4(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
var among_var int32
// (, line 140
// [, line 141
env.Ket = env.Cursor
// substring, line 141
among_var = env.FindAmongB(A_7, context)
if among_var == 0 {
return false
}
// ], line 141
env.Bra = env.Cursor
// call R2, line 141
if !r_R2(env, context) {
return false
}
if among_var == 0 {
return false
} else if among_var == 1 {
// (, line 144
// delete, line 144
if !env.SliceDel() {
return false
}
} else if among_var == 2 {
// (, line 145
// or, line 145
lab0:
for {
var v_1 = env.Limit - env.Cursor
lab1:
for {
// literal, line 145
if !env.EqSB("s") {
break lab1
}
break lab0
}
env.Cursor = env.Limit - v_1
// literal, line 145
if !env.EqSB("t") {
return false
}
break lab0
}
// delete, line 145
if !env.SliceDel() {
return false
}
}
return true
}
func r_Step_5(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
var among_var int32
// (, line 149
// [, line 150
env.Ket = env.Cursor
// substring, line 150
among_var = env.FindAmongB(A_8, context)
if among_var == 0 {
return false
}
// ], line 150
env.Bra = env.Cursor
if among_var == 0 {
return false
} else if among_var == 1 {
// (, line 151
// or, line 151
lab0:
for {
var v_1 = env.Limit - env.Cursor
lab1:
for {
// call R2, line 151
if !r_R2(env, context) {
break lab1
}
break lab0
}
env.Cursor = env.Limit - v_1
// (, line 151
// call R1, line 151
if !r_R1(env, context) {
return false
}
// not, line 151
var v_2 = env.Limit - env.Cursor
lab2:
for {
// call shortv, line 151
if !r_shortv(env, context) {
break lab2
}
return false
}
env.Cursor = env.Limit - v_2
break lab0
}
// delete, line 151
if !env.SliceDel() {
return false
}
} else if among_var == 2 {
// (, line 152
// call R2, line 152
if !r_R2(env, context) {
return false
}
// literal, line 152
if !env.EqSB("l") {
return false
}
// delete, line 152
if !env.SliceDel() {
return false
}
}
return true
}
func r_exception2(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
// (, line 156
// [, line 158
env.Ket = env.Cursor
// substring, line 158
if env.FindAmongB(A_9, context) == 0 {
return false
}
// ], line 158
env.Bra = env.Cursor
// atlimit, line 158
if env.Cursor > env.LimitBackward {
return false
}
return true
}
func r_exception1(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
var among_var int32
// (, line 168
// [, line 170
env.Bra = env.Cursor
// substring, line 170
among_var = env.FindAmong(A_10, context)
if among_var == 0 {
return false
}
// ], line 170
env.Ket = env.Cursor
// atlimit, line 170
if env.Cursor < env.Limit {
return false
}
if among_var == 0 {
return false
} else if among_var == 1 {
// (, line 174
// <-, line 174
if !env.SliceFrom("ski") {
return false
}
} else if among_var == 2 {
// (, line 175
// <-, line 175
if !env.SliceFrom("sky") {
return false
}
} else if among_var == 3 {
// (, line 176
// <-, line 176
if !env.SliceFrom("die") {
return false
}
} else if among_var == 4 {
// (, line 177
// <-, line 177
if !env.SliceFrom("lie") {
return false
}
} else if among_var == 5 {
// (, line 178
// <-, line 178
if !env.SliceFrom("tie") {
return false
}
} else if among_var == 6 {
// (, line 182
// <-, line 182
if !env.SliceFrom("idl") {
return false
}
} else if among_var == 7 {
// (, line 183
// <-, line 183
if !env.SliceFrom("gentl") {
return false
}
} else if among_var == 8 {
// (, line 184
// <-, line 184
if !env.SliceFrom("ugli") {
return false
}
} else if among_var == 9 {
// (, line 185
// <-, line 185
if !env.SliceFrom("earli") {
return false
}
} else if among_var == 10 {
// (, line 186
// <-, line 186
if !env.SliceFrom("onli") {
return false
}
} else if among_var == 11 {
// (, line 187
// <-, line 187
if !env.SliceFrom("singl") {
return false
}
}
return true
}
func r_postlude(env *snowballRuntime.Env, ctx interface{}) bool {
context := ctx.(*Context)
_ = context
// (, line 203
// Boolean test Y_found, line 203
if !context.b_Y_found {
return false
}
// repeat, line 203
replab0:
for {
var v_1 = env.Cursor
lab1:
for range [2]struct{}{} {
// (, line 203
// goto, line 203
golab2:
for {
var v_2 = env.Cursor
lab3:
for {
// (, line 203
// [, line 203
env.Bra = env.Cursor
// literal, line 203
if !env.EqS("Y") {
break lab3
}
// ], line 203
env.Ket = env.Cursor
env.Cursor = v_2
break golab2
}
env.Cursor = v_2
if env.Cursor >= env.Limit {
break lab1
}
env.NextChar()
}
// <-, line 203
if !env.SliceFrom("y") {
return false
}
continue replab0
}
env.Cursor = v_1
break replab0
}
return true
}
func Stem(env *snowballRuntime.Env) bool {
var context = &Context{
b_Y_found: false,
i_p2: 0,
i_p1: 0,
}
_ = context
// (, line 205
// or, line 207
lab0:
for {
var v_1 = env.Cursor
lab1:
for {
// call exception1, line 207
if !r_exception1(env, context) {
break lab1
}
break lab0
}
env.Cursor = v_1
lab2:
for {
// not, line 208
var v_2 = env.Cursor
lab3:
for {
{
// hop, line 208
var c = env.ByteIndexForHop((3))
if int32(0) > c || c > int32(env.Limit) {
break lab3
}
env.Cursor = int(c)
}
break lab2
}
env.Cursor = v_2
break lab0
}
env.Cursor = v_1
// (, line 208
// do, line 209
var v_3 = env.Cursor
lab4:
for {
// call prelude, line 209
if !r_prelude(env, context) {
break lab4
}
break lab4
}
env.Cursor = v_3
// do, line 210
var v_4 = env.Cursor
lab5:
for {
// call mark_regions, line 210
if !r_mark_regions(env, context) {
break lab5
}
break lab5
}
env.Cursor = v_4
// backwards, line 211
env.LimitBackward = env.Cursor
env.Cursor = env.Limit
// (, line 211
// do, line 213
var v_5 = env.Limit - env.Cursor
lab6:
for {
// call Step_1a, line 213
if !r_Step_1a(env, context) {
break lab6
}
break lab6
}
env.Cursor = env.Limit - v_5
// or, line 215
lab7:
for {
var v_6 = env.Limit - env.Cursor
lab8:
for {
// call exception2, line 215
if !r_exception2(env, context) {
break lab8
}
break lab7
}
env.Cursor = env.Limit - v_6
// (, line 215
// do, line 217
var v_7 = env.Limit - env.Cursor
lab9:
for {
// call Step_1b, line 217
if !r_Step_1b(env, context) {
break lab9
}
break lab9
}
env.Cursor = env.Limit - v_7
// do, line 218
var v_8 = env.Limit - env.Cursor
lab10:
for {
// call Step_1c, line 218
if !r_Step_1c(env, context) {
break lab10
}
break lab10
}
env.Cursor = env.Limit - v_8
// do, line 220
var v_9 = env.Limit - env.Cursor
lab11:
for {
// call Step_2, line 220
if !r_Step_2(env, context) {
break lab11
}
break lab11
}
env.Cursor = env.Limit - v_9
// do, line 221
var v_10 = env.Limit - env.Cursor
lab12:
for {
// call Step_3, line 221
if !r_Step_3(env, context) {
break lab12
}
break lab12
}
env.Cursor = env.Limit - v_10
// do, line 222
var v_11 = env.Limit - env.Cursor
lab13:
for {
// call Step_4, line 222
if !r_Step_4(env, context) {
break lab13
}
break lab13
}
env.Cursor = env.Limit - v_11
// do, line 224
var v_12 = env.Limit - env.Cursor
lab14:
for {
// call Step_5, line 224
if !r_Step_5(env, context) {
break lab14
}
break lab14
}
env.Cursor = env.Limit - v_12
break lab7
}
env.Cursor = env.LimitBackward
// do, line 227
var v_13 = env.Cursor
lab15:
for {
// call postlude, line 227
if !r_postlude(env, context) {
break lab15
}
break lab15
}
env.Cursor = v_13
break lab0
}
return true
}