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

Lucene example source code file (FrenchStemmer.java)

This example Lucene source code file (FrenchStemmer.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, frenchstemmer, i, i\u00e8r, i_p1, i_p1, i_p2, i_p2, i_pv, i_pv, snowballprogram, u, y

The Lucene FrenchStemmer.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 FrenchStemmer extends SnowballProgram {

        private Among a_0[] = {
            new Among ( "col", -1, -1, "", this),
            new Among ( "par", -1, -1, "", this),
            new Among ( "tap", -1, -1, "", this)
        };

        private Among a_1[] = {
            new Among ( "", -1, 4, "", this),
            new Among ( "I", 0, 1, "", this),
            new Among ( "U", 0, 2, "", this),
            new Among ( "Y", 0, 3, "", this)
        };

        private Among a_2[] = {
            new Among ( "iqU", -1, 3, "", this),
            new Among ( "abl", -1, 3, "", this),
            new Among ( "I\u00E8r", -1, 4, "", this),
            new Among ( "i\u00E8r", -1, 4, "", this),
            new Among ( "eus", -1, 2, "", this),
            new Among ( "iv", -1, 1, "", this)
        };

        private Among a_3[] = {
            new Among ( "ic", -1, 2, "", this),
            new Among ( "abil", -1, 1, "", this),
            new Among ( "iv", -1, 3, "", this)
        };

        private Among a_4[] = {
            new Among ( "iqUe", -1, 1, "", this),
            new Among ( "atrice", -1, 2, "", this),
            new Among ( "ance", -1, 1, "", this),
            new Among ( "ence", -1, 5, "", this),
            new Among ( "logie", -1, 3, "", this),
            new Among ( "able", -1, 1, "", this),
            new Among ( "isme", -1, 1, "", this),
            new Among ( "euse", -1, 11, "", this),
            new Among ( "iste", -1, 1, "", this),
            new Among ( "ive", -1, 8, "", this),
            new Among ( "if", -1, 8, "", this),
            new Among ( "usion", -1, 4, "", this),
            new Among ( "ation", -1, 2, "", this),
            new Among ( "ution", -1, 4, "", this),
            new Among ( "ateur", -1, 2, "", this),
            new Among ( "iqUes", -1, 1, "", this),
            new Among ( "atrices", -1, 2, "", this),
            new Among ( "ances", -1, 1, "", this),
            new Among ( "ences", -1, 5, "", this),
            new Among ( "logies", -1, 3, "", this),
            new Among ( "ables", -1, 1, "", this),
            new Among ( "ismes", -1, 1, "", this),
            new Among ( "euses", -1, 11, "", this),
            new Among ( "istes", -1, 1, "", this),
            new Among ( "ives", -1, 8, "", this),
            new Among ( "ifs", -1, 8, "", this),
            new Among ( "usions", -1, 4, "", this),
            new Among ( "ations", -1, 2, "", this),
            new Among ( "utions", -1, 4, "", this),
            new Among ( "ateurs", -1, 2, "", this),
            new Among ( "ments", -1, 15, "", this),
            new Among ( "ements", 30, 6, "", this),
            new Among ( "issements", 31, 12, "", this),
            new Among ( "it\u00E9s", -1, 7, "", this),
            new Among ( "ment", -1, 15, "", this),
            new Among ( "ement", 34, 6, "", this),
            new Among ( "issement", 35, 12, "", this),
            new Among ( "amment", 34, 13, "", this),
            new Among ( "emment", 34, 14, "", this),
            new Among ( "aux", -1, 10, "", this),
            new Among ( "eaux", 39, 9, "", this),
            new Among ( "eux", -1, 1, "", this),
            new Among ( "it\u00E9", -1, 7, "", this)
        };

        private Among a_5[] = {
            new Among ( "ira", -1, 1, "", this),
            new Among ( "ie", -1, 1, "", this),
            new Among ( "isse", -1, 1, "", this),
            new Among ( "issante", -1, 1, "", this),
            new Among ( "i", -1, 1, "", this),
            new Among ( "irai", 4, 1, "", this),
            new Among ( "ir", -1, 1, "", this),
            new Among ( "iras", -1, 1, "", this),
            new Among ( "ies", -1, 1, "", this),
            new Among ( "\u00EEmes", -1, 1, "", this),
            new Among ( "isses", -1, 1, "", this),
            new Among ( "issantes", -1, 1, "", this),
            new Among ( "\u00EEtes", -1, 1, "", this),
            new Among ( "is", -1, 1, "", this),
            new Among ( "irais", 13, 1, "", this),
            new Among ( "issais", 13, 1, "", this),
            new Among ( "irions", -1, 1, "", this),
            new Among ( "issions", -1, 1, "", this),
            new Among ( "irons", -1, 1, "", this),
            new Among ( "issons", -1, 1, "", this),
            new Among ( "issants", -1, 1, "", this),
            new Among ( "it", -1, 1, "", this),
            new Among ( "irait", 21, 1, "", this),
            new Among ( "issait", 21, 1, "", this),
            new Among ( "issant", -1, 1, "", this),
            new Among ( "iraIent", -1, 1, "", this),
            new Among ( "issaIent", -1, 1, "", this),
            new Among ( "irent", -1, 1, "", this),
            new Among ( "issent", -1, 1, "", this),
            new Among ( "iront", -1, 1, "", this),
            new Among ( "\u00EEt", -1, 1, "", this),
            new Among ( "iriez", -1, 1, "", this),
            new Among ( "issiez", -1, 1, "", this),
            new Among ( "irez", -1, 1, "", this),
            new Among ( "issez", -1, 1, "", this)
        };

        private Among a_6[] = {
            new Among ( "a", -1, 3, "", this),
            new Among ( "era", 0, 2, "", this),
            new Among ( "asse", -1, 3, "", this),
            new Among ( "ante", -1, 3, "", this),
            new Among ( "\u00E9e", -1, 2, "", this),
            new Among ( "ai", -1, 3, "", this),
            new Among ( "erai", 5, 2, "", this),
            new Among ( "er", -1, 2, "", this),
            new Among ( "as", -1, 3, "", this),
            new Among ( "eras", 8, 2, "", this),
            new Among ( "\u00E2mes", -1, 3, "", this),
            new Among ( "asses", -1, 3, "", this),
            new Among ( "antes", -1, 3, "", this),
            new Among ( "\u00E2tes", -1, 3, "", this),
            new Among ( "\u00E9es", -1, 2, "", this),
            new Among ( "ais", -1, 3, "", this),
            new Among ( "erais", 15, 2, "", this),
            new Among ( "ions", -1, 1, "", this),
            new Among ( "erions", 17, 2, "", this),
            new Among ( "assions", 17, 3, "", this),
            new Among ( "erons", -1, 2, "", this),
            new Among ( "ants", -1, 3, "", this),
            new Among ( "\u00E9s", -1, 2, "", this),
            new Among ( "ait", -1, 3, "", this),
            new Among ( "erait", 23, 2, "", this),
            new Among ( "ant", -1, 3, "", this),
            new Among ( "aIent", -1, 3, "", this),
            new Among ( "eraIent", 26, 2, "", this),
            new Among ( "\u00E8rent", -1, 2, "", this),
            new Among ( "assent", -1, 3, "", this),
            new Among ( "eront", -1, 2, "", this),
            new Among ( "\u00E2t", -1, 3, "", this),
            new Among ( "ez", -1, 2, "", this),
            new Among ( "iez", 32, 2, "", this),
            new Among ( "eriez", 33, 2, "", this),
            new Among ( "assiez", 33, 3, "", this),
            new Among ( "erez", 32, 2, "", this),
            new Among ( "\u00E9", -1, 2, "", this)
        };

        private Among a_7[] = {
            new Among ( "e", -1, 3, "", this),
            new Among ( "I\u00E8re", 0, 2, "", this),
            new Among ( "i\u00E8re", 0, 2, "", this),
            new Among ( "ion", -1, 1, "", this),
            new Among ( "Ier", -1, 2, "", this),
            new Among ( "ier", -1, 2, "", this),
            new Among ( "\u00EB", -1, 4, "", this)
        };

        private Among a_8[] = {
            new Among ( "ell", -1, -1, "", this),
            new Among ( "eill", -1, -1, "", this),
            new Among ( "enn", -1, -1, "", this),
            new Among ( "onn", -1, -1, "", this),
            new Among ( "ett", -1, -1, "", this)
        };

        private static final char g_v[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 130, 103, 8, 5 };

        private static final char g_keep_with_s[] = {1, 65, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128 };

        private int I_p2;
        private int I_p1;
        private int I_pV;

        private void copy_from(FrenchStemmer other) {
            I_p2 = other.I_p2;
            I_p1 = other.I_p1;
            I_pV = other.I_pV;
            super.copy_from(other);
        }

        private boolean r_prelude() {
            int v_1;
            int v_2;
            int v_3;
            int v_4;
            // repeat, line 38
            replab0: while(true)
            {
                v_1 = cursor;
                lab1: do {
                    // goto, line 38
                    golab2: while(true)
                    {
                        v_2 = cursor;
                        lab3: do {
                            // (, line 38
                            // or, line 44
                            lab4: do {
                                v_3 = cursor;
                                lab5: do {
                                    // (, line 40
                                    if (!(in_grouping(g_v, 97, 251)))
                                    {
                                        break lab5;
                                    }
                                    // [, line 40
                                    bra = cursor;
                                    // or, line 40
                                    lab6: do {
                                        v_4 = cursor;
                                        lab7: do {
                                            // (, line 40
                                            // literal, line 40
                                            if (!(eq_s(1, "u")))
                                            {
                                                break lab7;
                                            }
                                            // ], line 40
                                            ket = cursor;
                                            if (!(in_grouping(g_v, 97, 251)))
                                            {
                                                break lab7;
                                            }
                                            // <-, line 40
                                            slice_from("U");
                                            break lab6;
                                        } while (false);
                                        cursor = v_4;
                                        lab8: do {
                                            // (, line 41
                                            // literal, line 41
                                            if (!(eq_s(1, "i")))
                                            {
                                                break lab8;
                                            }
                                            // ], line 41
                                            ket = cursor;
                                            if (!(in_grouping(g_v, 97, 251)))
                                            {
                                                break lab8;
                                            }
                                            // <-, line 41
                                            slice_from("I");
                                            break lab6;
                                        } while (false);
                                        cursor = v_4;
                                        // (, line 42
                                        // literal, line 42
                                        if (!(eq_s(1, "y")))
                                        {
                                            break lab5;
                                        }
                                        // ], line 42
                                        ket = cursor;
                                        // <-, line 42
                                        slice_from("Y");
                                    } while (false);
                                    break lab4;
                                } while (false);
                                cursor = v_3;
                                lab9: do {
                                    // (, line 45
                                    // [, line 45
                                    bra = cursor;
                                    // literal, line 45
                                    if (!(eq_s(1, "y")))
                                    {
                                        break lab9;
                                    }
                                    // ], line 45
                                    ket = cursor;
                                    if (!(in_grouping(g_v, 97, 251)))
                                    {
                                        break lab9;
                                    }
                                    // <-, line 45
                                    slice_from("Y");
                                    break lab4;
                                } while (false);
                                cursor = v_3;
                                // (, line 47
                                // literal, line 47
                                if (!(eq_s(1, "q")))
                                {
                                    break lab3;
                                }
                                // [, line 47
                                bra = cursor;
                                // literal, line 47
                                if (!(eq_s(1, "u")))
                                {
                                    break lab3;
                                }
                                // ], line 47
                                ket = cursor;
                                // <-, line 47
                                slice_from("U");
                            } while (false);
                            cursor = v_2;
                            break golab2;
                        } while (false);
                        cursor = v_2;
                        if (cursor >= limit)
                        {
                            break lab1;
                        }
                        cursor++;
                    }
                    continue replab0;
                } while (false);
                cursor = v_1;
                break replab0;
            }
            return true;
        }

        private boolean r_mark_regions() {
            int v_1;
            int v_2;
            int v_4;
            // (, line 50
            I_pV = limit;
            I_p1 = limit;
            I_p2 = limit;
            // do, line 56
            v_1 = cursor;
            lab0: do {
                // (, line 56
                // or, line 58
                lab1: do {
                    v_2 = cursor;
                    lab2: do {
                        // (, line 57
                        if (!(in_grouping(g_v, 97, 251)))
                        {
                            break lab2;
                        }
                        if (!(in_grouping(g_v, 97, 251)))
                        {
                            break lab2;
                        }
                        // next, line 57
                        if (cursor >= limit)
                        {
                            break lab2;
                        }
                        cursor++;
                        break lab1;
                    } while (false);
                    cursor = v_2;
                    lab3: do {
                        // among, line 59
                        if (find_among(a_0, 3) == 0)
                        {
                            break lab3;
                        }
                        break lab1;
                    } while (false);
                    cursor = v_2;
                    // (, line 66
                    // next, line 66
                    if (cursor >= limit)
                    {
                        break lab0;
                    }
                    cursor++;
                    // gopast, line 66
                    golab4: while(true)
                    {
                        lab5: do {
                            if (!(in_grouping(g_v, 97, 251)))
                            {
                                break lab5;
                            }
                            break golab4;
                        } while (false);
                        if (cursor >= limit)
                        {
                            break lab0;
                        }
                        cursor++;
                    }
                } while (false);
                // setmark pV, line 67
                I_pV = cursor;
            } while (false);
            cursor = v_1;
            // do, line 69
            v_4 = cursor;
            lab6: do {
                // (, line 69
                // gopast, line 70
                golab7: while(true)
                {
                    lab8: do {
                        if (!(in_grouping(g_v, 97, 251)))
                        {
                            break lab8;
                        }
                        break golab7;
                    } while (false);
                    if (cursor >= limit)
                    {
                        break lab6;
                    }
                    cursor++;
                }
                // gopast, line 70
                golab9: while(true)
                {
                    lab10: do {
                        if (!(out_grouping(g_v, 97, 251)))
                        {
                            break lab10;
                        }
                        break golab9;
                    } while (false);
                    if (cursor >= limit)
                    {
                        break lab6;
                    }
                    cursor++;
                }
                // setmark p1, line 70
                I_p1 = cursor;
                // gopast, line 71
                golab11: while(true)
                {
                    lab12: do {
                        if (!(in_grouping(g_v, 97, 251)))
                        {
                            break lab12;
                        }
                        break golab11;
                    } while (false);
                    if (cursor >= limit)
                    {
                        break lab6;
                    }
                    cursor++;
                }
                // gopast, line 71
                golab13: while(true)
                {
                    lab14: do {
                        if (!(out_grouping(g_v, 97, 251)))
                        {
                            break lab14;
                        }
                        break golab13;
                    } while (false);
                    if (cursor >= limit)
                    {
                        break lab6;
                    }
                    cursor++;
                }
                // setmark p2, line 71
                I_p2 = cursor;
            } while (false);
            cursor = v_4;
            return true;
        }

        private boolean r_postlude() {
            int among_var;
            int v_1;
            // repeat, line 75
            replab0: while(true)
            {
                v_1 = cursor;
                lab1: do {
                    // (, line 75
                    // [, line 77
                    bra = cursor;
                    // substring, line 77
                    among_var = find_among(a_1, 4);
                    if (among_var == 0)
                    {
                        break lab1;
                    }
                    // ], line 77
                    ket = cursor;
                    switch(among_var) {
                        case 0:
                            break lab1;
                        case 1:
                            // (, line 78
                            // <-, line 78
                            slice_from("i");
                            break;
                        case 2:
                            // (, line 79
                            // <-, line 79
                            slice_from("u");
                            break;
                        case 3:
                            // (, line 80
                            // <-, line 80
                            slice_from("y");
                            break;
                        case 4:
                            // (, line 81
                            // next, line 81
                            if (cursor >= limit)
                            {
                                break lab1;
                            }
                            cursor++;
                            break;
                    }
                    continue replab0;
                } while (false);
                cursor = v_1;
                break replab0;
            }
            return true;
        }

        private boolean r_RV() {
            if (!(I_pV <= cursor))
            {
                return false;
            }
            return true;
        }

        private boolean r_R1() {
            if (!(I_p1 <= cursor))
            {
                return false;
            }
            return true;
        }

        private boolean r_R2() {
            if (!(I_p2 <= cursor))
            {
                return false;
            }
            return true;
        }

        private boolean r_standard_suffix() {
            int among_var;
            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;
            // (, line 91
            // [, line 92
            ket = cursor;
            // substring, line 92
            among_var = find_among_b(a_4, 43);
            if (among_var == 0)
            {
                return false;
            }
            // ], line 92
            bra = cursor;
            switch(among_var) {
                case 0:
                    return false;
                case 1:
                    // (, line 96
                    // call R2, line 96
                    if (!r_R2())
                    {
                        return false;
                    }
                    // delete, line 96
                    slice_del();
                    break;
                case 2:
                    // (, line 99
                    // call R2, line 99
                    if (!r_R2())
                    {
                        return false;
                    }
                    // delete, line 99
                    slice_del();
                    // try, line 100
                    v_1 = limit - cursor;
                    lab0: do {
                        // (, line 100
                        // [, line 100
                        ket = cursor;
                        // literal, line 100
                        if (!(eq_s_b(2, "ic")))
                        {
                            cursor = limit - v_1;
                            break lab0;
                        }
                        // ], line 100
                        bra = cursor;
                        // or, line 100
                        lab1: do {
                            v_2 = limit - cursor;
                            lab2: do {
                                // (, line 100
                                // call R2, line 100
                                if (!r_R2())
                                {
                                    break lab2;
                                }
                                // delete, line 100
                                slice_del();
                                break lab1;
                            } while (false);
                            cursor = limit - v_2;
                            // <-, line 100
                            slice_from("iqU");
                        } while (false);
                    } while (false);
                    break;
                case 3:
                    // (, line 104
                    // call R2, line 104
                    if (!r_R2())
                    {
                        return false;
                    }
                    // <-, line 104
                    slice_from("log");
                    break;
                case 4:
                    // (, line 107
                    // call R2, line 107
                    if (!r_R2())
                    {
                        return false;
                    }
                    // <-, line 107
                    slice_from("u");
                    break;
                case 5:
                    // (, line 110
                    // call R2, line 110
                    if (!r_R2())
                    {
                        return false;
                    }
                    // <-, line 110
                    slice_from("ent");
                    break;
                case 6:
                    // (, line 113
                    // call RV, line 114
                    if (!r_RV())
                    {
                        return false;
                    }
                    // delete, line 114
                    slice_del();
                    // try, line 115
                    v_3 = limit - cursor;
                    lab3: do {
                        // (, line 115
                        // [, line 116
                        ket = cursor;
                        // substring, line 116
                        among_var = find_among_b(a_2, 6);
                        if (among_var == 0)
                        {
                            cursor = limit - v_3;
                            break lab3;
                        }
                        // ], line 116
                        bra = cursor;
                        switch(among_var) {
                            case 0:
                                cursor = limit - v_3;
                                break lab3;
                            case 1:
                                // (, line 117
                                // call R2, line 117
                                if (!r_R2())
                                {
                                    cursor = limit - v_3;
                                    break lab3;
                                }
                                // delete, line 117
                                slice_del();
                                // [, line 117
                                ket = cursor;
                                // literal, line 117
                                if (!(eq_s_b(2, "at")))
                                {
                                    cursor = limit - v_3;
                                    break lab3;
                                }
                                // ], line 117
                                bra = cursor;
                                // call R2, line 117
                                if (!r_R2())
                                {
                                    cursor = limit - v_3;
                                    break lab3;
                                }
                                // delete, line 117
                                slice_del();
                                break;
                            case 2:
                                // (, line 118
                                // or, line 118
                                lab4: do {
                                    v_4 = limit - cursor;
                                    lab5: do {
                                        // (, line 118
                                        // call R2, line 118
                                        if (!r_R2())
                                        {
                                            break lab5;
                                        }
                                        // delete, line 118
                                        slice_del();
                                        break lab4;
                                    } while (false);
                                    cursor = limit - v_4;
                                    // (, line 118
                                    // call R1, line 118
                                    if (!r_R1())
                                    {
                                        cursor = limit - v_3;
                                        break lab3;
                                    }
                                    // <-, line 118
                                    slice_from("eux");
                                } while (false);
                                break;
                            case 3:
                                // (, line 120
                                // call R2, line 120
                                if (!r_R2())
                                {
                                    cursor = limit - v_3;
                                    break lab3;
                                }
                                // delete, line 120
                                slice_del();
                                break;
                            case 4:
                                // (, line 122
                                // call RV, line 122
                                if (!r_RV())
                                {
                                    cursor = limit - v_3;
                                    break lab3;
                                }
                                // <-, line 122
                                slice_from("i");
                                break;
                        }
                    } while (false);
                    break;
                case 7:
                    // (, line 128
                    // call R2, line 129
                    if (!r_R2())
                    {
                        return false;
                    }
                    // delete, line 129
                    slice_del();
                    // try, line 130
                    v_5 = limit - cursor;
                    lab6: do {
                        // (, line 130
                        // [, line 131
                        ket = cursor;
                        // substring, line 131
                        among_var = find_among_b(a_3, 3);
                        if (among_var == 0)
                        {
                            cursor = limit - v_5;
                            break lab6;
                        }
                        // ], line 131
                        bra = cursor;
                        switch(among_var) {
                            case 0:
                                cursor = limit - v_5;
                                break lab6;
                            case 1:
                                // (, line 132
                                // or, line 132
                                lab7: do {
                                    v_6 = limit - cursor;
                                    lab8: do {
                                        // (, line 132
                                        // call R2, line 132
                                        if (!r_R2())
                                        {
                                            break lab8;
                                        }
                                        // delete, line 132
                                        slice_del();
                                        break lab7;
                                    } while (false);
                                    cursor = limit - v_6;
                                    // <-, line 132
                                    slice_from("abl");
                                } while (false);
                                break;
                            case 2:
                                // (, line 133
                                // or, line 133
                                lab9: do {
                                    v_7 = limit - cursor;
                                    lab10: do {
                                        // (, line 133
                                        // call R2, line 133
                                        if (!r_R2())
                                        {
                                            break lab10;
                                        }
                                        // delete, line 133
                                        slice_del();
                                        break lab9;
                                    } while (false);
                                    cursor = limit - v_7;
                                    // <-, line 133
                                    slice_from("iqU");
                                } while (false);
                                break;
                            case 3:
                                // (, line 134
                                // call R2, line 134
                                if (!r_R2())
                                {
                                    cursor = limit - v_5;
                                    break lab6;
                                }
                                // delete, line 134
                                slice_del();
                                break;
                        }
                    } while (false);
                    break;
                case 8:
                    // (, line 140
                    // call R2, line 141
                    if (!r_R2())
                    {
                        return false;
                    }
                    // delete, line 141
                    slice_del();
                    // try, line 142
                    v_8 = limit - cursor;
                    lab11: do {
                        // (, line 142
                        // [, line 142
                        ket = cursor;
                        // literal, line 142
                        if (!(eq_s_b(2, "at")))
                        {
                            cursor = limit - v_8;
                            break lab11;
                        }
                        // ], line 142
                        bra = cursor;
                        // call R2, line 142
                        if (!r_R2())
                        {
                            cursor = limit - v_8;
                            break lab11;
                        }
                        // delete, line 142
                        slice_del();
                        // [, line 142
                        ket = cursor;
                        // literal, line 142
                        if (!(eq_s_b(2, "ic")))
                        {
                            cursor = limit - v_8;
                            break lab11;
                        }
                        // ], line 142
                        bra = cursor;
                        // or, line 142
                        lab12: do {
                            v_9 = limit - cursor;
                            lab13: do {
                                // (, line 142
                                // call R2, line 142
                                if (!r_R2())
                                {
                                    break lab13;
                                }
                                // delete, line 142
                                slice_del();
                                break lab12;
                            } while (false);
                            cursor = limit - v_9;
                            // <-, line 142
                            slice_from("iqU");
                        } while (false);
                    } while (false);
                    break;
                case 9:
                    // (, line 144
                    // <-, line 144
                    slice_from("eau");
                    break;
                case 10:
                    // (, line 145
                    // call R1, line 145
                    if (!r_R1())
                    {
                        return false;
                    }
                    // <-, line 145
                    slice_from("al");
                    break;
                case 11:
                    // (, line 147
                    // or, line 147
                    lab14: do {
                        v_10 = limit - cursor;
                        lab15: do {
                            // (, line 147
                            // call R2, line 147
                            if (!r_R2())
                            {
                                break lab15;
                            }
                            // delete, line 147
                            slice_del();
                            break lab14;
                        } while (false);
                        cursor = limit - v_10;
                        // (, line 147
                        // call R1, line 147
                        if (!r_R1())
                        {
                            return false;
                        }
                        // <-, line 147
                        slice_from("eux");
                    } while (false);
                    break;
                case 12:
                    // (, line 150
                    // call R1, line 150
                    if (!r_R1())
                    {
                        return false;
                    }
                    if (!(out_grouping_b(g_v, 97, 251)))
                    {
                        return false;
                    }
                    // delete, line 150
                    slice_del();
                    break;
                case 13:
                    // (, line 155
                    // call RV, line 155
                    if (!r_RV())
                    {
                        return false;
                    }
                    // fail, line 155
                    // (, line 155
                    // <-, line 155
                    slice_from("ant");
                    return false;
                case 14:
                    // (, line 156
                    // call RV, line 156
                    if (!r_RV())
                    {
                        return false;
                    }
                    // fail, line 156
                    // (, line 156
                    // <-, line 156
                    slice_from("ent");
                    return false;
                case 15:
                    // (, line 158
                    // test, line 158
                    v_11 = limit - cursor;
                    // (, line 158
                    if (!(in_grouping_b(g_v, 97, 251)))
                    {
                        return false;
                    }
                    // call RV, line 158
                    if (!r_RV())
                    {
                        return false;
                    }
                    cursor = limit - v_11;
                    // fail, line 158
                    // (, line 158
                    // delete, line 158
                    slice_del();
                    return false;
            }
            return true;
        }

        private boolean r_i_verb_suffix() {
            int among_var;
            int v_1;
            int v_2;
            // setlimit, line 163
            v_1 = limit - cursor;
            // tomark, line 163
            if (cursor < I_pV)
            {
                return false;
            }
            cursor = I_pV;
            v_2 = limit_backward;
            limit_backward = cursor;
            cursor = limit - v_1;
            // (, line 163
            // [, line 164
            ket = cursor;
            // substring, line 164
            among_var = find_among_b(a_5, 35);
            if (among_var == 0)
            {
                limit_backward = v_2;
                return false;
            }
            // ], line 164
            bra = cursor;
            switch(among_var) {
                case 0:
                    limit_backward = v_2;
                    return false;
                case 1:
                    // (, line 170
                    if (!(out_grouping_b(g_v, 97, 251)))
                    {
                        limit_backward = v_2;
                        return false;
                    }
                    // delete, line 170
                    slice_del();
                    break;
            }
            limit_backward = v_2;
            return true;
        }

        private boolean r_verb_suffix() {
            int among_var;
            int v_1;
            int v_2;
            int v_3;
            // setlimit, line 174
            v_1 = limit - cursor;
            // tomark, line 174
            if (cursor < I_pV)
            {
                return false;
            }
            cursor = I_pV;
            v_2 = limit_backward;
            limit_backward = cursor;
            cursor = limit - v_1;
            // (, line 174
            // [, line 175
            ket = cursor;
            // substring, line 175
            among_var = find_among_b(a_6, 38);
            if (among_var == 0)
            {
                limit_backward = v_2;
                return false;
            }
            // ], line 175
            bra = cursor;
            switch(among_var) {
                case 0:
                    limit_backward = v_2;
                    return false;
                case 1:
                    // (, line 177
                    // call R2, line 177
                    if (!r_R2())
                    {
                        limit_backward = v_2;
                        return false;
                    }
                    // delete, line 177
                    slice_del();
                    break;
                case 2:
                    // (, line 185
                    // delete, line 185
                    slice_del();
                    break;
                case 3:
                    // (, line 190
                    // delete, line 190
                    slice_del();
                    // try, line 191
                    v_3 = limit - cursor;
                    lab0: do {
                        // (, line 191
                        // [, line 191
                        ket = cursor;
                        // literal, line 191
                        if (!(eq_s_b(1, "e")))
                        {
                            cursor = limit - v_3;
                            break lab0;
                        }
                        // ], line 191
                        bra = cursor;
                        // delete, line 191
                        slice_del();
                    } while (false);
                    break;
            }
            limit_backward = v_2;
            return true;
        }

        private boolean r_residual_suffix() {
            int among_var;
            int v_1;
            int v_2;
            int v_3;
            int v_4;
            int v_5;
            // (, line 198
            // try, line 199
            v_1 = limit - cursor;
            lab0: do {
                // (, line 199
                // [, line 199
                ket = cursor;
                // literal, line 199
                if (!(eq_s_b(1, "s")))
                {
                    cursor = limit - v_1;
                    break lab0;
                }
                // ], line 199
                bra = cursor;
                // test, line 199
                v_2 = limit - cursor;
                if (!(out_grouping_b(g_keep_with_s, 97, 232)))
                {
                    cursor = limit - v_1;
                    break lab0;
                }
                cursor = limit - v_2;
                // delete, line 199
                slice_del();
            } while (false);
            // setlimit, line 200
            v_3 = limit - cursor;
            // tomark, line 200
            if (cursor < I_pV)
            {
                return false;
            }
            cursor = I_pV;
            v_4 = limit_backward;
            limit_backward = cursor;
            cursor = limit - v_3;
            // (, line 200
            // [, line 201
            ket = cursor;
            // substring, line 201
            among_var = find_among_b(a_7, 7);
            if (among_var == 0)
            {
                limit_backward = v_4;
                return false;
            }
            // ], line 201
            bra = cursor;
            switch(among_var) {
                case 0:
                    limit_backward = v_4;
                    return false;
                case 1:
                    // (, line 202
                    // call R2, line 202
                    if (!r_R2())
                    {
                        limit_backward = v_4;
                        return false;
                    }
                    // or, line 202
                    lab1: do {
                        v_5 = limit - cursor;
                        lab2: do {
                            // literal, line 202
                            if (!(eq_s_b(1, "s")))
                            {
                                break lab2;
                            }
                            break lab1;
                        } while (false);
                        cursor = limit - v_5;
                        // literal, line 202
                        if (!(eq_s_b(1, "t")))
                        {
                            limit_backward = v_4;
                            return false;
                        }
                    } while (false);
                    // delete, line 202
                    slice_del();
                    break;
                case 2:
                    // (, line 204
                    // <-, line 204
                    slice_from("i");
                    break;
                case 3:
                    // (, line 205
                    // delete, line 205
                    slice_del();
                    break;
                case 4:
                    // (, line 206
                    // literal, line 206
                    if (!(eq_s_b(2, "gu")))
                    {
                        limit_backward = v_4;
                        return false;
                    }
                    // delete, line 206
                    slice_del();
                    break;
            }
            limit_backward = v_4;
            return true;
        }

        private boolean r_un_double() {
            int v_1;
            // (, line 211
            // test, line 212
            v_1 = limit - cursor;
            // among, line 212
            if (find_among_b(a_8, 5) == 0)
            {
                return false;
            }
            cursor = limit - v_1;
            // [, line 212
            ket = cursor;
            // next, line 212
            if (cursor <= limit_backward)
            {
                return false;
            }
            cursor--;
            // ], line 212
            bra = cursor;
            // delete, line 212
            slice_del();
            return true;
        }

        private boolean r_un_accent() {
            int v_3;
            // (, line 215
            // atleast, line 216
            {
                int v_1 = 1;
                // atleast, line 216
                replab0: while(true)
                {
                    lab1: do {
                        if (!(out_grouping_b(g_v, 97, 251)))
                        {
                            break lab1;
                        }
                        v_1--;
                        continue replab0;
                    } while (false);
                    break replab0;
                }
                if (v_1 > 0)
                {
                    return false;
                }
            }
            // [, line 217
            ket = cursor;
            // or, line 217
            lab2: do {
                v_3 = limit - cursor;
                lab3: do {
                    // literal, line 217
                    if (!(eq_s_b(1, "\u00E9")))
                    {
                        break lab3;
                    }
                    break lab2;
                } while (false);
                cursor = limit - v_3;
                // literal, line 217
                if (!(eq_s_b(1, "\u00E8")))
                {
                    return false;
                }
            } while (false);
            // ], line 217
            bra = cursor;
            // <-, line 217
            slice_from("e");
            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;
            // (, line 221
            // do, line 223
            v_1 = cursor;
            lab0: do {
                // call prelude, line 223
                if (!r_prelude())
                {
                    break lab0;
                }
            } while (false);
            cursor = v_1;
            // do, line 224
            v_2 = cursor;
            lab1: do {
                // call mark_regions, line 224
                if (!r_mark_regions())
                {
                    break lab1;
                }
            } while (false);
            cursor = v_2;
            // backwards, line 225
            limit_backward = cursor; cursor = limit;
            // (, line 225
            // do, line 227
            v_3 = limit - cursor;
            lab2: do {
                // (, line 227
                // or, line 237
                lab3: do {
                    v_4 = limit - cursor;
                    lab4: do {
                        // (, line 228
                        // and, line 233
                        v_5 = limit - cursor;
                        // (, line 229
                        // or, line 229
                        lab5: do {
                            v_6 = limit - cursor;
                            lab6: do {
                                // call standard_suffix, line 229
                                if (!r_standard_suffix())
                                {
                                    break lab6;
                                }
                                break lab5;
                            } while (false);
                            cursor = limit - v_6;
                            lab7: do {
                                // call i_verb_suffix, line 230
                                if (!r_i_verb_suffix())
                                {
                                    break lab7;
                                }
                                break lab5;
                            } while (false);
                            cursor = limit - v_6;
                            // call verb_suffix, line 231
                            if (!r_verb_suffix())
                            {
                                break lab4;
                            }
                        } while (false);
                        cursor = limit - v_5;
                        // try, line 234
                        v_7 = limit - cursor;
                        lab8: do {
                            // (, line 234
                            // [, line 234
                            ket = cursor;
                            // or, line 234
                            lab9: do {
                                v_8 = limit - cursor;
                                lab10: do {
                                    // (, line 234
                                    // literal, line 234
                                    if (!(eq_s_b(1, "Y")))
                                    {
                                        break lab10;
                                    }
                                    // ], line 234
                                    bra = cursor;
                                    // <-, line 234
                                    slice_from("i");
                                    break lab9;
                                } while (false);
                                cursor = limit - v_8;
                                // (, line 235
                                // literal, line 235
                                if (!(eq_s_b(1, "\u00E7")))
                                {
                                    cursor = limit - v_7;
                                    break lab8;
                                }
                                // ], line 235
                                bra = cursor;
                                // <-, line 235
                                slice_from("c");
                            } while (false);
                        } while (false);
                        break lab3;
                    } while (false);
                    cursor = limit - v_4;
                    // call residual_suffix, line 238
                    if (!r_residual_suffix())
                    {
                        break lab2;
                    }
                } while (false);
            } while (false);
            cursor = limit - v_3;
            // do, line 243
            v_9 = limit - cursor;
            lab11: do {
                // call un_double, line 243
                if (!r_un_double())
                {
                    break lab11;
                }
            } while (false);
            cursor = limit - v_9;
            // do, line 244
            v_10 = limit - cursor;
            lab12: do {
                // call un_accent, line 244
                if (!r_un_accent())
                {
                    break lab12;
                }
            } while (false);
            cursor = limit - v_10;
            cursor = limit_backward;            // do, line 246
            v_11 = cursor;
            lab13: do {
                // call postlude, line 246
                if (!r_postlude())
                {
                    break lab13;
                }
            } while (false);
            cursor = v_11;
            return true;
        }

}

Other Lucene examples (source code examples)

Here is a short list of links related to this Lucene FrenchStemmer.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.