lovinsstemmer.java

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

                    // (, 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 {
                                    // 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;