lovinsstemmer.java

lucene2.2.0版本

                            // literal, line 32
                            if (!(eq_s_b(1, "o")))
                            {
                                break lab3;
                            }
                            break lab2;
                        } while (false);
                        cursor = limit - v_5;
                    }
                    return false;
                } while (false);
                cursor = limit - v_4;
            }
            return true;
        }

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

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

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

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

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

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

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

        private boolean r_T() {
            int v_1;
            int v_2;
            int v_3;
            // (, line 40
            // test, line 40
            v_1 = limit - cursor;
            // hop, line 40
            {
                int c = cursor - 2;
                if (limit_backward > c || c > limit)
                {
                    return false;
                }
                cursor = c;