[kaffe] CVS kaffe (guilhem): Added some missing java.text files.

Kaffe CVS cvs-commits at kaffe.org
Sat Aug 16 06:17:02 PDT 2003


PatchSet 3957 
Date: 2003/08/16 13:01:06
Author: guilhem
Branch: HEAD
Tag: (none) 
Log:
Added some missing java.text files.

Members: 
	ChangeLog:1.1555->1.1556 
	libraries/javalib/gnu/java/text/BaseBreakIterator.java:INITIAL->1.1 
	libraries/javalib/gnu/java/text/CharacterBreakIterator.java:INITIAL->1.1 
	libraries/javalib/gnu/java/text/LineBreakIterator.java:INITIAL->1.1 
	libraries/javalib/gnu/java/text/SentenceBreakIterator.java:INITIAL->1.1 
	libraries/javalib/gnu/java/text/WordBreakIterator.java:INITIAL->1.1 

Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.1555 kaffe/ChangeLog:1.1556
--- kaffe/ChangeLog:1.1555	Sat Aug 16 11:03:39 2003
+++ kaffe/ChangeLog	Sat Aug 16 13:01:06 2003
@@ -1,5 +1,14 @@
 2003-08-16  Guilhem Lavaux <guilhem at kaffe.org>
 
+	* libraries/gnu/java/text/BaseBreakIterator.java,
+	libraries/gnu/java/text/CharacterBreakIterator.java,
+	libraries/gnu/java/text/LineBreakIterator.java,
+	libraries/gnu/java/text/SentenceBreakIterator.java,
+	libraries/gnu/java/text/WordBreakIterator.java:
+	Added some missing files.
+
+2003-08-16  Guilhem Lavaux <guilhem at kaffe.org>
+
 	* java/text/Annotation.java,
 	java/text/AttributedCharacterIterator.java,
 	java/text/AttributedStringIterator.java,
@@ -54,6 +63,10 @@
 	* include/Makefile.am:
 	(NOINSTALL_DERIVED_HDRS) added java_util_TimeZone.h
 
+	* libraries/javalib/kaffe/text/: Removed.
+
+	* libaries/javalib/profiles/allatonce/all.files: Regenerated from
+	default. (Hope it is the way of making it)
 
 	* libraries/javalib/Makefile.am.in: added properties file in
 	gnu/java/locale and updated bundle packaging.
