mittens 0.1.1 → 0.3.0

data/vendor/snowball/go/env.go

@@ -43,14 +43,13 @@ func (env *Env) SetCurrent(s string) {
 
 func (env *Env) ReplaceS(bra, ket int, s string) int32 {
 	adjustment := int32(len(s)) - (int32(ket) - int32(bra))
-	result, _ := splitAt(env.current, bra)
+	result := env.current[:bra]
+	result += s
 	rsplit := ket
 	if ket < bra {
 		rsplit = bra
 	}
-	_, rhs := splitAt(env.current, rsplit)
-	result += s
-	result += rhs
+	result += env.current[rsplit:]
 
 	newLim := int32(env.Limit) + adjustment
 	env.Limit = int(newLim)
@@ -159,16 +158,34 @@ func (env *Env) InGrouping(chars []byte, min, max int32) bool {
 	}
 
 	r, _ := utf8.DecodeRuneInString(env.current[env.Cursor:])
-	if r != utf8.RuneError {
-		if r > max || r < min {
+	if r == utf8.RuneError {
+		return false
+	}
+	if r > max || r < min {
+		return false
+	}
+	r -= min
+	if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) == 0 {
+		return false
+	}
+	env.NextChar()
+	return true
+}
+
+func (env *Env) GoInGrouping(chars []byte, min, max int32) bool {
+	for env.Cursor < env.Limit {
+		r, _ := utf8.DecodeRuneInString(env.current[env.Cursor:])
+		if r == utf8.RuneError {
 			return false
 		}
+		if r > max || r < min {
+			return true
+		}
 		r -= min
 		if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) == 0 {
-			return false
+			return true
 		}
 		env.NextChar()
-		return true
 	}
 	return false
 }
@@ -177,19 +194,41 @@ func (env *Env) InGroupingB(chars []byte, min, max int32) bool {
 	if env.Cursor <= env.LimitBackward {
 		return false
 	}
+	c := env.Cursor
 	env.PrevChar()
 	r, _ := utf8.DecodeRuneInString(env.current[env.Cursor:])
-	if r != utf8.RuneError {
-		env.NextChar()
-		if r > max || r < min {
+	if r == utf8.RuneError {
+		return false
+	}
+	if r > max || r < min {
+		env.Cursor = c
+		return false
+	}
+	r -= min
+	if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) == 0 {
+		env.Cursor = c
+		return false
+	}
+	return true
+}
+
+func (env *Env) GoInGroupingB(chars []byte, min, max int32) bool {
+	for env.Cursor > env.LimitBackward {
+		c := env.Cursor
+		env.PrevChar()
+		r, _ := utf8.DecodeRuneInString(env.current[env.Cursor:])
+		if r == utf8.RuneError {
 			return false
 		}
+		if r > max || r < min {
+			env.Cursor = c
+			return true
+		}
 		r -= min
 		if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) == 0 {
-			return false
+			env.Cursor = c
+			return true
 		}
-		env.PrevChar()
-		return true
 	}
 	return false
 }
@@ -199,16 +238,34 @@ func (env *Env) OutGrouping(chars []byte, min, max int32) bool {
 		return false
 	}
 	r, _ := utf8.DecodeRuneInString(env.current[env.Cursor:])
-	if r != utf8.RuneError {
-		if r > max || r < min {
-			env.NextChar()
-			return true
+	if r == utf8.RuneError {
+		return false
+	}
+	if r > max || r < min {
+		env.NextChar()
+		return true
+	}
+	r -= min
+	if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) == 0 {
+		env.NextChar()
+		return true
+	}
+	return false
+}
+
+func (env *Env) GoOutGrouping(chars []byte, min, max int32) bool {
+	for env.Cursor < env.Limit {
+		r, _ := utf8.DecodeRuneInString(env.current[env.Cursor:])
+		if r == utf8.RuneError {
+			return false
 		}
-		r -= min
-		if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) == 0 {
-			env.NextChar()
-			return true
+		if r <= max && r >= min {
+			r -= min
+			if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) != 0 {
+				return true
+			}
 		}
+		env.NextChar()
 	}
 	return false
 }
