lovinsstemmer.java

lucene2.2.0版本

                    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;
            // (, line 30
            // test, line 30
            v_1 = limit - cursor;
            // hop, line 30
            {
                int c = cursor - 2;
                if (limit_backward > c || c > limit)
                {
                    return false;
                }
                cursor = c;
            }
            cursor = limit - v_1;
            // not, line 30
            {
                v_2 = limit - cursor;
                lab0: do {
                    // literal, line 30
                    if (!(eq_s_b(1, "a")))
                    {
                        break lab0;
                    }
                    return false;
                } while (false);
                cursor = limit - v_2;
            }
            // not, line 30
            {
                v_3 = limit - cursor;
                lab1: do {
                    // literal, line 30
                    if (!(eq_s_b(1, "e")))
                    {
                        break lab1;
                    }
                    return false;
                } while (false);
                cursor = limit - v_3;
            }
            return true;
        }

        private boolean r_K() {
            int v_1;
            int v_2;
            // (, line 31
            // test, line 31
            v_1 = limit - cursor;
            // hop, line 31
            {
                int c = cursor - 3;
                if (limit_backward > c || c > limit)
                {
                    return false;
                }
                cursor = c;
            }
            cursor = limit - v_1;
            // or, line 31
            lab0: do {
                v_2 = limit - cursor;
                lab1: do {
                    // literal, line 31
                    if (!(eq_s_b(1, "l")))
                    {
                        break lab1;
                    }
                    break lab0;
                } while (false);
                cursor = limit - v_2;
                lab2: do {
                    // literal, line 31
                    if (!(eq_s_b(1, "i")))
                    {
                        break lab2;
                    }
                    break lab0;
                } while (false);
                cursor = limit - v_2;
                // (, line 31
                // literal, line 31
                if (!(eq_s_b(1, "e")))
                {
                    return false;
                }
                // next, line 31
                if (cursor <= limit_backward)
                {
                    return false;
                }
                cursor--;
                // literal, line 31
                if (!(eq_s_b(1, "u")))
                {
                    return false;
                }
            } while (false);
            return true;
        }

        private boolean r_L() {
            int v_1;
            int v_2;
            int v_3;
            int v_4;
            int v_5;
            // (, line 32
            // test, line 32
            v_1 = limit - cursor;
            // hop, line 32
            {
                int c = cursor - 2;
                if (limit_backward > c || c > limit)
                {
                    return false;
                }
                cursor = c;
            }
            cursor = limit - v_1;
            // not, line 32
            {
                v_2 = limit - cursor;
                lab0: do {
                    // literal, line 32
                    if (!(eq_s_b(1, "u")))
                    {
                        break lab0;
                    }
                    return false;
                } while (false);
                cursor = limit - v_2;
            }
            // not, line 32
            {
                v_3 = limit - cursor;
                lab1: do {
                    // literal, line 32
                    if (!(eq_s_b(1, "x")))
                    {
                        break lab1;
                    }
                    return false;
                } while (false);
                cursor = limit - v_3;
            }
            // not, line 32
            {
                v_4 = limit - cursor;
                lab2: do {
                    // (, line 32
                    // literal, line 32
                    if (!(eq_s_b(1, "s")))
                    {
                        break lab2;
                    }
                    // not, line 32
                    {
                        v_5 = limit - cursor;
                        lab3: do {