===================================================================
Checking out kaffe/libraries/javalib/gnu/java/text/BaseBreakIterator.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/gnu/java/text/BaseBreakIterator.java,v
VERS: 1.1
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/gnu/java/text/BaseBreakIterator.java	Sat Aug 16 13:06:48 2003
@@ -0,0 +1,112 @@
+/* BaseBreakIterator.java -- Base class for default BreakIterators
+   Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.text;
+
+import java.text.BreakIterator;
+import java.text.CharacterIterator;
+
+/**
+ * @author Tom Tromey <tromey at cygnus.com>
+ * @date March 22, 1999
+ */
+
+public abstract class BaseBreakIterator extends BreakIterator
+{
+  public int current ()
+  {
+    return iter.getIndex();
+  }
+
+  public int first ()
+  {
+    iter.first();
+    return iter.getBeginIndex();
+  }
+
+  public int following (int pos)
+  {
+    int save = iter.getIndex();
+    iter.setIndex(pos);
+    int r = next ();
+    iter.setIndex(save);
+    return r;
+  }
+
+  public CharacterIterator getText ()
+  {
+    return iter;
+  }
+
+  public int last ()
+  {
+    iter.last();
+    // Go past the last character.
+    iter.next();
+    return iter.getEndIndex();
+  }
+
+  public int next (int n)
+  {
+    int r = iter.getIndex ();
+    if (n > 0)
+      {
+	while (n > 0 && r != DONE)
+	  {
+	    r = next ();
+	    --n;
+	  }
+      }
+    else if (n < 0)
+      {
+	while (n < 0 && r != DONE)
+	  {
+	    r = previous ();
+	    ++n;
+	  }
+      }
+    return r;
+  }
+
+  public void setText (CharacterIterator newText)
+  {
+    iter = newText;
+  }
+
+  protected CharacterIterator iter;
+}
===================================================================
Checking out kaffe/libraries/javalib/gnu/java/text/CharacterBreakIterator.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/gnu/java/text/CharacterBreakIterator.java,v
VERS: 1.1
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/gnu/java/text/CharacterBreakIterator.java	Sat Aug 16 13:06:48 2003
@@ -0,0 +1,216 @@
+/* CharacterBreakIterator.java - Default character BreakIterator.
+   Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.text;
+
+import java.text.BreakIterator;
+import java.text.CharacterIterator;
+
+/**
+ * @author Tom Tromey <tromey at cygnus.com>
+ * @date March 19, 1999
+ * Written using The Unicode Standard, Version 2.0.
+ */
+
+public class CharacterBreakIterator extends BaseBreakIterator
+{
+  // Hangul Jamo constants from Unicode book.
+  private static final int LBase = 0x1100;
+  private static final int VBase = 0x1161;
+  private static final int TBase = 0x11a7;
+  private static final int LCount = 19;
+  private static final int VCount = 21;
+  private static final int TCount = 28;
+
+  // Information about surrogates.
+  private static final int highSurrogateStart = 0xD800;
+  private static final int highSurrogateEnd = 0xDBFF;
+  private static final int lowSurrogateStart = 0xDC00;
+  private static final int lowSurrogateEnd = 0xDFFF;
+
+  public Object clone ()
+  {
+    return new CharacterBreakIterator (this);
+  }
+
+  public CharacterBreakIterator ()
+  {
+    iter = null;		// FIXME?
+  }
+
+  private CharacterBreakIterator (CharacterBreakIterator other)
+  {
+    iter = (CharacterIterator) other.iter.clone();
+  }
+
+  // Some methods to tell us different properties of characters.
+  private final boolean isL (char c)
+  {
+    return c >= LBase && c <= LBase + LCount;
+  }
+  private final boolean isV (char c)
+  {
+    return c >= VBase && c <= VBase + VCount;
+  }
+  private final boolean isT (char c)
+  {
+    return c >= TBase && c <= TBase + TCount;
+  }
+  private final boolean isLVT (char c)
+  {
+    return isL (c) || isV (c) || isT (c);
+  }
+  private final boolean isHighSurrogate (char c)
+  {
+    return c >= highSurrogateStart && c <= highSurrogateEnd;
+  }
+  private final boolean isLowSurrogate (char c)
+  {
+    return c >= lowSurrogateStart && c <= lowSurrogateEnd;
+  }
+
+  public int next ()
+  {
+    int end = iter.getEndIndex();
+    if (iter.getIndex() == end)
+      return DONE;
+
+    char c;
+    for (char prev = CharacterIterator.DONE; iter.getIndex() < end; prev = c)
+      {
+	c = iter.next();
+	if (c == CharacterIterator.DONE)
+	  break;
+	int type = Character.getType(c);
+
+	// Break after paragraph separators.
+	if (type == Character.PARAGRAPH_SEPARATOR)
+	  break;
+
+	// Now we need some lookahead.
+	char ahead = iter.next();
+	iter.previous();
+	if (ahead == CharacterIterator.DONE)
+	  break;
+	int aheadType = Character.getType(ahead);
+
+	if (aheadType != Character.NON_SPACING_MARK
+	    && ! isLowSurrogate (ahead)
+	    && ! isLVT (ahead))
+	  break;
+	if (! isLVT (c) && isLVT (ahead))
+	  break;
+	if (isL (c) && ! isLVT (ahead)
+	    && aheadType != Character.NON_SPACING_MARK)
+	  break;
+	if (isV (c) && ! isV (ahead) && !isT (ahead)
+	    && aheadType != Character.NON_SPACING_MARK)
+	  break;
+	if (isT (c) && ! isT (ahead)
+	    && aheadType != Character.NON_SPACING_MARK)
+	  break;
+
+	if (! isHighSurrogate (c) && isLowSurrogate (ahead))
+	  break;
+	if (isHighSurrogate (c) && ! isLowSurrogate (ahead))
+	  break;
+	if (! isHighSurrogate (prev) && isLowSurrogate (c))
+	  break;
+      }
+
+    return iter.getIndex();
+  }
+
+  public int previous ()
+  {
+    if (iter.getIndex() == iter.getBeginIndex())
+      return DONE;
+
+    int start = iter.getBeginIndex();
+    while (iter.getIndex() >= iter.getBeginIndex())
+      {
+	char c = iter.previous();
+	if (c == CharacterIterator.DONE)
+	  break;
+	int type = Character.getType(c);
+
+	if (type != Character.NON_SPACING_MARK
+	    && ! isLowSurrogate (c)
+	    && ! isLVT (c))
+	  break;
+
+	// Now we need some lookahead.
+	char ahead = iter.previous();
+	if (ahead == CharacterIterator.DONE)
+	  {
+	    iter.next();
+	    break;
+	  }
+	char ahead2 = iter.previous();
+	iter.next();
+	iter.next();
+	if (ahead2 == CharacterIterator.DONE)
+	  break;
+	int aheadType = Character.getType(ahead);
+
+	if (aheadType == Character.PARAGRAPH_SEPARATOR)
+	  break;
+
+	if (isLVT (c) && ! isLVT (ahead))
+	  break;
+	if (! isLVT (c) && type != Character.NON_SPACING_MARK
+	    && isL (ahead))
+	  break;
+	if (! isV (c) && ! isT (c) && type != Character.NON_SPACING_MARK
+	    && isV (ahead))
+	  break;
+	if (! isT (c) && type != Character.NON_SPACING_MARK
+	    && isT (ahead))
+	  break;
+
+	if (isLowSurrogate (c) && ! isHighSurrogate (ahead))
+	  break;
+	if (! isLowSurrogate (c) && isHighSurrogate (ahead))
+	  break;
+	if (isLowSurrogate (ahead) && ! isHighSurrogate (ahead2))
+	  break;
+      }
+
+    return iter.getIndex();
+  }
+}
===================================================================
Checking out kaffe/libraries/javalib/gnu/java/text/LineBreakIterator.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/gnu/java/text/LineBreakIterator.java,v
VERS: 1.1
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/gnu/java/text/LineBreakIterator.java	Sat Aug 16 13:06:49 2003
@@ -0,0 +1,196 @@
+/* LineBreakIterator.java - Default word BreakIterator.
+   Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.text;
+
+import java.text.BreakIterator;
+import java.text.CharacterIterator;
+
+/**
+ * @author Tom Tromey <tromey at cygnus.com>
+ * @date March 22, 1999
+ * Written using The Unicode Standard, Version 2.0.
+ */
+
+public class LineBreakIterator extends BaseBreakIterator
+{
+  public Object clone ()
+  {
+    return new LineBreakIterator (this);
+  }
+
+  public LineBreakIterator ()
+  {
+    iter = null;
+  }
+
+  private LineBreakIterator (LineBreakIterator other)
+  {
+    iter = (CharacterIterator) other.iter.clone();
+  }
+
+  // Some methods to tell us different properties of characters.
+  private final boolean isNb (char c)
+  {
+    return (c == 0x00a0		// NO-BREAK SPACE
+	    || c == 0x2011	// NON-BREAKING HYPHEN
+	    || c == 0xfeff);	// ZERO WITH NO-BREAK SPACE
+  }
+  private final boolean isClose (int type)
+  {
+    return (type == Character.END_PUNCTUATION
+	    // Unicode book says "comma, period, ...", which I take to
+	    // mean "Po" class.
+	    || type == Character.OTHER_PUNCTUATION);
+  }
+  private final boolean isIdeo (char c)
+  {
+    return (c >= 0x3040 && c <= 0x309f	       // Hiragana
+	    || c >= 0x30a0 && c <= 0x30ff      // Katakana
+	    || c >= 0x4e00 && c <= 0x9fff      // Han
+	    || c >= 0x3100 && c <= 0x312f);    // Bopomofo
+  }
+
+  public int next ()
+  {
+    int end = iter.getEndIndex();
+    if (iter.getIndex() == end)
+      return DONE;
+
+    while (iter.getIndex() < end)
+      {
+	char c = iter.current();
+	int type = Character.getType(c);
+
+	char n = iter.next();
+
+	if (n == CharacterIterator.DONE
+	    || type == Character.PARAGRAPH_SEPARATOR
+	    || type == Character.LINE_SEPARATOR)
+	  break;
+
+	// Handle two cases where we must scan for non-spacing marks.
+	int start = iter.getIndex();
+	if (type == Character.SPACE_SEPARATOR
+	    || type == Character.START_PUNCTUATION
+	    || isIdeo (c))
+	  {
+	    while (n != CharacterIterator.DONE
+		   && Character.getType(n) == Character.NON_SPACING_MARK)
+	      n = iter.next();
+	    if (n == CharacterIterator.DONE)
+	      break;
+
+	    if (type == Character.SPACE_SEPARATOR)
+	      {
+		int nt = Character.getType(n);
+		if (nt != Character.NON_SPACING_MARK
+		    && nt != Character.SPACE_SEPARATOR
+		    && ! isNb (n))
+		  break;
+	      }
+	    else if (type == Character.START_PUNCTUATION)
+	      {
+		if (isIdeo (n))
+		  {
+		    // Open punctuation followed by non spacing marks
+		    // and then ideograph does not have a break in
+		    // it.  So skip all this.
+		    start = iter.getIndex();
+		  }
+	      }
+	    else
+	      {
+		// Ideograph preceded this character.
+		if (isClose (Character.getType(n)))
+		  break;
+	      }
+	  }
+	iter.setIndex(start);
+      }
+
+    return iter.getIndex();
+  }
+
+  public int previous ()
+  {
+    int start = iter.getBeginIndex();
+    if (iter.getIndex() == start)
+      return DONE;
+
+    while (iter.getIndex() >= start)
+      {
+	char c = iter.previous();
+	if (c == CharacterIterator.DONE)
+	  break;
+	int type = Character.getType(c);
+
+	char n = iter.previous();
+	if (n == CharacterIterator.DONE)
+	  break;
+	iter.next();
+
+	int nt = Character.getType(n);
+	// Break after paragraph separators.
+	if (nt == Character.PARAGRAPH_SEPARATOR
+	    || nt == Character.LINE_SEPARATOR)
+	  break;
+
+	// Skip non-spacing marks.
+	int init = iter.getIndex();
+	while (n != CharacterIterator.DONE && nt == Character.NON_SPACING_MARK)
+	  {
+	    n = iter.previous();
+	    nt = Character.getType(n);
+	  }
+
+	if (nt == Character.SPACE_SEPARATOR
+	    && type != Character.SPACE_SEPARATOR
+	    && type != Character.NON_SPACING_MARK
+	    && ! isNb (c))
+	  break;
+	if (! isClose (type) && isIdeo (n))
+	  break;
+	if (isIdeo (c) && nt != Character.START_PUNCTUATION)
+	  break;
+	iter.setIndex(init);
+      }
+
+    return iter.getIndex();
+  }
+}
===================================================================
Checking out kaffe/libraries/javalib/gnu/java/text/SentenceBreakIterator.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/gnu/java/text/SentenceBreakIterator.java,v
VERS: 1.1
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/gnu/java/text/SentenceBreakIterator.java	Sat Aug 16 13:06:49 2003
@@ -0,0 +1,249 @@
+/* SentenceBreakIterator.java - Default sentence BreakIterator.
+   Copyright (C) 1999, 2001, 2002 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.text;
+
+import java.text.BreakIterator;
+import java.text.CharacterIterator;
+
+/**
+ * @author Tom Tromey <tromey at cygnus.com>
+ * @date March 23, 1999
+ * Written using The Unicode Standard, Version 2.0.
+ */
+
+public class SentenceBreakIterator extends BaseBreakIterator
+{
+  public Object clone ()
+  {
+    return new SentenceBreakIterator (this);
+  }
+
+  public SentenceBreakIterator ()
+  {
+    iter = null;
+  }
+
+  private SentenceBreakIterator (SentenceBreakIterator other)
+  {
+    iter = (CharacterIterator) other.iter.clone();
+  }
+
+  public int next ()
+  {
+    int end = iter.getEndIndex();
+    if (iter.getIndex() == end)
+      return DONE;
+
+    while (iter.getIndex() < end)
+      {
+	char c = iter.current();
+	if (c == CharacterIterator.DONE)
+	  break;
+	int type = Character.getType(c);
+
+	char n = iter.next();
+	if (n == CharacterIterator.DONE)
+	  break;
+
+	// Always break after paragraph separator.
+	if (type == Character.PARAGRAPH_SEPARATOR)
+	  break;
+
+	if (c == '!' || c == '?')
+	  {
+	    // Skip close punctuation.
+	    while (n != CharacterIterator.DONE
+		   && Character.getType(n) == Character.END_PUNCTUATION)
+	      n = iter.next();
+	    // Skip (java) space, line and paragraph separators.
+	    while (n != CharacterIterator.DONE && Character.isWhitespace(n))
+	      n = iter.next();
+
+	    // There's always a break somewhere after `!' or `?'.
+	    break;
+	  }
+
+	if (c == '.')
+	  {
+	    int save = iter.getIndex();
+	    // Skip close punctuation.
+	    while (n != CharacterIterator.DONE
+		   && Character.getType(n) == Character.END_PUNCTUATION)
+	      n = iter.next();
+	    // Skip (java) space, line and paragraph separators.
+	    // We keep count because we need at least one for this period to
+	    // represent a terminator.
+	    int spcount = 0;
+	    while (n != CharacterIterator.DONE && Character.isWhitespace(n))
+	      {
+		n = iter.next();
+		++spcount;
+	      }
+	    if (spcount > 0)
+	      {
+		int save2 = iter.getIndex();
+		// Skip over open puncutation.
+		while (n != CharacterIterator.DONE
+		       && Character.getType(n) == Character.START_PUNCTUATION)
+		  n = iter.next();
+		// Next character must not be lower case.
+		if (n == CharacterIterator.DONE
+		    || ! Character.isLowerCase(n))
+		  {
+		    iter.setIndex(save2);
+		    break;
+		  }
+	      }
+	    iter.setIndex(save);
+	  }
+      }
+
+    return iter.getIndex();
+  }
+
+  private final int previous_internal ()
+  {
+    int start = iter.getBeginIndex();
+    if (iter.getIndex() == start)
+      return DONE;
+
+    while (iter.getIndex() >= start)
+      {
+	char c = iter.previous();
+	if (c == CharacterIterator.DONE)
+	  break;
+
+	char n = iter.previous();
+	if (n == CharacterIterator.DONE)
+	  break;
+	iter.next();
+	int nt = Character.getType(n);
+
+	if (! Character.isLowerCase(c)
+	    && (nt == Character.START_PUNCTUATION
+		|| Character.isWhitespace(n)))
+	  {
+	    int save = iter.getIndex();
+	    int save_nt = nt;
+	    char save_n = n;
+	    // Skip open punctuation.
+	    while (n != CharacterIterator.DONE
+		   && Character.getType(n) == Character.START_PUNCTUATION)
+	      n = iter.previous();
+	    if (n == CharacterIterator.DONE)
+	      break;
+	    if (Character.isWhitespace(n))
+	      {
+		// Must have at least one (java) space after the `.'.
+		int save2 = iter.getIndex();
+		while (n != CharacterIterator.DONE
+		       && Character.isWhitespace(n))
+		  n = iter.previous();
+		// Skip close punctuation.
+		while (n != CharacterIterator.DONE
+		       && Character.getType(n) == Character.END_PUNCTUATION)
+		  n = iter.previous();
+		if (n == CharacterIterator.DONE || n == '.')
+		  {
+		    // Communicate location of actual end.
+		    period = iter.getIndex();
+		    iter.setIndex(save2);
+		    break;
+		  }
+	      }
+	    iter.setIndex(save);
+	    nt = save_nt;
+	    n = save_n;
+	  }
+
+	if (nt == Character.PARAGRAPH_SEPARATOR)
+	  {
+	    // Communicate location of actual end.
+	    period = iter.getIndex();
+	    break;
+	  }
+	else if (Character.isWhitespace(n)
+		 || nt == Character.END_PUNCTUATION)
+	  {
+	    int save = iter.getIndex();
+	    // Skip (java) space, line and paragraph separators.
+	    while (n != CharacterIterator.DONE
+		   && Character.isWhitespace(n))
+	      n = iter.previous();
+	    // Skip close punctuation.
+	    while (n != CharacterIterator.DONE
+		   && Character.getType(n) == Character.END_PUNCTUATION)
+	      n = iter.previous();
+	    int here = iter.getIndex();
+	    iter.setIndex(save);
+	    if (n == CharacterIterator.DONE || n == '!' || n == '?')
+	      {
+		// Communicate location of actual end.
+		period = here;
+		break;
+	      }
+	  }
+	else if (n == '!' || n == '?')
+	  {
+	    // Communicate location of actual end.
+	    period = iter.getIndex();
+	    break;
+	  }
+      }
+
+    return iter.getIndex();
+  }
+
+  public int previous ()
+  {
+    // We want to skip over the first sentence end to the second one.
+    // However, at the end of the string we want the first end.
+    int here = iter.getIndex();
+    period = here;
+    int first = previous_internal ();
+    if (here == iter.getEndIndex() || first == DONE)
+      return first;
+    iter.setIndex(period);
+    return previous_internal ();
+  }
+
+  // This is used for communication between previous and
+  // previous_internal.
+  private int period;
+}
===================================================================
Checking out kaffe/libraries/javalib/gnu/java/text/WordBreakIterator.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/gnu/java/text/WordBreakIterator.java,v
VERS: 1.1
***************
--- /dev/null	Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/gnu/java/text/WordBreakIterator.java	Sat Aug 16 13:06:49 2003
@@ -0,0 +1,252 @@
+/* WordBreakIterator.java - Default word BreakIterator.
+   Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.java.text;
+
+import java.text.BreakIterator;
+import java.text.CharacterIterator;
+
+/**
+ * @author Tom Tromey <tromey at cygnus.com>
+ * @date March 22, 1999
+ * Written using The Unicode Standard, Version 2.0.
+ */
+
+public class WordBreakIterator extends BaseBreakIterator
+{
+  public Object clone ()
+  {
+    return new WordBreakIterator (this);
+  }
+
+  public WordBreakIterator ()
+  {
+    iter = null;
+  }
+
+  private WordBreakIterator (WordBreakIterator other)
+  {
+    iter = (CharacterIterator) other.iter.clone();
+  }
+
+  // Some methods to tell us different properties of characters.
+  private final boolean isHira (char c)
+  {
+    return c >= 0x3040 && c <= 0x309f;
+  }
+  private final boolean isKata (char c)
+  {
+    return c >= 0x30a0 && c <= 0x30ff;
+  }
+  private final boolean isHan (char c)
+  {
+    return c >= 0x4e00 && c <= 0x9fff;
+  }
+
+  public int next ()
+  {
+    int end = iter.getEndIndex();
+    if (iter.getIndex() == end)
+      return DONE;
+
+    while (iter.getIndex() < end)
+      {
+	char c = iter.current();
+	if (c == CharacterIterator.DONE)
+	  break;
+	int type = Character.getType(c);
+
+	char n = iter.next();
+	if (n == CharacterIterator.DONE)
+	  break;
+
+	// Break after paragraph separators.
+	if (type == Character.PARAGRAPH_SEPARATOR
+	    || type == Character.LINE_SEPARATOR)
+	  break;
+
+	// Break between letters and non-letters.
+	// FIXME: we treat apostrophe as part of a word.  This
+	// is an English-ism.
+	boolean is_letter = Character.isLetter(c);
+	if (c != '\'' && ! is_letter && type != Character.NON_SPACING_MARK
+	    && Character.isLetter(n))
+	  break;
+
+	// Always break after certain symbols, such as punctuation.
+	// This heuristic is derived from hints in the JCL book and is
+	// not part of Unicode.  It seems to be right, however.
+	// FIXME: we treat apostrophe as part of a word.  This
+	// is an English-ism.
+	if (c != '\''
+	    && (type == Character.DASH_PUNCTUATION
+		|| type == Character.START_PUNCTUATION
+		|| type == Character.END_PUNCTUATION
+		|| type == Character.CONNECTOR_PUNCTUATION
+		|| type == Character.OTHER_PUNCTUATION
+		|| type == Character.MATH_SYMBOL
+		|| type == Character.CURRENCY_SYMBOL
+		|| type == Character.MODIFIER_SYMBOL
+		|| type == Character.OTHER_SYMBOL
+		|| type == Character.FORMAT
+		|| type == Character.CONTROL))
+	  break;
+
+	boolean is_hira = isHira (c);
+	boolean is_kata = isKata (c);
+	boolean is_han = isHan (c);
+
+	// Special case Japanese.
+	if (! is_hira && ! is_kata && ! is_han
+	    && type != Character.NON_SPACING_MARK
+	    && (isHira (n) || isKata (n) || isHan (n)))
+	  break;
+
+	if (is_hira || is_kata || is_han || is_letter)
+	  {

*** Patch too long, truncated ***




More information about the kaffe mailing list