| //! This file was generated automatically by the Snowball to Rust compiler |
| //! http://snowballstem.org/ |
| |
| #![allow(non_upper_case_globals)] |
| #![allow(non_snake_case)] |
| #![allow(unused_variables)] |
| #![allow(unused_mut)] |
| use snowball::SnowballEnv; |
| use snowball::Among; |
| |
| static A_0: &'static [Among<Context>; 10] = &[ |
| Among("m", -1, -1, None), |
| Among("n", -1, -1, None), |
| Among("miz", -1, -1, None), |
| Among("niz", -1, -1, None), |
| Among("muz", -1, -1, None), |
| Among("nuz", -1, -1, None), |
| Among("m\u{0131}z", -1, -1, None), |
| Among("n\u{0131}z", -1, -1, None), |
| Among("m\u{00FC}z", -1, -1, None), |
| Among("n\u{00FC}z", -1, -1, None), |
| ]; |
| |
| static A_1: &'static [Among<Context>; 2] = &[ |
| Among("leri", -1, -1, None), |
| Among("lar\u{0131}", -1, -1, None), |
| ]; |
| |
| static A_2: &'static [Among<Context>; 4] = &[ |
| Among("ni", -1, -1, None), |
| Among("nu", -1, -1, None), |
| Among("n\u{0131}", -1, -1, None), |
| Among("n\u{00FC}", -1, -1, None), |
| ]; |
| |
| static A_3: &'static [Among<Context>; 4] = &[ |
| Among("in", -1, -1, None), |
| Among("un", -1, -1, None), |
| Among("\u{0131}n", -1, -1, None), |
| Among("\u{00FC}n", -1, -1, None), |
| ]; |
| |
| static A_4: &'static [Among<Context>; 2] = &[ |
| Among("a", -1, -1, None), |
| Among("e", -1, -1, None), |
| ]; |
| |
| static A_5: &'static [Among<Context>; 2] = &[ |
| Among("na", -1, -1, None), |
| Among("ne", -1, -1, None), |
| ]; |
| |
| static A_6: &'static [Among<Context>; 4] = &[ |
| Among("da", -1, -1, None), |
| Among("ta", -1, -1, None), |
| Among("de", -1, -1, None), |
| Among("te", -1, -1, None), |
| ]; |
| |
| static A_7: &'static [Among<Context>; 2] = &[ |
| Among("nda", -1, -1, None), |
| Among("nde", -1, -1, None), |
| ]; |
| |
| static A_8: &'static [Among<Context>; 4] = &[ |
| Among("dan", -1, -1, None), |
| Among("tan", -1, -1, None), |
| Among("den", -1, -1, None), |
| Among("ten", -1, -1, None), |
| ]; |
| |
| static A_9: &'static [Among<Context>; 2] = &[ |
| Among("ndan", -1, -1, None), |
| Among("nden", -1, -1, None), |
| ]; |
| |
| static A_10: &'static [Among<Context>; 2] = &[ |
| Among("la", -1, -1, None), |
| Among("le", -1, -1, None), |
| ]; |
| |
| static A_11: &'static [Among<Context>; 2] = &[ |
| Among("ca", -1, -1, None), |
| Among("ce", -1, -1, None), |
| ]; |
| |
| static A_12: &'static [Among<Context>; 4] = &[ |
| Among("im", -1, -1, None), |
| Among("um", -1, -1, None), |
| Among("\u{0131}m", -1, -1, None), |
| Among("\u{00FC}m", -1, -1, None), |
| ]; |
| |
| static A_13: &'static [Among<Context>; 4] = &[ |
| Among("sin", -1, -1, None), |
| Among("sun", -1, -1, None), |
| Among("s\u{0131}n", -1, -1, None), |
| Among("s\u{00FC}n", -1, -1, None), |
| ]; |
| |
| static A_14: &'static [Among<Context>; 4] = &[ |
| Among("iz", -1, -1, None), |
| Among("uz", -1, -1, None), |
| Among("\u{0131}z", -1, -1, None), |
| Among("\u{00FC}z", -1, -1, None), |
| ]; |
| |
| static A_15: &'static [Among<Context>; 4] = &[ |
| Among("siniz", -1, -1, None), |
| Among("sunuz", -1, -1, None), |
| Among("s\u{0131}n\u{0131}z", -1, -1, None), |
| Among("s\u{00FC}n\u{00FC}z", -1, -1, None), |
| ]; |
| |
| static A_16: &'static [Among<Context>; 2] = &[ |
| Among("lar", -1, -1, None), |
| Among("ler", -1, -1, None), |
| ]; |
| |
| static A_17: &'static [Among<Context>; 4] = &[ |
| Among("niz", -1, -1, None), |
| Among("nuz", -1, -1, None), |
| Among("n\u{0131}z", -1, -1, None), |
| Among("n\u{00FC}z", -1, -1, None), |
| ]; |
| |
| static A_18: &'static [Among<Context>; 8] = &[ |
| Among("dir", -1, -1, None), |
| Among("tir", -1, -1, None), |
| Among("dur", -1, -1, None), |
| Among("tur", -1, -1, None), |
| Among("d\u{0131}r", -1, -1, None), |
| Among("t\u{0131}r", -1, -1, None), |
| Among("d\u{00FC}r", -1, -1, None), |
| Among("t\u{00FC}r", -1, -1, None), |
| ]; |
| |
| static A_19: &'static [Among<Context>; 2] = &[ |
| Among("cas\u{0131}na", -1, -1, None), |
| Among("cesine", -1, -1, None), |
| ]; |
| |
| static A_20: &'static [Among<Context>; 32] = &[ |
| Among("di", -1, -1, None), |
| Among("ti", -1, -1, None), |
| Among("dik", -1, -1, None), |
| Among("tik", -1, -1, None), |
| Among("duk", -1, -1, None), |
| Among("tuk", -1, -1, None), |
| Among("d\u{0131}k", -1, -1, None), |
| Among("t\u{0131}k", -1, -1, None), |
| Among("d\u{00FC}k", -1, -1, None), |
| Among("t\u{00FC}k", -1, -1, None), |
| Among("dim", -1, -1, None), |
| Among("tim", -1, -1, None), |
| Among("dum", -1, -1, None), |
| Among("tum", -1, -1, None), |
| Among("d\u{0131}m", -1, -1, None), |
| Among("t\u{0131}m", -1, -1, None), |
| Among("d\u{00FC}m", -1, -1, None), |
| Among("t\u{00FC}m", -1, -1, None), |
| Among("din", -1, -1, None), |
| Among("tin", -1, -1, None), |
| Among("dun", -1, -1, None), |
| Among("tun", -1, -1, None), |
| Among("d\u{0131}n", -1, -1, None), |
| Among("t\u{0131}n", -1, -1, None), |
| Among("d\u{00FC}n", -1, -1, None), |
| Among("t\u{00FC}n", -1, -1, None), |
| Among("du", -1, -1, None), |
| Among("tu", -1, -1, None), |
| Among("d\u{0131}", -1, -1, None), |
| Among("t\u{0131}", -1, -1, None), |
| Among("d\u{00FC}", -1, -1, None), |
| Among("t\u{00FC}", -1, -1, None), |
| ]; |
| |
| static A_21: &'static [Among<Context>; 8] = &[ |
| Among("sa", -1, -1, None), |
| Among("se", -1, -1, None), |
| Among("sak", -1, -1, None), |
| Among("sek", -1, -1, None), |
| Among("sam", -1, -1, None), |
| Among("sem", -1, -1, None), |
| Among("san", -1, -1, None), |
| Among("sen", -1, -1, None), |
| ]; |
| |
| static A_22: &'static [Among<Context>; 4] = &[ |
| Among("mi\u{015F}", -1, -1, None), |
| Among("mu\u{015F}", -1, -1, None), |
| Among("m\u{0131}\u{015F}", -1, -1, None), |
| Among("m\u{00FC}\u{015F}", -1, -1, None), |
| ]; |
| |
| static A_23: &'static [Among<Context>; 4] = &[ |
| Among("b", -1, 1, None), |
| Among("c", -1, 2, None), |
| Among("d", -1, 3, None), |
| Among("\u{011F}", -1, 4, None), |
| ]; |
| |
| static G_vowel: &'static [u8; 27] = &[17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 8, 0, 0, 0, 0, 0, 0, 1]; |
| |
| static G_U: &'static [u8; 26] = &[1, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1]; |
| |
| static G_vowel1: &'static [u8; 27] = &[1, 64, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]; |
| |
| static G_vowel2: &'static [u8; 19] = &[17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130]; |
| |
| static G_vowel3: &'static [u8; 27] = &[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]; |
| |
| static G_vowel4: &'static [u8; 1] = &[17]; |
| |
| static G_vowel5: &'static [u8; 1] = &[65]; |
| |
| static G_vowel6: &'static [u8; 1] = &[65]; |
| |
| #[derive(Clone)] |
| struct Context { |
| b_continue_stemming_noun_suffixes: bool, |
| i_strlen: usize, |
| } |
| |
| fn r_check_vowel_harmony(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 111 |
| // test, line 112 |
| let v_1 = env.limit - env.cursor; |
| // (, line 113 |
| // (, line 114 |
| // goto, line 114 |
| 'golab0: loop { |
| let v_2 = env.limit - env.cursor; |
| 'lab1: loop { |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| break 'lab1; |
| } |
| env.cursor = env.limit - v_2; |
| break 'golab0; |
| } |
| env.cursor = env.limit - v_2; |
| if env.cursor <= env.limit_backward { |
| return false; |
| } |
| env.previous_char(); |
| } |
| // (, line 115 |
| // or, line 116 |
| 'lab2: loop { |
| let v_3 = env.limit - env.cursor; |
| 'lab3: loop { |
| // (, line 116 |
| // literal, line 116 |
| if !env.eq_s_b(&"a") { |
| break 'lab3; |
| } |
| // goto, line 116 |
| 'golab4: loop { |
| let v_4 = env.limit - env.cursor; |
| 'lab5: loop { |
| if !env.in_grouping_b(G_vowel1, 97, 305) { |
| break 'lab5; |
| } |
| env.cursor = env.limit - v_4; |
| break 'golab4; |
| } |
| env.cursor = env.limit - v_4; |
| if env.cursor <= env.limit_backward { |
| break 'lab3; |
| } |
| env.previous_char(); |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab6: loop { |
| // (, line 117 |
| // literal, line 117 |
| if !env.eq_s_b(&"e") { |
| break 'lab6; |
| } |
| // goto, line 117 |
| 'golab7: loop { |
| let v_5 = env.limit - env.cursor; |
| 'lab8: loop { |
| if !env.in_grouping_b(G_vowel2, 101, 252) { |
| break 'lab8; |
| } |
| env.cursor = env.limit - v_5; |
| break 'golab7; |
| } |
| env.cursor = env.limit - v_5; |
| if env.cursor <= env.limit_backward { |
| break 'lab6; |
| } |
| env.previous_char(); |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab9: loop { |
| // (, line 118 |
| // literal, line 118 |
| if !env.eq_s_b(&"\u{0131}") { |
| break 'lab9; |
| } |
| // goto, line 118 |
| 'golab10: loop { |
| let v_6 = env.limit - env.cursor; |
| 'lab11: loop { |
| if !env.in_grouping_b(G_vowel3, 97, 305) { |
| break 'lab11; |
| } |
| env.cursor = env.limit - v_6; |
| break 'golab10; |
| } |
| env.cursor = env.limit - v_6; |
| if env.cursor <= env.limit_backward { |
| break 'lab9; |
| } |
| env.previous_char(); |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab12: loop { |
| // (, line 119 |
| // literal, line 119 |
| if !env.eq_s_b(&"i") { |
| break 'lab12; |
| } |
| // goto, line 119 |
| 'golab13: loop { |
| let v_7 = env.limit - env.cursor; |
| 'lab14: loop { |
| if !env.in_grouping_b(G_vowel4, 101, 105) { |
| break 'lab14; |
| } |
| env.cursor = env.limit - v_7; |
| break 'golab13; |
| } |
| env.cursor = env.limit - v_7; |
| if env.cursor <= env.limit_backward { |
| break 'lab12; |
| } |
| env.previous_char(); |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab15: loop { |
| // (, line 120 |
| // literal, line 120 |
| if !env.eq_s_b(&"o") { |
| break 'lab15; |
| } |
| // goto, line 120 |
| 'golab16: loop { |
| let v_8 = env.limit - env.cursor; |
| 'lab17: loop { |
| if !env.in_grouping_b(G_vowel5, 111, 117) { |
| break 'lab17; |
| } |
| env.cursor = env.limit - v_8; |
| break 'golab16; |
| } |
| env.cursor = env.limit - v_8; |
| if env.cursor <= env.limit_backward { |
| break 'lab15; |
| } |
| env.previous_char(); |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab18: loop { |
| // (, line 121 |
| // literal, line 121 |
| if !env.eq_s_b(&"\u{00F6}") { |
| break 'lab18; |
| } |
| // goto, line 121 |
| 'golab19: loop { |
| let v_9 = env.limit - env.cursor; |
| 'lab20: loop { |
| if !env.in_grouping_b(G_vowel6, 246, 252) { |
| break 'lab20; |
| } |
| env.cursor = env.limit - v_9; |
| break 'golab19; |
| } |
| env.cursor = env.limit - v_9; |
| if env.cursor <= env.limit_backward { |
| break 'lab18; |
| } |
| env.previous_char(); |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab21: loop { |
| // (, line 122 |
| // literal, line 122 |
| if !env.eq_s_b(&"u") { |
| break 'lab21; |
| } |
| // goto, line 122 |
| 'golab22: loop { |
| let v_10 = env.limit - env.cursor; |
| 'lab23: loop { |
| if !env.in_grouping_b(G_vowel5, 111, 117) { |
| break 'lab23; |
| } |
| env.cursor = env.limit - v_10; |
| break 'golab22; |
| } |
| env.cursor = env.limit - v_10; |
| if env.cursor <= env.limit_backward { |
| break 'lab21; |
| } |
| env.previous_char(); |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| // (, line 123 |
| // literal, line 123 |
| if !env.eq_s_b(&"\u{00FC}") { |
| return false; |
| } |
| // goto, line 123 |
| 'golab24: loop { |
| let v_11 = env.limit - env.cursor; |
| 'lab25: loop { |
| if !env.in_grouping_b(G_vowel6, 246, 252) { |
| break 'lab25; |
| } |
| env.cursor = env.limit - v_11; |
| break 'golab24; |
| } |
| env.cursor = env.limit - v_11; |
| if env.cursor <= env.limit_backward { |
| return false; |
| } |
| env.previous_char(); |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_1; |
| return true; |
| } |
| |
| fn r_mark_suffix_with_optional_n_consonant(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 132 |
| // or, line 134 |
| 'lab0: loop { |
| let v_1 = env.limit - env.cursor; |
| 'lab1: loop { |
| // (, line 133 |
| // literal, line 133 |
| if !env.eq_s_b(&"n") { |
| break 'lab1; |
| } |
| // (, line 133 |
| // test, line 133 |
| let v_2 = env.limit - env.cursor; |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| break 'lab1; |
| } |
| env.cursor = env.limit - v_2; |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| // (, line 135 |
| // (, line 135 |
| // not, line 135 |
| let v_3 = env.limit - env.cursor; |
| 'lab2: loop { |
| // (, line 135 |
| // test, line 135 |
| let v_4 = env.limit - env.cursor; |
| // literal, line 135 |
| if !env.eq_s_b(&"n") { |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_4; |
| return false; |
| } |
| env.cursor = env.limit - v_3; |
| // test, line 135 |
| let v_5 = env.limit - env.cursor; |
| // (, line 135 |
| // next, line 135 |
| if env.cursor <= env.limit_backward { |
| return false; |
| } |
| env.previous_char(); |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| return false; |
| } |
| env.cursor = env.limit - v_5; |
| break 'lab0; |
| } |
| return true; |
| } |
| |
| fn r_mark_suffix_with_optional_s_consonant(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 143 |
| // or, line 145 |
| 'lab0: loop { |
| let v_1 = env.limit - env.cursor; |
| 'lab1: loop { |
| // (, line 144 |
| // literal, line 144 |
| if !env.eq_s_b(&"s") { |
| break 'lab1; |
| } |
| // (, line 144 |
| // test, line 144 |
| let v_2 = env.limit - env.cursor; |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| break 'lab1; |
| } |
| env.cursor = env.limit - v_2; |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| // (, line 146 |
| // (, line 146 |
| // not, line 146 |
| let v_3 = env.limit - env.cursor; |
| 'lab2: loop { |
| // (, line 146 |
| // test, line 146 |
| let v_4 = env.limit - env.cursor; |
| // literal, line 146 |
| if !env.eq_s_b(&"s") { |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_4; |
| return false; |
| } |
| env.cursor = env.limit - v_3; |
| // test, line 146 |
| let v_5 = env.limit - env.cursor; |
| // (, line 146 |
| // next, line 146 |
| if env.cursor <= env.limit_backward { |
| return false; |
| } |
| env.previous_char(); |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| return false; |
| } |
| env.cursor = env.limit - v_5; |
| break 'lab0; |
| } |
| return true; |
| } |
| |
| fn r_mark_suffix_with_optional_y_consonant(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 153 |
| // or, line 155 |
| 'lab0: loop { |
| let v_1 = env.limit - env.cursor; |
| 'lab1: loop { |
| // (, line 154 |
| // literal, line 154 |
| if !env.eq_s_b(&"y") { |
| break 'lab1; |
| } |
| // (, line 154 |
| // test, line 154 |
| let v_2 = env.limit - env.cursor; |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| break 'lab1; |
| } |
| env.cursor = env.limit - v_2; |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| // (, line 156 |
| // (, line 156 |
| // not, line 156 |
| let v_3 = env.limit - env.cursor; |
| 'lab2: loop { |
| // (, line 156 |
| // test, line 156 |
| let v_4 = env.limit - env.cursor; |
| // literal, line 156 |
| if !env.eq_s_b(&"y") { |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_4; |
| return false; |
| } |
| env.cursor = env.limit - v_3; |
| // test, line 156 |
| let v_5 = env.limit - env.cursor; |
| // (, line 156 |
| // next, line 156 |
| if env.cursor <= env.limit_backward { |
| return false; |
| } |
| env.previous_char(); |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| return false; |
| } |
| env.cursor = env.limit - v_5; |
| break 'lab0; |
| } |
| return true; |
| } |
| |
| fn r_mark_suffix_with_optional_U_vowel(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 159 |
| // or, line 161 |
| 'lab0: loop { |
| let v_1 = env.limit - env.cursor; |
| 'lab1: loop { |
| // (, line 160 |
| if !env.in_grouping_b(G_U, 105, 305) { |
| break 'lab1; |
| } |
| // (, line 160 |
| // test, line 160 |
| let v_2 = env.limit - env.cursor; |
| if !env.out_grouping_b(G_vowel, 97, 305) { |
| break 'lab1; |
| } |
| env.cursor = env.limit - v_2; |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| // (, line 162 |
| // (, line 162 |
| // not, line 162 |
| let v_3 = env.limit - env.cursor; |
| 'lab2: loop { |
| // (, line 162 |
| // test, line 162 |
| let v_4 = env.limit - env.cursor; |
| if !env.in_grouping_b(G_U, 105, 305) { |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_4; |
| return false; |
| } |
| env.cursor = env.limit - v_3; |
| // test, line 162 |
| let v_5 = env.limit - env.cursor; |
| // (, line 162 |
| // next, line 162 |
| if env.cursor <= env.limit_backward { |
| return false; |
| } |
| env.previous_char(); |
| if !env.out_grouping_b(G_vowel, 97, 305) { |
| return false; |
| } |
| env.cursor = env.limit - v_5; |
| break 'lab0; |
| } |
| return true; |
| } |
| |
| fn r_mark_possessives(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 166 |
| // among, line 167 |
| if env.find_among_b(A_0, context) == 0 { |
| return false; |
| } |
| // (, line 169 |
| // call mark_suffix_with_optional_U_vowel, line 169 |
| if !r_mark_suffix_with_optional_U_vowel(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_sU(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 172 |
| // call check_vowel_harmony, line 173 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| if !env.in_grouping_b(G_U, 105, 305) { |
| return false; |
| } |
| // (, line 175 |
| // call mark_suffix_with_optional_s_consonant, line 175 |
| if !r_mark_suffix_with_optional_s_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_lArI(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 178 |
| // among, line 179 |
| if env.find_among_b(A_1, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_yU(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 182 |
| // call check_vowel_harmony, line 183 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| if !env.in_grouping_b(G_U, 105, 305) { |
| return false; |
| } |
| // (, line 185 |
| // call mark_suffix_with_optional_y_consonant, line 185 |
| if !r_mark_suffix_with_optional_y_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_nU(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 188 |
| // call check_vowel_harmony, line 189 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 190 |
| if env.find_among_b(A_2, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_nUn(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 193 |
| // call check_vowel_harmony, line 194 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 195 |
| if env.find_among_b(A_3, context) == 0 { |
| return false; |
| } |
| // (, line 196 |
| // call mark_suffix_with_optional_n_consonant, line 196 |
| if !r_mark_suffix_with_optional_n_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_yA(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 199 |
| // call check_vowel_harmony, line 200 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 201 |
| if env.find_among_b(A_4, context) == 0 { |
| return false; |
| } |
| // (, line 202 |
| // call mark_suffix_with_optional_y_consonant, line 202 |
| if !r_mark_suffix_with_optional_y_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_nA(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 205 |
| // call check_vowel_harmony, line 206 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 207 |
| if env.find_among_b(A_5, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_DA(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 210 |
| // call check_vowel_harmony, line 211 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 212 |
| if env.find_among_b(A_6, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_ndA(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 215 |
| // call check_vowel_harmony, line 216 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 217 |
| if env.find_among_b(A_7, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_DAn(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 220 |
| // call check_vowel_harmony, line 221 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 222 |
| if env.find_among_b(A_8, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_ndAn(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 225 |
| // call check_vowel_harmony, line 226 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 227 |
| if env.find_among_b(A_9, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_ylA(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 230 |
| // call check_vowel_harmony, line 231 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 232 |
| if env.find_among_b(A_10, context) == 0 { |
| return false; |
| } |
| // (, line 233 |
| // call mark_suffix_with_optional_y_consonant, line 233 |
| if !r_mark_suffix_with_optional_y_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_ki(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 236 |
| // literal, line 237 |
| if !env.eq_s_b(&"ki") { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_ncA(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 240 |
| // call check_vowel_harmony, line 241 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 242 |
| if env.find_among_b(A_11, context) == 0 { |
| return false; |
| } |
| // (, line 243 |
| // call mark_suffix_with_optional_n_consonant, line 243 |
| if !r_mark_suffix_with_optional_n_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_yUm(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 246 |
| // call check_vowel_harmony, line 247 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 248 |
| if env.find_among_b(A_12, context) == 0 { |
| return false; |
| } |
| // (, line 249 |
| // call mark_suffix_with_optional_y_consonant, line 249 |
| if !r_mark_suffix_with_optional_y_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_sUn(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 252 |
| // call check_vowel_harmony, line 253 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 254 |
| if env.find_among_b(A_13, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_yUz(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 257 |
| // call check_vowel_harmony, line 258 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 259 |
| if env.find_among_b(A_14, context) == 0 { |
| return false; |
| } |
| // (, line 260 |
| // call mark_suffix_with_optional_y_consonant, line 260 |
| if !r_mark_suffix_with_optional_y_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_sUnUz(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 263 |
| // among, line 264 |
| if env.find_among_b(A_15, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_lAr(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 267 |
| // call check_vowel_harmony, line 268 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 269 |
| if env.find_among_b(A_16, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_nUz(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 272 |
| // call check_vowel_harmony, line 273 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 274 |
| if env.find_among_b(A_17, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_DUr(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 277 |
| // call check_vowel_harmony, line 278 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 279 |
| if env.find_among_b(A_18, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_cAsInA(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 282 |
| // among, line 283 |
| if env.find_among_b(A_19, context) == 0 { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_yDU(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 286 |
| // call check_vowel_harmony, line 287 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 288 |
| if env.find_among_b(A_20, context) == 0 { |
| return false; |
| } |
| // (, line 292 |
| // call mark_suffix_with_optional_y_consonant, line 292 |
| if !r_mark_suffix_with_optional_y_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_ysA(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 296 |
| // among, line 297 |
| if env.find_among_b(A_21, context) == 0 { |
| return false; |
| } |
| // (, line 298 |
| // call mark_suffix_with_optional_y_consonant, line 298 |
| if !r_mark_suffix_with_optional_y_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_ymUs_(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 301 |
| // call check_vowel_harmony, line 302 |
| if !r_check_vowel_harmony(env, context) { |
| return false; |
| } |
| // among, line 303 |
| if env.find_among_b(A_22, context) == 0 { |
| return false; |
| } |
| // (, line 304 |
| // call mark_suffix_with_optional_y_consonant, line 304 |
| if !r_mark_suffix_with_optional_y_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_mark_yken(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 307 |
| // literal, line 308 |
| if !env.eq_s_b(&"ken") { |
| return false; |
| } |
| // (, line 308 |
| // call mark_suffix_with_optional_y_consonant, line 308 |
| if !r_mark_suffix_with_optional_y_consonant(env, context) { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_stem_nominal_verb_suffixes(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 311 |
| // [, line 312 |
| env.ket = env.cursor; |
| // set continue_stemming_noun_suffixes, line 313 |
| context.b_continue_stemming_noun_suffixes = true; |
| // or, line 315 |
| 'lab0: loop { |
| let v_1 = env.limit - env.cursor; |
| 'lab1: loop { |
| // (, line 314 |
| // or, line 314 |
| 'lab2: loop { |
| let v_2 = env.limit - env.cursor; |
| 'lab3: loop { |
| // call mark_ymUs_, line 314 |
| if !r_mark_ymUs_(env, context) { |
| break 'lab3; |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_2; |
| 'lab4: loop { |
| // call mark_yDU, line 314 |
| if !r_mark_yDU(env, context) { |
| break 'lab4; |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_2; |
| 'lab5: loop { |
| // call mark_ysA, line 314 |
| if !r_mark_ysA(env, context) { |
| break 'lab5; |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_2; |
| // call mark_yken, line 314 |
| if !r_mark_yken(env, context) { |
| break 'lab1; |
| } |
| break 'lab2; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab6: loop { |
| // (, line 316 |
| // call mark_cAsInA, line 316 |
| if !r_mark_cAsInA(env, context) { |
| break 'lab6; |
| } |
| // (, line 316 |
| // or, line 316 |
| 'lab7: loop { |
| let v_3 = env.limit - env.cursor; |
| 'lab8: loop { |
| // call mark_sUnUz, line 316 |
| if !r_mark_sUnUz(env, context) { |
| break 'lab8; |
| } |
| break 'lab7; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab9: loop { |
| // call mark_lAr, line 316 |
| if !r_mark_lAr(env, context) { |
| break 'lab9; |
| } |
| break 'lab7; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab10: loop { |
| // call mark_yUm, line 316 |
| if !r_mark_yUm(env, context) { |
| break 'lab10; |
| } |
| break 'lab7; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab11: loop { |
| // call mark_sUn, line 316 |
| if !r_mark_sUn(env, context) { |
| break 'lab11; |
| } |
| break 'lab7; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab12: loop { |
| // call mark_yUz, line 316 |
| if !r_mark_yUz(env, context) { |
| break 'lab12; |
| } |
| break 'lab7; |
| } |
| env.cursor = env.limit - v_3; |
| break 'lab7; |
| } |
| // call mark_ymUs_, line 316 |
| if !r_mark_ymUs_(env, context) { |
| break 'lab6; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab13: loop { |
| // (, line 318 |
| // call mark_lAr, line 319 |
| if !r_mark_lAr(env, context) { |
| break 'lab13; |
| } |
| // ], line 319 |
| env.bra = env.cursor; |
| // delete, line 319 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 319 |
| let v_4 = env.limit - env.cursor; |
| 'lab14: loop { |
| // (, line 319 |
| // [, line 319 |
| env.ket = env.cursor; |
| // (, line 319 |
| // or, line 319 |
| 'lab15: loop { |
| let v_5 = env.limit - env.cursor; |
| 'lab16: loop { |
| // call mark_DUr, line 319 |
| if !r_mark_DUr(env, context) { |
| break 'lab16; |
| } |
| break 'lab15; |
| } |
| env.cursor = env.limit - v_5; |
| 'lab17: loop { |
| // call mark_yDU, line 319 |
| if !r_mark_yDU(env, context) { |
| break 'lab17; |
| } |
| break 'lab15; |
| } |
| env.cursor = env.limit - v_5; |
| 'lab18: loop { |
| // call mark_ysA, line 319 |
| if !r_mark_ysA(env, context) { |
| break 'lab18; |
| } |
| break 'lab15; |
| } |
| env.cursor = env.limit - v_5; |
| // call mark_ymUs_, line 319 |
| if !r_mark_ymUs_(env, context) { |
| env.cursor = env.limit - v_4; |
| break 'lab14; |
| } |
| break 'lab15; |
| } |
| break 'lab14; |
| } |
| // unset continue_stemming_noun_suffixes, line 320 |
| context.b_continue_stemming_noun_suffixes = false; |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab19: loop { |
| // (, line 323 |
| // call mark_nUz, line 323 |
| if !r_mark_nUz(env, context) { |
| break 'lab19; |
| } |
| // (, line 323 |
| // or, line 323 |
| 'lab20: loop { |
| let v_6 = env.limit - env.cursor; |
| 'lab21: loop { |
| // call mark_yDU, line 323 |
| if !r_mark_yDU(env, context) { |
| break 'lab21; |
| } |
| break 'lab20; |
| } |
| env.cursor = env.limit - v_6; |
| // call mark_ysA, line 323 |
| if !r_mark_ysA(env, context) { |
| break 'lab19; |
| } |
| break 'lab20; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab22: loop { |
| // (, line 325 |
| // (, line 325 |
| // or, line 325 |
| 'lab23: loop { |
| let v_7 = env.limit - env.cursor; |
| 'lab24: loop { |
| // call mark_sUnUz, line 325 |
| if !r_mark_sUnUz(env, context) { |
| break 'lab24; |
| } |
| break 'lab23; |
| } |
| env.cursor = env.limit - v_7; |
| 'lab25: loop { |
| // call mark_yUz, line 325 |
| if !r_mark_yUz(env, context) { |
| break 'lab25; |
| } |
| break 'lab23; |
| } |
| env.cursor = env.limit - v_7; |
| 'lab26: loop { |
| // call mark_sUn, line 325 |
| if !r_mark_sUn(env, context) { |
| break 'lab26; |
| } |
| break 'lab23; |
| } |
| env.cursor = env.limit - v_7; |
| // call mark_yUm, line 325 |
| if !r_mark_yUm(env, context) { |
| break 'lab22; |
| } |
| break 'lab23; |
| } |
| // ], line 325 |
| env.bra = env.cursor; |
| // delete, line 325 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 325 |
| let v_8 = env.limit - env.cursor; |
| 'lab27: loop { |
| // (, line 325 |
| // [, line 325 |
| env.ket = env.cursor; |
| // call mark_ymUs_, line 325 |
| if !r_mark_ymUs_(env, context) { |
| env.cursor = env.limit - v_8; |
| break 'lab27; |
| } |
| break 'lab27; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| // (, line 327 |
| // call mark_DUr, line 327 |
| if !r_mark_DUr(env, context) { |
| return false; |
| } |
| // ], line 327 |
| env.bra = env.cursor; |
| // delete, line 327 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 327 |
| let v_9 = env.limit - env.cursor; |
| 'lab28: loop { |
| // (, line 327 |
| // [, line 327 |
| env.ket = env.cursor; |
| // (, line 327 |
| // or, line 327 |
| 'lab29: loop { |
| let v_10 = env.limit - env.cursor; |
| 'lab30: loop { |
| // call mark_sUnUz, line 327 |
| if !r_mark_sUnUz(env, context) { |
| break 'lab30; |
| } |
| break 'lab29; |
| } |
| env.cursor = env.limit - v_10; |
| 'lab31: loop { |
| // call mark_lAr, line 327 |
| if !r_mark_lAr(env, context) { |
| break 'lab31; |
| } |
| break 'lab29; |
| } |
| env.cursor = env.limit - v_10; |
| 'lab32: loop { |
| // call mark_yUm, line 327 |
| if !r_mark_yUm(env, context) { |
| break 'lab32; |
| } |
| break 'lab29; |
| } |
| env.cursor = env.limit - v_10; |
| 'lab33: loop { |
| // call mark_sUn, line 327 |
| if !r_mark_sUn(env, context) { |
| break 'lab33; |
| } |
| break 'lab29; |
| } |
| env.cursor = env.limit - v_10; |
| 'lab34: loop { |
| // call mark_yUz, line 327 |
| if !r_mark_yUz(env, context) { |
| break 'lab34; |
| } |
| break 'lab29; |
| } |
| env.cursor = env.limit - v_10; |
| break 'lab29; |
| } |
| // call mark_ymUs_, line 327 |
| if !r_mark_ymUs_(env, context) { |
| env.cursor = env.limit - v_9; |
| break 'lab28; |
| } |
| break 'lab28; |
| } |
| break 'lab0; |
| } |
| // ], line 328 |
| env.bra = env.cursor; |
| // delete, line 328 |
| if !env.slice_del() { |
| return false; |
| } |
| return true; |
| } |
| |
| fn r_stem_suffix_chain_before_ki(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 332 |
| // [, line 333 |
| env.ket = env.cursor; |
| // call mark_ki, line 334 |
| if !r_mark_ki(env, context) { |
| return false; |
| } |
| // (, line 335 |
| // or, line 342 |
| 'lab0: loop { |
| let v_1 = env.limit - env.cursor; |
| 'lab1: loop { |
| // (, line 336 |
| // call mark_DA, line 336 |
| if !r_mark_DA(env, context) { |
| break 'lab1; |
| } |
| // ], line 336 |
| env.bra = env.cursor; |
| // delete, line 336 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 336 |
| let v_2 = env.limit - env.cursor; |
| 'lab2: loop { |
| // (, line 336 |
| // [, line 336 |
| env.ket = env.cursor; |
| // or, line 338 |
| 'lab3: loop { |
| let v_3 = env.limit - env.cursor; |
| 'lab4: loop { |
| // (, line 337 |
| // call mark_lAr, line 337 |
| if !r_mark_lAr(env, context) { |
| break 'lab4; |
| } |
| // ], line 337 |
| env.bra = env.cursor; |
| // delete, line 337 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 337 |
| let v_4 = env.limit - env.cursor; |
| 'lab5: loop { |
| // (, line 337 |
| // call stem_suffix_chain_before_ki, line 337 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_4; |
| break 'lab5; |
| } |
| break 'lab5; |
| } |
| break 'lab3; |
| } |
| env.cursor = env.limit - v_3; |
| // (, line 339 |
| // call mark_possessives, line 339 |
| if !r_mark_possessives(env, context) { |
| env.cursor = env.limit - v_2; |
| break 'lab2; |
| } |
| // ], line 339 |
| env.bra = env.cursor; |
| // delete, line 339 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 339 |
| let v_5 = env.limit - env.cursor; |
| 'lab6: loop { |
| // (, line 339 |
| // [, line 339 |
| env.ket = env.cursor; |
| // call mark_lAr, line 339 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_5; |
| break 'lab6; |
| } |
| // ], line 339 |
| env.bra = env.cursor; |
| // delete, line 339 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 339 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_5; |
| break 'lab6; |
| } |
| break 'lab6; |
| } |
| break 'lab3; |
| } |
| break 'lab2; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab7: loop { |
| // (, line 343 |
| // call mark_nUn, line 343 |
| if !r_mark_nUn(env, context) { |
| break 'lab7; |
| } |
| // ], line 343 |
| env.bra = env.cursor; |
| // delete, line 343 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 343 |
| let v_6 = env.limit - env.cursor; |
| 'lab8: loop { |
| // (, line 343 |
| // [, line 343 |
| env.ket = env.cursor; |
| // or, line 345 |
| 'lab9: loop { |
| let v_7 = env.limit - env.cursor; |
| 'lab10: loop { |
| // (, line 344 |
| // call mark_lArI, line 344 |
| if !r_mark_lArI(env, context) { |
| break 'lab10; |
| } |
| // ], line 344 |
| env.bra = env.cursor; |
| // delete, line 344 |
| if !env.slice_del() { |
| return false; |
| } |
| break 'lab9; |
| } |
| env.cursor = env.limit - v_7; |
| 'lab11: loop { |
| // (, line 346 |
| // [, line 346 |
| env.ket = env.cursor; |
| // or, line 346 |
| 'lab12: loop { |
| let v_8 = env.limit - env.cursor; |
| 'lab13: loop { |
| // call mark_possessives, line 346 |
| if !r_mark_possessives(env, context) { |
| break 'lab13; |
| } |
| break 'lab12; |
| } |
| env.cursor = env.limit - v_8; |
| // call mark_sU, line 346 |
| if !r_mark_sU(env, context) { |
| break 'lab11; |
| } |
| break 'lab12; |
| } |
| // ], line 346 |
| env.bra = env.cursor; |
| // delete, line 346 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 346 |
| let v_9 = env.limit - env.cursor; |
| 'lab14: loop { |
| // (, line 346 |
| // [, line 346 |
| env.ket = env.cursor; |
| // call mark_lAr, line 346 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_9; |
| break 'lab14; |
| } |
| // ], line 346 |
| env.bra = env.cursor; |
| // delete, line 346 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 346 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_9; |
| break 'lab14; |
| } |
| break 'lab14; |
| } |
| break 'lab9; |
| } |
| env.cursor = env.limit - v_7; |
| // (, line 348 |
| // call stem_suffix_chain_before_ki, line 348 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_6; |
| break 'lab8; |
| } |
| break 'lab9; |
| } |
| break 'lab8; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| // (, line 351 |
| // call mark_ndA, line 351 |
| if !r_mark_ndA(env, context) { |
| return false; |
| } |
| // (, line 351 |
| // or, line 353 |
| 'lab15: loop { |
| let v_10 = env.limit - env.cursor; |
| 'lab16: loop { |
| // (, line 352 |
| // call mark_lArI, line 352 |
| if !r_mark_lArI(env, context) { |
| break 'lab16; |
| } |
| // ], line 352 |
| env.bra = env.cursor; |
| // delete, line 352 |
| if !env.slice_del() { |
| return false; |
| } |
| break 'lab15; |
| } |
| env.cursor = env.limit - v_10; |
| 'lab17: loop { |
| // (, line 354 |
| // (, line 354 |
| // call mark_sU, line 354 |
| if !r_mark_sU(env, context) { |
| break 'lab17; |
| } |
| // ], line 354 |
| env.bra = env.cursor; |
| // delete, line 354 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 354 |
| let v_11 = env.limit - env.cursor; |
| 'lab18: loop { |
| // (, line 354 |
| // [, line 354 |
| env.ket = env.cursor; |
| // call mark_lAr, line 354 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_11; |
| break 'lab18; |
| } |
| // ], line 354 |
| env.bra = env.cursor; |
| // delete, line 354 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 354 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_11; |
| break 'lab18; |
| } |
| break 'lab18; |
| } |
| break 'lab15; |
| } |
| env.cursor = env.limit - v_10; |
| // (, line 356 |
| // call stem_suffix_chain_before_ki, line 356 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| return false; |
| } |
| break 'lab15; |
| } |
| break 'lab0; |
| } |
| return true; |
| } |
| |
| fn r_stem_noun_suffixes(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 361 |
| // or, line 363 |
| 'lab0: loop { |
| let v_1 = env.limit - env.cursor; |
| 'lab1: loop { |
| // (, line 362 |
| // [, line 362 |
| env.ket = env.cursor; |
| // call mark_lAr, line 362 |
| if !r_mark_lAr(env, context) { |
| break 'lab1; |
| } |
| // ], line 362 |
| env.bra = env.cursor; |
| // delete, line 362 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 362 |
| let v_2 = env.limit - env.cursor; |
| 'lab2: loop { |
| // (, line 362 |
| // call stem_suffix_chain_before_ki, line 362 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_2; |
| break 'lab2; |
| } |
| break 'lab2; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab3: loop { |
| // (, line 364 |
| // [, line 364 |
| env.ket = env.cursor; |
| // call mark_ncA, line 364 |
| if !r_mark_ncA(env, context) { |
| break 'lab3; |
| } |
| // ], line 364 |
| env.bra = env.cursor; |
| // delete, line 364 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 365 |
| let v_3 = env.limit - env.cursor; |
| 'lab4: loop { |
| // (, line 365 |
| // or, line 367 |
| 'lab5: loop { |
| let v_4 = env.limit - env.cursor; |
| 'lab6: loop { |
| // (, line 366 |
| // [, line 366 |
| env.ket = env.cursor; |
| // call mark_lArI, line 366 |
| if !r_mark_lArI(env, context) { |
| break 'lab6; |
| } |
| // ], line 366 |
| env.bra = env.cursor; |
| // delete, line 366 |
| if !env.slice_del() { |
| return false; |
| } |
| break 'lab5; |
| } |
| env.cursor = env.limit - v_4; |
| 'lab7: loop { |
| // (, line 368 |
| // [, line 368 |
| env.ket = env.cursor; |
| // or, line 368 |
| 'lab8: loop { |
| let v_5 = env.limit - env.cursor; |
| 'lab9: loop { |
| // call mark_possessives, line 368 |
| if !r_mark_possessives(env, context) { |
| break 'lab9; |
| } |
| break 'lab8; |
| } |
| env.cursor = env.limit - v_5; |
| // call mark_sU, line 368 |
| if !r_mark_sU(env, context) { |
| break 'lab7; |
| } |
| break 'lab8; |
| } |
| // ], line 368 |
| env.bra = env.cursor; |
| // delete, line 368 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 368 |
| let v_6 = env.limit - env.cursor; |
| 'lab10: loop { |
| // (, line 368 |
| // [, line 368 |
| env.ket = env.cursor; |
| // call mark_lAr, line 368 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_6; |
| break 'lab10; |
| } |
| // ], line 368 |
| env.bra = env.cursor; |
| // delete, line 368 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 368 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_6; |
| break 'lab10; |
| } |
| break 'lab10; |
| } |
| break 'lab5; |
| } |
| env.cursor = env.limit - v_4; |
| // (, line 370 |
| // [, line 370 |
| env.ket = env.cursor; |
| // call mark_lAr, line 370 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_3; |
| break 'lab4; |
| } |
| // ], line 370 |
| env.bra = env.cursor; |
| // delete, line 370 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 370 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_3; |
| break 'lab4; |
| } |
| break 'lab5; |
| } |
| break 'lab4; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab11: loop { |
| // (, line 374 |
| // [, line 374 |
| env.ket = env.cursor; |
| // (, line 374 |
| // or, line 374 |
| 'lab12: loop { |
| let v_7 = env.limit - env.cursor; |
| 'lab13: loop { |
| // call mark_ndA, line 374 |
| if !r_mark_ndA(env, context) { |
| break 'lab13; |
| } |
| break 'lab12; |
| } |
| env.cursor = env.limit - v_7; |
| // call mark_nA, line 374 |
| if !r_mark_nA(env, context) { |
| break 'lab11; |
| } |
| break 'lab12; |
| } |
| // (, line 375 |
| // or, line 377 |
| 'lab14: loop { |
| let v_8 = env.limit - env.cursor; |
| 'lab15: loop { |
| // (, line 376 |
| // call mark_lArI, line 376 |
| if !r_mark_lArI(env, context) { |
| break 'lab15; |
| } |
| // ], line 376 |
| env.bra = env.cursor; |
| // delete, line 376 |
| if !env.slice_del() { |
| return false; |
| } |
| break 'lab14; |
| } |
| env.cursor = env.limit - v_8; |
| 'lab16: loop { |
| // (, line 378 |
| // call mark_sU, line 378 |
| if !r_mark_sU(env, context) { |
| break 'lab16; |
| } |
| // ], line 378 |
| env.bra = env.cursor; |
| // delete, line 378 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 378 |
| let v_9 = env.limit - env.cursor; |
| 'lab17: loop { |
| // (, line 378 |
| // [, line 378 |
| env.ket = env.cursor; |
| // call mark_lAr, line 378 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_9; |
| break 'lab17; |
| } |
| // ], line 378 |
| env.bra = env.cursor; |
| // delete, line 378 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 378 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_9; |
| break 'lab17; |
| } |
| break 'lab17; |
| } |
| break 'lab14; |
| } |
| env.cursor = env.limit - v_8; |
| // (, line 380 |
| // call stem_suffix_chain_before_ki, line 380 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| break 'lab11; |
| } |
| break 'lab14; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab18: loop { |
| // (, line 384 |
| // [, line 384 |
| env.ket = env.cursor; |
| // (, line 384 |
| // or, line 384 |
| 'lab19: loop { |
| let v_10 = env.limit - env.cursor; |
| 'lab20: loop { |
| // call mark_ndAn, line 384 |
| if !r_mark_ndAn(env, context) { |
| break 'lab20; |
| } |
| break 'lab19; |
| } |
| env.cursor = env.limit - v_10; |
| // call mark_nU, line 384 |
| if !r_mark_nU(env, context) { |
| break 'lab18; |
| } |
| break 'lab19; |
| } |
| // (, line 384 |
| // or, line 384 |
| 'lab21: loop { |
| let v_11 = env.limit - env.cursor; |
| 'lab22: loop { |
| // (, line 384 |
| // call mark_sU, line 384 |
| if !r_mark_sU(env, context) { |
| break 'lab22; |
| } |
| // ], line 384 |
| env.bra = env.cursor; |
| // delete, line 384 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 384 |
| let v_12 = env.limit - env.cursor; |
| 'lab23: loop { |
| // (, line 384 |
| // [, line 384 |
| env.ket = env.cursor; |
| // call mark_lAr, line 384 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_12; |
| break 'lab23; |
| } |
| // ], line 384 |
| env.bra = env.cursor; |
| // delete, line 384 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 384 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_12; |
| break 'lab23; |
| } |
| break 'lab23; |
| } |
| break 'lab21; |
| } |
| env.cursor = env.limit - v_11; |
| // (, line 384 |
| // call mark_lArI, line 384 |
| if !r_mark_lArI(env, context) { |
| break 'lab18; |
| } |
| break 'lab21; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab24: loop { |
| // (, line 386 |
| // [, line 386 |
| env.ket = env.cursor; |
| // call mark_DAn, line 386 |
| if !r_mark_DAn(env, context) { |
| break 'lab24; |
| } |
| // ], line 386 |
| env.bra = env.cursor; |
| // delete, line 386 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 386 |
| let v_13 = env.limit - env.cursor; |
| 'lab25: loop { |
| // (, line 386 |
| // [, line 386 |
| env.ket = env.cursor; |
| // (, line 387 |
| // or, line 389 |
| 'lab26: loop { |
| let v_14 = env.limit - env.cursor; |
| 'lab27: loop { |
| // (, line 388 |
| // call mark_possessives, line 388 |
| if !r_mark_possessives(env, context) { |
| break 'lab27; |
| } |
| // ], line 388 |
| env.bra = env.cursor; |
| // delete, line 388 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 388 |
| let v_15 = env.limit - env.cursor; |
| 'lab28: loop { |
| // (, line 388 |
| // [, line 388 |
| env.ket = env.cursor; |
| // call mark_lAr, line 388 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_15; |
| break 'lab28; |
| } |
| // ], line 388 |
| env.bra = env.cursor; |
| // delete, line 388 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 388 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_15; |
| break 'lab28; |
| } |
| break 'lab28; |
| } |
| break 'lab26; |
| } |
| env.cursor = env.limit - v_14; |
| 'lab29: loop { |
| // (, line 390 |
| // call mark_lAr, line 390 |
| if !r_mark_lAr(env, context) { |
| break 'lab29; |
| } |
| // ], line 390 |
| env.bra = env.cursor; |
| // delete, line 390 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 390 |
| let v_16 = env.limit - env.cursor; |
| 'lab30: loop { |
| // (, line 390 |
| // call stem_suffix_chain_before_ki, line 390 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_16; |
| break 'lab30; |
| } |
| break 'lab30; |
| } |
| break 'lab26; |
| } |
| env.cursor = env.limit - v_14; |
| // (, line 392 |
| // call stem_suffix_chain_before_ki, line 392 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_13; |
| break 'lab25; |
| } |
| break 'lab26; |
| } |
| break 'lab25; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab31: loop { |
| // (, line 396 |
| // [, line 396 |
| env.ket = env.cursor; |
| // or, line 396 |
| 'lab32: loop { |
| let v_17 = env.limit - env.cursor; |
| 'lab33: loop { |
| // call mark_nUn, line 396 |
| if !r_mark_nUn(env, context) { |
| break 'lab33; |
| } |
| break 'lab32; |
| } |
| env.cursor = env.limit - v_17; |
| // call mark_ylA, line 396 |
| if !r_mark_ylA(env, context) { |
| break 'lab31; |
| } |
| break 'lab32; |
| } |
| // ], line 396 |
| env.bra = env.cursor; |
| // delete, line 396 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 397 |
| let v_18 = env.limit - env.cursor; |
| 'lab34: loop { |
| // (, line 397 |
| // or, line 399 |
| 'lab35: loop { |
| let v_19 = env.limit - env.cursor; |
| 'lab36: loop { |
| // (, line 398 |
| // [, line 398 |
| env.ket = env.cursor; |
| // call mark_lAr, line 398 |
| if !r_mark_lAr(env, context) { |
| break 'lab36; |
| } |
| // ], line 398 |
| env.bra = env.cursor; |
| // delete, line 398 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 398 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| break 'lab36; |
| } |
| break 'lab35; |
| } |
| env.cursor = env.limit - v_19; |
| 'lab37: loop { |
| // (, line 400 |
| // [, line 400 |
| env.ket = env.cursor; |
| // or, line 400 |
| 'lab38: loop { |
| let v_20 = env.limit - env.cursor; |
| 'lab39: loop { |
| // call mark_possessives, line 400 |
| if !r_mark_possessives(env, context) { |
| break 'lab39; |
| } |
| break 'lab38; |
| } |
| env.cursor = env.limit - v_20; |
| // call mark_sU, line 400 |
| if !r_mark_sU(env, context) { |
| break 'lab37; |
| } |
| break 'lab38; |
| } |
| // ], line 400 |
| env.bra = env.cursor; |
| // delete, line 400 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 400 |
| let v_21 = env.limit - env.cursor; |
| 'lab40: loop { |
| // (, line 400 |
| // [, line 400 |
| env.ket = env.cursor; |
| // call mark_lAr, line 400 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_21; |
| break 'lab40; |
| } |
| // ], line 400 |
| env.bra = env.cursor; |
| // delete, line 400 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 400 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_21; |
| break 'lab40; |
| } |
| break 'lab40; |
| } |
| break 'lab35; |
| } |
| env.cursor = env.limit - v_19; |
| // call stem_suffix_chain_before_ki, line 402 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_18; |
| break 'lab34; |
| } |
| break 'lab35; |
| } |
| break 'lab34; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab41: loop { |
| // (, line 406 |
| // [, line 406 |
| env.ket = env.cursor; |
| // call mark_lArI, line 406 |
| if !r_mark_lArI(env, context) { |
| break 'lab41; |
| } |
| // ], line 406 |
| env.bra = env.cursor; |
| // delete, line 406 |
| if !env.slice_del() { |
| return false; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab42: loop { |
| // (, line 408 |
| // call stem_suffix_chain_before_ki, line 408 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| break 'lab42; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| 'lab43: loop { |
| // (, line 410 |
| // [, line 410 |
| env.ket = env.cursor; |
| // or, line 410 |
| 'lab44: loop { |
| let v_22 = env.limit - env.cursor; |
| 'lab45: loop { |
| // call mark_DA, line 410 |
| if !r_mark_DA(env, context) { |
| break 'lab45; |
| } |
| break 'lab44; |
| } |
| env.cursor = env.limit - v_22; |
| 'lab46: loop { |
| // call mark_yU, line 410 |
| if !r_mark_yU(env, context) { |
| break 'lab46; |
| } |
| break 'lab44; |
| } |
| env.cursor = env.limit - v_22; |
| // call mark_yA, line 410 |
| if !r_mark_yA(env, context) { |
| break 'lab43; |
| } |
| break 'lab44; |
| } |
| // ], line 410 |
| env.bra = env.cursor; |
| // delete, line 410 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 410 |
| let v_23 = env.limit - env.cursor; |
| 'lab47: loop { |
| // (, line 410 |
| // [, line 410 |
| env.ket = env.cursor; |
| // (, line 410 |
| // or, line 410 |
| 'lab48: loop { |
| let v_24 = env.limit - env.cursor; |
| 'lab49: loop { |
| // (, line 410 |
| // call mark_possessives, line 410 |
| if !r_mark_possessives(env, context) { |
| break 'lab49; |
| } |
| // ], line 410 |
| env.bra = env.cursor; |
| // delete, line 410 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 410 |
| let v_25 = env.limit - env.cursor; |
| 'lab50: loop { |
| // (, line 410 |
| // [, line 410 |
| env.ket = env.cursor; |
| // call mark_lAr, line 410 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_25; |
| break 'lab50; |
| } |
| break 'lab50; |
| } |
| break 'lab48; |
| } |
| env.cursor = env.limit - v_24; |
| // call mark_lAr, line 410 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_23; |
| break 'lab47; |
| } |
| break 'lab48; |
| } |
| // ], line 410 |
| env.bra = env.cursor; |
| // delete, line 410 |
| if !env.slice_del() { |
| return false; |
| } |
| // [, line 410 |
| env.ket = env.cursor; |
| // call stem_suffix_chain_before_ki, line 410 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_23; |
| break 'lab47; |
| } |
| break 'lab47; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| // (, line 412 |
| // [, line 412 |
| env.ket = env.cursor; |
| // or, line 412 |
| 'lab51: loop { |
| let v_26 = env.limit - env.cursor; |
| 'lab52: loop { |
| // call mark_possessives, line 412 |
| if !r_mark_possessives(env, context) { |
| break 'lab52; |
| } |
| break 'lab51; |
| } |
| env.cursor = env.limit - v_26; |
| // call mark_sU, line 412 |
| if !r_mark_sU(env, context) { |
| return false; |
| } |
| break 'lab51; |
| } |
| // ], line 412 |
| env.bra = env.cursor; |
| // delete, line 412 |
| if !env.slice_del() { |
| return false; |
| } |
| // try, line 412 |
| let v_27 = env.limit - env.cursor; |
| 'lab53: loop { |
| // (, line 412 |
| // [, line 412 |
| env.ket = env.cursor; |
| // call mark_lAr, line 412 |
| if !r_mark_lAr(env, context) { |
| env.cursor = env.limit - v_27; |
| break 'lab53; |
| } |
| // ], line 412 |
| env.bra = env.cursor; |
| // delete, line 412 |
| if !env.slice_del() { |
| return false; |
| } |
| // call stem_suffix_chain_before_ki, line 412 |
| if !r_stem_suffix_chain_before_ki(env, context) { |
| env.cursor = env.limit - v_27; |
| break 'lab53; |
| } |
| break 'lab53; |
| } |
| break 'lab0; |
| } |
| return true; |
| } |
| |
| fn r_post_process_last_consonants(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| let mut among_var; |
| // (, line 415 |
| // [, line 416 |
| env.ket = env.cursor; |
| // substring, line 416 |
| among_var = env.find_among_b(A_23, context); |
| if among_var == 0 { |
| return false; |
| } |
| // ], line 416 |
| env.bra = env.cursor; |
| if among_var == 0 { |
| return false; |
| } else if among_var == 1 { |
| // (, line 417 |
| // <-, line 417 |
| if !env.slice_from("p") { |
| return false; |
| } |
| } else if among_var == 2 { |
| // (, line 418 |
| // <-, line 418 |
| if !env.slice_from("\u{00E7}") { |
| return false; |
| } |
| } else if among_var == 3 { |
| // (, line 419 |
| // <-, line 419 |
| if !env.slice_from("t") { |
| return false; |
| } |
| } else if among_var == 4 { |
| // (, line 420 |
| // <-, line 420 |
| if !env.slice_from("k") { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| fn r_append_U_to_stems_ending_with_d_or_g(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 430 |
| // test, line 431 |
| let v_1 = env.limit - env.cursor; |
| // (, line 431 |
| // or, line 431 |
| 'lab0: loop { |
| let v_2 = env.limit - env.cursor; |
| 'lab1: loop { |
| // literal, line 431 |
| if !env.eq_s_b(&"d") { |
| break 'lab1; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_2; |
| // literal, line 431 |
| if !env.eq_s_b(&"g") { |
| return false; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| // or, line 433 |
| 'lab2: loop { |
| let v_3 = env.limit - env.cursor; |
| 'lab3: loop { |
| // (, line 432 |
| // test, line 432 |
| let v_4 = env.limit - env.cursor; |
| // (, line 432 |
| // (, line 432 |
| // goto, line 432 |
| 'golab4: loop { |
| let v_5 = env.limit - env.cursor; |
| 'lab5: loop { |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| break 'lab5; |
| } |
| env.cursor = env.limit - v_5; |
| break 'golab4; |
| } |
| env.cursor = env.limit - v_5; |
| if env.cursor <= env.limit_backward { |
| break 'lab3; |
| } |
| env.previous_char(); |
| } |
| // or, line 432 |
| 'lab6: loop { |
| let v_6 = env.limit - env.cursor; |
| 'lab7: loop { |
| // literal, line 432 |
| if !env.eq_s_b(&"a") { |
| break 'lab7; |
| } |
| break 'lab6; |
| } |
| env.cursor = env.limit - v_6; |
| // literal, line 432 |
| if !env.eq_s_b(&"\u{0131}") { |
| break 'lab3; |
| } |
| break 'lab6; |
| } |
| env.cursor = env.limit - v_4; |
| // <+, line 432 |
| let c = env.cursor; |
| let (bra, ket) = (env.cursor, env.cursor); |
| env.insert(bra, ket, "\u{0131}"); |
| env.cursor = c; |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab8: loop { |
| // (, line 434 |
| // test, line 434 |
| let v_7 = env.limit - env.cursor; |
| // (, line 434 |
| // (, line 434 |
| // goto, line 434 |
| 'golab9: loop { |
| let v_8 = env.limit - env.cursor; |
| 'lab10: loop { |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| break 'lab10; |
| } |
| env.cursor = env.limit - v_8; |
| break 'golab9; |
| } |
| env.cursor = env.limit - v_8; |
| if env.cursor <= env.limit_backward { |
| break 'lab8; |
| } |
| env.previous_char(); |
| } |
| // or, line 434 |
| 'lab11: loop { |
| let v_9 = env.limit - env.cursor; |
| 'lab12: loop { |
| // literal, line 434 |
| if !env.eq_s_b(&"e") { |
| break 'lab12; |
| } |
| break 'lab11; |
| } |
| env.cursor = env.limit - v_9; |
| // literal, line 434 |
| if !env.eq_s_b(&"i") { |
| break 'lab8; |
| } |
| break 'lab11; |
| } |
| env.cursor = env.limit - v_7; |
| // <+, line 434 |
| let c = env.cursor; |
| let (bra, ket) = (env.cursor, env.cursor); |
| env.insert(bra, ket, "i"); |
| env.cursor = c; |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| 'lab13: loop { |
| // (, line 436 |
| // test, line 436 |
| let v_10 = env.limit - env.cursor; |
| // (, line 436 |
| // (, line 436 |
| // goto, line 436 |
| 'golab14: loop { |
| let v_11 = env.limit - env.cursor; |
| 'lab15: loop { |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| break 'lab15; |
| } |
| env.cursor = env.limit - v_11; |
| break 'golab14; |
| } |
| env.cursor = env.limit - v_11; |
| if env.cursor <= env.limit_backward { |
| break 'lab13; |
| } |
| env.previous_char(); |
| } |
| // or, line 436 |
| 'lab16: loop { |
| let v_12 = env.limit - env.cursor; |
| 'lab17: loop { |
| // literal, line 436 |
| if !env.eq_s_b(&"o") { |
| break 'lab17; |
| } |
| break 'lab16; |
| } |
| env.cursor = env.limit - v_12; |
| // literal, line 436 |
| if !env.eq_s_b(&"u") { |
| break 'lab13; |
| } |
| break 'lab16; |
| } |
| env.cursor = env.limit - v_10; |
| // <+, line 436 |
| let c = env.cursor; |
| let (bra, ket) = (env.cursor, env.cursor); |
| env.insert(bra, ket, "u"); |
| env.cursor = c; |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| // (, line 438 |
| // test, line 438 |
| let v_13 = env.limit - env.cursor; |
| // (, line 438 |
| // (, line 438 |
| // goto, line 438 |
| 'golab18: loop { |
| let v_14 = env.limit - env.cursor; |
| 'lab19: loop { |
| if !env.in_grouping_b(G_vowel, 97, 305) { |
| break 'lab19; |
| } |
| env.cursor = env.limit - v_14; |
| break 'golab18; |
| } |
| env.cursor = env.limit - v_14; |
| if env.cursor <= env.limit_backward { |
| return false; |
| } |
| env.previous_char(); |
| } |
| // or, line 438 |
| 'lab20: loop { |
| let v_15 = env.limit - env.cursor; |
| 'lab21: loop { |
| // literal, line 438 |
| if !env.eq_s_b(&"\u{00F6}") { |
| break 'lab21; |
| } |
| break 'lab20; |
| } |
| env.cursor = env.limit - v_15; |
| // literal, line 438 |
| if !env.eq_s_b(&"\u{00FC}") { |
| return false; |
| } |
| break 'lab20; |
| } |
| env.cursor = env.limit - v_13; |
| // <+, line 438 |
| let c = env.cursor; |
| let (bra, ket) = (env.cursor, env.cursor); |
| env.insert(bra, ket, "\u{00FC}"); |
| env.cursor = c; |
| break 'lab2; |
| } |
| return true; |
| } |
| |
| fn r_more_than_one_syllable_word(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 445 |
| // test, line 446 |
| let v_1 = env.cursor; |
| // (, line 446 |
| // atleast, line 446 |
| let mut v_2 = 2; |
| // atleast, line 446 |
| 'replab0: loop{ |
| let v_3 = env.cursor; |
| 'lab1: for _ in 0..1 { |
| // (, line 446 |
| // gopast, line 446 |
| 'golab2: loop { |
| 'lab3: loop { |
| if !env.in_grouping(G_vowel, 97, 305) { |
| break 'lab3; |
| } |
| break 'golab2; |
| } |
| if env.cursor >= env.limit { |
| break 'lab1; |
| } |
| env.next_char(); |
| } |
| v_2 -= 1; |
| continue 'replab0; |
| } |
| env.cursor = v_3; |
| break 'replab0; |
| } |
| if v_2 > 0 { |
| return false; |
| } |
| env.cursor = v_1; |
| return true; |
| } |
| |
| fn r_is_reserved_word(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 449 |
| // or, line 451 |
| 'lab0: loop { |
| let v_1 = env.cursor; |
| 'lab1: loop { |
| // test, line 450 |
| let v_2 = env.cursor; |
| // (, line 450 |
| // gopast, line 450 |
| 'golab2: loop { |
| 'lab3: loop { |
| // literal, line 450 |
| if !env.eq_s(&"ad") { |
| break 'lab3; |
| } |
| break 'golab2; |
| } |
| if env.cursor >= env.limit { |
| break 'lab1; |
| } |
| env.next_char(); |
| } |
| // (, line 450 |
| context.i_strlen = 2; |
| // (, line 450 |
| if !(context.i_strlen == env.limit){ |
| break 'lab1; |
| } |
| env.cursor = v_2; |
| break 'lab0; |
| } |
| env.cursor = v_1; |
| // test, line 452 |
| let v_4 = env.cursor; |
| // (, line 452 |
| // gopast, line 452 |
| 'golab4: loop { |
| 'lab5: loop { |
| // literal, line 452 |
| if !env.eq_s(&"soyad") { |
| break 'lab5; |
| } |
| break 'golab4; |
| } |
| if env.cursor >= env.limit { |
| return false; |
| } |
| env.next_char(); |
| } |
| // (, line 452 |
| context.i_strlen = 5; |
| // (, line 452 |
| if !(context.i_strlen == env.limit){ |
| return false; |
| } |
| env.cursor = v_4; |
| break 'lab0; |
| } |
| return true; |
| } |
| |
| fn r_postlude(env: &mut SnowballEnv, context: &mut Context) -> bool { |
| // (, line 455 |
| // not, line 456 |
| let v_1 = env.cursor; |
| 'lab0: loop { |
| // (, line 456 |
| // call is_reserved_word, line 456 |
| if !r_is_reserved_word(env, context) { |
| break 'lab0; |
| } |
| return false; |
| } |
| env.cursor = v_1; |
| // backwards, line 457 |
| env.limit_backward = env.cursor; |
| env.cursor = env.limit; |
| // (, line 457 |
| // do, line 458 |
| let v_2 = env.limit - env.cursor; |
| 'lab1: loop { |
| // call append_U_to_stems_ending_with_d_or_g, line 458 |
| if !r_append_U_to_stems_ending_with_d_or_g(env, context) { |
| break 'lab1; |
| } |
| break 'lab1; |
| } |
| env.cursor = env.limit - v_2; |
| // do, line 459 |
| let v_3 = env.limit - env.cursor; |
| 'lab2: loop { |
| // call post_process_last_consonants, line 459 |
| if !r_post_process_last_consonants(env, context) { |
| break 'lab2; |
| } |
| break 'lab2; |
| } |
| env.cursor = env.limit - v_3; |
| env.cursor = env.limit_backward; |
| return true; |
| } |
| |
| pub fn stem(env: &mut SnowballEnv) -> bool { |
| let mut context = &mut Context { |
| b_continue_stemming_noun_suffixes: false, |
| i_strlen: 0, |
| }; |
| // (, line 464 |
| // (, line 465 |
| // call more_than_one_syllable_word, line 465 |
| if !r_more_than_one_syllable_word(env, context) { |
| return false; |
| } |
| // (, line 466 |
| // backwards, line 467 |
| env.limit_backward = env.cursor; |
| env.cursor = env.limit; |
| // (, line 467 |
| // do, line 468 |
| let v_1 = env.limit - env.cursor; |
| 'lab0: loop { |
| // call stem_nominal_verb_suffixes, line 468 |
| if !r_stem_nominal_verb_suffixes(env, context) { |
| break 'lab0; |
| } |
| break 'lab0; |
| } |
| env.cursor = env.limit - v_1; |
| // Boolean test continue_stemming_noun_suffixes, line 469 |
| if !context.b_continue_stemming_noun_suffixes { |
| return false; |
| } |
| // do, line 470 |
| let v_2 = env.limit - env.cursor; |
| 'lab1: loop { |
| // call stem_noun_suffixes, line 470 |
| if !r_stem_noun_suffixes(env, context) { |
| break 'lab1; |
| } |
| break 'lab1; |
| } |
| env.cursor = env.limit - v_2; |
| env.cursor = env.limit_backward; |
| // call postlude, line 473 |
| if !r_postlude(env, context) { |
| return false; |
| } |
| return true; |
| } |
