home | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Lucene example source code file (DutchStemmer.java)

This example Lucene source code file (DutchStemmer.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_e_found, b_e_found, dutchstemmer, i, i_p1, i_p1, i_p2, i_p2, snowballprogram, y

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

        private Among a_0[] = {
            new Among ( "", -1, 6, "", this),
            new Among ( "\u00E1", 0, 1, "", this),
            new Among ( "\u00E4", 0, 1, "", this),
            new Among ( "\u00E9", 0, 2, "", this),
            new Among ( "\u00EB", 0, 2, "", this),
            new Among ( "\u00ED", 0, 3, "", this),
            new Among ( "\u00EF", 0, 3, "", this),
            new Among ( "\u00F3", 0, 4, "", this),
            new Among ( "\u00F6", 0, 4, "", this),
            new Among ( "\u00FA", 0, 5, "", this),
            new Among ( "\u00FC", 0, 5, "", this)
        };

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

        private Among a_2[] = {
            new Among ( "dd", -1, -1, "", this),
            new Among ( "kk", -1, -1, "", this),
            new Among ( "tt", -1, -1, "", this)
        };

        private Among a_3[] = {
            new Among ( "ene", -1, 2, "", this),
            new Among ( "se", -1, 3, "", this),
            new Among ( "en", -1, 2, "", this),
            new Among ( "heden", 2, 1, "", this),
            new Among ( "s", -1, 3, "", this)
        };

        private Among a_4[] = {
            new Among ( "end", -1, 1, "", this),
            new Among ( "ig", -1, 2, "", this),
            new Among ( "ing", -1, 1, "", this),
            new Among ( "lijk", -1, 3, "", this),
            new Among ( "baar", -1, 4, "", this),
            new Among ( "bar", -1, 5, "", this)
        };

        private Among a_5[] = {
            new Among ( "aa", -1, -1, "", this),
            new Among ( "ee", -1, -1, "", this),
            new Among ( "oo", -1, -1, "", this),
            new Among ( "uu", -1, -1, "", this)
        };

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

        private static final char g_v_I[] = {1, 0, 0, 17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128 };

        private static final char g_v_j[] = {17, 67, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128 };

        private int I_p2;
        private int I_p1;
        private boolean B_e_found;

        private void copy_from(DutchStemmer other) {
            I_p2 = other.I_p2;
            I_p1 = other.I_p1;
            B_e_found = other.B_e_found;
            super.copy_from(other);
        }

        private boolean r_prelude() {
            int among_var;
            int v_1;
            int v_2;
            int v_3;
            int v_4;
            int v_5;
            int v_6;
            // (, line 41
            // test, line 42
            v_1 = cursor;
            // repeat, line 42
            replab0: while(true)
            {
                v_2 = cursor;
                lab1: do {
                    // (, line 42
                    // [, line 43
                    bra = cursor;
                    // substring, line 43
                    among_var = find_among(a_0, 11);
                    if (among_var == 0)
                    {
                        break lab1;
                    }
                    // ], line 43
                    ket = cursor;
                    switch(among_var) {
                        case 0:
                            break lab1;
                        case 1:
                            // (, line 45
                            // <-, line 45
                            slice_from("a");
                            break;
                        case 2:
                            // (, line 47
                            // <-, line 47
                            slice_from("e");
                            break;
                        case 3:
                            // (, line 49
                            // <-, line 49
                            slice_from("i");
                            break;
                        case 4:
                            // (, line 51
                            // <-, line 51
                            slice_from("o");
                            break;
                        case 5:
                            // (, line 53
                            // <-, line 53
                            slice_from("u");
                            break;
                        case 6:
                            // (, line 54
                            // next, line 54
                            if (cursor >= limit)
                            {
                                break lab1;
                            }
                            cursor++;
                            break;
                    }
                    continue replab0;
                } while (false);
                cursor = v_2;
                break replab0;
            }
            cursor = v_1;
            // try, line 57
            v_3 = cursor;
            lab2: do {
                // (, line 57
                // [, line 57
                bra = cursor;
                // literal, line 57
                if (!(eq_s(1, "y")))
                {
                    cursor = v_3;
                    break lab2;
                }
                // ], line 57
                ket = cursor;
                // <-, line 57
                slice_from("Y");
            } while (false);
            // repeat, line 58
            replab3: while(true)
            {
                v_4 = cursor;
                lab4: do {
                    // goto, line 58
                    golab5: while(true)
                    {
                        v_5 = cursor;
                        lab6: do {
                            // (, line 58
                            if (!(in_grouping(g_v, 97, 232)))
                            {
                                break lab6;
                            }
                            // [, line 59
                            bra = cursor;
                            // or, line 59
                            lab7: do {
                                v_6 = cursor;
                                lab8: do {
                                    // (, line 59
                                    // literal, line 59
                                    if (!(eq_s(1, "i")))
                                    {
                                        break lab8;
                                    }
                                    // ], line 59
                                    ket = cursor;
                                    if (!(in_grouping(g_v, 97, 232)))
                                    {
                                        break lab8;
                                    }
                                    // <-, line 59
                                    slice_from("I");
                                    break lab7;
                                } while (false);
                                cursor = v_6;
                                // (, line 60
                                // literal, line 60
                                if (!(eq_s(1, "y")))
                                {
                                    break lab6;
                                }
                                // ], line 60
                                ket = cursor;
                                // <-, line 60
                                slice_from("Y");
                            } while (false);
                            cursor = v_5;
                            break golab5;
                        } while (false);
                        cursor = v_5;
                        if (cursor >= limit)
                        {
                            break lab4;
                        }
                        cursor++;
                    }
                    continue replab3;
                } while (false);
                cursor = v_4;
                break replab3;
            }
            return true;
        }

        private boolean r_mark_regions() {
            // (, line 64
            I_p1 = limit;
            I_p2 = limit;
            // gopast, line 69
            golab0: while(true)
            {
                lab1: do {
                    if (!(in_grouping(g_v, 97, 232)))
                    {
                        break lab1;
                    }
                    break golab0;
                } while (false);
                if (cursor >= limit)
                {
                    return false;
                }
                cursor++;
            }
            // gopast, line 69
            golab2: while(true)
            {
                lab3: do {
                    if (!(out_grouping(g_v, 97, 232)))
                    {
                        break lab3;
                    }
                    break golab2;
                } while (false);
                if (cursor >= limit)
                {
                    return false;
                }
                cursor++;
            }
            // setmark p1, line 69
            I_p1 = cursor;
            // try, line 70
            lab4: do {
                // (, line 70
                if (!(I_p1 < 3))
                {
                    break lab4;
                }
                I_p1 = 3;
            } while (false);
            // gopast, line 71
            golab5: while(true)
            {
                lab6: do {
                    if (!(in_grouping(g_v, 97, 232)))
                    {
                        break lab6;
                    }
                    break golab5;
                } while (false);
                if (cursor >= limit)
                {
                    return false;
                }
                cursor++;
            }
            // gopast, line 71
            golab7: while(true)
            {
                lab8: do {
                    if (!(out_grouping(g_v, 97, 232)))
                    {
                        break lab8;
                    }
                    break golab7;
                } while (false);
                if (cursor >= limit)
                {
                    return false;
                }
                cursor++;
            }
            // setmark p2, line 71
            I_p2 = cursor;
            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, 3);
                    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("y");
                            break;
                        case 2:
                            // (, line 79
                            // <-, line 79
                            slice_from("i");
                            break;
                        case 3:
                            // (, line 80
                            // next, line 80
                            if (cursor >= limit)
                            {
                                break lab1;
                            }
                            cursor++;
                            break;
                    }
                    continue replab0;
                } while (false);
                cursor = v_1;
                break replab0;
            }
            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_undouble() {
            int v_1;
            // (, line 90
            // test, line 91
            v_1 = limit - cursor;
            // among, line 91
            if (find_among_b(a_2, 3) == 0)
            {
                return false;
            }
            cursor = limit - v_1;
            // [, line 91
            ket = cursor;
            // next, line 91
            if (cursor <= limit_backward)
            {
                return false;
            }
            cursor--;
            // ], line 91
            bra = cursor;
            // delete, line 91
            slice_del();
            return true;
        }

        private boolean r_e_ending() {
            int v_1;
            // (, line 94
            // unset e_found, line 95
            B_e_found = false;
            // [, line 96
            ket = cursor;
            // literal, line 96
            if (!(eq_s_b(1, "e")))
            {
                return false;
            }
            // ], line 96
            bra = cursor;
            // call R1, line 96
            if (!r_R1())
            {
                return false;
            }
            // test, line 96
            v_1 = limit - cursor;
            if (!(out_grouping_b(g_v, 97, 232)))
            {
                return false;
            }
            cursor = limit - v_1;
            // delete, line 96
            slice_del();
            // set e_found, line 97
            B_e_found = true;
            // call undouble, line 98
            if (!r_undouble())
            {
                return false;
            }
            return true;
        }

        private boolean r_en_ending() {
            int v_1;
            int v_2;
            // (, line 101
            // call R1, line 102
            if (!r_R1())
            {
                return false;
            }
            // and, line 102
            v_1 = limit - cursor;
            if (!(out_grouping_b(g_v, 97, 232)))
            {
                return false;
            }
            cursor = limit - v_1;
            // not, line 102
            {
                v_2 = limit - cursor;
                lab0: do {
                    // literal, line 102
                    if (!(eq_s_b(3, "gem")))
                    {
                        break lab0;
                    }
                    return false;
                } while (false);
                cursor = limit - v_2;
            }
            // delete, line 102
            slice_del();
            // call undouble, line 103
            if (!r_undouble())
            {
                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;
            // (, line 106
            // do, line 107
            v_1 = limit - cursor;
            lab0: do {
                // (, line 107
                // [, line 108
                ket = cursor;
                // substring, line 108
                among_var = find_among_b(a_3, 5);
                if (among_var == 0)
                {
                    break lab0;
                }
                // ], line 108
                bra = cursor;
                switch(among_var) {
                    case 0:
                        break lab0;
                    case 1:
                        // (, line 110
                        // call R1, line 110
                        if (!r_R1())
                        {
                            break lab0;
                        }
                        // <-, line 110
                        slice_from("heid");
                        break;
                    case 2:
                        // (, line 113
                        // call en_ending, line 113
                        if (!r_en_ending())
                        {
                            break lab0;
                        }
                        break;
                    case 3:
                        // (, line 116
                        // call R1, line 116
                        if (!r_R1())
                        {
                            break lab0;
                        }
                        if (!(out_grouping_b(g_v_j, 97, 232)))
                        {
                            break lab0;
                        }
                        // delete, line 116
                        slice_del();
                        break;
                }
            } while (false);
            cursor = limit - v_1;
            // do, line 120
            v_2 = limit - cursor;
            lab1: do {
                // call e_ending, line 120
                if (!r_e_ending())
                {
                    break lab1;
                }
            } while (false);
            cursor = limit - v_2;
            // do, line 122
            v_3 = limit - cursor;
            lab2: do {
                // (, line 122
                // [, line 122
                ket = cursor;
                // literal, line 122
                if (!(eq_s_b(4, "heid")))
                {
                    break lab2;
                }
                // ], line 122
                bra = cursor;
                // call R2, line 122
                if (!r_R2())
                {
                    break lab2;
                }
                // not, line 122
                {
                    v_4 = limit - cursor;
                    lab3: do {
                        // literal, line 122
                        if (!(eq_s_b(1, "c")))
                        {
                            break lab3;
                        }
                        break lab2;
                    } while (false);
                    cursor = limit - v_4;
                }
                // delete, line 122
                slice_del();
                // [, line 123
                ket = cursor;
                // literal, line 123
                if (!(eq_s_b(2, "en")))
                {
                    break lab2;
                }
                // ], line 123
                bra = cursor;
                // call en_ending, line 123
                if (!r_en_ending())
                {
                    break lab2;
                }
            } while (false);
            cursor = limit - v_3;
            // do, line 126
            v_5 = limit - cursor;
            lab4: do {
                // (, line 126
                // [, line 127
                ket = cursor;
                // substring, line 127
                among_var = find_among_b(a_4, 6);
                if (among_var == 0)
                {
                    break lab4;
                }
                // ], line 127
                bra = cursor;
                switch(among_var) {
                    case 0:
                        break lab4;
                    case 1:
                        // (, line 129
                        // call R2, line 129
                        if (!r_R2())
                        {
                            break lab4;
                        }
                        // delete, line 129
                        slice_del();
                        // or, line 130
                        lab5: do {
                            v_6 = limit - cursor;
                            lab6: do {
                                // (, line 130
                                // [, line 130
                                ket = cursor;
                                // literal, line 130
                                if (!(eq_s_b(2, "ig")))
                                {
                                    break lab6;
                                }
                                // ], line 130
                                bra = cursor;
                                // call R2, line 130
                                if (!r_R2())
                                {
                                    break lab6;
                                }
                                // not, line 130
                                {
                                    v_7 = limit - cursor;
                                    lab7: do {
                                        // literal, line 130
                                        if (!(eq_s_b(1, "e")))
                                        {
                                            break lab7;
                                        }
                                        break lab6;
                                    } while (false);
                                    cursor = limit - v_7;
                                }
                                // delete, line 130
                                slice_del();
                                break lab5;
                            } while (false);
                            cursor = limit - v_6;
                            // call undouble, line 130
                            if (!r_undouble())
                            {
                                break lab4;
                            }
                        } while (false);
                        break;
                    case 2:
                        // (, line 133
                        // call R2, line 133
                        if (!r_R2())
                        {
                            break lab4;
                        }
                        // not, line 133
                        {
                            v_8 = limit - cursor;
                            lab8: do {
                                // literal, line 133
                                if (!(eq_s_b(1, "e")))
                                {
                                    break lab8;
                                }
                                break lab4;
                            } while (false);
                            cursor = limit - v_8;
                        }
                        // delete, line 133
                        slice_del();
                        break;
                    case 3:
                        // (, line 136
                        // call R2, line 136
                        if (!r_R2())
                        {
                            break lab4;
                        }
                        // delete, line 136
                        slice_del();
                        // call e_ending, line 136
                        if (!r_e_ending())
                        {
                            break lab4;
                        }
                        break;
                    case 4:
                        // (, line 139
                        // call R2, line 139
                        if (!r_R2())
                        {
                            break lab4;
                        }
                        // delete, line 139
                        slice_del();
                        break;
                    case 5:
                        // (, line 142
                        // call R2, line 142
                        if (!r_R2())
                        {
                            break lab4;
                        }
                        // Boolean test e_found, line 142
                        if (!(B_e_found))
                        {
                            break lab4;
                        }
                        // delete, line 142
                        slice_del();
                        break;
                }
            } while (false);
            cursor = limit - v_5;
            // do, line 146
            v_9 = limit - cursor;
            lab9: do {
                // (, line 146
                if (!(out_grouping_b(g_v_I, 73, 232)))
                {
                    break lab9;
                }
                // test, line 148
                v_10 = limit - cursor;
                // (, line 148
                // among, line 149
                if (find_among_b(a_5, 4) == 0)
                {
                    break lab9;
                }
                if (!(out_grouping_b(g_v, 97, 232)))
                {
                    break lab9;
                }
                cursor = limit - v_10;
                // [, line 152
                ket = cursor;
                // next, line 152
                if (cursor <= limit_backward)
                {
                    break lab9;
                }
                cursor--;
                // ], line 152
                bra = cursor;
                // delete, line 152
                slice_del();
            } while (false);
            cursor = limit - v_9;
            return true;
        }

        public boolean stem() {
            int v_1;
            int v_2;
            int v_3;
            int v_4;
            // (, line 157
            // do, line 159
            v_1 = cursor;
            lab0: do {
                // call prelude, line 159
                if (!r_prelude())
                {
                    break lab0;
                }
            } while (false);
            cursor = v_1;
            // do, line 160
            v_2 = cursor;
            lab1: do {
                // call mark_regions, line 160
                if (!r_mark_regions())
                {
                    break lab1;
                }
            } while (false);
            cursor = v_2;
            // backwards, line 161
            limit_backward = cursor; cursor = limit;
            // do, line 162
            v_3 = limit - cursor;
            lab2: do {
                // call standard_suffix, line 162
                if (!r_standard_suffix())
                {
                    break lab2;
                }
            } while (false);
            cursor = limit - v_3;
            cursor = limit_backward;            // do, line 163
            v_4 = cursor;
            lab3: do {
                // call postlude, line 163
                if (!r_postlude())
                {
                    break lab3;
                }
            } while (false);
            cursor = v_4;
            return true;
        }

}

Other Lucene examples (source code examples)

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



my book on functional programming

 

new blog posts

 

Copyright 1998-2019 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.