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 <[EMAIL PROTECTED]>
+ * 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 <[EMAIL PROTECTED]>
+
* 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 <[EMAIL PROTECTED]>
+ * @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 <[EMAIL PROTECTED]>
+ * @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 <[EMAIL PROTECTED]>
+ * @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 <[EMAIL PROTECTED]>
+ * @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 <[EMAIL PROTECTED]>
+ * @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 ***
_______________________________________________
kaffe mailing list
[EMAIL PROTECTED]
http://kaffe.org/cgi-bin/mailman/listinfo/kaffe
