alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Lucene example source code file (KpStemmer.java)

This example Lucene source code file (KpStemmer.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Lucene tags/keywords

among, among, b_ge_removed, b_ge_removed, b_stemmed, b_stemmed, b_y_found, ge_removed, i_p1, i_p2, i_x, i_x, s_ch, y

The Lucene KpStemmer.java source code

// This file was generated automatically by the Snowball to Java compiler

package org.tartarus.snowball.ext;
import org.tartarus.snowball.SnowballProgram;
import org.tartarus.snowball.Among;

/**
 * Generated class implementing code defined by a snowball script.
 */
public class KpStemmer extends SnowballProgram {

        private Among a_0[] = {
            new Among ( "nde", -1, 7, "", this),
            new Among ( "en", -1, 6, "", this),
            new Among ( "s", -1, 2, "", this),
            new Among ( "'s", 2, 1, "", this),
            new Among ( "es", 2, 4, "", this),
            new Among ( "ies", 4, 3, "", this),
            new Among ( "aus", 2, 5, "", this)
        };

        private Among a_1[] = {
            new Among ( "de", -1, 5, "", this),
            new Among ( "ge", -1, 2, "", this),
            new Among ( "ische", -1, 4, "", this),
            new Among ( "je", -1, 1, "", this),
            new Among ( "lijke", -1, 3, "", this),
            new Among ( "le", -1, 9, "", this),
            new Among ( "ene", -1, 10, "", this),
            new Among ( "re", -1, 8, "", this),
            new Among ( "se", -1, 7, "", this),
            new Among ( "te", -1, 6, "", this),
            new Among ( "ieve", -1, 11, "", this)
        };

        private Among a_2[] = {
            new Among ( "heid", -1, 3, "", this),
            new Among ( "fie", -1, 7, "", this),
            new Among ( "gie", -1, 8, "", this),
            new Among ( "atie", -1, 1, "", this),
            new Among ( "isme", -1, 5, "", this),
            new Among ( "ing", -1, 5, "", this),
            new Among ( "arij", -1, 6, "", this),
            new Among ( "erij", -1, 5, "", this),
            new Among ( "sel", -1, 3, "", this),
            new Among ( "rder", -1, 4, "", this),
            new Among ( "ster", -1, 3, "", this),
            new Among ( "iteit", -1, 2, "", this),
            new Among ( "dst", -1, 10, "", this),
            new Among ( "tst", -1, 9, "", this)
        };

        private Among a_3[] = {
            new Among ( "end", -1, 10, "", this),
            new Among ( "atief", -1, 2, "", this),
            new Among ( "erig", -1, 10, "", this),
            new Among ( "achtig", -1, 9, "", this),
            new Among ( "ioneel", -1, 1, "", this),
            new Among ( "baar", -1, 3, "", this),
            new Among ( "laar", -1, 5, "", this),
            new Among ( "naar", -1, 4, "", this),
            new Among ( "raar", -1, 6, "", this),
            new Among ( "eriger", -1, 10, "", this),
            new Among ( "achtiger", -1, 9, "", this),
            new Among ( "lijker", -1, 8, "", this),
            new Among ( "tant", -1, 7, "", this),
            new Among ( "erigst", -1, 10, "", this),
            new Among ( "achtigst", -1, 9, "", this),
            new Among ( "lijkst", -1, 8, "", this)
        };

        private Among a_4[] = {
            new Among ( "ig", -1, 1, "", this),
            new Among ( "iger", -1, 1, "", this),
            new Among ( "igst", -1, 1, "", this)
        };

        private Among a_5[] = {
            new Among ( "ft", -1, 2, "", this),
            new Among ( "kt", -1, 1, "", this),
            new Among ( "pt", -1, 3, "", this)
        };

        private Among a_6[] = {
            new Among ( "bb", -1, 1, "", this),
            new Among ( "cc", -1, 2, "", this),
            new Among ( "dd", -1, 3, "", this),
            new Among ( "ff", -1, 4, "", this),
            new Among ( "gg", -1, 5, "", this),
            new Among ( "hh", -1, 6, "", this),
            new Among ( "jj", -1, 7, "", this),
            new Among ( "kk", -1, 8, "", this),
            new Among ( "ll", -1, 9, "", this),
            new Among ( "mm", -1, 10, "", this),
            new Among ( "nn", -1, 11, "", this),
            new Among ( "pp", -1, 12, "", this),
            new Among ( "qq", -1, 13, "", this),
            new Among ( "rr", -1, 14, "", this),
            new Among ( "ss", -1, 15, "", this),
            new Among ( "tt", -1, 16, "", this),
            new Among ( "v", -1, 21, "", this),
            new Among ( "vv", 16, 17, "", this),
            new Among ( "ww", -1, 18, "", this),
            new Among ( "xx", -1, 19, "", this),
            new Among ( "z", -1, 22, "", this),
            new Among ( "zz", 20, 20, "", this)
        };

        private Among a_7[] = {
            new Among ( "d", -1, 1, "", this),
            new Among ( "t", -1, 2, "", this)
        };

        private static final char g_v[] = {17, 65, 16, 1 };

        private static final char g_v_WX[] = {17, 65, 208, 1 };

        private static final char g_AOU[] = {1, 64, 16 };

        private static final char g_AIOU[] = {1, 65, 16 };

        private boolean B_GE_removed;
        private boolean B_stemmed;
        private boolean B_Y_found;
        private int I_p2;
        private int I_p1;
        private int I_x;
        private StringBuilder S_ch = new StringBuilder();

        private void copy_from(KpStemmer other) {
            B_GE_removed = other.B_GE_removed;
            B_stemmed = other.B_stemmed;
            B_Y_found = other.B_Y_found;
            I_p2 = other.I_p2;
            I_p1 = other.I_p1;
            I_x = other.I_x;
            S_ch = other.S_ch;
            super.copy_from(other);
        }

        private boolean r_R1() {
            // (, line 32
            // setmark x, line 32
            I_x = cursor;
            if (!(I_x >= I_p1))
            {
                return false;
            }
            return true;
        }

        private boolean r_R2() {
            // (, line 33
            // setmark x, line 33
            I_x = cursor;
            if (!(I_x >= I_p2))
            {
                return false;
            }
            return true;
        }

        private boolean r_V() {
            int v_1;
            int v_2;
            // test, line 35
            v_1 = limit - cursor;
            // (, line 35
            // or, line 35
            lab0: do {
                v_2 = limit - cursor;
                lab1: do {
                    if (!(in_grouping_b(g_v, 97, 121)))
                    {
                        break lab1;
                    }
                    break lab0;
                } while (false);
                cursor = limit - v_2;
                // literal, line 35
                if (!(eq_s_b(2, "ij")))
                {
                    return false;
                }
            } while (false);
            cursor = limit - v_1;
            return true;
        }

        private boolean r_VX() {
            int v_1;
            int v_2;
            // test, line 36
            v_1 = limit - cursor;
            // (, line 36
            // next, line 36
            if (cursor <= limit_backward)
            {
                return false;
            }
            cursor--;
            // or, line 36
            lab0: do {
                v_2 = limit - cursor;
                lab1: do {
                    if (!(in_grouping_b(g_v, 97, 121)))
                    {
                        break lab1;
                    }
                    break lab0;
                } while (false);
                cursor = limit - v_2;
                // literal, line 36
                if (!(eq_s_b(2, "ij")))
                {
                    return false;
                }
            } while (false);
            cursor = limit - v_1;
            return true;
        }

        private boolean r_C() {
            int v_1;
            int v_2;
            // test, line 37
            v_1 = limit - cursor;
            // (, line 37
            // not, line 37
            {
                v_2 = limit - cursor;
                lab0: do {
                    // literal, line 37
                    if (!(eq_s_b(2, "ij")))
                    {
                        break lab0;
                    }
                    return false;
                } while (false);
                cursor = limit - v_2;
            }
            if (!(out_grouping_b(g_v, 97, 121)))
            {
                return false;
            }
            cursor = limit - v_1;
            return true;
        }

        private boolean r_lengthen_V() {
            int v_1;
            int v_2;
            int v_3;
            int v_4;
            int v_5;
            int v_6;
            int v_7;
            int v_8;
            // do, line 39
            v_1 = limit - cursor;
            lab0: do {
                // (, line 39
                if (!(out_grouping_b(g_v_WX, 97, 121)))
                {
                    break lab0;
                }
                // [, line 40
                ket = cursor;
                // or, line 40
                lab1: do {
                    v_2 = limit - cursor;
                    lab2: do {
                        // (, line 40
                        if (!(in_grouping_b(g_AOU, 97, 117)))
                        {
                            break lab2;
                        }
                        // ], line 40
                        bra = cursor;
                        // test, line 40
                        v_3 = limit - cursor;
                        // (, line 40
                        // or, line 40
                        lab3: do {
                            v_4 = limit - cursor;
                            lab4: do {
                                if (!(out_grouping_b(g_v, 97, 121)))
                                {
                                    break lab4;
                                }
                                break lab3;
                            } while (false);
                            cursor = limit - v_4;
                            // atlimit, line 40
                            if (cursor > limit_backward)
                            {
                                break lab2;
                            }
                        } while (false);
                        cursor = limit - v_3;
                        break lab1;
                    } while (false);
                    cursor = limit - v_2;
                    // (, line 41
                    // literal, line 41
                    if (!(eq_s_b(1, "e")))
                    {
                        break lab0;
                    }
                    // ], line 41
                    bra = cursor;
                    // test, line 41
                    v_5 = limit - cursor;
                    // (, line 41
                    // or, line 41
                    lab5: do {
                        v_6 = limit - cursor;
                        lab6: do {
                            if (!(out_grouping_b(g_v, 97, 121)))
                            {
                                break lab6;
                            }
                            break lab5;
                        } while (false);
                        cursor = limit - v_6;
                        // atlimit, line 41
                        if (cursor > limit_backward)
                        {
                            break lab0;
                        }
                    } while (false);
                    // not, line 42
                    {
                        v_7 = limit - cursor;
                        lab7: do {
                            if (!(in_grouping_b(g_AIOU, 97, 117)))
                            {
                                break lab7;
                            }
                            break lab0;
                        } while (false);
                        cursor = limit - v_7;
                    }
                    // not, line 43
                    {
                        v_8 = limit - cursor;
                        lab8: do {
                            // (, line 43
                            // next, line 43
                            if (cursor <= limit_backward)
                            {
                                break lab8;
                            }
                            cursor--;
                            if (!(in_grouping_b(g_AIOU, 97, 117)))
                            {
                                break lab8;
                            }
                            if (!(out_grouping_b(g_v, 97, 121)))
                            {
                                break lab8;
                            }
                            break lab0;
                        } while (false);
                        cursor = limit - v_8;
                    }
                    cursor = limit - v_5;
                } while (false);
                // -> ch, line 44
                S_ch = slice_to(S_ch);
                // <+ ch, line 44
                {
                    int c = cursor;
                    insert(cursor, cursor, S_ch);
                    cursor = c;
                }
            } while (false);
            cursor = limit - v_1;
            return true;
        }

        private boolean r_Step_1() {
            int among_var;
            int v_1;
            int v_2;
            int v_3;
            int v_4;
            // (, line 48
            // [, line 49
            ket = cursor;
            // among, line 49
            among_var = find_among_b(a_0, 7);
            if (among_var == 0)
            {
                return false;
            }
            // (, line 49
            // ], line 49
            bra = cursor;
            switch(among_var) {
                case 0:
                    return false;
                case 1:
                    // (, line 51
                    // delete, line 51
                    slice_del();
                    break;
                case 2:
                    // (, line 52
                    // call R1, line 52
                    if (!r_R1())
                    {
                        return false;
                    }
                    // not, line 52
                    {
                        v_1 = limit - cursor;
                        lab0: do {
                            // (, line 52
                            // literal, line 52
                            if (!(eq_s_b(1, "t")))
                            {
                                break lab0;
                            }
                            // call R1, line 52
                            if (!r_R1())
                            {
                                break lab0;
                            }
                            return false;
                        } while (false);
                        cursor = limit - v_1;
                    }
                    // call C, line 52
                    if (!r_C())
                    {
                        return false;
                    }
                    // delete, line 52
                    slice_del();
                    break;
                case 3:
                    // (, line 53
                    // call R1, line 53
                    if (!r_R1())
                    {
                        return false;
                    }
                    // <-, line 53
                    slice_from("ie");
                    break;
                case 4:
                    // (, line 55
                    // or, line 55
                    lab1: do {
                        v_2 = limit - cursor;
                        lab2: do {
                            // (, line 55
                            // literal, line 55
                            if (!(eq_s_b(2, "ar")))
                            {
                                break lab2;
                            }
                            // call R1, line 55
                            if (!r_R1())
                            {
                                break lab2;
                            }
                            // call C, line 55
                            if (!r_C())
                            {
                                break lab2;
                            }
                            // ], line 55
                            bra = cursor;
                            // delete, line 55
                            slice_del();
                            // call lengthen_V, line 55
                            if (!r_lengthen_V())
                            {
                                break lab2;
                            }
                            break lab1;
                        } while (false);
                        cursor = limit - v_2;
                        lab3: do {
                            // (, line 56
                            // literal, line 56
                            if (!(eq_s_b(2, "er")))
                            {
                                break lab3;
                            }
                            // call R1, line 56
                            if (!r_R1())
                            {
                                break lab3;
                            }
                            // call C, line 56
                            if (!r_C())
                            {
                                break lab3;
                            }
                            // ], line 56
                            bra = cursor;
                            // delete, line 56
                            slice_del();
                            break lab1;
                        } while (false);
                        cursor = limit - v_2;
                        // (, line 57
                        // call R1, line 57
                        if (!r_R1())
                        {
                            return false;
                        }
                        // call C, line 57
                        if (!r_C())
                        {
                            return false;
                        }
                        // <-, line 57
                        slice_from("e");
                    } while (false);
                    break;
                case 5:
                    // (, line 59
                    // call R1, line 59
                    if (!r_R1())
                    {
                        return false;
                    }
                    // call V, line 59
                    if (!r_V())
                    {
                        return false;
                    }
                    // <-, line 59
                    slice_from("au");
                    break;
                case 6:
                    // (, line 60
                    // or, line 60
                    lab4: do {
                        v_3 = limit - cursor;
                        lab5: do {
                            // (, line 60
                            // literal, line 60
                            if (!(eq_s_b(3, "hed")))
                            {
                                break lab5;
                            }
                            // call R1, line 60
                            if (!r_R1())
                            {
                                break lab5;
                            }
                            // ], line 60
                            bra = cursor;
                            // <-, line 60
                            slice_from("heid");
                            break lab4;
                        } while (false);
                        cursor = limit - v_3;
                        lab6: do {
                            // (, line 61
                            // literal, line 61
                            if (!(eq_s_b(2, "nd")))
                            {
                                break lab6;
                            }
                            // delete, line 61
                            slice_del();
                            break lab4;
                        } while (false);
                        cursor = limit - v_3;
                        lab7: do {
                            // (, line 62
                            // literal, line 62
                            if (!(eq_s_b(1, "d")))
                            {
                                break lab7;
                            }
                            // call R1, line 62
                            if (!r_R1())
                            {
                                break lab7;
                            }
                            // call C, line 62
                            if (!r_C())
                            {
                                break lab7;
                            }
                            // ], line 62
                            bra = cursor;
                            // delete, line 62
                            slice_del();
                            break lab4;
                        } while (false);
                        cursor = limit - v_3;
                        lab8: do {
                            // (, line 63
                            // or, line 63
                            lab9: do {
                                v_4 = limit - cursor;
                                lab10: do {
                                    // literal, line 63
                                    if (!(eq_s_b(1, "i")))
                                    {
                                        break lab10;
                                    }
                                    break lab9;
                                } while (false);
                                cursor = limit - v_4;
                                // literal, line 63
                                if (!(eq_s_b(1, "j")))
                                {
                                    break lab8;
                                }
                            } while (false);
                            // call V, line 63
                            if (!r_V())
                            {
                                break lab8;
                            }
                            // delete, line 63
                            slice_del();
                            break lab4;
                        } while (false);
                        cursor = limit - v_3;
                        // (, line 64
                        // call R1, line 64
                        if (!r_R1())
                        {
                            return false;
                        }
                        // call C, line 64
                        if (!r_C())
                        {
                            return false;
                        }
                        // delete, line 64
                        slice_del();
                        // call lengthen_V, line 64
                        if (!r_lengthen_V())
                        {
                            return false;
                        }
                    } while (false);
                    break;
                case 7:
                    // (, line 65
                    // <-, line 65
                    slice_from("nd");
                    break;
            }
            return true;
        }

        private boolean r_Step_2() {
            int among_var;
            int v_1;
            // (, line 70
            // [, line 71
            ket = cursor;
            // among, line 71
            among_var = find_among_b(a_1, 11);
            if (among_var == 0)
            {
                return false;
            }
            // (, line 71
            // ], line 71
            bra = cursor;
            switch(among_var) {
                case 0:
                    return false;
                case 1:
                    // (, line 72
                    // or, line 72
                    lab0: do {
                        v_1 = limit - cursor;
                        lab1: do {
                            // (, line 72
                            // literal, line 72
                            if (!(eq_s_b(2, "'t")))
                            {
                                break lab1;
                            }
                            // ], line 72
                            bra = cursor;
                            // delete, line 72
                            slice_del();
                            break lab0;
                        } while (false);
                        cursor = limit - v_1;
                        lab2: do {
                            // (, line 73
                            // literal, line 73
                            if (!(eq_s_b(2, "et")))
                            {
                                break lab2;
                            }
                            // ], line 73
                            bra = cursor;
                            // call R1, line 73
                            if (!r_R1())
                            {
                                break lab2;
                            }
                            // call C, line 73
                            if (!r_C())
                            {
                                break lab2;
                            }
                            // delete, line 73
                            slice_del();
                            break lab0;
                        } while (false);
                        cursor = limit - v_1;
                        lab3: do {
                            // (, line 74
                            // literal, line 74
                            if (!(eq_s_b(3, "rnt")))
                            {
                                break lab3;
                            }
                            // ], line 74
                            bra = cursor;
                            // <-, line 74
                            slice_from("rn");
                            break lab0;
                        } while (false);
                        cursor = limit - v_1;
                        lab4: do {
                            // (, line 75
                            // literal, line 75
                            if (!(eq_s_b(1, "t")))
                            {
                                break lab4;
                            }
                            // ], line 75
                            bra = cursor;
                            // call R1, line 75
                            if (!r_R1())
                            {
                                break lab4;
                            }
                            // call VX, line 75
                            if (!r_VX())
                            {
                                break lab4;
                            }
                            // delete, line 75
                            slice_del();
                            break lab0;
                        } while (false);
                        cursor = limit - v_1;
                        lab5: do {
                            // (, line 76
                            // literal, line 76
                            if (!(eq_s_b(3, "ink")))
                            {
                                break lab5;
                            }
                            // ], line 76
                            bra = cursor;
                            // <-, line 76
                            slice_from("ing");
                            break lab0;
                        } while (false);
                        cursor = limit - v_1;
                        lab6: do {
                            // (, line 77
                            // literal, line 77
                            if (!(eq_s_b(2, "mp")))
                            {
                                break lab6;
                            }
                            // ], line 77
                            bra = cursor;
                            // <-, line 77
                            slice_from("m");
                            break lab0;
                        } while (false);
                        cursor = limit - v_1;
                        lab7: do {
                            // (, line 78
                            // literal, line 78
                            if (!(eq_s_b(1, "'")))
                            {
                                break lab7;
                            }
                            // ], line 78
                            bra = cursor;
                            // call R1, line 78
                            if (!r_R1())
                            {
                                break lab7;
                            }
                            // delete, line 78
                            slice_del();
                            break lab0;
                        } while (false);
                        cursor = limit - v_1;
                        // (, line 79
                        // ], line 79
                        bra = cursor;
                        // call R1, line 79
                        if (!r_R1())
                        {
                            return false;
                        }
                        // call C, line 79
                        if (!r_C())
                        {
                            return false;
                        }
                        // delete, line 79
                        slice_del();
                    } while (false);
                    break;
                case 2:
                    // (, line 80
                    // call R1, line 80
                    if (!r_R1())
                    {
                        return false;
                    }
                    // <-, line 80
                    slice_from("g");
                    break;
                case 3:
                    // (, line 81
                    // call R1, line 81
                    if (!r_R1())
                    {
                        return false;
                    }
                    // <-, line 81
                    slice_from("lijk");
                    break;
                case 4:
                    // (, line 82
                    // call R1, line 82
                    if (!r_R1())
                    {
                        return false;
                    }
                    // <-, line 82
                    slice_from("isch");
                    break;
                case 5:
                    // (, line 83
                    // call R1, line 83
                    if (!r_R1())
                    {
                        return false;
                    }
                    // call C, line 83
                    if (!r_C())
                    {
                        return false;
                    }
                    // delete, line 83
                    slice_del();
                    break;
                case 6:
                    // (, line 84
                    // call R1, line 84
                    if (!r_R1())
                    {
                        return false;
                    }
                    // <-, line 84
                    slice_from("t");
                    break;
                case 7:
                    // (, line 85
                    // call R1, line 85
                    if (!r_R1())
                    {
                        return false;
                    }
                    // <-, line 85
                    slice_from("s");
                    break;
                case 8:
                    // (, line 86
                    // call R1, line 86
                    if (!r_R1())
                    {
                        return false;
                    }
                    // <-, line 86
                    slice_from("r");
                    break;
                case 9:
                    // (, line 87
                    // call R1, line 87
                    if (!r_R1())
                    {
                        return false;
                    }
                    // delete, line 87
                    slice_del();
                    // attach, line 87
                    insert(cursor, cursor, "l");
                    // call lengthen_V, line 87
                    if (!r_lengthen_V())
                    {
                        return false;
                    }
                    break;
                case 10:
                    // (, line 88
                    // call R1, line 88
                    if (!r_R1())
                    {
                        return false;
                    }
                    // call C, line 88
                    if (!r_C())
                    {
                        return false;
                    }
                    // delete, line 88
                    slice_del();
                    // attach, line 88
                    insert(cursor, cursor, "en");
                    // call lengthen_V, line 88
                    if (!r_lengthen_V())
                    {
                        return false;
                    }
                    break;
                case 11:
                    // (, line 89
                    // call R1, line 89
                    if (!r_R1())
                    {
                        return false;
                    }
                    // call C, line 89
                    if (!r_C())
                    {
                        return false;
                    }
                    // <-, line 89
                    slice_from("ief");
                    break;
            }
            return true;
        }

        private boolean r_Step_3() {
            int among_var;
            // (, line 94
            // [, line 95
            ket = cursor;
            // among, line 95
            among_var = find_among_b(a_2, 14);
            if (among_var == 0)
            {
                return false;
            }
            // (, line 95
            // ], line 95
            bra = cursor;
            switch(among_var) {
                case 0:
                    return false;
                case 1:
                    // (, line 96
                    // call R1, line 96
                    if (!r_R1())
                    {
                        return false;
                    }
                    // <-, line 96
                    slice_from("eer");
                    break;
                case 2:
                    // (, line 97
                    // call R1, line 97
                    if (!r_R1())
                    {
                        return false;
                    }
                    // delete, line 97
                    slice_del();
                    // call lengthen_V, line 97
                    if (!r_lengthen_V())
                    {
                        return false;
                    }
                    break;
                case 3:
                    // (, line 100
                    // call R1, line 100
                    if (!r_R1())
                    {
                        return false;
                    }
                    // delete, line 100
                    slice_del();
                    break;
                case 4:
                    // (, line 101
                    // <-, line 101
                    slice_from("r");
                    break;
                case 5:
                    // (, line 104
                    // call R1, line 104
                    if (!r_R1())
                    {
                        return false;
                    }
                    // delete, line 104
                    slice_del();
                    // call lengthen_V, line 104
                    if (!r_lengthen_V())
                    {
                        return false;
                    }
                    break;
                case 6:
                    // (, line 105
                    // call R1, line 105
                    if (!r_R1())
                    {
                        return false;
                    }
                    // call C, line 105
                    if (!r_C())
                    {
                        return false;
                    }
                    // <-, line 105
                    slice_from("aar");
                    break;
                case 7:
                    // (, line 106
                    // call R2, line 106
                    if (!r_R2())
                    {
                        return false;
                    }
                    // delete, line 106
                    slice_del();
                    // attach, line 106
                    insert(cursor, cursor, "f");
                    // call lengthen_V, line 106
                    if (!r_lengthen_V())
                    {
                        return false;
                    }
                    break;
                case 8:
                    // (, line 107
                    // call R2, line 107
                    if (!r_R2())
                    {
                        return false;
                    }
                    // delete, line 107
                    slice_del();
                    // attach, line 107
                    insert(cursor, cursor, "g");
                    // call lengthen_V, line 107
                    if (!r_lengthen_V())
                    {
                        return false;
                    }
                    break;
                case 9:
                    // (, line 108
                    // call R1, line 108
                    if (!r_R1())
                    {
                        return false;
                    }
                    // call C, line 108
                    if (!r_C())
                    {
                        return false;
                    }
                    // <-, line 108
                    slice_from("t");
                    break;
                case 10:
                    // (, line 109
                    // call R1, line 109
                    if (!r_R1())
                    {
                        return false;
                    }
                    // call C, line 109
                    if (!r_C())
                    {
                        return false;
                    }
                    // <-, line 109
                    slice_from("d");
                    break;
            }
            return true;
        }

        private boolean r_Step_4() {
            int among_var;
            int v_1;
            // (, line 114
            // or, line 134
            lab0: do {
                v_1 = limit - cursor;
                lab1: do {
                    // (, line 115
                    // [, line 115
                    ket = cursor;
                    // among, line 115
                    among_var = find_among_b(a_3, 16);
                    if (among_var == 0)
                    {
                        break lab1;
                    }
                    // (, line 115
                    // ], line 115
                    bra = cursor;
                    switch(among_var) {
                        case 0:
                            break lab1;
                        case 1:
                            // (, line 116
                            // call R1, line 116
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // <-, line 116
                            slice_from("ie");
                            break;
                        case 2:
                            // (, line 117
                            // call R1, line 117
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // <-, line 117
                            slice_from("eer");
                            break;
                        case 3:
                            // (, line 118
                            // call R1, line 118
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // delete, line 118
                            slice_del();
                            break;
                        case 4:
                            // (, line 119
                            // call R1, line 119
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // call V, line 119
                            if (!r_V())
                            {
                                break lab1;
                            }
                            // <-, line 119
                            slice_from("n");
                            break;
                        case 5:
                            // (, line 120
                            // call R1, line 120
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // call V, line 120
                            if (!r_V())
                            {
                                break lab1;
                            }
                            // <-, line 120
                            slice_from("l");
                            break;
                        case 6:
                            // (, line 121
                            // call R1, line 121
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // call V, line 121
                            if (!r_V())
                            {
                                break lab1;
                            }
                            // <-, line 121
                            slice_from("r");
                            break;
                        case 7:
                            // (, line 122
                            // call R1, line 122
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // <-, line 122
                            slice_from("teer");
                            break;
                        case 8:
                            // (, line 124
                            // call R1, line 124
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // <-, line 124
                            slice_from("lijk");
                            break;
                        case 9:
                            // (, line 127
                            // call R1, line 127
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // delete, line 127
                            slice_del();
                            break;
                        case 10:
                            // (, line 131
                            // call R1, line 131
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            // call C, line 131
                            if (!r_C())
                            {
                                break lab1;
                            }
                            // delete, line 131
                            slice_del();
                            // call lengthen_V, line 131
                            if (!r_lengthen_V())
                            {
                                break lab1;
                            }
                            break;
                    }
                    break lab0;
                } while (false);
                cursor = limit - v_1;
                // (, line 135
                // [, line 135
                ket = cursor;
                // among, line 135
                among_var = find_among_b(a_4, 3);
                if (among_var == 0)
                {
                    return false;
                }
                // (, line 135
                // ], line 135
                bra = cursor;
                switch(among_var) {
                    case 0:
                        return false;
                    case 1:
                        // (, line 138
                        // call R1, line 138
                        if (!r_R1())
                        {
                            return false;
                        }
                        // call C, line 138
                        if (!r_C())
                        {
                            return false;
                        }
                        // delete, line 138
                        slice_del();
                        // call lengthen_V, line 138
                        if (!r_lengthen_V())
                        {
                            return false;
                        }
                        break;
                }
            } while (false);
            return true;
        }

        private boolean r_Step_7() {
            int among_var;
            // (, line 144
            // [, line 145
            ket = cursor;
            // among, line 145
            among_var = find_among_b(a_5, 3);
            if (among_var == 0)
            {
                return false;
            }
            // (, line 145
            // ], line 145
            bra = cursor;
            switch(among_var) {
                case 0:
                    return false;
                case 1:
                    // (, line 146
                    // <-, line 146
                    slice_from("k");
                    break;
                case 2:
                    // (, line 147
                    // <-, line 147
                    slice_from("f");
                    break;
                case 3:
                    // (, line 148
                    // <-, line 148
                    slice_from("p");
                    break;
            }
            return true;
        }

        private boolean r_Step_6() {
            int among_var;
            // (, line 153
            // [, line 154
            ket = cursor;
            // among, line 154
            among_var = find_among_b(a_6, 22);
            if (among_var == 0)
            {
                return false;
            }
            // (, line 154
            // ], line 154
            bra = cursor;
            switch(among_var) {
                case 0:
                    return false;
                case 1:
                    // (, line 155
                    // <-, line 155
                    slice_from("b");
                    break;
                case 2:
                    // (, line 156
                    // <-, line 156
                    slice_from("c");
                    break;
                case 3:
                    // (, line 157
                    // <-, line 157
                    slice_from("d");
                    break;
                case 4:
                    // (, line 158
                    // <-, line 158
                    slice_from("f");
                    break;
                case 5:
                    // (, line 159
                    // <-, line 159
                    slice_from("g");
                    break;
                case 6:
                    // (, line 160
                    // <-, line 160
                    slice_from("h");
                    break;
                case 7:
                    // (, line 161
                    // <-, line 161
                    slice_from("j");
                    break;
                case 8:
                    // (, line 162
                    // <-, line 162
                    slice_from("k");
                    break;
                case 9:
                    // (, line 163
                    // <-, line 163
                    slice_from("l");
                    break;
                case 10:
                    // (, line 164
                    // <-, line 164
                    slice_from("m");
                    break;
                case 11:
                    // (, line 165
                    // <-, line 165
                    slice_from("n");
                    break;
                case 12:
                    // (, line 166
                    // <-, line 166
                    slice_from("p");
                    break;
                case 13:
                    // (, line 167
                    // <-, line 167
                    slice_from("q");
                    break;
                case 14:
                    // (, line 168
                    // <-, line 168
                    slice_from("r");
                    break;
                case 15:
                    // (, line 169
                    // <-, line 169
                    slice_from("s");
                    break;
                case 16:
                    // (, line 170
                    // <-, line 170
                    slice_from("t");
                    break;
                case 17:
                    // (, line 171
                    // <-, line 171
                    slice_from("v");
                    break;
                case 18:
                    // (, line 172
                    // <-, line 172
                    slice_from("w");
                    break;
                case 19:
                    // (, line 173
                    // <-, line 173
                    slice_from("x");
                    break;
                case 20:
                    // (, line 174
                    // <-, line 174
                    slice_from("z");
                    break;
                case 21:
                    // (, line 175
                    // <-, line 175
                    slice_from("f");
                    break;
                case 22:
                    // (, line 176
                    // <-, line 176
                    slice_from("s");
                    break;
            }
            return true;
        }

        private boolean r_Step_1c() {
            int among_var;
            int v_1;
            int v_2;
            // (, line 181
            // [, line 182
            ket = cursor;
            // among, line 182
            among_var = find_among_b(a_7, 2);
            if (among_var == 0)
            {
                return false;
            }
            // (, line 182
            // ], line 182
            bra = cursor;
            // call R1, line 182
            if (!r_R1())
            {
                return false;
            }
            // call C, line 182
            if (!r_C())
            {
                return false;
            }
            switch(among_var) {
                case 0:
                    return false;
                case 1:
                    // (, line 183
                    // not, line 183
                    {
                        v_1 = limit - cursor;
                        lab0: do {
                            // (, line 183
                            // literal, line 183
                            if (!(eq_s_b(1, "n")))
                            {
                                break lab0;
                            }
                            // call R1, line 183
                            if (!r_R1())
                            {
                                break lab0;
                            }
                            return false;
                        } while (false);
                        cursor = limit - v_1;
                    }
                    // delete, line 183
                    slice_del();
                    break;
                case 2:
                    // (, line 184
                    // not, line 184
                    {
                        v_2 = limit - cursor;
                        lab1: do {
                            // (, line 184
                            // literal, line 184
                            if (!(eq_s_b(1, "h")))
                            {
                                break lab1;
                            }
                            // call R1, line 184
                            if (!r_R1())
                            {
                                break lab1;
                            }
                            return false;
                        } while (false);
                        cursor = limit - v_2;
                    }
                    // delete, line 184
                    slice_del();
                    break;
            }
            return true;
        }

        private boolean r_Lose_prefix() {
            int v_1;
            int v_2;
            int v_3;
            // (, line 189
            // [, line 190
            bra = cursor;
            // literal, line 190
            if (!(eq_s(2, "ge")))
            {
                return false;
            }
            // ], line 190
            ket = cursor;
            // test, line 190
            v_1 = cursor;
            // hop, line 190
            {
                int c = cursor + 3;
                if (0 > c || c > limit)
                {
                    return false;
                }
                cursor = c;
            }
            cursor = v_1;
            // (, line 190
            // goto, line 190
            golab0: while(true)
            {
                v_2 = cursor;
                lab1: do {
                    if (!(in_grouping(g_v, 97, 121)))
                    {
                        break lab1;
                    }
                    cursor = v_2;
                    break golab0;
                } while (false);
                cursor = v_2;
                if (cursor >= limit)
                {
                    return false;
                }
                cursor++;
            }
            // goto, line 190
            golab2: while(true)
            {
                v_3 = cursor;
                lab3: do {
                    if (!(out_grouping(g_v, 97, 121)))
                    {
                        break lab3;
                    }
                    cursor = v_3;
                    break golab2;
                } while (false);
                cursor = v_3;
                if (cursor >= limit)
                {
                    return false;
                }
                cursor++;
            }
            // set GE_removed, line 191
            B_GE_removed = true;
            // delete, line 192
            slice_del();
            return true;
        }

        private boolean r_Lose_infix() {
            int v_2;
            int v_3;
            int v_4;
            // (, line 195
            // next, line 196
            if (cursor >= limit)
            {
                return false;
            }
            cursor++;
            // gopast, line 197
            golab0: while(true)
            {
                lab1: do {
                    // (, line 197
                    // [, line 197
                    bra = cursor;
                    // literal, line 197
                    if (!(eq_s(2, "ge")))
                    {
                        break lab1;
                    }
                    // ], line 197
                    ket = cursor;
                    break golab0;
                } while (false);
                if (cursor >= limit)
                {
                    return false;
                }
                cursor++;
            }
            // test, line 197
            v_2 = cursor;
            // hop, line 197
            {
                int c = cursor + 3;
                if (0 > c || c > limit)
                {
                    return false;
                }
                cursor = c;
            }
            cursor = v_2;
            // (, line 197
            // goto, line 197
            golab2: while(true)
            {
                v_3 = cursor;
                lab3: do {
                    if (!(in_grouping(g_v, 97, 121)))
                    {
                        break lab3;
                    }
                    cursor = v_3;
                    break golab2;
                } while (false);
                cursor = v_3;
                if (cursor >= limit)
                {
                    return false;
                }
                cursor++;
            }
            // goto, line 197
            golab4: while(true)
            {
                v_4 = cursor;
                lab5: do {
                    if (!(out_grouping(g_v, 97, 121)))
                    {
                        break lab5;
                    }
                    cursor = v_4;
                    break golab4;
                } while (false);
                cursor = v_4;
                if (cursor >= limit)
                {
                    return false;
                }
                cursor++;
            }
            // set GE_removed, line 198
            B_GE_removed = true;
            // delete, line 199
            slice_del();
            return true;
        }

        private boolean r_measure() {
            int v_1;
            int v_2;
            int v_5;
            int v_6;
            int v_9;
            int v_10;
            // (, line 202
            // do, line 203
            v_1 = cursor;
            lab0: do {
                // (, line 203
                // tolimit, line 204
                cursor = limit;
                // setmark p1, line 205
                I_p1 = cursor;
                // setmark p2, line 206
                I_p2 = cursor;
            } while (false);
            cursor = v_1;
            // do, line 208
            v_2 = cursor;
            lab1: do {
                // (, line 208
                // repeat, line 209
                replab2: while(true)
                {
                    lab3: do {
                        if (!(out_grouping(g_v, 97, 121)))
                        {
                            break lab3;
                        }
                        continue replab2;
                    } while (false);
                    break replab2;
                }
                // atleast, line 209
                {
                    int v_4 = 1;
                    // atleast, line 209
                    replab4: while(true)
                    {
                        v_5 = cursor;
                        lab5: do {
                            // (, line 209
                            // or, line 209
                            lab6: do {
                                v_6 = cursor;
                                lab7: do {
                                    // literal, line 209
                                    if (!(eq_s(2, "ij")))
                                    {
                                        break lab7;
                                    }
                                    break lab6;
                                } while (false);
                                cursor = v_6;
                                if (!(in_grouping(g_v, 97, 121)))
                                {
                                    break lab5;
                                }
                            } while (false);
                            v_4--;
                            continue replab4;
                        } while (false);
                        cursor = v_5;
                        break replab4;
                    }
                    if (v_4 > 0)
                    {
                        break lab1;
                    }
                }
                if (!(out_grouping(g_v, 97, 121)))
                {
                    break lab1;
                }
                // setmark p1, line 209
                I_p1 = cursor;
                // repeat, line 210
                replab8: while(true)
                {
                    lab9: do {
                        if (!(out_grouping(g_v, 97, 121)))
                        {
                            break lab9;
                        }
                        continue replab8;
                    } while (false);
                    break replab8;
                }
                // atleast, line 210
                {
                    int v_8 = 1;
                    // atleast, line 210
                    replab10: while(true)
                    {
                        v_9 = cursor;
                        lab11: do {
                            // (, line 210
                            // or, line 210
                            lab12: do {
                                v_10 = cursor;
                                lab13: do {
                                    // literal, line 210
                                    if (!(eq_s(2, "ij")))
                                    {
                                        break lab13;
                                    }
                                    break lab12;
                                } while (false);
                                cursor = v_10;
                                if (!(in_grouping(g_v, 97, 121)))
                                {
                                    break lab11;
                                }
                            } while (false);
                            v_8--;
                            continue replab10;
                        } while (false);
                        cursor = v_9;
                        break replab10;
                    }
                    if (v_8 > 0)
                    {
                        break lab1;
                    }
                }
                if (!(out_grouping(g_v, 97, 121)))
                {
                    break lab1;
                }
                // setmark p2, line 210
                I_p2 = cursor;
            } while (false);
            cursor = v_2;
            return true;
        }

        public boolean stem() {
            int v_1;
            int v_2;
            int v_3;
            int v_4;
            int v_5;
            int v_6;
            int v_7;
            int v_8;
            int v_9;
            int v_10;
            int v_11;
            int v_12;
            int v_13;
            int v_14;
            int v_15;
            int v_16;
            int v_18;
            int v_19;
            int v_20;
            // (, line 214
            // unset Y_found, line 216
            B_Y_found = false;
            // unset stemmed, line 217
            B_stemmed = false;
            // do, line 218
            v_1 = cursor;
            lab0: do {
                // (, line 218
                // [, line 218
                bra = cursor;
                // literal, line 218
                if (!(eq_s(1, "y")))
                {
                    break lab0;
                }
                // ], line 218
                ket = cursor;
                // <-, line 218
                slice_from("Y");
                // set Y_found, line 218
                B_Y_found = true;
            } while (false);
            cursor = v_1;
            // do, line 219
            v_2 = cursor;
            lab1: do {
                // repeat, line 219
                replab2: while(true)
                {
                    v_3 = cursor;
                    lab3: do {
                        // (, line 219
                        // goto, line 219
                        golab4: while(true)
                        {
                            v_4 = cursor;
                            lab5: do {
                                // (, line 219
                                if (!(in_grouping(g_v, 97, 121)))
                                {
                                    break lab5;
                                }
                                // [, line 219
                                bra = cursor;
                                // literal, line 219
                                if (!(eq_s(1, "y")))
                                {
                                    break lab5;
                                }
                                // ], line 219
                                ket = cursor;
                                cursor = v_4;
                                break golab4;
                            } while (false);
                            cursor = v_4;
                            if (cursor >= limit)
                            {
                                break lab3;
                            }
                            cursor++;
                        }
                        // <-, line 219
                        slice_from("Y");
                        // set Y_found, line 219
                        B_Y_found = true;
                        continue replab2;
                    } while (false);
                    cursor = v_3;
                    break replab2;
                }
            } while (false);
            cursor = v_2;
            // call measure, line 221
            if (!r_measure())
            {
                return false;
            }
            // backwards, line 223
            limit_backward = cursor; cursor = limit;
            // (, line 223
            // do, line 224
            v_5 = limit - cursor;
            lab6: do {
                // (, line 224
                // call Step_1, line 224
                if (!r_Step_1())
                {
                    break lab6;
                }
                // set stemmed, line 224
                B_stemmed = true;
            } while (false);
            cursor = limit - v_5;
            // do, line 225
            v_6 = limit - cursor;
            lab7: do {
                // (, line 225
                // call Step_2, line 225
                if (!r_Step_2())
                {
                    break lab7;
                }
                // set stemmed, line 225
                B_stemmed = true;
            } while (false);
            cursor = limit - v_6;
            // do, line 226
            v_7 = limit - cursor;
            lab8: do {
                // (, line 226
                // call Step_3, line 226
                if (!r_Step_3())
                {
                    break lab8;
                }
                // set stemmed, line 226
                B_stemmed = true;
            } while (false);
            cursor = limit - v_7;
            // do, line 227
            v_8 = limit - cursor;
            lab9: do {
                // (, line 227
                // call Step_4, line 227
                if (!r_Step_4())
                {
                    break lab9;
                }
                // set stemmed, line 227
                B_stemmed = true;
            } while (false);
            cursor = limit - v_8;
            cursor = limit_backward;            // unset GE_removed, line 229
            B_GE_removed = false;
            // do, line 230
            v_9 = cursor;
            lab10: do {
                // (, line 230
                // and, line 230
                v_10 = cursor;
                // call Lose_prefix, line 230
                if (!r_Lose_prefix())
                {
                    break lab10;
                }
                cursor = v_10;
                // call measure, line 230
                if (!r_measure())
                {
                    break lab10;
                }
            } while (false);
            cursor = v_9;
            // backwards, line 231
            limit_backward = cursor; cursor = limit;
            // (, line 231
            // do, line 232
            v_11 = limit - cursor;
            lab11: do {
                // (, line 232
                // Boolean test GE_removed, line 232
                if (!(B_GE_removed))
                {
                    break lab11;
                }
                // call Step_1c, line 232
                if (!r_Step_1c())
                {
                    break lab11;
                }
            } while (false);
            cursor = limit - v_11;
            cursor = limit_backward;            // unset GE_removed, line 234
            B_GE_removed = false;
            // do, line 235
            v_12 = cursor;
            lab12: do {
                // (, line 235
                // and, line 235
                v_13 = cursor;
                // call Lose_infix, line 235
                if (!r_Lose_infix())
                {
                    break lab12;
                }
                cursor = v_13;
                // call measure, line 235
                if (!r_measure())
                {
                    break lab12;
                }
            } while (false);
            cursor = v_12;
            // backwards, line 236
            limit_backward = cursor; cursor = limit;
            // (, line 236
            // do, line 237
            v_14 = limit - cursor;
            lab13: do {
                // (, line 237
                // Boolean test GE_removed, line 237
                if (!(B_GE_removed))
                {
                    break lab13;
                }
                // call Step_1c, line 237
                if (!r_Step_1c())
                {
                    break lab13;
                }
            } while (false);
            cursor = limit - v_14;
            cursor = limit_backward;            // backwards, line 239
            limit_backward = cursor; cursor = limit;
            // (, line 239
            // do, line 240
            v_15 = limit - cursor;
            lab14: do {
                // (, line 240
                // call Step_7, line 240
                if (!r_Step_7())
                {
                    break lab14;
                }
                // set stemmed, line 240
                B_stemmed = true;
            } while (false);
            cursor = limit - v_15;
            // do, line 241
            v_16 = limit - cursor;
            lab15: do {
                // (, line 241
                // or, line 241
                lab16: do {
                    lab17: do {
                        // Boolean test stemmed, line 241
                        if (!(B_stemmed))
                        {
                            break lab17;
                        }
                        break lab16;
                    } while (false);
                    // Boolean test GE_removed, line 241
                    if (!(B_GE_removed))
                    {
                        break lab15;
                    }
                } while (false);
                // call Step_6, line 241
                if (!r_Step_6())
                {
                    break lab15;
                }
            } while (false);
            cursor = limit - v_16;
            cursor = limit_backward;            // do, line 243
            v_18 = cursor;
            lab18: do {
                // (, line 243
                // Boolean test Y_found, line 243
                if (!(B_Y_found))
                {
                    break lab18;
                }
                // repeat, line 243
                replab19: while(true)
                {
                    v_19 = cursor;
                    lab20: do {
                        // (, line 243
                        // goto, line 243
                        golab21: while(true)
                        {
                            v_20 = cursor;
                            lab22: do {
                                // (, line 243
                                // [, line 243
                                bra = cursor;
                                // literal, line 243
                                if (!(eq_s(1, "Y")))
                                {
                                    break lab22;
                                }
                                // ], line 243
                                ket = cursor;
                                cursor = v_20;
                                break golab21;
                            } while (false);
                            cursor = v_20;
                            if (cursor >= limit)
                            {
                                break lab20;
                            }
                            cursor++;
                        }
                        // <-, line 243
                        slice_from("y");
                        continue replab19;
                    } while (false);
                    cursor = v_19;
                    break replab19;
                }
            } while (false);
            cursor = v_18;
            return true;
        }

}

Other Lucene examples (source code examples)

Here is a short list of links related to this Lucene KpStemmer.java source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.