1 //! This file was generated automatically by the Snowball to Rust compiler 2 //! http://snowballstem.org/ 3 4 #![allow(non_upper_case_globals)] 5 #![allow(non_snake_case)] 6 #![allow(unused_variables)] 7 #![allow(unused_mut)] 8 use snowball::SnowballEnv; 9 use snowball::Among; 10 11 static A_0: &'static [Among<Context>; 8] = &[ 12 Among("cs", -1, -1, None), 13 Among("dzs", -1, -1, None), 14 Among("gy", -1, -1, None), 15 Among("ly", -1, -1, None), 16 Among("ny", -1, -1, None), 17 Among("sz", -1, -1, None), 18 Among("ty", -1, -1, None), 19 Among("zs", -1, -1, None), 20 ]; 21 22 static A_1: &'static [Among<Context>; 2] = &[ 23 Among("\u{00E1}", -1, 1, None), 24 Among("\u{00E9}", -1, 2, None), 25 ]; 26 27 static A_2: &'static [Among<Context>; 23] = &[ 28 Among("bb", -1, -1, None), 29 Among("cc", -1, -1, None), 30 Among("dd", -1, -1, None), 31 Among("ff", -1, -1, None), 32 Among("gg", -1, -1, None), 33 Among("jj", -1, -1, None), 34 Among("kk", -1, -1, None), 35 Among("ll", -1, -1, None), 36 Among("mm", -1, -1, None), 37 Among("nn", -1, -1, None), 38 Among("pp", -1, -1, None), 39 Among("rr", -1, -1, None), 40 Among("ccs", -1, -1, None), 41 Among("ss", -1, -1, None), 42 Among("zzs", -1, -1, None), 43 Among("tt", -1, -1, None), 44 Among("vv", -1, -1, None), 45 Among("ggy", -1, -1, None), 46 Among("lly", -1, -1, None), 47 Among("nny", -1, -1, None), 48 Among("tty", -1, -1, None), 49 Among("ssz", -1, -1, None), 50 Among("zz", -1, -1, None), 51 ]; 52 53 static A_3: &'static [Among<Context>; 2] = &[ 54 Among("al", -1, 1, None), 55 Among("el", -1, 2, None), 56 ]; 57 58 static A_4: &'static [Among<Context>; 44] = &[ 59 Among("ba", -1, -1, None), 60 Among("ra", -1, -1, None), 61 Among("be", -1, -1, None), 62 Among("re", -1, -1, None), 63 Among("ig", -1, -1, None), 64 Among("nak", -1, -1, None), 65 Among("nek", -1, -1, None), 66 Among("val", -1, -1, None), 67 Among("vel", -1, -1, None), 68 Among("ul", -1, -1, None), 69 Among("b\u{0151}l", -1, -1, None), 70 Among("r\u{0151}l", -1, -1, None), 71 Among("t\u{0151}l", -1, -1, None), 72 Among("n\u{00E1}l", -1, -1, None), 73 Among("n\u{00E9}l", -1, -1, None), 74 Among("b\u{00F3}l", -1, -1, None), 75 Among("r\u{00F3}l", -1, -1, None), 76 Among("t\u{00F3}l", -1, -1, None), 77 Among("\u{00FC}l", -1, -1, None), 78 Among("n", -1, -1, None), 79 Among("an", 19, -1, None), 80 Among("ban", 20, -1, None), 81 Among("en", 19, -1, None), 82 Among("ben", 22, -1, None), 83 Among("k\u{00E9}ppen", 22, -1, None), 84 Among("on", 19, -1, None), 85 Among("\u{00F6}n", 19, -1, None), 86 Among("k\u{00E9}pp", -1, -1, None), 87 Among("kor", -1, -1, None), 88 Among("t", -1, -1, None), 89 Among("at", 29, -1, None), 90 Among("et", 29, -1, None), 91 Among("k\u{00E9}nt", 29, -1, None), 92 Among("ank\u{00E9}nt", 32, -1, None), 93 Among("enk\u{00E9}nt", 32, -1, None), 94 Among("onk\u{00E9}nt", 32, -1, None), 95 Among("ot", 29, -1, None), 96 Among("\u{00E9}rt", 29, -1, None), 97 Among("\u{00F6}t", 29, -1, None), 98 Among("hez", -1, -1, None), 99 Among("hoz", -1, -1, None), 100 Among("h\u{00F6}z", -1, -1, None), 101 Among("v\u{00E1}", -1, -1, None), 102 Among("v\u{00E9}", -1, -1, None), 103 ]; 104 105 static A_5: &'static [Among<Context>; 3] = &[ 106 Among("\u{00E1}n", -1, 2, None), 107 Among("\u{00E9}n", -1, 1, None), 108 Among("\u{00E1}nk\u{00E9}nt", -1, 3, None), 109 ]; 110 111 static A_6: &'static [Among<Context>; 6] = &[ 112 Among("stul", -1, 2, None), 113 Among("astul", 0, 1, None), 114 Among("\u{00E1}stul", 0, 3, None), 115 Among("st\u{00FC}l", -1, 2, None), 116 Among("est\u{00FC}l", 3, 1, None), 117 Among("\u{00E9}st\u{00FC}l", 3, 4, None), 118 ]; 119 120 static A_7: &'static [Among<Context>; 2] = &[ 121 Among("\u{00E1}", -1, 1, None), 122 Among("\u{00E9}", -1, 2, None), 123 ]; 124 125 static A_8: &'static [Among<Context>; 7] = &[ 126 Among("k", -1, 7, None), 127 Among("ak", 0, 4, None), 128 Among("ek", 0, 6, None), 129 Among("ok", 0, 5, None), 130 Among("\u{00E1}k", 0, 1, None), 131 Among("\u{00E9}k", 0, 2, None), 132 Among("\u{00F6}k", 0, 3, None), 133 ]; 134 135 static A_9: &'static [Among<Context>; 12] = &[ 136 Among("\u{00E9}i", -1, 7, None), 137 Among("\u{00E1}\u{00E9}i", 0, 6, None), 138 Among("\u{00E9}\u{00E9}i", 0, 5, None), 139 Among("\u{00E9}", -1, 9, None), 140 Among("k\u{00E9}", 3, 4, None), 141 Among("ak\u{00E9}", 4, 1, None), 142 Among("ek\u{00E9}", 4, 1, None), 143 Among("ok\u{00E9}", 4, 1, None), 144 Among("\u{00E1}k\u{00E9}", 4, 3, None), 145 Among("\u{00E9}k\u{00E9}", 4, 2, None), 146 Among("\u{00F6}k\u{00E9}", 4, 1, None), 147 Among("\u{00E9}\u{00E9}", 3, 8, None), 148 ]; 149 150 static A_10: &'static [Among<Context>; 31] = &[ 151 Among("a", -1, 18, None), 152 Among("ja", 0, 17, None), 153 Among("d", -1, 16, None), 154 Among("ad", 2, 13, None), 155 Among("ed", 2, 13, None), 156 Among("od", 2, 13, None), 157 Among("\u{00E1}d", 2, 14, None), 158 Among("\u{00E9}d", 2, 15, None), 159 Among("\u{00F6}d", 2, 13, None), 160 Among("e", -1, 18, None), 161 Among("je", 9, 17, None), 162 Among("nk", -1, 4, None), 163 Among("unk", 11, 1, None), 164 Among("\u{00E1}nk", 11, 2, None), 165 Among("\u{00E9}nk", 11, 3, None), 166 Among("\u{00FC}nk", 11, 1, None), 167 Among("uk", -1, 8, None), 168 Among("juk", 16, 7, None), 169 Among("\u{00E1}juk", 17, 5, None), 170 Among("\u{00FC}k", -1, 8, None), 171 Among("j\u{00FC}k", 19, 7, None), 172 Among("\u{00E9}j\u{00FC}k", 20, 6, None), 173 Among("m", -1, 12, None), 174 Among("am", 22, 9, None), 175 Among("em", 22, 9, None), 176 Among("om", 22, 9, None), 177 Among("\u{00E1}m", 22, 10, None), 178 Among("\u{00E9}m", 22, 11, None), 179 Among("o", -1, 18, None), 180 Among("\u{00E1}", -1, 19, None), 181 Among("\u{00E9}", -1, 20, None), 182 ]; 183 184 static A_11: &'static [Among<Context>; 42] = &[ 185 Among("id", -1, 10, None), 186 Among("aid", 0, 9, None), 187 Among("jaid", 1, 6, None), 188 Among("eid", 0, 9, None), 189 Among("jeid", 3, 6, None), 190 Among("\u{00E1}id", 0, 7, None), 191 Among("\u{00E9}id", 0, 8, None), 192 Among("i", -1, 15, None), 193 Among("ai", 7, 14, None), 194 Among("jai", 8, 11, None), 195 Among("ei", 7, 14, None), 196 Among("jei", 10, 11, None), 197 Among("\u{00E1}i", 7, 12, None), 198 Among("\u{00E9}i", 7, 13, None), 199 Among("itek", -1, 24, None), 200 Among("eitek", 14, 21, None), 201 Among("jeitek", 15, 20, None), 202 Among("\u{00E9}itek", 14, 23, None), 203 Among("ik", -1, 29, None), 204 Among("aik", 18, 26, None), 205 Among("jaik", 19, 25, None), 206 Among("eik", 18, 26, None), 207 Among("jeik", 21, 25, None), 208 Among("\u{00E1}ik", 18, 27, None), 209 Among("\u{00E9}ik", 18, 28, None), 210 Among("ink", -1, 20, None), 211 Among("aink", 25, 17, None), 212 Among("jaink", 26, 16, None), 213 Among("eink", 25, 17, None), 214 Among("jeink", 28, 16, None), 215 Among("\u{00E1}ink", 25, 18, None), 216 Among("\u{00E9}ink", 25, 19, None), 217 Among("aitok", -1, 21, None), 218 Among("jaitok", 32, 20, None), 219 Among("\u{00E1}itok", -1, 22, None), 220 Among("im", -1, 5, None), 221 Among("aim", 35, 4, None), 222 Among("jaim", 36, 1, None), 223 Among("eim", 35, 4, None), 224 Among("jeim", 38, 1, None), 225 Among("\u{00E1}im", 35, 2, None), 226 Among("\u{00E9}im", 35, 3, None), 227 ]; 228 229 static G_v: &'static [u8; 35] = &[17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 36, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1]; 230 231 #[derive(Clone)] 232 struct Context { 233 i_p1: usize, 234 } 235 236 fn r_mark_regions(env: &mut SnowballEnv, context: &mut Context) -> bool { 237 // (, line 44 238 context.i_p1 = env.limit; 239 // or, line 51 240 'lab0: loop { 241 let v_1 = env.cursor; 242 'lab1: loop { 243 // (, line 48 244 if !env.in_grouping(G_v, 97, 369) { 245 break 'lab1; 246 } 247 // goto, line 48 248 'golab2: loop { 249 let v_2 = env.cursor; 250 'lab3: loop { 251 if !env.out_grouping(G_v, 97, 369) { 252 break 'lab3; 253 } 254 env.cursor = v_2; 255 break 'golab2; 256 } 257 env.cursor = v_2; 258 if env.cursor >= env.limit { 259 break 'lab1; 260 } 261 env.next_char(); 262 } 263 // or, line 49 264 'lab4: loop { 265 let v_3 = env.cursor; 266 'lab5: loop { 267 // among, line 49 268 if env.find_among(A_0, context) == 0 { 269 break 'lab5; 270 } 271 break 'lab4; 272 } 273 env.cursor = v_3; 274 // next, line 49 275 if env.cursor >= env.limit { 276 break 'lab1; 277 } 278 env.next_char(); 279 break 'lab4; 280 } 281 // setmark p1, line 50 282 context.i_p1 = env.cursor; 283 break 'lab0; 284 } 285 env.cursor = v_1; 286 // (, line 53 287 if !env.out_grouping(G_v, 97, 369) { 288 return false; 289 } 290 // gopast, line 53 291 'golab6: loop { 292 'lab7: loop { 293 if !env.in_grouping(G_v, 97, 369) { 294 break 'lab7; 295 } 296 break 'golab6; 297 } 298 if env.cursor >= env.limit { 299 return false; 300 } 301 env.next_char(); 302 } 303 // setmark p1, line 53 304 context.i_p1 = env.cursor; 305 break 'lab0; 306 } 307 return true; 308 } 309 310 fn r_R1(env: &mut SnowballEnv, context: &mut Context) -> bool { 311 if !(context.i_p1 <= env.cursor){ 312 return false; 313 } 314 return true; 315 } 316 317 fn r_v_ending(env: &mut SnowballEnv, context: &mut Context) -> bool { 318 let mut among_var; 319 // (, line 60 320 // [, line 61 321 env.ket = env.cursor; 322 // substring, line 61 323 among_var = env.find_among_b(A_1, context); 324 if among_var == 0 { 325 return false; 326 } 327 // ], line 61 328 env.bra = env.cursor; 329 // call R1, line 61 330 if !r_R1(env, context) { 331 return false; 332 } 333 if among_var == 0 { 334 return false; 335 } else if among_var == 1 { 336 // (, line 62 337 // <-, line 62 338 if !env.slice_from("a") { 339 return false; 340 } 341 } else if among_var == 2 { 342 // (, line 63 343 // <-, line 63 344 if !env.slice_from("e") { 345 return false; 346 } 347 } 348 return true; 349 } 350 351 fn r_double(env: &mut SnowballEnv, context: &mut Context) -> bool { 352 // (, line 67 353 // test, line 68 354 let v_1 = env.limit - env.cursor; 355 // among, line 68 356 if env.find_among_b(A_2, context) == 0 { 357 return false; 358 } 359 env.cursor = env.limit - v_1; 360 return true; 361 } 362 363 fn r_undouble(env: &mut SnowballEnv, context: &mut Context) -> bool { 364 // (, line 72 365 // next, line 73 366 if env.cursor <= env.limit_backward { 367 return false; 368 } 369 env.previous_char(); 370 // [, line 73 371 env.ket = env.cursor; 372 // hop, line 73 373 let c = env.byte_index_for_hop(-1); 374 if env.limit_backward as i32 > c || c > env.limit as i32 { 375 return false; 376 } 377 env.cursor = c as usize; 378 // ], line 73 379 env.bra = env.cursor; 380 // delete, line 73 381 if !env.slice_del() { 382 return false; 383 } 384 return true; 385 } 386 387 fn r_instrum(env: &mut SnowballEnv, context: &mut Context) -> bool { 388 let mut among_var; 389 // (, line 76 390 // [, line 77 391 env.ket = env.cursor; 392 // substring, line 77 393 among_var = env.find_among_b(A_3, context); 394 if among_var == 0 { 395 return false; 396 } 397 // ], line 77 398 env.bra = env.cursor; 399 // call R1, line 77 400 if !r_R1(env, context) { 401 return false; 402 } 403 if among_var == 0 { 404 return false; 405 } else if among_var == 1 { 406 // (, line 78 407 // call double, line 78 408 if !r_double(env, context) { 409 return false; 410 } 411 } else if among_var == 2 { 412 // (, line 79 413 // call double, line 79 414 if !r_double(env, context) { 415 return false; 416 } 417 } 418 // delete, line 81 419 if !env.slice_del() { 420 return false; 421 } 422 // call undouble, line 82 423 if !r_undouble(env, context) { 424 return false; 425 } 426 return true; 427 } 428 429 fn r_case(env: &mut SnowballEnv, context: &mut Context) -> bool { 430 // (, line 86 431 // [, line 87 432 env.ket = env.cursor; 433 // substring, line 87 434 if env.find_among_b(A_4, context) == 0 { 435 return false; 436 } 437 // ], line 87 438 env.bra = env.cursor; 439 // call R1, line 87 440 if !r_R1(env, context) { 441 return false; 442 } 443 // delete, line 111 444 if !env.slice_del() { 445 return false; 446 } 447 // call v_ending, line 112 448 if !r_v_ending(env, context) { 449 return false; 450 } 451 return true; 452 } 453 454 fn r_case_special(env: &mut SnowballEnv, context: &mut Context) -> bool { 455 let mut among_var; 456 // (, line 115 457 // [, line 116 458 env.ket = env.cursor; 459 // substring, line 116 460 among_var = env.find_among_b(A_5, context); 461 if among_var == 0 { 462 return false; 463 } 464 // ], line 116 465 env.bra = env.cursor; 466 // call R1, line 116 467 if !r_R1(env, context) { 468 return false; 469 } 470 if among_var == 0 { 471 return false; 472 } else if among_var == 1 { 473 // (, line 117 474 // <-, line 117 475 if !env.slice_from("e") { 476 return false; 477 } 478 } else if among_var == 2 { 479 // (, line 118 480 // <-, line 118 481 if !env.slice_from("a") { 482 return false; 483 } 484 } else if among_var == 3 { 485 // (, line 119 486 // <-, line 119 487 if !env.slice_from("a") { 488 return false; 489 } 490 } 491 return true; 492 } 493 494 fn r_case_other(env: &mut SnowballEnv, context: &mut Context) -> bool { 495 let mut among_var; 496 // (, line 123 497 // [, line 124 498 env.ket = env.cursor; 499 // substring, line 124 500 among_var = env.find_among_b(A_6, context); 501 if among_var == 0 { 502 return false; 503 } 504 // ], line 124 505 env.bra = env.cursor; 506 // call R1, line 124 507 if !r_R1(env, context) { 508 return false; 509 } 510 if among_var == 0 { 511 return false; 512 } else if among_var == 1 { 513 // (, line 125 514 // delete, line 125 515 if !env.slice_del() { 516 return false; 517 } 518 } else if among_var == 2 { 519 // (, line 126 520 // delete, line 126 521 if !env.slice_del() { 522 return false; 523 } 524 } else if among_var == 3 { 525 // (, line 127 526 // <-, line 127 527 if !env.slice_from("a") { 528 return false; 529 } 530 } else if among_var == 4 { 531 // (, line 128 532 // <-, line 128 533 if !env.slice_from("e") { 534 return false; 535 } 536 } 537 return true; 538 } 539 540 fn r_factive(env: &mut SnowballEnv, context: &mut Context) -> bool { 541 let mut among_var; 542 // (, line 132 543 // [, line 133 544 env.ket = env.cursor; 545 // substring, line 133 546 among_var = env.find_among_b(A_7, context); 547 if among_var == 0 { 548 return false; 549 } 550 // ], line 133 551 env.bra = env.cursor; 552 // call R1, line 133 553 if !r_R1(env, context) { 554 return false; 555 } 556 if among_var == 0 { 557 return false; 558 } else if among_var == 1 { 559 // (, line 134 560 // call double, line 134 561 if !r_double(env, context) { 562 return false; 563 } 564 } else if among_var == 2 { 565 // (, line 135 566 // call double, line 135 567 if !r_double(env, context) { 568 return false; 569 } 570 } 571 // delete, line 137 572 if !env.slice_del() { 573 return false; 574 } 575 // call undouble, line 138 576 if !r_undouble(env, context) { 577 return false; 578 } 579 return true; 580 } 581 582 fn r_plural(env: &mut SnowballEnv, context: &mut Context) -> bool { 583 let mut among_var; 584 // (, line 141 585 // [, line 142 586 env.ket = env.cursor; 587 // substring, line 142 588 among_var = env.find_among_b(A_8, context); 589 if among_var == 0 { 590 return false; 591 } 592 // ], line 142 593 env.bra = env.cursor; 594 // call R1, line 142 595 if !r_R1(env, context) { 596 return false; 597 } 598 if among_var == 0 { 599 return false; 600 } else if among_var == 1 { 601 // (, line 143 602 // <-, line 143 603 if !env.slice_from("a") { 604 return false; 605 } 606 } else if among_var == 2 { 607 // (, line 144 608 // <-, line 144 609 if !env.slice_from("e") { 610 return false; 611 } 612 } else if among_var == 3 { 613 // (, line 145 614 // delete, line 145 615 if !env.slice_del() { 616 return false; 617 } 618 } else if among_var == 4 { 619 // (, line 146 620 // delete, line 146 621 if !env.slice_del() { 622 return false; 623 } 624 } else if among_var == 5 { 625 // (, line 147 626 // delete, line 147 627 if !env.slice_del() { 628 return false; 629 } 630 } else if among_var == 6 { 631 // (, line 148 632 // delete, line 148 633 if !env.slice_del() { 634 return false; 635 } 636 } else if among_var == 7 { 637 // (, line 149 638 // delete, line 149 639 if !env.slice_del() { 640 return false; 641 } 642 } 643 return true; 644 } 645 646 fn r_owned(env: &mut SnowballEnv, context: &mut Context) -> bool { 647 let mut among_var; 648 // (, line 153 649 // [, line 154 650 env.ket = env.cursor; 651 // substring, line 154 652 among_var = env.find_among_b(A_9, context); 653 if among_var == 0 { 654 return false; 655 } 656 // ], line 154 657 env.bra = env.cursor; 658 // call R1, line 154 659 if !r_R1(env, context) { 660 return false; 661 } 662 if among_var == 0 { 663 return false; 664 } else if among_var == 1 { 665 // (, line 155 666 // delete, line 155 667 if !env.slice_del() { 668 return false; 669 } 670 } else if among_var == 2 { 671 // (, line 156 672 // <-, line 156 673 if !env.slice_from("e") { 674 return false; 675 } 676 } else if among_var == 3 { 677 // (, line 157 678 // <-, line 157 679 if !env.slice_from("a") { 680 return false; 681 } 682 } else if among_var == 4 { 683 // (, line 158 684 // delete, line 158 685 if !env.slice_del() { 686 return false; 687 } 688 } else if among_var == 5 { 689 // (, line 159 690 // <-, line 159 691 if !env.slice_from("e") { 692 return false; 693 } 694 } else if among_var == 6 { 695 // (, line 160 696 // <-, line 160 697 if !env.slice_from("a") { 698 return false; 699 } 700 } else if among_var == 7 { 701 // (, line 161 702 // delete, line 161 703 if !env.slice_del() { 704 return false; 705 } 706 } else if among_var == 8 { 707 // (, line 162 708 // <-, line 162 709 if !env.slice_from("e") { 710 return false; 711 } 712 } else if among_var == 9 { 713 // (, line 163 714 // delete, line 163 715 if !env.slice_del() { 716 return false; 717 } 718 } 719 return true; 720 } 721 722 fn r_sing_owner(env: &mut SnowballEnv, context: &mut Context) -> bool { 723 let mut among_var; 724 // (, line 167 725 // [, line 168 726 env.ket = env.cursor; 727 // substring, line 168 728 among_var = env.find_among_b(A_10, context); 729 if among_var == 0 { 730 return false; 731 } 732 // ], line 168 733 env.bra = env.cursor; 734 // call R1, line 168 735 if !r_R1(env, context) { 736 return false; 737 } 738 if among_var == 0 { 739 return false; 740 } else if among_var == 1 { 741 // (, line 169 742 // delete, line 169 743 if !env.slice_del() { 744 return false; 745 } 746 } else if among_var == 2 { 747 // (, line 170 748 // <-, line 170 749 if !env.slice_from("a") { 750 return false; 751 } 752 } else if among_var == 3 { 753 // (, line 171 754 // <-, line 171 755 if !env.slice_from("e") { 756 return false; 757 } 758 } else if among_var == 4 { 759 // (, line 172 760 // delete, line 172 761 if !env.slice_del() { 762 return false; 763 } 764 } else if among_var == 5 { 765 // (, line 173 766 // <-, line 173 767 if !env.slice_from("a") { 768 return false; 769 } 770 } else if among_var == 6 { 771 // (, line 174 772 // <-, line 174 773 if !env.slice_from("e") { 774 return false; 775 } 776 } else if among_var == 7 { 777 // (, line 175 778 // delete, line 175 779 if !env.slice_del() { 780 return false; 781 } 782 } else if among_var == 8 { 783 // (, line 176 784 // delete, line 176 785 if !env.slice_del() { 786 return false; 787 } 788 } else if among_var == 9 { 789 // (, line 177 790 // delete, line 177 791 if !env.slice_del() { 792 return false; 793 } 794 } else if among_var == 10 { 795 // (, line 178 796 // <-, line 178 797 if !env.slice_from("a") { 798 return false; 799 } 800 } else if among_var == 11 { 801 // (, line 179 802 // <-, line 179 803 if !env.slice_from("e") { 804 return false; 805 } 806 } else if among_var == 12 { 807 // (, line 180 808 // delete, line 180 809 if !env.slice_del() { 810 return false; 811 } 812 } else if among_var == 13 { 813 // (, line 181 814 // delete, line 181 815 if !env.slice_del() { 816 return false; 817 } 818 } else if among_var == 14 { 819 // (, line 182 820 // <-, line 182 821 if !env.slice_from("a") { 822 return false; 823 } 824 } else if among_var == 15 { 825 // (, line 183 826 // <-, line 183 827 if !env.slice_from("e") { 828 return false; 829 } 830 } else if among_var == 16 { 831 // (, line 184 832 // delete, line 184 833 if !env.slice_del() { 834 return false; 835 } 836 } else if among_var == 17 { 837 // (, line 185 838 // delete, line 185 839 if !env.slice_del() { 840 return false; 841 } 842 } else if among_var == 18 { 843 // (, line 186 844 // delete, line 186 845 if !env.slice_del() { 846 return false; 847 } 848 } else if among_var == 19 { 849 // (, line 187 850 // <-, line 187 851 if !env.slice_from("a") { 852 return false; 853 } 854 } else if among_var == 20 { 855 // (, line 188 856 // <-, line 188 857 if !env.slice_from("e") { 858 return false; 859 } 860 } 861 return true; 862 } 863 864 fn r_plur_owner(env: &mut SnowballEnv, context: &mut Context) -> bool { 865 let mut among_var; 866 // (, line 192 867 // [, line 193 868 env.ket = env.cursor; 869 // substring, line 193 870 among_var = env.find_among_b(A_11, context); 871 if among_var == 0 { 872 return false; 873 } 874 // ], line 193 875 env.bra = env.cursor; 876 // call R1, line 193 877 if !r_R1(env, context) { 878 return false; 879 } 880 if among_var == 0 { 881 return false; 882 } else if among_var == 1 { 883 // (, line 194 884 // delete, line 194 885 if !env.slice_del() { 886 return false; 887 } 888 } else if among_var == 2 { 889 // (, line 195 890 // <-, line 195 891 if !env.slice_from("a") { 892 return false; 893 } 894 } else if among_var == 3 { 895 // (, line 196 896 // <-, line 196 897 if !env.slice_from("e") { 898 return false; 899 } 900 } else if among_var == 4 { 901 // (, line 197 902 // delete, line 197 903 if !env.slice_del() { 904 return false; 905 } 906 } else if among_var == 5 { 907 // (, line 198 908 // delete, line 198 909 if !env.slice_del() { 910 return false; 911 } 912 } else if among_var == 6 { 913 // (, line 199 914 // delete, line 199 915 if !env.slice_del() { 916 return false; 917 } 918 } else if among_var == 7 { 919 // (, line 200 920 // <-, line 200 921 if !env.slice_from("a") { 922 return false; 923 } 924 } else if among_var == 8 { 925 // (, line 201 926 // <-, line 201 927 if !env.slice_from("e") { 928 return false; 929 } 930 } else if among_var == 9 { 931 // (, line 202 932 // delete, line 202 933 if !env.slice_del() { 934 return false; 935 } 936 } else if among_var == 10 { 937 // (, line 203 938 // delete, line 203 939 if !env.slice_del() { 940 return false; 941 } 942 } else if among_var == 11 { 943 // (, line 204 944 // delete, line 204 945 if !env.slice_del() { 946 return false; 947 } 948 } else if among_var == 12 { 949 // (, line 205 950 // <-, line 205 951 if !env.slice_from("a") { 952 return false; 953 } 954 } else if among_var == 13 { 955 // (, line 206 956 // <-, line 206 957 if !env.slice_from("e") { 958 return false; 959 } 960 } else if among_var == 14 { 961 // (, line 207 962 // delete, line 207 963 if !env.slice_del() { 964 return false; 965 } 966 } else if among_var == 15 { 967 // (, line 208 968 // delete, line 208 969 if !env.slice_del() { 970 return false; 971 } 972 } else if among_var == 16 { 973 // (, line 209 974 // delete, line 209 975 if !env.slice_del() { 976 return false; 977 } 978 } else if among_var == 17 { 979 // (, line 210 980 // delete, line 210 981 if !env.slice_del() { 982 return false; 983 } 984 } else if among_var == 18 { 985 // (, line 211 986 // <-, line 211 987 if !env.slice_from("a") { 988 return false; 989 } 990 } else if among_var == 19 { 991 // (, line 212 992 // <-, line 212 993 if !env.slice_from("e") { 994 return false; 995 } 996 } else if among_var == 20 { 997 // (, line 214 998 // delete, line 214 999 if !env.slice_del() { 1000 return false; 1001 } 1002 } else if among_var == 21 { 1003 // (, line 215 1004 // delete, line 215 1005 if !env.slice_del() { 1006 return false; 1007 } 1008 } else if among_var == 22 { 1009 // (, line 216 1010 // <-, line 216 1011 if !env.slice_from("a") { 1012 return false; 1013 } 1014 } else if among_var == 23 { 1015 // (, line 217 1016 // <-, line 217 1017 if !env.slice_from("e") { 1018 return false; 1019 } 1020 } else if among_var == 24 { 1021 // (, line 218 1022 // delete, line 218 1023 if !env.slice_del() { 1024 return false; 1025 } 1026 } else if among_var == 25 { 1027 // (, line 219 1028 // delete, line 219 1029 if !env.slice_del() { 1030 return false; 1031 } 1032 } else if among_var == 26 { 1033 // (, line 220 1034 // delete, line 220 1035 if !env.slice_del() { 1036 return false; 1037 } 1038 } else if among_var == 27 { 1039 // (, line 221 1040 // <-, line 221 1041 if !env.slice_from("a") { 1042 return false; 1043 } 1044 } else if among_var == 28 { 1045 // (, line 222 1046 // <-, line 222 1047 if !env.slice_from("e") { 1048 return false; 1049 } 1050 } else if among_var == 29 { 1051 // (, line 223 1052 // delete, line 223 1053 if !env.slice_del() { 1054 return false; 1055 } 1056 } 1057 return true; 1058 } 1059 1060 pub fn stem(env: &mut SnowballEnv) -> bool { 1061 let mut context = &mut Context { 1062 i_p1: 0, 1063 }; 1064 // (, line 228 1065 // do, line 229 1066 let v_1 = env.cursor; 1067 'lab0: loop { 1068 // call mark_regions, line 229 1069 if !r_mark_regions(env, context) { 1070 break 'lab0; 1071 } 1072 break 'lab0; 1073 } 1074 env.cursor = v_1; 1075 // backwards, line 230 1076 env.limit_backward = env.cursor; 1077 env.cursor = env.limit; 1078 // (, line 230 1079 // do, line 231 1080 let v_2 = env.limit - env.cursor; 1081 'lab1: loop { 1082 // call instrum, line 231 1083 if !r_instrum(env, context) { 1084 break 'lab1; 1085 } 1086 break 'lab1; 1087 } 1088 env.cursor = env.limit - v_2; 1089 // do, line 232 1090 let v_3 = env.limit - env.cursor; 1091 'lab2: loop { 1092 // call case, line 232 1093 if !r_case(env, context) { 1094 break 'lab2; 1095 } 1096 break 'lab2; 1097 } 1098 env.cursor = env.limit - v_3; 1099 // do, line 233 1100 let v_4 = env.limit - env.cursor; 1101 'lab3: loop { 1102 // call case_special, line 233 1103 if !r_case_special(env, context) { 1104 break 'lab3; 1105 } 1106 break 'lab3; 1107 } 1108 env.cursor = env.limit - v_4; 1109 // do, line 234 1110 let v_5 = env.limit - env.cursor; 1111 'lab4: loop { 1112 // call case_other, line 234 1113 if !r_case_other(env, context) { 1114 break 'lab4; 1115 } 1116 break 'lab4; 1117 } 1118 env.cursor = env.limit - v_5; 1119 // do, line 235 1120 let v_6 = env.limit - env.cursor; 1121 'lab5: loop { 1122 // call factive, line 235 1123 if !r_factive(env, context) { 1124 break 'lab5; 1125 } 1126 break 'lab5; 1127 } 1128 env.cursor = env.limit - v_6; 1129 // do, line 236 1130 let v_7 = env.limit - env.cursor; 1131 'lab6: loop { 1132 // call owned, line 236 1133 if !r_owned(env, context) { 1134 break 'lab6; 1135 } 1136 break 'lab6; 1137 } 1138 env.cursor = env.limit - v_7; 1139 // do, line 237 1140 let v_8 = env.limit - env.cursor; 1141 'lab7: loop { 1142 // call sing_owner, line 237 1143 if !r_sing_owner(env, context) { 1144 break 'lab7; 1145 } 1146 break 'lab7; 1147 } 1148 env.cursor = env.limit - v_8; 1149 // do, line 238 1150 let v_9 = env.limit - env.cursor; 1151 'lab8: loop { 1152 // call plur_owner, line 238 r_has_min_length(env: &mut SnowballEnv, context: &mut Context) -> bool1153 if !r_plur_owner(env, context) { 1154 break 'lab8; 1155 } 1156 break 'lab8; 1157 } 1158 env.cursor = env.limit - v_9; 1159 // do, line 239 1160 let v_10 = env.limit - env.cursor; r_tolower(env: &mut SnowballEnv, context: &mut Context) -> bool1161 'lab9: loop { 1162 // call plural, line 239 1163 if !r_plural(env, context) { 1164 break 'lab9; 1165 } 1166 break 'lab9; 1167 } 1168 env.cursor = env.limit - v_10; 1169 env.cursor = env.limit_backward; 1170 return true; 1171 } 1172