lovinsstemmer.java

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

                        }
                    } 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;
                    }
                    cursor = limit - v_1;
                    // or, line 40
                    lab0: do {
                        v_2 = limit - cursor;
                        lab1: do {
                            // literal, line 40
                            if (!(eq_s_b(1, "s")))
                            {
                                break lab1;
                            }
                            break lab0;
                        } while (false);
                        cursor = limit - v_2;
                        // (, line 40
                        // literal, line 40
                        if (!(eq_s_b(1, "t")))
                        {
                            return false;
                        }
                        // not, line 40
                        {
                            v_3 = limit - cursor;
                            lab2: do {
                                // literal, line 40
                                if (!(eq_s_b(1, "o")))
                                {
                                    break lab2;
                                }
                                return false;
                            } while (false);
                            cursor = limit - v_3;
                        }
                    } while (false);
                    return true;
                }

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