lovinsstemmer.java

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

                            if (!(eq_s_b(1, "m")))
                            {
                                break lab2;
                            }
                            break lab0;
                        } while (false);
                        cursor = limit - v_2;
                        lab3: do {
                            // literal, line 41
                            if (!(eq_s_b(1, "n")))
                            {
                                break lab3;
                            }
                            break lab0;
                        } while (false);
                        cursor = limit - v_2;
                        // literal, line 41
                        if (!(eq_s_b(1, "r")))
                        {
                            return false;
                        }
                    } while (false);
                    return true;
                }

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

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

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

                private boolean r_Y() {
            int v_1;
                    // (, line 45
                    // test, line 45
                    v_1 = limit - cursor;
                    // hop, line 45
                    {
                        int c = cursor - 2;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    cursor = limit - v_1;
                    // literal, line 45
                    if (!(eq_s_b(2, "in")))
                    {
                        return false;
                    }
                    return true;
                }

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

                private boolean r_AA() {
            int v_1;
                    // (, line 47
                    // test, line 47
                    v_1 = limit - cursor;
                    // hop, line 47
                    {
                        int c = cursor - 2;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    cursor = limit - v_1;
                    // among, line 47
                    if (find_among_b(a_0, 9) == 0)
                    {
                        return false;
                    }
                    return true;
                }

                private boolean r_BB() {
            int v_1;
            int v_2;
            int v_3;
                    // (, line 49
                    // test, line 49
                    v_1 = limit - cursor;
                    // hop, line 49
                    {
                        int c = cursor - 3;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    cursor = limit - v_1;
                    // not, line 49
                    {
                        v_2 = limit - cursor;
                        lab0: do {
                            // literal, line 49
                            if (!(eq_s_b(3, "met")))
                            {
                                break lab0;
                            }
                            return false;
                        } while (false);
                        cursor = limit - v_2;
                    }
                    // not, line 49
                    {
                        v_3 = limit - cursor;
                        lab1: do {
                            // literal, line 49
                            if (!(eq_s_b(4, "ryst")))
                            {
                                break lab1;
                            }
                            return false;
                        } while (false);
                        cursor = limit - v_3;
                    }
                    return true;
                }

                private boolean r_CC() {
            int v_1;
                    // (, line 50
                    // test, line 50
                    v_1 = limit - cursor;
                    // hop, line 50
                    {
                        int c = cursor - 2;
                        if (limit_backward > c || c > limit)
                        {
                            return false;
                        }
                        cursor = c;
                    }
                    cursor = limit - v_1;
                    // literal, line 50
                    if (!(eq_s_b(1, "l")))
                    {
                        return false;
                    }
                    return true;
                }