FileDocCategorySizeDatePackage
SnowballProgram.javaAPI DocApache Lucene 1.99175Mon Feb 20 09:17:48 GMT 2006net.sf.snowball

SnowballProgram

public class SnowballProgram extends Object

Fields Summary
protected StringBuffer
current
protected int
cursor
protected int
limit
protected int
limit_backward
protected int
bra
protected int
ket
Constructors Summary
protected SnowballProgram()

	current = new StringBuffer();
	setCurrent("");
    
Methods Summary
protected java.lang.StringBufferassign_to(java.lang.StringBuffer s)

	s.replace(0, s.length(), current.substring(0, limit));
	return s;
    
protected voidcopy_from(net.sf.snowball.SnowballProgram other)

	current          = other.current;
	cursor           = other.cursor;
	limit            = other.limit;
	limit_backward   = other.limit_backward;
	bra              = other.bra;
	ket              = other.ket;
    
protected booleaneq_s(int s_size, java.lang.String s)

	if (limit - cursor < s_size) return false;
	int i;
	for (i = 0; i != s_size; i++) {
	    if (current.charAt(cursor + i) != s.charAt(i)) return false;
	}
	cursor += s_size;
	return true;
    
protected booleaneq_s_b(int s_size, java.lang.String s)

	if (cursor - limit_backward < s_size) return false;
	int i;
	for (i = 0; i != s_size; i++) {
	    if (current.charAt(cursor - s_size + i) != s.charAt(i)) return false;
	}
	cursor -= s_size;
	return true;
    
protected booleaneq_v(java.lang.StringBuffer s)

	return eq_s(s.length(), s.toString());
    
protected booleaneq_v_b(java.lang.StringBuffer s)

   return eq_s_b(s.length(), s.toString());
    
protected intfind_among(Among[] v, int v_size)

	int i = 0;
	int j = v_size;

	int c = cursor;
	int l = limit;

	int common_i = 0;
	int common_j = 0;

	boolean first_key_inspected = false;

	while(true) {
	    int k = i + ((j - i) >> 1);
	    int diff = 0;
	    int common = common_i < common_j ? common_i : common_j; // smaller
	    Among w = v[k];
	    int i2;
	    for (i2 = common; i2 < w.s_size; i2++) {
		if (c + common == l) {
		    diff = -1;
		    break;
		}
		diff = current.charAt(c + common) - w.s.charAt(i2);
		if (diff != 0) break;
		common++;
	    }
	    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. This looks messy, but is actually
		// the optimal approach.

		if (first_key_inspected) break;
		first_key_inspected = true;
	    }
	}
	while(true) {
	    Among w = v[i];
	    if (common_i >= w.s_size) {
		cursor = c + w.s_size;
		if (w.method == null) return w.result;
		boolean res;
		try {
		    Object resobj = w.method.invoke(w.methodobject,
						    new Object[0]);
		    res = resobj.toString().equals("true");
		} catch (InvocationTargetException e) {
		    res = false;
		    // FIXME - debug message
		} catch (IllegalAccessException e) {
		    res = false;
		    // FIXME - debug message
		}
		cursor = c + w.s_size;
		if (res) return w.result;
	    }
	    i = w.substring_i;
	    if (i < 0) return 0;
	}
    
protected intfind_among_b(Among[] v, int v_size)

	int i = 0;
	int j = v_size;

	int c = cursor;
	int lb = limit_backward;

	int common_i = 0;
	int common_j = 0;

	boolean first_key_inspected = false;

	while(true) {
	    int k = i + ((j - i) >> 1);
	    int diff = 0;
	    int common = common_i < common_j ? common_i : common_j;
	    Among w = v[k];
	    int i2;
	    for (i2 = w.s_size - 1 - common; i2 >= 0; i2--) {
		if (c - common == lb) {
		    diff = -1;
		    break;
		}
		diff = current.charAt(c - 1 - common) - w.s.charAt(i2);
		if (diff != 0) break;
		common++;
	    }
	    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) {
	    Among w = v[i];
	    if (common_i >= w.s_size) {
		cursor = c - w.s_size;
		if (w.method == null) return w.result;

		boolean res;
		try {
		    Object resobj = w.method.invoke(w.methodobject,
						    new Object[0]);
		    res = resobj.toString().equals("true");
		} catch (InvocationTargetException e) {
		    res = false;
		    // FIXME - debug message
		} catch (IllegalAccessException e) {
		    res = false;
		    // FIXME - debug message
		}
		cursor = c - w.s_size;
		if (res) return w.result;
	    }
	    i = w.substring_i;
	    if (i < 0) return 0;
	}
    