@@ -217,18 +274,37 @@ func (env *Env) OutGroupingB(chars []byte, min, max int32) bool {
 	if env.Cursor <= env.LimitBackward {
 		return false
 	}
+	c := env.Cursor
 	env.PrevChar()
 	r, _ := utf8.DecodeRuneInString(env.current[env.Cursor:])
-	if r != utf8.RuneError {
-		env.NextChar()
-		if r > max || r < min {
-			env.PrevChar()
-			return true
+	if r == utf8.RuneError {
+		return false
+	}
+	if r > max || r < min {
+		return true
+	}
+	r -= min
+	if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) == 0 {
+		return true
+	}
+	env.Cursor = c
+	return false
+}
+
+func (env *Env) GoOutGroupingB(chars []byte, min, max int32) bool {
+	for env.Cursor > env.LimitBackward {
+		c := env.Cursor
+		env.PrevChar()
+		r, _ := utf8.DecodeRuneInString(env.current[env.Cursor:])
+		if r == utf8.RuneError {
+			return false
 		}
-		r -= min
-		if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) == 0 {
-			env.PrevChar()
-			return true
+		if r <= max && r >= min {
+			r -= min
+			if (chars[uint(r>>3)] & (0x1 << uint(r&0x7))) != 0 {
+				env.Cursor = c
+				return true
+			}
 		}
 	}
 	return false

data/vendor/snowball/go/util.go

@@ -8,10 +8,6 @@ import (
 const MaxInt = math.MaxInt32
 const MinInt = math.MinInt32
 
-func splitAt(str string, mid int) (string, string) {
-	return str[:mid], str[mid:]
-}
-
 func min(a, b int) int {
 	if a < b {
 		return a

data/vendor/snowball/include/libstemmer.h

@@ -56,6 +56,10 @@ struct sb_stemmer * sb_stemmer_new(const char * algorithm, const char * charenc)
 void                sb_stemmer_delete(struct sb_stemmer * stemmer);
 
 /** Stem a word.
+ *
+ *  The stemming algorithms generally expect the input text to use composed
+ *  accents (Unicode NFC or NFKC) and to have been folded to lower case
+ *  already.
  *
  *  The return value is owned by the stemmer - it must not be freed or
  *  modified, and it will become invalid when the stemmer is called again,

data/vendor/snowball/java/org/tartarus/snowball/Among.java

@@ -1,29 +1,46 @@
 package org.tartarus.snowball;
 
-import java.lang.reflect.Method;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.Locale;
 
+/**
+ * Internal class used by Snowball stemmers
+ */
 public class Among {
     public Among (String s, int substring_i, int result) {
         this.s = s.toCharArray();
         this.substring_i = substring_i;
-	this.result = result;
-	this.method = null;
+        this.result = result;
+        this.method = null;
     }
 
     public Among (String s, int substring_i, int result, String methodname,
-		  Class<? extends SnowballProgram> programclass) {
+                  MethodHandles.Lookup methodobject) {
         this.s = s.toCharArray();
         this.substring_i = substring_i;
-	this.result = result;
-	try {
-	    this.method = programclass.getDeclaredMethod(methodname);
-	} catch (NoSuchMethodException e) {
-	    throw new RuntimeException(e);
-	}
+        this.result = result;
+        final Class<? extends SnowballProgram> clazz = methodobject.lookupClass().asSubclass(SnowballProgram.class);
+        if (methodname.length() > 0) {
+            try {
+                this.method = methodobject.findVirtual(clazz, methodname, MethodType.methodType(boolean.class))
+                    .asType(MethodType.methodType(boolean.class, SnowballProgram.class));
+            } catch (NoSuchMethodException | IllegalAccessException e) {
+                throw new RuntimeException(String.format(Locale.ENGLISH,
+                    "Snowball program '%s' is broken, cannot access method: boolean %s()",
+                    clazz.getSimpleName(), methodname
+                ), e);
+            }
+        } else {
+            this.method = null;
+        }
     }
 
-    public final char[] s; /* search string */
-    public final int substring_i; /* index to longest matching substring */
-    public final int result; /* result of the lookup */
-    public final Method method; /* method to use if substring matches */
-};
+    final char[] s; /* search string */
+    final int substring_i; /* index to longest matching substring */
+    final int result; /* result of the lookup */
+
+    // Make sure this is not accessible outside package for Java security reasons!
+    final MethodHandle method; /* method to use if substring matches */
+}