lovinsstemmer.java

MG4J (Managing Gigabytes for Java) is a free full-text search engine for large document collections

                    new Among ( "icianry", 229, 1, "r_A", methodObject ),
                    new Among ( "atory", 229, 1, "r_A", methodObject ),
                    new Among ( "ity", 229, 1, "r_A", methodObject ),
                    new Among ( "acity", 276, 1, "r_A", methodObject ),
                    new Among ( "icity", 276, 1, "r_A", methodObject ),
                    new Among ( "eity", 276, 1, "r_A", methodObject ),
                    new Among ( "ality", 276, 1, "r_A", methodObject ),
                    new Among ( "icality", 280, 1, "r_A", methodObject ),
                    new Among ( "iality", 280, 1, "r_A", methodObject ),
                    new Among ( "antiality", 282, 1, "r_A", methodObject ),
                    new Among ( "entiality", 282, 1, "r_A", methodObject ),
                    new Among ( "ionality", 280, 1, "r_A", methodObject ),
                    new Among ( "elity", 276, 1, "r_A", methodObject ),
                    new Among ( "ability", 276, 1, "r_A", methodObject ),
                    new Among ( "izability", 287, 1, "r_A", methodObject ),
                    new Among ( "arizability", 288, 1, "r_A", methodObject ),
                    new Among ( "ibility", 276, 1, "r_A", methodObject ),
                    new Among ( "inity", 276, 1, "r_CC", methodObject ),
                    new Among ( "arity", 276, 1, "r_B", methodObject ),
                    new Among ( "ivity", 276, 1, "r_A", methodObject )
                };

                private final static Among a_2[] = {
                    new Among ( "bb", -1, -1, "", methodObject ),
                    new Among ( "dd", -1, -1, "", methodObject ),
                    new Among ( "gg", -1, -1, "", methodObject ),
                    new Among ( "ll", -1, -1, "", methodObject ),
                    new Among ( "mm", -1, -1, "", methodObject ),
                    new Among ( "nn", -1, -1, "", methodObject ),
                    new Among ( "pp", -1, -1, "", methodObject ),
                    new Among ( "rr", -1, -1, "", methodObject ),
                    new Among ( "ss", -1, -1, "", methodObject ),
                    new Among ( "tt", -1, -1, "", methodObject )
                };

                private final static Among a_3[] = {
                    new Among ( "uad", -1, 18, "", methodObject ),
                    new Among ( "vad", -1, 19, "", methodObject ),
                    new Among ( "cid", -1, 20, "", methodObject ),
                    new Among ( "lid", -1, 21, "", methodObject ),
                    new Among ( "erid", -1, 22, "", methodObject ),
                    new Among ( "pand", -1, 23, "", methodObject ),
                    new Among ( "end", -1, 24, "", methodObject ),
                    new Among ( "ond", -1, 25, "", methodObject ),
                    new Among ( "lud", -1, 26, "", methodObject ),
                    new Among ( "rud", -1, 27, "", methodObject ),
                    new Among ( "ul", -1, 9, "", methodObject ),
                    new Among ( "her", -1, 28, "", methodObject ),
                    new Among ( "metr", -1, 7, "", methodObject ),
                    new Among ( "istr", -1, 6, "", methodObject ),
                    new Among ( "urs", -1, 5, "", methodObject ),
                    new Among ( "uct", -1, 2, "", methodObject ),
                    new Among ( "et", -1, 32, "", methodObject ),
                    new Among ( "mit", -1, 29, "", methodObject ),
                    new Among ( "ent", -1, 30, "", methodObject ),
                    new Among ( "umpt", -1, 3, "", methodObject ),
                    new Among ( "rpt", -1, 4, "", methodObject ),
                    new Among ( "ert", -1, 31, "", methodObject ),
                    new Among ( "yt", -1, 33, "", methodObject ),
                    new Among ( "iev", -1, 1, "", methodObject ),
                    new Among ( "olv", -1, 8, "", methodObject ),
                    new Among ( "ax", -1, 14, "", methodObject ),
                    new Among ( "ex", -1, 15, "", methodObject ),
                    new Among ( "bex", 26, 10, "", methodObject ),
                    new Among ( "dex", 26, 11, "", methodObject ),
                    new Among ( "pex", 26, 12, "", methodObject ),
                    new Among ( "tex", 26, 13, "", methodObject ),
                    new Among ( "ix", -1, 16, "", methodObject ),
                    new Among ( "lux", -1, 17, "", methodObject ),
                    new Among ( "yz", -1, 34, "", methodObject )
                };



                private boolean r_A() {
                    // (, line 21
                    // hop, line 21
                    {
                        int c = cursor - 2;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    return true;
                }

                private boolean r_B() {
                    // (, line 22
                    // hop, line 22
                    {
                        int c = cursor - 3;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    return true;
                }

                private boolean r_C() {
                    // (, line 23
                    // hop, line 23
                    {
                        int c = cursor - 4;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    return true;
                }

                private boolean r_D() {
                    // (, line 24
                    // hop, line 24
                    {
                        int c = cursor - 5;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    return true;
                }

                private boolean r_E() {
            int v_1;
            int v_2;
                    // (, line 25
                    // test, line 25
                    v_1 = limit - cursor;
                    // hop, line 25
                    {
                        int c = cursor - 2;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    cursor = limit - v_1;
                    // not, line 25
                    {
                        v_2 = limit - cursor;
                        lab0: do {
                            // literal, line 25
                            if (!(eq_s_b(1, "e")))
                            {
                                break lab0;
                            }
                            return false;
                        } while (false);
                        cursor = limit - v_2;
                    }
                    return true;
                }

                private boolean r_F() {
            int v_1;
            int v_2;
                    // (, line 26
                    // test, line 26
                    v_1 = limit - cursor;
                    // hop, line 26
                    {
                        int c = cursor - 3;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    cursor = limit - v_1;
                    // not, line 26
                    {
                        v_2 = limit - cursor;
                        lab0: do {
                            // literal, line 26
                            if (!(eq_s_b(1, "e")))
                            {
                                break lab0;
                            }
                            return false;
                        } while (false);
                        cursor = limit - v_2;
                    }
                    return true;
                }

                private boolean r_G() {
            int v_1;
                    // (, line 27
                    // test, line 27
                    v_1 = limit - cursor;
                    // hop, line 27
                    {
                        int c = cursor - 3;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    cursor = limit - v_1;
                    // literal, line 27
                    if (!(eq_s_b(1, "f")))
                    {
                        return false;
                    }
                    return true;
                }

                private boolean r_H() {
            int v_1;
            int v_2;
                    // (, line 28
                    // test, line 28
                    v_1 = limit - cursor;
                    // hop, line 28
                    {
                        int c = cursor - 2;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    cursor = limit - v_1;
                    // or, line 28
                    lab0: do {
                        v_2 = limit - cursor;
                        lab1: do {
                            // literal, line 28
                            if (!(eq_s_b(1, "t")))
                            {
                                break lab1;
                            }
                            break lab0;
                        } while (false);
                        cursor = limit - v_2;
                        // literal, line 28
                        if (!(eq_s_b(2, "ll")))
                        {
                            return false;
                        }
                    } while (false);
                    return true;
                }

                private boolean r_I() {
            int v_1;
            int v_2;
            int v_3;
                    // (, line 29
                    // test, line 29
                    v_1 = limit - cursor;
                    // hop, line 29
                    {
                        int c = cursor - 2;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    cursor = limit - v_1;
                    // not, line 29
                    {
                        v_2 = limit - cursor;
                        lab0: do {
                            // literal, line 29
                            if (!(eq_s_b(1, "o")))
                            {
                                break lab0;
                            }
                            return false;
                        } while (false);
                        cursor = limit - v_2;
                    }
                    // not, line 29
                    {
                        v_3 = limit - cursor;
                        lab1: do {
                            // literal, line 29
                            if (!(eq_s_b(1, "e")))
                            {
                                break lab1;
                            }
                            return false;
                        } while (false);
                        cursor = limit - v_3;
                    }
                    return true;
                }

                private boolean r_J() {
            int v_1;
            int v_2;
            int v_3;