snowballstemmer-1.2.1/0000755€-©8€ZĂ);0000000000012637133746022034 5ustar shibukawa.yoshikiDENA\Domain Users00000000000000snowballstemmer-1.2.1/LICENSE.rst0000644€-©8€ZĂ);0000000244412637132734023650 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000License ------- Copyright (c) 2013, Yoshiki Shibukawa All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. snowballstemmer-1.2.1/MANIFEST.in0000644€-©8€ZĂ);0000000011512637132734023563 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000include *.rst include setup.* recursive-include src *.py include MANIFEST.in snowballstemmer-1.2.1/PKG-INFO0000644€-©8€ZĂ);0000000427712637133746023143 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000Metadata-Version: 1.1 Name: snowballstemmer Version: 1.2.1 Summary: This package provides 16 stemmer algorithms (15 + Poerter English stemmer) generated from Snowball algorithms. Home-page: https://github.com/shibukawa/snowball_py Author: Yoshiki Shibukawa Author-email: yoshiki at shibu.jp License: BSD Description: It includes following language algorithms: * Danish * Dutch * English (Standard, Porter) * Finnish * French * German * Hungarian * Italian * Norwegian * Portuguese * Romanian * Russian * Spanish * Swedish * Turkish This is a pure Python stemming library. If `PyStemmer `_ is available, this module uses it to accelerate. Keywords: stemmer Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: BSD License Classifier: Programming Language :: Python Classifier: Natural Language :: Danish Classifier: Natural Language :: Dutch Classifier: Natural Language :: English Classifier: Natural Language :: Finnish Classifier: Natural Language :: French Classifier: Natural Language :: German Classifier: Natural Language :: Hungarian Classifier: Natural Language :: Italian Classifier: Natural Language :: Norwegian Classifier: Natural Language :: Portuguese Classifier: Natural Language :: Romanian Classifier: Natural Language :: Russian Classifier: Natural Language :: Spanish Classifier: Natural Language :: Swedish Classifier: Natural Language :: Turkish Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 2.5 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: Implementation :: PyPy Classifier: Topic :: Database Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search Classifier: Topic :: Text Processing :: Indexing Classifier: Topic :: Text Processing :: Linguistic snowballstemmer-1.2.1/README.rst0000644€-©8€ZĂ);0000000751412637132734023526 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000Snowball stemming library collection for Python =============================================== This document pertains to the Python version of the stemmer library distribution, available for download from: * https://github.com/shibukawa/snowball/ This repository includes Python source code generator * https://github.com/shibukawa/snowball_python/ This repository includes generated Python source codes Original program is maintained at following place: * http://snowball.tartarus.org/ Original Snowball product created by Dr Martin Porter and Richard Boulton (Java porting). Original Snowball and my products are released under BSD license. How to use library ------------------ The ``snowballstemmer`` module has two functions. The ``snowballstemmer.algorithms`` function returns a list of avilable algorithm name' string. The ``snowballstemmer.stemmer`` function accepts algorithm name and returns ``Stemmer`` objects. ``Stemmer`` objects have ``Stemmer.stemWord(word)`` method and ``Stemmer.stemWords(word[])`` method. .. code-block:: python import snowballstemmer stemmer = snowballstemmer.stemmer('english'); print(stemmer.stemWords("We are the world".split())); ``Stemmer`` objects have ``Stemmer.maxCacheSize`` property. They cache result within the value. Default is ``10000``. Accerarates Stemming -------------------- if **PyStemmer** is installed, ``snowballstemmer.stemmer`` returns ``PyStemmer``\ 's ``Stemmer`` objects. This ``Stemmer`` object has same methods (``Stemmer.stemWord()``, ``Stemmer.stemWords()``). **PyStemmer** is a Snowball's ``libstemmer_c`` wrapper module and it returns 100% compatible result with **snowballstemmer**. **PyStemmer** has faster speed because it uses C-lang module, and **snowballstemmer** has higher usability because it is pure Python module. * `PyStemmer `_ Benchmark ~~~~~~~~~ Test Case: Snowball stemmer check data (16 algorithms, total 582560 words, cache hit 0%) Computer: MacBook Pro 3rd Gen Corei7 2.3GHz * Python 2.7 + **snowballstemmer** : 2m 30s * PyPy 1.9 + **snowballstemmer** : 45s * Python 2.7 + **PyStemmer** : 5s This test case is much harder than usual usecases! The TestApp example ------------------- The ``testapp.py`` example program allows you to run any of the stemmers on a sample vocabulary. Usage:: testapp.py "sentences ... " .. code-block:: bash $ python testapp.py English "sentences... " Thanks ------- * Original Snowball authors * Emil Stenström License ------- It is a BSD licensed library. ----------------------------- Copyright (c) 2013, Yoshiki Shibukawa All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. snowballstemmer-1.2.1/setup.py0000644€-©8€ZĂ);0000000442112637132734023543 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000#!/usr/bin/env python from distutils.core import setup setup(name='snowballstemmer', version='1.2.1', description='This package provides 16 stemmer algorithms (15 + Poerter English stemmer) generated from Snowball algorithms.', long_description=''' It includes following language algorithms: * Danish * Dutch * English (Standard, Porter) * Finnish * French * German * Hungarian * Italian * Norwegian * Portuguese * Romanian * Russian * Spanish * Swedish * Turkish This is a pure Python stemming library. If `PyStemmer `_ is available, this module uses it to accelerate. ''', author='Yoshiki Shibukawa', author_email='yoshiki at shibu.jp', url='https://github.com/shibukawa/snowball_py', keywords="stemmer", license="BSD", packages=['snowballstemmer'], package_dir={"snowballstemmer": "snowballstemmer"}, classifiers = [ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'License :: OSI Approved :: BSD License', 'Programming Language :: Python', 'Natural Language :: Danish', 'Natural Language :: Dutch', 'Natural Language :: English', 'Natural Language :: Finnish', 'Natural Language :: French', 'Natural Language :: German', 'Natural Language :: Hungarian', 'Natural Language :: Italian', 'Natural Language :: Norwegian', 'Natural Language :: Portuguese', 'Natural Language :: Romanian', 'Natural Language :: Russian', 'Natural Language :: Spanish', 'Natural Language :: Swedish', 'Natural Language :: Turkish', 'Operating System :: OS Independent', 'Programming Language :: Python :: 2.5', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: Implementation :: PyPy', 'Topic :: Database', 'Topic :: Internet :: WWW/HTTP :: Indexing/Search', 'Topic :: Text Processing :: Indexing', 'Topic :: Text Processing :: Linguistic' ] ) snowballstemmer-1.2.1/snowballstemmer/0000755€-©8€ZĂ);0000000000012637133746025252 5ustar shibukawa.yoshikiDENA\Domain Users00000000000000snowballstemmer-1.2.1/snowballstemmer/__init__.py0000644€-©8€ZĂ);0000000326612637132734027366 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000__all__ = ('language', 'stemmer') from .danish_stemmer import DanishStemmer from .dutch_stemmer import DutchStemmer from .english_stemmer import EnglishStemmer from .finnish_stemmer import FinnishStemmer from .french_stemmer import FrenchStemmer from .german_stemmer import GermanStemmer from .hungarian_stemmer import HungarianStemmer from .italian_stemmer import ItalianStemmer from .norwegian_stemmer import NorwegianStemmer from .porter_stemmer import PorterStemmer from .portuguese_stemmer import PortugueseStemmer from .romanian_stemmer import RomanianStemmer from .russian_stemmer import RussianStemmer from .spanish_stemmer import SpanishStemmer from .swedish_stemmer import SwedishStemmer from .turkish_stemmer import TurkishStemmer _languages = { 'danish': DanishStemmer, 'dutch': DutchStemmer, 'english': EnglishStemmer, 'finnish': FinnishStemmer, 'french': FrenchStemmer, 'german': GermanStemmer, 'hungarian': HungarianStemmer, 'italian': ItalianStemmer, 'norwegian': NorwegianStemmer, 'porter': PorterStemmer, 'portuguese': PortugueseStemmer, 'romanian': RomanianStemmer, 'russian': RussianStemmer, 'spanish': SpanishStemmer, 'swedish': SwedishStemmer, 'turkish': TurkishStemmer, } try: import Stemmer cext_available = True except ImportError: cext_available = False def algorithms(): if cext_available: return Stemmer.language() else: return list(_languages.keys()) def stemmer(lang): if cext_available: return Stemmer.Stemmer(lang) if lang.lower() in _languages: return _languages[lang.lower()]() else: raise KeyError("Stemming algorithm '%s' not found" % lang) snowballstemmer-1.2.1/snowballstemmer/among.py0000644€-©8€ZĂ);0000000073112637132734026722 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000 class Among(object): def __init__(self, s, substring_i, result, method=None): """ @ivar s_size search string size @ivar s search string @ivar substring index to longest matching substring @ivar result of the lookup @ivar method method to use if substring matches """ self.s_size = len(s) self.s = s self.substring_i = substring_i self.result = result self.method = method snowballstemmer-1.2.1/snowballstemmer/basestemmer.py0000644€-©8€ZĂ);0000002357312637132734030141 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000class BaseStemmer(object): def __init__(self): self.set_current("") self.maxCacheSize = 10000 self._cache = {} self._counter = 0 def set_current(self, value): ''' Set the self.current string. ''' self.current = value self.cursor = 0 self.limit = len(self.current) self.limit_backward = 0 self.bra = self.cursor self.ket = self.limit def get_current(self): ''' Get the self.current string. ''' return self.current def copy_from(self, other): self.current = other.current self.cursor = other.cursor self.limit = other.limit self.limit_backward = other.limit_backward self.bra = other.bra self.ket = other.ket def in_grouping(self, s, min, max): if self.cursor >= self.limit: return False ch = ord(self.current[self.cursor]) if ch > max or ch < min: return False ch -= min if (s[ch >> 3] & (0x1 << (ch & 0x7))) == 0: return False self.cursor += 1 return True def in_grouping_b(self, s, min, max): if self.cursor <= self.limit_backward: return False ch = ord(self.current[self.cursor - 1]) if ch > max or ch < min: return False ch -= min if (s[ch >> 3] & (0x1 << (ch & 0x7))) == 0: return False self.cursor -= 1 return True def out_grouping(self, s, min, max): if self.cursor >= self.limit: return False ch = ord(self.current[self.cursor]) if ch > max or ch < min: self.cursor += 1 return True ch -= min if (s[ch >> 3] & (0X1 << (ch & 0x7))) == 0: self.cursor += 1 return True return False def out_grouping_b(self, s, min, max): if self.cursor <= self.limit_backward: return False ch = ord(self.current[self.cursor - 1]) if ch > max or ch < min: self.cursor -= 1 return True ch -= min if (s[ch >> 3] & (0X1 << (ch & 0x7))) == 0: self.cursor -= 1 return True return False def in_range(self, min, max): if self.cursor >= self.limit: return False ch = ord(self.current[self.cursor]) if ch > max or ch < min: return False self.cursor += 1 return True def in_range_b(self, min, max): if self.cursor <= self.limit_backward: return False ch = ord(self.current[self.cursor - 1]) if ch > max or ch < min: return False self.cursor -= 1 return True def out_range(self, min, max): if self.cursor >= self.limit: return False ch = ord(self.current[self.cursor]) if not (ch > max or ch < min): return False self.cursor += 1 return True def out_range_b(self, min, max): if self.cursor <= self.limit_backward: return False ch = ord(self.current[self.cursor - 1]) if not (ch > max or ch < min): return False self.cursor -= 1 return True def eq_s(self, s_size, s): if self.limit - self.cursor < s_size: return False if self.current[self.cursor:self.cursor + s_size] != s: return False self.cursor += s_size return True def eq_s_b(self, s_size, s): if self.cursor - self.limit_backward < s_size: return False if self.current[self.cursor - s_size:self.cursor] != s: return False self.cursor -= s_size return True def eq_v(self, s): return self.eq_s(len(s), s) def eq_v_b(self, s): return self.eq_s_b(len(s), s) def find_among(self, v, v_size): i = 0 j = v_size c = self.cursor l = self.limit common_i = 0 common_j = 0 first_key_inspected = False while True: k = i + ((j - i) >> 1) diff = 0 common = min(common_i, common_j) # smalle w = v[k] for i2 in range(common, w.s_size): if c + common == l: diff = -1 break diff = ord(self.current[c + common]) - ord(w.s[i2]) if diff != 0: break common += 1 if diff < 0: j = k common_j = common else: i = k common_i = common if j - i <= 1: if i > 0: break # v->s has been inspected if j == i: break # only one item in v # - but now we need to go round once more to get # v->s inspected. self looks messy, but is actually # the optimal approach. if first_key_inspected: break first_key_inspected = True while True: w = v[i] if common_i >= w.s_size: self.cursor = c + w.s_size if w.method is None: return w.result method = getattr(self, w.method) res = method() self.cursor = c + w.s_size if res: return w.result i = w.substring_i if i < 0: return 0 return -1 # not reachable def find_among_b(self, v, v_size): ''' find_among_b is for backwards processing. Same comments apply ''' i = 0 j = v_size c = self.cursor lb = self.limit_backward; common_i = 0 common_j = 0 first_key_inspected = False while True: k = i + ((j - i) >> 1) diff = 0 common = min(common_i, common_j) w = v[k] for i2 in range(w.s_size - 1 - common, -1, -1): if c - common == lb: diff = -1 break diff = ord(self.current[c - 1 - common]) - ord(w.s[i2]) if diff != 0: break common += 1 if diff < 0: j = k common_j = common else: i = k common_i = common if j - i <= 1: if i > 0: break if j == i: break if first_key_inspected: break first_key_inspected = True while True: w = v[i] if common_i >= w.s_size: self.cursor = c - w.s_size if w.method is None: return w.result method = getattr(self, w.method) res = method() self.cursor = c - w.s_size if res: return w.result i = w.substring_i if i < 0: return 0 return -1 # not reachable def replace_s(self, c_bra, c_ket, s): ''' to replace chars between c_bra and c_ket in self.current by the chars in s. @type c_bra int @type c_ket int @type s: string ''' adjustment = len(s) - (c_ket - c_bra) self.current = self.current[0:c_bra] + s + self.current[c_ket:] self.limit += adjustment if self.cursor >= c_ket: self.cursor += adjustment elif self.cursor > c_bra: self.cursor = c_bra return adjustment def slice_check(self): if self.bra < 0 or self.bra > self.ket or self.ket > self.limit or self.limit > len(self.current): return False return True def slice_from(self, s): ''' @type s string ''' result = False if self.slice_check(): self.replace_s(self.bra, self.ket, s) result = True return result def slice_del(self): return self.slice_from("") def insert(self, c_bra, c_ket, s): ''' @type c_bra int @type c_ket int @type s: string ''' adjustment = self.replace_s(c_bra, c_ket, s) if c_bra <= self.bra: self.bra += adjustment if c_bra <= self.ket: self.ket += adjustment def slice_to(self, s): ''' Copy the slice into the supplied StringBuffer @type s: string ''' result = '' if self.slice_check(): result = self.current[self.bra:self.ket] return result def assign_to(self, s): ''' @type s: string ''' return self.current[0:self.limit] def _stem_word(self, word): cache = self._cache.get(word) if cache is None: self.set_current(word) self._stem() result = self.get_current() self._cache[word] = [result, self._counter] else: cache[1] = self._counter result = cache[0] self._counter += 1 return result def _clear_cache(self): removecount = int(len(self._cache) - self.maxCacheSize * 8 / 10) oldcaches = sorted(self._cache.items(), key=lambda cache: cache[1][1])[0:removecount] for key, value in oldcaches: del self._cache[key] def stemWord(self, word): result = self._stem_word(word) if len(self._cache) > self.maxCacheSize: self._clear_cache() return result def stemWords(self, words): result = [self._stem_word(word) for word in words] if len(self._cache) > self.maxCacheSize: self._clear_cache() return result snowballstemmer-1.2.1/snowballstemmer/danish_stemmer.py0000644€-©8€ZĂ);0000002433112637132734030625 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class DanishStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"hed", -1, 1), Among(u"ethed", 0, 1), Among(u"ered", -1, 1), Among(u"e", -1, 1), Among(u"erede", 3, 1), Among(u"ende", 3, 1), Among(u"erende", 5, 1), Among(u"ene", 3, 1), Among(u"erne", 3, 1), Among(u"ere", 3, 1), Among(u"en", -1, 1), Among(u"heden", 10, 1), Among(u"eren", 10, 1), Among(u"er", -1, 1), Among(u"heder", 13, 1), Among(u"erer", 13, 1), Among(u"s", -1, 2), Among(u"heds", 16, 1), Among(u"es", 16, 1), Among(u"endes", 18, 1), Among(u"erendes", 19, 1), Among(u"enes", 18, 1), Among(u"ernes", 18, 1), Among(u"eres", 18, 1), Among(u"ens", 16, 1), Among(u"hedens", 24, 1), Among(u"erens", 24, 1), Among(u"ers", 16, 1), Among(u"ets", 16, 1), Among(u"erets", 28, 1), Among(u"et", -1, 1), Among(u"eret", 30, 1) ] a_1 = [ Among(u"gd", -1, -1), Among(u"dt", -1, -1), Among(u"gt", -1, -1), Among(u"kt", -1, -1) ] a_2 = [ Among(u"ig", -1, 1), Among(u"lig", 0, 1), Among(u"elig", 1, 1), Among(u"els", -1, 1), Among(u"l\u00F8st", -1, 2) ] g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 128] g_s_ending = [239, 254, 42, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16] I_x = 0 I_p1 = 0 S_ch = "" def copy_from(self, other): self.I_x = other.I_x self.I_p1 = other.I_p1 self.S_ch = other.S_ch super.copy_from(other) def r_mark_regions(self): # (, line 29 self.I_p1 = self.limit; # test, line 33 v_1 = self.cursor # (, line 33 # hop, line 33 c = self.cursor + 3 if 0 > c or c > self.limit: return False self.cursor = c # setmark x, line 33 self.I_x = self.cursor self.cursor = v_1 # goto, line 34 try: while True: v_2 = self.cursor try: if not self.in_grouping(DanishStemmer.g_v, 97, 248): raise lab1() self.cursor = v_2 raise lab0() except lab1: pass self.cursor = v_2 if self.cursor >= self.limit: return False self.cursor += 1 except lab0: pass # gopast, line 34 try: while True: try: if not self.out_grouping(DanishStemmer.g_v, 97, 248): raise lab3() raise lab2() except lab3: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab2: pass # setmark p1, line 34 self.I_p1 = self.cursor # try, line 35 try: # (, line 35 if not (self.I_p1 < self.I_x): raise lab4() self.I_p1 = self.I_x; except lab4: pass return True def r_main_suffix(self): # (, line 40 # setlimit, line 41 v_1 = self.limit - self.cursor # tomark, line 41 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 41 # [, line 41 self.ket = self.cursor # substring, line 41 among_var = self.find_among_b(DanishStemmer.a_0, 32) if among_var == 0: self.limit_backward = v_2 return False # ], line 41 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 48 # delete, line 48 if not self.slice_del(): return False elif among_var == 2: # (, line 50 if not self.in_grouping_b(DanishStemmer.g_s_ending, 97, 229): return False # delete, line 50 if not self.slice_del(): return False return True def r_consonant_pair(self): # (, line 54 # test, line 55 v_1 = self.limit - self.cursor # (, line 55 # setlimit, line 56 v_2 = self.limit - self.cursor # tomark, line 56 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_3 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_2 # (, line 56 # [, line 56 self.ket = self.cursor # substring, line 56 if self.find_among_b(DanishStemmer.a_1, 4) == 0: self.limit_backward = v_3 return False # ], line 56 self.bra = self.cursor self.limit_backward = v_3 self.cursor = self.limit - v_1 # next, line 62 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # ], line 62 self.bra = self.cursor # delete, line 62 if not self.slice_del(): return False return True def r_other_suffix(self): # (, line 65 # do, line 66 v_1 = self.limit - self.cursor try: # (, line 66 # [, line 66 self.ket = self.cursor # literal, line 66 if not self.eq_s_b(2, u"st"): raise lab0() # ], line 66 self.bra = self.cursor # literal, line 66 if not self.eq_s_b(2, u"ig"): raise lab0() # delete, line 66 if not self.slice_del(): return False except lab0: pass self.cursor = self.limit - v_1 # setlimit, line 67 v_2 = self.limit - self.cursor # tomark, line 67 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_3 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_2 # (, line 67 # [, line 67 self.ket = self.cursor # substring, line 67 among_var = self.find_among_b(DanishStemmer.a_2, 5) if among_var == 0: self.limit_backward = v_3 return False # ], line 67 self.bra = self.cursor self.limit_backward = v_3 if among_var == 0: return False elif among_var == 1: # (, line 70 # delete, line 70 if not self.slice_del(): return False # do, line 70 v_4 = self.limit - self.cursor try: # call consonant_pair, line 70 if not self.r_consonant_pair(): raise lab1() except lab1: pass self.cursor = self.limit - v_4 elif among_var == 2: # (, line 72 # <-, line 72 if not self.slice_from(u"l\u00F8s"): return False return True def r_undouble(self): # (, line 75 # setlimit, line 76 v_1 = self.limit - self.cursor # tomark, line 76 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 76 # [, line 76 self.ket = self.cursor if not self.out_grouping_b(DanishStemmer.g_v, 97, 248): self.limit_backward = v_2 return False # ], line 76 self.bra = self.cursor # -> ch, line 76 self.S_ch = self.slice_to(self.S_ch) if self.S_ch == '': return False self.limit_backward = v_2 # name ch, line 77 if not self.eq_v_b(self.S_ch): return False # delete, line 78 if not self.slice_del(): return False return True def _stem(self): # (, line 82 # do, line 84 v_1 = self.cursor try: # call mark_regions, line 84 if not self.r_mark_regions(): raise lab0() except lab0: pass self.cursor = v_1 # backwards, line 85 self.limit_backward = self.cursor self.cursor = self.limit # (, line 85 # do, line 86 v_2 = self.limit - self.cursor try: # call main_suffix, line 86 if not self.r_main_suffix(): raise lab1() except lab1: pass self.cursor = self.limit - v_2 # do, line 87 v_3 = self.limit - self.cursor try: # call consonant_pair, line 87 if not self.r_consonant_pair(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 # do, line 88 v_4 = self.limit - self.cursor try: # call other_suffix, line 88 if not self.r_other_suffix(): raise lab3() except lab3: pass self.cursor = self.limit - v_4 # do, line 89 v_5 = self.limit - self.cursor try: # call undouble, line 89 if not self.r_undouble(): raise lab4() except lab4: pass self.cursor = self.limit - v_5 self.cursor = self.limit_backward return True def equals(self, o): return isinstance(o, DanishStemmer) def hashCode(self): return hash("DanishStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/dutch_stemmer.py0000644€-©8€ZĂ);0000005522012637132734030467 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class DutchStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"", -1, 6), Among(u"\u00E1", 0, 1), Among(u"\u00E4", 0, 1), Among(u"\u00E9", 0, 2), Among(u"\u00EB", 0, 2), Among(u"\u00ED", 0, 3), Among(u"\u00EF", 0, 3), Among(u"\u00F3", 0, 4), Among(u"\u00F6", 0, 4), Among(u"\u00FA", 0, 5), Among(u"\u00FC", 0, 5) ] a_1 = [ Among(u"", -1, 3), Among(u"I", 0, 2), Among(u"Y", 0, 1) ] a_2 = [ Among(u"dd", -1, -1), Among(u"kk", -1, -1), Among(u"tt", -1, -1) ] a_3 = [ Among(u"ene", -1, 2), Among(u"se", -1, 3), Among(u"en", -1, 2), Among(u"heden", 2, 1), Among(u"s", -1, 3) ] a_4 = [ Among(u"end", -1, 1), Among(u"ig", -1, 2), Among(u"ing", -1, 1), Among(u"lijk", -1, 3), Among(u"baar", -1, 4), Among(u"bar", -1, 5) ] a_5 = [ Among(u"aa", -1, -1), Among(u"ee", -1, -1), Among(u"oo", -1, -1), Among(u"uu", -1, -1) ] g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128] g_v_I = [1, 0, 0, 17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128] g_v_j = [17, 67, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128] I_p2 = 0 I_p1 = 0 B_e_found = False def copy_from(self, other): self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 self.B_e_found = other.B_e_found super.copy_from(other) def r_prelude(self): # (, line 41 # test, line 42 v_1 = self.cursor # repeat, line 42 try: while True: try: v_2 = self.cursor try: # (, line 42 # [, line 43 self.bra = self.cursor # substring, line 43 among_var = self.find_among(DutchStemmer.a_0, 11) if among_var == 0: raise lab2() # ], line 43 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 45 # <-, line 45 if not self.slice_from(u"a"): return False elif among_var == 2: # (, line 47 # <-, line 47 if not self.slice_from(u"e"): return False elif among_var == 3: # (, line 49 # <-, line 49 if not self.slice_from(u"i"): return False elif among_var == 4: # (, line 51 # <-, line 51 if not self.slice_from(u"o"): return False elif among_var == 5: # (, line 53 # <-, line 53 if not self.slice_from(u"u"): return False elif among_var == 6: # (, line 54 # next, line 54 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_2 raise lab0() except lab1: pass except lab0: pass self.cursor = v_1 # try, line 57 v_3 = self.cursor try: # (, line 57 # [, line 57 self.bra = self.cursor # literal, line 57 if not self.eq_s(1, u"y"): self.cursor = v_3 raise lab3() # ], line 57 self.ket = self.cursor # <-, line 57 if not self.slice_from(u"Y"): return False except lab3: pass # repeat, line 58 try: while True: try: v_4 = self.cursor try: # goto, line 58 try: while True: v_5 = self.cursor try: # (, line 58 if not self.in_grouping(DutchStemmer.g_v, 97, 232): raise lab8() # [, line 59 self.bra = self.cursor # or, line 59 try: v_6 = self.cursor try: # (, line 59 # literal, line 59 if not self.eq_s(1, u"i"): raise lab10() # ], line 59 self.ket = self.cursor if not self.in_grouping(DutchStemmer.g_v, 97, 232): raise lab10() # <-, line 59 if not self.slice_from(u"I"): return False raise lab9() except lab10: pass self.cursor = v_6 # (, line 60 # literal, line 60 if not self.eq_s(1, u"y"): raise lab8() # ], line 60 self.ket = self.cursor # <-, line 60 if not self.slice_from(u"Y"): return False except lab9: pass self.cursor = v_5 raise lab7() except lab8: pass self.cursor = v_5 if self.cursor >= self.limit: raise lab6() self.cursor += 1 except lab7: pass raise lab5() except lab6: pass self.cursor = v_4 raise lab4() except lab5: pass except lab4: pass return True def r_mark_regions(self): # (, line 64 self.I_p1 = self.limit; self.I_p2 = self.limit; # gopast, line 69 try: while True: try: if not self.in_grouping(DutchStemmer.g_v, 97, 232): raise lab1() raise lab0() except lab1: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab0: pass # gopast, line 69 try: while True: try: if not self.out_grouping(DutchStemmer.g_v, 97, 232): raise lab3() raise lab2() except lab3: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab2: pass # setmark p1, line 69 self.I_p1 = self.cursor # try, line 70 try: # (, line 70 if not self.I_p1 < 3: raise lab4() self.I_p1 = 3; except lab4: pass # gopast, line 71 try: while True: try: if not self.in_grouping(DutchStemmer.g_v, 97, 232): raise lab6() raise lab5() except lab6: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab5: pass # gopast, line 71 try: while True: try: if not self.out_grouping(DutchStemmer.g_v, 97, 232): raise lab8() raise lab7() except lab8: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab7: pass # setmark p2, line 71 self.I_p2 = self.cursor return True def r_postlude(self): # repeat, line 75 try: while True: try: v_1 = self.cursor try: # (, line 75 # [, line 77 self.bra = self.cursor # substring, line 77 among_var = self.find_among(DutchStemmer.a_1, 3) if among_var == 0: raise lab2() # ], line 77 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 78 # <-, line 78 if not self.slice_from(u"y"): return False elif among_var == 2: # (, line 79 # <-, line 79 if not self.slice_from(u"i"): return False elif among_var == 3: # (, line 80 # next, line 80 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_undouble(self): # (, line 90 # test, line 91 v_1 = self.limit - self.cursor # among, line 91 if self.find_among_b(DutchStemmer.a_2, 3) == 0: return False self.cursor = self.limit - v_1 # [, line 91 self.ket = self.cursor # next, line 91 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # ], line 91 self.bra = self.cursor # delete, line 91 if not self.slice_del(): return False return True def r_e_ending(self): # (, line 94 # unset e_found, line 95 self.B_e_found = False # [, line 96 self.ket = self.cursor # literal, line 96 if not self.eq_s_b(1, u"e"): return False # ], line 96 self.bra = self.cursor # call R1, line 96 if not self.r_R1(): return False # test, line 96 v_1 = self.limit - self.cursor if not self.out_grouping_b(DutchStemmer.g_v, 97, 232): return False self.cursor = self.limit - v_1 # delete, line 96 if not self.slice_del(): return False # set e_found, line 97 self.B_e_found = True # call undouble, line 98 if not self.r_undouble(): return False return True def r_en_ending(self): # (, line 101 # call R1, line 102 if not self.r_R1(): return False # and, line 102 v_1 = self.limit - self.cursor if not self.out_grouping_b(DutchStemmer.g_v, 97, 232): return False self.cursor = self.limit - v_1 # not, line 102 v_2 = self.limit - self.cursor try: # literal, line 102 if not self.eq_s_b(3, u"gem"): raise lab0() return False except lab0: pass self.cursor = self.limit - v_2 # delete, line 102 if not self.slice_del(): return False # call undouble, line 103 if not self.r_undouble(): return False return True def r_standard_suffix(self): # (, line 106 # do, line 107 v_1 = self.limit - self.cursor try: # (, line 107 # [, line 108 self.ket = self.cursor # substring, line 108 among_var = self.find_among_b(DutchStemmer.a_3, 5) if among_var == 0: raise lab0() # ], line 108 self.bra = self.cursor if among_var == 0: raise lab0() elif among_var == 1: # (, line 110 # call R1, line 110 if not self.r_R1(): raise lab0() # <-, line 110 if not self.slice_from(u"heid"): return False elif among_var == 2: # (, line 113 # call en_ending, line 113 if not self.r_en_ending(): raise lab0() elif among_var == 3: # (, line 116 # call R1, line 116 if not self.r_R1(): raise lab0() if not self.out_grouping_b(DutchStemmer.g_v_j, 97, 232): raise lab0() # delete, line 116 if not self.slice_del(): return False except lab0: pass self.cursor = self.limit - v_1 # do, line 120 v_2 = self.limit - self.cursor try: # call e_ending, line 120 if not self.r_e_ending(): raise lab1() except lab1: pass self.cursor = self.limit - v_2 # do, line 122 v_3 = self.limit - self.cursor try: # (, line 122 # [, line 122 self.ket = self.cursor # literal, line 122 if not self.eq_s_b(4, u"heid"): raise lab2() # ], line 122 self.bra = self.cursor # call R2, line 122 if not self.r_R2(): raise lab2() # not, line 122 v_4 = self.limit - self.cursor try: # literal, line 122 if not self.eq_s_b(1, u"c"): raise lab3() raise lab2() except lab3: pass self.cursor = self.limit - v_4 # delete, line 122 if not self.slice_del(): return False # [, line 123 self.ket = self.cursor # literal, line 123 if not self.eq_s_b(2, u"en"): raise lab2() # ], line 123 self.bra = self.cursor # call en_ending, line 123 if not self.r_en_ending(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 # do, line 126 v_5 = self.limit - self.cursor try: # (, line 126 # [, line 127 self.ket = self.cursor # substring, line 127 among_var = self.find_among_b(DutchStemmer.a_4, 6) if among_var == 0: raise lab4() # ], line 127 self.bra = self.cursor if among_var == 0: raise lab4() elif among_var == 1: # (, line 129 # call R2, line 129 if not self.r_R2(): raise lab4() # delete, line 129 if not self.slice_del(): return False # or, line 130 try: v_6 = self.limit - self.cursor try: # (, line 130 # [, line 130 self.ket = self.cursor # literal, line 130 if not self.eq_s_b(2, u"ig"): raise lab6() # ], line 130 self.bra = self.cursor # call R2, line 130 if not self.r_R2(): raise lab6() # not, line 130 v_7 = self.limit - self.cursor try: # literal, line 130 if not self.eq_s_b(1, u"e"): raise lab7() raise lab6() except lab7: pass self.cursor = self.limit - v_7 # delete, line 130 if not self.slice_del(): return False raise lab5() except lab6: pass self.cursor = self.limit - v_6 # call undouble, line 130 if not self.r_undouble(): raise lab4() except lab5: pass elif among_var == 2: # (, line 133 # call R2, line 133 if not self.r_R2(): raise lab4() # not, line 133 v_8 = self.limit - self.cursor try: # literal, line 133 if not self.eq_s_b(1, u"e"): raise lab8() raise lab4() except lab8: pass self.cursor = self.limit - v_8 # delete, line 133 if not self.slice_del(): return False elif among_var == 3: # (, line 136 # call R2, line 136 if not self.r_R2(): raise lab4() # delete, line 136 if not self.slice_del(): return False # call e_ending, line 136 if not self.r_e_ending(): raise lab4() elif among_var == 4: # (, line 139 # call R2, line 139 if not self.r_R2(): raise lab4() # delete, line 139 if not self.slice_del(): return False elif among_var == 5: # (, line 142 # call R2, line 142 if not self.r_R2(): raise lab4() # Boolean test e_found, line 142 if not self.B_e_found: raise lab4() # delete, line 142 if not self.slice_del(): return False except lab4: pass self.cursor = self.limit - v_5 # do, line 146 v_9 = self.limit - self.cursor try: # (, line 146 if not self.out_grouping_b(DutchStemmer.g_v_I, 73, 232): raise lab9() # test, line 148 v_10 = self.limit - self.cursor # (, line 148 # among, line 149 if self.find_among_b(DutchStemmer.a_5, 4) == 0: raise lab9() if not self.out_grouping_b(DutchStemmer.g_v, 97, 232): raise lab9() self.cursor = self.limit - v_10 # [, line 152 self.ket = self.cursor # next, line 152 if self.cursor <= self.limit_backward: raise lab9() self.cursor -= 1 # ], line 152 self.bra = self.cursor # delete, line 152 if not self.slice_del(): return False except lab9: pass self.cursor = self.limit - v_9 return True def _stem(self): # (, line 157 # do, line 159 v_1 = self.cursor try: # call prelude, line 159 if not self.r_prelude(): raise lab0() except lab0: pass self.cursor = v_1 # do, line 160 v_2 = self.cursor try: # call mark_regions, line 160 if not self.r_mark_regions(): raise lab1() except lab1: pass self.cursor = v_2 # backwards, line 161 self.limit_backward = self.cursor self.cursor = self.limit # do, line 162 v_3 = self.limit - self.cursor try: # call standard_suffix, line 162 if not self.r_standard_suffix(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 self.cursor = self.limit_backward # do, line 163 v_4 = self.cursor try: # call postlude, line 163 if not self.r_postlude(): raise lab3() except lab3: pass self.cursor = v_4 return True def equals(self, o): return isinstance(o, DutchStemmer) def hashCode(self): return hash("DutchStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/english_stemmer.py0000644€-©8€ZĂ);0000010434312637132734031012 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class EnglishStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"arsen", -1, -1), Among(u"commun", -1, -1), Among(u"gener", -1, -1) ] a_1 = [ Among(u"'", -1, 1), Among(u"'s'", 0, 1), Among(u"'s", -1, 1) ] a_2 = [ Among(u"ied", -1, 2), Among(u"s", -1, 3), Among(u"ies", 1, 2), Among(u"sses", 1, 1), Among(u"ss", 1, -1), Among(u"us", 1, -1) ] a_3 = [ Among(u"", -1, 3), Among(u"bb", 0, 2), Among(u"dd", 0, 2), Among(u"ff", 0, 2), Among(u"gg", 0, 2), Among(u"bl", 0, 1), Among(u"mm", 0, 2), Among(u"nn", 0, 2), Among(u"pp", 0, 2), Among(u"rr", 0, 2), Among(u"at", 0, 1), Among(u"tt", 0, 2), Among(u"iz", 0, 1) ] a_4 = [ Among(u"ed", -1, 2), Among(u"eed", 0, 1), Among(u"ing", -1, 2), Among(u"edly", -1, 2), Among(u"eedly", 3, 1), Among(u"ingly", -1, 2) ] a_5 = [ Among(u"anci", -1, 3), Among(u"enci", -1, 2), Among(u"ogi", -1, 13), Among(u"li", -1, 16), Among(u"bli", 3, 12), Among(u"abli", 4, 4), Among(u"alli", 3, 8), Among(u"fulli", 3, 14), Among(u"lessli", 3, 15), Among(u"ousli", 3, 10), Among(u"entli", 3, 5), Among(u"aliti", -1, 8), Among(u"biliti", -1, 12), Among(u"iviti", -1, 11), Among(u"tional", -1, 1), Among(u"ational", 14, 7), Among(u"alism", -1, 8), Among(u"ation", -1, 7), Among(u"ization", 17, 6), Among(u"izer", -1, 6), Among(u"ator", -1, 7), Among(u"iveness", -1, 11), Among(u"fulness", -1, 9), Among(u"ousness", -1, 10) ] a_6 = [ Among(u"icate", -1, 4), Among(u"ative", -1, 6), Among(u"alize", -1, 3), Among(u"iciti", -1, 4), Among(u"ical", -1, 4), Among(u"tional", -1, 1), Among(u"ational", 5, 2), Among(u"ful", -1, 5), Among(u"ness", -1, 5) ] a_7 = [ Among(u"ic", -1, 1), Among(u"ance", -1, 1), Among(u"ence", -1, 1), Among(u"able", -1, 1), Among(u"ible", -1, 1), Among(u"ate", -1, 1), Among(u"ive", -1, 1), Among(u"ize", -1, 1), Among(u"iti", -1, 1), Among(u"al", -1, 1), Among(u"ism", -1, 1), Among(u"ion", -1, 2), Among(u"er", -1, 1), Among(u"ous", -1, 1), Among(u"ant", -1, 1), Among(u"ent", -1, 1), Among(u"ment", 15, 1), Among(u"ement", 16, 1) ] a_8 = [ Among(u"e", -1, 1), Among(u"l", -1, 2) ] a_9 = [ Among(u"succeed", -1, -1), Among(u"proceed", -1, -1), Among(u"exceed", -1, -1), Among(u"canning", -1, -1), Among(u"inning", -1, -1), Among(u"earring", -1, -1), Among(u"herring", -1, -1), Among(u"outing", -1, -1) ] a_10 = [ Among(u"andes", -1, -1), Among(u"atlas", -1, -1), Among(u"bias", -1, -1), Among(u"cosmos", -1, -1), Among(u"dying", -1, 3), Among(u"early", -1, 9), Among(u"gently", -1, 7), Among(u"howe", -1, -1), Among(u"idly", -1, 6), Among(u"lying", -1, 4), Among(u"news", -1, -1), Among(u"only", -1, 10), Among(u"singly", -1, 11), Among(u"skies", -1, 2), Among(u"skis", -1, 1), Among(u"sky", -1, -1), Among(u"tying", -1, 5), Among(u"ugly", -1, 8) ] g_v = [17, 65, 16, 1] g_v_WXY = [1, 17, 65, 208, 1] g_valid_LI = [55, 141, 2] B_Y_found = False I_p2 = 0 I_p1 = 0 def copy_from(self, other): self.B_Y_found = other.B_Y_found self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 super.copy_from(other) def r_prelude(self): # (, line 25 # unset Y_found, line 26 self.B_Y_found = False # do, line 27 v_1 = self.cursor try: # (, line 27 # [, line 27 self.bra = self.cursor # literal, line 27 if not self.eq_s(1, u"'"): raise lab0() # ], line 27 self.ket = self.cursor # delete, line 27 if not self.slice_del(): return False except lab0: pass self.cursor = v_1 # do, line 28 v_2 = self.cursor try: # (, line 28 # [, line 28 self.bra = self.cursor # literal, line 28 if not self.eq_s(1, u"y"): raise lab1() # ], line 28 self.ket = self.cursor # <-, line 28 if not self.slice_from(u"Y"): return False # set Y_found, line 28 self.B_Y_found = True except lab1: pass self.cursor = v_2 # do, line 29 v_3 = self.cursor try: # repeat, line 29 try: while True: try: v_4 = self.cursor try: # (, line 29 # goto, line 29 try: while True: v_5 = self.cursor try: # (, line 29 if not self.in_grouping(EnglishStemmer.g_v, 97, 121): raise lab7() # [, line 29 self.bra = self.cursor # literal, line 29 if not self.eq_s(1, u"y"): raise lab7() # ], line 29 self.ket = self.cursor self.cursor = v_5 raise lab6() except lab7: pass self.cursor = v_5 if self.cursor >= self.limit: raise lab5() self.cursor += 1 except lab6: pass # <-, line 29 if not self.slice_from(u"Y"): return False # set Y_found, line 29 self.B_Y_found = True raise lab4() except lab5: pass self.cursor = v_4 raise lab3() except lab4: pass except lab3: pass except lab2: pass self.cursor = v_3 return True def r_mark_regions(self): # (, line 32 self.I_p1 = self.limit; self.I_p2 = self.limit; # do, line 35 v_1 = self.cursor try: # (, line 35 # or, line 41 try: v_2 = self.cursor try: # among, line 36 if self.find_among(EnglishStemmer.a_0, 3) == 0: raise lab2() raise lab1() except lab2: pass self.cursor = v_2 # (, line 41 # gopast, line 41 try: while True: try: if not self.in_grouping(EnglishStemmer.g_v, 97, 121): raise lab4() raise lab3() except lab4: pass if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab3: pass # gopast, line 41 try: while True: try: if not self.out_grouping(EnglishStemmer.g_v, 97, 121): raise lab6() raise lab5() except lab6: pass if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab5: pass except lab1: pass # setmark p1, line 42 self.I_p1 = self.cursor # gopast, line 43 try: while True: try: if not self.in_grouping(EnglishStemmer.g_v, 97, 121): raise lab8() raise lab7() except lab8: pass if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab7: pass # gopast, line 43 try: while True: try: if not self.out_grouping(EnglishStemmer.g_v, 97, 121): raise lab10() raise lab9() except lab10: pass if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab9: pass # setmark p2, line 43 self.I_p2 = self.cursor except lab0: pass self.cursor = v_1 return True def r_shortv(self): # (, line 49 # or, line 51 try: v_1 = self.limit - self.cursor try: # (, line 50 if not self.out_grouping_b(EnglishStemmer.g_v_WXY, 89, 121): raise lab1() if not self.in_grouping_b(EnglishStemmer.g_v, 97, 121): raise lab1() if not self.out_grouping_b(EnglishStemmer.g_v, 97, 121): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_1 # (, line 52 if not self.out_grouping_b(EnglishStemmer.g_v, 97, 121): return False if not self.in_grouping_b(EnglishStemmer.g_v, 97, 121): return False # atlimit, line 52 if self.cursor > self.limit_backward: return False except lab0: pass return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_Step_1a(self): # (, line 58 # try, line 59 v_1 = self.limit - self.cursor try: # (, line 59 # [, line 60 self.ket = self.cursor # substring, line 60 among_var = self.find_among_b(EnglishStemmer.a_1, 3) if among_var == 0: self.cursor = self.limit - v_1 raise lab0() # ], line 60 self.bra = self.cursor if among_var == 0: self.cursor = self.limit - v_1 raise lab0() elif among_var == 1: # (, line 62 # delete, line 62 if not self.slice_del(): return False except lab0: pass # [, line 65 self.ket = self.cursor # substring, line 65 among_var = self.find_among_b(EnglishStemmer.a_2, 6) if among_var == 0: return False # ], line 65 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 66 # <-, line 66 if not self.slice_from(u"ss"): return False elif among_var == 2: # (, line 68 # or, line 68 try: v_2 = self.limit - self.cursor try: # (, line 68 # hop, line 68 c = self.cursor - 2 if self.limit_backward > c or c > self.limit: raise lab2() self.cursor = c # <-, line 68 if not self.slice_from(u"i"): return False raise lab1() except lab2: pass self.cursor = self.limit - v_2 # <-, line 68 if not self.slice_from(u"ie"): return False except lab1: pass elif among_var == 3: # (, line 69 # next, line 69 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # gopast, line 69 try: while True: try: if not self.in_grouping_b(EnglishStemmer.g_v, 97, 121): raise lab4() raise lab3() except lab4: pass if self.cursor <= self.limit_backward: return False self.cursor -= 1 except lab3: pass # delete, line 69 if not self.slice_del(): return False return True def r_Step_1b(self): # (, line 74 # [, line 75 self.ket = self.cursor # substring, line 75 among_var = self.find_among_b(EnglishStemmer.a_4, 6) if among_var == 0: return False # ], line 75 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 77 # call R1, line 77 if not self.r_R1(): return False # <-, line 77 if not self.slice_from(u"ee"): return False elif among_var == 2: # (, line 79 # test, line 80 v_1 = self.limit - self.cursor # gopast, line 80 try: while True: try: if not self.in_grouping_b(EnglishStemmer.g_v, 97, 121): raise lab1() raise lab0() except lab1: pass if self.cursor <= self.limit_backward: return False self.cursor -= 1 except lab0: pass self.cursor = self.limit - v_1 # delete, line 80 if not self.slice_del(): return False # test, line 81 v_3 = self.limit - self.cursor # substring, line 81 among_var = self.find_among_b(EnglishStemmer.a_3, 13) if among_var == 0: return False self.cursor = self.limit - v_3 if among_var == 0: return False elif among_var == 1: # (, line 83 # <+, line 83 c = self.cursor self.insert(self.cursor, self.cursor, u"e") self.cursor = c elif among_var == 2: # (, line 86 # [, line 86 self.ket = self.cursor # next, line 86 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # ], line 86 self.bra = self.cursor # delete, line 86 if not self.slice_del(): return False elif among_var == 3: # (, line 87 # atmark, line 87 if self.cursor != self.I_p1: return False # test, line 87 v_4 = self.limit - self.cursor # call shortv, line 87 if not self.r_shortv(): return False self.cursor = self.limit - v_4 # <+, line 87 c = self.cursor self.insert(self.cursor, self.cursor, u"e") self.cursor = c return True def r_Step_1c(self): # (, line 93 # [, line 94 self.ket = self.cursor # or, line 94 try: v_1 = self.limit - self.cursor try: # literal, line 94 if not self.eq_s_b(1, u"y"): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_1 # literal, line 94 if not self.eq_s_b(1, u"Y"): return False except lab0: pass # ], line 94 self.bra = self.cursor if not self.out_grouping_b(EnglishStemmer.g_v, 97, 121): return False # not, line 95 v_2 = self.limit - self.cursor try: # atlimit, line 95 if self.cursor > self.limit_backward: raise lab2() return False except lab2: pass self.cursor = self.limit - v_2 # <-, line 96 if not self.slice_from(u"i"): return False return True def r_Step_2(self): # (, line 99 # [, line 100 self.ket = self.cursor # substring, line 100 among_var = self.find_among_b(EnglishStemmer.a_5, 24) if among_var == 0: return False # ], line 100 self.bra = self.cursor # call R1, line 100 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 101 # <-, line 101 if not self.slice_from(u"tion"): return False elif among_var == 2: # (, line 102 # <-, line 102 if not self.slice_from(u"ence"): return False elif among_var == 3: # (, line 103 # <-, line 103 if not self.slice_from(u"ance"): return False elif among_var == 4: # (, line 104 # <-, line 104 if not self.slice_from(u"able"): return False elif among_var == 5: # (, line 105 # <-, line 105 if not self.slice_from(u"ent"): return False elif among_var == 6: # (, line 107 # <-, line 107 if not self.slice_from(u"ize"): return False elif among_var == 7: # (, line 109 # <-, line 109 if not self.slice_from(u"ate"): return False elif among_var == 8: # (, line 111 # <-, line 111 if not self.slice_from(u"al"): return False elif among_var == 9: # (, line 112 # <-, line 112 if not self.slice_from(u"ful"): return False elif among_var == 10: # (, line 114 # <-, line 114 if not self.slice_from(u"ous"): return False elif among_var == 11: # (, line 116 # <-, line 116 if not self.slice_from(u"ive"): return False elif among_var == 12: # (, line 118 # <-, line 118 if not self.slice_from(u"ble"): return False elif among_var == 13: # (, line 119 # literal, line 119 if not self.eq_s_b(1, u"l"): return False # <-, line 119 if not self.slice_from(u"og"): return False elif among_var == 14: # (, line 120 # <-, line 120 if not self.slice_from(u"ful"): return False elif among_var == 15: # (, line 121 # <-, line 121 if not self.slice_from(u"less"): return False elif among_var == 16: # (, line 122 if not self.in_grouping_b(EnglishStemmer.g_valid_LI, 99, 116): return False # delete, line 122 if not self.slice_del(): return False return True def r_Step_3(self): # (, line 126 # [, line 127 self.ket = self.cursor # substring, line 127 among_var = self.find_among_b(EnglishStemmer.a_6, 9) if among_var == 0: return False # ], line 127 self.bra = self.cursor # call R1, line 127 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 128 # <-, line 128 if not self.slice_from(u"tion"): return False elif among_var == 2: # (, line 129 # <-, line 129 if not self.slice_from(u"ate"): return False elif among_var == 3: # (, line 130 # <-, line 130 if not self.slice_from(u"al"): return False elif among_var == 4: # (, line 132 # <-, line 132 if not self.slice_from(u"ic"): return False elif among_var == 5: # (, line 134 # delete, line 134 if not self.slice_del(): return False elif among_var == 6: # (, line 136 # call R2, line 136 if not self.r_R2(): return False # delete, line 136 if not self.slice_del(): return False return True def r_Step_4(self): # (, line 140 # [, line 141 self.ket = self.cursor # substring, line 141 among_var = self.find_among_b(EnglishStemmer.a_7, 18) if among_var == 0: return False # ], line 141 self.bra = self.cursor # call R2, line 141 if not self.r_R2(): return False if among_var == 0: return False elif among_var == 1: # (, line 144 # delete, line 144 if not self.slice_del(): return False elif among_var == 2: # (, line 145 # or, line 145 try: v_1 = self.limit - self.cursor try: # literal, line 145 if not self.eq_s_b(1, u"s"): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_1 # literal, line 145 if not self.eq_s_b(1, u"t"): return False except lab0: pass # delete, line 145 if not self.slice_del(): return False return True def r_Step_5(self): # (, line 149 # [, line 150 self.ket = self.cursor # substring, line 150 among_var = self.find_among_b(EnglishStemmer.a_8, 2) if among_var == 0: return False # ], line 150 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 151 # or, line 151 try: v_1 = self.limit - self.cursor try: # call R2, line 151 if not self.r_R2(): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_1 # (, line 151 # call R1, line 151 if not self.r_R1(): return False # not, line 151 v_2 = self.limit - self.cursor try: # call shortv, line 151 if not self.r_shortv(): raise lab2() return False except lab2: pass self.cursor = self.limit - v_2 except lab0: pass # delete, line 151 if not self.slice_del(): return False elif among_var == 2: # (, line 152 # call R2, line 152 if not self.r_R2(): return False # literal, line 152 if not self.eq_s_b(1, u"l"): return False # delete, line 152 if not self.slice_del(): return False return True def r_exception2(self): # (, line 156 # [, line 158 self.ket = self.cursor # substring, line 158 if self.find_among_b(EnglishStemmer.a_9, 8) == 0: return False # ], line 158 self.bra = self.cursor # atlimit, line 158 if self.cursor > self.limit_backward: return False return True def r_exception1(self): # (, line 168 # [, line 170 self.bra = self.cursor # substring, line 170 among_var = self.find_among(EnglishStemmer.a_10, 18) if among_var == 0: return False # ], line 170 self.ket = self.cursor # atlimit, line 170 if self.cursor < self.limit: return False if among_var == 0: return False elif among_var == 1: # (, line 174 # <-, line 174 if not self.slice_from(u"ski"): return False elif among_var == 2: # (, line 175 # <-, line 175 if not self.slice_from(u"sky"): return False elif among_var == 3: # (, line 176 # <-, line 176 if not self.slice_from(u"die"): return False elif among_var == 4: # (, line 177 # <-, line 177 if not self.slice_from(u"lie"): return False elif among_var == 5: # (, line 178 # <-, line 178 if not self.slice_from(u"tie"): return False elif among_var == 6: # (, line 182 # <-, line 182 if not self.slice_from(u"idl"): return False elif among_var == 7: # (, line 183 # <-, line 183 if not self.slice_from(u"gentl"): return False elif among_var == 8: # (, line 184 # <-, line 184 if not self.slice_from(u"ugli"): return False elif among_var == 9: # (, line 185 # <-, line 185 if not self.slice_from(u"earli"): return False elif among_var == 10: # (, line 186 # <-, line 186 if not self.slice_from(u"onli"): return False elif among_var == 11: # (, line 187 # <-, line 187 if not self.slice_from(u"singl"): return False return True def r_postlude(self): # (, line 203 # Boolean test Y_found, line 203 if not self.B_Y_found: return False # repeat, line 203 try: while True: try: v_1 = self.cursor try: # (, line 203 # goto, line 203 try: while True: v_2 = self.cursor try: # (, line 203 # [, line 203 self.bra = self.cursor # literal, line 203 if not self.eq_s(1, u"Y"): raise lab4() # ], line 203 self.ket = self.cursor self.cursor = v_2 raise lab3() except lab4: pass self.cursor = v_2 if self.cursor >= self.limit: raise lab2() self.cursor += 1 except lab3: pass # <-, line 203 if not self.slice_from(u"y"): return False raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def _stem(self): # (, line 205 # or, line 207 try: v_1 = self.cursor try: # call exception1, line 207 if not self.r_exception1(): raise lab1() raise lab0() except lab1: pass self.cursor = v_1 try: # not, line 208 v_2 = self.cursor try: # hop, line 208 c = self.cursor + 3 if 0 > c or c > self.limit: raise lab3() self.cursor = c raise lab2() except lab3: pass self.cursor = v_2 raise lab0() except lab2: pass self.cursor = v_1 # (, line 208 # do, line 209 v_3 = self.cursor try: # call prelude, line 209 if not self.r_prelude(): raise lab4() except lab4: pass self.cursor = v_3 # do, line 210 v_4 = self.cursor try: # call mark_regions, line 210 if not self.r_mark_regions(): raise lab5() except lab5: pass self.cursor = v_4 # backwards, line 211 self.limit_backward = self.cursor self.cursor = self.limit # (, line 211 # do, line 213 v_5 = self.limit - self.cursor try: # call Step_1a, line 213 if not self.r_Step_1a(): raise lab6() except lab6: pass self.cursor = self.limit - v_5 # or, line 215 try: v_6 = self.limit - self.cursor try: # call exception2, line 215 if not self.r_exception2(): raise lab8() raise lab7() except lab8: pass self.cursor = self.limit - v_6 # (, line 215 # do, line 217 v_7 = self.limit - self.cursor try: # call Step_1b, line 217 if not self.r_Step_1b(): raise lab9() except lab9: pass self.cursor = self.limit - v_7 # do, line 218 v_8 = self.limit - self.cursor try: # call Step_1c, line 218 if not self.r_Step_1c(): raise lab10() except lab10: pass self.cursor = self.limit - v_8 # do, line 220 v_9 = self.limit - self.cursor try: # call Step_2, line 220 if not self.r_Step_2(): raise lab11() except lab11: pass self.cursor = self.limit - v_9 # do, line 221 v_10 = self.limit - self.cursor try: # call Step_3, line 221 if not self.r_Step_3(): raise lab12() except lab12: pass self.cursor = self.limit - v_10 # do, line 222 v_11 = self.limit - self.cursor try: # call Step_4, line 222 if not self.r_Step_4(): raise lab13() except lab13: pass self.cursor = self.limit - v_11 # do, line 224 v_12 = self.limit - self.cursor try: # call Step_5, line 224 if not self.r_Step_5(): raise lab14() except lab14: pass self.cursor = self.limit - v_12 except lab7: pass self.cursor = self.limit_backward # do, line 227 v_13 = self.cursor try: # call postlude, line 227 if not self.r_postlude(): raise lab15() except lab15: pass self.cursor = v_13 except lab0: pass return True def equals(self, o): return isinstance(o, EnglishStemmer) def hashCode(self): return hash("EnglishStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass class lab11(BaseException): pass class lab12(BaseException): pass class lab13(BaseException): pass class lab14(BaseException): pass class lab15(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/finnish_stemmer.py0000644€-©8€ZĂ);0000006200012637132734031010 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class FinnishStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"pa", -1, 1), Among(u"sti", -1, 2), Among(u"kaan", -1, 1), Among(u"han", -1, 1), Among(u"kin", -1, 1), Among(u"h\u00E4n", -1, 1), Among(u"k\u00E4\u00E4n", -1, 1), Among(u"ko", -1, 1), Among(u"p\u00E4", -1, 1), Among(u"k\u00F6", -1, 1) ] a_1 = [ Among(u"lla", -1, -1), Among(u"na", -1, -1), Among(u"ssa", -1, -1), Among(u"ta", -1, -1), Among(u"lta", 3, -1), Among(u"sta", 3, -1) ] a_2 = [ Among(u"ll\u00E4", -1, -1), Among(u"n\u00E4", -1, -1), Among(u"ss\u00E4", -1, -1), Among(u"t\u00E4", -1, -1), Among(u"lt\u00E4", 3, -1), Among(u"st\u00E4", 3, -1) ] a_3 = [ Among(u"lle", -1, -1), Among(u"ine", -1, -1) ] a_4 = [ Among(u"nsa", -1, 3), Among(u"mme", -1, 3), Among(u"nne", -1, 3), Among(u"ni", -1, 2), Among(u"si", -1, 1), Among(u"an", -1, 4), Among(u"en", -1, 6), Among(u"\u00E4n", -1, 5), Among(u"ns\u00E4", -1, 3) ] a_5 = [ Among(u"aa", -1, -1), Among(u"ee", -1, -1), Among(u"ii", -1, -1), Among(u"oo", -1, -1), Among(u"uu", -1, -1), Among(u"\u00E4\u00E4", -1, -1), Among(u"\u00F6\u00F6", -1, -1) ] a_6 = [ Among(u"a", -1, 8), Among(u"lla", 0, -1), Among(u"na", 0, -1), Among(u"ssa", 0, -1), Among(u"ta", 0, -1), Among(u"lta", 4, -1), Among(u"sta", 4, -1), Among(u"tta", 4, 9), Among(u"lle", -1, -1), Among(u"ine", -1, -1), Among(u"ksi", -1, -1), Among(u"n", -1, 7), Among(u"han", 11, 1), Among(u"den", 11, -1, "r_VI"), Among(u"seen", 11, -1, "r_LONG"), Among(u"hen", 11, 2), Among(u"tten", 11, -1, "r_VI"), Among(u"hin", 11, 3), Among(u"siin", 11, -1, "r_VI"), Among(u"hon", 11, 4), Among(u"h\u00E4n", 11, 5), Among(u"h\u00F6n", 11, 6), Among(u"\u00E4", -1, 8), Among(u"ll\u00E4", 22, -1), Among(u"n\u00E4", 22, -1), Among(u"ss\u00E4", 22, -1), Among(u"t\u00E4", 22, -1), Among(u"lt\u00E4", 26, -1), Among(u"st\u00E4", 26, -1), Among(u"tt\u00E4", 26, 9) ] a_7 = [ Among(u"eja", -1, -1), Among(u"mma", -1, 1), Among(u"imma", 1, -1), Among(u"mpa", -1, 1), Among(u"impa", 3, -1), Among(u"mmi", -1, 1), Among(u"immi", 5, -1), Among(u"mpi", -1, 1), Among(u"impi", 7, -1), Among(u"ej\u00E4", -1, -1), Among(u"mm\u00E4", -1, 1), Among(u"imm\u00E4", 10, -1), Among(u"mp\u00E4", -1, 1), Among(u"imp\u00E4", 12, -1) ] a_8 = [ Among(u"i", -1, -1), Among(u"j", -1, -1) ] a_9 = [ Among(u"mma", -1, 1), Among(u"imma", 0, -1) ] g_AEI = [17, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8] g_V1 = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32] g_V2 = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32] g_particle_end = [17, 97, 24, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32] B_ending_removed = False S_x = "" I_p2 = 0 I_p1 = 0 def copy_from(self, other): self.B_ending_removed = other.B_ending_removed self.S_x = other.S_x self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 super.copy_from(other) def r_mark_regions(self): # (, line 41 self.I_p1 = self.limit; self.I_p2 = self.limit; # goto, line 46 try: while True: v_1 = self.cursor try: if not self.in_grouping(FinnishStemmer.g_V1, 97, 246): raise lab1() self.cursor = v_1 raise lab0() except lab1: pass self.cursor = v_1 if self.cursor >= self.limit: return False self.cursor += 1 except lab0: pass # gopast, line 46 try: while True: try: if not self.out_grouping(FinnishStemmer.g_V1, 97, 246): raise lab3() raise lab2() except lab3: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab2: pass # setmark p1, line 46 self.I_p1 = self.cursor # goto, line 47 try: while True: v_3 = self.cursor try: if not self.in_grouping(FinnishStemmer.g_V1, 97, 246): raise lab5() self.cursor = v_3 raise lab4() except lab5: pass self.cursor = v_3 if self.cursor >= self.limit: return False self.cursor += 1 except lab4: pass # gopast, line 47 try: while True: try: if not self.out_grouping(FinnishStemmer.g_V1, 97, 246): raise lab7() raise lab6() except lab7: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab6: pass # setmark p2, line 47 self.I_p2 = self.cursor return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_particle_etc(self): # (, line 54 # setlimit, line 55 v_1 = self.limit - self.cursor # tomark, line 55 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 55 # [, line 55 self.ket = self.cursor # substring, line 55 among_var = self.find_among_b(FinnishStemmer.a_0, 10) if among_var == 0: self.limit_backward = v_2 return False # ], line 55 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 62 if not self.in_grouping_b(FinnishStemmer.g_particle_end, 97, 246): return False elif among_var == 2: # (, line 64 # call R2, line 64 if not self.r_R2(): return False # delete, line 66 if not self.slice_del(): return False return True def r_possessive(self): # (, line 68 # setlimit, line 69 v_1 = self.limit - self.cursor # tomark, line 69 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 69 # [, line 69 self.ket = self.cursor # substring, line 69 among_var = self.find_among_b(FinnishStemmer.a_4, 9) if among_var == 0: self.limit_backward = v_2 return False # ], line 69 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 72 # not, line 72 v_3 = self.limit - self.cursor try: # literal, line 72 if not self.eq_s_b(1, u"k"): raise lab0() return False except lab0: pass self.cursor = self.limit - v_3 # delete, line 72 if not self.slice_del(): return False elif among_var == 2: # (, line 74 # delete, line 74 if not self.slice_del(): return False # [, line 74 self.ket = self.cursor # literal, line 74 if not self.eq_s_b(3, u"kse"): return False # ], line 74 self.bra = self.cursor # <-, line 74 if not self.slice_from(u"ksi"): return False elif among_var == 3: # (, line 78 # delete, line 78 if not self.slice_del(): return False elif among_var == 4: # (, line 81 # among, line 81 if self.find_among_b(FinnishStemmer.a_1, 6) == 0: return False # delete, line 81 if not self.slice_del(): return False elif among_var == 5: # (, line 83 # among, line 83 if self.find_among_b(FinnishStemmer.a_2, 6) == 0: return False # delete, line 84 if not self.slice_del(): return False elif among_var == 6: # (, line 86 # among, line 86 if self.find_among_b(FinnishStemmer.a_3, 2) == 0: return False # delete, line 86 if not self.slice_del(): return False return True def r_LONG(self): # among, line 91 if self.find_among_b(FinnishStemmer.a_5, 7) == 0: return False return True def r_VI(self): # (, line 93 # literal, line 93 if not self.eq_s_b(1, u"i"): return False if not self.in_grouping_b(FinnishStemmer.g_V2, 97, 246): return False return True def r_case_ending(self): # (, line 95 # setlimit, line 96 v_1 = self.limit - self.cursor # tomark, line 96 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 96 # [, line 96 self.ket = self.cursor # substring, line 96 among_var = self.find_among_b(FinnishStemmer.a_6, 30) if among_var == 0: self.limit_backward = v_2 return False # ], line 96 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 98 # literal, line 98 if not self.eq_s_b(1, u"a"): return False elif among_var == 2: # (, line 99 # literal, line 99 if not self.eq_s_b(1, u"e"): return False elif among_var == 3: # (, line 100 # literal, line 100 if not self.eq_s_b(1, u"i"): return False elif among_var == 4: # (, line 101 # literal, line 101 if not self.eq_s_b(1, u"o"): return False elif among_var == 5: # (, line 102 # literal, line 102 if not self.eq_s_b(1, u"\u00E4"): return False elif among_var == 6: # (, line 103 # literal, line 103 if not self.eq_s_b(1, u"\u00F6"): return False elif among_var == 7: # (, line 111 # try, line 111 v_3 = self.limit - self.cursor try: # (, line 111 # and, line 113 v_4 = self.limit - self.cursor # or, line 112 try: v_5 = self.limit - self.cursor try: # call LONG, line 111 if not self.r_LONG(): raise lab2() raise lab1() except lab2: pass self.cursor = self.limit - v_5 # literal, line 112 if not self.eq_s_b(2, u"ie"): self.cursor = self.limit - v_3 raise lab0() except lab1: pass self.cursor = self.limit - v_4 # next, line 113 if self.cursor <= self.limit_backward: self.cursor = self.limit - v_3 raise lab0() self.cursor -= 1 # ], line 113 self.bra = self.cursor except lab0: pass elif among_var == 8: # (, line 119 if not self.in_grouping_b(FinnishStemmer.g_V1, 97, 246): return False if not self.out_grouping_b(FinnishStemmer.g_V1, 97, 246): return False elif among_var == 9: # (, line 121 # literal, line 121 if not self.eq_s_b(1, u"e"): return False # delete, line 138 if not self.slice_del(): return False # set ending_removed, line 139 self.B_ending_removed = True return True def r_other_endings(self): # (, line 141 # setlimit, line 142 v_1 = self.limit - self.cursor # tomark, line 142 if self.cursor < self.I_p2: return False self.cursor = self.I_p2 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 142 # [, line 142 self.ket = self.cursor # substring, line 142 among_var = self.find_among_b(FinnishStemmer.a_7, 14) if among_var == 0: self.limit_backward = v_2 return False # ], line 142 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 146 # not, line 146 v_3 = self.limit - self.cursor try: # literal, line 146 if not self.eq_s_b(2, u"po"): raise lab0() return False except lab0: pass self.cursor = self.limit - v_3 # delete, line 151 if not self.slice_del(): return False return True def r_i_plural(self): # (, line 153 # setlimit, line 154 v_1 = self.limit - self.cursor # tomark, line 154 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 154 # [, line 154 self.ket = self.cursor # substring, line 154 if self.find_among_b(FinnishStemmer.a_8, 2) == 0: self.limit_backward = v_2 return False # ], line 154 self.bra = self.cursor self.limit_backward = v_2 # delete, line 158 if not self.slice_del(): return False return True def r_t_plural(self): # (, line 160 # setlimit, line 161 v_1 = self.limit - self.cursor # tomark, line 161 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 161 # [, line 162 self.ket = self.cursor # literal, line 162 if not self.eq_s_b(1, u"t"): self.limit_backward = v_2 return False # ], line 162 self.bra = self.cursor # test, line 162 v_3 = self.limit - self.cursor if not self.in_grouping_b(FinnishStemmer.g_V1, 97, 246): self.limit_backward = v_2 return False self.cursor = self.limit - v_3 # delete, line 163 if not self.slice_del(): return False self.limit_backward = v_2 # setlimit, line 165 v_4 = self.limit - self.cursor # tomark, line 165 if self.cursor < self.I_p2: return False self.cursor = self.I_p2 v_5 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_4 # (, line 165 # [, line 165 self.ket = self.cursor # substring, line 165 among_var = self.find_among_b(FinnishStemmer.a_9, 2) if among_var == 0: self.limit_backward = v_5 return False # ], line 165 self.bra = self.cursor self.limit_backward = v_5 if among_var == 0: return False elif among_var == 1: # (, line 167 # not, line 167 v_6 = self.limit - self.cursor try: # literal, line 167 if not self.eq_s_b(2, u"po"): raise lab0() return False except lab0: pass self.cursor = self.limit - v_6 # delete, line 170 if not self.slice_del(): return False return True def r_tidy(self): # (, line 172 # setlimit, line 173 v_1 = self.limit - self.cursor # tomark, line 173 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 173 # do, line 174 v_3 = self.limit - self.cursor try: # (, line 174 # and, line 174 v_4 = self.limit - self.cursor # call LONG, line 174 if not self.r_LONG(): raise lab0() self.cursor = self.limit - v_4 # (, line 174 # [, line 174 self.ket = self.cursor # next, line 174 if self.cursor <= self.limit_backward: raise lab0() self.cursor -= 1 # ], line 174 self.bra = self.cursor # delete, line 174 if not self.slice_del(): return False except lab0: pass self.cursor = self.limit - v_3 # do, line 175 v_5 = self.limit - self.cursor try: # (, line 175 # [, line 175 self.ket = self.cursor if not self.in_grouping_b(FinnishStemmer.g_AEI, 97, 228): raise lab1() # ], line 175 self.bra = self.cursor if not self.out_grouping_b(FinnishStemmer.g_V1, 97, 246): raise lab1() # delete, line 175 if not self.slice_del(): return False except lab1: pass self.cursor = self.limit - v_5 # do, line 176 v_6 = self.limit - self.cursor try: # (, line 176 # [, line 176 self.ket = self.cursor # literal, line 176 if not self.eq_s_b(1, u"j"): raise lab2() # ], line 176 self.bra = self.cursor # or, line 176 try: v_7 = self.limit - self.cursor try: # literal, line 176 if not self.eq_s_b(1, u"o"): raise lab4() raise lab3() except lab4: pass self.cursor = self.limit - v_7 # literal, line 176 if not self.eq_s_b(1, u"u"): raise lab2() except lab3: pass # delete, line 176 if not self.slice_del(): return False except lab2: pass self.cursor = self.limit - v_6 # do, line 177 v_8 = self.limit - self.cursor try: # (, line 177 # [, line 177 self.ket = self.cursor # literal, line 177 if not self.eq_s_b(1, u"o"): raise lab5() # ], line 177 self.bra = self.cursor # literal, line 177 if not self.eq_s_b(1, u"j"): raise lab5() # delete, line 177 if not self.slice_del(): return False except lab5: pass self.cursor = self.limit - v_8 self.limit_backward = v_2 # goto, line 179 try: while True: v_9 = self.limit - self.cursor try: if not self.out_grouping_b(FinnishStemmer.g_V1, 97, 246): raise lab7() self.cursor = self.limit - v_9 raise lab6() except lab7: pass self.cursor = self.limit - v_9 if self.cursor <= self.limit_backward: return False self.cursor -= 1 except lab6: pass # [, line 179 self.ket = self.cursor # next, line 179 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # ], line 179 self.bra = self.cursor # -> x, line 179 self.S_x = self.slice_to(self.S_x) if self.S_x == '': return False # name x, line 179 if not self.eq_v_b(self.S_x): return False # delete, line 179 if not self.slice_del(): return False return True def _stem(self): # (, line 183 # do, line 185 v_1 = self.cursor try: # call mark_regions, line 185 if not self.r_mark_regions(): raise lab0() except lab0: pass self.cursor = v_1 # unset ending_removed, line 186 self.B_ending_removed = False # backwards, line 187 self.limit_backward = self.cursor self.cursor = self.limit # (, line 187 # do, line 188 v_2 = self.limit - self.cursor try: # call particle_etc, line 188 if not self.r_particle_etc(): raise lab1() except lab1: pass self.cursor = self.limit - v_2 # do, line 189 v_3 = self.limit - self.cursor try: # call possessive, line 189 if not self.r_possessive(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 # do, line 190 v_4 = self.limit - self.cursor try: # call case_ending, line 190 if not self.r_case_ending(): raise lab3() except lab3: pass self.cursor = self.limit - v_4 # do, line 191 v_5 = self.limit - self.cursor try: # call other_endings, line 191 if not self.r_other_endings(): raise lab4() except lab4: pass self.cursor = self.limit - v_5 # or, line 192 try: v_6 = self.limit - self.cursor try: # (, line 192 # Boolean test ending_removed, line 192 if not self.B_ending_removed: raise lab6() # do, line 192 v_7 = self.limit - self.cursor try: # call i_plural, line 192 if not self.r_i_plural(): raise lab7() except lab7: pass self.cursor = self.limit - v_7 raise lab5() except lab6: pass self.cursor = self.limit - v_6 # do, line 192 v_8 = self.limit - self.cursor try: # call t_plural, line 192 if not self.r_t_plural(): raise lab8() except lab8: pass self.cursor = self.limit - v_8 except lab5: pass # do, line 193 v_9 = self.limit - self.cursor try: # call tidy, line 193 if not self.r_tidy(): raise lab9() except lab9: pass self.cursor = self.limit - v_9 self.cursor = self.limit_backward return True def equals(self, o): return isinstance(o, FinnishStemmer) def hashCode(self): return hash("FinnishStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/french_stemmer.py0000644€-©8€ZĂ);0000013134212637132734030625 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class FrenchStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"col", -1, -1), Among(u"par", -1, -1), Among(u"tap", -1, -1) ] a_1 = [ Among(u"", -1, 4), Among(u"I", 0, 1), Among(u"U", 0, 2), Among(u"Y", 0, 3) ] a_2 = [ Among(u"iqU", -1, 3), Among(u"abl", -1, 3), Among(u"I\u00E8r", -1, 4), Among(u"i\u00E8r", -1, 4), Among(u"eus", -1, 2), Among(u"iv", -1, 1) ] a_3 = [ Among(u"ic", -1, 2), Among(u"abil", -1, 1), Among(u"iv", -1, 3) ] a_4 = [ Among(u"iqUe", -1, 1), Among(u"atrice", -1, 2), Among(u"ance", -1, 1), Among(u"ence", -1, 5), Among(u"logie", -1, 3), Among(u"able", -1, 1), Among(u"isme", -1, 1), Among(u"euse", -1, 11), Among(u"iste", -1, 1), Among(u"ive", -1, 8), Among(u"if", -1, 8), Among(u"usion", -1, 4), Among(u"ation", -1, 2), Among(u"ution", -1, 4), Among(u"ateur", -1, 2), Among(u"iqUes", -1, 1), Among(u"atrices", -1, 2), Among(u"ances", -1, 1), Among(u"ences", -1, 5), Among(u"logies", -1, 3), Among(u"ables", -1, 1), Among(u"ismes", -1, 1), Among(u"euses", -1, 11), Among(u"istes", -1, 1), Among(u"ives", -1, 8), Among(u"ifs", -1, 8), Among(u"usions", -1, 4), Among(u"ations", -1, 2), Among(u"utions", -1, 4), Among(u"ateurs", -1, 2), Among(u"ments", -1, 15), Among(u"ements", 30, 6), Among(u"issements", 31, 12), Among(u"it\u00E9s", -1, 7), Among(u"ment", -1, 15), Among(u"ement", 34, 6), Among(u"issement", 35, 12), Among(u"amment", 34, 13), Among(u"emment", 34, 14), Among(u"aux", -1, 10), Among(u"eaux", 39, 9), Among(u"eux", -1, 1), Among(u"it\u00E9", -1, 7) ] a_5 = [ Among(u"ira", -1, 1), Among(u"ie", -1, 1), Among(u"isse", -1, 1), Among(u"issante", -1, 1), Among(u"i", -1, 1), Among(u"irai", 4, 1), Among(u"ir", -1, 1), Among(u"iras", -1, 1), Among(u"ies", -1, 1), Among(u"\u00EEmes", -1, 1), Among(u"isses", -1, 1), Among(u"issantes", -1, 1), Among(u"\u00EEtes", -1, 1), Among(u"is", -1, 1), Among(u"irais", 13, 1), Among(u"issais", 13, 1), Among(u"irions", -1, 1), Among(u"issions", -1, 1), Among(u"irons", -1, 1), Among(u"issons", -1, 1), Among(u"issants", -1, 1), Among(u"it", -1, 1), Among(u"irait", 21, 1), Among(u"issait", 21, 1), Among(u"issant", -1, 1), Among(u"iraIent", -1, 1), Among(u"issaIent", -1, 1), Among(u"irent", -1, 1), Among(u"issent", -1, 1), Among(u"iront", -1, 1), Among(u"\u00EEt", -1, 1), Among(u"iriez", -1, 1), Among(u"issiez", -1, 1), Among(u"irez", -1, 1), Among(u"issez", -1, 1) ] a_6 = [ Among(u"a", -1, 3), Among(u"era", 0, 2), Among(u"asse", -1, 3), Among(u"ante", -1, 3), Among(u"\u00E9e", -1, 2), Among(u"ai", -1, 3), Among(u"erai", 5, 2), Among(u"er", -1, 2), Among(u"as", -1, 3), Among(u"eras", 8, 2), Among(u"\u00E2mes", -1, 3), Among(u"asses", -1, 3), Among(u"antes", -1, 3), Among(u"\u00E2tes", -1, 3), Among(u"\u00E9es", -1, 2), Among(u"ais", -1, 3), Among(u"erais", 15, 2), Among(u"ions", -1, 1), Among(u"erions", 17, 2), Among(u"assions", 17, 3), Among(u"erons", -1, 2), Among(u"ants", -1, 3), Among(u"\u00E9s", -1, 2), Among(u"ait", -1, 3), Among(u"erait", 23, 2), Among(u"ant", -1, 3), Among(u"aIent", -1, 3), Among(u"eraIent", 26, 2), Among(u"\u00E8rent", -1, 2), Among(u"assent", -1, 3), Among(u"eront", -1, 2), Among(u"\u00E2t", -1, 3), Among(u"ez", -1, 2), Among(u"iez", 32, 2), Among(u"eriez", 33, 2), Among(u"assiez", 33, 3), Among(u"erez", 32, 2), Among(u"\u00E9", -1, 2) ] a_7 = [ Among(u"e", -1, 3), Among(u"I\u00E8re", 0, 2), Among(u"i\u00E8re", 0, 2), Among(u"ion", -1, 1), Among(u"Ier", -1, 2), Among(u"ier", -1, 2), Among(u"\u00EB", -1, 4) ] a_8 = [ Among(u"ell", -1, -1), Among(u"eill", -1, -1), Among(u"enn", -1, -1), Among(u"onn", -1, -1), Among(u"ett", -1, -1) ] g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 130, 103, 8, 5] g_keep_with_s = [1, 65, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128] I_p2 = 0 I_p1 = 0 I_pV = 0 def copy_from(self, other): self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 self.I_pV = other.I_pV super.copy_from(other) def r_prelude(self): # repeat, line 38 try: while True: try: v_1 = self.cursor try: # goto, line 38 try: while True: v_2 = self.cursor try: # (, line 38 # or, line 44 try: v_3 = self.cursor try: # (, line 40 if not self.in_grouping(FrenchStemmer.g_v, 97, 251): raise lab6() # [, line 40 self.bra = self.cursor # or, line 40 try: v_4 = self.cursor try: # (, line 40 # literal, line 40 if not self.eq_s(1, u"u"): raise lab8() # ], line 40 self.ket = self.cursor if not self.in_grouping(FrenchStemmer.g_v, 97, 251): raise lab8() # <-, line 40 if not self.slice_from(u"U"): return False raise lab7() except lab8: pass self.cursor = v_4 try: # (, line 41 # literal, line 41 if not self.eq_s(1, u"i"): raise lab9() # ], line 41 self.ket = self.cursor if not self.in_grouping(FrenchStemmer.g_v, 97, 251): raise lab9() # <-, line 41 if not self.slice_from(u"I"): return False raise lab7() except lab9: pass self.cursor = v_4 # (, line 42 # literal, line 42 if not self.eq_s(1, u"y"): raise lab6() # ], line 42 self.ket = self.cursor # <-, line 42 if not self.slice_from(u"Y"): return False except lab7: pass raise lab5() except lab6: pass self.cursor = v_3 try: # (, line 45 # [, line 45 self.bra = self.cursor # literal, line 45 if not self.eq_s(1, u"y"): raise lab10() # ], line 45 self.ket = self.cursor if not self.in_grouping(FrenchStemmer.g_v, 97, 251): raise lab10() # <-, line 45 if not self.slice_from(u"Y"): return False raise lab5() except lab10: pass self.cursor = v_3 # (, line 47 # literal, line 47 if not self.eq_s(1, u"q"): raise lab4() # [, line 47 self.bra = self.cursor # literal, line 47 if not self.eq_s(1, u"u"): raise lab4() # ], line 47 self.ket = self.cursor # <-, line 47 if not self.slice_from(u"U"): return False except lab5: pass self.cursor = v_2 raise lab3() except lab4: pass self.cursor = v_2 if self.cursor >= self.limit: raise lab2() self.cursor += 1 except lab3: pass raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_mark_regions(self): # (, line 50 self.I_pV = self.limit; self.I_p1 = self.limit; self.I_p2 = self.limit; # do, line 56 v_1 = self.cursor try: # (, line 56 # or, line 58 try: v_2 = self.cursor try: # (, line 57 if not self.in_grouping(FrenchStemmer.g_v, 97, 251): raise lab2() if not self.in_grouping(FrenchStemmer.g_v, 97, 251): raise lab2() # next, line 57 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_2 try: # among, line 59 if self.find_among(FrenchStemmer.a_0, 3) == 0: raise lab3() raise lab1() except lab3: pass self.cursor = v_2 # (, line 66 # next, line 66 if self.cursor >= self.limit: raise lab0() self.cursor += 1 # gopast, line 66 try: while True: try: if not self.in_grouping(FrenchStemmer.g_v, 97, 251): raise lab5() raise lab4() except lab5: pass if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab4: pass except lab1: pass # setmark pV, line 67 self.I_pV = self.cursor except lab0: pass self.cursor = v_1 # do, line 69 v_4 = self.cursor try: # (, line 69 # gopast, line 70 try: while True: try: if not self.in_grouping(FrenchStemmer.g_v, 97, 251): raise lab8() raise lab7() except lab8: pass if self.cursor >= self.limit: raise lab6() self.cursor += 1 except lab7: pass # gopast, line 70 try: while True: try: if not self.out_grouping(FrenchStemmer.g_v, 97, 251): raise lab10() raise lab9() except lab10: pass if self.cursor >= self.limit: raise lab6() self.cursor += 1 except lab9: pass # setmark p1, line 70 self.I_p1 = self.cursor # gopast, line 71 try: while True: try: if not self.in_grouping(FrenchStemmer.g_v, 97, 251): raise lab12() raise lab11() except lab12: pass if self.cursor >= self.limit: raise lab6() self.cursor += 1 except lab11: pass # gopast, line 71 try: while True: try: if not self.out_grouping(FrenchStemmer.g_v, 97, 251): raise lab14() raise lab13() except lab14: pass if self.cursor >= self.limit: raise lab6() self.cursor += 1 except lab13: pass # setmark p2, line 71 self.I_p2 = self.cursor except lab6: pass self.cursor = v_4 return True def r_postlude(self): # repeat, line 75 try: while True: try: v_1 = self.cursor try: # (, line 75 # [, line 77 self.bra = self.cursor # substring, line 77 among_var = self.find_among(FrenchStemmer.a_1, 4) if among_var == 0: raise lab2() # ], line 77 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 78 # <-, line 78 if not self.slice_from(u"i"): return False elif among_var == 2: # (, line 79 # <-, line 79 if not self.slice_from(u"u"): return False elif among_var == 3: # (, line 80 # <-, line 80 if not self.slice_from(u"y"): return False elif among_var == 4: # (, line 81 # next, line 81 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_RV(self): if not self.I_pV <= self.cursor: return False return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_standard_suffix(self): # (, line 91 # [, line 92 self.ket = self.cursor # substring, line 92 among_var = self.find_among_b(FrenchStemmer.a_4, 43) if among_var == 0: return False # ], line 92 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 96 # call R2, line 96 if not self.r_R2(): return False # delete, line 96 if not self.slice_del(): return False elif among_var == 2: # (, line 99 # call R2, line 99 if not self.r_R2(): return False # delete, line 99 if not self.slice_del(): return False # try, line 100 v_1 = self.limit - self.cursor try: # (, line 100 # [, line 100 self.ket = self.cursor # literal, line 100 if not self.eq_s_b(2, u"ic"): self.cursor = self.limit - v_1 raise lab0() # ], line 100 self.bra = self.cursor # or, line 100 try: v_2 = self.limit - self.cursor try: # (, line 100 # call R2, line 100 if not self.r_R2(): raise lab2() # delete, line 100 if not self.slice_del(): return False raise lab1() except lab2: pass self.cursor = self.limit - v_2 # <-, line 100 if not self.slice_from(u"iqU"): return False except lab1: pass except lab0: pass elif among_var == 3: # (, line 104 # call R2, line 104 if not self.r_R2(): return False # <-, line 104 if not self.slice_from(u"log"): return False elif among_var == 4: # (, line 107 # call R2, line 107 if not self.r_R2(): return False # <-, line 107 if not self.slice_from(u"u"): return False elif among_var == 5: # (, line 110 # call R2, line 110 if not self.r_R2(): return False # <-, line 110 if not self.slice_from(u"ent"): return False elif among_var == 6: # (, line 113 # call RV, line 114 if not self.r_RV(): return False # delete, line 114 if not self.slice_del(): return False # try, line 115 v_3 = self.limit - self.cursor try: # (, line 115 # [, line 116 self.ket = self.cursor # substring, line 116 among_var = self.find_among_b(FrenchStemmer.a_2, 6) if among_var == 0: self.cursor = self.limit - v_3 raise lab3() # ], line 116 self.bra = self.cursor if among_var == 0: self.cursor = self.limit - v_3 raise lab3() elif among_var == 1: # (, line 117 # call R2, line 117 if not self.r_R2(): self.cursor = self.limit - v_3 raise lab3() # delete, line 117 if not self.slice_del(): return False # [, line 117 self.ket = self.cursor # literal, line 117 if not self.eq_s_b(2, u"at"): self.cursor = self.limit - v_3 raise lab3() # ], line 117 self.bra = self.cursor # call R2, line 117 if not self.r_R2(): self.cursor = self.limit - v_3 raise lab3() # delete, line 117 if not self.slice_del(): return False elif among_var == 2: # (, line 118 # or, line 118 try: v_4 = self.limit - self.cursor try: # (, line 118 # call R2, line 118 if not self.r_R2(): raise lab5() # delete, line 118 if not self.slice_del(): return False raise lab4() except lab5: pass self.cursor = self.limit - v_4 # (, line 118 # call R1, line 118 if not self.r_R1(): self.cursor = self.limit - v_3 raise lab3() # <-, line 118 if not self.slice_from(u"eux"): return False except lab4: pass elif among_var == 3: # (, line 120 # call R2, line 120 if not self.r_R2(): self.cursor = self.limit - v_3 raise lab3() # delete, line 120 if not self.slice_del(): return False elif among_var == 4: # (, line 122 # call RV, line 122 if not self.r_RV(): self.cursor = self.limit - v_3 raise lab3() # <-, line 122 if not self.slice_from(u"i"): return False except lab3: pass elif among_var == 7: # (, line 128 # call R2, line 129 if not self.r_R2(): return False # delete, line 129 if not self.slice_del(): return False # try, line 130 v_5 = self.limit - self.cursor try: # (, line 130 # [, line 131 self.ket = self.cursor # substring, line 131 among_var = self.find_among_b(FrenchStemmer.a_3, 3) if among_var == 0: self.cursor = self.limit - v_5 raise lab6() # ], line 131 self.bra = self.cursor if among_var == 0: self.cursor = self.limit - v_5 raise lab6() elif among_var == 1: # (, line 132 # or, line 132 try: v_6 = self.limit - self.cursor try: # (, line 132 # call R2, line 132 if not self.r_R2(): raise lab8() # delete, line 132 if not self.slice_del(): return False raise lab7() except lab8: pass self.cursor = self.limit - v_6 # <-, line 132 if not self.slice_from(u"abl"): return False except lab7: pass elif among_var == 2: # (, line 133 # or, line 133 try: v_7 = self.limit - self.cursor try: # (, line 133 # call R2, line 133 if not self.r_R2(): raise lab10() # delete, line 133 if not self.slice_del(): return False raise lab9() except lab10: pass self.cursor = self.limit - v_7 # <-, line 133 if not self.slice_from(u"iqU"): return False except lab9: pass elif among_var == 3: # (, line 134 # call R2, line 134 if not self.r_R2(): self.cursor = self.limit - v_5 raise lab6() # delete, line 134 if not self.slice_del(): return False except lab6: pass elif among_var == 8: # (, line 140 # call R2, line 141 if not self.r_R2(): return False # delete, line 141 if not self.slice_del(): return False # try, line 142 v_8 = self.limit - self.cursor try: # (, line 142 # [, line 142 self.ket = self.cursor # literal, line 142 if not self.eq_s_b(2, u"at"): self.cursor = self.limit - v_8 raise lab11() # ], line 142 self.bra = self.cursor # call R2, line 142 if not self.r_R2(): self.cursor = self.limit - v_8 raise lab11() # delete, line 142 if not self.slice_del(): return False # [, line 142 self.ket = self.cursor # literal, line 142 if not self.eq_s_b(2, u"ic"): self.cursor = self.limit - v_8 raise lab11() # ], line 142 self.bra = self.cursor # or, line 142 try: v_9 = self.limit - self.cursor try: # (, line 142 # call R2, line 142 if not self.r_R2(): raise lab13() # delete, line 142 if not self.slice_del(): return False raise lab12() except lab13: pass self.cursor = self.limit - v_9 # <-, line 142 if not self.slice_from(u"iqU"): return False except lab12: pass except lab11: pass elif among_var == 9: # (, line 144 # <-, line 144 if not self.slice_from(u"eau"): return False elif among_var == 10: # (, line 145 # call R1, line 145 if not self.r_R1(): return False # <-, line 145 if not self.slice_from(u"al"): return False elif among_var == 11: # (, line 147 # or, line 147 try: v_10 = self.limit - self.cursor try: # (, line 147 # call R2, line 147 if not self.r_R2(): raise lab15() # delete, line 147 if not self.slice_del(): return False raise lab14() except lab15: pass self.cursor = self.limit - v_10 # (, line 147 # call R1, line 147 if not self.r_R1(): return False # <-, line 147 if not self.slice_from(u"eux"): return False except lab14: pass elif among_var == 12: # (, line 150 # call R1, line 150 if not self.r_R1(): return False if not self.out_grouping_b(FrenchStemmer.g_v, 97, 251): return False # delete, line 150 if not self.slice_del(): return False elif among_var == 13: # (, line 155 # call RV, line 155 if not self.r_RV(): return False # fail, line 155 # (, line 155 # <-, line 155 if not self.slice_from(u"ant"): return False return False elif among_var == 14: # (, line 156 # call RV, line 156 if not self.r_RV(): return False # fail, line 156 # (, line 156 # <-, line 156 if not self.slice_from(u"ent"): return False return False elif among_var == 15: # (, line 158 # test, line 158 v_11 = self.limit - self.cursor # (, line 158 if not self.in_grouping_b(FrenchStemmer.g_v, 97, 251): return False # call RV, line 158 if not self.r_RV(): return False self.cursor = self.limit - v_11 # fail, line 158 # (, line 158 # delete, line 158 if not self.slice_del(): return False return False return True def r_i_verb_suffix(self): # setlimit, line 163 v_1 = self.limit - self.cursor # tomark, line 163 if self.cursor < self.I_pV: return False self.cursor = self.I_pV v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 163 # [, line 164 self.ket = self.cursor # substring, line 164 among_var = self.find_among_b(FrenchStemmer.a_5, 35) if among_var == 0: self.limit_backward = v_2 return False # ], line 164 self.bra = self.cursor if among_var == 0: self.limit_backward = v_2 return False elif among_var == 1: # (, line 170 if not self.out_grouping_b(FrenchStemmer.g_v, 97, 251): self.limit_backward = v_2 return False # delete, line 170 if not self.slice_del(): return False self.limit_backward = v_2 return True def r_verb_suffix(self): # setlimit, line 174 v_1 = self.limit - self.cursor # tomark, line 174 if self.cursor < self.I_pV: return False self.cursor = self.I_pV v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 174 # [, line 175 self.ket = self.cursor # substring, line 175 among_var = self.find_among_b(FrenchStemmer.a_6, 38) if among_var == 0: self.limit_backward = v_2 return False # ], line 175 self.bra = self.cursor if among_var == 0: self.limit_backward = v_2 return False elif among_var == 1: # (, line 177 # call R2, line 177 if not self.r_R2(): self.limit_backward = v_2 return False # delete, line 177 if not self.slice_del(): return False elif among_var == 2: # (, line 185 # delete, line 185 if not self.slice_del(): return False elif among_var == 3: # (, line 190 # delete, line 190 if not self.slice_del(): return False # try, line 191 v_3 = self.limit - self.cursor try: # (, line 191 # [, line 191 self.ket = self.cursor # literal, line 191 if not self.eq_s_b(1, u"e"): self.cursor = self.limit - v_3 raise lab0() # ], line 191 self.bra = self.cursor # delete, line 191 if not self.slice_del(): return False except lab0: pass self.limit_backward = v_2 return True def r_residual_suffix(self): # (, line 198 # try, line 199 v_1 = self.limit - self.cursor try: # (, line 199 # [, line 199 self.ket = self.cursor # literal, line 199 if not self.eq_s_b(1, u"s"): self.cursor = self.limit - v_1 raise lab0() # ], line 199 self.bra = self.cursor # test, line 199 v_2 = self.limit - self.cursor if not self.out_grouping_b(FrenchStemmer.g_keep_with_s, 97, 232): self.cursor = self.limit - v_1 raise lab0() self.cursor = self.limit - v_2 # delete, line 199 if not self.slice_del(): return False except lab0: pass # setlimit, line 200 v_3 = self.limit - self.cursor # tomark, line 200 if self.cursor < self.I_pV: return False self.cursor = self.I_pV v_4 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_3 # (, line 200 # [, line 201 self.ket = self.cursor # substring, line 201 among_var = self.find_among_b(FrenchStemmer.a_7, 7) if among_var == 0: self.limit_backward = v_4 return False # ], line 201 self.bra = self.cursor if among_var == 0: self.limit_backward = v_4 return False elif among_var == 1: # (, line 202 # call R2, line 202 if not self.r_R2(): self.limit_backward = v_4 return False # or, line 202 try: v_5 = self.limit - self.cursor try: # literal, line 202 if not self.eq_s_b(1, u"s"): raise lab2() raise lab1() except lab2: pass self.cursor = self.limit - v_5 # literal, line 202 if not self.eq_s_b(1, u"t"): self.limit_backward = v_4 return False except lab1: pass # delete, line 202 if not self.slice_del(): return False elif among_var == 2: # (, line 204 # <-, line 204 if not self.slice_from(u"i"): return False elif among_var == 3: # (, line 205 # delete, line 205 if not self.slice_del(): return False elif among_var == 4: # (, line 206 # literal, line 206 if not self.eq_s_b(2, u"gu"): self.limit_backward = v_4 return False # delete, line 206 if not self.slice_del(): return False self.limit_backward = v_4 return True def r_un_double(self): # (, line 211 # test, line 212 v_1 = self.limit - self.cursor # among, line 212 if self.find_among_b(FrenchStemmer.a_8, 5) == 0: return False self.cursor = self.limit - v_1 # [, line 212 self.ket = self.cursor # next, line 212 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # ], line 212 self.bra = self.cursor # delete, line 212 if not self.slice_del(): return False return True def r_un_accent(self): # (, line 215 # atleast, line 216 v_1 = 1 # atleast, line 216 try: while True: try: try: if not self.out_grouping_b(FrenchStemmer.g_v, 97, 251): raise lab2() v_1 -= 1 raise lab1() except lab2: pass raise lab0() except lab1: pass except lab0: pass if v_1 > 0: return False # [, line 217 self.ket = self.cursor # or, line 217 try: v_3 = self.limit - self.cursor try: # literal, line 217 if not self.eq_s_b(1, u"\u00E9"): raise lab4() raise lab3() except lab4: pass self.cursor = self.limit - v_3 # literal, line 217 if not self.eq_s_b(1, u"\u00E8"): return False except lab3: pass # ], line 217 self.bra = self.cursor # <-, line 217 if not self.slice_from(u"e"): return False return True def _stem(self): # (, line 221 # do, line 223 v_1 = self.cursor try: # call prelude, line 223 if not self.r_prelude(): raise lab0() except lab0: pass self.cursor = v_1 # do, line 224 v_2 = self.cursor try: # call mark_regions, line 224 if not self.r_mark_regions(): raise lab1() except lab1: pass self.cursor = v_2 # backwards, line 225 self.limit_backward = self.cursor self.cursor = self.limit # (, line 225 # do, line 227 v_3 = self.limit - self.cursor try: # (, line 227 # or, line 237 try: v_4 = self.limit - self.cursor try: # (, line 228 # and, line 233 v_5 = self.limit - self.cursor # (, line 229 # or, line 229 try: v_6 = self.limit - self.cursor try: # call standard_suffix, line 229 if not self.r_standard_suffix(): raise lab6() raise lab5() except lab6: pass self.cursor = self.limit - v_6 try: # call i_verb_suffix, line 230 if not self.r_i_verb_suffix(): raise lab7() raise lab5() except lab7: pass self.cursor = self.limit - v_6 # call verb_suffix, line 231 if not self.r_verb_suffix(): raise lab4() except lab5: pass self.cursor = self.limit - v_5 # try, line 234 v_7 = self.limit - self.cursor try: # (, line 234 # [, line 234 self.ket = self.cursor # or, line 234 try: v_8 = self.limit - self.cursor try: # (, line 234 # literal, line 234 if not self.eq_s_b(1, u"Y"): raise lab10() # ], line 234 self.bra = self.cursor # <-, line 234 if not self.slice_from(u"i"): return False raise lab9() except lab10: pass self.cursor = self.limit - v_8 # (, line 235 # literal, line 235 if not self.eq_s_b(1, u"\u00E7"): self.cursor = self.limit - v_7 raise lab8() # ], line 235 self.bra = self.cursor # <-, line 235 if not self.slice_from(u"c"): return False except lab9: pass except lab8: pass raise lab3() except lab4: pass self.cursor = self.limit - v_4 # call residual_suffix, line 238 if not self.r_residual_suffix(): raise lab2() except lab3: pass except lab2: pass self.cursor = self.limit - v_3 # do, line 243 v_9 = self.limit - self.cursor try: # call un_double, line 243 if not self.r_un_double(): raise lab11() except lab11: pass self.cursor = self.limit - v_9 # do, line 244 v_10 = self.limit - self.cursor try: # call un_accent, line 244 if not self.r_un_accent(): raise lab12() except lab12: pass self.cursor = self.limit - v_10 self.cursor = self.limit_backward # do, line 246 v_11 = self.cursor try: # call postlude, line 246 if not self.r_postlude(): raise lab13() except lab13: pass self.cursor = v_11 return True def equals(self, o): return isinstance(o, FrenchStemmer) def hashCode(self): return hash("FrenchStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass class lab11(BaseException): pass class lab12(BaseException): pass class lab13(BaseException): pass class lab14(BaseException): pass class lab15(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/german_stemmer.py0000644€-©8€ZĂ);0000005163212637132734030634 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class GermanStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"", -1, 6), Among(u"U", 0, 2), Among(u"Y", 0, 1), Among(u"\u00E4", 0, 3), Among(u"\u00F6", 0, 4), Among(u"\u00FC", 0, 5) ] a_1 = [ Among(u"e", -1, 2), Among(u"em", -1, 1), Among(u"en", -1, 2), Among(u"ern", -1, 1), Among(u"er", -1, 1), Among(u"s", -1, 3), Among(u"es", 5, 2) ] a_2 = [ Among(u"en", -1, 1), Among(u"er", -1, 1), Among(u"st", -1, 2), Among(u"est", 2, 1) ] a_3 = [ Among(u"ig", -1, 1), Among(u"lich", -1, 1) ] a_4 = [ Among(u"end", -1, 1), Among(u"ig", -1, 2), Among(u"ung", -1, 1), Among(u"lich", -1, 3), Among(u"isch", -1, 2), Among(u"ik", -1, 2), Among(u"heit", -1, 3), Among(u"keit", -1, 4) ] g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32, 8] g_s_ending = [117, 30, 5] g_st_ending = [117, 30, 4] I_x = 0 I_p2 = 0 I_p1 = 0 def copy_from(self, other): self.I_x = other.I_x self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 super.copy_from(other) def r_prelude(self): # (, line 33 # test, line 35 v_1 = self.cursor # repeat, line 35 try: while True: try: v_2 = self.cursor try: # (, line 35 # or, line 38 try: v_3 = self.cursor try: # (, line 36 # [, line 37 self.bra = self.cursor # literal, line 37 if not self.eq_s(1, u"\u00DF"): raise lab4() # ], line 37 self.ket = self.cursor # <-, line 37 if not self.slice_from(u"ss"): return False raise lab3() except lab4: pass self.cursor = v_3 # next, line 38 if self.cursor >= self.limit: raise lab2() self.cursor += 1 except lab3: pass raise lab1() except lab2: pass self.cursor = v_2 raise lab0() except lab1: pass except lab0: pass self.cursor = v_1 # repeat, line 41 try: while True: try: v_4 = self.cursor try: # goto, line 41 try: while True: v_5 = self.cursor try: # (, line 41 if not self.in_grouping(GermanStemmer.g_v, 97, 252): raise lab9() # [, line 42 self.bra = self.cursor # or, line 42 try: v_6 = self.cursor try: # (, line 42 # literal, line 42 if not self.eq_s(1, u"u"): raise lab11() # ], line 42 self.ket = self.cursor if not self.in_grouping(GermanStemmer.g_v, 97, 252): raise lab11() # <-, line 42 if not self.slice_from(u"U"): return False raise lab10() except lab11: pass self.cursor = v_6 # (, line 43 # literal, line 43 if not self.eq_s(1, u"y"): raise lab9() # ], line 43 self.ket = self.cursor if not self.in_grouping(GermanStemmer.g_v, 97, 252): raise lab9() # <-, line 43 if not self.slice_from(u"Y"): return False except lab10: pass self.cursor = v_5 raise lab8() except lab9: pass self.cursor = v_5 if self.cursor >= self.limit: raise lab7() self.cursor += 1 except lab8: pass raise lab6() except lab7: pass self.cursor = v_4 raise lab5() except lab6: pass except lab5: pass return True def r_mark_regions(self): # (, line 47 self.I_p1 = self.limit; self.I_p2 = self.limit; # test, line 52 v_1 = self.cursor # (, line 52 # hop, line 52 c = self.cursor + 3 if 0 > c or c > self.limit: return False self.cursor = c # setmark x, line 52 self.I_x = self.cursor self.cursor = v_1 # gopast, line 54 try: while True: try: if not self.in_grouping(GermanStemmer.g_v, 97, 252): raise lab1() raise lab0() except lab1: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab0: pass # gopast, line 54 try: while True: try: if not self.out_grouping(GermanStemmer.g_v, 97, 252): raise lab3() raise lab2() except lab3: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab2: pass # setmark p1, line 54 self.I_p1 = self.cursor # try, line 55 try: # (, line 55 if not (self.I_p1 < self.I_x): raise lab4() self.I_p1 = self.I_x; except lab4: pass # gopast, line 56 try: while True: try: if not self.in_grouping(GermanStemmer.g_v, 97, 252): raise lab6() raise lab5() except lab6: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab5: pass # gopast, line 56 try: while True: try: if not self.out_grouping(GermanStemmer.g_v, 97, 252): raise lab8() raise lab7() except lab8: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab7: pass # setmark p2, line 56 self.I_p2 = self.cursor return True def r_postlude(self): # repeat, line 60 try: while True: try: v_1 = self.cursor try: # (, line 60 # [, line 62 self.bra = self.cursor # substring, line 62 among_var = self.find_among(GermanStemmer.a_0, 6) if among_var == 0: raise lab2() # ], line 62 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 63 # <-, line 63 if not self.slice_from(u"y"): return False elif among_var == 2: # (, line 64 # <-, line 64 if not self.slice_from(u"u"): return False elif among_var == 3: # (, line 65 # <-, line 65 if not self.slice_from(u"a"): return False elif among_var == 4: # (, line 66 # <-, line 66 if not self.slice_from(u"o"): return False elif among_var == 5: # (, line 67 # <-, line 67 if not self.slice_from(u"u"): return False elif among_var == 6: # (, line 68 # next, line 68 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_standard_suffix(self): # (, line 78 # do, line 79 v_1 = self.limit - self.cursor try: # (, line 79 # [, line 80 self.ket = self.cursor # substring, line 80 among_var = self.find_among_b(GermanStemmer.a_1, 7) if among_var == 0: raise lab0() # ], line 80 self.bra = self.cursor # call R1, line 80 if not self.r_R1(): raise lab0() if among_var == 0: raise lab0() elif among_var == 1: # (, line 82 # delete, line 82 if not self.slice_del(): return False elif among_var == 2: # (, line 85 # delete, line 85 if not self.slice_del(): return False # try, line 86 v_2 = self.limit - self.cursor try: # (, line 86 # [, line 86 self.ket = self.cursor # literal, line 86 if not self.eq_s_b(1, u"s"): self.cursor = self.limit - v_2 raise lab1() # ], line 86 self.bra = self.cursor # literal, line 86 if not self.eq_s_b(3, u"nis"): self.cursor = self.limit - v_2 raise lab1() # delete, line 86 if not self.slice_del(): return False except lab1: pass elif among_var == 3: # (, line 89 if not self.in_grouping_b(GermanStemmer.g_s_ending, 98, 116): raise lab0() # delete, line 89 if not self.slice_del(): return False except lab0: pass self.cursor = self.limit - v_1 # do, line 93 v_3 = self.limit - self.cursor try: # (, line 93 # [, line 94 self.ket = self.cursor # substring, line 94 among_var = self.find_among_b(GermanStemmer.a_2, 4) if among_var == 0: raise lab2() # ], line 94 self.bra = self.cursor # call R1, line 94 if not self.r_R1(): raise lab2() if among_var == 0: raise lab2() elif among_var == 1: # (, line 96 # delete, line 96 if not self.slice_del(): return False elif among_var == 2: # (, line 99 if not self.in_grouping_b(GermanStemmer.g_st_ending, 98, 116): raise lab2() # hop, line 99 c = self.cursor - 3 if self.limit_backward > c or c > self.limit: raise lab2() self.cursor = c # delete, line 99 if not self.slice_del(): return False except lab2: pass self.cursor = self.limit - v_3 # do, line 103 v_4 = self.limit - self.cursor try: # (, line 103 # [, line 104 self.ket = self.cursor # substring, line 104 among_var = self.find_among_b(GermanStemmer.a_4, 8) if among_var == 0: raise lab3() # ], line 104 self.bra = self.cursor # call R2, line 104 if not self.r_R2(): raise lab3() if among_var == 0: raise lab3() elif among_var == 1: # (, line 106 # delete, line 106 if not self.slice_del(): return False # try, line 107 v_5 = self.limit - self.cursor try: # (, line 107 # [, line 107 self.ket = self.cursor # literal, line 107 if not self.eq_s_b(2, u"ig"): self.cursor = self.limit - v_5 raise lab4() # ], line 107 self.bra = self.cursor # not, line 107 v_6 = self.limit - self.cursor try: # literal, line 107 if not self.eq_s_b(1, u"e"): raise lab5() self.cursor = self.limit - v_5 raise lab4() except lab5: pass self.cursor = self.limit - v_6 # call R2, line 107 if not self.r_R2(): self.cursor = self.limit - v_5 raise lab4() # delete, line 107 if not self.slice_del(): return False except lab4: pass elif among_var == 2: # (, line 110 # not, line 110 v_7 = self.limit - self.cursor try: # literal, line 110 if not self.eq_s_b(1, u"e"): raise lab6() raise lab3() except lab6: pass self.cursor = self.limit - v_7 # delete, line 110 if not self.slice_del(): return False elif among_var == 3: # (, line 113 # delete, line 113 if not self.slice_del(): return False # try, line 114 v_8 = self.limit - self.cursor try: # (, line 114 # [, line 115 self.ket = self.cursor # or, line 115 try: v_9 = self.limit - self.cursor try: # literal, line 115 if not self.eq_s_b(2, u"er"): raise lab9() raise lab8() except lab9: pass self.cursor = self.limit - v_9 # literal, line 115 if not self.eq_s_b(2, u"en"): self.cursor = self.limit - v_8 raise lab7() except lab8: pass # ], line 115 self.bra = self.cursor # call R1, line 115 if not self.r_R1(): self.cursor = self.limit - v_8 raise lab7() # delete, line 115 if not self.slice_del(): return False except lab7: pass elif among_var == 4: # (, line 119 # delete, line 119 if not self.slice_del(): return False # try, line 120 v_10 = self.limit - self.cursor try: # (, line 120 # [, line 121 self.ket = self.cursor # substring, line 121 among_var = self.find_among_b(GermanStemmer.a_3, 2) if among_var == 0: self.cursor = self.limit - v_10 raise lab10() # ], line 121 self.bra = self.cursor # call R2, line 121 if not self.r_R2(): self.cursor = self.limit - v_10 raise lab10() if among_var == 0: self.cursor = self.limit - v_10 raise lab10() elif among_var == 1: # (, line 123 # delete, line 123 if not self.slice_del(): return False except lab10: pass except lab3: pass self.cursor = self.limit - v_4 return True def _stem(self): # (, line 133 # do, line 134 v_1 = self.cursor try: # call prelude, line 134 if not self.r_prelude(): raise lab0() except lab0: pass self.cursor = v_1 # do, line 135 v_2 = self.cursor try: # call mark_regions, line 135 if not self.r_mark_regions(): raise lab1() except lab1: pass self.cursor = v_2 # backwards, line 136 self.limit_backward = self.cursor self.cursor = self.limit # do, line 137 v_3 = self.limit - self.cursor try: # call standard_suffix, line 137 if not self.r_standard_suffix(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 self.cursor = self.limit_backward # do, line 138 v_4 = self.cursor try: # call postlude, line 138 if not self.r_postlude(): raise lab3() except lab3: pass self.cursor = v_4 return True def equals(self, o): return isinstance(o, GermanStemmer) def hashCode(self): return hash("GermanStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass class lab11(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/hungarian_stemmer.py0000644€-©8€ZĂ);0000007251212637132734031337 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class HungarianStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"cs", -1, -1), Among(u"dzs", -1, -1), Among(u"gy", -1, -1), Among(u"ly", -1, -1), Among(u"ny", -1, -1), Among(u"sz", -1, -1), Among(u"ty", -1, -1), Among(u"zs", -1, -1) ] a_1 = [ Among(u"\u00E1", -1, 1), Among(u"\u00E9", -1, 2) ] a_2 = [ Among(u"bb", -1, -1), Among(u"cc", -1, -1), Among(u"dd", -1, -1), Among(u"ff", -1, -1), Among(u"gg", -1, -1), Among(u"jj", -1, -1), Among(u"kk", -1, -1), Among(u"ll", -1, -1), Among(u"mm", -1, -1), Among(u"nn", -1, -1), Among(u"pp", -1, -1), Among(u"rr", -1, -1), Among(u"ccs", -1, -1), Among(u"ss", -1, -1), Among(u"zzs", -1, -1), Among(u"tt", -1, -1), Among(u"vv", -1, -1), Among(u"ggy", -1, -1), Among(u"lly", -1, -1), Among(u"nny", -1, -1), Among(u"tty", -1, -1), Among(u"ssz", -1, -1), Among(u"zz", -1, -1) ] a_3 = [ Among(u"al", -1, 1), Among(u"el", -1, 2) ] a_4 = [ Among(u"ba", -1, -1), Among(u"ra", -1, -1), Among(u"be", -1, -1), Among(u"re", -1, -1), Among(u"ig", -1, -1), Among(u"nak", -1, -1), Among(u"nek", -1, -1), Among(u"val", -1, -1), Among(u"vel", -1, -1), Among(u"ul", -1, -1), Among(u"n\u00E1l", -1, -1), Among(u"n\u00E9l", -1, -1), Among(u"b\u00F3l", -1, -1), Among(u"r\u00F3l", -1, -1), Among(u"t\u00F3l", -1, -1), Among(u"b\u00F5l", -1, -1), Among(u"r\u00F5l", -1, -1), Among(u"t\u00F5l", -1, -1), Among(u"\u00FCl", -1, -1), Among(u"n", -1, -1), Among(u"an", 19, -1), Among(u"ban", 20, -1), Among(u"en", 19, -1), Among(u"ben", 22, -1), Among(u"k\u00E9ppen", 22, -1), Among(u"on", 19, -1), Among(u"\u00F6n", 19, -1), Among(u"k\u00E9pp", -1, -1), Among(u"kor", -1, -1), Among(u"t", -1, -1), Among(u"at", 29, -1), Among(u"et", 29, -1), Among(u"k\u00E9nt", 29, -1), Among(u"ank\u00E9nt", 32, -1), Among(u"enk\u00E9nt", 32, -1), Among(u"onk\u00E9nt", 32, -1), Among(u"ot", 29, -1), Among(u"\u00E9rt", 29, -1), Among(u"\u00F6t", 29, -1), Among(u"hez", -1, -1), Among(u"hoz", -1, -1), Among(u"h\u00F6z", -1, -1), Among(u"v\u00E1", -1, -1), Among(u"v\u00E9", -1, -1) ] a_5 = [ Among(u"\u00E1n", -1, 2), Among(u"\u00E9n", -1, 1), Among(u"\u00E1nk\u00E9nt", -1, 3) ] a_6 = [ Among(u"stul", -1, 2), Among(u"astul", 0, 1), Among(u"\u00E1stul", 0, 3), Among(u"st\u00FCl", -1, 2), Among(u"est\u00FCl", 3, 1), Among(u"\u00E9st\u00FCl", 3, 4) ] a_7 = [ Among(u"\u00E1", -1, 1), Among(u"\u00E9", -1, 2) ] a_8 = [ Among(u"k", -1, 7), Among(u"ak", 0, 4), Among(u"ek", 0, 6), Among(u"ok", 0, 5), Among(u"\u00E1k", 0, 1), Among(u"\u00E9k", 0, 2), Among(u"\u00F6k", 0, 3) ] a_9 = [ Among(u"\u00E9i", -1, 7), Among(u"\u00E1\u00E9i", 0, 6), Among(u"\u00E9\u00E9i", 0, 5), Among(u"\u00E9", -1, 9), Among(u"k\u00E9", 3, 4), Among(u"ak\u00E9", 4, 1), Among(u"ek\u00E9", 4, 1), Among(u"ok\u00E9", 4, 1), Among(u"\u00E1k\u00E9", 4, 3), Among(u"\u00E9k\u00E9", 4, 2), Among(u"\u00F6k\u00E9", 4, 1), Among(u"\u00E9\u00E9", 3, 8) ] a_10 = [ Among(u"a", -1, 18), Among(u"ja", 0, 17), Among(u"d", -1, 16), Among(u"ad", 2, 13), Among(u"ed", 2, 13), Among(u"od", 2, 13), Among(u"\u00E1d", 2, 14), Among(u"\u00E9d", 2, 15), Among(u"\u00F6d", 2, 13), Among(u"e", -1, 18), Among(u"je", 9, 17), Among(u"nk", -1, 4), Among(u"unk", 11, 1), Among(u"\u00E1nk", 11, 2), Among(u"\u00E9nk", 11, 3), Among(u"\u00FCnk", 11, 1), Among(u"uk", -1, 8), Among(u"juk", 16, 7), Among(u"\u00E1juk", 17, 5), Among(u"\u00FCk", -1, 8), Among(u"j\u00FCk", 19, 7), Among(u"\u00E9j\u00FCk", 20, 6), Among(u"m", -1, 12), Among(u"am", 22, 9), Among(u"em", 22, 9), Among(u"om", 22, 9), Among(u"\u00E1m", 22, 10), Among(u"\u00E9m", 22, 11), Among(u"o", -1, 18), Among(u"\u00E1", -1, 19), Among(u"\u00E9", -1, 20) ] a_11 = [ Among(u"id", -1, 10), Among(u"aid", 0, 9), Among(u"jaid", 1, 6), Among(u"eid", 0, 9), Among(u"jeid", 3, 6), Among(u"\u00E1id", 0, 7), Among(u"\u00E9id", 0, 8), Among(u"i", -1, 15), Among(u"ai", 7, 14), Among(u"jai", 8, 11), Among(u"ei", 7, 14), Among(u"jei", 10, 11), Among(u"\u00E1i", 7, 12), Among(u"\u00E9i", 7, 13), Among(u"itek", -1, 24), Among(u"eitek", 14, 21), Among(u"jeitek", 15, 20), Among(u"\u00E9itek", 14, 23), Among(u"ik", -1, 29), Among(u"aik", 18, 26), Among(u"jaik", 19, 25), Among(u"eik", 18, 26), Among(u"jeik", 21, 25), Among(u"\u00E1ik", 18, 27), Among(u"\u00E9ik", 18, 28), Among(u"ink", -1, 20), Among(u"aink", 25, 17), Among(u"jaink", 26, 16), Among(u"eink", 25, 17), Among(u"jeink", 28, 16), Among(u"\u00E1ink", 25, 18), Among(u"\u00E9ink", 25, 19), Among(u"aitok", -1, 21), Among(u"jaitok", 32, 20), Among(u"\u00E1itok", -1, 22), Among(u"im", -1, 5), Among(u"aim", 35, 4), Among(u"jaim", 36, 1), Among(u"eim", 35, 4), Among(u"jeim", 38, 1), Among(u"\u00E1im", 35, 2), Among(u"\u00E9im", 35, 3) ] g_v = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 52, 14] I_p1 = 0 def copy_from(self, other): self.I_p1 = other.I_p1 super.copy_from(other) def r_mark_regions(self): # (, line 44 self.I_p1 = self.limit; # or, line 51 try: v_1 = self.cursor try: # (, line 48 if not self.in_grouping(HungarianStemmer.g_v, 97, 252): raise lab1() # goto, line 48 try: while True: v_2 = self.cursor try: if not self.out_grouping(HungarianStemmer.g_v, 97, 252): raise lab3() self.cursor = v_2 raise lab2() except lab3: pass self.cursor = v_2 if self.cursor >= self.limit: raise lab1() self.cursor += 1 except lab2: pass # or, line 49 try: v_3 = self.cursor try: # among, line 49 if self.find_among(HungarianStemmer.a_0, 8) == 0: raise lab5() raise lab4() except lab5: pass self.cursor = v_3 # next, line 49 if self.cursor >= self.limit: raise lab1() self.cursor += 1 except lab4: pass # setmark p1, line 50 self.I_p1 = self.cursor raise lab0() except lab1: pass self.cursor = v_1 # (, line 53 if not self.out_grouping(HungarianStemmer.g_v, 97, 252): return False # gopast, line 53 try: while True: try: if not self.in_grouping(HungarianStemmer.g_v, 97, 252): raise lab7() raise lab6() except lab7: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab6: pass # setmark p1, line 53 self.I_p1 = self.cursor except lab0: pass return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_v_ending(self): # (, line 60 # [, line 61 self.ket = self.cursor # substring, line 61 among_var = self.find_among_b(HungarianStemmer.a_1, 2) if among_var == 0: return False # ], line 61 self.bra = self.cursor # call R1, line 61 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 62 # <-, line 62 if not self.slice_from(u"a"): return False elif among_var == 2: # (, line 63 # <-, line 63 if not self.slice_from(u"e"): return False return True def r_double(self): # (, line 67 # test, line 68 v_1 = self.limit - self.cursor # among, line 68 if self.find_among_b(HungarianStemmer.a_2, 23) == 0: return False self.cursor = self.limit - v_1 return True def r_undouble(self): # (, line 72 # next, line 73 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # [, line 73 self.ket = self.cursor # hop, line 73 c = self.cursor - 1 if self.limit_backward > c or c > self.limit: return False self.cursor = c # ], line 73 self.bra = self.cursor # delete, line 73 if not self.slice_del(): return False return True def r_instrum(self): # (, line 76 # [, line 77 self.ket = self.cursor # substring, line 77 among_var = self.find_among_b(HungarianStemmer.a_3, 2) if among_var == 0: return False # ], line 77 self.bra = self.cursor # call R1, line 77 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 78 # call double, line 78 if not self.r_double(): return False elif among_var == 2: # (, line 79 # call double, line 79 if not self.r_double(): return False # delete, line 81 if not self.slice_del(): return False # call undouble, line 82 if not self.r_undouble(): return False return True def r_case(self): # (, line 86 # [, line 87 self.ket = self.cursor # substring, line 87 if self.find_among_b(HungarianStemmer.a_4, 44) == 0: return False # ], line 87 self.bra = self.cursor # call R1, line 87 if not self.r_R1(): return False # delete, line 111 if not self.slice_del(): return False # call v_ending, line 112 if not self.r_v_ending(): return False return True def r_case_special(self): # (, line 115 # [, line 116 self.ket = self.cursor # substring, line 116 among_var = self.find_among_b(HungarianStemmer.a_5, 3) if among_var == 0: return False # ], line 116 self.bra = self.cursor # call R1, line 116 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 117 # <-, line 117 if not self.slice_from(u"e"): return False elif among_var == 2: # (, line 118 # <-, line 118 if not self.slice_from(u"a"): return False elif among_var == 3: # (, line 119 # <-, line 119 if not self.slice_from(u"a"): return False return True def r_case_other(self): # (, line 123 # [, line 124 self.ket = self.cursor # substring, line 124 among_var = self.find_among_b(HungarianStemmer.a_6, 6) if among_var == 0: return False # ], line 124 self.bra = self.cursor # call R1, line 124 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 125 # delete, line 125 if not self.slice_del(): return False elif among_var == 2: # (, line 126 # delete, line 126 if not self.slice_del(): return False elif among_var == 3: # (, line 127 # <-, line 127 if not self.slice_from(u"a"): return False elif among_var == 4: # (, line 128 # <-, line 128 if not self.slice_from(u"e"): return False return True def r_factive(self): # (, line 132 # [, line 133 self.ket = self.cursor # substring, line 133 among_var = self.find_among_b(HungarianStemmer.a_7, 2) if among_var == 0: return False # ], line 133 self.bra = self.cursor # call R1, line 133 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 134 # call double, line 134 if not self.r_double(): return False elif among_var == 2: # (, line 135 # call double, line 135 if not self.r_double(): return False # delete, line 137 if not self.slice_del(): return False # call undouble, line 138 if not self.r_undouble(): return False return True def r_plural(self): # (, line 141 # [, line 142 self.ket = self.cursor # substring, line 142 among_var = self.find_among_b(HungarianStemmer.a_8, 7) if among_var == 0: return False # ], line 142 self.bra = self.cursor # call R1, line 142 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 143 # <-, line 143 if not self.slice_from(u"a"): return False elif among_var == 2: # (, line 144 # <-, line 144 if not self.slice_from(u"e"): return False elif among_var == 3: # (, line 145 # delete, line 145 if not self.slice_del(): return False elif among_var == 4: # (, line 146 # delete, line 146 if not self.slice_del(): return False elif among_var == 5: # (, line 147 # delete, line 147 if not self.slice_del(): return False elif among_var == 6: # (, line 148 # delete, line 148 if not self.slice_del(): return False elif among_var == 7: # (, line 149 # delete, line 149 if not self.slice_del(): return False return True def r_owned(self): # (, line 153 # [, line 154 self.ket = self.cursor # substring, line 154 among_var = self.find_among_b(HungarianStemmer.a_9, 12) if among_var == 0: return False # ], line 154 self.bra = self.cursor # call R1, line 154 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 155 # delete, line 155 if not self.slice_del(): return False elif among_var == 2: # (, line 156 # <-, line 156 if not self.slice_from(u"e"): return False elif among_var == 3: # (, line 157 # <-, line 157 if not self.slice_from(u"a"): return False elif among_var == 4: # (, line 158 # delete, line 158 if not self.slice_del(): return False elif among_var == 5: # (, line 159 # <-, line 159 if not self.slice_from(u"e"): return False elif among_var == 6: # (, line 160 # <-, line 160 if not self.slice_from(u"a"): return False elif among_var == 7: # (, line 161 # delete, line 161 if not self.slice_del(): return False elif among_var == 8: # (, line 162 # <-, line 162 if not self.slice_from(u"e"): return False elif among_var == 9: # (, line 163 # delete, line 163 if not self.slice_del(): return False return True def r_sing_owner(self): # (, line 167 # [, line 168 self.ket = self.cursor # substring, line 168 among_var = self.find_among_b(HungarianStemmer.a_10, 31) if among_var == 0: return False # ], line 168 self.bra = self.cursor # call R1, line 168 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 169 # delete, line 169 if not self.slice_del(): return False elif among_var == 2: # (, line 170 # <-, line 170 if not self.slice_from(u"a"): return False elif among_var == 3: # (, line 171 # <-, line 171 if not self.slice_from(u"e"): return False elif among_var == 4: # (, line 172 # delete, line 172 if not self.slice_del(): return False elif among_var == 5: # (, line 173 # <-, line 173 if not self.slice_from(u"a"): return False elif among_var == 6: # (, line 174 # <-, line 174 if not self.slice_from(u"e"): return False elif among_var == 7: # (, line 175 # delete, line 175 if not self.slice_del(): return False elif among_var == 8: # (, line 176 # delete, line 176 if not self.slice_del(): return False elif among_var == 9: # (, line 177 # delete, line 177 if not self.slice_del(): return False elif among_var == 10: # (, line 178 # <-, line 178 if not self.slice_from(u"a"): return False elif among_var == 11: # (, line 179 # <-, line 179 if not self.slice_from(u"e"): return False elif among_var == 12: # (, line 180 # delete, line 180 if not self.slice_del(): return False elif among_var == 13: # (, line 181 # delete, line 181 if not self.slice_del(): return False elif among_var == 14: # (, line 182 # <-, line 182 if not self.slice_from(u"a"): return False elif among_var == 15: # (, line 183 # <-, line 183 if not self.slice_from(u"e"): return False elif among_var == 16: # (, line 184 # delete, line 184 if not self.slice_del(): return False elif among_var == 17: # (, line 185 # delete, line 185 if not self.slice_del(): return False elif among_var == 18: # (, line 186 # delete, line 186 if not self.slice_del(): return False elif among_var == 19: # (, line 187 # <-, line 187 if not self.slice_from(u"a"): return False elif among_var == 20: # (, line 188 # <-, line 188 if not self.slice_from(u"e"): return False return True def r_plur_owner(self): # (, line 192 # [, line 193 self.ket = self.cursor # substring, line 193 among_var = self.find_among_b(HungarianStemmer.a_11, 42) if among_var == 0: return False # ], line 193 self.bra = self.cursor # call R1, line 193 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 194 # delete, line 194 if not self.slice_del(): return False elif among_var == 2: # (, line 195 # <-, line 195 if not self.slice_from(u"a"): return False elif among_var == 3: # (, line 196 # <-, line 196 if not self.slice_from(u"e"): return False elif among_var == 4: # (, line 197 # delete, line 197 if not self.slice_del(): return False elif among_var == 5: # (, line 198 # delete, line 198 if not self.slice_del(): return False elif among_var == 6: # (, line 199 # delete, line 199 if not self.slice_del(): return False elif among_var == 7: # (, line 200 # <-, line 200 if not self.slice_from(u"a"): return False elif among_var == 8: # (, line 201 # <-, line 201 if not self.slice_from(u"e"): return False elif among_var == 9: # (, line 202 # delete, line 202 if not self.slice_del(): return False elif among_var == 10: # (, line 203 # delete, line 203 if not self.slice_del(): return False elif among_var == 11: # (, line 204 # delete, line 204 if not self.slice_del(): return False elif among_var == 12: # (, line 205 # <-, line 205 if not self.slice_from(u"a"): return False elif among_var == 13: # (, line 206 # <-, line 206 if not self.slice_from(u"e"): return False elif among_var == 14: # (, line 207 # delete, line 207 if not self.slice_del(): return False elif among_var == 15: # (, line 208 # delete, line 208 if not self.slice_del(): return False elif among_var == 16: # (, line 209 # delete, line 209 if not self.slice_del(): return False elif among_var == 17: # (, line 210 # delete, line 210 if not self.slice_del(): return False elif among_var == 18: # (, line 211 # <-, line 211 if not self.slice_from(u"a"): return False elif among_var == 19: # (, line 212 # <-, line 212 if not self.slice_from(u"e"): return False elif among_var == 20: # (, line 214 # delete, line 214 if not self.slice_del(): return False elif among_var == 21: # (, line 215 # delete, line 215 if not self.slice_del(): return False elif among_var == 22: # (, line 216 # <-, line 216 if not self.slice_from(u"a"): return False elif among_var == 23: # (, line 217 # <-, line 217 if not self.slice_from(u"e"): return False elif among_var == 24: # (, line 218 # delete, line 218 if not self.slice_del(): return False elif among_var == 25: # (, line 219 # delete, line 219 if not self.slice_del(): return False elif among_var == 26: # (, line 220 # delete, line 220 if not self.slice_del(): return False elif among_var == 27: # (, line 221 # <-, line 221 if not self.slice_from(u"a"): return False elif among_var == 28: # (, line 222 # <-, line 222 if not self.slice_from(u"e"): return False elif among_var == 29: # (, line 223 # delete, line 223 if not self.slice_del(): return False return True def _stem(self): # (, line 228 # do, line 229 v_1 = self.cursor try: # call mark_regions, line 229 if not self.r_mark_regions(): raise lab0() except lab0: pass self.cursor = v_1 # backwards, line 230 self.limit_backward = self.cursor self.cursor = self.limit # (, line 230 # do, line 231 v_2 = self.limit - self.cursor try: # call instrum, line 231 if not self.r_instrum(): raise lab1() except lab1: pass self.cursor = self.limit - v_2 # do, line 232 v_3 = self.limit - self.cursor try: # call case, line 232 if not self.r_case(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 # do, line 233 v_4 = self.limit - self.cursor try: # call case_special, line 233 if not self.r_case_special(): raise lab3() except lab3: pass self.cursor = self.limit - v_4 # do, line 234 v_5 = self.limit - self.cursor try: # call case_other, line 234 if not self.r_case_other(): raise lab4() except lab4: pass self.cursor = self.limit - v_5 # do, line 235 v_6 = self.limit - self.cursor try: # call factive, line 235 if not self.r_factive(): raise lab5() except lab5: pass self.cursor = self.limit - v_6 # do, line 236 v_7 = self.limit - self.cursor try: # call owned, line 236 if not self.r_owned(): raise lab6() except lab6: pass self.cursor = self.limit - v_7 # do, line 237 v_8 = self.limit - self.cursor try: # call sing_owner, line 237 if not self.r_sing_owner(): raise lab7() except lab7: pass self.cursor = self.limit - v_8 # do, line 238 v_9 = self.limit - self.cursor try: # call plur_owner, line 238 if not self.r_plur_owner(): raise lab8() except lab8: pass self.cursor = self.limit - v_9 # do, line 239 v_10 = self.limit - self.cursor try: # call plural, line 239 if not self.r_plural(): raise lab9() except lab9: pass self.cursor = self.limit - v_10 self.cursor = self.limit_backward return True def equals(self, o): return isinstance(o, HungarianStemmer) def hashCode(self): return hash("HungarianStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/italian_stemmer.py0000644€-©8€ZĂ);0000010413012637132734030774 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class ItalianStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"", -1, 7), Among(u"qu", 0, 6), Among(u"\u00E1", 0, 1), Among(u"\u00E9", 0, 2), Among(u"\u00ED", 0, 3), Among(u"\u00F3", 0, 4), Among(u"\u00FA", 0, 5) ] a_1 = [ Among(u"", -1, 3), Among(u"I", 0, 1), Among(u"U", 0, 2) ] a_2 = [ Among(u"la", -1, -1), Among(u"cela", 0, -1), Among(u"gliela", 0, -1), Among(u"mela", 0, -1), Among(u"tela", 0, -1), Among(u"vela", 0, -1), Among(u"le", -1, -1), Among(u"cele", 6, -1), Among(u"gliele", 6, -1), Among(u"mele", 6, -1), Among(u"tele", 6, -1), Among(u"vele", 6, -1), Among(u"ne", -1, -1), Among(u"cene", 12, -1), Among(u"gliene", 12, -1), Among(u"mene", 12, -1), Among(u"sene", 12, -1), Among(u"tene", 12, -1), Among(u"vene", 12, -1), Among(u"ci", -1, -1), Among(u"li", -1, -1), Among(u"celi", 20, -1), Among(u"glieli", 20, -1), Among(u"meli", 20, -1), Among(u"teli", 20, -1), Among(u"veli", 20, -1), Among(u"gli", 20, -1), Among(u"mi", -1, -1), Among(u"si", -1, -1), Among(u"ti", -1, -1), Among(u"vi", -1, -1), Among(u"lo", -1, -1), Among(u"celo", 31, -1), Among(u"glielo", 31, -1), Among(u"melo", 31, -1), Among(u"telo", 31, -1), Among(u"velo", 31, -1) ] a_3 = [ Among(u"ando", -1, 1), Among(u"endo", -1, 1), Among(u"ar", -1, 2), Among(u"er", -1, 2), Among(u"ir", -1, 2) ] a_4 = [ Among(u"ic", -1, -1), Among(u"abil", -1, -1), Among(u"os", -1, -1), Among(u"iv", -1, 1) ] a_5 = [ Among(u"ic", -1, 1), Among(u"abil", -1, 1), Among(u"iv", -1, 1) ] a_6 = [ Among(u"ica", -1, 1), Among(u"logia", -1, 3), Among(u"osa", -1, 1), Among(u"ista", -1, 1), Among(u"iva", -1, 9), Among(u"anza", -1, 1), Among(u"enza", -1, 5), Among(u"ice", -1, 1), Among(u"atrice", 7, 1), Among(u"iche", -1, 1), Among(u"logie", -1, 3), Among(u"abile", -1, 1), Among(u"ibile", -1, 1), Among(u"usione", -1, 4), Among(u"azione", -1, 2), Among(u"uzione", -1, 4), Among(u"atore", -1, 2), Among(u"ose", -1, 1), Among(u"ante", -1, 1), Among(u"mente", -1, 1), Among(u"amente", 19, 7), Among(u"iste", -1, 1), Among(u"ive", -1, 9), Among(u"anze", -1, 1), Among(u"enze", -1, 5), Among(u"ici", -1, 1), Among(u"atrici", 25, 1), Among(u"ichi", -1, 1), Among(u"abili", -1, 1), Among(u"ibili", -1, 1), Among(u"ismi", -1, 1), Among(u"usioni", -1, 4), Among(u"azioni", -1, 2), Among(u"uzioni", -1, 4), Among(u"atori", -1, 2), Among(u"osi", -1, 1), Among(u"anti", -1, 1), Among(u"amenti", -1, 6), Among(u"imenti", -1, 6), Among(u"isti", -1, 1), Among(u"ivi", -1, 9), Among(u"ico", -1, 1), Among(u"ismo", -1, 1), Among(u"oso", -1, 1), Among(u"amento", -1, 6), Among(u"imento", -1, 6), Among(u"ivo", -1, 9), Among(u"it\u00E0", -1, 8), Among(u"ist\u00E0", -1, 1), Among(u"ist\u00E8", -1, 1), Among(u"ist\u00EC", -1, 1) ] a_7 = [ Among(u"isca", -1, 1), Among(u"enda", -1, 1), Among(u"ata", -1, 1), Among(u"ita", -1, 1), Among(u"uta", -1, 1), Among(u"ava", -1, 1), Among(u"eva", -1, 1), Among(u"iva", -1, 1), Among(u"erebbe", -1, 1), Among(u"irebbe", -1, 1), Among(u"isce", -1, 1), Among(u"ende", -1, 1), Among(u"are", -1, 1), Among(u"ere", -1, 1), Among(u"ire", -1, 1), Among(u"asse", -1, 1), Among(u"ate", -1, 1), Among(u"avate", 16, 1), Among(u"evate", 16, 1), Among(u"ivate", 16, 1), Among(u"ete", -1, 1), Among(u"erete", 20, 1), Among(u"irete", 20, 1), Among(u"ite", -1, 1), Among(u"ereste", -1, 1), Among(u"ireste", -1, 1), Among(u"ute", -1, 1), Among(u"erai", -1, 1), Among(u"irai", -1, 1), Among(u"isci", -1, 1), Among(u"endi", -1, 1), Among(u"erei", -1, 1), Among(u"irei", -1, 1), Among(u"assi", -1, 1), Among(u"ati", -1, 1), Among(u"iti", -1, 1), Among(u"eresti", -1, 1), Among(u"iresti", -1, 1), Among(u"uti", -1, 1), Among(u"avi", -1, 1), Among(u"evi", -1, 1), Among(u"ivi", -1, 1), Among(u"isco", -1, 1), Among(u"ando", -1, 1), Among(u"endo", -1, 1), Among(u"Yamo", -1, 1), Among(u"iamo", -1, 1), Among(u"avamo", -1, 1), Among(u"evamo", -1, 1), Among(u"ivamo", -1, 1), Among(u"eremo", -1, 1), Among(u"iremo", -1, 1), Among(u"assimo", -1, 1), Among(u"ammo", -1, 1), Among(u"emmo", -1, 1), Among(u"eremmo", 54, 1), Among(u"iremmo", 54, 1), Among(u"immo", -1, 1), Among(u"ano", -1, 1), Among(u"iscano", 58, 1), Among(u"avano", 58, 1), Among(u"evano", 58, 1), Among(u"ivano", 58, 1), Among(u"eranno", -1, 1), Among(u"iranno", -1, 1), Among(u"ono", -1, 1), Among(u"iscono", 65, 1), Among(u"arono", 65, 1), Among(u"erono", 65, 1), Among(u"irono", 65, 1), Among(u"erebbero", -1, 1), Among(u"irebbero", -1, 1), Among(u"assero", -1, 1), Among(u"essero", -1, 1), Among(u"issero", -1, 1), Among(u"ato", -1, 1), Among(u"ito", -1, 1), Among(u"uto", -1, 1), Among(u"avo", -1, 1), Among(u"evo", -1, 1), Among(u"ivo", -1, 1), Among(u"ar", -1, 1), Among(u"ir", -1, 1), Among(u"er\u00E0", -1, 1), Among(u"ir\u00E0", -1, 1), Among(u"er\u00F2", -1, 1), Among(u"ir\u00F2", -1, 1) ] g_v = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 8, 2, 1] g_AEIO = [17, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 8, 2] g_CG = [17] I_p2 = 0 I_p1 = 0 I_pV = 0 def copy_from(self, other): self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 self.I_pV = other.I_pV super.copy_from(other) def r_prelude(self): # (, line 34 # test, line 35 v_1 = self.cursor # repeat, line 35 try: while True: try: v_2 = self.cursor try: # (, line 35 # [, line 36 self.bra = self.cursor # substring, line 36 among_var = self.find_among(ItalianStemmer.a_0, 7) if among_var == 0: raise lab2() # ], line 36 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 37 # <-, line 37 if not self.slice_from(u"\u00E0"): return False elif among_var == 2: # (, line 38 # <-, line 38 if not self.slice_from(u"\u00E8"): return False elif among_var == 3: # (, line 39 # <-, line 39 if not self.slice_from(u"\u00EC"): return False elif among_var == 4: # (, line 40 # <-, line 40 if not self.slice_from(u"\u00F2"): return False elif among_var == 5: # (, line 41 # <-, line 41 if not self.slice_from(u"\u00F9"): return False elif among_var == 6: # (, line 42 # <-, line 42 if not self.slice_from(u"qU"): return False elif among_var == 7: # (, line 43 # next, line 43 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_2 raise lab0() except lab1: pass except lab0: pass self.cursor = v_1 # repeat, line 46 try: while True: try: v_3 = self.cursor try: # goto, line 46 try: while True: v_4 = self.cursor try: # (, line 46 if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab7() # [, line 47 self.bra = self.cursor # or, line 47 try: v_5 = self.cursor try: # (, line 47 # literal, line 47 if not self.eq_s(1, u"u"): raise lab9() # ], line 47 self.ket = self.cursor if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab9() # <-, line 47 if not self.slice_from(u"U"): return False raise lab8() except lab9: pass self.cursor = v_5 # (, line 48 # literal, line 48 if not self.eq_s(1, u"i"): raise lab7() # ], line 48 self.ket = self.cursor if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab7() # <-, line 48 if not self.slice_from(u"I"): return False except lab8: pass self.cursor = v_4 raise lab6() except lab7: pass self.cursor = v_4 if self.cursor >= self.limit: raise lab5() self.cursor += 1 except lab6: pass raise lab4() except lab5: pass self.cursor = v_3 raise lab3() except lab4: pass except lab3: pass return True def r_mark_regions(self): # (, line 52 self.I_pV = self.limit; self.I_p1 = self.limit; self.I_p2 = self.limit; # do, line 58 v_1 = self.cursor try: # (, line 58 # or, line 60 try: v_2 = self.cursor try: # (, line 59 if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab2() # or, line 59 try: v_3 = self.cursor try: # (, line 59 if not self.out_grouping(ItalianStemmer.g_v, 97, 249): raise lab4() # gopast, line 59 try: while True: try: if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab6() raise lab5() except lab6: pass if self.cursor >= self.limit: raise lab4() self.cursor += 1 except lab5: pass raise lab3() except lab4: pass self.cursor = v_3 # (, line 59 if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab2() # gopast, line 59 try: while True: try: if not self.out_grouping(ItalianStemmer.g_v, 97, 249): raise lab8() raise lab7() except lab8: pass if self.cursor >= self.limit: raise lab2() self.cursor += 1 except lab7: pass except lab3: pass raise lab1() except lab2: pass self.cursor = v_2 # (, line 61 if not self.out_grouping(ItalianStemmer.g_v, 97, 249): raise lab0() # or, line 61 try: v_6 = self.cursor try: # (, line 61 if not self.out_grouping(ItalianStemmer.g_v, 97, 249): raise lab10() # gopast, line 61 try: while True: try: if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab12() raise lab11() except lab12: pass if self.cursor >= self.limit: raise lab10() self.cursor += 1 except lab11: pass raise lab9() except lab10: pass self.cursor = v_6 # (, line 61 if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab0() # next, line 61 if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab9: pass except lab1: pass # setmark pV, line 62 self.I_pV = self.cursor except lab0: pass self.cursor = v_1 # do, line 64 v_8 = self.cursor try: # (, line 64 # gopast, line 65 try: while True: try: if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab15() raise lab14() except lab15: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab14: pass # gopast, line 65 try: while True: try: if not self.out_grouping(ItalianStemmer.g_v, 97, 249): raise lab17() raise lab16() except lab17: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab16: pass # setmark p1, line 65 self.I_p1 = self.cursor # gopast, line 66 try: while True: try: if not self.in_grouping(ItalianStemmer.g_v, 97, 249): raise lab19() raise lab18() except lab19: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab18: pass # gopast, line 66 try: while True: try: if not self.out_grouping(ItalianStemmer.g_v, 97, 249): raise lab21() raise lab20() except lab21: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab20: pass # setmark p2, line 66 self.I_p2 = self.cursor except lab13: pass self.cursor = v_8 return True def r_postlude(self): # repeat, line 70 try: while True: try: v_1 = self.cursor try: # (, line 70 # [, line 72 self.bra = self.cursor # substring, line 72 among_var = self.find_among(ItalianStemmer.a_1, 3) if among_var == 0: raise lab2() # ], line 72 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 73 # <-, line 73 if not self.slice_from(u"i"): return False elif among_var == 2: # (, line 74 # <-, line 74 if not self.slice_from(u"u"): return False elif among_var == 3: # (, line 75 # next, line 75 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_RV(self): if not self.I_pV <= self.cursor: return False return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_attached_pronoun(self): # (, line 86 # [, line 87 self.ket = self.cursor # substring, line 87 if self.find_among_b(ItalianStemmer.a_2, 37) == 0: return False # ], line 87 self.bra = self.cursor # among, line 97 among_var = self.find_among_b(ItalianStemmer.a_3, 5) if among_var == 0: return False # (, line 97 # call RV, line 97 if not self.r_RV(): return False if among_var == 0: return False elif among_var == 1: # (, line 98 # delete, line 98 if not self.slice_del(): return False elif among_var == 2: # (, line 99 # <-, line 99 if not self.slice_from(u"e"): return False return True def r_standard_suffix(self): # (, line 103 # [, line 104 self.ket = self.cursor # substring, line 104 among_var = self.find_among_b(ItalianStemmer.a_6, 51) if among_var == 0: return False # ], line 104 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 111 # call R2, line 111 if not self.r_R2(): return False # delete, line 111 if not self.slice_del(): return False elif among_var == 2: # (, line 113 # call R2, line 113 if not self.r_R2(): return False # delete, line 113 if not self.slice_del(): return False # try, line 114 v_1 = self.limit - self.cursor try: # (, line 114 # [, line 114 self.ket = self.cursor # literal, line 114 if not self.eq_s_b(2, u"ic"): self.cursor = self.limit - v_1 raise lab0() # ], line 114 self.bra = self.cursor # call R2, line 114 if not self.r_R2(): self.cursor = self.limit - v_1 raise lab0() # delete, line 114 if not self.slice_del(): return False except lab0: pass elif among_var == 3: # (, line 117 # call R2, line 117 if not self.r_R2(): return False # <-, line 117 if not self.slice_from(u"log"): return False elif among_var == 4: # (, line 119 # call R2, line 119 if not self.r_R2(): return False # <-, line 119 if not self.slice_from(u"u"): return False elif among_var == 5: # (, line 121 # call R2, line 121 if not self.r_R2(): return False # <-, line 121 if not self.slice_from(u"ente"): return False elif among_var == 6: # (, line 123 # call RV, line 123 if not self.r_RV(): return False # delete, line 123 if not self.slice_del(): return False elif among_var == 7: # (, line 124 # call R1, line 125 if not self.r_R1(): return False # delete, line 125 if not self.slice_del(): return False # try, line 126 v_2 = self.limit - self.cursor try: # (, line 126 # [, line 127 self.ket = self.cursor # substring, line 127 among_var = self.find_among_b(ItalianStemmer.a_4, 4) if among_var == 0: self.cursor = self.limit - v_2 raise lab1() # ], line 127 self.bra = self.cursor # call R2, line 127 if not self.r_R2(): self.cursor = self.limit - v_2 raise lab1() # delete, line 127 if not self.slice_del(): return False if among_var == 0: self.cursor = self.limit - v_2 raise lab1() elif among_var == 1: # (, line 128 # [, line 128 self.ket = self.cursor # literal, line 128 if not self.eq_s_b(2, u"at"): self.cursor = self.limit - v_2 raise lab1() # ], line 128 self.bra = self.cursor # call R2, line 128 if not self.r_R2(): self.cursor = self.limit - v_2 raise lab1() # delete, line 128 if not self.slice_del(): return False except lab1: pass elif among_var == 8: # (, line 133 # call R2, line 134 if not self.r_R2(): return False # delete, line 134 if not self.slice_del(): return False # try, line 135 v_3 = self.limit - self.cursor try: # (, line 135 # [, line 136 self.ket = self.cursor # substring, line 136 among_var = self.find_among_b(ItalianStemmer.a_5, 3) if among_var == 0: self.cursor = self.limit - v_3 raise lab2() # ], line 136 self.bra = self.cursor if among_var == 0: self.cursor = self.limit - v_3 raise lab2() elif among_var == 1: # (, line 137 # call R2, line 137 if not self.r_R2(): self.cursor = self.limit - v_3 raise lab2() # delete, line 137 if not self.slice_del(): return False except lab2: pass elif among_var == 9: # (, line 141 # call R2, line 142 if not self.r_R2(): return False # delete, line 142 if not self.slice_del(): return False # try, line 143 v_4 = self.limit - self.cursor try: # (, line 143 # [, line 143 self.ket = self.cursor # literal, line 143 if not self.eq_s_b(2, u"at"): self.cursor = self.limit - v_4 raise lab3() # ], line 143 self.bra = self.cursor # call R2, line 143 if not self.r_R2(): self.cursor = self.limit - v_4 raise lab3() # delete, line 143 if not self.slice_del(): return False # [, line 143 self.ket = self.cursor # literal, line 143 if not self.eq_s_b(2, u"ic"): self.cursor = self.limit - v_4 raise lab3() # ], line 143 self.bra = self.cursor # call R2, line 143 if not self.r_R2(): self.cursor = self.limit - v_4 raise lab3() # delete, line 143 if not self.slice_del(): return False except lab3: pass return True def r_verb_suffix(self): # setlimit, line 148 v_1 = self.limit - self.cursor # tomark, line 148 if self.cursor < self.I_pV: return False self.cursor = self.I_pV v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 148 # [, line 149 self.ket = self.cursor # substring, line 149 among_var = self.find_among_b(ItalianStemmer.a_7, 87) if among_var == 0: self.limit_backward = v_2 return False # ], line 149 self.bra = self.cursor if among_var == 0: self.limit_backward = v_2 return False elif among_var == 1: # (, line 163 # delete, line 163 if not self.slice_del(): return False self.limit_backward = v_2 return True def r_vowel_suffix(self): # (, line 170 # try, line 171 v_1 = self.limit - self.cursor try: # (, line 171 # [, line 172 self.ket = self.cursor if not self.in_grouping_b(ItalianStemmer.g_AEIO, 97, 242): self.cursor = self.limit - v_1 raise lab0() # ], line 172 self.bra = self.cursor # call RV, line 172 if not self.r_RV(): self.cursor = self.limit - v_1 raise lab0() # delete, line 172 if not self.slice_del(): return False # [, line 173 self.ket = self.cursor # literal, line 173 if not self.eq_s_b(1, u"i"): self.cursor = self.limit - v_1 raise lab0() # ], line 173 self.bra = self.cursor # call RV, line 173 if not self.r_RV(): self.cursor = self.limit - v_1 raise lab0() # delete, line 173 if not self.slice_del(): return False except lab0: pass # try, line 175 v_2 = self.limit - self.cursor try: # (, line 175 # [, line 176 self.ket = self.cursor # literal, line 176 if not self.eq_s_b(1, u"h"): self.cursor = self.limit - v_2 raise lab1() # ], line 176 self.bra = self.cursor if not self.in_grouping_b(ItalianStemmer.g_CG, 99, 103): self.cursor = self.limit - v_2 raise lab1() # call RV, line 176 if not self.r_RV(): self.cursor = self.limit - v_2 raise lab1() # delete, line 176 if not self.slice_del(): return False except lab1: pass return True def _stem(self): # (, line 181 # do, line 182 v_1 = self.cursor try: # call prelude, line 182 if not self.r_prelude(): raise lab0() except lab0: pass self.cursor = v_1 # do, line 183 v_2 = self.cursor try: # call mark_regions, line 183 if not self.r_mark_regions(): raise lab1() except lab1: pass self.cursor = v_2 # backwards, line 184 self.limit_backward = self.cursor self.cursor = self.limit # (, line 184 # do, line 185 v_3 = self.limit - self.cursor try: # call attached_pronoun, line 185 if not self.r_attached_pronoun(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 # do, line 186 v_4 = self.limit - self.cursor try: # (, line 186 # or, line 186 try: v_5 = self.limit - self.cursor try: # call standard_suffix, line 186 if not self.r_standard_suffix(): raise lab5() raise lab4() except lab5: pass self.cursor = self.limit - v_5 # call verb_suffix, line 186 if not self.r_verb_suffix(): raise lab3() except lab4: pass except lab3: pass self.cursor = self.limit - v_4 # do, line 187 v_6 = self.limit - self.cursor try: # call vowel_suffix, line 187 if not self.r_vowel_suffix(): raise lab6() except lab6: pass self.cursor = self.limit - v_6 self.cursor = self.limit_backward # do, line 189 v_7 = self.cursor try: # call postlude, line 189 if not self.r_postlude(): raise lab7() except lab7: pass self.cursor = v_7 return True def equals(self, o): return isinstance(o, ItalianStemmer) def hashCode(self): return hash("ItalianStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass class lab11(BaseException): pass class lab12(BaseException): pass class lab13(BaseException): pass class lab14(BaseException): pass class lab15(BaseException): pass class lab16(BaseException): pass class lab17(BaseException): pass class lab18(BaseException): pass class lab19(BaseException): pass class lab20(BaseException): pass class lab21(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/norwegian_stemmer.py0000644€-©8€ZĂ);0000002122612637132734031350 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class NorwegianStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"a", -1, 1), Among(u"e", -1, 1), Among(u"ede", 1, 1), Among(u"ande", 1, 1), Among(u"ende", 1, 1), Among(u"ane", 1, 1), Among(u"ene", 1, 1), Among(u"hetene", 6, 1), Among(u"erte", 1, 3), Among(u"en", -1, 1), Among(u"heten", 9, 1), Among(u"ar", -1, 1), Among(u"er", -1, 1), Among(u"heter", 12, 1), Among(u"s", -1, 2), Among(u"as", 14, 1), Among(u"es", 14, 1), Among(u"edes", 16, 1), Among(u"endes", 16, 1), Among(u"enes", 16, 1), Among(u"hetenes", 19, 1), Among(u"ens", 14, 1), Among(u"hetens", 21, 1), Among(u"ers", 14, 1), Among(u"ets", 14, 1), Among(u"et", -1, 1), Among(u"het", 25, 1), Among(u"ert", -1, 3), Among(u"ast", -1, 1) ] a_1 = [ Among(u"dt", -1, -1), Among(u"vt", -1, -1) ] a_2 = [ Among(u"leg", -1, 1), Among(u"eleg", 0, 1), Among(u"ig", -1, 1), Among(u"eig", 2, 1), Among(u"lig", 2, 1), Among(u"elig", 4, 1), Among(u"els", -1, 1), Among(u"lov", -1, 1), Among(u"elov", 7, 1), Among(u"slov", 7, 1), Among(u"hetslov", 9, 1) ] g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 128] g_s_ending = [119, 125, 149, 1] I_x = 0 I_p1 = 0 def copy_from(self, other): self.I_x = other.I_x self.I_p1 = other.I_p1 super.copy_from(other) def r_mark_regions(self): # (, line 26 self.I_p1 = self.limit; # test, line 30 v_1 = self.cursor # (, line 30 # hop, line 30 c = self.cursor + 3 if 0 > c or c > self.limit: return False self.cursor = c # setmark x, line 30 self.I_x = self.cursor self.cursor = v_1 # goto, line 31 try: while True: v_2 = self.cursor try: if not self.in_grouping(NorwegianStemmer.g_v, 97, 248): raise lab1() self.cursor = v_2 raise lab0() except lab1: pass self.cursor = v_2 if self.cursor >= self.limit: return False self.cursor += 1 except lab0: pass # gopast, line 31 try: while True: try: if not self.out_grouping(NorwegianStemmer.g_v, 97, 248): raise lab3() raise lab2() except lab3: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab2: pass # setmark p1, line 31 self.I_p1 = self.cursor # try, line 32 try: # (, line 32 if not (self.I_p1 < self.I_x): raise lab4() self.I_p1 = self.I_x; except lab4: pass return True def r_main_suffix(self): # (, line 37 # setlimit, line 38 v_1 = self.limit - self.cursor # tomark, line 38 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 38 # [, line 38 self.ket = self.cursor # substring, line 38 among_var = self.find_among_b(NorwegianStemmer.a_0, 29) if among_var == 0: self.limit_backward = v_2 return False # ], line 38 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 44 # delete, line 44 if not self.slice_del(): return False elif among_var == 2: # (, line 46 # or, line 46 try: v_3 = self.limit - self.cursor try: if not self.in_grouping_b(NorwegianStemmer.g_s_ending, 98, 122): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_3 # (, line 46 # literal, line 46 if not self.eq_s_b(1, u"k"): return False if not self.out_grouping_b(NorwegianStemmer.g_v, 97, 248): return False except lab0: pass # delete, line 46 if not self.slice_del(): return False elif among_var == 3: # (, line 48 # <-, line 48 if not self.slice_from(u"er"): return False return True def r_consonant_pair(self): # (, line 52 # test, line 53 v_1 = self.limit - self.cursor # (, line 53 # setlimit, line 54 v_2 = self.limit - self.cursor # tomark, line 54 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_3 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_2 # (, line 54 # [, line 54 self.ket = self.cursor # substring, line 54 if self.find_among_b(NorwegianStemmer.a_1, 2) == 0: self.limit_backward = v_3 return False # ], line 54 self.bra = self.cursor self.limit_backward = v_3 self.cursor = self.limit - v_1 # next, line 59 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # ], line 59 self.bra = self.cursor # delete, line 59 if not self.slice_del(): return False return True def r_other_suffix(self): # (, line 62 # setlimit, line 63 v_1 = self.limit - self.cursor # tomark, line 63 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 63 # [, line 63 self.ket = self.cursor # substring, line 63 among_var = self.find_among_b(NorwegianStemmer.a_2, 11) if among_var == 0: self.limit_backward = v_2 return False # ], line 63 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 67 # delete, line 67 if not self.slice_del(): return False return True def _stem(self): # (, line 72 # do, line 74 v_1 = self.cursor try: # call mark_regions, line 74 if not self.r_mark_regions(): raise lab0() except lab0: pass self.cursor = v_1 # backwards, line 75 self.limit_backward = self.cursor self.cursor = self.limit # (, line 75 # do, line 76 v_2 = self.limit - self.cursor try: # call main_suffix, line 76 if not self.r_main_suffix(): raise lab1() except lab1: pass self.cursor = self.limit - v_2 # do, line 77 v_3 = self.limit - self.cursor try: # call consonant_pair, line 77 if not self.r_consonant_pair(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 # do, line 78 v_4 = self.limit - self.cursor try: # call other_suffix, line 78 if not self.r_other_suffix(): raise lab3() except lab3: pass self.cursor = self.limit - v_4 self.cursor = self.limit_backward return True def equals(self, o): return isinstance(o, NorwegianStemmer) def hashCode(self): return hash("NorwegianStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/porter_stemmer.py0000644€-©8€ZĂ);0000006006112637132734030672 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class PorterStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"s", -1, 3), Among(u"ies", 0, 2), Among(u"sses", 0, 1), Among(u"ss", 0, -1) ] a_1 = [ Among(u"", -1, 3), Among(u"bb", 0, 2), Among(u"dd", 0, 2), Among(u"ff", 0, 2), Among(u"gg", 0, 2), Among(u"bl", 0, 1), Among(u"mm", 0, 2), Among(u"nn", 0, 2), Among(u"pp", 0, 2), Among(u"rr", 0, 2), Among(u"at", 0, 1), Among(u"tt", 0, 2), Among(u"iz", 0, 1) ] a_2 = [ Among(u"ed", -1, 2), Among(u"eed", 0, 1), Among(u"ing", -1, 2) ] a_3 = [ Among(u"anci", -1, 3), Among(u"enci", -1, 2), Among(u"abli", -1, 4), Among(u"eli", -1, 6), Among(u"alli", -1, 9), Among(u"ousli", -1, 12), Among(u"entli", -1, 5), Among(u"aliti", -1, 10), Among(u"biliti", -1, 14), Among(u"iviti", -1, 13), Among(u"tional", -1, 1), Among(u"ational", 10, 8), Among(u"alism", -1, 10), Among(u"ation", -1, 8), Among(u"ization", 13, 7), Among(u"izer", -1, 7), Among(u"ator", -1, 8), Among(u"iveness", -1, 13), Among(u"fulness", -1, 11), Among(u"ousness", -1, 12) ] a_4 = [ Among(u"icate", -1, 2), Among(u"ative", -1, 3), Among(u"alize", -1, 1), Among(u"iciti", -1, 2), Among(u"ical", -1, 2), Among(u"ful", -1, 3), Among(u"ness", -1, 3) ] a_5 = [ Among(u"ic", -1, 1), Among(u"ance", -1, 1), Among(u"ence", -1, 1), Among(u"able", -1, 1), Among(u"ible", -1, 1), Among(u"ate", -1, 1), Among(u"ive", -1, 1), Among(u"ize", -1, 1), Among(u"iti", -1, 1), Among(u"al", -1, 1), Among(u"ism", -1, 1), Among(u"ion", -1, 2), Among(u"er", -1, 1), Among(u"ous", -1, 1), Among(u"ant", -1, 1), Among(u"ent", -1, 1), Among(u"ment", 15, 1), Among(u"ement", 16, 1), Among(u"ou", -1, 1) ] g_v = [17, 65, 16, 1] g_v_WXY = [1, 17, 65, 208, 1] B_Y_found = False I_p2 = 0 I_p1 = 0 def copy_from(self, other): self.B_Y_found = other.B_Y_found self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 super.copy_from(other) def r_shortv(self): # (, line 19 if not self.out_grouping_b(PorterStemmer.g_v_WXY, 89, 121): return False if not self.in_grouping_b(PorterStemmer.g_v, 97, 121): return False if not self.out_grouping_b(PorterStemmer.g_v, 97, 121): return False return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_Step_1a(self): # (, line 24 # [, line 25 self.ket = self.cursor # substring, line 25 among_var = self.find_among_b(PorterStemmer.a_0, 4) if among_var == 0: return False # ], line 25 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 26 # <-, line 26 if not self.slice_from(u"ss"): return False elif among_var == 2: # (, line 27 # <-, line 27 if not self.slice_from(u"i"): return False elif among_var == 3: # (, line 29 # delete, line 29 if not self.slice_del(): return False return True def r_Step_1b(self): # (, line 33 # [, line 34 self.ket = self.cursor # substring, line 34 among_var = self.find_among_b(PorterStemmer.a_2, 3) if among_var == 0: return False # ], line 34 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 35 # call R1, line 35 if not self.r_R1(): return False # <-, line 35 if not self.slice_from(u"ee"): return False elif among_var == 2: # (, line 37 # test, line 38 v_1 = self.limit - self.cursor # gopast, line 38 try: while True: try: if not self.in_grouping_b(PorterStemmer.g_v, 97, 121): raise lab1() raise lab0() except lab1: pass if self.cursor <= self.limit_backward: return False self.cursor -= 1 except lab0: pass self.cursor = self.limit - v_1 # delete, line 38 if not self.slice_del(): return False # test, line 39 v_3 = self.limit - self.cursor # substring, line 39 among_var = self.find_among_b(PorterStemmer.a_1, 13) if among_var == 0: return False self.cursor = self.limit - v_3 if among_var == 0: return False elif among_var == 1: # (, line 41 # <+, line 41 c = self.cursor self.insert(self.cursor, self.cursor, u"e") self.cursor = c elif among_var == 2: # (, line 44 # [, line 44 self.ket = self.cursor # next, line 44 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # ], line 44 self.bra = self.cursor # delete, line 44 if not self.slice_del(): return False elif among_var == 3: # (, line 45 # atmark, line 45 if self.cursor != self.I_p1: return False # test, line 45 v_4 = self.limit - self.cursor # call shortv, line 45 if not self.r_shortv(): return False self.cursor = self.limit - v_4 # <+, line 45 c = self.cursor self.insert(self.cursor, self.cursor, u"e") self.cursor = c return True def r_Step_1c(self): # (, line 51 # [, line 52 self.ket = self.cursor # or, line 52 try: v_1 = self.limit - self.cursor try: # literal, line 52 if not self.eq_s_b(1, u"y"): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_1 # literal, line 52 if not self.eq_s_b(1, u"Y"): return False except lab0: pass # ], line 52 self.bra = self.cursor # gopast, line 53 try: while True: try: if not self.in_grouping_b(PorterStemmer.g_v, 97, 121): raise lab3() raise lab2() except lab3: pass if self.cursor <= self.limit_backward: return False self.cursor -= 1 except lab2: pass # <-, line 54 if not self.slice_from(u"i"): return False return True def r_Step_2(self): # (, line 57 # [, line 58 self.ket = self.cursor # substring, line 58 among_var = self.find_among_b(PorterStemmer.a_3, 20) if among_var == 0: return False # ], line 58 self.bra = self.cursor # call R1, line 58 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 59 # <-, line 59 if not self.slice_from(u"tion"): return False elif among_var == 2: # (, line 60 # <-, line 60 if not self.slice_from(u"ence"): return False elif among_var == 3: # (, line 61 # <-, line 61 if not self.slice_from(u"ance"): return False elif among_var == 4: # (, line 62 # <-, line 62 if not self.slice_from(u"able"): return False elif among_var == 5: # (, line 63 # <-, line 63 if not self.slice_from(u"ent"): return False elif among_var == 6: # (, line 64 # <-, line 64 if not self.slice_from(u"e"): return False elif among_var == 7: # (, line 66 # <-, line 66 if not self.slice_from(u"ize"): return False elif among_var == 8: # (, line 68 # <-, line 68 if not self.slice_from(u"ate"): return False elif among_var == 9: # (, line 69 # <-, line 69 if not self.slice_from(u"al"): return False elif among_var == 10: # (, line 71 # <-, line 71 if not self.slice_from(u"al"): return False elif among_var == 11: # (, line 72 # <-, line 72 if not self.slice_from(u"ful"): return False elif among_var == 12: # (, line 74 # <-, line 74 if not self.slice_from(u"ous"): return False elif among_var == 13: # (, line 76 # <-, line 76 if not self.slice_from(u"ive"): return False elif among_var == 14: # (, line 77 # <-, line 77 if not self.slice_from(u"ble"): return False return True def r_Step_3(self): # (, line 81 # [, line 82 self.ket = self.cursor # substring, line 82 among_var = self.find_among_b(PorterStemmer.a_4, 7) if among_var == 0: return False # ], line 82 self.bra = self.cursor # call R1, line 82 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 83 # <-, line 83 if not self.slice_from(u"al"): return False elif among_var == 2: # (, line 85 # <-, line 85 if not self.slice_from(u"ic"): return False elif among_var == 3: # (, line 87 # delete, line 87 if not self.slice_del(): return False return True def r_Step_4(self): # (, line 91 # [, line 92 self.ket = self.cursor # substring, line 92 among_var = self.find_among_b(PorterStemmer.a_5, 19) if among_var == 0: return False # ], line 92 self.bra = self.cursor # call R2, line 92 if not self.r_R2(): return False if among_var == 0: return False elif among_var == 1: # (, line 95 # delete, line 95 if not self.slice_del(): return False elif among_var == 2: # (, line 96 # or, line 96 try: v_1 = self.limit - self.cursor try: # literal, line 96 if not self.eq_s_b(1, u"s"): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_1 # literal, line 96 if not self.eq_s_b(1, u"t"): return False except lab0: pass # delete, line 96 if not self.slice_del(): return False return True def r_Step_5a(self): # (, line 100 # [, line 101 self.ket = self.cursor # literal, line 101 if not self.eq_s_b(1, u"e"): return False # ], line 101 self.bra = self.cursor # or, line 102 try: v_1 = self.limit - self.cursor try: # call R2, line 102 if not self.r_R2(): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_1 # (, line 102 # call R1, line 102 if not self.r_R1(): return False # not, line 102 v_2 = self.limit - self.cursor try: # call shortv, line 102 if not self.r_shortv(): raise lab2() return False except lab2: pass self.cursor = self.limit - v_2 except lab0: pass # delete, line 103 if not self.slice_del(): return False return True def r_Step_5b(self): # (, line 106 # [, line 107 self.ket = self.cursor # literal, line 107 if not self.eq_s_b(1, u"l"): return False # ], line 107 self.bra = self.cursor # call R2, line 108 if not self.r_R2(): return False # literal, line 108 if not self.eq_s_b(1, u"l"): return False # delete, line 109 if not self.slice_del(): return False return True def _stem(self): # (, line 113 # unset Y_found, line 115 self.B_Y_found = False # do, line 116 v_1 = self.cursor try: # (, line 116 # [, line 116 self.bra = self.cursor # literal, line 116 if not self.eq_s(1, u"y"): raise lab0() # ], line 116 self.ket = self.cursor # <-, line 116 if not self.slice_from(u"Y"): return False # set Y_found, line 116 self.B_Y_found = True except lab0: pass self.cursor = v_1 # do, line 117 v_2 = self.cursor try: # repeat, line 117 try: while True: try: v_3 = self.cursor try: # (, line 117 # goto, line 117 try: while True: v_4 = self.cursor try: # (, line 117 if not self.in_grouping(PorterStemmer.g_v, 97, 121): raise lab6() # [, line 117 self.bra = self.cursor # literal, line 117 if not self.eq_s(1, u"y"): raise lab6() # ], line 117 self.ket = self.cursor self.cursor = v_4 raise lab5() except lab6: pass self.cursor = v_4 if self.cursor >= self.limit: raise lab4() self.cursor += 1 except lab5: pass # <-, line 117 if not self.slice_from(u"Y"): return False # set Y_found, line 117 self.B_Y_found = True raise lab3() except lab4: pass self.cursor = v_3 raise lab2() except lab3: pass except lab2: pass except lab1: pass self.cursor = v_2 self.I_p1 = self.limit; self.I_p2 = self.limit; # do, line 121 v_5 = self.cursor try: # (, line 121 # gopast, line 122 try: while True: try: if not self.in_grouping(PorterStemmer.g_v, 97, 121): raise lab9() raise lab8() except lab9: pass if self.cursor >= self.limit: raise lab7() self.cursor += 1 except lab8: pass # gopast, line 122 try: while True: try: if not self.out_grouping(PorterStemmer.g_v, 97, 121): raise lab11() raise lab10() except lab11: pass if self.cursor >= self.limit: raise lab7() self.cursor += 1 except lab10: pass # setmark p1, line 122 self.I_p1 = self.cursor # gopast, line 123 try: while True: try: if not self.in_grouping(PorterStemmer.g_v, 97, 121): raise lab13() raise lab12() except lab13: pass if self.cursor >= self.limit: raise lab7() self.cursor += 1 except lab12: pass # gopast, line 123 try: while True: try: if not self.out_grouping(PorterStemmer.g_v, 97, 121): raise lab15() raise lab14() except lab15: pass if self.cursor >= self.limit: raise lab7() self.cursor += 1 except lab14: pass # setmark p2, line 123 self.I_p2 = self.cursor except lab7: pass self.cursor = v_5 # backwards, line 126 self.limit_backward = self.cursor self.cursor = self.limit # (, line 126 # do, line 127 v_10 = self.limit - self.cursor try: # call Step_1a, line 127 if not self.r_Step_1a(): raise lab16() except lab16: pass self.cursor = self.limit - v_10 # do, line 128 v_11 = self.limit - self.cursor try: # call Step_1b, line 128 if not self.r_Step_1b(): raise lab17() except lab17: pass self.cursor = self.limit - v_11 # do, line 129 v_12 = self.limit - self.cursor try: # call Step_1c, line 129 if not self.r_Step_1c(): raise lab18() except lab18: pass self.cursor = self.limit - v_12 # do, line 130 v_13 = self.limit - self.cursor try: # call Step_2, line 130 if not self.r_Step_2(): raise lab19() except lab19: pass self.cursor = self.limit - v_13 # do, line 131 v_14 = self.limit - self.cursor try: # call Step_3, line 131 if not self.r_Step_3(): raise lab20() except lab20: pass self.cursor = self.limit - v_14 # do, line 132 v_15 = self.limit - self.cursor try: # call Step_4, line 132 if not self.r_Step_4(): raise lab21() except lab21: pass self.cursor = self.limit - v_15 # do, line 133 v_16 = self.limit - self.cursor try: # call Step_5a, line 133 if not self.r_Step_5a(): raise lab22() except lab22: pass self.cursor = self.limit - v_16 # do, line 134 v_17 = self.limit - self.cursor try: # call Step_5b, line 134 if not self.r_Step_5b(): raise lab23() except lab23: pass self.cursor = self.limit - v_17 self.cursor = self.limit_backward # do, line 137 v_18 = self.cursor try: # (, line 137 # Boolean test Y_found, line 137 if not self.B_Y_found: raise lab24() # repeat, line 137 try: while True: try: v_19 = self.cursor try: # (, line 137 # goto, line 137 try: while True: v_20 = self.cursor try: # (, line 137 # [, line 137 self.bra = self.cursor # literal, line 137 if not self.eq_s(1, u"Y"): raise lab29() # ], line 137 self.ket = self.cursor self.cursor = v_20 raise lab28() except lab29: pass self.cursor = v_20 if self.cursor >= self.limit: raise lab27() self.cursor += 1 except lab28: pass # <-, line 137 if not self.slice_from(u"y"): return False raise lab26() except lab27: pass self.cursor = v_19 raise lab25() except lab26: pass except lab25: pass except lab24: pass self.cursor = v_18 return True def equals(self, o): return isinstance(o, PorterStemmer) def hashCode(self): return hash("PorterStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass class lab11(BaseException): pass class lab12(BaseException): pass class lab13(BaseException): pass class lab14(BaseException): pass class lab15(BaseException): pass class lab16(BaseException): pass class lab17(BaseException): pass class lab18(BaseException): pass class lab19(BaseException): pass class lab20(BaseException): pass class lab21(BaseException): pass class lab22(BaseException): pass class lab23(BaseException): pass class lab24(BaseException): pass class lab25(BaseException): pass class lab26(BaseException): pass class lab27(BaseException): pass class lab28(BaseException): pass class lab29(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/portuguese_stemmer.py0000644€-©8€ZĂ);0000007656312637132734031577 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class PortugueseStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"", -1, 3), Among(u"\u00E3", 0, 1), Among(u"\u00F5", 0, 2) ] a_1 = [ Among(u"", -1, 3), Among(u"a~", 0, 1), Among(u"o~", 0, 2) ] a_2 = [ Among(u"ic", -1, -1), Among(u"ad", -1, -1), Among(u"os", -1, -1), Among(u"iv", -1, 1) ] a_3 = [ Among(u"ante", -1, 1), Among(u"avel", -1, 1), Among(u"\u00EDvel", -1, 1) ] a_4 = [ Among(u"ic", -1, 1), Among(u"abil", -1, 1), Among(u"iv", -1, 1) ] a_5 = [ Among(u"ica", -1, 1), Among(u"\u00E2ncia", -1, 1), Among(u"\u00EAncia", -1, 4), Among(u"ira", -1, 9), Among(u"adora", -1, 1), Among(u"osa", -1, 1), Among(u"ista", -1, 1), Among(u"iva", -1, 8), Among(u"eza", -1, 1), Among(u"log\u00EDa", -1, 2), Among(u"idade", -1, 7), Among(u"ante", -1, 1), Among(u"mente", -1, 6), Among(u"amente", 12, 5), Among(u"\u00E1vel", -1, 1), Among(u"\u00EDvel", -1, 1), Among(u"uci\u00F3n", -1, 3), Among(u"ico", -1, 1), Among(u"ismo", -1, 1), Among(u"oso", -1, 1), Among(u"amento", -1, 1), Among(u"imento", -1, 1), Among(u"ivo", -1, 8), Among(u"a\u00E7a~o", -1, 1), Among(u"ador", -1, 1), Among(u"icas", -1, 1), Among(u"\u00EAncias", -1, 4), Among(u"iras", -1, 9), Among(u"adoras", -1, 1), Among(u"osas", -1, 1), Among(u"istas", -1, 1), Among(u"ivas", -1, 8), Among(u"ezas", -1, 1), Among(u"log\u00EDas", -1, 2), Among(u"idades", -1, 7), Among(u"uciones", -1, 3), Among(u"adores", -1, 1), Among(u"antes", -1, 1), Among(u"a\u00E7o~es", -1, 1), Among(u"icos", -1, 1), Among(u"ismos", -1, 1), Among(u"osos", -1, 1), Among(u"amentos", -1, 1), Among(u"imentos", -1, 1), Among(u"ivos", -1, 8) ] a_6 = [ Among(u"ada", -1, 1), Among(u"ida", -1, 1), Among(u"ia", -1, 1), Among(u"aria", 2, 1), Among(u"eria", 2, 1), Among(u"iria", 2, 1), Among(u"ara", -1, 1), Among(u"era", -1, 1), Among(u"ira", -1, 1), Among(u"ava", -1, 1), Among(u"asse", -1, 1), Among(u"esse", -1, 1), Among(u"isse", -1, 1), Among(u"aste", -1, 1), Among(u"este", -1, 1), Among(u"iste", -1, 1), Among(u"ei", -1, 1), Among(u"arei", 16, 1), Among(u"erei", 16, 1), Among(u"irei", 16, 1), Among(u"am", -1, 1), Among(u"iam", 20, 1), Among(u"ariam", 21, 1), Among(u"eriam", 21, 1), Among(u"iriam", 21, 1), Among(u"aram", 20, 1), Among(u"eram", 20, 1), Among(u"iram", 20, 1), Among(u"avam", 20, 1), Among(u"em", -1, 1), Among(u"arem", 29, 1), Among(u"erem", 29, 1), Among(u"irem", 29, 1), Among(u"assem", 29, 1), Among(u"essem", 29, 1), Among(u"issem", 29, 1), Among(u"ado", -1, 1), Among(u"ido", -1, 1), Among(u"ando", -1, 1), Among(u"endo", -1, 1), Among(u"indo", -1, 1), Among(u"ara~o", -1, 1), Among(u"era~o", -1, 1), Among(u"ira~o", -1, 1), Among(u"ar", -1, 1), Among(u"er", -1, 1), Among(u"ir", -1, 1), Among(u"as", -1, 1), Among(u"adas", 47, 1), Among(u"idas", 47, 1), Among(u"ias", 47, 1), Among(u"arias", 50, 1), Among(u"erias", 50, 1), Among(u"irias", 50, 1), Among(u"aras", 47, 1), Among(u"eras", 47, 1), Among(u"iras", 47, 1), Among(u"avas", 47, 1), Among(u"es", -1, 1), Among(u"ardes", 58, 1), Among(u"erdes", 58, 1), Among(u"irdes", 58, 1), Among(u"ares", 58, 1), Among(u"eres", 58, 1), Among(u"ires", 58, 1), Among(u"asses", 58, 1), Among(u"esses", 58, 1), Among(u"isses", 58, 1), Among(u"astes", 58, 1), Among(u"estes", 58, 1), Among(u"istes", 58, 1), Among(u"is", -1, 1), Among(u"ais", 71, 1), Among(u"eis", 71, 1), Among(u"areis", 73, 1), Among(u"ereis", 73, 1), Among(u"ireis", 73, 1), Among(u"\u00E1reis", 73, 1), Among(u"\u00E9reis", 73, 1), Among(u"\u00EDreis", 73, 1), Among(u"\u00E1sseis", 73, 1), Among(u"\u00E9sseis", 73, 1), Among(u"\u00EDsseis", 73, 1), Among(u"\u00E1veis", 73, 1), Among(u"\u00EDeis", 73, 1), Among(u"ar\u00EDeis", 84, 1), Among(u"er\u00EDeis", 84, 1), Among(u"ir\u00EDeis", 84, 1), Among(u"ados", -1, 1), Among(u"idos", -1, 1), Among(u"amos", -1, 1), Among(u"\u00E1ramos", 90, 1), Among(u"\u00E9ramos", 90, 1), Among(u"\u00EDramos", 90, 1), Among(u"\u00E1vamos", 90, 1), Among(u"\u00EDamos", 90, 1), Among(u"ar\u00EDamos", 95, 1), Among(u"er\u00EDamos", 95, 1), Among(u"ir\u00EDamos", 95, 1), Among(u"emos", -1, 1), Among(u"aremos", 99, 1), Among(u"eremos", 99, 1), Among(u"iremos", 99, 1), Among(u"\u00E1ssemos", 99, 1), Among(u"\u00EAssemos", 99, 1), Among(u"\u00EDssemos", 99, 1), Among(u"imos", -1, 1), Among(u"armos", -1, 1), Among(u"ermos", -1, 1), Among(u"irmos", -1, 1), Among(u"\u00E1mos", -1, 1), Among(u"ar\u00E1s", -1, 1), Among(u"er\u00E1s", -1, 1), Among(u"ir\u00E1s", -1, 1), Among(u"eu", -1, 1), Among(u"iu", -1, 1), Among(u"ou", -1, 1), Among(u"ar\u00E1", -1, 1), Among(u"er\u00E1", -1, 1), Among(u"ir\u00E1", -1, 1) ] a_7 = [ Among(u"a", -1, 1), Among(u"i", -1, 1), Among(u"o", -1, 1), Among(u"os", -1, 1), Among(u"\u00E1", -1, 1), Among(u"\u00ED", -1, 1), Among(u"\u00F3", -1, 1) ] a_8 = [ Among(u"e", -1, 1), Among(u"\u00E7", -1, 2), Among(u"\u00E9", -1, 1), Among(u"\u00EA", -1, 1) ] g_v = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 19, 12, 2] I_p2 = 0 I_p1 = 0 I_pV = 0 def copy_from(self, other): self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 self.I_pV = other.I_pV super.copy_from(other) def r_prelude(self): # repeat, line 36 try: while True: try: v_1 = self.cursor try: # (, line 36 # [, line 37 self.bra = self.cursor # substring, line 37 among_var = self.find_among(PortugueseStemmer.a_0, 3) if among_var == 0: raise lab2() # ], line 37 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 38 # <-, line 38 if not self.slice_from(u"a~"): return False elif among_var == 2: # (, line 39 # <-, line 39 if not self.slice_from(u"o~"): return False elif among_var == 3: # (, line 40 # next, line 40 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_mark_regions(self): # (, line 44 self.I_pV = self.limit; self.I_p1 = self.limit; self.I_p2 = self.limit; # do, line 50 v_1 = self.cursor try: # (, line 50 # or, line 52 try: v_2 = self.cursor try: # (, line 51 if not self.in_grouping(PortugueseStemmer.g_v, 97, 250): raise lab2() # or, line 51 try: v_3 = self.cursor try: # (, line 51 if not self.out_grouping(PortugueseStemmer.g_v, 97, 250): raise lab4() # gopast, line 51 try: while True: try: if not self.in_grouping(PortugueseStemmer.g_v, 97, 250): raise lab6() raise lab5() except lab6: pass if self.cursor >= self.limit: raise lab4() self.cursor += 1 except lab5: pass raise lab3() except lab4: pass self.cursor = v_3 # (, line 51 if not self.in_grouping(PortugueseStemmer.g_v, 97, 250): raise lab2() # gopast, line 51 try: while True: try: if not self.out_grouping(PortugueseStemmer.g_v, 97, 250): raise lab8() raise lab7() except lab8: pass if self.cursor >= self.limit: raise lab2() self.cursor += 1 except lab7: pass except lab3: pass raise lab1() except lab2: pass self.cursor = v_2 # (, line 53 if not self.out_grouping(PortugueseStemmer.g_v, 97, 250): raise lab0() # or, line 53 try: v_6 = self.cursor try: # (, line 53 if not self.out_grouping(PortugueseStemmer.g_v, 97, 250): raise lab10() # gopast, line 53 try: while True: try: if not self.in_grouping(PortugueseStemmer.g_v, 97, 250): raise lab12() raise lab11() except lab12: pass if self.cursor >= self.limit: raise lab10() self.cursor += 1 except lab11: pass raise lab9() except lab10: pass self.cursor = v_6 # (, line 53 if not self.in_grouping(PortugueseStemmer.g_v, 97, 250): raise lab0() # next, line 53 if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab9: pass except lab1: pass # setmark pV, line 54 self.I_pV = self.cursor except lab0: pass self.cursor = v_1 # do, line 56 v_8 = self.cursor try: # (, line 56 # gopast, line 57 try: while True: try: if not self.in_grouping(PortugueseStemmer.g_v, 97, 250): raise lab15() raise lab14() except lab15: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab14: pass # gopast, line 57 try: while True: try: if not self.out_grouping(PortugueseStemmer.g_v, 97, 250): raise lab17() raise lab16() except lab17: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab16: pass # setmark p1, line 57 self.I_p1 = self.cursor # gopast, line 58 try: while True: try: if not self.in_grouping(PortugueseStemmer.g_v, 97, 250): raise lab19() raise lab18() except lab19: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab18: pass # gopast, line 58 try: while True: try: if not self.out_grouping(PortugueseStemmer.g_v, 97, 250): raise lab21() raise lab20() except lab21: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab20: pass # setmark p2, line 58 self.I_p2 = self.cursor except lab13: pass self.cursor = v_8 return True def r_postlude(self): # repeat, line 62 try: while True: try: v_1 = self.cursor try: # (, line 62 # [, line 63 self.bra = self.cursor # substring, line 63 among_var = self.find_among(PortugueseStemmer.a_1, 3) if among_var == 0: raise lab2() # ], line 63 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 64 # <-, line 64 if not self.slice_from(u"\u00E3"): return False elif among_var == 2: # (, line 65 # <-, line 65 if not self.slice_from(u"\u00F5"): return False elif among_var == 3: # (, line 66 # next, line 66 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_RV(self): if not self.I_pV <= self.cursor: return False return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_standard_suffix(self): # (, line 76 # [, line 77 self.ket = self.cursor # substring, line 77 among_var = self.find_among_b(PortugueseStemmer.a_5, 45) if among_var == 0: return False # ], line 77 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 92 # call R2, line 93 if not self.r_R2(): return False # delete, line 93 if not self.slice_del(): return False elif among_var == 2: # (, line 97 # call R2, line 98 if not self.r_R2(): return False # <-, line 98 if not self.slice_from(u"log"): return False elif among_var == 3: # (, line 101 # call R2, line 102 if not self.r_R2(): return False # <-, line 102 if not self.slice_from(u"u"): return False elif among_var == 4: # (, line 105 # call R2, line 106 if not self.r_R2(): return False # <-, line 106 if not self.slice_from(u"ente"): return False elif among_var == 5: # (, line 109 # call R1, line 110 if not self.r_R1(): return False # delete, line 110 if not self.slice_del(): return False # try, line 111 v_1 = self.limit - self.cursor try: # (, line 111 # [, line 112 self.ket = self.cursor # substring, line 112 among_var = self.find_among_b(PortugueseStemmer.a_2, 4) if among_var == 0: self.cursor = self.limit - v_1 raise lab0() # ], line 112 self.bra = self.cursor # call R2, line 112 if not self.r_R2(): self.cursor = self.limit - v_1 raise lab0() # delete, line 112 if not self.slice_del(): return False if among_var == 0: self.cursor = self.limit - v_1 raise lab0() elif among_var == 1: # (, line 113 # [, line 113 self.ket = self.cursor # literal, line 113 if not self.eq_s_b(2, u"at"): self.cursor = self.limit - v_1 raise lab0() # ], line 113 self.bra = self.cursor # call R2, line 113 if not self.r_R2(): self.cursor = self.limit - v_1 raise lab0() # delete, line 113 if not self.slice_del(): return False except lab0: pass elif among_var == 6: # (, line 121 # call R2, line 122 if not self.r_R2(): return False # delete, line 122 if not self.slice_del(): return False # try, line 123 v_2 = self.limit - self.cursor try: # (, line 123 # [, line 124 self.ket = self.cursor # substring, line 124 among_var = self.find_among_b(PortugueseStemmer.a_3, 3) if among_var == 0: self.cursor = self.limit - v_2 raise lab1() # ], line 124 self.bra = self.cursor if among_var == 0: self.cursor = self.limit - v_2 raise lab1() elif among_var == 1: # (, line 127 # call R2, line 127 if not self.r_R2(): self.cursor = self.limit - v_2 raise lab1() # delete, line 127 if not self.slice_del(): return False except lab1: pass elif among_var == 7: # (, line 133 # call R2, line 134 if not self.r_R2(): return False # delete, line 134 if not self.slice_del(): return False # try, line 135 v_3 = self.limit - self.cursor try: # (, line 135 # [, line 136 self.ket = self.cursor # substring, line 136 among_var = self.find_among_b(PortugueseStemmer.a_4, 3) if among_var == 0: self.cursor = self.limit - v_3 raise lab2() # ], line 136 self.bra = self.cursor if among_var == 0: self.cursor = self.limit - v_3 raise lab2() elif among_var == 1: # (, line 139 # call R2, line 139 if not self.r_R2(): self.cursor = self.limit - v_3 raise lab2() # delete, line 139 if not self.slice_del(): return False except lab2: pass elif among_var == 8: # (, line 145 # call R2, line 146 if not self.r_R2(): return False # delete, line 146 if not self.slice_del(): return False # try, line 147 v_4 = self.limit - self.cursor try: # (, line 147 # [, line 148 self.ket = self.cursor # literal, line 148 if not self.eq_s_b(2, u"at"): self.cursor = self.limit - v_4 raise lab3() # ], line 148 self.bra = self.cursor # call R2, line 148 if not self.r_R2(): self.cursor = self.limit - v_4 raise lab3() # delete, line 148 if not self.slice_del(): return False except lab3: pass elif among_var == 9: # (, line 152 # call RV, line 153 if not self.r_RV(): return False # literal, line 153 if not self.eq_s_b(1, u"e"): return False # <-, line 154 if not self.slice_from(u"ir"): return False return True def r_verb_suffix(self): # setlimit, line 159 v_1 = self.limit - self.cursor # tomark, line 159 if self.cursor < self.I_pV: return False self.cursor = self.I_pV v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 159 # [, line 160 self.ket = self.cursor # substring, line 160 among_var = self.find_among_b(PortugueseStemmer.a_6, 120) if among_var == 0: self.limit_backward = v_2 return False # ], line 160 self.bra = self.cursor if among_var == 0: self.limit_backward = v_2 return False elif among_var == 1: # (, line 179 # delete, line 179 if not self.slice_del(): return False self.limit_backward = v_2 return True def r_residual_suffix(self): # (, line 183 # [, line 184 self.ket = self.cursor # substring, line 184 among_var = self.find_among_b(PortugueseStemmer.a_7, 7) if among_var == 0: return False # ], line 184 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 187 # call RV, line 187 if not self.r_RV(): return False # delete, line 187 if not self.slice_del(): return False return True def r_residual_form(self): # (, line 191 # [, line 192 self.ket = self.cursor # substring, line 192 among_var = self.find_among_b(PortugueseStemmer.a_8, 4) if among_var == 0: return False # ], line 192 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 194 # call RV, line 194 if not self.r_RV(): return False # delete, line 194 if not self.slice_del(): return False # [, line 194 self.ket = self.cursor # or, line 194 try: v_1 = self.limit - self.cursor try: # (, line 194 # literal, line 194 if not self.eq_s_b(1, u"u"): raise lab1() # ], line 194 self.bra = self.cursor # test, line 194 v_2 = self.limit - self.cursor # literal, line 194 if not self.eq_s_b(1, u"g"): raise lab1() self.cursor = self.limit - v_2 raise lab0() except lab1: pass self.cursor = self.limit - v_1 # (, line 195 # literal, line 195 if not self.eq_s_b(1, u"i"): return False # ], line 195 self.bra = self.cursor # test, line 195 v_3 = self.limit - self.cursor # literal, line 195 if not self.eq_s_b(1, u"c"): return False self.cursor = self.limit - v_3 except lab0: pass # call RV, line 195 if not self.r_RV(): return False # delete, line 195 if not self.slice_del(): return False elif among_var == 2: # (, line 196 # <-, line 196 if not self.slice_from(u"c"): return False return True def _stem(self): # (, line 201 # do, line 202 v_1 = self.cursor try: # call prelude, line 202 if not self.r_prelude(): raise lab0() except lab0: pass self.cursor = v_1 # do, line 203 v_2 = self.cursor try: # call mark_regions, line 203 if not self.r_mark_regions(): raise lab1() except lab1: pass self.cursor = v_2 # backwards, line 204 self.limit_backward = self.cursor self.cursor = self.limit # (, line 204 # do, line 205 v_3 = self.limit - self.cursor try: # (, line 205 # or, line 209 try: v_4 = self.limit - self.cursor try: # (, line 206 # and, line 207 v_5 = self.limit - self.cursor # (, line 206 # or, line 206 try: v_6 = self.limit - self.cursor try: # call standard_suffix, line 206 if not self.r_standard_suffix(): raise lab6() raise lab5() except lab6: pass self.cursor = self.limit - v_6 # call verb_suffix, line 206 if not self.r_verb_suffix(): raise lab4() except lab5: pass self.cursor = self.limit - v_5 # do, line 207 v_7 = self.limit - self.cursor try: # (, line 207 # [, line 207 self.ket = self.cursor # literal, line 207 if not self.eq_s_b(1, u"i"): raise lab7() # ], line 207 self.bra = self.cursor # test, line 207 v_8 = self.limit - self.cursor # literal, line 207 if not self.eq_s_b(1, u"c"): raise lab7() self.cursor = self.limit - v_8 # call RV, line 207 if not self.r_RV(): raise lab7() # delete, line 207 if not self.slice_del(): return False except lab7: pass self.cursor = self.limit - v_7 raise lab3() except lab4: pass self.cursor = self.limit - v_4 # call residual_suffix, line 209 if not self.r_residual_suffix(): raise lab2() except lab3: pass except lab2: pass self.cursor = self.limit - v_3 # do, line 211 v_9 = self.limit - self.cursor try: # call residual_form, line 211 if not self.r_residual_form(): raise lab8() except lab8: pass self.cursor = self.limit - v_9 self.cursor = self.limit_backward # do, line 213 v_10 = self.cursor try: # call postlude, line 213 if not self.r_postlude(): raise lab9() except lab9: pass self.cursor = v_10 return True def equals(self, o): return isinstance(o, PortugueseStemmer) def hashCode(self): return hash("PortugueseStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass class lab11(BaseException): pass class lab12(BaseException): pass class lab13(BaseException): pass class lab14(BaseException): pass class lab15(BaseException): pass class lab16(BaseException): pass class lab17(BaseException): pass class lab18(BaseException): pass class lab19(BaseException): pass class lab20(BaseException): pass class lab21(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/romanian_stemmer.py0000644€-©8€ZĂ);0000007333712637132734031175 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class RomanianStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"", -1, 3), Among(u"I", 0, 1), Among(u"U", 0, 2) ] a_1 = [ Among(u"ea", -1, 3), Among(u"a\u0163ia", -1, 7), Among(u"aua", -1, 2), Among(u"iua", -1, 4), Among(u"a\u0163ie", -1, 7), Among(u"ele", -1, 3), Among(u"ile", -1, 5), Among(u"iile", 6, 4), Among(u"iei", -1, 4), Among(u"atei", -1, 6), Among(u"ii", -1, 4), Among(u"ului", -1, 1), Among(u"ul", -1, 1), Among(u"elor", -1, 3), Among(u"ilor", -1, 4), Among(u"iilor", 14, 4) ] a_2 = [ Among(u"icala", -1, 4), Among(u"iciva", -1, 4), Among(u"ativa", -1, 5), Among(u"itiva", -1, 6), Among(u"icale", -1, 4), Among(u"a\u0163iune", -1, 5), Among(u"i\u0163iune", -1, 6), Among(u"atoare", -1, 5), Among(u"itoare", -1, 6), Among(u"\u0103toare", -1, 5), Among(u"icitate", -1, 4), Among(u"abilitate", -1, 1), Among(u"ibilitate", -1, 2), Among(u"ivitate", -1, 3), Among(u"icive", -1, 4), Among(u"ative", -1, 5), Among(u"itive", -1, 6), Among(u"icali", -1, 4), Among(u"atori", -1, 5), Among(u"icatori", 18, 4), Among(u"itori", -1, 6), Among(u"\u0103tori", -1, 5), Among(u"icitati", -1, 4), Among(u"abilitati", -1, 1), Among(u"ivitati", -1, 3), Among(u"icivi", -1, 4), Among(u"ativi", -1, 5), Among(u"itivi", -1, 6), Among(u"icit\u0103i", -1, 4), Among(u"abilit\u0103i", -1, 1), Among(u"ivit\u0103i", -1, 3), Among(u"icit\u0103\u0163i", -1, 4), Among(u"abilit\u0103\u0163i", -1, 1), Among(u"ivit\u0103\u0163i", -1, 3), Among(u"ical", -1, 4), Among(u"ator", -1, 5), Among(u"icator", 35, 4), Among(u"itor", -1, 6), Among(u"\u0103tor", -1, 5), Among(u"iciv", -1, 4), Among(u"ativ", -1, 5), Among(u"itiv", -1, 6), Among(u"ical\u0103", -1, 4), Among(u"iciv\u0103", -1, 4), Among(u"ativ\u0103", -1, 5), Among(u"itiv\u0103", -1, 6) ] a_3 = [ Among(u"ica", -1, 1), Among(u"abila", -1, 1), Among(u"ibila", -1, 1), Among(u"oasa", -1, 1), Among(u"ata", -1, 1), Among(u"ita", -1, 1), Among(u"anta", -1, 1), Among(u"ista", -1, 3), Among(u"uta", -1, 1), Among(u"iva", -1, 1), Among(u"ic", -1, 1), Among(u"ice", -1, 1), Among(u"abile", -1, 1), Among(u"ibile", -1, 1), Among(u"isme", -1, 3), Among(u"iune", -1, 2), Among(u"oase", -1, 1), Among(u"ate", -1, 1), Among(u"itate", 17, 1), Among(u"ite", -1, 1), Among(u"ante", -1, 1), Among(u"iste", -1, 3), Among(u"ute", -1, 1), Among(u"ive", -1, 1), Among(u"ici", -1, 1), Among(u"abili", -1, 1), Among(u"ibili", -1, 1), Among(u"iuni", -1, 2), Among(u"atori", -1, 1), Among(u"osi", -1, 1), Among(u"ati", -1, 1), Among(u"itati", 30, 1), Among(u"iti", -1, 1), Among(u"anti", -1, 1), Among(u"isti", -1, 3), Among(u"uti", -1, 1), Among(u"i\u015Fti", -1, 3), Among(u"ivi", -1, 1), Among(u"it\u0103i", -1, 1), Among(u"o\u015Fi", -1, 1), Among(u"it\u0103\u0163i", -1, 1), Among(u"abil", -1, 1), Among(u"ibil", -1, 1), Among(u"ism", -1, 3), Among(u"ator", -1, 1), Among(u"os", -1, 1), Among(u"at", -1, 1), Among(u"it", -1, 1), Among(u"ant", -1, 1), Among(u"ist", -1, 3), Among(u"ut", -1, 1), Among(u"iv", -1, 1), Among(u"ic\u0103", -1, 1), Among(u"abil\u0103", -1, 1), Among(u"ibil\u0103", -1, 1), Among(u"oas\u0103", -1, 1), Among(u"at\u0103", -1, 1), Among(u"it\u0103", -1, 1), Among(u"ant\u0103", -1, 1), Among(u"ist\u0103", -1, 3), Among(u"ut\u0103", -1, 1), Among(u"iv\u0103", -1, 1) ] a_4 = [ Among(u"ea", -1, 1), Among(u"ia", -1, 1), Among(u"esc", -1, 1), Among(u"\u0103sc", -1, 1), Among(u"ind", -1, 1), Among(u"\u00E2nd", -1, 1), Among(u"are", -1, 1), Among(u"ere", -1, 1), Among(u"ire", -1, 1), Among(u"\u00E2re", -1, 1), Among(u"se", -1, 2), Among(u"ase", 10, 1), Among(u"sese", 10, 2), Among(u"ise", 10, 1), Among(u"use", 10, 1), Among(u"\u00E2se", 10, 1), Among(u"e\u015Fte", -1, 1), Among(u"\u0103\u015Fte", -1, 1), Among(u"eze", -1, 1), Among(u"ai", -1, 1), Among(u"eai", 19, 1), Among(u"iai", 19, 1), Among(u"sei", -1, 2), Among(u"e\u015Fti", -1, 1), Among(u"\u0103\u015Fti", -1, 1), Among(u"ui", -1, 1), Among(u"ezi", -1, 1), Among(u"\u00E2i", -1, 1), Among(u"a\u015Fi", -1, 1), Among(u"se\u015Fi", -1, 2), Among(u"ase\u015Fi", 29, 1), Among(u"sese\u015Fi", 29, 2), Among(u"ise\u015Fi", 29, 1), Among(u"use\u015Fi", 29, 1), Among(u"\u00E2se\u015Fi", 29, 1), Among(u"i\u015Fi", -1, 1), Among(u"u\u015Fi", -1, 1), Among(u"\u00E2\u015Fi", -1, 1), Among(u"a\u0163i", -1, 2), Among(u"ea\u0163i", 38, 1), Among(u"ia\u0163i", 38, 1), Among(u"e\u0163i", -1, 2), Among(u"i\u0163i", -1, 2), Among(u"\u00E2\u0163i", -1, 2), Among(u"ar\u0103\u0163i", -1, 1), Among(u"ser\u0103\u0163i", -1, 2), Among(u"aser\u0103\u0163i", 45, 1), Among(u"seser\u0103\u0163i", 45, 2), Among(u"iser\u0103\u0163i", 45, 1), Among(u"user\u0103\u0163i", 45, 1), Among(u"\u00E2ser\u0103\u0163i", 45, 1), Among(u"ir\u0103\u0163i", -1, 1), Among(u"ur\u0103\u0163i", -1, 1), Among(u"\u00E2r\u0103\u0163i", -1, 1), Among(u"am", -1, 1), Among(u"eam", 54, 1), Among(u"iam", 54, 1), Among(u"em", -1, 2), Among(u"asem", 57, 1), Among(u"sesem", 57, 2), Among(u"isem", 57, 1), Among(u"usem", 57, 1), Among(u"\u00E2sem", 57, 1), Among(u"im", -1, 2), Among(u"\u00E2m", -1, 2), Among(u"\u0103m", -1, 2), Among(u"ar\u0103m", 65, 1), Among(u"ser\u0103m", 65, 2), Among(u"aser\u0103m", 67, 1), Among(u"seser\u0103m", 67, 2), Among(u"iser\u0103m", 67, 1), Among(u"user\u0103m", 67, 1), Among(u"\u00E2ser\u0103m", 67, 1), Among(u"ir\u0103m", 65, 1), Among(u"ur\u0103m", 65, 1), Among(u"\u00E2r\u0103m", 65, 1), Among(u"au", -1, 1), Among(u"eau", 76, 1), Among(u"iau", 76, 1), Among(u"indu", -1, 1), Among(u"\u00E2ndu", -1, 1), Among(u"ez", -1, 1), Among(u"easc\u0103", -1, 1), Among(u"ar\u0103", -1, 1), Among(u"ser\u0103", -1, 2), Among(u"aser\u0103", 84, 1), Among(u"seser\u0103", 84, 2), Among(u"iser\u0103", 84, 1), Among(u"user\u0103", 84, 1), Among(u"\u00E2ser\u0103", 84, 1), Among(u"ir\u0103", -1, 1), Among(u"ur\u0103", -1, 1), Among(u"\u00E2r\u0103", -1, 1), Among(u"eaz\u0103", -1, 1) ] a_5 = [ Among(u"a", -1, 1), Among(u"e", -1, 1), Among(u"ie", 1, 1), Among(u"i", -1, 1), Among(u"\u0103", -1, 1) ] g_v = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 32, 0, 0, 4] B_standard_suffix_removed = False I_p2 = 0 I_p1 = 0 I_pV = 0 def copy_from(self, other): self.B_standard_suffix_removed = other.B_standard_suffix_removed self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 self.I_pV = other.I_pV super.copy_from(other) def r_prelude(self): # (, line 31 # repeat, line 32 try: while True: try: v_1 = self.cursor try: # goto, line 32 try: while True: v_2 = self.cursor try: # (, line 32 if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab4() # [, line 33 self.bra = self.cursor # or, line 33 try: v_3 = self.cursor try: # (, line 33 # literal, line 33 if not self.eq_s(1, u"u"): raise lab6() # ], line 33 self.ket = self.cursor if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab6() # <-, line 33 if not self.slice_from(u"U"): return False raise lab5() except lab6: pass self.cursor = v_3 # (, line 34 # literal, line 34 if not self.eq_s(1, u"i"): raise lab4() # ], line 34 self.ket = self.cursor if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab4() # <-, line 34 if not self.slice_from(u"I"): return False except lab5: pass self.cursor = v_2 raise lab3() except lab4: pass self.cursor = v_2 if self.cursor >= self.limit: raise lab2() self.cursor += 1 except lab3: pass raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_mark_regions(self): # (, line 38 self.I_pV = self.limit; self.I_p1 = self.limit; self.I_p2 = self.limit; # do, line 44 v_1 = self.cursor try: # (, line 44 # or, line 46 try: v_2 = self.cursor try: # (, line 45 if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab2() # or, line 45 try: v_3 = self.cursor try: # (, line 45 if not self.out_grouping(RomanianStemmer.g_v, 97, 259): raise lab4() # gopast, line 45 try: while True: try: if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab6() raise lab5() except lab6: pass if self.cursor >= self.limit: raise lab4() self.cursor += 1 except lab5: pass raise lab3() except lab4: pass self.cursor = v_3 # (, line 45 if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab2() # gopast, line 45 try: while True: try: if not self.out_grouping(RomanianStemmer.g_v, 97, 259): raise lab8() raise lab7() except lab8: pass if self.cursor >= self.limit: raise lab2() self.cursor += 1 except lab7: pass except lab3: pass raise lab1() except lab2: pass self.cursor = v_2 # (, line 47 if not self.out_grouping(RomanianStemmer.g_v, 97, 259): raise lab0() # or, line 47 try: v_6 = self.cursor try: # (, line 47 if not self.out_grouping(RomanianStemmer.g_v, 97, 259): raise lab10() # gopast, line 47 try: while True: try: if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab12() raise lab11() except lab12: pass if self.cursor >= self.limit: raise lab10() self.cursor += 1 except lab11: pass raise lab9() except lab10: pass self.cursor = v_6 # (, line 47 if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab0() # next, line 47 if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab9: pass except lab1: pass # setmark pV, line 48 self.I_pV = self.cursor except lab0: pass self.cursor = v_1 # do, line 50 v_8 = self.cursor try: # (, line 50 # gopast, line 51 try: while True: try: if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab15() raise lab14() except lab15: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab14: pass # gopast, line 51 try: while True: try: if not self.out_grouping(RomanianStemmer.g_v, 97, 259): raise lab17() raise lab16() except lab17: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab16: pass # setmark p1, line 51 self.I_p1 = self.cursor # gopast, line 52 try: while True: try: if not self.in_grouping(RomanianStemmer.g_v, 97, 259): raise lab19() raise lab18() except lab19: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab18: pass # gopast, line 52 try: while True: try: if not self.out_grouping(RomanianStemmer.g_v, 97, 259): raise lab21() raise lab20() except lab21: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab20: pass # setmark p2, line 52 self.I_p2 = self.cursor except lab13: pass self.cursor = v_8 return True def r_postlude(self): # repeat, line 56 try: while True: try: v_1 = self.cursor try: # (, line 56 # [, line 58 self.bra = self.cursor # substring, line 58 among_var = self.find_among(RomanianStemmer.a_0, 3) if among_var == 0: raise lab2() # ], line 58 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 59 # <-, line 59 if not self.slice_from(u"i"): return False elif among_var == 2: # (, line 60 # <-, line 60 if not self.slice_from(u"u"): return False elif among_var == 3: # (, line 61 # next, line 61 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_RV(self): if not self.I_pV <= self.cursor: return False return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_step_0(self): # (, line 72 # [, line 73 self.ket = self.cursor # substring, line 73 among_var = self.find_among_b(RomanianStemmer.a_1, 16) if among_var == 0: return False # ], line 73 self.bra = self.cursor # call R1, line 73 if not self.r_R1(): return False if among_var == 0: return False elif among_var == 1: # (, line 75 # delete, line 75 if not self.slice_del(): return False elif among_var == 2: # (, line 77 # <-, line 77 if not self.slice_from(u"a"): return False elif among_var == 3: # (, line 79 # <-, line 79 if not self.slice_from(u"e"): return False elif among_var == 4: # (, line 81 # <-, line 81 if not self.slice_from(u"i"): return False elif among_var == 5: # (, line 83 # not, line 83 v_1 = self.limit - self.cursor try: # literal, line 83 if not self.eq_s_b(2, u"ab"): raise lab0() return False except lab0: pass self.cursor = self.limit - v_1 # <-, line 83 if not self.slice_from(u"i"): return False elif among_var == 6: # (, line 85 # <-, line 85 if not self.slice_from(u"at"): return False elif among_var == 7: # (, line 87 # <-, line 87 if not self.slice_from(u"a\u0163i"): return False return True def r_combo_suffix(self): # test, line 91 v_1 = self.limit - self.cursor # (, line 91 # [, line 92 self.ket = self.cursor # substring, line 92 among_var = self.find_among_b(RomanianStemmer.a_2, 46) if among_var == 0: return False # ], line 92 self.bra = self.cursor # call R1, line 92 if not self.r_R1(): return False # (, line 92 if among_var == 0: return False elif among_var == 1: # (, line 100 # <-, line 101 if not self.slice_from(u"abil"): return False elif among_var == 2: # (, line 103 # <-, line 104 if not self.slice_from(u"ibil"): return False elif among_var == 3: # (, line 106 # <-, line 107 if not self.slice_from(u"iv"): return False elif among_var == 4: # (, line 112 # <-, line 113 if not self.slice_from(u"ic"): return False elif among_var == 5: # (, line 117 # <-, line 118 if not self.slice_from(u"at"): return False elif among_var == 6: # (, line 121 # <-, line 122 if not self.slice_from(u"it"): return False # set standard_suffix_removed, line 125 self.B_standard_suffix_removed = True self.cursor = self.limit - v_1 return True def r_standard_suffix(self): # (, line 129 # unset standard_suffix_removed, line 130 self.B_standard_suffix_removed = False # repeat, line 131 try: while True: try: v_1 = self.limit - self.cursor try: # call combo_suffix, line 131 if not self.r_combo_suffix(): raise lab2() raise lab1() except lab2: pass self.cursor = self.limit - v_1 raise lab0() except lab1: pass except lab0: pass # [, line 132 self.ket = self.cursor # substring, line 132 among_var = self.find_among_b(RomanianStemmer.a_3, 62) if among_var == 0: return False # ], line 132 self.bra = self.cursor # call R2, line 132 if not self.r_R2(): return False # (, line 132 if among_var == 0: return False elif among_var == 1: # (, line 148 # delete, line 149 if not self.slice_del(): return False elif among_var == 2: # (, line 151 # literal, line 152 if not self.eq_s_b(1, u"\u0163"): return False # ], line 152 self.bra = self.cursor # <-, line 152 if not self.slice_from(u"t"): return False elif among_var == 3: # (, line 155 # <-, line 156 if not self.slice_from(u"ist"): return False # set standard_suffix_removed, line 160 self.B_standard_suffix_removed = True return True def r_verb_suffix(self): # setlimit, line 164 v_1 = self.limit - self.cursor # tomark, line 164 if self.cursor < self.I_pV: return False self.cursor = self.I_pV v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 164 # [, line 165 self.ket = self.cursor # substring, line 165 among_var = self.find_among_b(RomanianStemmer.a_4, 94) if among_var == 0: self.limit_backward = v_2 return False # ], line 165 self.bra = self.cursor if among_var == 0: self.limit_backward = v_2 return False elif among_var == 1: # (, line 200 # or, line 200 try: v_3 = self.limit - self.cursor try: if not self.out_grouping_b(RomanianStemmer.g_v, 97, 259): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_3 # literal, line 200 if not self.eq_s_b(1, u"u"): self.limit_backward = v_2 return False except lab0: pass # delete, line 200 if not self.slice_del(): return False elif among_var == 2: # (, line 214 # delete, line 214 if not self.slice_del(): return False self.limit_backward = v_2 return True def r_vowel_suffix(self): # (, line 218 # [, line 219 self.ket = self.cursor # substring, line 219 among_var = self.find_among_b(RomanianStemmer.a_5, 5) if among_var == 0: return False # ], line 219 self.bra = self.cursor # call RV, line 219 if not self.r_RV(): return False if among_var == 0: return False elif among_var == 1: # (, line 220 # delete, line 220 if not self.slice_del(): return False return True def _stem(self): # (, line 225 # do, line 226 v_1 = self.cursor try: # call prelude, line 226 if not self.r_prelude(): raise lab0() except lab0: pass self.cursor = v_1 # do, line 227 v_2 = self.cursor try: # call mark_regions, line 227 if not self.r_mark_regions(): raise lab1() except lab1: pass self.cursor = v_2 # backwards, line 228 self.limit_backward = self.cursor self.cursor = self.limit # (, line 228 # do, line 229 v_3 = self.limit - self.cursor try: # call step_0, line 229 if not self.r_step_0(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 # do, line 230 v_4 = self.limit - self.cursor try: # call standard_suffix, line 230 if not self.r_standard_suffix(): raise lab3() except lab3: pass self.cursor = self.limit - v_4 # do, line 231 v_5 = self.limit - self.cursor try: # (, line 231 # or, line 231 try: v_6 = self.limit - self.cursor try: # Boolean test standard_suffix_removed, line 231 if not self.B_standard_suffix_removed: raise lab6() raise lab5() except lab6: pass self.cursor = self.limit - v_6 # call verb_suffix, line 231 if not self.r_verb_suffix(): raise lab4() except lab5: pass except lab4: pass self.cursor = self.limit - v_5 # do, line 232 v_7 = self.limit - self.cursor try: # call vowel_suffix, line 232 if not self.r_vowel_suffix(): raise lab7() except lab7: pass self.cursor = self.limit - v_7 self.cursor = self.limit_backward # do, line 234 v_8 = self.cursor try: # call postlude, line 234 if not self.r_postlude(): raise lab8() except lab8: pass self.cursor = v_8 return True def equals(self, o): return isinstance(o, RomanianStemmer) def hashCode(self): return hash("RomanianStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass class lab11(BaseException): pass class lab12(BaseException): pass class lab13(BaseException): pass class lab14(BaseException): pass class lab15(BaseException): pass class lab16(BaseException): pass class lab17(BaseException): pass class lab18(BaseException): pass class lab19(BaseException): pass class lab20(BaseException): pass class lab21(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/russian_stemmer.py0000644€-©8€ZĂ);0000004717212637132734031053 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class RussianStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"\u0432", -1, 1), Among(u"\u0438\u0432", 0, 2), Among(u"\u044B\u0432", 0, 2), Among(u"\u0432\u0448\u0438", -1, 1), Among(u"\u0438\u0432\u0448\u0438", 3, 2), Among(u"\u044B\u0432\u0448\u0438", 3, 2), Among(u"\u0432\u0448\u0438\u0441\u044C", -1, 1), Among(u"\u0438\u0432\u0448\u0438\u0441\u044C", 6, 2), Among(u"\u044B\u0432\u0448\u0438\u0441\u044C", 6, 2) ] a_1 = [ Among(u"\u0435\u0435", -1, 1), Among(u"\u0438\u0435", -1, 1), Among(u"\u043E\u0435", -1, 1), Among(u"\u044B\u0435", -1, 1), Among(u"\u0438\u043C\u0438", -1, 1), Among(u"\u044B\u043C\u0438", -1, 1), Among(u"\u0435\u0439", -1, 1), Among(u"\u0438\u0439", -1, 1), Among(u"\u043E\u0439", -1, 1), Among(u"\u044B\u0439", -1, 1), Among(u"\u0435\u043C", -1, 1), Among(u"\u0438\u043C", -1, 1), Among(u"\u043E\u043C", -1, 1), Among(u"\u044B\u043C", -1, 1), Among(u"\u0435\u0433\u043E", -1, 1), Among(u"\u043E\u0433\u043E", -1, 1), Among(u"\u0435\u043C\u0443", -1, 1), Among(u"\u043E\u043C\u0443", -1, 1), Among(u"\u0438\u0445", -1, 1), Among(u"\u044B\u0445", -1, 1), Among(u"\u0435\u044E", -1, 1), Among(u"\u043E\u044E", -1, 1), Among(u"\u0443\u044E", -1, 1), Among(u"\u044E\u044E", -1, 1), Among(u"\u0430\u044F", -1, 1), Among(u"\u044F\u044F", -1, 1) ] a_2 = [ Among(u"\u0435\u043C", -1, 1), Among(u"\u043D\u043D", -1, 1), Among(u"\u0432\u0448", -1, 1), Among(u"\u0438\u0432\u0448", 2, 2), Among(u"\u044B\u0432\u0448", 2, 2), Among(u"\u0449", -1, 1), Among(u"\u044E\u0449", 5, 1), Among(u"\u0443\u044E\u0449", 6, 2) ] a_3 = [ Among(u"\u0441\u044C", -1, 1), Among(u"\u0441\u044F", -1, 1) ] a_4 = [ Among(u"\u043B\u0430", -1, 1), Among(u"\u0438\u043B\u0430", 0, 2), Among(u"\u044B\u043B\u0430", 0, 2), Among(u"\u043D\u0430", -1, 1), Among(u"\u0435\u043D\u0430", 3, 2), Among(u"\u0435\u0442\u0435", -1, 1), Among(u"\u0438\u0442\u0435", -1, 2), Among(u"\u0439\u0442\u0435", -1, 1), Among(u"\u0435\u0439\u0442\u0435", 7, 2), Among(u"\u0443\u0439\u0442\u0435", 7, 2), Among(u"\u043B\u0438", -1, 1), Among(u"\u0438\u043B\u0438", 10, 2), Among(u"\u044B\u043B\u0438", 10, 2), Among(u"\u0439", -1, 1), Among(u"\u0435\u0439", 13, 2), Among(u"\u0443\u0439", 13, 2), Among(u"\u043B", -1, 1), Among(u"\u0438\u043B", 16, 2), Among(u"\u044B\u043B", 16, 2), Among(u"\u0435\u043C", -1, 1), Among(u"\u0438\u043C", -1, 2), Among(u"\u044B\u043C", -1, 2), Among(u"\u043D", -1, 1), Among(u"\u0435\u043D", 22, 2), Among(u"\u043B\u043E", -1, 1), Among(u"\u0438\u043B\u043E", 24, 2), Among(u"\u044B\u043B\u043E", 24, 2), Among(u"\u043D\u043E", -1, 1), Among(u"\u0435\u043D\u043E", 27, 2), Among(u"\u043D\u043D\u043E", 27, 1), Among(u"\u0435\u0442", -1, 1), Among(u"\u0443\u0435\u0442", 30, 2), Among(u"\u0438\u0442", -1, 2), Among(u"\u044B\u0442", -1, 2), Among(u"\u044E\u0442", -1, 1), Among(u"\u0443\u044E\u0442", 34, 2), Among(u"\u044F\u0442", -1, 2), Among(u"\u043D\u044B", -1, 1), Among(u"\u0435\u043D\u044B", 37, 2), Among(u"\u0442\u044C", -1, 1), Among(u"\u0438\u0442\u044C", 39, 2), Among(u"\u044B\u0442\u044C", 39, 2), Among(u"\u0435\u0448\u044C", -1, 1), Among(u"\u0438\u0448\u044C", -1, 2), Among(u"\u044E", -1, 2), Among(u"\u0443\u044E", 44, 2) ] a_5 = [ Among(u"\u0430", -1, 1), Among(u"\u0435\u0432", -1, 1), Among(u"\u043E\u0432", -1, 1), Among(u"\u0435", -1, 1), Among(u"\u0438\u0435", 3, 1), Among(u"\u044C\u0435", 3, 1), Among(u"\u0438", -1, 1), Among(u"\u0435\u0438", 6, 1), Among(u"\u0438\u0438", 6, 1), Among(u"\u0430\u043C\u0438", 6, 1), Among(u"\u044F\u043C\u0438", 6, 1), Among(u"\u0438\u044F\u043C\u0438", 10, 1), Among(u"\u0439", -1, 1), Among(u"\u0435\u0439", 12, 1), Among(u"\u0438\u0435\u0439", 13, 1), Among(u"\u0438\u0439", 12, 1), Among(u"\u043E\u0439", 12, 1), Among(u"\u0430\u043C", -1, 1), Among(u"\u0435\u043C", -1, 1), Among(u"\u0438\u0435\u043C", 18, 1), Among(u"\u043E\u043C", -1, 1), Among(u"\u044F\u043C", -1, 1), Among(u"\u0438\u044F\u043C", 21, 1), Among(u"\u043E", -1, 1), Among(u"\u0443", -1, 1), Among(u"\u0430\u0445", -1, 1), Among(u"\u044F\u0445", -1, 1), Among(u"\u0438\u044F\u0445", 26, 1), Among(u"\u044B", -1, 1), Among(u"\u044C", -1, 1), Among(u"\u044E", -1, 1), Among(u"\u0438\u044E", 30, 1), Among(u"\u044C\u044E", 30, 1), Among(u"\u044F", -1, 1), Among(u"\u0438\u044F", 33, 1), Among(u"\u044C\u044F", 33, 1) ] a_6 = [ Among(u"\u043E\u0441\u0442", -1, 1), Among(u"\u043E\u0441\u0442\u044C", -1, 1) ] a_7 = [ Among(u"\u0435\u0439\u0448\u0435", -1, 1), Among(u"\u043D", -1, 2), Among(u"\u0435\u0439\u0448", -1, 1), Among(u"\u044C", -1, 3) ] g_v = [33, 65, 8, 232] I_p2 = 0 I_pV = 0 def copy_from(self, other): self.I_p2 = other.I_p2 self.I_pV = other.I_pV super.copy_from(other) def r_mark_regions(self): # (, line 57 self.I_pV = self.limit; self.I_p2 = self.limit; # do, line 61 v_1 = self.cursor try: # (, line 61 # gopast, line 62 try: while True: try: if not self.in_grouping(RussianStemmer.g_v, 1072, 1103): raise lab2() raise lab1() except lab2: pass if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab1: pass # setmark pV, line 62 self.I_pV = self.cursor # gopast, line 62 try: while True: try: if not self.out_grouping(RussianStemmer.g_v, 1072, 1103): raise lab4() raise lab3() except lab4: pass if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab3: pass # gopast, line 63 try: while True: try: if not self.in_grouping(RussianStemmer.g_v, 1072, 1103): raise lab6() raise lab5() except lab6: pass if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab5: pass # gopast, line 63 try: while True: try: if not self.out_grouping(RussianStemmer.g_v, 1072, 1103): raise lab8() raise lab7() except lab8: pass if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab7: pass # setmark p2, line 63 self.I_p2 = self.cursor except lab0: pass self.cursor = v_1 return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_perfective_gerund(self): # (, line 71 # [, line 72 self.ket = self.cursor # substring, line 72 among_var = self.find_among_b(RussianStemmer.a_0, 9) if among_var == 0: return False # ], line 72 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 76 # or, line 76 try: v_1 = self.limit - self.cursor try: # literal, line 76 if not self.eq_s_b(1, u"\u0430"): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_1 # literal, line 76 if not self.eq_s_b(1, u"\u044F"): return False except lab0: pass # delete, line 76 if not self.slice_del(): return False elif among_var == 2: # (, line 83 # delete, line 83 if not self.slice_del(): return False return True def r_adjective(self): # (, line 87 # [, line 88 self.ket = self.cursor # substring, line 88 among_var = self.find_among_b(RussianStemmer.a_1, 26) if among_var == 0: return False # ], line 88 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 97 # delete, line 97 if not self.slice_del(): return False return True def r_adjectival(self): # (, line 101 # call adjective, line 102 if not self.r_adjective(): return False # try, line 109 v_1 = self.limit - self.cursor try: # (, line 109 # [, line 110 self.ket = self.cursor # substring, line 110 among_var = self.find_among_b(RussianStemmer.a_2, 8) if among_var == 0: self.cursor = self.limit - v_1 raise lab0() # ], line 110 self.bra = self.cursor if among_var == 0: self.cursor = self.limit - v_1 raise lab0() elif among_var == 1: # (, line 115 # or, line 115 try: v_2 = self.limit - self.cursor try: # literal, line 115 if not self.eq_s_b(1, u"\u0430"): raise lab2() raise lab1() except lab2: pass self.cursor = self.limit - v_2 # literal, line 115 if not self.eq_s_b(1, u"\u044F"): self.cursor = self.limit - v_1 raise lab0() except lab1: pass # delete, line 115 if not self.slice_del(): return False elif among_var == 2: # (, line 122 # delete, line 122 if not self.slice_del(): return False except lab0: pass return True def r_reflexive(self): # (, line 128 # [, line 129 self.ket = self.cursor # substring, line 129 among_var = self.find_among_b(RussianStemmer.a_3, 2) if among_var == 0: return False # ], line 129 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 132 # delete, line 132 if not self.slice_del(): return False return True def r_verb(self): # (, line 136 # [, line 137 self.ket = self.cursor # substring, line 137 among_var = self.find_among_b(RussianStemmer.a_4, 46) if among_var == 0: return False # ], line 137 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 143 # or, line 143 try: v_1 = self.limit - self.cursor try: # literal, line 143 if not self.eq_s_b(1, u"\u0430"): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_1 # literal, line 143 if not self.eq_s_b(1, u"\u044F"): return False except lab0: pass # delete, line 143 if not self.slice_del(): return False elif among_var == 2: # (, line 151 # delete, line 151 if not self.slice_del(): return False return True def r_noun(self): # (, line 159 # [, line 160 self.ket = self.cursor # substring, line 160 among_var = self.find_among_b(RussianStemmer.a_5, 36) if among_var == 0: return False # ], line 160 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 167 # delete, line 167 if not self.slice_del(): return False return True def r_derivational(self): # (, line 175 # [, line 176 self.ket = self.cursor # substring, line 176 among_var = self.find_among_b(RussianStemmer.a_6, 2) if among_var == 0: return False # ], line 176 self.bra = self.cursor # call R2, line 176 if not self.r_R2(): return False if among_var == 0: return False elif among_var == 1: # (, line 179 # delete, line 179 if not self.slice_del(): return False return True def r_tidy_up(self): # (, line 183 # [, line 184 self.ket = self.cursor # substring, line 184 among_var = self.find_among_b(RussianStemmer.a_7, 4) if among_var == 0: return False # ], line 184 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 188 # delete, line 188 if not self.slice_del(): return False # [, line 189 self.ket = self.cursor # literal, line 189 if not self.eq_s_b(1, u"\u043D"): return False # ], line 189 self.bra = self.cursor # literal, line 189 if not self.eq_s_b(1, u"\u043D"): return False # delete, line 189 if not self.slice_del(): return False elif among_var == 2: # (, line 192 # literal, line 192 if not self.eq_s_b(1, u"\u043D"): return False # delete, line 192 if not self.slice_del(): return False elif among_var == 3: # (, line 194 # delete, line 194 if not self.slice_del(): return False return True def _stem(self): # (, line 199 # do, line 201 v_1 = self.cursor try: # call mark_regions, line 201 if not self.r_mark_regions(): raise lab0() except lab0: pass self.cursor = v_1 # backwards, line 202 self.limit_backward = self.cursor self.cursor = self.limit # setlimit, line 202 v_2 = self.limit - self.cursor # tomark, line 202 if self.cursor < self.I_pV: return False self.cursor = self.I_pV v_3 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_2 # (, line 202 # do, line 203 v_4 = self.limit - self.cursor try: # (, line 203 # or, line 204 try: v_5 = self.limit - self.cursor try: # call perfective_gerund, line 204 if not self.r_perfective_gerund(): raise lab3() raise lab2() except lab3: pass self.cursor = self.limit - v_5 # (, line 205 # try, line 205 v_6 = self.limit - self.cursor try: # call reflexive, line 205 if not self.r_reflexive(): self.cursor = self.limit - v_6 raise lab4() except lab4: pass # or, line 206 try: v_7 = self.limit - self.cursor try: # call adjectival, line 206 if not self.r_adjectival(): raise lab6() raise lab5() except lab6: pass self.cursor = self.limit - v_7 try: # call verb, line 206 if not self.r_verb(): raise lab7() raise lab5() except lab7: pass self.cursor = self.limit - v_7 # call noun, line 206 if not self.r_noun(): raise lab1() except lab5: pass except lab2: pass except lab1: pass self.cursor = self.limit - v_4 # try, line 209 v_8 = self.limit - self.cursor try: # (, line 209 # [, line 209 self.ket = self.cursor # literal, line 209 if not self.eq_s_b(1, u"\u0438"): self.cursor = self.limit - v_8 raise lab8() # ], line 209 self.bra = self.cursor # delete, line 209 if not self.slice_del(): return False except lab8: pass # do, line 212 v_9 = self.limit - self.cursor try: # call derivational, line 212 if not self.r_derivational(): raise lab9() except lab9: pass self.cursor = self.limit - v_9 # do, line 213 v_10 = self.limit - self.cursor try: # call tidy_up, line 213 if not self.r_tidy_up(): raise lab10() except lab10: pass self.cursor = self.limit - v_10 self.limit_backward = v_3 self.cursor = self.limit_backward return True def equals(self, o): return isinstance(o, RussianStemmer) def hashCode(self): return hash("RussianStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/spanish_stemmer.py0000644€-©8€ZĂ);0000010132212637132734031020 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class SpanishStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"", -1, 6), Among(u"\u00E1", 0, 1), Among(u"\u00E9", 0, 2), Among(u"\u00ED", 0, 3), Among(u"\u00F3", 0, 4), Among(u"\u00FA", 0, 5) ] a_1 = [ Among(u"la", -1, -1), Among(u"sela", 0, -1), Among(u"le", -1, -1), Among(u"me", -1, -1), Among(u"se", -1, -1), Among(u"lo", -1, -1), Among(u"selo", 5, -1), Among(u"las", -1, -1), Among(u"selas", 7, -1), Among(u"les", -1, -1), Among(u"los", -1, -1), Among(u"selos", 10, -1), Among(u"nos", -1, -1) ] a_2 = [ Among(u"ando", -1, 6), Among(u"iendo", -1, 6), Among(u"yendo", -1, 7), Among(u"\u00E1ndo", -1, 2), Among(u"i\u00E9ndo", -1, 1), Among(u"ar", -1, 6), Among(u"er", -1, 6), Among(u"ir", -1, 6), Among(u"\u00E1r", -1, 3), Among(u"\u00E9r", -1, 4), Among(u"\u00EDr", -1, 5) ] a_3 = [ Among(u"ic", -1, -1), Among(u"ad", -1, -1), Among(u"os", -1, -1), Among(u"iv", -1, 1) ] a_4 = [ Among(u"able", -1, 1), Among(u"ible", -1, 1), Among(u"ante", -1, 1) ] a_5 = [ Among(u"ic", -1, 1), Among(u"abil", -1, 1), Among(u"iv", -1, 1) ] a_6 = [ Among(u"ica", -1, 1), Among(u"ancia", -1, 2), Among(u"encia", -1, 5), Among(u"adora", -1, 2), Among(u"osa", -1, 1), Among(u"ista", -1, 1), Among(u"iva", -1, 9), Among(u"anza", -1, 1), Among(u"log\u00EDa", -1, 3), Among(u"idad", -1, 8), Among(u"able", -1, 1), Among(u"ible", -1, 1), Among(u"ante", -1, 2), Among(u"mente", -1, 7), Among(u"amente", 13, 6), Among(u"aci\u00F3n", -1, 2), Among(u"uci\u00F3n", -1, 4), Among(u"ico", -1, 1), Among(u"ismo", -1, 1), Among(u"oso", -1, 1), Among(u"amiento", -1, 1), Among(u"imiento", -1, 1), Among(u"ivo", -1, 9), Among(u"ador", -1, 2), Among(u"icas", -1, 1), Among(u"ancias", -1, 2), Among(u"encias", -1, 5), Among(u"adoras", -1, 2), Among(u"osas", -1, 1), Among(u"istas", -1, 1), Among(u"ivas", -1, 9), Among(u"anzas", -1, 1), Among(u"log\u00EDas", -1, 3), Among(u"idades", -1, 8), Among(u"ables", -1, 1), Among(u"ibles", -1, 1), Among(u"aciones", -1, 2), Among(u"uciones", -1, 4), Among(u"adores", -1, 2), Among(u"antes", -1, 2), Among(u"icos", -1, 1), Among(u"ismos", -1, 1), Among(u"osos", -1, 1), Among(u"amientos", -1, 1), Among(u"imientos", -1, 1), Among(u"ivos", -1, 9) ] a_7 = [ Among(u"ya", -1, 1), Among(u"ye", -1, 1), Among(u"yan", -1, 1), Among(u"yen", -1, 1), Among(u"yeron", -1, 1), Among(u"yendo", -1, 1), Among(u"yo", -1, 1), Among(u"yas", -1, 1), Among(u"yes", -1, 1), Among(u"yais", -1, 1), Among(u"yamos", -1, 1), Among(u"y\u00F3", -1, 1) ] a_8 = [ Among(u"aba", -1, 2), Among(u"ada", -1, 2), Among(u"ida", -1, 2), Among(u"ara", -1, 2), Among(u"iera", -1, 2), Among(u"\u00EDa", -1, 2), Among(u"ar\u00EDa", 5, 2), Among(u"er\u00EDa", 5, 2), Among(u"ir\u00EDa", 5, 2), Among(u"ad", -1, 2), Among(u"ed", -1, 2), Among(u"id", -1, 2), Among(u"ase", -1, 2), Among(u"iese", -1, 2), Among(u"aste", -1, 2), Among(u"iste", -1, 2), Among(u"an", -1, 2), Among(u"aban", 16, 2), Among(u"aran", 16, 2), Among(u"ieran", 16, 2), Among(u"\u00EDan", 16, 2), Among(u"ar\u00EDan", 20, 2), Among(u"er\u00EDan", 20, 2), Among(u"ir\u00EDan", 20, 2), Among(u"en", -1, 1), Among(u"asen", 24, 2), Among(u"iesen", 24, 2), Among(u"aron", -1, 2), Among(u"ieron", -1, 2), Among(u"ar\u00E1n", -1, 2), Among(u"er\u00E1n", -1, 2), Among(u"ir\u00E1n", -1, 2), Among(u"ado", -1, 2), Among(u"ido", -1, 2), Among(u"ando", -1, 2), Among(u"iendo", -1, 2), Among(u"ar", -1, 2), Among(u"er", -1, 2), Among(u"ir", -1, 2), Among(u"as", -1, 2), Among(u"abas", 39, 2), Among(u"adas", 39, 2), Among(u"idas", 39, 2), Among(u"aras", 39, 2), Among(u"ieras", 39, 2), Among(u"\u00EDas", 39, 2), Among(u"ar\u00EDas", 45, 2), Among(u"er\u00EDas", 45, 2), Among(u"ir\u00EDas", 45, 2), Among(u"es", -1, 1), Among(u"ases", 49, 2), Among(u"ieses", 49, 2), Among(u"abais", -1, 2), Among(u"arais", -1, 2), Among(u"ierais", -1, 2), Among(u"\u00EDais", -1, 2), Among(u"ar\u00EDais", 55, 2), Among(u"er\u00EDais", 55, 2), Among(u"ir\u00EDais", 55, 2), Among(u"aseis", -1, 2), Among(u"ieseis", -1, 2), Among(u"asteis", -1, 2), Among(u"isteis", -1, 2), Among(u"\u00E1is", -1, 2), Among(u"\u00E9is", -1, 1), Among(u"ar\u00E9is", 64, 2), Among(u"er\u00E9is", 64, 2), Among(u"ir\u00E9is", 64, 2), Among(u"ados", -1, 2), Among(u"idos", -1, 2), Among(u"amos", -1, 2), Among(u"\u00E1bamos", 70, 2), Among(u"\u00E1ramos", 70, 2), Among(u"i\u00E9ramos", 70, 2), Among(u"\u00EDamos", 70, 2), Among(u"ar\u00EDamos", 74, 2), Among(u"er\u00EDamos", 74, 2), Among(u"ir\u00EDamos", 74, 2), Among(u"emos", -1, 1), Among(u"aremos", 78, 2), Among(u"eremos", 78, 2), Among(u"iremos", 78, 2), Among(u"\u00E1semos", 78, 2), Among(u"i\u00E9semos", 78, 2), Among(u"imos", -1, 2), Among(u"ar\u00E1s", -1, 2), Among(u"er\u00E1s", -1, 2), Among(u"ir\u00E1s", -1, 2), Among(u"\u00EDs", -1, 2), Among(u"ar\u00E1", -1, 2), Among(u"er\u00E1", -1, 2), Among(u"ir\u00E1", -1, 2), Among(u"ar\u00E9", -1, 2), Among(u"er\u00E9", -1, 2), Among(u"ir\u00E9", -1, 2), Among(u"i\u00F3", -1, 2) ] a_9 = [ Among(u"a", -1, 1), Among(u"e", -1, 2), Among(u"o", -1, 1), Among(u"os", -1, 1), Among(u"\u00E1", -1, 1), Among(u"\u00E9", -1, 2), Among(u"\u00ED", -1, 1), Among(u"\u00F3", -1, 1) ] g_v = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 4, 10] I_p2 = 0 I_p1 = 0 I_pV = 0 def copy_from(self, other): self.I_p2 = other.I_p2 self.I_p1 = other.I_p1 self.I_pV = other.I_pV super.copy_from(other) def r_mark_regions(self): # (, line 31 self.I_pV = self.limit; self.I_p1 = self.limit; self.I_p2 = self.limit; # do, line 37 v_1 = self.cursor try: # (, line 37 # or, line 39 try: v_2 = self.cursor try: # (, line 38 if not self.in_grouping(SpanishStemmer.g_v, 97, 252): raise lab2() # or, line 38 try: v_3 = self.cursor try: # (, line 38 if not self.out_grouping(SpanishStemmer.g_v, 97, 252): raise lab4() # gopast, line 38 try: while True: try: if not self.in_grouping(SpanishStemmer.g_v, 97, 252): raise lab6() raise lab5() except lab6: pass if self.cursor >= self.limit: raise lab4() self.cursor += 1 except lab5: pass raise lab3() except lab4: pass self.cursor = v_3 # (, line 38 if not self.in_grouping(SpanishStemmer.g_v, 97, 252): raise lab2() # gopast, line 38 try: while True: try: if not self.out_grouping(SpanishStemmer.g_v, 97, 252): raise lab8() raise lab7() except lab8: pass if self.cursor >= self.limit: raise lab2() self.cursor += 1 except lab7: pass except lab3: pass raise lab1() except lab2: pass self.cursor = v_2 # (, line 40 if not self.out_grouping(SpanishStemmer.g_v, 97, 252): raise lab0() # or, line 40 try: v_6 = self.cursor try: # (, line 40 if not self.out_grouping(SpanishStemmer.g_v, 97, 252): raise lab10() # gopast, line 40 try: while True: try: if not self.in_grouping(SpanishStemmer.g_v, 97, 252): raise lab12() raise lab11() except lab12: pass if self.cursor >= self.limit: raise lab10() self.cursor += 1 except lab11: pass raise lab9() except lab10: pass self.cursor = v_6 # (, line 40 if not self.in_grouping(SpanishStemmer.g_v, 97, 252): raise lab0() # next, line 40 if self.cursor >= self.limit: raise lab0() self.cursor += 1 except lab9: pass except lab1: pass # setmark pV, line 41 self.I_pV = self.cursor except lab0: pass self.cursor = v_1 # do, line 43 v_8 = self.cursor try: # (, line 43 # gopast, line 44 try: while True: try: if not self.in_grouping(SpanishStemmer.g_v, 97, 252): raise lab15() raise lab14() except lab15: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab14: pass # gopast, line 44 try: while True: try: if not self.out_grouping(SpanishStemmer.g_v, 97, 252): raise lab17() raise lab16() except lab17: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab16: pass # setmark p1, line 44 self.I_p1 = self.cursor # gopast, line 45 try: while True: try: if not self.in_grouping(SpanishStemmer.g_v, 97, 252): raise lab19() raise lab18() except lab19: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab18: pass # gopast, line 45 try: while True: try: if not self.out_grouping(SpanishStemmer.g_v, 97, 252): raise lab21() raise lab20() except lab21: pass if self.cursor >= self.limit: raise lab13() self.cursor += 1 except lab20: pass # setmark p2, line 45 self.I_p2 = self.cursor except lab13: pass self.cursor = v_8 return True def r_postlude(self): # repeat, line 49 try: while True: try: v_1 = self.cursor try: # (, line 49 # [, line 50 self.bra = self.cursor # substring, line 50 among_var = self.find_among(SpanishStemmer.a_0, 6) if among_var == 0: raise lab2() # ], line 50 self.ket = self.cursor if among_var == 0: raise lab2() elif among_var == 1: # (, line 51 # <-, line 51 if not self.slice_from(u"a"): return False elif among_var == 2: # (, line 52 # <-, line 52 if not self.slice_from(u"e"): return False elif among_var == 3: # (, line 53 # <-, line 53 if not self.slice_from(u"i"): return False elif among_var == 4: # (, line 54 # <-, line 54 if not self.slice_from(u"o"): return False elif among_var == 5: # (, line 55 # <-, line 55 if not self.slice_from(u"u"): return False elif among_var == 6: # (, line 57 # next, line 57 if self.cursor >= self.limit: raise lab2() self.cursor += 1 raise lab1() except lab2: pass self.cursor = v_1 raise lab0() except lab1: pass except lab0: pass return True def r_RV(self): if not self.I_pV <= self.cursor: return False return True def r_R1(self): if not self.I_p1 <= self.cursor: return False return True def r_R2(self): if not self.I_p2 <= self.cursor: return False return True def r_attached_pronoun(self): # (, line 67 # [, line 68 self.ket = self.cursor # substring, line 68 if self.find_among_b(SpanishStemmer.a_1, 13) == 0: return False # ], line 68 self.bra = self.cursor # substring, line 72 among_var = self.find_among_b(SpanishStemmer.a_2, 11) if among_var == 0: return False # call RV, line 72 if not self.r_RV(): return False if among_var == 0: return False elif among_var == 1: # (, line 73 # ], line 73 self.bra = self.cursor # <-, line 73 if not self.slice_from(u"iendo"): return False elif among_var == 2: # (, line 74 # ], line 74 self.bra = self.cursor # <-, line 74 if not self.slice_from(u"ando"): return False elif among_var == 3: # (, line 75 # ], line 75 self.bra = self.cursor # <-, line 75 if not self.slice_from(u"ar"): return False elif among_var == 4: # (, line 76 # ], line 76 self.bra = self.cursor # <-, line 76 if not self.slice_from(u"er"): return False elif among_var == 5: # (, line 77 # ], line 77 self.bra = self.cursor # <-, line 77 if not self.slice_from(u"ir"): return False elif among_var == 6: # (, line 81 # delete, line 81 if not self.slice_del(): return False elif among_var == 7: # (, line 82 # literal, line 82 if not self.eq_s_b(1, u"u"): return False # delete, line 82 if not self.slice_del(): return False return True def r_standard_suffix(self): # (, line 86 # [, line 87 self.ket = self.cursor # substring, line 87 among_var = self.find_among_b(SpanishStemmer.a_6, 46) if among_var == 0: return False # ], line 87 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 98 # call R2, line 99 if not self.r_R2(): return False # delete, line 99 if not self.slice_del(): return False elif among_var == 2: # (, line 104 # call R2, line 105 if not self.r_R2(): return False # delete, line 105 if not self.slice_del(): return False # try, line 106 v_1 = self.limit - self.cursor try: # (, line 106 # [, line 106 self.ket = self.cursor # literal, line 106 if not self.eq_s_b(2, u"ic"): self.cursor = self.limit - v_1 raise lab0() # ], line 106 self.bra = self.cursor # call R2, line 106 if not self.r_R2(): self.cursor = self.limit - v_1 raise lab0() # delete, line 106 if not self.slice_del(): return False except lab0: pass elif among_var == 3: # (, line 110 # call R2, line 111 if not self.r_R2(): return False # <-, line 111 if not self.slice_from(u"log"): return False elif among_var == 4: # (, line 114 # call R2, line 115 if not self.r_R2(): return False # <-, line 115 if not self.slice_from(u"u"): return False elif among_var == 5: # (, line 118 # call R2, line 119 if not self.r_R2(): return False # <-, line 119 if not self.slice_from(u"ente"): return False elif among_var == 6: # (, line 122 # call R1, line 123 if not self.r_R1(): return False # delete, line 123 if not self.slice_del(): return False # try, line 124 v_2 = self.limit - self.cursor try: # (, line 124 # [, line 125 self.ket = self.cursor # substring, line 125 among_var = self.find_among_b(SpanishStemmer.a_3, 4) if among_var == 0: self.cursor = self.limit - v_2 raise lab1() # ], line 125 self.bra = self.cursor # call R2, line 125 if not self.r_R2(): self.cursor = self.limit - v_2 raise lab1() # delete, line 125 if not self.slice_del(): return False if among_var == 0: self.cursor = self.limit - v_2 raise lab1() elif among_var == 1: # (, line 126 # [, line 126 self.ket = self.cursor # literal, line 126 if not self.eq_s_b(2, u"at"): self.cursor = self.limit - v_2 raise lab1() # ], line 126 self.bra = self.cursor # call R2, line 126 if not self.r_R2(): self.cursor = self.limit - v_2 raise lab1() # delete, line 126 if not self.slice_del(): return False except lab1: pass elif among_var == 7: # (, line 134 # call R2, line 135 if not self.r_R2(): return False # delete, line 135 if not self.slice_del(): return False # try, line 136 v_3 = self.limit - self.cursor try: # (, line 136 # [, line 137 self.ket = self.cursor # substring, line 137 among_var = self.find_among_b(SpanishStemmer.a_4, 3) if among_var == 0: self.cursor = self.limit - v_3 raise lab2() # ], line 137 self.bra = self.cursor if among_var == 0: self.cursor = self.limit - v_3 raise lab2() elif among_var == 1: # (, line 140 # call R2, line 140 if not self.r_R2(): self.cursor = self.limit - v_3 raise lab2() # delete, line 140 if not self.slice_del(): return False except lab2: pass elif among_var == 8: # (, line 146 # call R2, line 147 if not self.r_R2(): return False # delete, line 147 if not self.slice_del(): return False # try, line 148 v_4 = self.limit - self.cursor try: # (, line 148 # [, line 149 self.ket = self.cursor # substring, line 149 among_var = self.find_among_b(SpanishStemmer.a_5, 3) if among_var == 0: self.cursor = self.limit - v_4 raise lab3() # ], line 149 self.bra = self.cursor if among_var == 0: self.cursor = self.limit - v_4 raise lab3() elif among_var == 1: # (, line 152 # call R2, line 152 if not self.r_R2(): self.cursor = self.limit - v_4 raise lab3() # delete, line 152 if not self.slice_del(): return False except lab3: pass elif among_var == 9: # (, line 158 # call R2, line 159 if not self.r_R2(): return False # delete, line 159 if not self.slice_del(): return False # try, line 160 v_5 = self.limit - self.cursor try: # (, line 160 # [, line 161 self.ket = self.cursor # literal, line 161 if not self.eq_s_b(2, u"at"): self.cursor = self.limit - v_5 raise lab4() # ], line 161 self.bra = self.cursor # call R2, line 161 if not self.r_R2(): self.cursor = self.limit - v_5 raise lab4() # delete, line 161 if not self.slice_del(): return False except lab4: pass return True def r_y_verb_suffix(self): # (, line 167 # setlimit, line 168 v_1 = self.limit - self.cursor # tomark, line 168 if self.cursor < self.I_pV: return False self.cursor = self.I_pV v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 168 # [, line 168 self.ket = self.cursor # substring, line 168 among_var = self.find_among_b(SpanishStemmer.a_7, 12) if among_var == 0: self.limit_backward = v_2 return False # ], line 168 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 171 # literal, line 171 if not self.eq_s_b(1, u"u"): return False # delete, line 171 if not self.slice_del(): return False return True def r_verb_suffix(self): # (, line 175 # setlimit, line 176 v_1 = self.limit - self.cursor # tomark, line 176 if self.cursor < self.I_pV: return False self.cursor = self.I_pV v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 176 # [, line 176 self.ket = self.cursor # substring, line 176 among_var = self.find_among_b(SpanishStemmer.a_8, 96) if among_var == 0: self.limit_backward = v_2 return False # ], line 176 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 179 # try, line 179 v_3 = self.limit - self.cursor try: # (, line 179 # literal, line 179 if not self.eq_s_b(1, u"u"): self.cursor = self.limit - v_3 raise lab0() # test, line 179 v_4 = self.limit - self.cursor # literal, line 179 if not self.eq_s_b(1, u"g"): self.cursor = self.limit - v_3 raise lab0() self.cursor = self.limit - v_4 except lab0: pass # ], line 179 self.bra = self.cursor # delete, line 179 if not self.slice_del(): return False elif among_var == 2: # (, line 200 # delete, line 200 if not self.slice_del(): return False return True def r_residual_suffix(self): # (, line 204 # [, line 205 self.ket = self.cursor # substring, line 205 among_var = self.find_among_b(SpanishStemmer.a_9, 8) if among_var == 0: return False # ], line 205 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 208 # call RV, line 208 if not self.r_RV(): return False # delete, line 208 if not self.slice_del(): return False elif among_var == 2: # (, line 210 # call RV, line 210 if not self.r_RV(): return False # delete, line 210 if not self.slice_del(): return False # try, line 210 v_1 = self.limit - self.cursor try: # (, line 210 # [, line 210 self.ket = self.cursor # literal, line 210 if not self.eq_s_b(1, u"u"): self.cursor = self.limit - v_1 raise lab0() # ], line 210 self.bra = self.cursor # test, line 210 v_2 = self.limit - self.cursor # literal, line 210 if not self.eq_s_b(1, u"g"): self.cursor = self.limit - v_1 raise lab0() self.cursor = self.limit - v_2 # call RV, line 210 if not self.r_RV(): self.cursor = self.limit - v_1 raise lab0() # delete, line 210 if not self.slice_del(): return False except lab0: pass return True def _stem(self): # (, line 215 # do, line 216 v_1 = self.cursor try: # call mark_regions, line 216 if not self.r_mark_regions(): raise lab0() except lab0: pass self.cursor = v_1 # backwards, line 217 self.limit_backward = self.cursor self.cursor = self.limit # (, line 217 # do, line 218 v_2 = self.limit - self.cursor try: # call attached_pronoun, line 218 if not self.r_attached_pronoun(): raise lab1() except lab1: pass self.cursor = self.limit - v_2 # do, line 219 v_3 = self.limit - self.cursor try: # (, line 219 # or, line 219 try: v_4 = self.limit - self.cursor try: # call standard_suffix, line 219 if not self.r_standard_suffix(): raise lab4() raise lab3() except lab4: pass self.cursor = self.limit - v_4 try: # call y_verb_suffix, line 220 if not self.r_y_verb_suffix(): raise lab5() raise lab3() except lab5: pass self.cursor = self.limit - v_4 # call verb_suffix, line 221 if not self.r_verb_suffix(): raise lab2() except lab3: pass except lab2: pass self.cursor = self.limit - v_3 # do, line 223 v_5 = self.limit - self.cursor try: # call residual_suffix, line 223 if not self.r_residual_suffix(): raise lab6() except lab6: pass self.cursor = self.limit - v_5 self.cursor = self.limit_backward # do, line 225 v_6 = self.cursor try: # call postlude, line 225 if not self.r_postlude(): raise lab7() except lab7: pass self.cursor = v_6 return True def equals(self, o): return isinstance(o, SpanishStemmer) def hashCode(self): return hash("SpanishStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass class lab11(BaseException): pass class lab12(BaseException): pass class lab13(BaseException): pass class lab14(BaseException): pass class lab15(BaseException): pass class lab16(BaseException): pass class lab17(BaseException): pass class lab18(BaseException): pass class lab19(BaseException): pass class lab20(BaseException): pass class lab21(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/swedish_stemmer.py0000644€-©8€ZĂ);0000002074112637132734031026 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class SwedishStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"a", -1, 1), Among(u"arna", 0, 1), Among(u"erna", 0, 1), Among(u"heterna", 2, 1), Among(u"orna", 0, 1), Among(u"ad", -1, 1), Among(u"e", -1, 1), Among(u"ade", 6, 1), Among(u"ande", 6, 1), Among(u"arne", 6, 1), Among(u"are", 6, 1), Among(u"aste", 6, 1), Among(u"en", -1, 1), Among(u"anden", 12, 1), Among(u"aren", 12, 1), Among(u"heten", 12, 1), Among(u"ern", -1, 1), Among(u"ar", -1, 1), Among(u"er", -1, 1), Among(u"heter", 18, 1), Among(u"or", -1, 1), Among(u"s", -1, 2), Among(u"as", 21, 1), Among(u"arnas", 22, 1), Among(u"ernas", 22, 1), Among(u"ornas", 22, 1), Among(u"es", 21, 1), Among(u"ades", 26, 1), Among(u"andes", 26, 1), Among(u"ens", 21, 1), Among(u"arens", 29, 1), Among(u"hetens", 29, 1), Among(u"erns", 21, 1), Among(u"at", -1, 1), Among(u"andet", -1, 1), Among(u"het", -1, 1), Among(u"ast", -1, 1) ] a_1 = [ Among(u"dd", -1, -1), Among(u"gd", -1, -1), Among(u"nn", -1, -1), Among(u"dt", -1, -1), Among(u"gt", -1, -1), Among(u"kt", -1, -1), Among(u"tt", -1, -1) ] a_2 = [ Among(u"ig", -1, 1), Among(u"lig", 0, 1), Among(u"els", -1, 1), Among(u"fullt", -1, 3), Among(u"l\u00F6st", -1, 2) ] g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 32] g_s_ending = [119, 127, 149] I_x = 0 I_p1 = 0 def copy_from(self, other): self.I_x = other.I_x self.I_p1 = other.I_p1 super.copy_from(other) def r_mark_regions(self): # (, line 26 self.I_p1 = self.limit; # test, line 29 v_1 = self.cursor # (, line 29 # hop, line 29 c = self.cursor + 3 if 0 > c or c > self.limit: return False self.cursor = c # setmark x, line 29 self.I_x = self.cursor self.cursor = v_1 # goto, line 30 try: while True: v_2 = self.cursor try: if not self.in_grouping(SwedishStemmer.g_v, 97, 246): raise lab1() self.cursor = v_2 raise lab0() except lab1: pass self.cursor = v_2 if self.cursor >= self.limit: return False self.cursor += 1 except lab0: pass # gopast, line 30 try: while True: try: if not self.out_grouping(SwedishStemmer.g_v, 97, 246): raise lab3() raise lab2() except lab3: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab2: pass # setmark p1, line 30 self.I_p1 = self.cursor # try, line 31 try: # (, line 31 if not (self.I_p1 < self.I_x): raise lab4() self.I_p1 = self.I_x; except lab4: pass return True def r_main_suffix(self): # (, line 36 # setlimit, line 37 v_1 = self.limit - self.cursor # tomark, line 37 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 37 # [, line 37 self.ket = self.cursor # substring, line 37 among_var = self.find_among_b(SwedishStemmer.a_0, 37) if among_var == 0: self.limit_backward = v_2 return False # ], line 37 self.bra = self.cursor self.limit_backward = v_2 if among_var == 0: return False elif among_var == 1: # (, line 44 # delete, line 44 if not self.slice_del(): return False elif among_var == 2: # (, line 46 if not self.in_grouping_b(SwedishStemmer.g_s_ending, 98, 121): return False # delete, line 46 if not self.slice_del(): return False return True def r_consonant_pair(self): # setlimit, line 50 v_1 = self.limit - self.cursor # tomark, line 50 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 50 # and, line 52 v_3 = self.limit - self.cursor # among, line 51 if self.find_among_b(SwedishStemmer.a_1, 7) == 0: self.limit_backward = v_2 return False self.cursor = self.limit - v_3 # (, line 52 # [, line 52 self.ket = self.cursor # next, line 52 if self.cursor <= self.limit_backward: self.limit_backward = v_2 return False self.cursor -= 1 # ], line 52 self.bra = self.cursor # delete, line 52 if not self.slice_del(): return False self.limit_backward = v_2 return True def r_other_suffix(self): # setlimit, line 55 v_1 = self.limit - self.cursor # tomark, line 55 if self.cursor < self.I_p1: return False self.cursor = self.I_p1 v_2 = self.limit_backward self.limit_backward = self.cursor self.cursor = self.limit - v_1 # (, line 55 # [, line 56 self.ket = self.cursor # substring, line 56 among_var = self.find_among_b(SwedishStemmer.a_2, 5) if among_var == 0: self.limit_backward = v_2 return False # ], line 56 self.bra = self.cursor if among_var == 0: self.limit_backward = v_2 return False elif among_var == 1: # (, line 57 # delete, line 57 if not self.slice_del(): return False elif among_var == 2: # (, line 58 # <-, line 58 if not self.slice_from(u"l\u00F6s"): return False elif among_var == 3: # (, line 59 # <-, line 59 if not self.slice_from(u"full"): return False self.limit_backward = v_2 return True def _stem(self): # (, line 64 # do, line 66 v_1 = self.cursor try: # call mark_regions, line 66 if not self.r_mark_regions(): raise lab0() except lab0: pass self.cursor = v_1 # backwards, line 67 self.limit_backward = self.cursor self.cursor = self.limit # (, line 67 # do, line 68 v_2 = self.limit - self.cursor try: # call main_suffix, line 68 if not self.r_main_suffix(): raise lab1() except lab1: pass self.cursor = self.limit - v_2 # do, line 69 v_3 = self.limit - self.cursor try: # call consonant_pair, line 69 if not self.r_consonant_pair(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 # do, line 70 v_4 = self.limit - self.cursor try: # call other_suffix, line 70 if not self.r_other_suffix(): raise lab3() except lab3: pass self.cursor = self.limit - v_4 self.cursor = self.limit_backward return True def equals(self, o): return isinstance(o, SwedishStemmer) def hashCode(self): return hash("SwedishStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass snowballstemmer-1.2.1/snowballstemmer/turkish_stemmer.py0000644€-©8€ZĂ);0000027213212637132734031054 0ustar shibukawa.yoshikiDENA\Domain Users00000000000000# self file was generated automatically by the Snowball to Python interpreter from .basestemmer import BaseStemmer from .among import Among class TurkishStemmer(BaseStemmer): ''' self class was automatically generated by a Snowball to Python interpreter It implements the stemming algorithm defined by a snowball script. ''' serialVersionUID = 1 a_0 = [ Among(u"m", -1, -1), Among(u"n", -1, -1), Among(u"miz", -1, -1), Among(u"niz", -1, -1), Among(u"muz", -1, -1), Among(u"nuz", -1, -1), Among(u"m\u00FCz", -1, -1), Among(u"n\u00FCz", -1, -1), Among(u"m\u0131z", -1, -1), Among(u"n\u0131z", -1, -1) ] a_1 = [ Among(u"leri", -1, -1), Among(u"lar\u0131", -1, -1) ] a_2 = [ Among(u"ni", -1, -1), Among(u"nu", -1, -1), Among(u"n\u00FC", -1, -1), Among(u"n\u0131", -1, -1) ] a_3 = [ Among(u"in", -1, -1), Among(u"un", -1, -1), Among(u"\u00FCn", -1, -1), Among(u"\u0131n", -1, -1) ] a_4 = [ Among(u"a", -1, -1), Among(u"e", -1, -1) ] a_5 = [ Among(u"na", -1, -1), Among(u"ne", -1, -1) ] a_6 = [ Among(u"da", -1, -1), Among(u"ta", -1, -1), Among(u"de", -1, -1), Among(u"te", -1, -1) ] a_7 = [ Among(u"nda", -1, -1), Among(u"nde", -1, -1) ] a_8 = [ Among(u"dan", -1, -1), Among(u"tan", -1, -1), Among(u"den", -1, -1), Among(u"ten", -1, -1) ] a_9 = [ Among(u"ndan", -1, -1), Among(u"nden", -1, -1) ] a_10 = [ Among(u"la", -1, -1), Among(u"le", -1, -1) ] a_11 = [ Among(u"ca", -1, -1), Among(u"ce", -1, -1) ] a_12 = [ Among(u"im", -1, -1), Among(u"um", -1, -1), Among(u"\u00FCm", -1, -1), Among(u"\u0131m", -1, -1) ] a_13 = [ Among(u"sin", -1, -1), Among(u"sun", -1, -1), Among(u"s\u00FCn", -1, -1), Among(u"s\u0131n", -1, -1) ] a_14 = [ Among(u"iz", -1, -1), Among(u"uz", -1, -1), Among(u"\u00FCz", -1, -1), Among(u"\u0131z", -1, -1) ] a_15 = [ Among(u"siniz", -1, -1), Among(u"sunuz", -1, -1), Among(u"s\u00FCn\u00FCz", -1, -1), Among(u"s\u0131n\u0131z", -1, -1) ] a_16 = [ Among(u"lar", -1, -1), Among(u"ler", -1, -1) ] a_17 = [ Among(u"niz", -1, -1), Among(u"nuz", -1, -1), Among(u"n\u00FCz", -1, -1), Among(u"n\u0131z", -1, -1) ] a_18 = [ Among(u"dir", -1, -1), Among(u"tir", -1, -1), Among(u"dur", -1, -1), Among(u"tur", -1, -1), Among(u"d\u00FCr", -1, -1), Among(u"t\u00FCr", -1, -1), Among(u"d\u0131r", -1, -1), Among(u"t\u0131r", -1, -1) ] a_19 = [ Among(u"cas\u0131na", -1, -1), Among(u"cesine", -1, -1) ] a_20 = [ Among(u"di", -1, -1), Among(u"ti", -1, -1), Among(u"dik", -1, -1), Among(u"tik", -1, -1), Among(u"duk", -1, -1), Among(u"tuk", -1, -1), Among(u"d\u00FCk", -1, -1), Among(u"t\u00FCk", -1, -1), Among(u"d\u0131k", -1, -1), Among(u"t\u0131k", -1, -1), Among(u"dim", -1, -1), Among(u"tim", -1, -1), Among(u"dum", -1, -1), Among(u"tum", -1, -1), Among(u"d\u00FCm", -1, -1), Among(u"t\u00FCm", -1, -1), Among(u"d\u0131m", -1, -1), Among(u"t\u0131m", -1, -1), Among(u"din", -1, -1), Among(u"tin", -1, -1), Among(u"dun", -1, -1), Among(u"tun", -1, -1), Among(u"d\u00FCn", -1, -1), Among(u"t\u00FCn", -1, -1), Among(u"d\u0131n", -1, -1), Among(u"t\u0131n", -1, -1), Among(u"du", -1, -1), Among(u"tu", -1, -1), Among(u"d\u00FC", -1, -1), Among(u"t\u00FC", -1, -1), Among(u"d\u0131", -1, -1), Among(u"t\u0131", -1, -1) ] a_21 = [ Among(u"sa", -1, -1), Among(u"se", -1, -1), Among(u"sak", -1, -1), Among(u"sek", -1, -1), Among(u"sam", -1, -1), Among(u"sem", -1, -1), Among(u"san", -1, -1), Among(u"sen", -1, -1) ] a_22 = [ Among(u"mi\u015F", -1, -1), Among(u"mu\u015F", -1, -1), Among(u"m\u00FC\u015F", -1, -1), Among(u"m\u0131\u015F", -1, -1) ] a_23 = [ Among(u"b", -1, 1), Among(u"c", -1, 2), Among(u"d", -1, 3), Among(u"\u011F", -1, 4) ] g_vowel = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 8, 0, 0, 0, 0, 0, 0, 1] g_U = [1, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1] g_vowel1 = [1, 64, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] g_vowel2 = [17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130] g_vowel3 = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] g_vowel4 = [17] g_vowel5 = [65] g_vowel6 = [65] B_continue_stemming_noun_suffixes = False I_strlen = 0 def copy_from(self, other): self.B_continue_stemming_noun_suffixes = other.B_continue_stemming_noun_suffixes self.I_strlen = other.I_strlen super.copy_from(other) def r_check_vowel_harmony(self): # (, line 111 # test, line 112 v_1 = self.limit - self.cursor # (, line 113 # (, line 114 # goto, line 114 try: while True: v_2 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): raise lab1() self.cursor = self.limit - v_2 raise lab0() except lab1: pass self.cursor = self.limit - v_2 if self.cursor <= self.limit_backward: return False self.cursor -= 1 except lab0: pass # (, line 115 # or, line 116 try: v_3 = self.limit - self.cursor try: # (, line 116 # literal, line 116 if not self.eq_s_b(1, u"a"): raise lab3() # goto, line 116 try: while True: v_4 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel1, 97, 305): raise lab5() self.cursor = self.limit - v_4 raise lab4() except lab5: pass self.cursor = self.limit - v_4 if self.cursor <= self.limit_backward: raise lab3() self.cursor -= 1 except lab4: pass raise lab2() except lab3: pass self.cursor = self.limit - v_3 try: # (, line 117 # literal, line 117 if not self.eq_s_b(1, u"e"): raise lab6() # goto, line 117 try: while True: v_5 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel2, 101, 252): raise lab8() self.cursor = self.limit - v_5 raise lab7() except lab8: pass self.cursor = self.limit - v_5 if self.cursor <= self.limit_backward: raise lab6() self.cursor -= 1 except lab7: pass raise lab2() except lab6: pass self.cursor = self.limit - v_3 try: # (, line 118 # literal, line 118 if not self.eq_s_b(1, u"\u0131"): raise lab9() # goto, line 118 try: while True: v_6 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel3, 97, 305): raise lab11() self.cursor = self.limit - v_6 raise lab10() except lab11: pass self.cursor = self.limit - v_6 if self.cursor <= self.limit_backward: raise lab9() self.cursor -= 1 except lab10: pass raise lab2() except lab9: pass self.cursor = self.limit - v_3 try: # (, line 119 # literal, line 119 if not self.eq_s_b(1, u"i"): raise lab12() # goto, line 119 try: while True: v_7 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel4, 101, 105): raise lab14() self.cursor = self.limit - v_7 raise lab13() except lab14: pass self.cursor = self.limit - v_7 if self.cursor <= self.limit_backward: raise lab12() self.cursor -= 1 except lab13: pass raise lab2() except lab12: pass self.cursor = self.limit - v_3 try: # (, line 120 # literal, line 120 if not self.eq_s_b(1, u"o"): raise lab15() # goto, line 120 try: while True: v_8 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel5, 111, 117): raise lab17() self.cursor = self.limit - v_8 raise lab16() except lab17: pass self.cursor = self.limit - v_8 if self.cursor <= self.limit_backward: raise lab15() self.cursor -= 1 except lab16: pass raise lab2() except lab15: pass self.cursor = self.limit - v_3 try: # (, line 121 # literal, line 121 if not self.eq_s_b(1, u"\u00F6"): raise lab18() # goto, line 121 try: while True: v_9 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel6, 246, 252): raise lab20() self.cursor = self.limit - v_9 raise lab19() except lab20: pass self.cursor = self.limit - v_9 if self.cursor <= self.limit_backward: raise lab18() self.cursor -= 1 except lab19: pass raise lab2() except lab18: pass self.cursor = self.limit - v_3 try: # (, line 122 # literal, line 122 if not self.eq_s_b(1, u"u"): raise lab21() # goto, line 122 try: while True: v_10 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel5, 111, 117): raise lab23() self.cursor = self.limit - v_10 raise lab22() except lab23: pass self.cursor = self.limit - v_10 if self.cursor <= self.limit_backward: raise lab21() self.cursor -= 1 except lab22: pass raise lab2() except lab21: pass self.cursor = self.limit - v_3 # (, line 123 # literal, line 123 if not self.eq_s_b(1, u"\u00FC"): return False # goto, line 123 try: while True: v_11 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel6, 246, 252): raise lab25() self.cursor = self.limit - v_11 raise lab24() except lab25: pass self.cursor = self.limit - v_11 if self.cursor <= self.limit_backward: return False self.cursor -= 1 except lab24: pass except lab2: pass self.cursor = self.limit - v_1 return True def r_mark_suffix_with_optional_n_consonant(self): # (, line 132 # or, line 134 try: v_1 = self.limit - self.cursor try: # (, line 133 # (, line 133 # test, line 133 v_2 = self.limit - self.cursor # literal, line 133 if not self.eq_s_b(1, u"n"): raise lab1() self.cursor = self.limit - v_2 # next, line 133 if self.cursor <= self.limit_backward: raise lab1() self.cursor -= 1 # (, line 133 # test, line 133 v_3 = self.limit - self.cursor if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): raise lab1() self.cursor = self.limit - v_3 raise lab0() except lab1: pass self.cursor = self.limit - v_1 # (, line 135 # (, line 135 # not, line 135 v_4 = self.limit - self.cursor try: # (, line 135 # test, line 135 v_5 = self.limit - self.cursor # literal, line 135 if not self.eq_s_b(1, u"n"): raise lab2() self.cursor = self.limit - v_5 return False except lab2: pass self.cursor = self.limit - v_4 # test, line 135 v_6 = self.limit - self.cursor # (, line 135 # next, line 135 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # (, line 135 # test, line 135 v_7 = self.limit - self.cursor if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): return False self.cursor = self.limit - v_7 self.cursor = self.limit - v_6 except lab0: pass return True def r_mark_suffix_with_optional_s_consonant(self): # (, line 143 # or, line 145 try: v_1 = self.limit - self.cursor try: # (, line 144 # (, line 144 # test, line 144 v_2 = self.limit - self.cursor # literal, line 144 if not self.eq_s_b(1, u"s"): raise lab1() self.cursor = self.limit - v_2 # next, line 144 if self.cursor <= self.limit_backward: raise lab1() self.cursor -= 1 # (, line 144 # test, line 144 v_3 = self.limit - self.cursor if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): raise lab1() self.cursor = self.limit - v_3 raise lab0() except lab1: pass self.cursor = self.limit - v_1 # (, line 146 # (, line 146 # not, line 146 v_4 = self.limit - self.cursor try: # (, line 146 # test, line 146 v_5 = self.limit - self.cursor # literal, line 146 if not self.eq_s_b(1, u"s"): raise lab2() self.cursor = self.limit - v_5 return False except lab2: pass self.cursor = self.limit - v_4 # test, line 146 v_6 = self.limit - self.cursor # (, line 146 # next, line 146 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # (, line 146 # test, line 146 v_7 = self.limit - self.cursor if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): return False self.cursor = self.limit - v_7 self.cursor = self.limit - v_6 except lab0: pass return True def r_mark_suffix_with_optional_y_consonant(self): # (, line 153 # or, line 155 try: v_1 = self.limit - self.cursor try: # (, line 154 # (, line 154 # test, line 154 v_2 = self.limit - self.cursor # literal, line 154 if not self.eq_s_b(1, u"y"): raise lab1() self.cursor = self.limit - v_2 # next, line 154 if self.cursor <= self.limit_backward: raise lab1() self.cursor -= 1 # (, line 154 # test, line 154 v_3 = self.limit - self.cursor if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): raise lab1() self.cursor = self.limit - v_3 raise lab0() except lab1: pass self.cursor = self.limit - v_1 # (, line 156 # (, line 156 # not, line 156 v_4 = self.limit - self.cursor try: # (, line 156 # test, line 156 v_5 = self.limit - self.cursor # literal, line 156 if not self.eq_s_b(1, u"y"): raise lab2() self.cursor = self.limit - v_5 return False except lab2: pass self.cursor = self.limit - v_4 # test, line 156 v_6 = self.limit - self.cursor # (, line 156 # next, line 156 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # (, line 156 # test, line 156 v_7 = self.limit - self.cursor if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): return False self.cursor = self.limit - v_7 self.cursor = self.limit - v_6 except lab0: pass return True def r_mark_suffix_with_optional_U_vowel(self): # (, line 159 # or, line 161 try: v_1 = self.limit - self.cursor try: # (, line 160 # (, line 160 # test, line 160 v_2 = self.limit - self.cursor if not self.in_grouping_b(TurkishStemmer.g_U, 105, 305): raise lab1() self.cursor = self.limit - v_2 # next, line 160 if self.cursor <= self.limit_backward: raise lab1() self.cursor -= 1 # (, line 160 # test, line 160 v_3 = self.limit - self.cursor if not self.out_grouping_b(TurkishStemmer.g_vowel, 97, 305): raise lab1() self.cursor = self.limit - v_3 raise lab0() except lab1: pass self.cursor = self.limit - v_1 # (, line 162 # (, line 162 # not, line 162 v_4 = self.limit - self.cursor try: # (, line 162 # test, line 162 v_5 = self.limit - self.cursor if not self.in_grouping_b(TurkishStemmer.g_U, 105, 305): raise lab2() self.cursor = self.limit - v_5 return False except lab2: pass self.cursor = self.limit - v_4 # test, line 162 v_6 = self.limit - self.cursor # (, line 162 # next, line 162 if self.cursor <= self.limit_backward: return False self.cursor -= 1 # (, line 162 # test, line 162 v_7 = self.limit - self.cursor if not self.out_grouping_b(TurkishStemmer.g_vowel, 97, 305): return False self.cursor = self.limit - v_7 self.cursor = self.limit - v_6 except lab0: pass return True def r_mark_possessives(self): # (, line 166 # among, line 167 if self.find_among_b(TurkishStemmer.a_0, 10) == 0: return False # (, line 169 # call mark_suffix_with_optional_U_vowel, line 169 if not self.r_mark_suffix_with_optional_U_vowel(): return False return True def r_mark_sU(self): # (, line 172 # call check_vowel_harmony, line 173 if not self.r_check_vowel_harmony(): return False if not self.in_grouping_b(TurkishStemmer.g_U, 105, 305): return False # (, line 175 # call mark_suffix_with_optional_s_consonant, line 175 if not self.r_mark_suffix_with_optional_s_consonant(): return False return True def r_mark_lArI(self): # (, line 178 # among, line 179 if self.find_among_b(TurkishStemmer.a_1, 2) == 0: return False return True def r_mark_yU(self): # (, line 182 # call check_vowel_harmony, line 183 if not self.r_check_vowel_harmony(): return False if not self.in_grouping_b(TurkishStemmer.g_U, 105, 305): return False # (, line 185 # call mark_suffix_with_optional_y_consonant, line 185 if not self.r_mark_suffix_with_optional_y_consonant(): return False return True def r_mark_nU(self): # (, line 188 # call check_vowel_harmony, line 189 if not self.r_check_vowel_harmony(): return False # among, line 190 if self.find_among_b(TurkishStemmer.a_2, 4) == 0: return False return True def r_mark_nUn(self): # (, line 193 # call check_vowel_harmony, line 194 if not self.r_check_vowel_harmony(): return False # among, line 195 if self.find_among_b(TurkishStemmer.a_3, 4) == 0: return False # (, line 196 # call mark_suffix_with_optional_n_consonant, line 196 if not self.r_mark_suffix_with_optional_n_consonant(): return False return True def r_mark_yA(self): # (, line 199 # call check_vowel_harmony, line 200 if not self.r_check_vowel_harmony(): return False # among, line 201 if self.find_among_b(TurkishStemmer.a_4, 2) == 0: return False # (, line 202 # call mark_suffix_with_optional_y_consonant, line 202 if not self.r_mark_suffix_with_optional_y_consonant(): return False return True def r_mark_nA(self): # (, line 205 # call check_vowel_harmony, line 206 if not self.r_check_vowel_harmony(): return False # among, line 207 if self.find_among_b(TurkishStemmer.a_5, 2) == 0: return False return True def r_mark_DA(self): # (, line 210 # call check_vowel_harmony, line 211 if not self.r_check_vowel_harmony(): return False # among, line 212 if self.find_among_b(TurkishStemmer.a_6, 4) == 0: return False return True def r_mark_ndA(self): # (, line 215 # call check_vowel_harmony, line 216 if not self.r_check_vowel_harmony(): return False # among, line 217 if self.find_among_b(TurkishStemmer.a_7, 2) == 0: return False return True def r_mark_DAn(self): # (, line 220 # call check_vowel_harmony, line 221 if not self.r_check_vowel_harmony(): return False # among, line 222 if self.find_among_b(TurkishStemmer.a_8, 4) == 0: return False return True def r_mark_ndAn(self): # (, line 225 # call check_vowel_harmony, line 226 if not self.r_check_vowel_harmony(): return False # among, line 227 if self.find_among_b(TurkishStemmer.a_9, 2) == 0: return False return True def r_mark_ylA(self): # (, line 230 # call check_vowel_harmony, line 231 if not self.r_check_vowel_harmony(): return False # among, line 232 if self.find_among_b(TurkishStemmer.a_10, 2) == 0: return False # (, line 233 # call mark_suffix_with_optional_y_consonant, line 233 if not self.r_mark_suffix_with_optional_y_consonant(): return False return True def r_mark_ki(self): # (, line 236 # literal, line 237 if not self.eq_s_b(2, u"ki"): return False return True def r_mark_ncA(self): # (, line 240 # call check_vowel_harmony, line 241 if not self.r_check_vowel_harmony(): return False # among, line 242 if self.find_among_b(TurkishStemmer.a_11, 2) == 0: return False # (, line 243 # call mark_suffix_with_optional_n_consonant, line 243 if not self.r_mark_suffix_with_optional_n_consonant(): return False return True def r_mark_yUm(self): # (, line 246 # call check_vowel_harmony, line 247 if not self.r_check_vowel_harmony(): return False # among, line 248 if self.find_among_b(TurkishStemmer.a_12, 4) == 0: return False # (, line 249 # call mark_suffix_with_optional_y_consonant, line 249 if not self.r_mark_suffix_with_optional_y_consonant(): return False return True def r_mark_sUn(self): # (, line 252 # call check_vowel_harmony, line 253 if not self.r_check_vowel_harmony(): return False # among, line 254 if self.find_among_b(TurkishStemmer.a_13, 4) == 0: return False return True def r_mark_yUz(self): # (, line 257 # call check_vowel_harmony, line 258 if not self.r_check_vowel_harmony(): return False # among, line 259 if self.find_among_b(TurkishStemmer.a_14, 4) == 0: return False # (, line 260 # call mark_suffix_with_optional_y_consonant, line 260 if not self.r_mark_suffix_with_optional_y_consonant(): return False return True def r_mark_sUnUz(self): # (, line 263 # among, line 264 if self.find_among_b(TurkishStemmer.a_15, 4) == 0: return False return True def r_mark_lAr(self): # (, line 267 # call check_vowel_harmony, line 268 if not self.r_check_vowel_harmony(): return False # among, line 269 if self.find_among_b(TurkishStemmer.a_16, 2) == 0: return False return True def r_mark_nUz(self): # (, line 272 # call check_vowel_harmony, line 273 if not self.r_check_vowel_harmony(): return False # among, line 274 if self.find_among_b(TurkishStemmer.a_17, 4) == 0: return False return True def r_mark_DUr(self): # (, line 277 # call check_vowel_harmony, line 278 if not self.r_check_vowel_harmony(): return False # among, line 279 if self.find_among_b(TurkishStemmer.a_18, 8) == 0: return False return True def r_mark_cAsInA(self): # (, line 282 # among, line 283 if self.find_among_b(TurkishStemmer.a_19, 2) == 0: return False return True def r_mark_yDU(self): # (, line 286 # call check_vowel_harmony, line 287 if not self.r_check_vowel_harmony(): return False # among, line 288 if self.find_among_b(TurkishStemmer.a_20, 32) == 0: return False # (, line 292 # call mark_suffix_with_optional_y_consonant, line 292 if not self.r_mark_suffix_with_optional_y_consonant(): return False return True def r_mark_ysA(self): # (, line 296 # among, line 297 if self.find_among_b(TurkishStemmer.a_21, 8) == 0: return False # (, line 298 # call mark_suffix_with_optional_y_consonant, line 298 if not self.r_mark_suffix_with_optional_y_consonant(): return False return True def r_mark_ymUs_(self): # (, line 301 # call check_vowel_harmony, line 302 if not self.r_check_vowel_harmony(): return False # among, line 303 if self.find_among_b(TurkishStemmer.a_22, 4) == 0: return False # (, line 304 # call mark_suffix_with_optional_y_consonant, line 304 if not self.r_mark_suffix_with_optional_y_consonant(): return False return True def r_mark_yken(self): # (, line 307 # literal, line 308 if not self.eq_s_b(3, u"ken"): return False # (, line 308 # call mark_suffix_with_optional_y_consonant, line 308 if not self.r_mark_suffix_with_optional_y_consonant(): return False return True def r_stem_nominal_verb_suffixes(self): # (, line 311 # [, line 312 self.ket = self.cursor # set continue_stemming_noun_suffixes, line 313 self.B_continue_stemming_noun_suffixes = True # or, line 315 try: v_1 = self.limit - self.cursor try: # (, line 314 # or, line 314 try: v_2 = self.limit - self.cursor try: # call mark_ymUs_, line 314 if not self.r_mark_ymUs_(): raise lab3() raise lab2() except lab3: pass self.cursor = self.limit - v_2 try: # call mark_yDU, line 314 if not self.r_mark_yDU(): raise lab4() raise lab2() except lab4: pass self.cursor = self.limit - v_2 try: # call mark_ysA, line 314 if not self.r_mark_ysA(): raise lab5() raise lab2() except lab5: pass self.cursor = self.limit - v_2 # call mark_yken, line 314 if not self.r_mark_yken(): raise lab1() except lab2: pass raise lab0() except lab1: pass self.cursor = self.limit - v_1 try: # (, line 316 # call mark_cAsInA, line 316 if not self.r_mark_cAsInA(): raise lab6() # (, line 316 # or, line 316 try: v_3 = self.limit - self.cursor try: # call mark_sUnUz, line 316 if not self.r_mark_sUnUz(): raise lab8() raise lab7() except lab8: pass self.cursor = self.limit - v_3 try: # call mark_lAr, line 316 if not self.r_mark_lAr(): raise lab9() raise lab7() except lab9: pass self.cursor = self.limit - v_3 try: # call mark_yUm, line 316 if not self.r_mark_yUm(): raise lab10() raise lab7() except lab10: pass self.cursor = self.limit - v_3 try: # call mark_sUn, line 316 if not self.r_mark_sUn(): raise lab11() raise lab7() except lab11: pass self.cursor = self.limit - v_3 try: # call mark_yUz, line 316 if not self.r_mark_yUz(): raise lab12() raise lab7() except lab12: pass self.cursor = self.limit - v_3 except lab7: pass # call mark_ymUs_, line 316 if not self.r_mark_ymUs_(): raise lab6() raise lab0() except lab6: pass self.cursor = self.limit - v_1 try: # (, line 318 # call mark_lAr, line 319 if not self.r_mark_lAr(): raise lab13() # ], line 319 self.bra = self.cursor # delete, line 319 if not self.slice_del(): return False # try, line 319 v_4 = self.limit - self.cursor try: # (, line 319 # [, line 319 self.ket = self.cursor # (, line 319 # or, line 319 try: v_5 = self.limit - self.cursor try: # call mark_DUr, line 319 if not self.r_mark_DUr(): raise lab16() raise lab15() except lab16: pass self.cursor = self.limit - v_5 try: # call mark_yDU, line 319 if not self.r_mark_yDU(): raise lab17() raise lab15() except lab17: pass self.cursor = self.limit - v_5 try: # call mark_ysA, line 319 if not self.r_mark_ysA(): raise lab18() raise lab15() except lab18: pass self.cursor = self.limit - v_5 # call mark_ymUs_, line 319 if not self.r_mark_ymUs_(): self.cursor = self.limit - v_4 raise lab14() except lab15: pass except lab14: pass # unset continue_stemming_noun_suffixes, line 320 self.B_continue_stemming_noun_suffixes = False raise lab0() except lab13: pass self.cursor = self.limit - v_1 try: # (, line 323 # call mark_nUz, line 323 if not self.r_mark_nUz(): raise lab19() # (, line 323 # or, line 323 try: v_6 = self.limit - self.cursor try: # call mark_yDU, line 323 if not self.r_mark_yDU(): raise lab21() raise lab20() except lab21: pass self.cursor = self.limit - v_6 # call mark_ysA, line 323 if not self.r_mark_ysA(): raise lab19() except lab20: pass raise lab0() except lab19: pass self.cursor = self.limit - v_1 try: # (, line 325 # (, line 325 # or, line 325 try: v_7 = self.limit - self.cursor try: # call mark_sUnUz, line 325 if not self.r_mark_sUnUz(): raise lab24() raise lab23() except lab24: pass self.cursor = self.limit - v_7 try: # call mark_yUz, line 325 if not self.r_mark_yUz(): raise lab25() raise lab23() except lab25: pass self.cursor = self.limit - v_7 try: # call mark_sUn, line 325 if not self.r_mark_sUn(): raise lab26() raise lab23() except lab26: pass self.cursor = self.limit - v_7 # call mark_yUm, line 325 if not self.r_mark_yUm(): raise lab22() except lab23: pass # ], line 325 self.bra = self.cursor # delete, line 325 if not self.slice_del(): return False # try, line 325 v_8 = self.limit - self.cursor try: # (, line 325 # [, line 325 self.ket = self.cursor # call mark_ymUs_, line 325 if not self.r_mark_ymUs_(): self.cursor = self.limit - v_8 raise lab27() except lab27: pass raise lab0() except lab22: pass self.cursor = self.limit - v_1 # (, line 327 # call mark_DUr, line 327 if not self.r_mark_DUr(): return False # ], line 327 self.bra = self.cursor # delete, line 327 if not self.slice_del(): return False # try, line 327 v_9 = self.limit - self.cursor try: # (, line 327 # [, line 327 self.ket = self.cursor # (, line 327 # or, line 327 try: v_10 = self.limit - self.cursor try: # call mark_sUnUz, line 327 if not self.r_mark_sUnUz(): raise lab30() raise lab29() except lab30: pass self.cursor = self.limit - v_10 try: # call mark_lAr, line 327 if not self.r_mark_lAr(): raise lab31() raise lab29() except lab31: pass self.cursor = self.limit - v_10 try: # call mark_yUm, line 327 if not self.r_mark_yUm(): raise lab32() raise lab29() except lab32: pass self.cursor = self.limit - v_10 try: # call mark_sUn, line 327 if not self.r_mark_sUn(): raise lab33() raise lab29() except lab33: pass self.cursor = self.limit - v_10 try: # call mark_yUz, line 327 if not self.r_mark_yUz(): raise lab34() raise lab29() except lab34: pass self.cursor = self.limit - v_10 except lab29: pass # call mark_ymUs_, line 327 if not self.r_mark_ymUs_(): self.cursor = self.limit - v_9 raise lab28() except lab28: pass except lab0: pass # ], line 328 self.bra = self.cursor # delete, line 328 if not self.slice_del(): return False return True def r_stem_suffix_chain_before_ki(self): # (, line 332 # [, line 333 self.ket = self.cursor # call mark_ki, line 334 if not self.r_mark_ki(): return False # (, line 335 # or, line 342 try: v_1 = self.limit - self.cursor try: # (, line 336 # call mark_DA, line 336 if not self.r_mark_DA(): raise lab1() # ], line 336 self.bra = self.cursor # delete, line 336 if not self.slice_del(): return False # try, line 336 v_2 = self.limit - self.cursor try: # (, line 336 # [, line 336 self.ket = self.cursor # or, line 338 try: v_3 = self.limit - self.cursor try: # (, line 337 # call mark_lAr, line 337 if not self.r_mark_lAr(): raise lab4() # ], line 337 self.bra = self.cursor # delete, line 337 if not self.slice_del(): return False # try, line 337 v_4 = self.limit - self.cursor try: # (, line 337 # call stem_suffix_chain_before_ki, line 337 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_4 raise lab5() except lab5: pass raise lab3() except lab4: pass self.cursor = self.limit - v_3 # (, line 339 # call mark_possessives, line 339 if not self.r_mark_possessives(): self.cursor = self.limit - v_2 raise lab2() # ], line 339 self.bra = self.cursor # delete, line 339 if not self.slice_del(): return False # try, line 339 v_5 = self.limit - self.cursor try: # (, line 339 # [, line 339 self.ket = self.cursor # call mark_lAr, line 339 if not self.r_mark_lAr(): self.cursor = self.limit - v_5 raise lab6() # ], line 339 self.bra = self.cursor # delete, line 339 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 339 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_5 raise lab6() except lab6: pass except lab3: pass except lab2: pass raise lab0() except lab1: pass self.cursor = self.limit - v_1 try: # (, line 343 # call mark_nUn, line 343 if not self.r_mark_nUn(): raise lab7() # ], line 343 self.bra = self.cursor # delete, line 343 if not self.slice_del(): return False # try, line 343 v_6 = self.limit - self.cursor try: # (, line 343 # [, line 343 self.ket = self.cursor # or, line 345 try: v_7 = self.limit - self.cursor try: # (, line 344 # call mark_lArI, line 344 if not self.r_mark_lArI(): raise lab10() # ], line 344 self.bra = self.cursor # delete, line 344 if not self.slice_del(): return False raise lab9() except lab10: pass self.cursor = self.limit - v_7 try: # (, line 346 # [, line 346 self.ket = self.cursor # or, line 346 try: v_8 = self.limit - self.cursor try: # call mark_possessives, line 346 if not self.r_mark_possessives(): raise lab13() raise lab12() except lab13: pass self.cursor = self.limit - v_8 # call mark_sU, line 346 if not self.r_mark_sU(): raise lab11() except lab12: pass # ], line 346 self.bra = self.cursor # delete, line 346 if not self.slice_del(): return False # try, line 346 v_9 = self.limit - self.cursor try: # (, line 346 # [, line 346 self.ket = self.cursor # call mark_lAr, line 346 if not self.r_mark_lAr(): self.cursor = self.limit - v_9 raise lab14() # ], line 346 self.bra = self.cursor # delete, line 346 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 346 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_9 raise lab14() except lab14: pass raise lab9() except lab11: pass self.cursor = self.limit - v_7 # (, line 348 # call stem_suffix_chain_before_ki, line 348 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_6 raise lab8() except lab9: pass except lab8: pass raise lab0() except lab7: pass self.cursor = self.limit - v_1 # (, line 351 # call mark_ndA, line 351 if not self.r_mark_ndA(): return False # (, line 351 # or, line 353 try: v_10 = self.limit - self.cursor try: # (, line 352 # call mark_lArI, line 352 if not self.r_mark_lArI(): raise lab16() # ], line 352 self.bra = self.cursor # delete, line 352 if not self.slice_del(): return False raise lab15() except lab16: pass self.cursor = self.limit - v_10 try: # (, line 354 # (, line 354 # call mark_sU, line 354 if not self.r_mark_sU(): raise lab17() # ], line 354 self.bra = self.cursor # delete, line 354 if not self.slice_del(): return False # try, line 354 v_11 = self.limit - self.cursor try: # (, line 354 # [, line 354 self.ket = self.cursor # call mark_lAr, line 354 if not self.r_mark_lAr(): self.cursor = self.limit - v_11 raise lab18() # ], line 354 self.bra = self.cursor # delete, line 354 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 354 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_11 raise lab18() except lab18: pass raise lab15() except lab17: pass self.cursor = self.limit - v_10 # (, line 356 # call stem_suffix_chain_before_ki, line 356 if not self.r_stem_suffix_chain_before_ki(): return False except lab15: pass except lab0: pass return True def r_stem_noun_suffixes(self): # (, line 361 # or, line 363 try: v_1 = self.limit - self.cursor try: # (, line 362 # [, line 362 self.ket = self.cursor # call mark_lAr, line 362 if not self.r_mark_lAr(): raise lab1() # ], line 362 self.bra = self.cursor # delete, line 362 if not self.slice_del(): return False # try, line 362 v_2 = self.limit - self.cursor try: # (, line 362 # call stem_suffix_chain_before_ki, line 362 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_2 raise lab2() except lab2: pass raise lab0() except lab1: pass self.cursor = self.limit - v_1 try: # (, line 364 # [, line 364 self.ket = self.cursor # call mark_ncA, line 364 if not self.r_mark_ncA(): raise lab3() # ], line 364 self.bra = self.cursor # delete, line 364 if not self.slice_del(): return False # try, line 365 v_3 = self.limit - self.cursor try: # (, line 365 # or, line 367 try: v_4 = self.limit - self.cursor try: # (, line 366 # [, line 366 self.ket = self.cursor # call mark_lArI, line 366 if not self.r_mark_lArI(): raise lab6() # ], line 366 self.bra = self.cursor # delete, line 366 if not self.slice_del(): return False raise lab5() except lab6: pass self.cursor = self.limit - v_4 try: # (, line 368 # [, line 368 self.ket = self.cursor # or, line 368 try: v_5 = self.limit - self.cursor try: # call mark_possessives, line 368 if not self.r_mark_possessives(): raise lab9() raise lab8() except lab9: pass self.cursor = self.limit - v_5 # call mark_sU, line 368 if not self.r_mark_sU(): raise lab7() except lab8: pass # ], line 368 self.bra = self.cursor # delete, line 368 if not self.slice_del(): return False # try, line 368 v_6 = self.limit - self.cursor try: # (, line 368 # [, line 368 self.ket = self.cursor # call mark_lAr, line 368 if not self.r_mark_lAr(): self.cursor = self.limit - v_6 raise lab10() # ], line 368 self.bra = self.cursor # delete, line 368 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 368 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_6 raise lab10() except lab10: pass raise lab5() except lab7: pass self.cursor = self.limit - v_4 # (, line 370 # [, line 370 self.ket = self.cursor # call mark_lAr, line 370 if not self.r_mark_lAr(): self.cursor = self.limit - v_3 raise lab4() # ], line 370 self.bra = self.cursor # delete, line 370 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 370 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_3 raise lab4() except lab5: pass except lab4: pass raise lab0() except lab3: pass self.cursor = self.limit - v_1 try: # (, line 374 # [, line 374 self.ket = self.cursor # (, line 374 # or, line 374 try: v_7 = self.limit - self.cursor try: # call mark_ndA, line 374 if not self.r_mark_ndA(): raise lab13() raise lab12() except lab13: pass self.cursor = self.limit - v_7 # call mark_nA, line 374 if not self.r_mark_nA(): raise lab11() except lab12: pass # (, line 375 # or, line 377 try: v_8 = self.limit - self.cursor try: # (, line 376 # call mark_lArI, line 376 if not self.r_mark_lArI(): raise lab15() # ], line 376 self.bra = self.cursor # delete, line 376 if not self.slice_del(): return False raise lab14() except lab15: pass self.cursor = self.limit - v_8 try: # (, line 378 # call mark_sU, line 378 if not self.r_mark_sU(): raise lab16() # ], line 378 self.bra = self.cursor # delete, line 378 if not self.slice_del(): return False # try, line 378 v_9 = self.limit - self.cursor try: # (, line 378 # [, line 378 self.ket = self.cursor # call mark_lAr, line 378 if not self.r_mark_lAr(): self.cursor = self.limit - v_9 raise lab17() # ], line 378 self.bra = self.cursor # delete, line 378 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 378 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_9 raise lab17() except lab17: pass raise lab14() except lab16: pass self.cursor = self.limit - v_8 # (, line 380 # call stem_suffix_chain_before_ki, line 380 if not self.r_stem_suffix_chain_before_ki(): raise lab11() except lab14: pass raise lab0() except lab11: pass self.cursor = self.limit - v_1 try: # (, line 384 # [, line 384 self.ket = self.cursor # (, line 384 # or, line 384 try: v_10 = self.limit - self.cursor try: # call mark_ndAn, line 384 if not self.r_mark_ndAn(): raise lab20() raise lab19() except lab20: pass self.cursor = self.limit - v_10 # call mark_nU, line 384 if not self.r_mark_nU(): raise lab18() except lab19: pass # (, line 384 # or, line 384 try: v_11 = self.limit - self.cursor try: # (, line 384 # call mark_sU, line 384 if not self.r_mark_sU(): raise lab22() # ], line 384 self.bra = self.cursor # delete, line 384 if not self.slice_del(): return False # try, line 384 v_12 = self.limit - self.cursor try: # (, line 384 # [, line 384 self.ket = self.cursor # call mark_lAr, line 384 if not self.r_mark_lAr(): self.cursor = self.limit - v_12 raise lab23() # ], line 384 self.bra = self.cursor # delete, line 384 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 384 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_12 raise lab23() except lab23: pass raise lab21() except lab22: pass self.cursor = self.limit - v_11 # (, line 384 # call mark_lArI, line 384 if not self.r_mark_lArI(): raise lab18() except lab21: pass raise lab0() except lab18: pass self.cursor = self.limit - v_1 try: # (, line 386 # [, line 386 self.ket = self.cursor # call mark_DAn, line 386 if not self.r_mark_DAn(): raise lab24() # ], line 386 self.bra = self.cursor # delete, line 386 if not self.slice_del(): return False # try, line 386 v_13 = self.limit - self.cursor try: # (, line 386 # [, line 386 self.ket = self.cursor # (, line 387 # or, line 389 try: v_14 = self.limit - self.cursor try: # (, line 388 # call mark_possessives, line 388 if not self.r_mark_possessives(): raise lab27() # ], line 388 self.bra = self.cursor # delete, line 388 if not self.slice_del(): return False # try, line 388 v_15 = self.limit - self.cursor try: # (, line 388 # [, line 388 self.ket = self.cursor # call mark_lAr, line 388 if not self.r_mark_lAr(): self.cursor = self.limit - v_15 raise lab28() # ], line 388 self.bra = self.cursor # delete, line 388 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 388 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_15 raise lab28() except lab28: pass raise lab26() except lab27: pass self.cursor = self.limit - v_14 try: # (, line 390 # call mark_lAr, line 390 if not self.r_mark_lAr(): raise lab29() # ], line 390 self.bra = self.cursor # delete, line 390 if not self.slice_del(): return False # try, line 390 v_16 = self.limit - self.cursor try: # (, line 390 # call stem_suffix_chain_before_ki, line 390 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_16 raise lab30() except lab30: pass raise lab26() except lab29: pass self.cursor = self.limit - v_14 # (, line 392 # call stem_suffix_chain_before_ki, line 392 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_13 raise lab25() except lab26: pass except lab25: pass raise lab0() except lab24: pass self.cursor = self.limit - v_1 try: # (, line 396 # [, line 396 self.ket = self.cursor # or, line 396 try: v_17 = self.limit - self.cursor try: # call mark_nUn, line 396 if not self.r_mark_nUn(): raise lab33() raise lab32() except lab33: pass self.cursor = self.limit - v_17 # call mark_ylA, line 396 if not self.r_mark_ylA(): raise lab31() except lab32: pass # ], line 396 self.bra = self.cursor # delete, line 396 if not self.slice_del(): return False # try, line 397 v_18 = self.limit - self.cursor try: # (, line 397 # or, line 399 try: v_19 = self.limit - self.cursor try: # (, line 398 # [, line 398 self.ket = self.cursor # call mark_lAr, line 398 if not self.r_mark_lAr(): raise lab36() # ], line 398 self.bra = self.cursor # delete, line 398 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 398 if not self.r_stem_suffix_chain_before_ki(): raise lab36() raise lab35() except lab36: pass self.cursor = self.limit - v_19 try: # (, line 400 # [, line 400 self.ket = self.cursor # or, line 400 try: v_20 = self.limit - self.cursor try: # call mark_possessives, line 400 if not self.r_mark_possessives(): raise lab39() raise lab38() except lab39: pass self.cursor = self.limit - v_20 # call mark_sU, line 400 if not self.r_mark_sU(): raise lab37() except lab38: pass # ], line 400 self.bra = self.cursor # delete, line 400 if not self.slice_del(): return False # try, line 400 v_21 = self.limit - self.cursor try: # (, line 400 # [, line 400 self.ket = self.cursor # call mark_lAr, line 400 if not self.r_mark_lAr(): self.cursor = self.limit - v_21 raise lab40() # ], line 400 self.bra = self.cursor # delete, line 400 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 400 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_21 raise lab40() except lab40: pass raise lab35() except lab37: pass self.cursor = self.limit - v_19 # call stem_suffix_chain_before_ki, line 402 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_18 raise lab34() except lab35: pass except lab34: pass raise lab0() except lab31: pass self.cursor = self.limit - v_1 try: # (, line 406 # [, line 406 self.ket = self.cursor # call mark_lArI, line 406 if not self.r_mark_lArI(): raise lab41() # ], line 406 self.bra = self.cursor # delete, line 406 if not self.slice_del(): return False raise lab0() except lab41: pass self.cursor = self.limit - v_1 try: # (, line 408 # call stem_suffix_chain_before_ki, line 408 if not self.r_stem_suffix_chain_before_ki(): raise lab42() raise lab0() except lab42: pass self.cursor = self.limit - v_1 try: # (, line 410 # [, line 410 self.ket = self.cursor # or, line 410 try: v_22 = self.limit - self.cursor try: # call mark_DA, line 410 if not self.r_mark_DA(): raise lab45() raise lab44() except lab45: pass self.cursor = self.limit - v_22 try: # call mark_yU, line 410 if not self.r_mark_yU(): raise lab46() raise lab44() except lab46: pass self.cursor = self.limit - v_22 # call mark_yA, line 410 if not self.r_mark_yA(): raise lab43() except lab44: pass # ], line 410 self.bra = self.cursor # delete, line 410 if not self.slice_del(): return False # try, line 410 v_23 = self.limit - self.cursor try: # (, line 410 # [, line 410 self.ket = self.cursor # (, line 410 # or, line 410 try: v_24 = self.limit - self.cursor try: # (, line 410 # call mark_possessives, line 410 if not self.r_mark_possessives(): raise lab49() # ], line 410 self.bra = self.cursor # delete, line 410 if not self.slice_del(): return False # try, line 410 v_25 = self.limit - self.cursor try: # (, line 410 # [, line 410 self.ket = self.cursor # call mark_lAr, line 410 if not self.r_mark_lAr(): self.cursor = self.limit - v_25 raise lab50() except lab50: pass raise lab48() except lab49: pass self.cursor = self.limit - v_24 # call mark_lAr, line 410 if not self.r_mark_lAr(): self.cursor = self.limit - v_23 raise lab47() except lab48: pass # ], line 410 self.bra = self.cursor # delete, line 410 if not self.slice_del(): return False # [, line 410 self.ket = self.cursor # call stem_suffix_chain_before_ki, line 410 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_23 raise lab47() except lab47: pass raise lab0() except lab43: pass self.cursor = self.limit - v_1 # (, line 412 # [, line 412 self.ket = self.cursor # or, line 412 try: v_26 = self.limit - self.cursor try: # call mark_possessives, line 412 if not self.r_mark_possessives(): raise lab52() raise lab51() except lab52: pass self.cursor = self.limit - v_26 # call mark_sU, line 412 if not self.r_mark_sU(): return False except lab51: pass # ], line 412 self.bra = self.cursor # delete, line 412 if not self.slice_del(): return False # try, line 412 v_27 = self.limit - self.cursor try: # (, line 412 # [, line 412 self.ket = self.cursor # call mark_lAr, line 412 if not self.r_mark_lAr(): self.cursor = self.limit - v_27 raise lab53() # ], line 412 self.bra = self.cursor # delete, line 412 if not self.slice_del(): return False # call stem_suffix_chain_before_ki, line 412 if not self.r_stem_suffix_chain_before_ki(): self.cursor = self.limit - v_27 raise lab53() except lab53: pass except lab0: pass return True def r_post_process_last_consonants(self): # (, line 415 # [, line 416 self.ket = self.cursor # substring, line 416 among_var = self.find_among_b(TurkishStemmer.a_23, 4) if among_var == 0: return False # ], line 416 self.bra = self.cursor if among_var == 0: return False elif among_var == 1: # (, line 417 # <-, line 417 if not self.slice_from(u"p"): return False elif among_var == 2: # (, line 418 # <-, line 418 if not self.slice_from(u"\u00E7"): return False elif among_var == 3: # (, line 419 # <-, line 419 if not self.slice_from(u"t"): return False elif among_var == 4: # (, line 420 # <-, line 420 if not self.slice_from(u"k"): return False return True def r_append_U_to_stems_ending_with_d_or_g(self): # (, line 430 # test, line 431 v_1 = self.limit - self.cursor # (, line 431 # or, line 431 try: v_2 = self.limit - self.cursor try: # literal, line 431 if not self.eq_s_b(1, u"d"): raise lab1() raise lab0() except lab1: pass self.cursor = self.limit - v_2 # literal, line 431 if not self.eq_s_b(1, u"g"): return False except lab0: pass self.cursor = self.limit - v_1 # or, line 433 try: v_3 = self.limit - self.cursor try: # (, line 432 # test, line 432 v_4 = self.limit - self.cursor # (, line 432 # (, line 432 # goto, line 432 try: while True: v_5 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): raise lab5() self.cursor = self.limit - v_5 raise lab4() except lab5: pass self.cursor = self.limit - v_5 if self.cursor <= self.limit_backward: raise lab3() self.cursor -= 1 except lab4: pass # or, line 432 try: v_6 = self.limit - self.cursor try: # literal, line 432 if not self.eq_s_b(1, u"a"): raise lab7() raise lab6() except lab7: pass self.cursor = self.limit - v_6 # literal, line 432 if not self.eq_s_b(1, u"\u0131"): raise lab3() except lab6: pass self.cursor = self.limit - v_4 # <+, line 432 c = self.cursor self.insert(self.cursor, self.cursor, u"\u0131") self.cursor = c raise lab2() except lab3: pass self.cursor = self.limit - v_3 try: # (, line 434 # test, line 434 v_7 = self.limit - self.cursor # (, line 434 # (, line 434 # goto, line 434 try: while True: v_8 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): raise lab10() self.cursor = self.limit - v_8 raise lab9() except lab10: pass self.cursor = self.limit - v_8 if self.cursor <= self.limit_backward: raise lab8() self.cursor -= 1 except lab9: pass # or, line 434 try: v_9 = self.limit - self.cursor try: # literal, line 434 if not self.eq_s_b(1, u"e"): raise lab12() raise lab11() except lab12: pass self.cursor = self.limit - v_9 # literal, line 434 if not self.eq_s_b(1, u"i"): raise lab8() except lab11: pass self.cursor = self.limit - v_7 # <+, line 434 c = self.cursor self.insert(self.cursor, self.cursor, u"i") self.cursor = c raise lab2() except lab8: pass self.cursor = self.limit - v_3 try: # (, line 436 # test, line 436 v_10 = self.limit - self.cursor # (, line 436 # (, line 436 # goto, line 436 try: while True: v_11 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): raise lab15() self.cursor = self.limit - v_11 raise lab14() except lab15: pass self.cursor = self.limit - v_11 if self.cursor <= self.limit_backward: raise lab13() self.cursor -= 1 except lab14: pass # or, line 436 try: v_12 = self.limit - self.cursor try: # literal, line 436 if not self.eq_s_b(1, u"o"): raise lab17() raise lab16() except lab17: pass self.cursor = self.limit - v_12 # literal, line 436 if not self.eq_s_b(1, u"u"): raise lab13() except lab16: pass self.cursor = self.limit - v_10 # <+, line 436 c = self.cursor self.insert(self.cursor, self.cursor, u"u") self.cursor = c raise lab2() except lab13: pass self.cursor = self.limit - v_3 # (, line 438 # test, line 438 v_13 = self.limit - self.cursor # (, line 438 # (, line 438 # goto, line 438 try: while True: v_14 = self.limit - self.cursor try: if not self.in_grouping_b(TurkishStemmer.g_vowel, 97, 305): raise lab19() self.cursor = self.limit - v_14 raise lab18() except lab19: pass self.cursor = self.limit - v_14 if self.cursor <= self.limit_backward: return False self.cursor -= 1 except lab18: pass # or, line 438 try: v_15 = self.limit - self.cursor try: # literal, line 438 if not self.eq_s_b(1, u"\u00F6"): raise lab21() raise lab20() except lab21: pass self.cursor = self.limit - v_15 # literal, line 438 if not self.eq_s_b(1, u"\u00FC"): return False except lab20: pass self.cursor = self.limit - v_13 # <+, line 438 c = self.cursor self.insert(self.cursor, self.cursor, u"\u00FC") self.cursor = c except lab2: pass return True def r_more_than_one_syllable_word(self): # (, line 445 # test, line 446 v_1 = self.cursor # (, line 446 # atleast, line 446 v_2 = 2 # atleast, line 446 try: while True: try: v_3 = self.cursor try: # (, line 446 # gopast, line 446 try: while True: try: if not self.in_grouping(TurkishStemmer.g_vowel, 97, 305): raise lab4() raise lab3() except lab4: pass if self.cursor >= self.limit: raise lab2() self.cursor += 1 except lab3: pass v_2 -= 1 raise lab1() except lab2: pass self.cursor = v_3 raise lab0() except lab1: pass except lab0: pass if v_2 > 0: return False self.cursor = v_1 return True def r_is_reserved_word(self): # (, line 449 # or, line 451 try: v_1 = self.cursor try: # test, line 450 v_2 = self.cursor # (, line 450 # gopast, line 450 try: while True: try: # literal, line 450 if not self.eq_s(2, u"ad"): raise lab3() raise lab2() except lab3: pass if self.cursor >= self.limit: raise lab1() self.cursor += 1 except lab2: pass # (, line 450 self.I_strlen = 2; # (, line 450 if not self.I_strlen == self.limit: raise lab1() self.cursor = v_2 raise lab0() except lab1: pass self.cursor = v_1 # test, line 452 v_4 = self.cursor # (, line 452 # gopast, line 452 try: while True: try: # literal, line 452 if not self.eq_s(5, u"soyad"): raise lab5() raise lab4() except lab5: pass if self.cursor >= self.limit: return False self.cursor += 1 except lab4: pass # (, line 452 self.I_strlen = 5; # (, line 452 if not self.I_strlen == self.limit: return False self.cursor = v_4 except lab0: pass return True def r_postlude(self): # (, line 455 # not, line 456 v_1 = self.cursor try: # (, line 456 # call is_reserved_word, line 456 if not self.r_is_reserved_word(): raise lab0() return False except lab0: pass self.cursor = v_1 # backwards, line 457 self.limit_backward = self.cursor self.cursor = self.limit # (, line 457 # do, line 458 v_2 = self.limit - self.cursor try: # call append_U_to_stems_ending_with_d_or_g, line 458 if not self.r_append_U_to_stems_ending_with_d_or_g(): raise lab1() except lab1: pass self.cursor = self.limit - v_2 # do, line 459 v_3 = self.limit - self.cursor try: # call post_process_last_consonants, line 459 if not self.r_post_process_last_consonants(): raise lab2() except lab2: pass self.cursor = self.limit - v_3 self.cursor = self.limit_backward return True def _stem(self): # (, line 464 # (, line 465 # call more_than_one_syllable_word, line 465 if not self.r_more_than_one_syllable_word(): return False # (, line 466 # backwards, line 467 self.limit_backward = self.cursor self.cursor = self.limit # (, line 467 # do, line 468 v_1 = self.limit - self.cursor try: # call stem_nominal_verb_suffixes, line 468 if not self.r_stem_nominal_verb_suffixes(): raise lab0() except lab0: pass self.cursor = self.limit - v_1 # Boolean test continue_stemming_noun_suffixes, line 469 if not self.B_continue_stemming_noun_suffixes: return False # do, line 470 v_2 = self.limit - self.cursor try: # call stem_noun_suffixes, line 470 if not self.r_stem_noun_suffixes(): raise lab1() except lab1: pass self.cursor = self.limit - v_2 self.cursor = self.limit_backward # call postlude, line 473 if not self.r_postlude(): return False return True def equals(self, o): return isinstance(o, TurkishStemmer) def hashCode(self): return hash("TurkishStemmer") class lab0(BaseException): pass class lab1(BaseException): pass class lab2(BaseException): pass class lab3(BaseException): pass class lab4(BaseException): pass class lab5(BaseException): pass class lab6(BaseException): pass class lab7(BaseException): pass class lab8(BaseException): pass class lab9(BaseException): pass class lab10(BaseException): pass class lab11(BaseException): pass class lab12(BaseException): pass class lab13(BaseException): pass class lab14(BaseException): pass class lab15(BaseException): pass class lab16(BaseException): pass class lab17(BaseException): pass class lab18(BaseException): pass class lab19(BaseException): pass class lab20(BaseException): pass class lab21(BaseException): pass class lab22(BaseException): pass class lab23(BaseException): pass class lab24(BaseException): pass class lab25(BaseException): pass class lab26(BaseException): pass class lab27(BaseException): pass class lab28(BaseException): pass class lab29(BaseException): pass class lab30(BaseException): pass class lab31(BaseException): pass class lab32(BaseException): pass class lab33(BaseException): pass class lab34(BaseException): pass class lab35(BaseException): pass class lab36(BaseException): pass class lab37(BaseException): pass class lab38(BaseException): pass class lab39(BaseException): pass class lab40(BaseException): pass class lab41(BaseException): pass class lab42(BaseException): pass class lab43(BaseException): pass class lab44(BaseException): pass class lab45(BaseException): pass class lab46(BaseException): pass class lab47(BaseException): pass class lab48(BaseException): pass class lab49(BaseException): pass class lab50(BaseException): pass class lab51(BaseException): pass class lab52(BaseException): pass class lab53(BaseException): pass