public java.lang.StringgetCurrent()
Get the current string.

	return current.toString();
    
protected booleanin_grouping(char[] s, int min, int max)

	if (cursor >= limit) return false;
	char ch = current.charAt(cursor);
	if (ch > max || ch < min) return false;
	ch -= min;
	if ((s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return false;
	cursor++;
	return true;
    
protected booleanin_grouping_b(char[] s, int min, int max)

	if (cursor <= limit_backward) return false;
	char ch = current.charAt(cursor - 1);
	if (ch > max || ch < min) return false;
	ch -= min;
	if ((s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return false;
	cursor--;
	return true;
    
protected booleanin_range(int min, int max)

	if (cursor >= limit) return false;
	char ch = current.charAt(cursor);
	if (ch > max || ch < min) return false;
	cursor++;
	return true;
    
protected booleanin_range_b(int min, int max)

	if (cursor <= limit_backward) return false;
	char ch = current.charAt(cursor - 1);
	if (ch > max || ch < min) return false;
	cursor--;
	return true;
    
protected voidinsert(int c_bra, int c_ket, java.lang.String s)

	int adjustment = replace_s(c_bra, c_ket, s);
	if (c_bra <= bra) bra += adjustment;
	if (c_bra <= ket) ket += adjustment;
    
protected voidinsert(int c_bra, int c_ket, java.lang.StringBuffer s)

	insert(c_bra, c_ket, s.toString());
    
protected booleanout_grouping(char[] s, int min, int max)

	if (cursor >= limit) return false;
	char ch = current.charAt(cursor);
	if (ch > max || ch < min) {
	    cursor++;
	    return true;
	}
	ch -= min;
	if ((s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) {
	    cursor ++;
	    return true;
	}
	return false;
    
protected booleanout_grouping_b(char[] s, int min, int max)

	if (cursor <= limit_backward) return false;
	char ch = current.charAt(cursor - 1);
	if (ch > max || ch < min) {
	    cursor--;
	    return true;
	}
	ch -= min;
	if ((s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) {
	    cursor--;
	    return true;
	}
	return false;
    
protected booleanout_range(int min, int max)

	if (cursor >= limit) return false;
	char ch = current.charAt(cursor);
	if (!(ch > max || ch < min)) return false;
	cursor++;
	return true;
    
protected booleanout_range_b(int min, int max)

	if (cursor <= limit_backward) return false;
	char ch = current.charAt(cursor - 1);
	if(!(ch > max || ch < min)) return false;
	cursor--;
	return true;
    
protected intreplace_s(int c_bra, int c_ket, java.lang.String s)

	int adjustment = s.length() - (c_ket - c_bra);
	current.replace(bra, ket, s);
	limit += adjustment;
	if (cursor >= c_ket) cursor += adjustment;
	else if (cursor > c_bra) cursor = c_bra;
	return adjustment;
    
public voidsetCurrent(java.lang.String value)
Set the current string.

	current.replace(0, current.length(), value);
	cursor = 0;
	limit = current.length();
	limit_backward = 0;
	bra = cursor;
	ket = limit;
    
protected voidslice_check()

	if (bra < 0 ||
	    bra > ket ||
	    ket > limit ||
	    limit > current.length())   // this line could be removed
	{
	    System.err.println("faulty slice operation");
	// FIXME: report error somehow.
	/*
	    fprintf(stderr, "faulty slice operation:\n");
	    debug(z, -1, 0);
	    exit(1);
	    */
	}
    
protected voidslice_del()

	slice_from("");
    
protected voidslice_from(java.lang.String s)

	slice_check();
	replace_s(bra, ket, s);
    
protected voidslice_from(java.lang.StringBuffer s)

        slice_from(s.toString());
    
protected java.lang.StringBufferslice_to(java.lang.StringBuffer s)

	slice_check();
	int len = ket - bra;
	s.replace(0, s.length(), current.substring(bra, ket));
	return s;