diff --git a/src/main/java/java/lang/AbstractMethodError.java b/src/main/java/java/lang/AbstractMethodError.java
new file mode 100644
index 0000000..5d069dc
--- /dev/null
+++ b/src/main/java/java/lang/AbstractMethodError.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when an application tries to call an abstract method.
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of some class has
+ * incompatibly changed since the currently executing method was last
+ * compiled.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public
+class AbstractMethodError extends IncompatibleClassChangeError {
+ private static final long serialVersionUID = -1654391082989018462L;
+
+ /**
+ * Constructs an <code>AbstractMethodError</code> with no detail message.
+ */
+ public AbstractMethodError() {
+ super();
+ }
+
+ /**
+ * Constructs an <code>AbstractMethodError</code> with the specified
+ * detail message.
+ *
+ * @param s the detail message.
+ */
+ public AbstractMethodError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.AbstractMethodError: " + message)
+ : "java.lang.AbstractMethodError";
+ }
+}
diff --git a/src/main/java/java/lang/ArithmeticException.java b/src/main/java/java/lang/ArithmeticException.java
new file mode 100644
index 0000000..692eec3
--- /dev/null
+++ b/src/main/java/java/lang/ArithmeticException.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public class ArithmeticException extends RuntimeException {
+ private static final long serialVersionUID = 2256477558314496007L;
+
+ public ArithmeticException() {
+ super();
+ }
+
+ public ArithmeticException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.ArithmeticException: " + message)
+ : "java.lang.ArithmeticException";
+ }
+}
diff --git a/src/main/java/java/lang/ArrayIndexOutOfBoundsException.java b/src/main/java/java/lang/ArrayIndexOutOfBoundsException.java
new file mode 100644
index 0000000..4c5e4f9
--- /dev/null
+++ b/src/main/java/java/lang/ArrayIndexOutOfBoundsException.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException {
+ private static final long serialVersionUID = -5116101128118950844L;
+
+ public ArrayIndexOutOfBoundsException() {
+ super();
+ }
+
+ public ArrayIndexOutOfBoundsException(int index) {
+ super("Array index out of range: " + index);
+ }
+
+ public ArrayIndexOutOfBoundsException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.ArrayIndexOutOfBoundsException: " + message)
+ : "java.lang.ArrayIndexOutOfBoundsException";
+ }
+}
diff --git a/src/main/java/java/lang/ArrayStoreException.java b/src/main/java/java/lang/ArrayStoreException.java
new file mode 100644
index 0000000..fa886cf
--- /dev/null
+++ b/src/main/java/java/lang/ArrayStoreException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class ArrayStoreException extends RuntimeException {
+ private static final long serialVersionUID = -4522193890499838241L;
+
+ public ArrayStoreException() {
+ super();
+ }
+
+ public ArrayStoreException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.ArrayStoreException: " + message)
+ : "java.lang.ArrayStoreException";
+ }
+}
diff --git a/src/main/java/java/lang/BootstrapMethodError.java b/src/main/java/java/lang/BootstrapMethodError.java
new file mode 100644
index 0000000..fd542d4
--- /dev/null
+++ b/src/main/java/java/lang/BootstrapMethodError.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown to indicate that an {@code invokedynamic} instruction has
+ * failed to find its bootstrap method,
+ * or the bootstrap method has failed to provide a
+ * {@linkplain java.lang.invoke.CallSite call site} with a {@linkplain java.lang.invoke.CallSite#getTarget target}
+ * of the correct {@linkplain java.lang.invoke.MethodHandle#type method type}.
+ *
+ * @author John Rose, JSR 292 EG
+ * @since 1.7
+ */
+public class BootstrapMethodError extends LinkageError {
+ private static final long serialVersionUID = 292L;
+
+ /**
+ * Constructs a {@code BootstrapMethodError} with no detail message.
+ */
+ public BootstrapMethodError() {
+ super();
+ }
+
+ /**
+ * Constructs a {@code BootstrapMethodError} with the specified
+ * detail message.
+ *
+ * @param s the detail message.
+ */
+ public BootstrapMethodError(String s) {
+ super(s);
+ }
+
+ /**
+ * Constructs a {@code BootstrapMethodError} with the specified
+ * detail message and cause.
+ *
+ * @param s the detail message.
+ * @param cause the cause, may be {@code null}.
+ */
+ public BootstrapMethodError(String s, Throwable cause) {
+ super(s, cause);
+ }
+
+ /**
+ * Constructs a {@code BootstrapMethodError} with the specified
+ * cause.
+ *
+ * @param cause the cause, may be {@code null}.
+ */
+ public BootstrapMethodError(Throwable cause) {
+ // cf. Throwable(Throwable cause) constructor.
+ super(cause == null ? null : cause.toString());
+ initCause(cause);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.BootstrapMethodError: " + message)
+ : "java.lang.BootstrapMethodError";
+ }
+}
diff --git a/src/main/java/java/lang/CharSequence.java b/src/main/java/java/lang/CharSequence.java
new file mode 100644
index 0000000..4d9ab3f
--- /dev/null
+++ b/src/main/java/java/lang/CharSequence.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import java.util.NoSuchElementException;
+import java.util.PrimitiveIterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.function.IntConsumer;
+import java.util.stream.IntStream;
+import java.util.stream.StreamSupport;
+
+/**
+ * A <tt>CharSequence</tt> is a readable sequence of <code>char</code> values. This
+ * interface provides uniform, read-only access to many different kinds of
+ * <code>char</code> sequences.
+ * A <code>char</code> value represents a character in the <i>Basic
+ * Multilingual Plane (BMP)</i> or a surrogate. Refer to <a
+ * href="Character.html#unicode">Unicode Character Representation</a> for details.
+ *
+ * <p> This interface does not refine the general contracts of the {@link
+ * java.lang.Object#equals(java.lang.Object) equals} and {@link
+ * java.lang.Object#hashCode() hashCode} methods. The result of comparing two
+ * objects that implement <tt>CharSequence</tt> is therefore, in general,
+ * undefined. Each object may be implemented by a different class, and there
+ * is no guarantee that each class will be capable of testing its instances
+ * for equality with those of the other. It is therefore inappropriate to use
+ * arbitrary <tt>CharSequence</tt> instances as elements in a set or as keys in
+ * a map. </p>
+ *
+ * @author Mike McCloskey
+ * @since 1.4
+ * @spec JSR-51
+ */
+
+public interface CharSequence {
+
+ /**
+ * Returns the length of this character sequence. The length is the number
+ * of 16-bit <code>char</code>s in the sequence.
+ *
+ * @return the number of <code>char</code>s in this sequence
+ */
+ int length();
+
+ /**
+ * Returns the <code>char</code> value at the specified index. An index ranges from zero
+ * to <tt>length() - 1</tt>. The first <code>char</code> value of the sequence is at
+ * index zero, the next at index one, and so on, as for array
+ * indexing.
+ *
+ * <p>If the <code>char</code> value specified by the index is a
+ * <a href="{@docRoot}/java/lang/Character.html#unicode">surrogate</a>, the surrogate
+ * value is returned.
+ *
+ * @param index the index of the <code>char</code> value to be returned
+ *
+ * @return the specified <code>char</code> value
+ *
+ * @throws IndexOutOfBoundsException
+ * if the <tt>index</tt> argument is negative or not less than
+ * <tt>length()</tt>
+ */
+ char charAt(int index);
+
+ /**
+ * Returns a <code>CharSequence</code> that is a subsequence of this sequence.
+ * The subsequence starts with the <code>char</code> value at the specified index and
+ * ends with the <code>char</code> value at index <tt>end - 1</tt>. The length
+ * (in <code>char</code>s) of the
+ * returned sequence is <tt>end - start</tt>, so if <tt>start == end</tt>
+ * then an empty sequence is returned.
+ *
+ * @param start the start index, inclusive
+ * @param end the end index, exclusive
+ *
+ * @return the specified subsequence
+ *
+ * @throws IndexOutOfBoundsException
+ * if <tt>start</tt> or <tt>end</tt> are negative,
+ * if <tt>end</tt> is greater than <tt>length()</tt>,
+ * or if <tt>start</tt> is greater than <tt>end</tt>
+ */
+ CharSequence subSequence(int start, int end);
+
+ /**
+ * Returns a string containing the characters in this sequence in the same
+ * order as this sequence. The length of the string will be the length of
+ * this sequence.
+ *
+ * @return a string consisting of exactly this sequence of characters
+ */
+ public String toString();
+
+ /**
+ * Returns a stream of {@code int} zero-extending the {@code char} values
+ * from this sequence. Any char which maps to a <a
+ * href="{@docRoot}/java/lang/Character.html#unicode">surrogate code
+ * point</a> is passed through uninterpreted.
+ *
+ * <p>If the sequence is mutated while the stream is being read, the
+ * result is undefined.
+ *
+ * @return an IntStream of char values from this sequence
+ * @since 1.8
+ */
+ public default IntStream chars() {
+ class CharIterator implements PrimitiveIterator.OfInt {
+ int cur = 0;
+
+ public boolean hasNext() {
+ return cur < length();
+ }
+
+ public int nextInt() {
+ if (hasNext()) {
+ return charAt(cur++);
+ } else {
+ throw new NoSuchElementException();
+ }
+ }
+
+ @Override
+ public void forEachRemaining(IntConsumer block) {
+ for (; cur < length(); cur++) {
+ block.accept(charAt(cur));
+ }
+ }
+ }
+
+ return StreamSupport.intStream(() ->
+ Spliterators.spliterator(
+ new CharIterator(),
+ length(),
+ Spliterator.ORDERED),
+ Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
+ false);
+ }
+
+ /**
+ * Returns a stream of code point values from this sequence. Any surrogate
+ * pairs encountered in the sequence are combined as if by {@linkplain
+ * Character#toCodePoint Character.toCodePoint} and the result is passed
+ * to the stream. Any other code units, including ordinary BMP characters,
+ * unpaired surrogates, and undefined code units, are zero-extended to
+ * {@code int} values which are then passed to the stream.
+ *
+ * <p>If the sequence is mutated while the stream is being read, the result
+ * is undefined.
+ *
+ * @return an IntStream of Unicode code points from this sequence
+ * @since 1.8
+ */
+ public default IntStream codePoints() {
+ class CodePointIterator implements PrimitiveIterator.OfInt {
+ int cur = 0;
+
+ @Override
+ public void forEachRemaining(IntConsumer block) {
+ final int length = length();
+ int i = cur;
+ try {
+ while (i < length) {
+ char c1 = charAt(i++);
+ if (!Character.isHighSurrogate(c1) || i >= length) {
+ block.accept(c1);
+ } else {
+ char c2 = charAt(i);
+ if (Character.isLowSurrogate(c2)) {
+ i++;
+ block.accept(Character.toCodePoint(c1, c2));
+ } else {
+ block.accept(c1);
+ }
+ }
+ }
+ } finally {
+ cur = i;
+ }
+ }
+
+ public boolean hasNext() {
+ return cur < length();
+ }
+
+ public int nextInt() {
+ final int length = length();
+
+ if (cur >= length) {
+ throw new NoSuchElementException();
+ }
+ char c1 = charAt(cur++);
+ if (Character.isHighSurrogate(c1) && cur < length) {
+ char c2 = charAt(cur);
+ if (Character.isLowSurrogate(c2)) {
+ cur++;
+ return Character.toCodePoint(c1, c2);
+ }
+ }
+ return c1;
+ }
+ }
+
+ return StreamSupport.intStream(() ->
+ Spliterators.spliteratorUnknownSize(
+ new CodePointIterator(),
+ Spliterator.ORDERED),
+ Spliterator.ORDERED,
+ false);
+ }
+}
diff --git a/src/main/java/java/lang/Character.java b/src/main/java/java/lang/Character.java
new file mode 100644
index 0000000..c1d3f7a
--- /dev/null
+++ b/src/main/java/java/lang/Character.java
@@ -0,0 +1,7235 @@
+/*
+ * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Locale;
+
+/**
+ * The {@code Character} class wraps a value of the primitive
+ * type {@code char} in an object. An object of type
+ * {@code Character} contains a single field whose type is
+ * {@code char}.
+ * <p>
+ * In addition, this class provides several methods for determining
+ * a character's category (lowercase letter, digit, etc.) and for converting
+ * characters from uppercase to lowercase and vice versa.
+ * <p>
+ * Character information is based on the Unicode Standard, version 6.2.0.
+ * <p>
+ * The methods and data of class {@code Character} are defined by
+ * the information in the <i>UnicodeData</i> file that is part of the
+ * Unicode Character Database maintained by the Unicode
+ * Consortium. This file specifies various properties including name
+ * and general category for every defined Unicode code point or
+ * character range.
+ * <p>
+ * The file and its description are available from the Unicode Consortium at:
+ * <ul>
+ * <li><a href="http://www.unicode.org">http://www.unicode.org</a>
+ * </ul>
+ *
+ * <h3><a name="unicode">Unicode Character Representations</a></h3>
+ *
+ * <p>The {@code char} data type (and therefore the value that a
+ * {@code Character} object encapsulates) are based on the
+ * original Unicode specification, which defined characters as
+ * fixed-width 16-bit entities. The Unicode Standard has since been
+ * changed to allow for characters whose representation requires more
+ * than 16 bits. The range of legal <em>code point</em>s is now
+ * U+0000 to U+10FFFF, known as <em>Unicode scalar value</em>.
+ * (Refer to the <a
+ * href="http://www.unicode.org/reports/tr27/#notation"><i>
+ * definition</i></a> of the U+<i>n</i> notation in the Unicode
+ * Standard.)
+ *
+ * <p><a name="BMP">The set of characters from U+0000 to U+FFFF</a> is
+ * sometimes referred to as the <em>Basic Multilingual Plane (BMP)</em>.
+ * <a name="supplementary">Characters</a> whose code points are greater
+ * than U+FFFF are called <em>supplementary character</em>s. The Java
+ * platform uses the UTF-16 representation in {@code char} arrays and
+ * in the {@code String} and {@code StringBuffer} classes. In
+ * this representation, supplementary characters are represented as a pair
+ * of {@code char} values, the first from the <em>high-surrogates</em>
+ * range, (\uD800-\uDBFF), the second from the
+ * <em>low-surrogates</em> range (\uDC00-\uDFFF).
+ *
+ * <p>A {@code char} value, therefore, represents Basic
+ * Multilingual Plane (BMP) code points, including the surrogate
+ * code points, or code units of the UTF-16 encoding. An
+ * {@code int} value represents all Unicode code points,
+ * including supplementary code points. The lower (least significant)
+ * 21 bits of {@code int} are used to represent Unicode code
+ * points and the upper (most significant) 11 bits must be zero.
+ * Unless otherwise specified, the behavior with respect to
+ * supplementary characters and surrogate {@code char} values is
+ * as follows:
+ *
+ * <ul>
+ * <li>The methods that only accept a {@code char} value cannot support
+ * supplementary characters. They treat {@code char} values from the
+ * surrogate ranges as undefined characters. For example,
+ * {@code Character.isLetter('\u005CuD840')} returns {@code false}, even though
+ * this specific value if followed by any low-surrogate value in a string
+ * would represent a letter.
+ *
+ * <li>The methods that accept an {@code int} value support all
+ * Unicode characters, including supplementary characters. For
+ * example, {@code Character.isLetter(0x2F81A)} returns
+ * {@code true} because the code point value represents a letter
+ * (a CJK ideograph).
+ * </ul>
+ *
+ * <p>In the Java SE API documentation, <em>Unicode code point</em> is
+ * used for character values in the range between U+0000 and U+10FFFF,
+ * and <em>Unicode code unit</em> is used for 16-bit
+ * {@code char} values that are code units of the <em>UTF-16</em>
+ * encoding. For more information on Unicode terminology, refer to the
+ * <a href="http://www.unicode.org/glossary/">Unicode Glossary</a>.
+ *
+ * @author Lee Boynton
+ * @author Guy Steele
+ * @author Akira Tanaka
+ * @author Martin Buchholz
+ * @author Ulf Zibis
+ * @since 1.0
+ */
+public final
+class Character implements java.io.Serializable, Comparable<Character> {
+ /**
+ * The minimum radix available for conversion to and from strings.
+ * The constant value of this field is the smallest value permitted
+ * for the radix argument in radix-conversion methods such as the
+ * {@code digit} method, the {@code forDigit} method, and the
+ * {@code toString} method of class {@code Integer}.
+ *
+ * @see Character#digit(char, int)
+ * @see Character#forDigit(int, int)
+ * @see Integer#toString(int, int)
+ * @see Integer#valueOf(String)
+ */
+ public static final int MIN_RADIX = 2;
+
+ /**
+ * The maximum radix available for conversion to and from strings.
+ * The constant value of this field is the largest value permitted
+ * for the radix argument in radix-conversion methods such as the
+ * {@code digit} method, the {@code forDigit} method, and the
+ * {@code toString} method of class {@code Integer}.
+ *
+ * @see Character#digit(char, int)
+ * @see Character#forDigit(int, int)
+ * @see Integer#toString(int, int)
+ * @see Integer#valueOf(String)
+ */
+ public static final int MAX_RADIX = 36;
+
+ /**
+ * The constant value of this field is the smallest value of type
+ * {@code char}, {@code '\u005Cu0000'}.
+ *
+ * @since 1.0.2
+ */
+ public static final char MIN_VALUE = '\u0000';
+
+ /**
+ * The constant value of this field is the largest value of type
+ * {@code char}, {@code '\u005CuFFFF'}.
+ *
+ * @since 1.0.2
+ */
+ public static final char MAX_VALUE = '\uFFFF';
+
+ /**
+ * The {@code Class} instance representing the primitive type
+ * {@code char}.
+ *
+ * @since 1.1
+ */
+ @SuppressWarnings("unchecked")
+ public static final Class<Character> TYPE = (Class<Character>) Class.getPrimitiveClass("char");
+
+ /*
+ * Normative general types
+ */
+
+ /*
+ * General character types
+ */
+
+ /**
+ * General category "Cn" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte UNASSIGNED = 0;
+
+ /**
+ * General category "Lu" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte UPPERCASE_LETTER = 1;
+
+ /**
+ * General category "Ll" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte LOWERCASE_LETTER = 2;
+
+ /**
+ * General category "Lt" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte TITLECASE_LETTER = 3;
+
+ /**
+ * General category "Lm" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte MODIFIER_LETTER = 4;
+
+ /**
+ * General category "Lo" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte OTHER_LETTER = 5;
+
+ /**
+ * General category "Mn" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte NON_SPACING_MARK = 6;
+
+ /**
+ * General category "Me" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte ENCLOSING_MARK = 7;
+
+ /**
+ * General category "Mc" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte COMBINING_SPACING_MARK = 8;
+
+ /**
+ * General category "Nd" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte DECIMAL_DIGIT_NUMBER = 9;
+
+ /**
+ * General category "Nl" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte LETTER_NUMBER = 10;
+
+ /**
+ * General category "No" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte OTHER_NUMBER = 11;
+
+ /**
+ * General category "Zs" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte SPACE_SEPARATOR = 12;
+
+ /**
+ * General category "Zl" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte LINE_SEPARATOR = 13;
+
+ /**
+ * General category "Zp" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte PARAGRAPH_SEPARATOR = 14;
+
+ /**
+ * General category "Cc" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte CONTROL = 15;
+
+ /**
+ * General category "Cf" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte FORMAT = 16;
+
+ /**
+ * General category "Co" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte PRIVATE_USE = 18;
+
+ /**
+ * General category "Cs" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte SURROGATE = 19;
+
+ /**
+ * General category "Pd" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte DASH_PUNCTUATION = 20;
+
+ /**
+ * General category "Ps" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte START_PUNCTUATION = 21;
+
+ /**
+ * General category "Pe" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte END_PUNCTUATION = 22;
+
+ /**
+ * General category "Pc" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte CONNECTOR_PUNCTUATION = 23;
+
+ /**
+ * General category "Po" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte OTHER_PUNCTUATION = 24;
+
+ /**
+ * General category "Sm" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte MATH_SYMBOL = 25;
+
+ /**
+ * General category "Sc" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte CURRENCY_SYMBOL = 26;
+
+ /**
+ * General category "Sk" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte MODIFIER_SYMBOL = 27;
+
+ /**
+ * General category "So" in the Unicode specification.
+ * @since 1.1
+ */
+ public static final byte OTHER_SYMBOL = 28;
+
+ /**
+ * General category "Pi" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte INITIAL_QUOTE_PUNCTUATION = 29;
+
+ /**
+ * General category "Pf" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte FINAL_QUOTE_PUNCTUATION = 30;
+
+ /**
+ * Error flag. Use int (code point) to avoid confusion with U+FFFF.
+ */
+ static final int ERROR = 0xFFFFFFFF;
+
+
+ /**
+ * Undefined bidirectional character type. Undefined {@code char}
+ * values have undefined directionality in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_UNDEFINED = -1;
+
+ /**
+ * Strong bidirectional character type "L" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_LEFT_TO_RIGHT = 0;
+
+ /**
+ * Strong bidirectional character type "R" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT = 1;
+
+ /**
+ * Strong bidirectional character type "AL" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC = 2;
+
+ /**
+ * Weak bidirectional character type "EN" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_EUROPEAN_NUMBER = 3;
+
+ /**
+ * Weak bidirectional character type "ES" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR = 4;
+
+ /**
+ * Weak bidirectional character type "ET" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR = 5;
+
+ /**
+ * Weak bidirectional character type "AN" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_ARABIC_NUMBER = 6;
+
+ /**
+ * Weak bidirectional character type "CS" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_COMMON_NUMBER_SEPARATOR = 7;
+
+ /**
+ * Weak bidirectional character type "NSM" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_NONSPACING_MARK = 8;
+
+ /**
+ * Weak bidirectional character type "BN" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_BOUNDARY_NEUTRAL = 9;
+
+ /**
+ * Neutral bidirectional character type "B" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_PARAGRAPH_SEPARATOR = 10;
+
+ /**
+ * Neutral bidirectional character type "S" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_SEGMENT_SEPARATOR = 11;
+
+ /**
+ * Neutral bidirectional character type "WS" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_WHITESPACE = 12;
+
+ /**
+ * Neutral bidirectional character type "ON" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_OTHER_NEUTRALS = 13;
+
+ /**
+ * Strong bidirectional character type "LRE" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING = 14;
+
+ /**
+ * Strong bidirectional character type "LRO" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE = 15;
+
+ /**
+ * Strong bidirectional character type "RLE" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING = 16;
+
+ /**
+ * Strong bidirectional character type "RLO" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE = 17;
+
+ /**
+ * Weak bidirectional character type "PDF" in the Unicode specification.
+ * @since 1.4
+ */
+ public static final byte DIRECTIONALITY_POP_DIRECTIONAL_FORMAT = 18;
+
+ /**
+ * The minimum value of a
+ * <a href="http://www.unicode.org/glossary/#high_surrogate_code_unit">
+ * Unicode high-surrogate code unit</a>
+ * in the UTF-16 encoding, constant {@code '\u005CuD800'}.
+ * A high-surrogate is also known as a <i>leading-surrogate</i>.
+ *
+ * @since 1.5
+ */
+ public static final char MIN_HIGH_SURROGATE = '\uD800';
+
+ /**
+ * The maximum value of a
+ * <a href="http://www.unicode.org/glossary/#high_surrogate_code_unit">
+ * Unicode high-surrogate code unit</a>
+ * in the UTF-16 encoding, constant {@code '\u005CuDBFF'}.
+ * A high-surrogate is also known as a <i>leading-surrogate</i>.
+ *
+ * @since 1.5
+ */
+ public static final char MAX_HIGH_SURROGATE = '\uDBFF';
+
+ /**
+ * The minimum value of a
+ * <a href="http://www.unicode.org/glossary/#low_surrogate_code_unit">
+ * Unicode low-surrogate code unit</a>
+ * in the UTF-16 encoding, constant {@code '\u005CuDC00'}.
+ * A low-surrogate is also known as a <i>trailing-surrogate</i>.
+ *
+ * @since 1.5
+ */
+ public static final char MIN_LOW_SURROGATE = '\uDC00';
+
+ /**
+ * The maximum value of a
+ * <a href="http://www.unicode.org/glossary/#low_surrogate_code_unit">
+ * Unicode low-surrogate code unit</a>
+ * in the UTF-16 encoding, constant {@code '\u005CuDFFF'}.
+ * A low-surrogate is also known as a <i>trailing-surrogate</i>.
+ *
+ * @since 1.5
+ */
+ public static final char MAX_LOW_SURROGATE = '\uDFFF';
+
+ /**
+ * The minimum value of a Unicode surrogate code unit in the
+ * UTF-16 encoding, constant {@code '\u005CuD800'}.
+ *
+ * @since 1.5
+ */
+ public static final char MIN_SURROGATE = MIN_HIGH_SURROGATE;
+
+ /**
+ * The maximum value of a Unicode surrogate code unit in the
+ * UTF-16 encoding, constant {@code '\u005CuDFFF'}.
+ *
+ * @since 1.5
+ */
+ public static final char MAX_SURROGATE = MAX_LOW_SURROGATE;
+
+ /**
+ * The minimum value of a
+ * <a href="http://www.unicode.org/glossary/#supplementary_code_point">
+ * Unicode supplementary code point</a>, constant {@code U+10000}.
+ *
+ * @since 1.5
+ */
+ public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;
+
+ /**
+ * The minimum value of a
+ * <a href="http://www.unicode.org/glossary/#code_point">
+ * Unicode code point</a>, constant {@code U+0000}.
+ *
+ * @since 1.5
+ */
+ public static final int MIN_CODE_POINT = 0x000000;
+
+ /**
+ * The maximum value of a
+ * <a href="http://www.unicode.org/glossary/#code_point">
+ * Unicode code point</a>, constant {@code U+10FFFF}.
+ *
+ * @since 1.5
+ */
+ public static final int MAX_CODE_POINT = 0X10FFFF;
+
+
+ /**
+ * Instances of this class represent particular subsets of the Unicode
+ * character set. The only family of subsets defined in the
+ * {@code Character} class is {@link Character.UnicodeBlock}.
+ * Other portions of the Java API may define other subsets for their
+ * own purposes.
+ *
+ * @since 1.2
+ */
+ public static class Subset {
+
+ private String name;
+
+ /**
+ * Constructs a new {@code Subset} instance.
+ *
+ * @param name The name of this subset
+ * @exception NullPointerException if name is {@code null}
+ */
+ protected Subset(String name) {
+ if (name == null) {
+ throw new NullPointerException("name");
+ }
+ this.name = name;
+ }
+
+ /**
+ * Compares two {@code Subset} objects for equality.
+ * This method returns {@code true} if and only if
+ * {@code this} and the argument refer to the same
+ * object; since this method is {@code final}, this
+ * guarantee holds for all subclasses.
+ */
+ public final boolean equals(Object obj) {
+ return (this == obj);
+ }
+
+ /**
+ * Returns the standard hash code as defined by the
+ * {@link Object#hashCode} method. This method
+ * is {@code final} in order to ensure that the
+ * {@code equals} and {@code hashCode} methods will
+ * be consistent in all subclasses.
+ */
+ public final int hashCode() {
+ return super.hashCode();
+ }
+
+ /**
+ * Returns the name of this subset.
+ */
+ public final String toString() {
+ return name;
+ }
+ }
+
+ // See http://www.unicode.org/Public/UNIDATA/Blocks.txt
+ // for the latest specification of Unicode Blocks.
+
+ /**
+ * A family of character subsets representing the character blocks in the
+ * Unicode specification. Character blocks generally define characters
+ * used for a specific script or purpose. A character is contained by
+ * at most one Unicode block.
+ *
+ * @since 1.2
+ */
+ public static final class UnicodeBlock extends Subset {
+
+ private static Map<String, UnicodeBlock> map = new HashMap<>(256);
+
+ /**
+ * Creates a UnicodeBlock with the given identifier name.
+ * This name must be the same as the block identifier.
+ */
+ private UnicodeBlock(String idName) {
+ super(idName);
+ map.put(idName, this);
+ }
+
+ /**
+ * Creates a UnicodeBlock with the given identifier name and
+ * alias name.
+ */
+ private UnicodeBlock(String idName, String alias) {
+ this(idName);
+ map.put(alias, this);
+ }
+
+ /**
+ * Creates a UnicodeBlock with the given identifier name and
+ * alias names.
+ */
+ private UnicodeBlock(String idName, String... aliases) {
+ this(idName);
+ for (String alias : aliases)
+ map.put(alias, this);
+ }
+
+ /**
+ * Constant for the "Basic Latin" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BASIC_LATIN =
+ new UnicodeBlock("BASIC_LATIN",
+ "BASIC LATIN",
+ "BASICLATIN");
+
+ /**
+ * Constant for the "Latin-1 Supplement" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LATIN_1_SUPPLEMENT =
+ new UnicodeBlock("LATIN_1_SUPPLEMENT",
+ "LATIN-1 SUPPLEMENT",
+ "LATIN-1SUPPLEMENT");
+
+ /**
+ * Constant for the "Latin Extended-A" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LATIN_EXTENDED_A =
+ new UnicodeBlock("LATIN_EXTENDED_A",
+ "LATIN EXTENDED-A",
+ "LATINEXTENDED-A");
+
+ /**
+ * Constant for the "Latin Extended-B" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LATIN_EXTENDED_B =
+ new UnicodeBlock("LATIN_EXTENDED_B",
+ "LATIN EXTENDED-B",
+ "LATINEXTENDED-B");
+
+ /**
+ * Constant for the "IPA Extensions" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock IPA_EXTENSIONS =
+ new UnicodeBlock("IPA_EXTENSIONS",
+ "IPA EXTENSIONS",
+ "IPAEXTENSIONS");
+
+ /**
+ * Constant for the "Spacing Modifier Letters" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock SPACING_MODIFIER_LETTERS =
+ new UnicodeBlock("SPACING_MODIFIER_LETTERS",
+ "SPACING MODIFIER LETTERS",
+ "SPACINGMODIFIERLETTERS");
+
+ /**
+ * Constant for the "Combining Diacritical Marks" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock COMBINING_DIACRITICAL_MARKS =
+ new UnicodeBlock("COMBINING_DIACRITICAL_MARKS",
+ "COMBINING DIACRITICAL MARKS",
+ "COMBININGDIACRITICALMARKS");
+
+ /**
+ * Constant for the "Greek and Coptic" Unicode character block.
+ * <p>
+ * This block was previously known as the "Greek" block.
+ *
+ * @since 1.2
+ */
+ public static final UnicodeBlock GREEK =
+ new UnicodeBlock("GREEK",
+ "GREEK AND COPTIC",
+ "GREEKANDCOPTIC");
+
+ /**
+ * Constant for the "Cyrillic" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CYRILLIC =
+ new UnicodeBlock("CYRILLIC");
+
+ /**
+ * Constant for the "Armenian" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARMENIAN =
+ new UnicodeBlock("ARMENIAN");
+
+ /**
+ * Constant for the "Hebrew" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HEBREW =
+ new UnicodeBlock("HEBREW");
+
+ /**
+ * Constant for the "Arabic" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARABIC =
+ new UnicodeBlock("ARABIC");
+
+ /**
+ * Constant for the "Devanagari" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock DEVANAGARI =
+ new UnicodeBlock("DEVANAGARI");
+
+ /**
+ * Constant for the "Bengali" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BENGALI =
+ new UnicodeBlock("BENGALI");
+
+ /**
+ * Constant for the "Gurmukhi" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GURMUKHI =
+ new UnicodeBlock("GURMUKHI");
+
+ /**
+ * Constant for the "Gujarati" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GUJARATI =
+ new UnicodeBlock("GUJARATI");
+
+ /**
+ * Constant for the "Oriya" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ORIYA =
+ new UnicodeBlock("ORIYA");
+
+ /**
+ * Constant for the "Tamil" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock TAMIL =
+ new UnicodeBlock("TAMIL");
+
+ /**
+ * Constant for the "Telugu" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock TELUGU =
+ new UnicodeBlock("TELUGU");
+
+ /**
+ * Constant for the "Kannada" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock KANNADA =
+ new UnicodeBlock("KANNADA");
+
+ /**
+ * Constant for the "Malayalam" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock MALAYALAM =
+ new UnicodeBlock("MALAYALAM");
+
+ /**
+ * Constant for the "Thai" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock THAI =
+ new UnicodeBlock("THAI");
+
+ /**
+ * Constant for the "Lao" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LAO =
+ new UnicodeBlock("LAO");
+
+ /**
+ * Constant for the "Tibetan" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock TIBETAN =
+ new UnicodeBlock("TIBETAN");
+
+ /**
+ * Constant for the "Georgian" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GEORGIAN =
+ new UnicodeBlock("GEORGIAN");
+
+ /**
+ * Constant for the "Hangul Jamo" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HANGUL_JAMO =
+ new UnicodeBlock("HANGUL_JAMO",
+ "HANGUL JAMO",
+ "HANGULJAMO");
+
+ /**
+ * Constant for the "Latin Extended Additional" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LATIN_EXTENDED_ADDITIONAL =
+ new UnicodeBlock("LATIN_EXTENDED_ADDITIONAL",
+ "LATIN EXTENDED ADDITIONAL",
+ "LATINEXTENDEDADDITIONAL");
+
+ /**
+ * Constant for the "Greek Extended" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GREEK_EXTENDED =
+ new UnicodeBlock("GREEK_EXTENDED",
+ "GREEK EXTENDED",
+ "GREEKEXTENDED");
+
+ /**
+ * Constant for the "General Punctuation" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GENERAL_PUNCTUATION =
+ new UnicodeBlock("GENERAL_PUNCTUATION",
+ "GENERAL PUNCTUATION",
+ "GENERALPUNCTUATION");
+
+ /**
+ * Constant for the "Superscripts and Subscripts" Unicode character
+ * block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock SUPERSCRIPTS_AND_SUBSCRIPTS =
+ new UnicodeBlock("SUPERSCRIPTS_AND_SUBSCRIPTS",
+ "SUPERSCRIPTS AND SUBSCRIPTS",
+ "SUPERSCRIPTSANDSUBSCRIPTS");
+
+ /**
+ * Constant for the "Currency Symbols" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CURRENCY_SYMBOLS =
+ new UnicodeBlock("CURRENCY_SYMBOLS",
+ "CURRENCY SYMBOLS",
+ "CURRENCYSYMBOLS");
+
+ /**
+ * Constant for the "Combining Diacritical Marks for Symbols" Unicode
+ * character block.
+ * <p>
+ * This block was previously known as "Combining Marks for Symbols".
+ * @since 1.2
+ */
+ public static final UnicodeBlock COMBINING_MARKS_FOR_SYMBOLS =
+ new UnicodeBlock("COMBINING_MARKS_FOR_SYMBOLS",
+ "COMBINING DIACRITICAL MARKS FOR SYMBOLS",
+ "COMBININGDIACRITICALMARKSFORSYMBOLS",
+ "COMBINING MARKS FOR SYMBOLS",
+ "COMBININGMARKSFORSYMBOLS");
+
+ /**
+ * Constant for the "Letterlike Symbols" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock LETTERLIKE_SYMBOLS =
+ new UnicodeBlock("LETTERLIKE_SYMBOLS",
+ "LETTERLIKE SYMBOLS",
+ "LETTERLIKESYMBOLS");
+
+ /**
+ * Constant for the "Number Forms" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock NUMBER_FORMS =
+ new UnicodeBlock("NUMBER_FORMS",
+ "NUMBER FORMS",
+ "NUMBERFORMS");
+
+ /**
+ * Constant for the "Arrows" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARROWS =
+ new UnicodeBlock("ARROWS");
+
+ /**
+ * Constant for the "Mathematical Operators" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock MATHEMATICAL_OPERATORS =
+ new UnicodeBlock("MATHEMATICAL_OPERATORS",
+ "MATHEMATICAL OPERATORS",
+ "MATHEMATICALOPERATORS");
+
+ /**
+ * Constant for the "Miscellaneous Technical" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock MISCELLANEOUS_TECHNICAL =
+ new UnicodeBlock("MISCELLANEOUS_TECHNICAL",
+ "MISCELLANEOUS TECHNICAL",
+ "MISCELLANEOUSTECHNICAL");
+
+ /**
+ * Constant for the "Control Pictures" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CONTROL_PICTURES =
+ new UnicodeBlock("CONTROL_PICTURES",
+ "CONTROL PICTURES",
+ "CONTROLPICTURES");
+
+ /**
+ * Constant for the "Optical Character Recognition" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock OPTICAL_CHARACTER_RECOGNITION =
+ new UnicodeBlock("OPTICAL_CHARACTER_RECOGNITION",
+ "OPTICAL CHARACTER RECOGNITION",
+ "OPTICALCHARACTERRECOGNITION");
+
+ /**
+ * Constant for the "Enclosed Alphanumerics" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ENCLOSED_ALPHANUMERICS =
+ new UnicodeBlock("ENCLOSED_ALPHANUMERICS",
+ "ENCLOSED ALPHANUMERICS",
+ "ENCLOSEDALPHANUMERICS");
+
+ /**
+ * Constant for the "Box Drawing" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BOX_DRAWING =
+ new UnicodeBlock("BOX_DRAWING",
+ "BOX DRAWING",
+ "BOXDRAWING");
+
+ /**
+ * Constant for the "Block Elements" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BLOCK_ELEMENTS =
+ new UnicodeBlock("BLOCK_ELEMENTS",
+ "BLOCK ELEMENTS",
+ "BLOCKELEMENTS");
+
+ /**
+ * Constant for the "Geometric Shapes" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock GEOMETRIC_SHAPES =
+ new UnicodeBlock("GEOMETRIC_SHAPES",
+ "GEOMETRIC SHAPES",
+ "GEOMETRICSHAPES");
+
+ /**
+ * Constant for the "Miscellaneous Symbols" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock MISCELLANEOUS_SYMBOLS =
+ new UnicodeBlock("MISCELLANEOUS_SYMBOLS",
+ "MISCELLANEOUS SYMBOLS",
+ "MISCELLANEOUSSYMBOLS");
+
+ /**
+ * Constant for the "Dingbats" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock DINGBATS =
+ new UnicodeBlock("DINGBATS");
+
+ /**
+ * Constant for the "CJK Symbols and Punctuation" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_SYMBOLS_AND_PUNCTUATION =
+ new UnicodeBlock("CJK_SYMBOLS_AND_PUNCTUATION",
+ "CJK SYMBOLS AND PUNCTUATION",
+ "CJKSYMBOLSANDPUNCTUATION");
+
+ /**
+ * Constant for the "Hiragana" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HIRAGANA =
+ new UnicodeBlock("HIRAGANA");
+
+ /**
+ * Constant for the "Katakana" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock KATAKANA =
+ new UnicodeBlock("KATAKANA");
+
+ /**
+ * Constant for the "Bopomofo" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock BOPOMOFO =
+ new UnicodeBlock("BOPOMOFO");
+
+ /**
+ * Constant for the "Hangul Compatibility Jamo" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HANGUL_COMPATIBILITY_JAMO =
+ new UnicodeBlock("HANGUL_COMPATIBILITY_JAMO",
+ "HANGUL COMPATIBILITY JAMO",
+ "HANGULCOMPATIBILITYJAMO");
+
+ /**
+ * Constant for the "Kanbun" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock KANBUN =
+ new UnicodeBlock("KANBUN");
+
+ /**
+ * Constant for the "Enclosed CJK Letters and Months" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ENCLOSED_CJK_LETTERS_AND_MONTHS =
+ new UnicodeBlock("ENCLOSED_CJK_LETTERS_AND_MONTHS",
+ "ENCLOSED CJK LETTERS AND MONTHS",
+ "ENCLOSEDCJKLETTERSANDMONTHS");
+
+ /**
+ * Constant for the "CJK Compatibility" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_COMPATIBILITY =
+ new UnicodeBlock("CJK_COMPATIBILITY",
+ "CJK COMPATIBILITY",
+ "CJKCOMPATIBILITY");
+
+ /**
+ * Constant for the "CJK Unified Ideographs" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS =
+ new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS",
+ "CJK UNIFIED IDEOGRAPHS",
+ "CJKUNIFIEDIDEOGRAPHS");
+
+ /**
+ * Constant for the "Hangul Syllables" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HANGUL_SYLLABLES =
+ new UnicodeBlock("HANGUL_SYLLABLES",
+ "HANGUL SYLLABLES",
+ "HANGULSYLLABLES");
+
+ /**
+ * Constant for the "Private Use Area" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock PRIVATE_USE_AREA =
+ new UnicodeBlock("PRIVATE_USE_AREA",
+ "PRIVATE USE AREA",
+ "PRIVATEUSEAREA");
+
+ /**
+ * Constant for the "CJK Compatibility Ideographs" Unicode character
+ * block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS =
+ new UnicodeBlock("CJK_COMPATIBILITY_IDEOGRAPHS",
+ "CJK COMPATIBILITY IDEOGRAPHS",
+ "CJKCOMPATIBILITYIDEOGRAPHS");
+
+ /**
+ * Constant for the "Alphabetic Presentation Forms" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ALPHABETIC_PRESENTATION_FORMS =
+ new UnicodeBlock("ALPHABETIC_PRESENTATION_FORMS",
+ "ALPHABETIC PRESENTATION FORMS",
+ "ALPHABETICPRESENTATIONFORMS");
+
+ /**
+ * Constant for the "Arabic Presentation Forms-A" Unicode character
+ * block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_A =
+ new UnicodeBlock("ARABIC_PRESENTATION_FORMS_A",
+ "ARABIC PRESENTATION FORMS-A",
+ "ARABICPRESENTATIONFORMS-A");
+
+ /**
+ * Constant for the "Combining Half Marks" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock COMBINING_HALF_MARKS =
+ new UnicodeBlock("COMBINING_HALF_MARKS",
+ "COMBINING HALF MARKS",
+ "COMBININGHALFMARKS");
+
+ /**
+ * Constant for the "CJK Compatibility Forms" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock CJK_COMPATIBILITY_FORMS =
+ new UnicodeBlock("CJK_COMPATIBILITY_FORMS",
+ "CJK COMPATIBILITY FORMS",
+ "CJKCOMPATIBILITYFORMS");
+
+ /**
+ * Constant for the "Small Form Variants" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock SMALL_FORM_VARIANTS =
+ new UnicodeBlock("SMALL_FORM_VARIANTS",
+ "SMALL FORM VARIANTS",
+ "SMALLFORMVARIANTS");
+
+ /**
+ * Constant for the "Arabic Presentation Forms-B" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock ARABIC_PRESENTATION_FORMS_B =
+ new UnicodeBlock("ARABIC_PRESENTATION_FORMS_B",
+ "ARABIC PRESENTATION FORMS-B",
+ "ARABICPRESENTATIONFORMS-B");
+
+ /**
+ * Constant for the "Halfwidth and Fullwidth Forms" Unicode character
+ * block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock HALFWIDTH_AND_FULLWIDTH_FORMS =
+ new UnicodeBlock("HALFWIDTH_AND_FULLWIDTH_FORMS",
+ "HALFWIDTH AND FULLWIDTH FORMS",
+ "HALFWIDTHANDFULLWIDTHFORMS");
+
+ /**
+ * Constant for the "Specials" Unicode character block.
+ * @since 1.2
+ */
+ public static final UnicodeBlock SPECIALS =
+ new UnicodeBlock("SPECIALS");
+
+ /**
+ * @deprecated As of J2SE 5, use {@link #HIGH_SURROGATES},
+ * {@link #HIGH_PRIVATE_USE_SURROGATES}, and
+ * {@link #LOW_SURROGATES}. These new constants match
+ * the block definitions of the Unicode Standard.
+ * The {@link #of(char)} and {@link #of(int)} methods
+ * return the new constants, not SURROGATES_AREA.
+ */
+ @Deprecated
+ public static final UnicodeBlock SURROGATES_AREA =
+ new UnicodeBlock("SURROGATES_AREA");
+
+ /**
+ * Constant for the "Syriac" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock SYRIAC =
+ new UnicodeBlock("SYRIAC");
+
+ /**
+ * Constant for the "Thaana" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock THAANA =
+ new UnicodeBlock("THAANA");
+
+ /**
+ * Constant for the "Sinhala" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock SINHALA =
+ new UnicodeBlock("SINHALA");
+
+ /**
+ * Constant for the "Myanmar" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock MYANMAR =
+ new UnicodeBlock("MYANMAR");
+
+ /**
+ * Constant for the "Ethiopic" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock ETHIOPIC =
+ new UnicodeBlock("ETHIOPIC");
+
+ /**
+ * Constant for the "Cherokee" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock CHEROKEE =
+ new UnicodeBlock("CHEROKEE");
+
+ /**
+ * Constant for the "Unified Canadian Aboriginal Syllabics" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS =
+ new UnicodeBlock("UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS",
+ "UNIFIED CANADIAN ABORIGINAL SYLLABICS",
+ "UNIFIEDCANADIANABORIGINALSYLLABICS");
+
+ /**
+ * Constant for the "Ogham" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock OGHAM =
+ new UnicodeBlock("OGHAM");
+
+ /**
+ * Constant for the "Runic" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock RUNIC =
+ new UnicodeBlock("RUNIC");
+
+ /**
+ * Constant for the "Khmer" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock KHMER =
+ new UnicodeBlock("KHMER");
+
+ /**
+ * Constant for the "Mongolian" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock MONGOLIAN =
+ new UnicodeBlock("MONGOLIAN");
+
+ /**
+ * Constant for the "Braille Patterns" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock BRAILLE_PATTERNS =
+ new UnicodeBlock("BRAILLE_PATTERNS",
+ "BRAILLE PATTERNS",
+ "BRAILLEPATTERNS");
+
+ /**
+ * Constant for the "CJK Radicals Supplement" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock CJK_RADICALS_SUPPLEMENT =
+ new UnicodeBlock("CJK_RADICALS_SUPPLEMENT",
+ "CJK RADICALS SUPPLEMENT",
+ "CJKRADICALSSUPPLEMENT");
+
+ /**
+ * Constant for the "Kangxi Radicals" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock KANGXI_RADICALS =
+ new UnicodeBlock("KANGXI_RADICALS",
+ "KANGXI RADICALS",
+ "KANGXIRADICALS");
+
+ /**
+ * Constant for the "Ideographic Description Characters" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock IDEOGRAPHIC_DESCRIPTION_CHARACTERS =
+ new UnicodeBlock("IDEOGRAPHIC_DESCRIPTION_CHARACTERS",
+ "IDEOGRAPHIC DESCRIPTION CHARACTERS",
+ "IDEOGRAPHICDESCRIPTIONCHARACTERS");
+
+ /**
+ * Constant for the "Bopomofo Extended" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock BOPOMOFO_EXTENDED =
+ new UnicodeBlock("BOPOMOFO_EXTENDED",
+ "BOPOMOFO EXTENDED",
+ "BOPOMOFOEXTENDED");
+
+ /**
+ * Constant for the "CJK Unified Ideographs Extension A" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A =
+ new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A",
+ "CJK UNIFIED IDEOGRAPHS EXTENSION A",
+ "CJKUNIFIEDIDEOGRAPHSEXTENSIONA");
+
+ /**
+ * Constant for the "Yi Syllables" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock YI_SYLLABLES =
+ new UnicodeBlock("YI_SYLLABLES",
+ "YI SYLLABLES",
+ "YISYLLABLES");
+
+ /**
+ * Constant for the "Yi Radicals" Unicode character block.
+ * @since 1.4
+ */
+ public static final UnicodeBlock YI_RADICALS =
+ new UnicodeBlock("YI_RADICALS",
+ "YI RADICALS",
+ "YIRADICALS");
+
+ /**
+ * Constant for the "Cyrillic Supplementary" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock CYRILLIC_SUPPLEMENTARY =
+ new UnicodeBlock("CYRILLIC_SUPPLEMENTARY",
+ "CYRILLIC SUPPLEMENTARY",
+ "CYRILLICSUPPLEMENTARY",
+ "CYRILLIC SUPPLEMENT",
+ "CYRILLICSUPPLEMENT");
+
+ /**
+ * Constant for the "Tagalog" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAGALOG =
+ new UnicodeBlock("TAGALOG");
+
+ /**
+ * Constant for the "Hanunoo" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock HANUNOO =
+ new UnicodeBlock("HANUNOO");
+
+ /**
+ * Constant for the "Buhid" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock BUHID =
+ new UnicodeBlock("BUHID");
+
+ /**
+ * Constant for the "Tagbanwa" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAGBANWA =
+ new UnicodeBlock("TAGBANWA");
+
+ /**
+ * Constant for the "Limbu" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock LIMBU =
+ new UnicodeBlock("LIMBU");
+
+ /**
+ * Constant for the "Tai Le" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAI_LE =
+ new UnicodeBlock("TAI_LE",
+ "TAI LE",
+ "TAILE");
+
+ /**
+ * Constant for the "Khmer Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock KHMER_SYMBOLS =
+ new UnicodeBlock("KHMER_SYMBOLS",
+ "KHMER SYMBOLS",
+ "KHMERSYMBOLS");
+
+ /**
+ * Constant for the "Phonetic Extensions" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock PHONETIC_EXTENSIONS =
+ new UnicodeBlock("PHONETIC_EXTENSIONS",
+ "PHONETIC EXTENSIONS",
+ "PHONETICEXTENSIONS");
+
+ /**
+ * Constant for the "Miscellaneous Mathematical Symbols-A" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A =
+ new UnicodeBlock("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A",
+ "MISCELLANEOUS MATHEMATICAL SYMBOLS-A",
+ "MISCELLANEOUSMATHEMATICALSYMBOLS-A");
+
+ /**
+ * Constant for the "Supplemental Arrows-A" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTAL_ARROWS_A =
+ new UnicodeBlock("SUPPLEMENTAL_ARROWS_A",
+ "SUPPLEMENTAL ARROWS-A",
+ "SUPPLEMENTALARROWS-A");
+
+ /**
+ * Constant for the "Supplemental Arrows-B" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTAL_ARROWS_B =
+ new UnicodeBlock("SUPPLEMENTAL_ARROWS_B",
+ "SUPPLEMENTAL ARROWS-B",
+ "SUPPLEMENTALARROWS-B");
+
+ /**
+ * Constant for the "Miscellaneous Mathematical Symbols-B" Unicode
+ * character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B =
+ new UnicodeBlock("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B",
+ "MISCELLANEOUS MATHEMATICAL SYMBOLS-B",
+ "MISCELLANEOUSMATHEMATICALSYMBOLS-B");
+
+ /**
+ * Constant for the "Supplemental Mathematical Operators" Unicode
+ * character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTAL_MATHEMATICAL_OPERATORS =
+ new UnicodeBlock("SUPPLEMENTAL_MATHEMATICAL_OPERATORS",
+ "SUPPLEMENTAL MATHEMATICAL OPERATORS",
+ "SUPPLEMENTALMATHEMATICALOPERATORS");
+
+ /**
+ * Constant for the "Miscellaneous Symbols and Arrows" Unicode character
+ * block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MISCELLANEOUS_SYMBOLS_AND_ARROWS =
+ new UnicodeBlock("MISCELLANEOUS_SYMBOLS_AND_ARROWS",
+ "MISCELLANEOUS SYMBOLS AND ARROWS",
+ "MISCELLANEOUSSYMBOLSANDARROWS");
+
+ /**
+ * Constant for the "Katakana Phonetic Extensions" Unicode character
+ * block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock KATAKANA_PHONETIC_EXTENSIONS =
+ new UnicodeBlock("KATAKANA_PHONETIC_EXTENSIONS",
+ "KATAKANA PHONETIC EXTENSIONS",
+ "KATAKANAPHONETICEXTENSIONS");
+
+ /**
+ * Constant for the "Yijing Hexagram Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock YIJING_HEXAGRAM_SYMBOLS =
+ new UnicodeBlock("YIJING_HEXAGRAM_SYMBOLS",
+ "YIJING HEXAGRAM SYMBOLS",
+ "YIJINGHEXAGRAMSYMBOLS");
+
+ /**
+ * Constant for the "Variation Selectors" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock VARIATION_SELECTORS =
+ new UnicodeBlock("VARIATION_SELECTORS",
+ "VARIATION SELECTORS",
+ "VARIATIONSELECTORS");
+
+ /**
+ * Constant for the "Linear B Syllabary" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock LINEAR_B_SYLLABARY =
+ new UnicodeBlock("LINEAR_B_SYLLABARY",
+ "LINEAR B SYLLABARY",
+ "LINEARBSYLLABARY");
+
+ /**
+ * Constant for the "Linear B Ideograms" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock LINEAR_B_IDEOGRAMS =
+ new UnicodeBlock("LINEAR_B_IDEOGRAMS",
+ "LINEAR B IDEOGRAMS",
+ "LINEARBIDEOGRAMS");
+
+ /**
+ * Constant for the "Aegean Numbers" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock AEGEAN_NUMBERS =
+ new UnicodeBlock("AEGEAN_NUMBERS",
+ "AEGEAN NUMBERS",
+ "AEGEANNUMBERS");
+
+ /**
+ * Constant for the "Old Italic" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock OLD_ITALIC =
+ new UnicodeBlock("OLD_ITALIC",
+ "OLD ITALIC",
+ "OLDITALIC");
+
+ /**
+ * Constant for the "Gothic" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock GOTHIC =
+ new UnicodeBlock("GOTHIC");
+
+ /**
+ * Constant for the "Ugaritic" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock UGARITIC =
+ new UnicodeBlock("UGARITIC");
+
+ /**
+ * Constant for the "Deseret" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock DESERET =
+ new UnicodeBlock("DESERET");
+
+ /**
+ * Constant for the "Shavian" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SHAVIAN =
+ new UnicodeBlock("SHAVIAN");
+
+ /**
+ * Constant for the "Osmanya" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock OSMANYA =
+ new UnicodeBlock("OSMANYA");
+
+ /**
+ * Constant for the "Cypriot Syllabary" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock CYPRIOT_SYLLABARY =
+ new UnicodeBlock("CYPRIOT_SYLLABARY",
+ "CYPRIOT SYLLABARY",
+ "CYPRIOTSYLLABARY");
+
+ /**
+ * Constant for the "Byzantine Musical Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock BYZANTINE_MUSICAL_SYMBOLS =
+ new UnicodeBlock("BYZANTINE_MUSICAL_SYMBOLS",
+ "BYZANTINE MUSICAL SYMBOLS",
+ "BYZANTINEMUSICALSYMBOLS");
+
+ /**
+ * Constant for the "Musical Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MUSICAL_SYMBOLS =
+ new UnicodeBlock("MUSICAL_SYMBOLS",
+ "MUSICAL SYMBOLS",
+ "MUSICALSYMBOLS");
+
+ /**
+ * Constant for the "Tai Xuan Jing Symbols" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAI_XUAN_JING_SYMBOLS =
+ new UnicodeBlock("TAI_XUAN_JING_SYMBOLS",
+ "TAI XUAN JING SYMBOLS",
+ "TAIXUANJINGSYMBOLS");
+
+ /**
+ * Constant for the "Mathematical Alphanumeric Symbols" Unicode
+ * character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock MATHEMATICAL_ALPHANUMERIC_SYMBOLS =
+ new UnicodeBlock("MATHEMATICAL_ALPHANUMERIC_SYMBOLS",
+ "MATHEMATICAL ALPHANUMERIC SYMBOLS",
+ "MATHEMATICALALPHANUMERICSYMBOLS");
+
+ /**
+ * Constant for the "CJK Unified Ideographs Extension B" Unicode
+ * character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B =
+ new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B",
+ "CJK UNIFIED IDEOGRAPHS EXTENSION B",
+ "CJKUNIFIEDIDEOGRAPHSEXTENSIONB");
+
+ /**
+ * Constant for the "CJK Compatibility Ideographs Supplement" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT =
+ new UnicodeBlock("CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT",
+ "CJK COMPATIBILITY IDEOGRAPHS SUPPLEMENT",
+ "CJKCOMPATIBILITYIDEOGRAPHSSUPPLEMENT");
+
+ /**
+ * Constant for the "Tags" Unicode character block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock TAGS =
+ new UnicodeBlock("TAGS");
+
+ /**
+ * Constant for the "Variation Selectors Supplement" Unicode character
+ * block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock VARIATION_SELECTORS_SUPPLEMENT =
+ new UnicodeBlock("VARIATION_SELECTORS_SUPPLEMENT",
+ "VARIATION SELECTORS SUPPLEMENT",
+ "VARIATIONSELECTORSSUPPLEMENT");
+
+ /**
+ * Constant for the "Supplementary Private Use Area-A" Unicode character
+ * block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_A =
+ new UnicodeBlock("SUPPLEMENTARY_PRIVATE_USE_AREA_A",
+ "SUPPLEMENTARY PRIVATE USE AREA-A",
+ "SUPPLEMENTARYPRIVATEUSEAREA-A");
+
+ /**
+ * Constant for the "Supplementary Private Use Area-B" Unicode character
+ * block.
+ * @since 1.5
+ */
+ public static final UnicodeBlock SUPPLEMENTARY_PRIVATE_USE_AREA_B =
+ new UnicodeBlock("SUPPLEMENTARY_PRIVATE_USE_AREA_B",
+ "SUPPLEMENTARY PRIVATE USE AREA-B",
+ "SUPPLEMENTARYPRIVATEUSEAREA-B");
+
+ /**
+ * Constant for the "High Surrogates" Unicode character block.
+ * This block represents codepoint values in the high surrogate
+ * range: U+D800 through U+DB7F
+ *
+ * @since 1.5
+ */
+ public static final UnicodeBlock HIGH_SURROGATES =
+ new UnicodeBlock("HIGH_SURROGATES",
+ "HIGH SURROGATES",
+ "HIGHSURROGATES");
+
+ /**
+ * Constant for the "High Private Use Surrogates" Unicode character
+ * block.
+ * This block represents codepoint values in the private use high
+ * surrogate range: U+DB80 through U+DBFF
+ *
+ * @since 1.5
+ */
+ public static final UnicodeBlock HIGH_PRIVATE_USE_SURROGATES =
+ new UnicodeBlock("HIGH_PRIVATE_USE_SURROGATES",
+ "HIGH PRIVATE USE SURROGATES",
+ "HIGHPRIVATEUSESURROGATES");
+
+ /**
+ * Constant for the "Low Surrogates" Unicode character block.
+ * This block represents codepoint values in the low surrogate
+ * range: U+DC00 through U+DFFF
+ *
+ * @since 1.5
+ */
+ public static final UnicodeBlock LOW_SURROGATES =
+ new UnicodeBlock("LOW_SURROGATES",
+ "LOW SURROGATES",
+ "LOWSURROGATES");
+
+ /**
+ * Constant for the "Arabic Supplement" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ARABIC_SUPPLEMENT =
+ new UnicodeBlock("ARABIC_SUPPLEMENT",
+ "ARABIC SUPPLEMENT",
+ "ARABICSUPPLEMENT");
+
+ /**
+ * Constant for the "NKo" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock NKO =
+ new UnicodeBlock("NKO");
+
+ /**
+ * Constant for the "Samaritan" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock SAMARITAN =
+ new UnicodeBlock("SAMARITAN");
+
+ /**
+ * Constant for the "Mandaic" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock MANDAIC =
+ new UnicodeBlock("MANDAIC");
+
+ /**
+ * Constant for the "Ethiopic Supplement" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ETHIOPIC_SUPPLEMENT =
+ new UnicodeBlock("ETHIOPIC_SUPPLEMENT",
+ "ETHIOPIC SUPPLEMENT",
+ "ETHIOPICSUPPLEMENT");
+
+ /**
+ * Constant for the "Unified Canadian Aboriginal Syllabics Extended"
+ * Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED =
+ new UnicodeBlock("UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED",
+ "UNIFIED CANADIAN ABORIGINAL SYLLABICS EXTENDED",
+ "UNIFIEDCANADIANABORIGINALSYLLABICSEXTENDED");
+
+ /**
+ * Constant for the "New Tai Lue" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock NEW_TAI_LUE =
+ new UnicodeBlock("NEW_TAI_LUE",
+ "NEW TAI LUE",
+ "NEWTAILUE");
+
+ /**
+ * Constant for the "Buginese" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock BUGINESE =
+ new UnicodeBlock("BUGINESE");
+
+ /**
+ * Constant for the "Tai Tham" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock TAI_THAM =
+ new UnicodeBlock("TAI_THAM",
+ "TAI THAM",
+ "TAITHAM");
+
+ /**
+ * Constant for the "Balinese" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock BALINESE =
+ new UnicodeBlock("BALINESE");
+
+ /**
+ * Constant for the "Sundanese" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock SUNDANESE =
+ new UnicodeBlock("SUNDANESE");
+
+ /**
+ * Constant for the "Batak" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock BATAK =
+ new UnicodeBlock("BATAK");
+
+ /**
+ * Constant for the "Lepcha" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock LEPCHA =
+ new UnicodeBlock("LEPCHA");
+
+ /**
+ * Constant for the "Ol Chiki" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock OL_CHIKI =
+ new UnicodeBlock("OL_CHIKI",
+ "OL CHIKI",
+ "OLCHIKI");
+
+ /**
+ * Constant for the "Vedic Extensions" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock VEDIC_EXTENSIONS =
+ new UnicodeBlock("VEDIC_EXTENSIONS",
+ "VEDIC EXTENSIONS",
+ "VEDICEXTENSIONS");
+
+ /**
+ * Constant for the "Phonetic Extensions Supplement" Unicode character
+ * block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock PHONETIC_EXTENSIONS_SUPPLEMENT =
+ new UnicodeBlock("PHONETIC_EXTENSIONS_SUPPLEMENT",
+ "PHONETIC EXTENSIONS SUPPLEMENT",
+ "PHONETICEXTENSIONSSUPPLEMENT");
+
+ /**
+ * Constant for the "Combining Diacritical Marks Supplement" Unicode
+ * character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock COMBINING_DIACRITICAL_MARKS_SUPPLEMENT =
+ new UnicodeBlock("COMBINING_DIACRITICAL_MARKS_SUPPLEMENT",
+ "COMBINING DIACRITICAL MARKS SUPPLEMENT",
+ "COMBININGDIACRITICALMARKSSUPPLEMENT");
+
+ /**
+ * Constant for the "Glagolitic" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock GLAGOLITIC =
+ new UnicodeBlock("GLAGOLITIC");
+
+ /**
+ * Constant for the "Latin Extended-C" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock LATIN_EXTENDED_C =
+ new UnicodeBlock("LATIN_EXTENDED_C",
+ "LATIN EXTENDED-C",
+ "LATINEXTENDED-C");
+
+ /**
+ * Constant for the "Coptic" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock COPTIC =
+ new UnicodeBlock("COPTIC");
+
+ /**
+ * Constant for the "Georgian Supplement" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock GEORGIAN_SUPPLEMENT =
+ new UnicodeBlock("GEORGIAN_SUPPLEMENT",
+ "GEORGIAN SUPPLEMENT",
+ "GEORGIANSUPPLEMENT");
+
+ /**
+ * Constant for the "Tifinagh" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock TIFINAGH =
+ new UnicodeBlock("TIFINAGH");
+
+ /**
+ * Constant for the "Ethiopic Extended" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ETHIOPIC_EXTENDED =
+ new UnicodeBlock("ETHIOPIC_EXTENDED",
+ "ETHIOPIC EXTENDED",
+ "ETHIOPICEXTENDED");
+
+ /**
+ * Constant for the "Cyrillic Extended-A" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock CYRILLIC_EXTENDED_A =
+ new UnicodeBlock("CYRILLIC_EXTENDED_A",
+ "CYRILLIC EXTENDED-A",
+ "CYRILLICEXTENDED-A");
+
+ /**
+ * Constant for the "Supplemental Punctuation" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock SUPPLEMENTAL_PUNCTUATION =
+ new UnicodeBlock("SUPPLEMENTAL_PUNCTUATION",
+ "SUPPLEMENTAL PUNCTUATION",
+ "SUPPLEMENTALPUNCTUATION");
+
+ /**
+ * Constant for the "CJK Strokes" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock CJK_STROKES =
+ new UnicodeBlock("CJK_STROKES",
+ "CJK STROKES",
+ "CJKSTROKES");
+
+ /**
+ * Constant for the "Lisu" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock LISU =
+ new UnicodeBlock("LISU");
+
+ /**
+ * Constant for the "Vai" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock VAI =
+ new UnicodeBlock("VAI");
+
+ /**
+ * Constant for the "Cyrillic Extended-B" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock CYRILLIC_EXTENDED_B =
+ new UnicodeBlock("CYRILLIC_EXTENDED_B",
+ "CYRILLIC EXTENDED-B",
+ "CYRILLICEXTENDED-B");
+
+ /**
+ * Constant for the "Bamum" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock BAMUM =
+ new UnicodeBlock("BAMUM");
+
+ /**
+ * Constant for the "Modifier Tone Letters" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock MODIFIER_TONE_LETTERS =
+ new UnicodeBlock("MODIFIER_TONE_LETTERS",
+ "MODIFIER TONE LETTERS",
+ "MODIFIERTONELETTERS");
+
+ /**
+ * Constant for the "Latin Extended-D" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock LATIN_EXTENDED_D =
+ new UnicodeBlock("LATIN_EXTENDED_D",
+ "LATIN EXTENDED-D",
+ "LATINEXTENDED-D");
+
+ /**
+ * Constant for the "Syloti Nagri" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock SYLOTI_NAGRI =
+ new UnicodeBlock("SYLOTI_NAGRI",
+ "SYLOTI NAGRI",
+ "SYLOTINAGRI");
+
+ /**
+ * Constant for the "Common Indic Number Forms" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock COMMON_INDIC_NUMBER_FORMS =
+ new UnicodeBlock("COMMON_INDIC_NUMBER_FORMS",
+ "COMMON INDIC NUMBER FORMS",
+ "COMMONINDICNUMBERFORMS");
+
+ /**
+ * Constant for the "Phags-pa" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock PHAGS_PA =
+ new UnicodeBlock("PHAGS_PA",
+ "PHAGS-PA");
+
+ /**
+ * Constant for the "Saurashtra" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock SAURASHTRA =
+ new UnicodeBlock("SAURASHTRA");
+
+ /**
+ * Constant for the "Devanagari Extended" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock DEVANAGARI_EXTENDED =
+ new UnicodeBlock("DEVANAGARI_EXTENDED",
+ "DEVANAGARI EXTENDED",
+ "DEVANAGARIEXTENDED");
+
+ /**
+ * Constant for the "Kayah Li" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock KAYAH_LI =
+ new UnicodeBlock("KAYAH_LI",
+ "KAYAH LI",
+ "KAYAHLI");
+
+ /**
+ * Constant for the "Rejang" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock REJANG =
+ new UnicodeBlock("REJANG");
+
+ /**
+ * Constant for the "Hangul Jamo Extended-A" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock HANGUL_JAMO_EXTENDED_A =
+ new UnicodeBlock("HANGUL_JAMO_EXTENDED_A",
+ "HANGUL JAMO EXTENDED-A",
+ "HANGULJAMOEXTENDED-A");
+
+ /**
+ * Constant for the "Javanese" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock JAVANESE =
+ new UnicodeBlock("JAVANESE");
+
+ /**
+ * Constant for the "Cham" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock CHAM =
+ new UnicodeBlock("CHAM");
+
+ /**
+ * Constant for the "Myanmar Extended-A" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock MYANMAR_EXTENDED_A =
+ new UnicodeBlock("MYANMAR_EXTENDED_A",
+ "MYANMAR EXTENDED-A",
+ "MYANMAREXTENDED-A");
+
+ /**
+ * Constant for the "Tai Viet" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock TAI_VIET =
+ new UnicodeBlock("TAI_VIET",
+ "TAI VIET",
+ "TAIVIET");
+
+ /**
+ * Constant for the "Ethiopic Extended-A" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ETHIOPIC_EXTENDED_A =
+ new UnicodeBlock("ETHIOPIC_EXTENDED_A",
+ "ETHIOPIC EXTENDED-A",
+ "ETHIOPICEXTENDED-A");
+
+ /**
+ * Constant for the "Meetei Mayek" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock MEETEI_MAYEK =
+ new UnicodeBlock("MEETEI_MAYEK",
+ "MEETEI MAYEK",
+ "MEETEIMAYEK");
+
+ /**
+ * Constant for the "Hangul Jamo Extended-B" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock HANGUL_JAMO_EXTENDED_B =
+ new UnicodeBlock("HANGUL_JAMO_EXTENDED_B",
+ "HANGUL JAMO EXTENDED-B",
+ "HANGULJAMOEXTENDED-B");
+
+ /**
+ * Constant for the "Vertical Forms" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock VERTICAL_FORMS =
+ new UnicodeBlock("VERTICAL_FORMS",
+ "VERTICAL FORMS",
+ "VERTICALFORMS");
+
+ /**
+ * Constant for the "Ancient Greek Numbers" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ANCIENT_GREEK_NUMBERS =
+ new UnicodeBlock("ANCIENT_GREEK_NUMBERS",
+ "ANCIENT GREEK NUMBERS",
+ "ANCIENTGREEKNUMBERS");
+
+ /**
+ * Constant for the "Ancient Symbols" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ANCIENT_SYMBOLS =
+ new UnicodeBlock("ANCIENT_SYMBOLS",
+ "ANCIENT SYMBOLS",
+ "ANCIENTSYMBOLS");
+
+ /**
+ * Constant for the "Phaistos Disc" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock PHAISTOS_DISC =
+ new UnicodeBlock("PHAISTOS_DISC",
+ "PHAISTOS DISC",
+ "PHAISTOSDISC");
+
+ /**
+ * Constant for the "Lycian" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock LYCIAN =
+ new UnicodeBlock("LYCIAN");
+
+ /**
+ * Constant for the "Carian" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock CARIAN =
+ new UnicodeBlock("CARIAN");
+
+ /**
+ * Constant for the "Old Persian" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock OLD_PERSIAN =
+ new UnicodeBlock("OLD_PERSIAN",
+ "OLD PERSIAN",
+ "OLDPERSIAN");
+
+ /**
+ * Constant for the "Imperial Aramaic" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock IMPERIAL_ARAMAIC =
+ new UnicodeBlock("IMPERIAL_ARAMAIC",
+ "IMPERIAL ARAMAIC",
+ "IMPERIALARAMAIC");
+
+ /**
+ * Constant for the "Phoenician" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock PHOENICIAN =
+ new UnicodeBlock("PHOENICIAN");
+
+ /**
+ * Constant for the "Lydian" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock LYDIAN =
+ new UnicodeBlock("LYDIAN");
+
+ /**
+ * Constant for the "Kharoshthi" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock KHAROSHTHI =
+ new UnicodeBlock("KHAROSHTHI");
+
+ /**
+ * Constant for the "Old South Arabian" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock OLD_SOUTH_ARABIAN =
+ new UnicodeBlock("OLD_SOUTH_ARABIAN",
+ "OLD SOUTH ARABIAN",
+ "OLDSOUTHARABIAN");
+
+ /**
+ * Constant for the "Avestan" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock AVESTAN =
+ new UnicodeBlock("AVESTAN");
+
+ /**
+ * Constant for the "Inscriptional Parthian" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock INSCRIPTIONAL_PARTHIAN =
+ new UnicodeBlock("INSCRIPTIONAL_PARTHIAN",
+ "INSCRIPTIONAL PARTHIAN",
+ "INSCRIPTIONALPARTHIAN");
+
+ /**
+ * Constant for the "Inscriptional Pahlavi" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock INSCRIPTIONAL_PAHLAVI =
+ new UnicodeBlock("INSCRIPTIONAL_PAHLAVI",
+ "INSCRIPTIONAL PAHLAVI",
+ "INSCRIPTIONALPAHLAVI");
+
+ /**
+ * Constant for the "Old Turkic" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock OLD_TURKIC =
+ new UnicodeBlock("OLD_TURKIC",
+ "OLD TURKIC",
+ "OLDTURKIC");
+
+ /**
+ * Constant for the "Rumi Numeral Symbols" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock RUMI_NUMERAL_SYMBOLS =
+ new UnicodeBlock("RUMI_NUMERAL_SYMBOLS",
+ "RUMI NUMERAL SYMBOLS",
+ "RUMINUMERALSYMBOLS");
+
+ /**
+ * Constant for the "Brahmi" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock BRAHMI =
+ new UnicodeBlock("BRAHMI");
+
+ /**
+ * Constant for the "Kaithi" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock KAITHI =
+ new UnicodeBlock("KAITHI");
+
+ /**
+ * Constant for the "Cuneiform" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock CUNEIFORM =
+ new UnicodeBlock("CUNEIFORM");
+
+ /**
+ * Constant for the "Cuneiform Numbers and Punctuation" Unicode
+ * character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock CUNEIFORM_NUMBERS_AND_PUNCTUATION =
+ new UnicodeBlock("CUNEIFORM_NUMBERS_AND_PUNCTUATION",
+ "CUNEIFORM NUMBERS AND PUNCTUATION",
+ "CUNEIFORMNUMBERSANDPUNCTUATION");
+
+ /**
+ * Constant for the "Egyptian Hieroglyphs" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock EGYPTIAN_HIEROGLYPHS =
+ new UnicodeBlock("EGYPTIAN_HIEROGLYPHS",
+ "EGYPTIAN HIEROGLYPHS",
+ "EGYPTIANHIEROGLYPHS");
+
+ /**
+ * Constant for the "Bamum Supplement" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock BAMUM_SUPPLEMENT =
+ new UnicodeBlock("BAMUM_SUPPLEMENT",
+ "BAMUM SUPPLEMENT",
+ "BAMUMSUPPLEMENT");
+
+ /**
+ * Constant for the "Kana Supplement" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock KANA_SUPPLEMENT =
+ new UnicodeBlock("KANA_SUPPLEMENT",
+ "KANA SUPPLEMENT",
+ "KANASUPPLEMENT");
+
+ /**
+ * Constant for the "Ancient Greek Musical Notation" Unicode character
+ * block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ANCIENT_GREEK_MUSICAL_NOTATION =
+ new UnicodeBlock("ANCIENT_GREEK_MUSICAL_NOTATION",
+ "ANCIENT GREEK MUSICAL NOTATION",
+ "ANCIENTGREEKMUSICALNOTATION");
+
+ /**
+ * Constant for the "Counting Rod Numerals" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock COUNTING_ROD_NUMERALS =
+ new UnicodeBlock("COUNTING_ROD_NUMERALS",
+ "COUNTING ROD NUMERALS",
+ "COUNTINGRODNUMERALS");
+
+ /**
+ * Constant for the "Mahjong Tiles" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock MAHJONG_TILES =
+ new UnicodeBlock("MAHJONG_TILES",
+ "MAHJONG TILES",
+ "MAHJONGTILES");
+
+ /**
+ * Constant for the "Domino Tiles" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock DOMINO_TILES =
+ new UnicodeBlock("DOMINO_TILES",
+ "DOMINO TILES",
+ "DOMINOTILES");
+
+ /**
+ * Constant for the "Playing Cards" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock PLAYING_CARDS =
+ new UnicodeBlock("PLAYING_CARDS",
+ "PLAYING CARDS",
+ "PLAYINGCARDS");
+
+ /**
+ * Constant for the "Enclosed Alphanumeric Supplement" Unicode character
+ * block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ENCLOSED_ALPHANUMERIC_SUPPLEMENT =
+ new UnicodeBlock("ENCLOSED_ALPHANUMERIC_SUPPLEMENT",
+ "ENCLOSED ALPHANUMERIC SUPPLEMENT",
+ "ENCLOSEDALPHANUMERICSUPPLEMENT");
+
+ /**
+ * Constant for the "Enclosed Ideographic Supplement" Unicode character
+ * block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ENCLOSED_IDEOGRAPHIC_SUPPLEMENT =
+ new UnicodeBlock("ENCLOSED_IDEOGRAPHIC_SUPPLEMENT",
+ "ENCLOSED IDEOGRAPHIC SUPPLEMENT",
+ "ENCLOSEDIDEOGRAPHICSUPPLEMENT");
+
+ /**
+ * Constant for the "Miscellaneous Symbols And Pictographs" Unicode
+ * character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS =
+ new UnicodeBlock("MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS",
+ "MISCELLANEOUS SYMBOLS AND PICTOGRAPHS",
+ "MISCELLANEOUSSYMBOLSANDPICTOGRAPHS");
+
+ /**
+ * Constant for the "Emoticons" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock EMOTICONS =
+ new UnicodeBlock("EMOTICONS");
+
+ /**
+ * Constant for the "Transport And Map Symbols" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock TRANSPORT_AND_MAP_SYMBOLS =
+ new UnicodeBlock("TRANSPORT_AND_MAP_SYMBOLS",
+ "TRANSPORT AND MAP SYMBOLS",
+ "TRANSPORTANDMAPSYMBOLS");
+
+ /**
+ * Constant for the "Alchemical Symbols" Unicode character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock ALCHEMICAL_SYMBOLS =
+ new UnicodeBlock("ALCHEMICAL_SYMBOLS",
+ "ALCHEMICAL SYMBOLS",
+ "ALCHEMICALSYMBOLS");
+
+ /**
+ * Constant for the "CJK Unified Ideographs Extension C" Unicode
+ * character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C =
+ new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C",
+ "CJK UNIFIED IDEOGRAPHS EXTENSION C",
+ "CJKUNIFIEDIDEOGRAPHSEXTENSIONC");
+
+ /**
+ * Constant for the "CJK Unified Ideographs Extension D" Unicode
+ * character block.
+ * @since 1.7
+ */
+ public static final UnicodeBlock CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D =
+ new UnicodeBlock("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D",
+ "CJK UNIFIED IDEOGRAPHS EXTENSION D",
+ "CJKUNIFIEDIDEOGRAPHSEXTENSIOND");
+
+ /**
+ * Constant for the "Arabic Extended-A" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock ARABIC_EXTENDED_A =
+ new UnicodeBlock("ARABIC_EXTENDED_A",
+ "ARABIC EXTENDED-A",
+ "ARABICEXTENDED-A");
+
+ /**
+ * Constant for the "Sundanese Supplement" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock SUNDANESE_SUPPLEMENT =
+ new UnicodeBlock("SUNDANESE_SUPPLEMENT",
+ "SUNDANESE SUPPLEMENT",
+ "SUNDANESESUPPLEMENT");
+
+ /**
+ * Constant for the "Meetei Mayek Extensions" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock MEETEI_MAYEK_EXTENSIONS =
+ new UnicodeBlock("MEETEI_MAYEK_EXTENSIONS",
+ "MEETEI MAYEK EXTENSIONS",
+ "MEETEIMAYEKEXTENSIONS");
+
+ /**
+ * Constant for the "Meroitic Hieroglyphs" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock MEROITIC_HIEROGLYPHS =
+ new UnicodeBlock("MEROITIC_HIEROGLYPHS",
+ "MEROITIC HIEROGLYPHS",
+ "MEROITICHIEROGLYPHS");
+
+ /**
+ * Constant for the "Meroitic Cursive" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock MEROITIC_CURSIVE =
+ new UnicodeBlock("MEROITIC_CURSIVE",
+ "MEROITIC CURSIVE",
+ "MEROITICCURSIVE");
+
+ /**
+ * Constant for the "Sora Sompeng" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock SORA_SOMPENG =
+ new UnicodeBlock("SORA_SOMPENG",
+ "SORA SOMPENG",
+ "SORASOMPENG");
+
+ /**
+ * Constant for the "Chakma" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock CHAKMA =
+ new UnicodeBlock("CHAKMA");
+
+ /**
+ * Constant for the "Sharada" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock SHARADA =
+ new UnicodeBlock("SHARADA");
+
+ /**
+ * Constant for the "Takri" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock TAKRI =
+ new UnicodeBlock("TAKRI");
+
+ /**
+ * Constant for the "Miao" Unicode character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock MIAO =
+ new UnicodeBlock("MIAO");
+
+ /**
+ * Constant for the "Arabic Mathematical Alphabetic Symbols" Unicode
+ * character block.
+ * @since 1.8
+ */
+ public static final UnicodeBlock ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS =
+ new UnicodeBlock("ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS",
+ "ARABIC MATHEMATICAL ALPHABETIC SYMBOLS",
+ "ARABICMATHEMATICALALPHABETICSYMBOLS");
+
+ private static final int blockStarts[] = {
+ 0x0000, // 0000..007F; Basic Latin
+ 0x0080, // 0080..00FF; Latin-1 Supplement
+ 0x0100, // 0100..017F; Latin Extended-A
+ 0x0180, // 0180..024F; Latin Extended-B
+ 0x0250, // 0250..02AF; IPA Extensions
+ 0x02B0, // 02B0..02FF; Spacing Modifier Letters
+ 0x0300, // 0300..036F; Combining Diacritical Marks
+ 0x0370, // 0370..03FF; Greek and Coptic
+ 0x0400, // 0400..04FF; Cyrillic
+ 0x0500, // 0500..052F; Cyrillic Supplement
+ 0x0530, // 0530..058F; Armenian
+ 0x0590, // 0590..05FF; Hebrew
+ 0x0600, // 0600..06FF; Arabic
+ 0x0700, // 0700..074F; Syriac
+ 0x0750, // 0750..077F; Arabic Supplement
+ 0x0780, // 0780..07BF; Thaana
+ 0x07C0, // 07C0..07FF; NKo
+ 0x0800, // 0800..083F; Samaritan
+ 0x0840, // 0840..085F; Mandaic
+ 0x0860, // unassigned
+ 0x08A0, // 08A0..08FF; Arabic Extended-A
+ 0x0900, // 0900..097F; Devanagari
+ 0x0980, // 0980..09FF; Bengali
+ 0x0A00, // 0A00..0A7F; Gurmukhi
+ 0x0A80, // 0A80..0AFF; Gujarati
+ 0x0B00, // 0B00..0B7F; Oriya
+ 0x0B80, // 0B80..0BFF; Tamil
+ 0x0C00, // 0C00..0C7F; Telugu
+ 0x0C80, // 0C80..0CFF; Kannada
+ 0x0D00, // 0D00..0D7F; Malayalam
+ 0x0D80, // 0D80..0DFF; Sinhala
+ 0x0E00, // 0E00..0E7F; Thai
+ 0x0E80, // 0E80..0EFF; Lao
+ 0x0F00, // 0F00..0FFF; Tibetan
+ 0x1000, // 1000..109F; Myanmar
+ 0x10A0, // 10A0..10FF; Georgian
+ 0x1100, // 1100..11FF; Hangul Jamo
+ 0x1200, // 1200..137F; Ethiopic
+ 0x1380, // 1380..139F; Ethiopic Supplement
+ 0x13A0, // 13A0..13FF; Cherokee
+ 0x1400, // 1400..167F; Unified Canadian Aboriginal Syllabics
+ 0x1680, // 1680..169F; Ogham
+ 0x16A0, // 16A0..16FF; Runic
+ 0x1700, // 1700..171F; Tagalog
+ 0x1720, // 1720..173F; Hanunoo
+ 0x1740, // 1740..175F; Buhid
+ 0x1760, // 1760..177F; Tagbanwa
+ 0x1780, // 1780..17FF; Khmer
+ 0x1800, // 1800..18AF; Mongolian
+ 0x18B0, // 18B0..18FF; Unified Canadian Aboriginal Syllabics Extended
+ 0x1900, // 1900..194F; Limbu
+ 0x1950, // 1950..197F; Tai Le
+ 0x1980, // 1980..19DF; New Tai Lue
+ 0x19E0, // 19E0..19FF; Khmer Symbols
+ 0x1A00, // 1A00..1A1F; Buginese
+ 0x1A20, // 1A20..1AAF; Tai Tham
+ 0x1AB0, // unassigned
+ 0x1B00, // 1B00..1B7F; Balinese
+ 0x1B80, // 1B80..1BBF; Sundanese
+ 0x1BC0, // 1BC0..1BFF; Batak
+ 0x1C00, // 1C00..1C4F; Lepcha
+ 0x1C50, // 1C50..1C7F; Ol Chiki
+ 0x1C80, // unassigned
+ 0x1CC0, // 1CC0..1CCF; Sundanese Supplement
+ 0x1CD0, // 1CD0..1CFF; Vedic Extensions
+ 0x1D00, // 1D00..1D7F; Phonetic Extensions
+ 0x1D80, // 1D80..1DBF; Phonetic Extensions Supplement
+ 0x1DC0, // 1DC0..1DFF; Combining Diacritical Marks Supplement
+ 0x1E00, // 1E00..1EFF; Latin Extended Additional
+ 0x1F00, // 1F00..1FFF; Greek Extended
+ 0x2000, // 2000..206F; General Punctuation
+ 0x2070, // 2070..209F; Superscripts and Subscripts
+ 0x20A0, // 20A0..20CF; Currency Symbols
+ 0x20D0, // 20D0..20FF; Combining Diacritical Marks for Symbols
+ 0x2100, // 2100..214F; Letterlike Symbols
+ 0x2150, // 2150..218F; Number Forms
+ 0x2190, // 2190..21FF; Arrows
+ 0x2200, // 2200..22FF; Mathematical Operators
+ 0x2300, // 2300..23FF; Miscellaneous Technical
+ 0x2400, // 2400..243F; Control Pictures
+ 0x2440, // 2440..245F; Optical Character Recognition
+ 0x2460, // 2460..24FF; Enclosed Alphanumerics
+ 0x2500, // 2500..257F; Box Drawing
+ 0x2580, // 2580..259F; Block Elements
+ 0x25A0, // 25A0..25FF; Geometric Shapes
+ 0x2600, // 2600..26FF; Miscellaneous Symbols
+ 0x2700, // 2700..27BF; Dingbats
+ 0x27C0, // 27C0..27EF; Miscellaneous Mathematical Symbols-A
+ 0x27F0, // 27F0..27FF; Supplemental Arrows-A
+ 0x2800, // 2800..28FF; Braille Patterns
+ 0x2900, // 2900..297F; Supplemental Arrows-B
+ 0x2980, // 2980..29FF; Miscellaneous Mathematical Symbols-B
+ 0x2A00, // 2A00..2AFF; Supplemental Mathematical Operators
+ 0x2B00, // 2B00..2BFF; Miscellaneous Symbols and Arrows
+ 0x2C00, // 2C00..2C5F; Glagolitic
+ 0x2C60, // 2C60..2C7F; Latin Extended-C
+ 0x2C80, // 2C80..2CFF; Coptic
+ 0x2D00, // 2D00..2D2F; Georgian Supplement
+ 0x2D30, // 2D30..2D7F; Tifinagh
+ 0x2D80, // 2D80..2DDF; Ethiopic Extended
+ 0x2DE0, // 2DE0..2DFF; Cyrillic Extended-A
+ 0x2E00, // 2E00..2E7F; Supplemental Punctuation
+ 0x2E80, // 2E80..2EFF; CJK Radicals Supplement
+ 0x2F00, // 2F00..2FDF; Kangxi Radicals
+ 0x2FE0, // unassigned
+ 0x2FF0, // 2FF0..2FFF; Ideographic Description Characters
+ 0x3000, // 3000..303F; CJK Symbols and Punctuation
+ 0x3040, // 3040..309F; Hiragana
+ 0x30A0, // 30A0..30FF; Katakana
+ 0x3100, // 3100..312F; Bopomofo
+ 0x3130, // 3130..318F; Hangul Compatibility Jamo
+ 0x3190, // 3190..319F; Kanbun
+ 0x31A0, // 31A0..31BF; Bopomofo Extended
+ 0x31C0, // 31C0..31EF; CJK Strokes
+ 0x31F0, // 31F0..31FF; Katakana Phonetic Extensions
+ 0x3200, // 3200..32FF; Enclosed CJK Letters and Months
+ 0x3300, // 3300..33FF; CJK Compatibility
+ 0x3400, // 3400..4DBF; CJK Unified Ideographs Extension A
+ 0x4DC0, // 4DC0..4DFF; Yijing Hexagram Symbols
+ 0x4E00, // 4E00..9FFF; CJK Unified Ideographs
+ 0xA000, // A000..A48F; Yi Syllables
+ 0xA490, // A490..A4CF; Yi Radicals
+ 0xA4D0, // A4D0..A4FF; Lisu
+ 0xA500, // A500..A63F; Vai
+ 0xA640, // A640..A69F; Cyrillic Extended-B
+ 0xA6A0, // A6A0..A6FF; Bamum
+ 0xA700, // A700..A71F; Modifier Tone Letters
+ 0xA720, // A720..A7FF; Latin Extended-D
+ 0xA800, // A800..A82F; Syloti Nagri
+ 0xA830, // A830..A83F; Common Indic Number Forms
+ 0xA840, // A840..A87F; Phags-pa
+ 0xA880, // A880..A8DF; Saurashtra
+ 0xA8E0, // A8E0..A8FF; Devanagari Extended
+ 0xA900, // A900..A92F; Kayah Li
+ 0xA930, // A930..A95F; Rejang
+ 0xA960, // A960..A97F; Hangul Jamo Extended-A
+ 0xA980, // A980..A9DF; Javanese
+ 0xA9E0, // unassigned
+ 0xAA00, // AA00..AA5F; Cham
+ 0xAA60, // AA60..AA7F; Myanmar Extended-A
+ 0xAA80, // AA80..AADF; Tai Viet
+ 0xAAE0, // AAE0..AAFF; Meetei Mayek Extensions
+ 0xAB00, // AB00..AB2F; Ethiopic Extended-A
+ 0xAB30, // unassigned
+ 0xABC0, // ABC0..ABFF; Meetei Mayek
+ 0xAC00, // AC00..D7AF; Hangul Syllables
+ 0xD7B0, // D7B0..D7FF; Hangul Jamo Extended-B
+ 0xD800, // D800..DB7F; High Surrogates
+ 0xDB80, // DB80..DBFF; High Private Use Surrogates
+ 0xDC00, // DC00..DFFF; Low Surrogates
+ 0xE000, // E000..F8FF; Private Use Area
+ 0xF900, // F900..FAFF; CJK Compatibility Ideographs
+ 0xFB00, // FB00..FB4F; Alphabetic Presentation Forms
+ 0xFB50, // FB50..FDFF; Arabic Presentation Forms-A
+ 0xFE00, // FE00..FE0F; Variation Selectors
+ 0xFE10, // FE10..FE1F; Vertical Forms
+ 0xFE20, // FE20..FE2F; Combining Half Marks
+ 0xFE30, // FE30..FE4F; CJK Compatibility Forms
+ 0xFE50, // FE50..FE6F; Small Form Variants
+ 0xFE70, // FE70..FEFF; Arabic Presentation Forms-B
+ 0xFF00, // FF00..FFEF; Halfwidth and Fullwidth Forms
+ 0xFFF0, // FFF0..FFFF; Specials
+ 0x10000, // 10000..1007F; Linear B Syllabary
+ 0x10080, // 10080..100FF; Linear B Ideograms
+ 0x10100, // 10100..1013F; Aegean Numbers
+ 0x10140, // 10140..1018F; Ancient Greek Numbers
+ 0x10190, // 10190..101CF; Ancient Symbols
+ 0x101D0, // 101D0..101FF; Phaistos Disc
+ 0x10200, // unassigned
+ 0x10280, // 10280..1029F; Lycian
+ 0x102A0, // 102A0..102DF; Carian
+ 0x102E0, // unassigned
+ 0x10300, // 10300..1032F; Old Italic
+ 0x10330, // 10330..1034F; Gothic
+ 0x10350, // unassigned
+ 0x10380, // 10380..1039F; Ugaritic
+ 0x103A0, // 103A0..103DF; Old Persian
+ 0x103E0, // unassigned
+ 0x10400, // 10400..1044F; Deseret
+ 0x10450, // 10450..1047F; Shavian
+ 0x10480, // 10480..104AF; Osmanya
+ 0x104B0, // unassigned
+ 0x10800, // 10800..1083F; Cypriot Syllabary
+ 0x10840, // 10840..1085F; Imperial Aramaic
+ 0x10860, // unassigned
+ 0x10900, // 10900..1091F; Phoenician
+ 0x10920, // 10920..1093F; Lydian
+ 0x10940, // unassigned
+ 0x10980, // 10980..1099F; Meroitic Hieroglyphs
+ 0x109A0, // 109A0..109FF; Meroitic Cursive
+ 0x10A00, // 10A00..10A5F; Kharoshthi
+ 0x10A60, // 10A60..10A7F; Old South Arabian
+ 0x10A80, // unassigned
+ 0x10B00, // 10B00..10B3F; Avestan
+ 0x10B40, // 10B40..10B5F; Inscriptional Parthian
+ 0x10B60, // 10B60..10B7F; Inscriptional Pahlavi
+ 0x10B80, // unassigned
+ 0x10C00, // 10C00..10C4F; Old Turkic
+ 0x10C50, // unassigned
+ 0x10E60, // 10E60..10E7F; Rumi Numeral Symbols
+ 0x10E80, // unassigned
+ 0x11000, // 11000..1107F; Brahmi
+ 0x11080, // 11080..110CF; Kaithi
+ 0x110D0, // 110D0..110FF; Sora Sompeng
+ 0x11100, // 11100..1114F; Chakma
+ 0x11150, // unassigned
+ 0x11180, // 11180..111DF; Sharada
+ 0x111E0, // unassigned
+ 0x11680, // 11680..116CF; Takri
+ 0x116D0, // unassigned
+ 0x12000, // 12000..123FF; Cuneiform
+ 0x12400, // 12400..1247F; Cuneiform Numbers and Punctuation
+ 0x12480, // unassigned
+ 0x13000, // 13000..1342F; Egyptian Hieroglyphs
+ 0x13430, // unassigned
+ 0x16800, // 16800..16A3F; Bamum Supplement
+ 0x16A40, // unassigned
+ 0x16F00, // 16F00..16F9F; Miao
+ 0x16FA0, // unassigned
+ 0x1B000, // 1B000..1B0FF; Kana Supplement
+ 0x1B100, // unassigned
+ 0x1D000, // 1D000..1D0FF; Byzantine Musical Symbols
+ 0x1D100, // 1D100..1D1FF; Musical Symbols
+ 0x1D200, // 1D200..1D24F; Ancient Greek Musical Notation
+ 0x1D250, // unassigned
+ 0x1D300, // 1D300..1D35F; Tai Xuan Jing Symbols
+ 0x1D360, // 1D360..1D37F; Counting Rod Numerals
+ 0x1D380, // unassigned
+ 0x1D400, // 1D400..1D7FF; Mathematical Alphanumeric Symbols
+ 0x1D800, // unassigned
+ 0x1EE00, // 1EE00..1EEFF; Arabic Mathematical Alphabetic Symbols
+ 0x1EF00, // unassigned
+ 0x1F000, // 1F000..1F02F; Mahjong Tiles
+ 0x1F030, // 1F030..1F09F; Domino Tiles
+ 0x1F0A0, // 1F0A0..1F0FF; Playing Cards
+ 0x1F100, // 1F100..1F1FF; Enclosed Alphanumeric Supplement
+ 0x1F200, // 1F200..1F2FF; Enclosed Ideographic Supplement
+ 0x1F300, // 1F300..1F5FF; Miscellaneous Symbols And Pictographs
+ 0x1F600, // 1F600..1F64F; Emoticons
+ 0x1F650, // unassigned
+ 0x1F680, // 1F680..1F6FF; Transport And Map Symbols
+ 0x1F700, // 1F700..1F77F; Alchemical Symbols
+ 0x1F780, // unassigned
+ 0x20000, // 20000..2A6DF; CJK Unified Ideographs Extension B
+ 0x2A6E0, // unassigned
+ 0x2A700, // 2A700..2B73F; CJK Unified Ideographs Extension C
+ 0x2B740, // 2B740..2B81F; CJK Unified Ideographs Extension D
+ 0x2B820, // unassigned
+ 0x2F800, // 2F800..2FA1F; CJK Compatibility Ideographs Supplement
+ 0x2FA20, // unassigned
+ 0xE0000, // E0000..E007F; Tags
+ 0xE0080, // unassigned
+ 0xE0100, // E0100..E01EF; Variation Selectors Supplement
+ 0xE01F0, // unassigned
+ 0xF0000, // F0000..FFFFF; Supplementary Private Use Area-A
+ 0x100000 // 100000..10FFFF; Supplementary Private Use Area-B
+ };
+
+ private static final UnicodeBlock[] blocks = {
+ BASIC_LATIN,
+ LATIN_1_SUPPLEMENT,
+ LATIN_EXTENDED_A,
+ LATIN_EXTENDED_B,
+ IPA_EXTENSIONS,
+ SPACING_MODIFIER_LETTERS,
+ COMBINING_DIACRITICAL_MARKS,
+ GREEK,
+ CYRILLIC,
+ CYRILLIC_SUPPLEMENTARY,
+ ARMENIAN,
+ HEBREW,
+ ARABIC,
+ SYRIAC,
+ ARABIC_SUPPLEMENT,
+ THAANA,
+ NKO,
+ SAMARITAN,
+ MANDAIC,
+ null,
+ ARABIC_EXTENDED_A,
+ DEVANAGARI,
+ BENGALI,
+ GURMUKHI,
+ GUJARATI,
+ ORIYA,
+ TAMIL,
+ TELUGU,
+ KANNADA,
+ MALAYALAM,
+ SINHALA,
+ THAI,
+ LAO,
+ TIBETAN,
+ MYANMAR,
+ GEORGIAN,
+ HANGUL_JAMO,
+ ETHIOPIC,
+ ETHIOPIC_SUPPLEMENT,
+ CHEROKEE,
+ UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS,
+ OGHAM,
+ RUNIC,
+ TAGALOG,
+ HANUNOO,
+ BUHID,
+ TAGBANWA,
+ KHMER,
+ MONGOLIAN,
+ UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED,
+ LIMBU,
+ TAI_LE,
+ NEW_TAI_LUE,
+ KHMER_SYMBOLS,
+ BUGINESE,
+ TAI_THAM,
+ null,
+ BALINESE,
+ SUNDANESE,
+ BATAK,
+ LEPCHA,
+ OL_CHIKI,
+ null,
+ SUNDANESE_SUPPLEMENT,
+ VEDIC_EXTENSIONS,
+ PHONETIC_EXTENSIONS,
+ PHONETIC_EXTENSIONS_SUPPLEMENT,
+ COMBINING_DIACRITICAL_MARKS_SUPPLEMENT,
+ LATIN_EXTENDED_ADDITIONAL,
+ GREEK_EXTENDED,
+ GENERAL_PUNCTUATION,
+ SUPERSCRIPTS_AND_SUBSCRIPTS,
+ CURRENCY_SYMBOLS,
+ COMBINING_MARKS_FOR_SYMBOLS,
+ LETTERLIKE_SYMBOLS,
+ NUMBER_FORMS,
+ ARROWS,
+ MATHEMATICAL_OPERATORS,
+ MISCELLANEOUS_TECHNICAL,
+ CONTROL_PICTURES,
+ OPTICAL_CHARACTER_RECOGNITION,
+ ENCLOSED_ALPHANUMERICS,
+ BOX_DRAWING,
+ BLOCK_ELEMENTS,
+ GEOMETRIC_SHAPES,
+ MISCELLANEOUS_SYMBOLS,
+ DINGBATS,
+ MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A,
+ SUPPLEMENTAL_ARROWS_A,
+ BRAILLE_PATTERNS,
+ SUPPLEMENTAL_ARROWS_B,
+ MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B,
+ SUPPLEMENTAL_MATHEMATICAL_OPERATORS,
+ MISCELLANEOUS_SYMBOLS_AND_ARROWS,
+ GLAGOLITIC,
+ LATIN_EXTENDED_C,
+ COPTIC,
+ GEORGIAN_SUPPLEMENT,
+ TIFINAGH,
+ ETHIOPIC_EXTENDED,
+ CYRILLIC_EXTENDED_A,
+ SUPPLEMENTAL_PUNCTUATION,
+ CJK_RADICALS_SUPPLEMENT,
+ KANGXI_RADICALS,
+ null,
+ IDEOGRAPHIC_DESCRIPTION_CHARACTERS,
+ CJK_SYMBOLS_AND_PUNCTUATION,
+ HIRAGANA,
+ KATAKANA,
+ BOPOMOFO,
+ HANGUL_COMPATIBILITY_JAMO,
+ KANBUN,
+ BOPOMOFO_EXTENDED,
+ CJK_STROKES,
+ KATAKANA_PHONETIC_EXTENSIONS,
+ ENCLOSED_CJK_LETTERS_AND_MONTHS,
+ CJK_COMPATIBILITY,
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A,
+ YIJING_HEXAGRAM_SYMBOLS,
+ CJK_UNIFIED_IDEOGRAPHS,
+ YI_SYLLABLES,
+ YI_RADICALS,
+ LISU,
+ VAI,
+ CYRILLIC_EXTENDED_B,
+ BAMUM,
+ MODIFIER_TONE_LETTERS,
+ LATIN_EXTENDED_D,
+ SYLOTI_NAGRI,
+ COMMON_INDIC_NUMBER_FORMS,
+ PHAGS_PA,
+ SAURASHTRA,
+ DEVANAGARI_EXTENDED,
+ KAYAH_LI,
+ REJANG,
+ HANGUL_JAMO_EXTENDED_A,
+ JAVANESE,
+ null,
+ CHAM,
+ MYANMAR_EXTENDED_A,
+ TAI_VIET,
+ MEETEI_MAYEK_EXTENSIONS,
+ ETHIOPIC_EXTENDED_A,
+ null,
+ MEETEI_MAYEK,
+ HANGUL_SYLLABLES,
+ HANGUL_JAMO_EXTENDED_B,
+ HIGH_SURROGATES,
+ HIGH_PRIVATE_USE_SURROGATES,
+ LOW_SURROGATES,
+ PRIVATE_USE_AREA,
+ CJK_COMPATIBILITY_IDEOGRAPHS,
+ ALPHABETIC_PRESENTATION_FORMS,
+ ARABIC_PRESENTATION_FORMS_A,
+ VARIATION_SELECTORS,
+ VERTICAL_FORMS,
+ COMBINING_HALF_MARKS,
+ CJK_COMPATIBILITY_FORMS,
+ SMALL_FORM_VARIANTS,
+ ARABIC_PRESENTATION_FORMS_B,
+ HALFWIDTH_AND_FULLWIDTH_FORMS,
+ SPECIALS,
+ LINEAR_B_SYLLABARY,
+ LINEAR_B_IDEOGRAMS,
+ AEGEAN_NUMBERS,
+ ANCIENT_GREEK_NUMBERS,
+ ANCIENT_SYMBOLS,
+ PHAISTOS_DISC,
+ null,
+ LYCIAN,
+ CARIAN,
+ null,
+ OLD_ITALIC,
+ GOTHIC,
+ null,
+ UGARITIC,
+ OLD_PERSIAN,
+ null,
+ DESERET,
+ SHAVIAN,
+ OSMANYA,
+ null,
+ CYPRIOT_SYLLABARY,
+ IMPERIAL_ARAMAIC,
+ null,
+ PHOENICIAN,
+ LYDIAN,
+ null,
+ MEROITIC_HIEROGLYPHS,
+ MEROITIC_CURSIVE,
+ KHAROSHTHI,
+ OLD_SOUTH_ARABIAN,
+ null,
+ AVESTAN,
+ INSCRIPTIONAL_PARTHIAN,
+ INSCRIPTIONAL_PAHLAVI,
+ null,
+ OLD_TURKIC,
+ null,
+ RUMI_NUMERAL_SYMBOLS,
+ null,
+ BRAHMI,
+ KAITHI,
+ SORA_SOMPENG,
+ CHAKMA,
+ null,
+ SHARADA,
+ null,
+ TAKRI,
+ null,
+ CUNEIFORM,
+ CUNEIFORM_NUMBERS_AND_PUNCTUATION,
+ null,
+ EGYPTIAN_HIEROGLYPHS,
+ null,
+ BAMUM_SUPPLEMENT,
+ null,
+ MIAO,
+ null,
+ KANA_SUPPLEMENT,
+ null,
+ BYZANTINE_MUSICAL_SYMBOLS,
+ MUSICAL_SYMBOLS,
+ ANCIENT_GREEK_MUSICAL_NOTATION,
+ null,
+ TAI_XUAN_JING_SYMBOLS,
+ COUNTING_ROD_NUMERALS,
+ null,
+ MATHEMATICAL_ALPHANUMERIC_SYMBOLS,
+ null,
+ ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS,
+ null,
+ MAHJONG_TILES,
+ DOMINO_TILES,
+ PLAYING_CARDS,
+ ENCLOSED_ALPHANUMERIC_SUPPLEMENT,
+ ENCLOSED_IDEOGRAPHIC_SUPPLEMENT,
+ MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS,
+ EMOTICONS,
+ null,
+ TRANSPORT_AND_MAP_SYMBOLS,
+ ALCHEMICAL_SYMBOLS,
+ null,
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B,
+ null,
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C,
+ CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D,
+ null,
+ CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT,
+ null,
+ TAGS,
+ null,
+ VARIATION_SELECTORS_SUPPLEMENT,
+ null,
+ SUPPLEMENTARY_PRIVATE_USE_AREA_A,
+ SUPPLEMENTARY_PRIVATE_USE_AREA_B
+ };
+
+
+ /**
+ * Returns the object representing the Unicode block containing the
+ * given character, or {@code null} if the character is not a
+ * member of a defined block.
+ *
+ * <p><b>Note:</b> This method cannot handle
+ * <a href="Character.html#supplementary"> supplementary
+ * characters</a>. To support all Unicode characters, including
+ * supplementary characters, use the {@link #of(int)} method.
+ *
+ * @param c The character in question
+ * @return The {@code UnicodeBlock} instance representing the
+ * Unicode block of which this character is a member, or
+ * {@code null} if the character is not a member of any
+ * Unicode block
+ */
+ public static UnicodeBlock of(char c) {
+ return of((int)c);
+ }
+
+ /**
+ * Returns the object representing the Unicode block
+ * containing the given character (Unicode code point), or
+ * {@code null} if the character is not a member of a
+ * defined block.
+ *
+ * @param codePoint the character (Unicode code point) in question.
+ * @return The {@code UnicodeBlock} instance representing the
+ * Unicode block of which this character is a member, or
+ * {@code null} if the character is not a member of any
+ * Unicode block
+ * @exception IllegalArgumentException if the specified
+ * {@code codePoint} is an invalid Unicode code point.
+ * @see Character#isValidCodePoint(int)
+ * @since 1.5
+ */
+ public static UnicodeBlock of(int codePoint) {
+ if (!isValidCodePoint(codePoint)) {
+ throw new IllegalArgumentException();
+ }
+
+ int top, bottom, current;
+ bottom = 0;
+ top = blockStarts.length;
+ current = top/2;
+
+ // invariant: top > current >= bottom && codePoint >= unicodeBlockStarts[bottom]
+ while (top - bottom > 1) {
+ if (codePoint >= blockStarts[current]) {
+ bottom = current;
+ } else {
+ top = current;
+ }
+ current = (top + bottom) / 2;
+ }
+ return blocks[current];
+ }
+
+ /**
+ * Returns the UnicodeBlock with the given name. Block
+ * names are determined by The Unicode Standard. The file
+ * Blocks-<version>.txt defines blocks for a particular
+ * version of the standard. The {@link Character} class specifies
+ * the version of the standard that it supports.
+ * <p>
+ * This method accepts block names in the following forms:
+ * <ol>
+ * <li> Canonical block names as defined by the Unicode Standard.
+ * For example, the standard defines a "Basic Latin" block. Therefore, this
+ * method accepts "Basic Latin" as a valid block name. The documentation of
+ * each UnicodeBlock provides the canonical name.
+ * <li>Canonical block names with all spaces removed. For example, "BasicLatin"
+ * is a valid block name for the "Basic Latin" block.
+ * <li>The text representation of each constant UnicodeBlock identifier.
+ * For example, this method will return the {@link #BASIC_LATIN} block if
+ * provided with the "BASIC_LATIN" name. This form replaces all spaces and
+ * hyphens in the canonical name with underscores.
+ * </ol>
+ * Finally, character case is ignored for all of the valid block name forms.
+ * For example, "BASIC_LATIN" and "basic_latin" are both valid block names.
+ * The en_US locale's case mapping rules are used to provide case-insensitive
+ * string comparisons for block name validation.
+ * <p>
+ * If the Unicode Standard changes block names, both the previous and
+ * current names will be accepted.
+ *
+ * @param blockName A {@code UnicodeBlock} name.
+ * @return The {@code UnicodeBlock} instance identified
+ * by {@code blockName}
+ * @throws IllegalArgumentException if {@code blockName} is an
+ * invalid name
+ * @throws NullPointerException if {@code blockName} is null
+ * @since 1.5
+ */
+ public static final UnicodeBlock forName(String blockName) {
+ UnicodeBlock block = map.get(blockName.toUpperCase(Locale.US));
+ if (block == null) {
+ throw new IllegalArgumentException();
+ }
+ return block;
+ }
+ }
+
+
+ /**
+ * A family of character subsets representing the character scripts
+ * defined in the <a href="http://www.unicode.org/reports/tr24/">
+ * <i>Unicode Standard Annex #24: Script Names</i></a>. Every Unicode
+ * character is assigned to a single Unicode script, either a specific
+ * script, such as {@link Character.UnicodeScript#LATIN Latin}, or
+ * one of the following three special values,
+ * {@link Character.UnicodeScript#INHERITED Inherited},
+ * {@link Character.UnicodeScript#COMMON Common} or
+ * {@link Character.UnicodeScript#UNKNOWN Unknown}.
+ *
+ * @since 1.7
+ */
+ public static enum UnicodeScript {
+ /**
+ * Unicode script "Common".
+ */
+ COMMON,
+
+ /**
+ * Unicode script "Latin".
+ */
+ LATIN,
+
+ /**
+ * Unicode script "Greek".
+ */
+ GREEK,
+
+ /**
+ * Unicode script "Cyrillic".
+ */
+ CYRILLIC,
+
+ /**
+ * Unicode script "Armenian".
+ */
+ ARMENIAN,
+
+ /**
+ * Unicode script "Hebrew".
+ */
+ HEBREW,
+
+ /**
+ * Unicode script "Arabic".
+ */
+ ARABIC,
+
+ /**
+ * Unicode script "Syriac".
+ */
+ SYRIAC,
+
+ /**
+ * Unicode script "Thaana".
+ */
+ THAANA,
+
+ /**
+ * Unicode script "Devanagari".
+ */
+ DEVANAGARI,
+
+ /**
+ * Unicode script "Bengali".
+ */
+ BENGALI,
+
+ /**
+ * Unicode script "Gurmukhi".
+ */
+ GURMUKHI,
+
+ /**
+ * Unicode script "Gujarati".
+ */
+ GUJARATI,
+
+ /**
+ * Unicode script "Oriya".
+ */
+ ORIYA,
+
+ /**
+ * Unicode script "Tamil".
+ */
+ TAMIL,
+
+ /**
+ * Unicode script "Telugu".
+ */
+ TELUGU,
+
+ /**
+ * Unicode script "Kannada".
+ */
+ KANNADA,
+
+ /**
+ * Unicode script "Malayalam".
+ */
+ MALAYALAM,
+
+ /**
+ * Unicode script "Sinhala".
+ */
+ SINHALA,
+
+ /**
+ * Unicode script "Thai".
+ */
+ THAI,
+
+ /**
+ * Unicode script "Lao".
+ */
+ LAO,
+
+ /**
+ * Unicode script "Tibetan".
+ */
+ TIBETAN,
+
+ /**
+ * Unicode script "Myanmar".
+ */
+ MYANMAR,
+
+ /**
+ * Unicode script "Georgian".
+ */
+ GEORGIAN,
+
+ /**
+ * Unicode script "Hangul".
+ */
+ HANGUL,
+
+ /**
+ * Unicode script "Ethiopic".
+ */
+ ETHIOPIC,
+
+ /**
+ * Unicode script "Cherokee".
+ */
+ CHEROKEE,
+
+ /**
+ * Unicode script "Canadian_Aboriginal".
+ */
+ CANADIAN_ABORIGINAL,
+
+ /**
+ * Unicode script "Ogham".
+ */
+ OGHAM,
+
+ /**
+ * Unicode script "Runic".
+ */
+ RUNIC,
+
+ /**
+ * Unicode script "Khmer".
+ */
+ KHMER,
+
+ /**
+ * Unicode script "Mongolian".
+ */
+ MONGOLIAN,
+
+ /**
+ * Unicode script "Hiragana".
+ */
+ HIRAGANA,
+
+ /**
+ * Unicode script "Katakana".
+ */
+ KATAKANA,
+
+ /**
+ * Unicode script "Bopomofo".
+ */
+ BOPOMOFO,
+
+ /**
+ * Unicode script "Han".
+ */
+ HAN,
+
+ /**
+ * Unicode script "Yi".
+ */
+ YI,
+
+ /**
+ * Unicode script "Old_Italic".
+ */
+ OLD_ITALIC,
+
+ /**
+ * Unicode script "Gothic".
+ */
+ GOTHIC,
+
+ /**
+ * Unicode script "Deseret".
+ */
+ DESERET,
+
+ /**
+ * Unicode script "Inherited".
+ */
+ INHERITED,
+
+ /**
+ * Unicode script "Tagalog".
+ */
+ TAGALOG,
+
+ /**
+ * Unicode script "Hanunoo".
+ */
+ HANUNOO,
+
+ /**
+ * Unicode script "Buhid".
+ */
+ BUHID,
+
+ /**
+ * Unicode script "Tagbanwa".
+ */
+ TAGBANWA,
+
+ /**
+ * Unicode script "Limbu".
+ */
+ LIMBU,
+
+ /**
+ * Unicode script "Tai_Le".
+ */
+ TAI_LE,
+
+ /**
+ * Unicode script "Linear_B".
+ */
+ LINEAR_B,
+
+ /**
+ * Unicode script "Ugaritic".
+ */
+ UGARITIC,
+
+ /**
+ * Unicode script "Shavian".
+ */
+ SHAVIAN,
+
+ /**
+ * Unicode script "Osmanya".
+ */
+ OSMANYA,
+
+ /**
+ * Unicode script "Cypriot".
+ */
+ CYPRIOT,
+
+ /**
+ * Unicode script "Braille".
+ */
+ BRAILLE,
+
+ /**
+ * Unicode script "Buginese".
+ */
+ BUGINESE,
+
+ /**
+ * Unicode script "Coptic".
+ */
+ COPTIC,
+
+ /**
+ * Unicode script "New_Tai_Lue".
+ */
+ NEW_TAI_LUE,
+
+ /**
+ * Unicode script "Glagolitic".
+ */
+ GLAGOLITIC,
+
+ /**
+ * Unicode script "Tifinagh".
+ */
+ TIFINAGH,
+
+ /**
+ * Unicode script "Syloti_Nagri".
+ */
+ SYLOTI_NAGRI,
+
+ /**
+ * Unicode script "Old_Persian".
+ */
+ OLD_PERSIAN,
+
+ /**
+ * Unicode script "Kharoshthi".
+ */
+ KHAROSHTHI,
+
+ /**
+ * Unicode script "Balinese".
+ */
+ BALINESE,
+
+ /**
+ * Unicode script "Cuneiform".
+ */
+ CUNEIFORM,
+
+ /**
+ * Unicode script "Phoenician".
+ */
+ PHOENICIAN,
+
+ /**
+ * Unicode script "Phags_Pa".
+ */
+ PHAGS_PA,
+
+ /**
+ * Unicode script "Nko".
+ */
+ NKO,
+
+ /**
+ * Unicode script "Sundanese".
+ */
+ SUNDANESE,
+
+ /**
+ * Unicode script "Batak".
+ */
+ BATAK,
+
+ /**
+ * Unicode script "Lepcha".
+ */
+ LEPCHA,
+
+ /**
+ * Unicode script "Ol_Chiki".
+ */
+ OL_CHIKI,
+
+ /**
+ * Unicode script "Vai".
+ */
+ VAI,
+
+ /**
+ * Unicode script "Saurashtra".
+ */
+ SAURASHTRA,
+
+ /**
+ * Unicode script "Kayah_Li".
+ */
+ KAYAH_LI,
+
+ /**
+ * Unicode script "Rejang".
+ */
+ REJANG,
+
+ /**
+ * Unicode script "Lycian".
+ */
+ LYCIAN,
+
+ /**
+ * Unicode script "Carian".
+ */
+ CARIAN,
+
+ /**
+ * Unicode script "Lydian".
+ */
+ LYDIAN,
+
+ /**
+ * Unicode script "Cham".
+ */
+ CHAM,
+
+ /**
+ * Unicode script "Tai_Tham".
+ */
+ TAI_THAM,
+
+ /**
+ * Unicode script "Tai_Viet".
+ */
+ TAI_VIET,
+
+ /**
+ * Unicode script "Avestan".
+ */
+ AVESTAN,
+
+ /**
+ * Unicode script "Egyptian_Hieroglyphs".
+ */
+ EGYPTIAN_HIEROGLYPHS,
+
+ /**
+ * Unicode script "Samaritan".
+ */
+ SAMARITAN,
+
+ /**
+ * Unicode script "Mandaic".
+ */
+ MANDAIC,
+
+ /**
+ * Unicode script "Lisu".
+ */
+ LISU,
+
+ /**
+ * Unicode script "Bamum".
+ */
+ BAMUM,
+
+ /**
+ * Unicode script "Javanese".
+ */
+ JAVANESE,
+
+ /**
+ * Unicode script "Meetei_Mayek".
+ */
+ MEETEI_MAYEK,
+
+ /**
+ * Unicode script "Imperial_Aramaic".
+ */
+ IMPERIAL_ARAMAIC,
+
+ /**
+ * Unicode script "Old_South_Arabian".
+ */
+ OLD_SOUTH_ARABIAN,
+
+ /**
+ * Unicode script "Inscriptional_Parthian".
+ */
+ INSCRIPTIONAL_PARTHIAN,
+
+ /**
+ * Unicode script "Inscriptional_Pahlavi".
+ */
+ INSCRIPTIONAL_PAHLAVI,
+
+ /**
+ * Unicode script "Old_Turkic".
+ */
+ OLD_TURKIC,
+
+ /**
+ * Unicode script "Brahmi".
+ */
+ BRAHMI,
+
+ /**
+ * Unicode script "Kaithi".
+ */
+ KAITHI,
+
+ /**
+ * Unicode script "Meroitic Hieroglyphs".
+ */
+ MEROITIC_HIEROGLYPHS,
+
+ /**
+ * Unicode script "Meroitic Cursive".
+ */
+ MEROITIC_CURSIVE,
+
+ /**
+ * Unicode script "Sora Sompeng".
+ */
+ SORA_SOMPENG,
+
+ /**
+ * Unicode script "Chakma".
+ */
+ CHAKMA,
+
+ /**
+ * Unicode script "Sharada".
+ */
+ SHARADA,
+
+ /**
+ * Unicode script "Takri".
+ */
+ TAKRI,
+
+ /**
+ * Unicode script "Miao".
+ */
+ MIAO,
+
+ /**
+ * Unicode script "Unknown".
+ */
+ UNKNOWN;
+
+ private static final int[] scriptStarts = {
+ 0x0000, // 0000..0040; COMMON
+ 0x0041, // 0041..005A; LATIN
+ 0x005B, // 005B..0060; COMMON
+ 0x0061, // 0061..007A; LATIN
+ 0x007B, // 007B..00A9; COMMON
+ 0x00AA, // 00AA..00AA; LATIN
+ 0x00AB, // 00AB..00B9; COMMON
+ 0x00BA, // 00BA..00BA; LATIN
+ 0x00BB, // 00BB..00BF; COMMON
+ 0x00C0, // 00C0..00D6; LATIN
+ 0x00D7, // 00D7..00D7; COMMON
+ 0x00D8, // 00D8..00F6; LATIN
+ 0x00F7, // 00F7..00F7; COMMON
+ 0x00F8, // 00F8..02B8; LATIN
+ 0x02B9, // 02B9..02DF; COMMON
+ 0x02E0, // 02E0..02E4; LATIN
+ 0x02E5, // 02E5..02E9; COMMON
+ 0x02EA, // 02EA..02EB; BOPOMOFO
+ 0x02EC, // 02EC..02FF; COMMON
+ 0x0300, // 0300..036F; INHERITED
+ 0x0370, // 0370..0373; GREEK
+ 0x0374, // 0374..0374; COMMON
+ 0x0375, // 0375..037D; GREEK
+ 0x037E, // 037E..0383; COMMON
+ 0x0384, // 0384..0384; GREEK
+ 0x0385, // 0385..0385; COMMON
+ 0x0386, // 0386..0386; GREEK
+ 0x0387, // 0387..0387; COMMON
+ 0x0388, // 0388..03E1; GREEK
+ 0x03E2, // 03E2..03EF; COPTIC
+ 0x03F0, // 03F0..03FF; GREEK
+ 0x0400, // 0400..0484; CYRILLIC
+ 0x0485, // 0485..0486; INHERITED
+ 0x0487, // 0487..0530; CYRILLIC
+ 0x0531, // 0531..0588; ARMENIAN
+ 0x0589, // 0589..0589; COMMON
+ 0x058A, // 058A..0590; ARMENIAN
+ 0x0591, // 0591..05FF; HEBREW
+ 0x0600, // 0600..060B; ARABIC
+ 0x060C, // 060C..060C; COMMON
+ 0x060D, // 060D..061A; ARABIC
+ 0x061B, // 061B..061D; COMMON
+ 0x061E, // 061E..061E; ARABIC
+ 0x061F, // 061F..061F; COMMON
+ 0x0620, // 0620..063F; ARABIC
+ 0x0640, // 0640..0640; COMMON
+ 0x0641, // 0641..064A; ARABIC
+ 0x064B, // 064B..0655; INHERITED
+ 0x0656, // 0656..065F; ARABIC
+ 0x0660, // 0660..0669; COMMON
+ 0x066A, // 066A..066F; ARABIC
+ 0x0670, // 0670..0670; INHERITED
+ 0x0671, // 0671..06DC; ARABIC
+ 0x06DD, // 06DD..06DD; COMMON
+ 0x06DE, // 06DE..06FF; ARABIC
+ 0x0700, // 0700..074F; SYRIAC
+ 0x0750, // 0750..077F; ARABIC
+ 0x0780, // 0780..07BF; THAANA
+ 0x07C0, // 07C0..07FF; NKO
+ 0x0800, // 0800..083F; SAMARITAN
+ 0x0840, // 0840..089F; MANDAIC
+ 0x08A0, // 08A0..08FF; ARABIC
+ 0x0900, // 0900..0950; DEVANAGARI
+ 0x0951, // 0951..0952; INHERITED
+ 0x0953, // 0953..0963; DEVANAGARI
+ 0x0964, // 0964..0965; COMMON
+ 0x0966, // 0966..0980; DEVANAGARI
+ 0x0981, // 0981..0A00; BENGALI
+ 0x0A01, // 0A01..0A80; GURMUKHI
+ 0x0A81, // 0A81..0B00; GUJARATI
+ 0x0B01, // 0B01..0B81; ORIYA
+ 0x0B82, // 0B82..0C00; TAMIL
+ 0x0C01, // 0C01..0C81; TELUGU
+ 0x0C82, // 0C82..0CF0; KANNADA
+ 0x0D02, // 0D02..0D81; MALAYALAM
+ 0x0D82, // 0D82..0E00; SINHALA
+ 0x0E01, // 0E01..0E3E; THAI
+ 0x0E3F, // 0E3F..0E3F; COMMON
+ 0x0E40, // 0E40..0E80; THAI
+ 0x0E81, // 0E81..0EFF; LAO
+ 0x0F00, // 0F00..0FD4; TIBETAN
+ 0x0FD5, // 0FD5..0FD8; COMMON
+ 0x0FD9, // 0FD9..0FFF; TIBETAN
+ 0x1000, // 1000..109F; MYANMAR
+ 0x10A0, // 10A0..10FA; GEORGIAN
+ 0x10FB, // 10FB..10FB; COMMON
+ 0x10FC, // 10FC..10FF; GEORGIAN
+ 0x1100, // 1100..11FF; HANGUL
+ 0x1200, // 1200..139F; ETHIOPIC
+ 0x13A0, // 13A0..13FF; CHEROKEE
+ 0x1400, // 1400..167F; CANADIAN_ABORIGINAL
+ 0x1680, // 1680..169F; OGHAM
+ 0x16A0, // 16A0..16EA; RUNIC
+ 0x16EB, // 16EB..16ED; COMMON
+ 0x16EE, // 16EE..16FF; RUNIC
+ 0x1700, // 1700..171F; TAGALOG
+ 0x1720, // 1720..1734; HANUNOO
+ 0x1735, // 1735..173F; COMMON
+ 0x1740, // 1740..175F; BUHID
+ 0x1760, // 1760..177F; TAGBANWA
+ 0x1780, // 1780..17FF; KHMER
+ 0x1800, // 1800..1801; MONGOLIAN
+ 0x1802, // 1802..1803; COMMON
+ 0x1804, // 1804..1804; MONGOLIAN
+ 0x1805, // 1805..1805; COMMON
+ 0x1806, // 1806..18AF; MONGOLIAN
+ 0x18B0, // 18B0..18FF; CANADIAN_ABORIGINAL
+ 0x1900, // 1900..194F; LIMBU
+ 0x1950, // 1950..197F; TAI_LE
+ 0x1980, // 1980..19DF; NEW_TAI_LUE
+ 0x19E0, // 19E0..19FF; KHMER
+ 0x1A00, // 1A00..1A1F; BUGINESE
+ 0x1A20, // 1A20..1AFF; TAI_THAM
+ 0x1B00, // 1B00..1B7F; BALINESE
+ 0x1B80, // 1B80..1BBF; SUNDANESE
+ 0x1BC0, // 1BC0..1BFF; BATAK
+ 0x1C00, // 1C00..1C4F; LEPCHA
+ 0x1C50, // 1C50..1CBF; OL_CHIKI
+ 0x1CC0, // 1CC0..1CCF; SUNDANESE
+ 0x1CD0, // 1CD0..1CD2; INHERITED
+ 0x1CD3, // 1CD3..1CD3; COMMON
+ 0x1CD4, // 1CD4..1CE0; INHERITED
+ 0x1CE1, // 1CE1..1CE1; COMMON
+ 0x1CE2, // 1CE2..1CE8; INHERITED
+ 0x1CE9, // 1CE9..1CEC; COMMON
+ 0x1CED, // 1CED..1CED; INHERITED
+ 0x1CEE, // 1CEE..1CF3; COMMON
+ 0x1CF4, // 1CF4..1CF4; INHERITED
+ 0x1CF5, // 1CF5..1CFF; COMMON
+ 0x1D00, // 1D00..1D25; LATIN
+ 0x1D26, // 1D26..1D2A; GREEK
+ 0x1D2B, // 1D2B..1D2B; CYRILLIC
+ 0x1D2C, // 1D2C..1D5C; LATIN
+ 0x1D5D, // 1D5D..1D61; GREEK
+ 0x1D62, // 1D62..1D65; LATIN
+ 0x1D66, // 1D66..1D6A; GREEK
+ 0x1D6B, // 1D6B..1D77; LATIN
+ 0x1D78, // 1D78..1D78; CYRILLIC
+ 0x1D79, // 1D79..1DBE; LATIN
+ 0x1DBF, // 1DBF..1DBF; GREEK
+ 0x1DC0, // 1DC0..1DFF; INHERITED
+ 0x1E00, // 1E00..1EFF; LATIN
+ 0x1F00, // 1F00..1FFF; GREEK
+ 0x2000, // 2000..200B; COMMON
+ 0x200C, // 200C..200D; INHERITED
+ 0x200E, // 200E..2070; COMMON
+ 0x2071, // 2071..2073; LATIN
+ 0x2074, // 2074..207E; COMMON
+ 0x207F, // 207F..207F; LATIN
+ 0x2080, // 2080..208F; COMMON
+ 0x2090, // 2090..209F; LATIN
+ 0x20A0, // 20A0..20CF; COMMON
+ 0x20D0, // 20D0..20FF; INHERITED
+ 0x2100, // 2100..2125; COMMON
+ 0x2126, // 2126..2126; GREEK
+ 0x2127, // 2127..2129; COMMON
+ 0x212A, // 212A..212B; LATIN
+ 0x212C, // 212C..2131; COMMON
+ 0x2132, // 2132..2132; LATIN
+ 0x2133, // 2133..214D; COMMON
+ 0x214E, // 214E..214E; LATIN
+ 0x214F, // 214F..215F; COMMON
+ 0x2160, // 2160..2188; LATIN
+ 0x2189, // 2189..27FF; COMMON
+ 0x2800, // 2800..28FF; BRAILLE
+ 0x2900, // 2900..2BFF; COMMON
+ 0x2C00, // 2C00..2C5F; GLAGOLITIC
+ 0x2C60, // 2C60..2C7F; LATIN
+ 0x2C80, // 2C80..2CFF; COPTIC
+ 0x2D00, // 2D00..2D2F; GEORGIAN
+ 0x2D30, // 2D30..2D7F; TIFINAGH
+ 0x2D80, // 2D80..2DDF; ETHIOPIC
+ 0x2DE0, // 2DE0..2DFF; CYRILLIC
+ 0x2E00, // 2E00..2E7F; COMMON
+ 0x2E80, // 2E80..2FEF; HAN
+ 0x2FF0, // 2FF0..3004; COMMON
+ 0x3005, // 3005..3005; HAN
+ 0x3006, // 3006..3006; COMMON
+ 0x3007, // 3007..3007; HAN
+ 0x3008, // 3008..3020; COMMON
+ 0x3021, // 3021..3029; HAN
+ 0x302A, // 302A..302D; INHERITED
+ 0x302E, // 302E..302F; HANGUL
+ 0x3030, // 3030..3037; COMMON
+ 0x3038, // 3038..303B; HAN
+ 0x303C, // 303C..3040; COMMON
+ 0x3041, // 3041..3098; HIRAGANA
+ 0x3099, // 3099..309A; INHERITED
+ 0x309B, // 309B..309C; COMMON
+ 0x309D, // 309D..309F; HIRAGANA
+ 0x30A0, // 30A0..30A0; COMMON
+ 0x30A1, // 30A1..30FA; KATAKANA
+ 0x30FB, // 30FB..30FC; COMMON
+ 0x30FD, // 30FD..3104; KATAKANA
+ 0x3105, // 3105..3130; BOPOMOFO
+ 0x3131, // 3131..318F; HANGUL
+ 0x3190, // 3190..319F; COMMON
+ 0x31A0, // 31A0..31BF; BOPOMOFO
+ 0x31C0, // 31C0..31EF; COMMON
+ 0x31F0, // 31F0..31FF; KATAKANA
+ 0x3200, // 3200..321F; HANGUL
+ 0x3220, // 3220..325F; COMMON
+ 0x3260, // 3260..327E; HANGUL
+ 0x327F, // 327F..32CF; COMMON
+ 0x32D0, // 32D0..3357; KATAKANA
+ 0x3358, // 3358..33FF; COMMON
+ 0x3400, // 3400..4DBF; HAN
+ 0x4DC0, // 4DC0..4DFF; COMMON
+ 0x4E00, // 4E00..9FFF; HAN
+ 0xA000, // A000..A4CF; YI
+ 0xA4D0, // A4D0..A4FF; LISU
+ 0xA500, // A500..A63F; VAI
+ 0xA640, // A640..A69F; CYRILLIC
+ 0xA6A0, // A6A0..A6FF; BAMUM
+ 0xA700, // A700..A721; COMMON
+ 0xA722, // A722..A787; LATIN
+ 0xA788, // A788..A78A; COMMON
+ 0xA78B, // A78B..A7FF; LATIN
+ 0xA800, // A800..A82F; SYLOTI_NAGRI
+ 0xA830, // A830..A83F; COMMON
+ 0xA840, // A840..A87F; PHAGS_PA
+ 0xA880, // A880..A8DF; SAURASHTRA
+ 0xA8E0, // A8E0..A8FF; DEVANAGARI
+ 0xA900, // A900..A92F; KAYAH_LI
+ 0xA930, // A930..A95F; REJANG
+ 0xA960, // A960..A97F; HANGUL
+ 0xA980, // A980..A9FF; JAVANESE
+ 0xAA00, // AA00..AA5F; CHAM
+ 0xAA60, // AA60..AA7F; MYANMAR
+ 0xAA80, // AA80..AADF; TAI_VIET
+ 0xAAE0, // AAE0..AB00; MEETEI_MAYEK
+ 0xAB01, // AB01..ABBF; ETHIOPIC
+ 0xABC0, // ABC0..ABFF; MEETEI_MAYEK
+ 0xAC00, // AC00..D7FB; HANGUL
+ 0xD7FC, // D7FC..F8FF; UNKNOWN
+ 0xF900, // F900..FAFF; HAN
+ 0xFB00, // FB00..FB12; LATIN
+ 0xFB13, // FB13..FB1C; ARMENIAN
+ 0xFB1D, // FB1D..FB4F; HEBREW
+ 0xFB50, // FB50..FD3D; ARABIC
+ 0xFD3E, // FD3E..FD4F; COMMON
+ 0xFD50, // FD50..FDFC; ARABIC
+ 0xFDFD, // FDFD..FDFF; COMMON
+ 0xFE00, // FE00..FE0F; INHERITED
+ 0xFE10, // FE10..FE1F; COMMON
+ 0xFE20, // FE20..FE2F; INHERITED
+ 0xFE30, // FE30..FE6F; COMMON
+ 0xFE70, // FE70..FEFE; ARABIC
+ 0xFEFF, // FEFF..FF20; COMMON
+ 0xFF21, // FF21..FF3A; LATIN
+ 0xFF3B, // FF3B..FF40; COMMON
+ 0xFF41, // FF41..FF5A; LATIN
+ 0xFF5B, // FF5B..FF65; COMMON
+ 0xFF66, // FF66..FF6F; KATAKANA
+ 0xFF70, // FF70..FF70; COMMON
+ 0xFF71, // FF71..FF9D; KATAKANA
+ 0xFF9E, // FF9E..FF9F; COMMON
+ 0xFFA0, // FFA0..FFDF; HANGUL
+ 0xFFE0, // FFE0..FFFF; COMMON
+ 0x10000, // 10000..100FF; LINEAR_B
+ 0x10100, // 10100..1013F; COMMON
+ 0x10140, // 10140..1018F; GREEK
+ 0x10190, // 10190..101FC; COMMON
+ 0x101FD, // 101FD..1027F; INHERITED
+ 0x10280, // 10280..1029F; LYCIAN
+ 0x102A0, // 102A0..102FF; CARIAN
+ 0x10300, // 10300..1032F; OLD_ITALIC
+ 0x10330, // 10330..1037F; GOTHIC
+ 0x10380, // 10380..1039F; UGARITIC
+ 0x103A0, // 103A0..103FF; OLD_PERSIAN
+ 0x10400, // 10400..1044F; DESERET
+ 0x10450, // 10450..1047F; SHAVIAN
+ 0x10480, // 10480..107FF; OSMANYA
+ 0x10800, // 10800..1083F; CYPRIOT
+ 0x10840, // 10840..108FF; IMPERIAL_ARAMAIC
+ 0x10900, // 10900..1091F; PHOENICIAN
+ 0x10920, // 10920..1097F; LYDIAN
+ 0x10980, // 10980..1099F; MEROITIC_HIEROGLYPHS
+ 0x109A0, // 109A0..109FF; MEROITIC_CURSIVE
+ 0x10A00, // 10A00..10A5F; KHAROSHTHI
+ 0x10A60, // 10A60..10AFF; OLD_SOUTH_ARABIAN
+ 0x10B00, // 10B00..10B3F; AVESTAN
+ 0x10B40, // 10B40..10B5F; INSCRIPTIONAL_PARTHIAN
+ 0x10B60, // 10B60..10BFF; INSCRIPTIONAL_PAHLAVI
+ 0x10C00, // 10C00..10E5F; OLD_TURKIC
+ 0x10E60, // 10E60..10FFF; ARABIC
+ 0x11000, // 11000..1107F; BRAHMI
+ 0x11080, // 11080..110CF; KAITHI
+ 0x110D0, // 110D0..110FF; SORA_SOMPENG
+ 0x11100, // 11100..1117F; CHAKMA
+ 0x11180, // 11180..1167F; SHARADA
+ 0x11680, // 11680..116CF; TAKRI
+ 0x12000, // 12000..12FFF; CUNEIFORM
+ 0x13000, // 13000..167FF; EGYPTIAN_HIEROGLYPHS
+ 0x16800, // 16800..16A38; BAMUM
+ 0x16F00, // 16F00..16F9F; MIAO
+ 0x1B000, // 1B000..1B000; KATAKANA
+ 0x1B001, // 1B001..1CFFF; HIRAGANA
+ 0x1D000, // 1D000..1D166; COMMON
+ 0x1D167, // 1D167..1D169; INHERITED
+ 0x1D16A, // 1D16A..1D17A; COMMON
+ 0x1D17B, // 1D17B..1D182; INHERITED
+ 0x1D183, // 1D183..1D184; COMMON
+ 0x1D185, // 1D185..1D18B; INHERITED
+ 0x1D18C, // 1D18C..1D1A9; COMMON
+ 0x1D1AA, // 1D1AA..1D1AD; INHERITED
+ 0x1D1AE, // 1D1AE..1D1FF; COMMON
+ 0x1D200, // 1D200..1D2FF; GREEK
+ 0x1D300, // 1D300..1EDFF; COMMON
+ 0x1EE00, // 1EE00..1EFFF; ARABIC
+ 0x1F000, // 1F000..1F1FF; COMMON
+ 0x1F200, // 1F200..1F200; HIRAGANA
+ 0x1F201, // 1F210..1FFFF; COMMON
+ 0x20000, // 20000..E0000; HAN
+ 0xE0001, // E0001..E00FF; COMMON
+ 0xE0100, // E0100..E01EF; INHERITED
+ 0xE01F0 // E01F0..10FFFF; UNKNOWN
+
+ };
+
+ private static final UnicodeScript[] scripts = {
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ BOPOMOFO,
+ COMMON,
+ INHERITED,
+ GREEK,
+ COMMON,
+ GREEK,
+ COMMON,
+ GREEK,
+ COMMON,
+ GREEK,
+ COMMON,
+ GREEK,
+ COPTIC,
+ GREEK,
+ CYRILLIC,
+ INHERITED,
+ CYRILLIC,
+ ARMENIAN,
+ COMMON,
+ ARMENIAN,
+ HEBREW,
+ ARABIC,
+ COMMON,
+ ARABIC,
+ COMMON,
+ ARABIC,
+ COMMON,
+ ARABIC,
+ COMMON,
+ ARABIC,
+ INHERITED,
+ ARABIC,
+ COMMON,
+ ARABIC,
+ INHERITED,
+ ARABIC,
+ COMMON,
+ ARABIC,
+ SYRIAC,
+ ARABIC,
+ THAANA,
+ NKO,
+ SAMARITAN,
+ MANDAIC,
+ ARABIC,
+ DEVANAGARI,
+ INHERITED,
+ DEVANAGARI,
+ COMMON,
+ DEVANAGARI,
+ BENGALI,
+ GURMUKHI,
+ GUJARATI,
+ ORIYA,
+ TAMIL,
+ TELUGU,
+ KANNADA,
+ MALAYALAM,
+ SINHALA,
+ THAI,
+ COMMON,
+ THAI,
+ LAO,
+ TIBETAN,
+ COMMON,
+ TIBETAN,
+ MYANMAR,
+ GEORGIAN,
+ COMMON,
+ GEORGIAN,
+ HANGUL,
+ ETHIOPIC,
+ CHEROKEE,
+ CANADIAN_ABORIGINAL,
+ OGHAM,
+ RUNIC,
+ COMMON,
+ RUNIC,
+ TAGALOG,
+ HANUNOO,
+ COMMON,
+ BUHID,
+ TAGBANWA,
+ KHMER,
+ MONGOLIAN,
+ COMMON,
+ MONGOLIAN,
+ COMMON,
+ MONGOLIAN,
+ CANADIAN_ABORIGINAL,
+ LIMBU,
+ TAI_LE,
+ NEW_TAI_LUE,
+ KHMER,
+ BUGINESE,
+ TAI_THAM,
+ BALINESE,
+ SUNDANESE,
+ BATAK,
+ LEPCHA,
+ OL_CHIKI,
+ SUNDANESE,
+ INHERITED,
+ COMMON,
+ INHERITED,
+ COMMON,
+ INHERITED,
+ COMMON,
+ INHERITED,
+ COMMON,
+ INHERITED,
+ COMMON,
+ LATIN,
+ GREEK,
+ CYRILLIC,
+ LATIN,
+ GREEK,
+ LATIN,
+ GREEK,
+ LATIN,
+ CYRILLIC,
+ LATIN,
+ GREEK,
+ INHERITED,
+ LATIN,
+ GREEK,
+ COMMON,
+ INHERITED,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ INHERITED,
+ COMMON,
+ GREEK,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ BRAILLE,
+ COMMON,
+ GLAGOLITIC,
+ LATIN,
+ COPTIC,
+ GEORGIAN,
+ TIFINAGH,
+ ETHIOPIC,
+ CYRILLIC,
+ COMMON,
+ HAN,
+ COMMON,
+ HAN,
+ COMMON,
+ HAN,
+ COMMON,
+ HAN,
+ INHERITED,
+ HANGUL,
+ COMMON,
+ HAN,
+ COMMON,
+ HIRAGANA,
+ INHERITED,
+ COMMON,
+ HIRAGANA,
+ COMMON,
+ KATAKANA,
+ COMMON,
+ KATAKANA,
+ BOPOMOFO,
+ HANGUL,
+ COMMON,
+ BOPOMOFO,
+ COMMON,
+ KATAKANA,
+ HANGUL,
+ COMMON,
+ HANGUL,
+ COMMON,
+ KATAKANA,
+ COMMON,
+ HAN,
+ COMMON,
+ HAN,
+ YI,
+ LISU,
+ VAI,
+ CYRILLIC,
+ BAMUM,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ SYLOTI_NAGRI,
+ COMMON,
+ PHAGS_PA,
+ SAURASHTRA,
+ DEVANAGARI,
+ KAYAH_LI,
+ REJANG,
+ HANGUL,
+ JAVANESE,
+ CHAM,
+ MYANMAR,
+ TAI_VIET,
+ MEETEI_MAYEK,
+ ETHIOPIC,
+ MEETEI_MAYEK,
+ HANGUL,
+ UNKNOWN ,
+ HAN,
+ LATIN,
+ ARMENIAN,
+ HEBREW,
+ ARABIC,
+ COMMON,
+ ARABIC,
+ COMMON,
+ INHERITED,
+ COMMON,
+ INHERITED,
+ COMMON,
+ ARABIC,
+ COMMON,
+ LATIN,
+ COMMON,
+ LATIN,
+ COMMON,
+ KATAKANA,
+ COMMON,
+ KATAKANA,
+ COMMON,
+ HANGUL,
+ COMMON,
+ LINEAR_B,
+ COMMON,
+ GREEK,
+ COMMON,
+ INHERITED,
+ LYCIAN,
+ CARIAN,
+ OLD_ITALIC,
+ GOTHIC,
+ UGARITIC,
+ OLD_PERSIAN,
+ DESERET,
+ SHAVIAN,
+ OSMANYA,
+ CYPRIOT,
+ IMPERIAL_ARAMAIC,
+ PHOENICIAN,
+ LYDIAN,
+ MEROITIC_HIEROGLYPHS,
+ MEROITIC_CURSIVE,
+ KHAROSHTHI,
+ OLD_SOUTH_ARABIAN,
+ AVESTAN,
+ INSCRIPTIONAL_PARTHIAN,
+ INSCRIPTIONAL_PAHLAVI,
+ OLD_TURKIC,
+ ARABIC,
+ BRAHMI,
+ KAITHI,
+ SORA_SOMPENG,
+ CHAKMA,
+ SHARADA,
+ TAKRI,
+ CUNEIFORM,
+ EGYPTIAN_HIEROGLYPHS,
+ BAMUM,
+ MIAO,
+ KATAKANA,
+ HIRAGANA,
+ COMMON,
+ INHERITED,
+ COMMON,
+ INHERITED,
+ COMMON,
+ INHERITED,
+ COMMON,
+ INHERITED,
+ COMMON,
+ GREEK,
+ COMMON,
+ ARABIC,
+ COMMON,
+ HIRAGANA,
+ COMMON,
+ HAN,
+ COMMON,
+ INHERITED,
+ UNKNOWN
+ };
+
+ private static HashMap<String, Character.UnicodeScript> aliases;
+ static {
+ aliases = new HashMap<>(128);
+ aliases.put("ARAB", ARABIC);
+ aliases.put("ARMI", IMPERIAL_ARAMAIC);
+ aliases.put("ARMN", ARMENIAN);
+ aliases.put("AVST", AVESTAN);
+ aliases.put("BALI", BALINESE);
+ aliases.put("BAMU", BAMUM);
+ aliases.put("BATK", BATAK);
+ aliases.put("BENG", BENGALI);
+ aliases.put("BOPO", BOPOMOFO);
+ aliases.put("BRAI", BRAILLE);
+ aliases.put("BRAH", BRAHMI);
+ aliases.put("BUGI", BUGINESE);
+ aliases.put("BUHD", BUHID);
+ aliases.put("CAKM", CHAKMA);
+ aliases.put("CANS", CANADIAN_ABORIGINAL);
+ aliases.put("CARI", CARIAN);
+ aliases.put("CHAM", CHAM);
+ aliases.put("CHER", CHEROKEE);
+ aliases.put("COPT", COPTIC);
+ aliases.put("CPRT", CYPRIOT);
+ aliases.put("CYRL", CYRILLIC);
+ aliases.put("DEVA", DEVANAGARI);
+ aliases.put("DSRT", DESERET);
+ aliases.put("EGYP", EGYPTIAN_HIEROGLYPHS);
+ aliases.put("ETHI", ETHIOPIC);
+ aliases.put("GEOR", GEORGIAN);
+ aliases.put("GLAG", GLAGOLITIC);
+ aliases.put("GOTH", GOTHIC);
+ aliases.put("GREK", GREEK);
+ aliases.put("GUJR", GUJARATI);
+ aliases.put("GURU", GURMUKHI);
+ aliases.put("HANG", HANGUL);
+ aliases.put("HANI", HAN);
+ aliases.put("HANO", HANUNOO);
+ aliases.put("HEBR", HEBREW);
+ aliases.put("HIRA", HIRAGANA);
+ // it appears we don't have the KATAKANA_OR_HIRAGANA
+ //aliases.put("HRKT", KATAKANA_OR_HIRAGANA);
+ aliases.put("ITAL", OLD_ITALIC);
+ aliases.put("JAVA", JAVANESE);
+ aliases.put("KALI", KAYAH_LI);
+ aliases.put("KANA", KATAKANA);
+ aliases.put("KHAR", KHAROSHTHI);
+ aliases.put("KHMR", KHMER);
+ aliases.put("KNDA", KANNADA);
+ aliases.put("KTHI", KAITHI);
+ aliases.put("LANA", TAI_THAM);
+ aliases.put("LAOO", LAO);
+ aliases.put("LATN", LATIN);
+ aliases.put("LEPC", LEPCHA);
+ aliases.put("LIMB", LIMBU);
+ aliases.put("LINB", LINEAR_B);
+ aliases.put("LISU", LISU);
+ aliases.put("LYCI", LYCIAN);
+ aliases.put("LYDI", LYDIAN);
+ aliases.put("MAND", MANDAIC);
+ aliases.put("MERC", MEROITIC_CURSIVE);
+ aliases.put("MERO", MEROITIC_HIEROGLYPHS);
+ aliases.put("MLYM", MALAYALAM);
+ aliases.put("MONG", MONGOLIAN);
+ aliases.put("MTEI", MEETEI_MAYEK);
+ aliases.put("MYMR", MYANMAR);
+ aliases.put("NKOO", NKO);
+ aliases.put("OGAM", OGHAM);
+ aliases.put("OLCK", OL_CHIKI);
+ aliases.put("ORKH", OLD_TURKIC);
+ aliases.put("ORYA", ORIYA);
+ aliases.put("OSMA", OSMANYA);
+ aliases.put("PHAG", PHAGS_PA);
+ aliases.put("PLRD", MIAO);
+ aliases.put("PHLI", INSCRIPTIONAL_PAHLAVI);
+ aliases.put("PHNX", PHOENICIAN);
+ aliases.put("PRTI", INSCRIPTIONAL_PARTHIAN);
+ aliases.put("RJNG", REJANG);
+ aliases.put("RUNR", RUNIC);
+ aliases.put("SAMR", SAMARITAN);
+ aliases.put("SARB", OLD_SOUTH_ARABIAN);
+ aliases.put("SAUR", SAURASHTRA);
+ aliases.put("SHAW", SHAVIAN);
+ aliases.put("SHRD", SHARADA);
+ aliases.put("SINH", SINHALA);
+ aliases.put("SORA", SORA_SOMPENG);
+ aliases.put("SUND", SUNDANESE);
+ aliases.put("SYLO", SYLOTI_NAGRI);
+ aliases.put("SYRC", SYRIAC);
+ aliases.put("TAGB", TAGBANWA);
+ aliases.put("TALE", TAI_LE);
+ aliases.put("TAKR", TAKRI);
+ aliases.put("TALU", NEW_TAI_LUE);
+ aliases.put("TAML", TAMIL);
+ aliases.put("TAVT", TAI_VIET);
+ aliases.put("TELU", TELUGU);
+ aliases.put("TFNG", TIFINAGH);
+ aliases.put("TGLG", TAGALOG);
+ aliases.put("THAA", THAANA);
+ aliases.put("THAI", THAI);
+ aliases.put("TIBT", TIBETAN);
+ aliases.put("UGAR", UGARITIC);
+ aliases.put("VAII", VAI);
+ aliases.put("XPEO", OLD_PERSIAN);
+ aliases.put("XSUX", CUNEIFORM);
+ aliases.put("YIII", YI);
+ aliases.put("ZINH", INHERITED);
+ aliases.put("ZYYY", COMMON);
+ aliases.put("ZZZZ", UNKNOWN);
+ }
+
+ /**
+ * Returns the enum constant representing the Unicode script of which
+ * the given character (Unicode code point) is assigned to.
+ *
+ * @param codePoint the character (Unicode code point) in question.
+ * @return The {@code UnicodeScript} constant representing the
+ * Unicode script of which this character is assigned to.
+ *
+ * @exception IllegalArgumentException if the specified
+ * {@code codePoint} is an invalid Unicode code point.
+ * @see Character#isValidCodePoint(int)
+ *
+ */
+ public static UnicodeScript of(int codePoint) {
+ if (!isValidCodePoint(codePoint))
+ throw new IllegalArgumentException();
+ int type = getType(codePoint);
+ // leave SURROGATE and PRIVATE_USE for table lookup
+ if (type == UNASSIGNED)
+ return UNKNOWN;
+ int index = Arrays.binarySearch(scriptStarts, codePoint);
+ if (index < 0)
+ index = -index - 2;
+ return scripts[index];
+ }
+
+ /**
+ * Returns the UnicodeScript constant with the given Unicode script
+ * name or the script name alias. Script names and their aliases are
+ * determined by The Unicode Standard. The files Scripts<version>.txt
+ * and PropertyValueAliases<version>.txt define script names
+ * and the script name aliases for a particular version of the
+ * standard. The {@link Character} class specifies the version of
+ * the standard that it supports.
+ * <p>
+ * Character case is ignored for all of the valid script names.
+ * The en_US locale's case mapping rules are used to provide
+ * case-insensitive string comparisons for script name validation.
+ * <p>
+ *
+ * @param scriptName A {@code UnicodeScript} name.
+ * @return The {@code UnicodeScript} constant identified
+ * by {@code scriptName}
+ * @throws IllegalArgumentException if {@code scriptName} is an
+ * invalid name
+ * @throws NullPointerException if {@code scriptName} is null
+ */
+ public static final UnicodeScript forName(String scriptName) {
+ scriptName = scriptName.toUpperCase(Locale.ENGLISH);
+ //.replace(' ', '_'));
+ UnicodeScript sc = aliases.get(scriptName);
+ if (sc != null)
+ return sc;
+ return valueOf(scriptName);
+ }
+ }
+
+ /**
+ * The value of the {@code Character}.
+ *
+ * @serial
+ */
+ private final char value;
+
+ /** use serialVersionUID from JDK 1.0.2 for interoperability */
+ private static final long serialVersionUID = 3786198910865385080L;
+
+ /**
+ * Constructs a newly allocated {@code Character} object that
+ * represents the specified {@code char} value.
+ *
+ * @param value the value to be represented by the
+ * {@code Character} object.
+ */
+ public Character(char value) {
+ this.value = value;
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // We disable caching to avoid large arrays.
+ // private static class CharacterCache {
+ // private CharacterCache(){}
+
+ // static final Character cache[] = new Character[127 + 1];
+
+ // static {
+ // for (int i = 0; i < cache.length; i++)
+ // cache[i] = new Character((char)i);
+ // }
+ // }
+
+ /**
+ * Returns a <tt>Character</tt> instance representing the specified
+ * <tt>char</tt> value.
+ * If a new <tt>Character</tt> instance is not required, this method
+ * should generally be used in preference to the constructor
+ * {@link #Character(char)}, as this method is likely to yield
+ * significantly better space and time performance by caching
+ * frequently requested values.
+ *
+ * This method will always cache values in the range {@code
+ * '\u005Cu0000'} to {@code '\u005Cu007F'}, inclusive, and may
+ * cache other values outside of this range.
+ *
+ * @param c a char value.
+ * @return a <tt>Character</tt> instance representing <tt>c</tt>.
+ * @since 1.5
+ */
+ public static Character valueOf(char c) {
+ // DIFFBLUE MODEL LIBRARY
+ // We disable caching to avoid large arrays.
+ // if (c <= 127) { // must cache
+ // return CharacterCache.cache[(int)c];
+ // }
+ return new Character(c);
+ }
+
+ /**
+ * Returns the value of this {@code Character} object.
+ * @return the primitive {@code char} value represented by
+ * this object.
+ */
+ public char charValue() {
+ return value;
+ }
+
+ /**
+ * Returns a hash code for this {@code Character}; equal to the result
+ * of invoking {@code charValue()}.
+ *
+ * @return a hash code value for this {@code Character}
+ */
+ @Override
+ public int hashCode() {
+ return Character.hashCode(value);
+ }
+
+ /**
+ * Returns a hash code for a {@code char} value; compatible with
+ * {@code Character.hashCode()}.
+ *
+ * @since 1.8
+ *
+ * @param value The {@code char} for which to return a hash code.
+ * @return a hash code value for a {@code char} value.
+ */
+ public static int hashCode(char value) {
+ return (int)value;
+ }
+
+ /**
+ * Compares this object against the specified object.
+ * The result is {@code true} if and only if the argument is not
+ * {@code null} and is a {@code Character} object that
+ * represents the same {@code char} value as this object.
+ *
+ * @param obj the object to compare with.
+ * @return {@code true} if the objects are the same;
+ * {@code false} otherwise.
+ */
+ public boolean equals(Object obj) {
+ if (obj instanceof Character) {
+ return value == ((Character)obj).charValue();
+ }
+ return false;
+ }
+
+ /**
+ * Returns a {@code String} object representing this
+ * {@code Character}'s value. The result is a string of
+ * length 1 whose sole component is the primitive
+ * {@code char} value represented by this
+ * {@code Character} object.
+ *
+ * @return a string representation of this object.
+ */
+ public String toString() {
+ char buf[] = {value};
+ return String.valueOf(buf);
+ }
+
+ /**
+ * Returns a {@code String} object representing the
+ * specified {@code char}. The result is a string of length
+ * 1 consisting solely of the specified {@code char}.
+ *
+ * @param c the {@code char} to be converted
+ * @return the string representation of the specified {@code char}
+ * @since 1.4
+ */
+ public static String toString(char c) {
+ return String.valueOf(c);
+ }
+
+ /**
+ * Determines whether the specified code point is a valid
+ * <a href="http://www.unicode.org/glossary/#code_point">
+ * Unicode code point value</a>.
+ *
+ * @param codePoint the Unicode code point to be tested
+ * @return {@code true} if the specified code point value is between
+ * {@link #MIN_CODE_POINT} and
+ * {@link #MAX_CODE_POINT} inclusive;
+ * {@code false} otherwise.
+ * @since 1.5
+ */
+ public static boolean isValidCodePoint(int codePoint) {
+ // Optimized form of:
+ // codePoint >= MIN_CODE_POINT && codePoint <= MAX_CODE_POINT
+ int plane = codePoint >>> 16;
+ return plane < ((MAX_CODE_POINT + 1) >>> 16);
+ }
+
+ /**
+ * Determines whether the specified character (Unicode code point)
+ * is in the <a href="#BMP">Basic Multilingual Plane (BMP)</a>.
+ * Such code points can be represented using a single {@code char}.
+ *
+ * @param codePoint the character (Unicode code point) to be tested
+ * @return {@code true} if the specified code point is between
+ * {@link #MIN_VALUE} and {@link #MAX_VALUE} inclusive;
+ * {@code false} otherwise.
+ * @since 1.7
+ */
+ public static boolean isBmpCodePoint(int codePoint) {
+ return codePoint >>> 16 == 0;
+ // Optimized form of:
+ // codePoint >= MIN_VALUE && codePoint <= MAX_VALUE
+ // We consistently use logical shift (>>>) to facilitate
+ // additional runtime optimizations.
+ }
+
+ /**
+ * Determines whether the specified character (Unicode code point)
+ * is in the <a href="#supplementary">supplementary character</a> range.
+ *
+ * @param codePoint the character (Unicode code point) to be tested
+ * @return {@code true} if the specified code point is between
+ * {@link #MIN_SUPPLEMENTARY_CODE_POINT} and
+ * {@link #MAX_CODE_POINT} inclusive;
+ * {@code false} otherwise.
+ * @since 1.5
+ */
+ public static boolean isSupplementaryCodePoint(int codePoint) {
+ return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT
+ && codePoint < MAX_CODE_POINT + 1;
+ }
+
+ /**
+ * Determines if the given {@code char} value is a
+ * <a href="http://www.unicode.org/glossary/#high_surrogate_code_unit">
+ * Unicode high-surrogate code unit</a>
+ * (also known as <i>leading-surrogate code unit</i>).
+ *
+ * <p>Such values do not represent characters by themselves,
+ * but are used in the representation of
+ * <a href="#supplementary">supplementary characters</a>
+ * in the UTF-16 encoding.
+ *
+ * @param ch the {@code char} value to be tested.
+ * @return {@code true} if the {@code char} value is between
+ * {@link #MIN_HIGH_SURROGATE} and
+ * {@link #MAX_HIGH_SURROGATE} inclusive;
+ * {@code false} otherwise.
+ * @see Character#isLowSurrogate(char)
+ * @see Character.UnicodeBlock#of(int)
+ * @since 1.5
+ */
+ public static boolean isHighSurrogate(char ch) {
+ // Help VM constant-fold; MAX_HIGH_SURROGATE + 1 == MIN_LOW_SURROGATE
+ return ch >= MIN_HIGH_SURROGATE && ch < (MAX_HIGH_SURROGATE + 1);
+ }
+
+ /**
+ * Determines if the given {@code char} value is a
+ * <a href="http://www.unicode.org/glossary/#low_surrogate_code_unit">
+ * Unicode low-surrogate code unit</a>
+ * (also known as <i>trailing-surrogate code unit</i>).
+ *
+ * <p>Such values do not represent characters by themselves,
+ * but are used in the representation of
+ * <a href="#supplementary">supplementary characters</a>
+ * in the UTF-16 encoding.
+ *
+ * @param ch the {@code char} value to be tested.
+ * @return {@code true} if the {@code char} value is between
+ * {@link #MIN_LOW_SURROGATE} and
+ * {@link #MAX_LOW_SURROGATE} inclusive;
+ * {@code false} otherwise.
+ * @see Character#isHighSurrogate(char)
+ * @since 1.5
+ */
+ public static boolean isLowSurrogate(char ch) {
+ return ch >= MIN_LOW_SURROGATE && ch < (MAX_LOW_SURROGATE + 1);
+ }
+
+ /**
+ * Determines if the given {@code char} value is a Unicode
+ * <i>surrogate code unit</i>.
+ *
+ * <p>Such values do not represent characters by themselves,
+ * but are used in the representation of
+ * <a href="#supplementary">supplementary characters</a>
+ * in the UTF-16 encoding.
+ *
+ * <p>A char value is a surrogate code unit if and only if it is either
+ * a {@linkplain #isLowSurrogate(char) low-surrogate code unit} or
+ * a {@linkplain #isHighSurrogate(char) high-surrogate code unit}.
+ *
+ * @param ch the {@code char} value to be tested.
+ * @return {@code true} if the {@code char} value is between
+ * {@link #MIN_SURROGATE} and
+ * {@link #MAX_SURROGATE} inclusive;
+ * {@code false} otherwise.
+ * @since 1.7
+ */
+ public static boolean isSurrogate(char ch) {
+ return ch >= MIN_SURROGATE && ch < (MAX_SURROGATE + 1);
+ }
+
+ /**
+ * Determines whether the specified pair of {@code char}
+ * values is a valid
+ * <a href="http://www.unicode.org/glossary/#surrogate_pair">
+ * Unicode surrogate pair</a>.
+
+ * <p>This method is equivalent to the expression:
+ * <blockquote><pre>{@code
+ * isHighSurrogate(high) && isLowSurrogate(low)
+ * }</pre></blockquote>
+ *
+ * @param high the high-surrogate code value to be tested
+ * @param low the low-surrogate code value to be tested
+ * @return {@code true} if the specified high and
+ * low-surrogate code values represent a valid surrogate pair;
+ * {@code false} otherwise.
+ * @since 1.5
+ */
+ public static boolean isSurrogatePair(char high, char low) {
+ return isHighSurrogate(high) && isLowSurrogate(low);
+ }
+
+ /**
+ * Determines the number of {@code char} values needed to
+ * represent the specified character (Unicode code point). If the
+ * specified character is equal to or greater than 0x10000, then
+ * the method returns 2. Otherwise, the method returns 1.
+ *
+ * <p>This method doesn't validate the specified character to be a
+ * valid Unicode code point. The caller must validate the
+ * character value using {@link #isValidCodePoint(int) isValidCodePoint}
+ * if necessary.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return 2 if the character is a valid supplementary character; 1 otherwise.
+ * @see Character#isSupplementaryCodePoint(int)
+ * @since 1.5
+ */
+ public static int charCount(int codePoint) {
+ return codePoint >= MIN_SUPPLEMENTARY_CODE_POINT ? 2 : 1;
+ }
+
+ /**
+ * Converts the specified surrogate pair to its supplementary code
+ * point value. This method does not validate the specified
+ * surrogate pair. The caller must validate it using {@link
+ * #isSurrogatePair(char, char) isSurrogatePair} if necessary.
+ *
+ * @param high the high-surrogate code unit
+ * @param low the low-surrogate code unit
+ * @return the supplementary code point composed from the
+ * specified surrogate pair.
+ * @since 1.5
+ */
+ public static int toCodePoint(char high, char low) {
+ // Optimized form of:
+ // return ((high - MIN_HIGH_SURROGATE) << 10)
+ // + (low - MIN_LOW_SURROGATE)
+ // + MIN_SUPPLEMENTARY_CODE_POINT;
+ return ((high << 10) + low) + (MIN_SUPPLEMENTARY_CODE_POINT
+ - (MIN_HIGH_SURROGATE << 10)
+ - MIN_LOW_SURROGATE);
+ }
+
+ /**
+ * Returns the code point at the given index of the
+ * {@code CharSequence}. If the {@code char} value at
+ * the given index in the {@code CharSequence} is in the
+ * high-surrogate range, the following index is less than the
+ * length of the {@code CharSequence}, and the
+ * {@code char} value at the following index is in the
+ * low-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the {@code char} value at the given index is returned.
+ *
+ * @param seq a sequence of {@code char} values (Unicode code
+ * units)
+ * @param index the index to the {@code char} values (Unicode
+ * code units) in {@code seq} to be converted
+ * @return the Unicode code point at the given index
+ * @exception NullPointerException if {@code seq} is null.
+ * @exception IndexOutOfBoundsException if the value
+ * {@code index} is negative or not less than
+ * {@link CharSequence#length() seq.length()}.
+ * @since 1.5
+ */
+ public static int codePointAt(CharSequence seq, int index) {
+ char c1 = seq.charAt(index);
+ if (isHighSurrogate(c1) && ++index < seq.length()) {
+ char c2 = seq.charAt(index);
+ if (isLowSurrogate(c2)) {
+ return toCodePoint(c1, c2);
+ }
+ }
+ return c1;
+ }
+
+ /**
+ * Returns the code point at the given index of the
+ * {@code char} array. If the {@code char} value at
+ * the given index in the {@code char} array is in the
+ * high-surrogate range, the following index is less than the
+ * length of the {@code char} array, and the
+ * {@code char} value at the following index is in the
+ * low-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the {@code char} value at the given index is returned.
+ *
+ * @param a the {@code char} array
+ * @param index the index to the {@code char} values (Unicode
+ * code units) in the {@code char} array to be converted
+ * @return the Unicode code point at the given index
+ * @exception NullPointerException if {@code a} is null.
+ * @exception IndexOutOfBoundsException if the value
+ * {@code index} is negative or not less than
+ * the length of the {@code char} array.
+ * @since 1.5
+ */
+ public static int codePointAt(char[] a, int index) {
+ return codePointAtImpl(a, index, a.length);
+ }
+
+ /**
+ * Returns the code point at the given index of the
+ * {@code char} array, where only array elements with
+ * {@code index} less than {@code limit} can be used. If
+ * the {@code char} value at the given index in the
+ * {@code char} array is in the high-surrogate range, the
+ * following index is less than the {@code limit}, and the
+ * {@code char} value at the following index is in the
+ * low-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the {@code char} value at the given index is returned.
+ *
+ * @param a the {@code char} array
+ * @param index the index to the {@code char} values (Unicode
+ * code units) in the {@code char} array to be converted
+ * @param limit the index after the last array element that
+ * can be used in the {@code char} array
+ * @return the Unicode code point at the given index
+ * @exception NullPointerException if {@code a} is null.
+ * @exception IndexOutOfBoundsException if the {@code index}
+ * argument is negative or not less than the {@code limit}
+ * argument, or if the {@code limit} argument is negative or
+ * greater than the length of the {@code char} array.
+ * @since 1.5
+ */
+ public static int codePointAt(char[] a, int index, int limit) {
+ if (index >= limit || limit < 0 || limit > a.length) {
+ throw new IndexOutOfBoundsException();
+ }
+ return codePointAtImpl(a, index, limit);
+ }
+
+ // throws ArrayIndexOutOfBoundsException if index out of bounds
+ static int codePointAtImpl(char[] a, int index, int limit) {
+ char c1 = a[index];
+ if (isHighSurrogate(c1) && ++index < limit) {
+ char c2 = a[index];
+ if (isLowSurrogate(c2)) {
+ return toCodePoint(c1, c2);
+ }
+ }
+ return c1;
+ }
+
+ /**
+ * Returns the code point preceding the given index of the
+ * {@code CharSequence}. If the {@code char} value at
+ * {@code (index - 1)} in the {@code CharSequence} is in
+ * the low-surrogate range, {@code (index - 2)} is not
+ * negative, and the {@code char} value at {@code (index - 2)}
+ * in the {@code CharSequence} is in the
+ * high-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the {@code char} value at {@code (index - 1)} is
+ * returned.
+ *
+ * @param seq the {@code CharSequence} instance
+ * @param index the index following the code point that should be returned
+ * @return the Unicode code point value before the given index.
+ * @exception NullPointerException if {@code seq} is null.
+ * @exception IndexOutOfBoundsException if the {@code index}
+ * argument is less than 1 or greater than {@link
+ * CharSequence#length() seq.length()}.
+ * @since 1.5
+ */
+ public static int codePointBefore(CharSequence seq, int index) {
+ char c2 = seq.charAt(--index);
+ if (isLowSurrogate(c2) && index > 0) {
+ char c1 = seq.charAt(--index);
+ if (isHighSurrogate(c1)) {
+ return toCodePoint(c1, c2);
+ }
+ }
+ return c2;
+ }
+
+ /**
+ * Returns the code point preceding the given index of the
+ * {@code char} array. If the {@code char} value at
+ * {@code (index - 1)} in the {@code char} array is in
+ * the low-surrogate range, {@code (index - 2)} is not
+ * negative, and the {@code char} value at {@code (index - 2)}
+ * in the {@code char} array is in the
+ * high-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the {@code char} value at {@code (index - 1)} is
+ * returned.
+ *
+ * @param a the {@code char} array
+ * @param index the index following the code point that should be returned
+ * @return the Unicode code point value before the given index.
+ * @exception NullPointerException if {@code a} is null.
+ * @exception IndexOutOfBoundsException if the {@code index}
+ * argument is less than 1 or greater than the length of the
+ * {@code char} array
+ * @since 1.5
+ */
+ public static int codePointBefore(char[] a, int index) {
+ return codePointBeforeImpl(a, index, 0);
+ }
+
+ /**
+ * Returns the code point preceding the given index of the
+ * {@code char} array, where only array elements with
+ * {@code index} greater than or equal to {@code start}
+ * can be used. If the {@code char} value at {@code (index - 1)}
+ * in the {@code char} array is in the
+ * low-surrogate range, {@code (index - 2)} is not less than
+ * {@code start}, and the {@code char} value at
+ * {@code (index - 2)} in the {@code char} array is in
+ * the high-surrogate range, then the supplementary code point
+ * corresponding to this surrogate pair is returned. Otherwise,
+ * the {@code char} value at {@code (index - 1)} is
+ * returned.
+ *
+ * @param a the {@code char} array
+ * @param index the index following the code point that should be returned
+ * @param start the index of the first array element in the
+ * {@code char} array
+ * @return the Unicode code point value before the given index.
+ * @exception NullPointerException if {@code a} is null.
+ * @exception IndexOutOfBoundsException if the {@code index}
+ * argument is not greater than the {@code start} argument or
+ * is greater than the length of the {@code char} array, or
+ * if the {@code start} argument is negative or not less than
+ * the length of the {@code char} array.
+ * @since 1.5
+ */
+ public static int codePointBefore(char[] a, int index, int start) {
+ if (index <= start || start < 0 || start >= a.length) {
+ throw new IndexOutOfBoundsException();
+ }
+ return codePointBeforeImpl(a, index, start);
+ }
+
+ // throws ArrayIndexOutOfBoundsException if index-1 out of bounds
+ static int codePointBeforeImpl(char[] a, int index, int start) {
+ char c2 = a[--index];
+ if (isLowSurrogate(c2) && index > start) {
+ char c1 = a[--index];
+ if (isHighSurrogate(c1)) {
+ return toCodePoint(c1, c2);
+ }
+ }
+ return c2;
+ }
+
+ /**
+ * Returns the leading surrogate (a
+ * <a href="http://www.unicode.org/glossary/#high_surrogate_code_unit">
+ * high surrogate code unit</a>) of the
+ * <a href="http://www.unicode.org/glossary/#surrogate_pair">
+ * surrogate pair</a>
+ * representing the specified supplementary character (Unicode
+ * code point) in the UTF-16 encoding. If the specified character
+ * is not a
+ * <a href="Character.html#supplementary">supplementary character</a>,
+ * an unspecified {@code char} is returned.
+ *
+ * <p>If
+ * {@link #isSupplementaryCodePoint isSupplementaryCodePoint(x)}
+ * is {@code true}, then
+ * {@link #isHighSurrogate isHighSurrogate}{@code (highSurrogate(x))} and
+ * {@link #toCodePoint toCodePoint}{@code (highSurrogate(x), }{@link #lowSurrogate lowSurrogate}{@code (x)) == x}
+ * are also always {@code true}.
+ *
+ * @param codePoint a supplementary character (Unicode code point)
+ * @return the leading surrogate code unit used to represent the
+ * character in the UTF-16 encoding
+ * @since 1.7
+ */
+ public static char highSurrogate(int codePoint) {
+ return (char) ((codePoint >>> 10)
+ + (MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT >>> 10)));
+ }
+
+ /**
+ * Returns the trailing surrogate (a
+ * <a href="http://www.unicode.org/glossary/#low_surrogate_code_unit">
+ * low surrogate code unit</a>) of the
+ * <a href="http://www.unicode.org/glossary/#surrogate_pair">
+ * surrogate pair</a>
+ * representing the specified supplementary character (Unicode
+ * code point) in the UTF-16 encoding. If the specified character
+ * is not a
+ * <a href="Character.html#supplementary">supplementary character</a>,
+ * an unspecified {@code char} is returned.
+ *
+ * <p>If
+ * {@link #isSupplementaryCodePoint isSupplementaryCodePoint(x)}
+ * is {@code true}, then
+ * {@link #isLowSurrogate isLowSurrogate}{@code (lowSurrogate(x))} and
+ * {@link #toCodePoint toCodePoint}{@code (}{@link #highSurrogate highSurrogate}{@code (x), lowSurrogate(x)) == x}
+ * are also always {@code true}.
+ *
+ * @param codePoint a supplementary character (Unicode code point)
+ * @return the trailing surrogate code unit used to represent the
+ * character in the UTF-16 encoding
+ * @since 1.7
+ */
+ public static char lowSurrogate(int codePoint) {
+ return (char) ((codePoint & 0x3ff) + MIN_LOW_SURROGATE);
+ }
+
+ /**
+ * Converts the specified character (Unicode code point) to its
+ * UTF-16 representation. If the specified code point is a BMP
+ * (Basic Multilingual Plane or Plane 0) value, the same value is
+ * stored in {@code dst[dstIndex]}, and 1 is returned. If the
+ * specified code point is a supplementary character, its
+ * surrogate values are stored in {@code dst[dstIndex]}
+ * (high-surrogate) and {@code dst[dstIndex+1]}
+ * (low-surrogate), and 2 is returned.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @param dst an array of {@code char} in which the
+ * {@code codePoint}'s UTF-16 value is stored.
+ * @param dstIndex the start index into the {@code dst}
+ * array where the converted value is stored.
+ * @return 1 if the code point is a BMP code point, 2 if the
+ * code point is a supplementary code point.
+ * @exception IllegalArgumentException if the specified
+ * {@code codePoint} is not a valid Unicode code point.
+ * @exception NullPointerException if the specified {@code dst} is null.
+ * @exception IndexOutOfBoundsException if {@code dstIndex}
+ * is negative or not less than {@code dst.length}, or if
+ * {@code dst} at {@code dstIndex} doesn't have enough
+ * array element(s) to store the resulting {@code char}
+ * value(s). (If {@code dstIndex} is equal to
+ * {@code dst.length-1} and the specified
+ * {@code codePoint} is a supplementary character, the
+ * high-surrogate value is not stored in
+ * {@code dst[dstIndex]}.)
+ * @since 1.5
+ */
+ public static int toChars(int codePoint, char[] dst, int dstIndex) {
+ if (isBmpCodePoint(codePoint)) {
+ dst[dstIndex] = (char) codePoint;
+ return 1;
+ } else if (isValidCodePoint(codePoint)) {
+ toSurrogates(codePoint, dst, dstIndex);
+ return 2;
+ } else {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ /**
+ * Converts the specified character (Unicode code point) to its
+ * UTF-16 representation stored in a {@code char} array. If
+ * the specified code point is a BMP (Basic Multilingual Plane or
+ * Plane 0) value, the resulting {@code char} array has
+ * the same value as {@code codePoint}. If the specified code
+ * point is a supplementary code point, the resulting
+ * {@code char} array has the corresponding surrogate pair.
+ *
+ * @param codePoint a Unicode code point
+ * @return a {@code char} array having
+ * {@code codePoint}'s UTF-16 representation.
+ * @exception IllegalArgumentException if the specified
+ * {@code codePoint} is not a valid Unicode code point.
+ * @since 1.5
+ */
+ public static char[] toChars(int codePoint) {
+ if (isBmpCodePoint(codePoint)) {
+ return new char[] { (char) codePoint };
+ } else if (isValidCodePoint(codePoint)) {
+ char[] result = new char[2];
+ toSurrogates(codePoint, result, 0);
+ return result;
+ } else {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ static void toSurrogates(int codePoint, char[] dst, int index) {
+ // We write elements "backwards" to guarantee all-or-nothing
+ dst[index+1] = lowSurrogate(codePoint);
+ dst[index] = highSurrogate(codePoint);
+ }
+
+ /**
+ * Returns the number of Unicode code points in the text range of
+ * the specified char sequence. The text range begins at the
+ * specified {@code beginIndex} and extends to the
+ * {@code char} at index {@code endIndex - 1}. Thus the
+ * length (in {@code char}s) of the text range is
+ * {@code endIndex-beginIndex}. Unpaired surrogates within
+ * the text range count as one code point each.
+ *
+ * @param seq the char sequence
+ * @param beginIndex the index to the first {@code char} of
+ * the text range.
+ * @param endIndex the index after the last {@code char} of
+ * the text range.
+ * @return the number of Unicode code points in the specified text
+ * range
+ * @exception NullPointerException if {@code seq} is null.
+ * @exception IndexOutOfBoundsException if the
+ * {@code beginIndex} is negative, or {@code endIndex}
+ * is larger than the length of the given sequence, or
+ * {@code beginIndex} is larger than {@code endIndex}.
+ * @since 1.5
+ */
+ public static int codePointCount(CharSequence seq, int beginIndex, int endIndex) {
+ int length = seq.length();
+ if (beginIndex < 0 || endIndex > length || beginIndex > endIndex) {
+ throw new IndexOutOfBoundsException();
+ }
+ int n = endIndex - beginIndex;
+ for (int i = beginIndex; i < endIndex; ) {
+ if (isHighSurrogate(seq.charAt(i++)) && i < endIndex &&
+ isLowSurrogate(seq.charAt(i))) {
+ n--;
+ i++;
+ }
+ }
+ return n;
+ }
+
+ /**
+ * Returns the number of Unicode code points in a subarray of the
+ * {@code char} array argument. The {@code offset}
+ * argument is the index of the first {@code char} of the
+ * subarray and the {@code count} argument specifies the
+ * length of the subarray in {@code char}s. Unpaired
+ * surrogates within the subarray count as one code point each.
+ *
+ * @param a the {@code char} array
+ * @param offset the index of the first {@code char} in the
+ * given {@code char} array
+ * @param count the length of the subarray in {@code char}s
+ * @return the number of Unicode code points in the specified subarray
+ * @exception NullPointerException if {@code a} is null.
+ * @exception IndexOutOfBoundsException if {@code offset} or
+ * {@code count} is negative, or if {@code offset +
+ * count} is larger than the length of the given array.
+ * @since 1.5
+ */
+ public static int codePointCount(char[] a, int offset, int count) {
+ if (count > a.length - offset || offset < 0 || count < 0) {
+ throw new IndexOutOfBoundsException();
+ }
+ return codePointCountImpl(a, offset, count);
+ }
+
+ static int codePointCountImpl(char[] a, int offset, int count) {
+ int endIndex = offset + count;
+ int n = count;
+ for (int i = offset; i < endIndex; ) {
+ if (isHighSurrogate(a[i++]) && i < endIndex &&
+ isLowSurrogate(a[i])) {
+ n--;
+ i++;
+ }
+ }
+ return n;
+ }
+
+ /**
+ * Returns the index within the given char sequence that is offset
+ * from the given {@code index} by {@code codePointOffset}
+ * code points. Unpaired surrogates within the text range given by
+ * {@code index} and {@code codePointOffset} count as
+ * one code point each.
+ *
+ * @param seq the char sequence
+ * @param index the index to be offset
+ * @param codePointOffset the offset in code points
+ * @return the index within the char sequence
+ * @exception NullPointerException if {@code seq} is null.
+ * @exception IndexOutOfBoundsException if {@code index}
+ * is negative or larger then the length of the char sequence,
+ * or if {@code codePointOffset} is positive and the
+ * subsequence starting with {@code index} has fewer than
+ * {@code codePointOffset} code points, or if
+ * {@code codePointOffset} is negative and the subsequence
+ * before {@code index} has fewer than the absolute value
+ * of {@code codePointOffset} code points.
+ * @since 1.5
+ */
+ public static int offsetByCodePoints(CharSequence seq, int index,
+ int codePointOffset) {
+ int length = seq.length();
+ if (index < 0 || index > length) {
+ throw new IndexOutOfBoundsException();
+ }
+
+ int x = index;
+ if (codePointOffset >= 0) {
+ int i;
+ for (i = 0; x < length && i < codePointOffset; i++) {
+ if (isHighSurrogate(seq.charAt(x++)) && x < length &&
+ isLowSurrogate(seq.charAt(x))) {
+ x++;
+ }
+ }
+ if (i < codePointOffset) {
+ throw new IndexOutOfBoundsException();
+ }
+ } else {
+ int i;
+ for (i = codePointOffset; x > 0 && i < 0; i++) {
+ if (isLowSurrogate(seq.charAt(--x)) && x > 0 &&
+ isHighSurrogate(seq.charAt(x-1))) {
+ x--;
+ }
+ }
+ if (i < 0) {
+ throw new IndexOutOfBoundsException();
+ }
+ }
+ return x;
+ }
+
+ /**
+ * Returns the index within the given {@code char} subarray
+ * that is offset from the given {@code index} by
+ * {@code codePointOffset} code points. The
+ * {@code start} and {@code count} arguments specify a
+ * subarray of the {@code char} array. Unpaired surrogates
+ * within the text range given by {@code index} and
+ * {@code codePointOffset} count as one code point each.
+ *
+ * @param a the {@code char} array
+ * @param start the index of the first {@code char} of the
+ * subarray
+ * @param count the length of the subarray in {@code char}s
+ * @param index the index to be offset
+ * @param codePointOffset the offset in code points
+ * @return the index within the subarray
+ * @exception NullPointerException if {@code a} is null.
+ * @exception IndexOutOfBoundsException
+ * if {@code start} or {@code count} is negative,
+ * or if {@code start + count} is larger than the length of
+ * the given array,
+ * or if {@code index} is less than {@code start} or
+ * larger then {@code start + count},
+ * or if {@code codePointOffset} is positive and the text range
+ * starting with {@code index} and ending with {@code start + count - 1}
+ * has fewer than {@code codePointOffset} code
+ * points,
+ * or if {@code codePointOffset} is negative and the text range
+ * starting with {@code start} and ending with {@code index - 1}
+ * has fewer than the absolute value of
+ * {@code codePointOffset} code points.
+ * @since 1.5
+ */
+ public static int offsetByCodePoints(char[] a, int start, int count,
+ int index, int codePointOffset) {
+ if (count > a.length-start || start < 0 || count < 0
+ || index < start || index > start+count) {
+ throw new IndexOutOfBoundsException();
+ }
+ return offsetByCodePointsImpl(a, start, count, index, codePointOffset);
+ }
+
+ static int offsetByCodePointsImpl(char[]a, int start, int count,
+ int index, int codePointOffset) {
+ int x = index;
+ if (codePointOffset >= 0) {
+ int limit = start + count;
+ int i;
+ for (i = 0; x < limit && i < codePointOffset; i++) {
+ if (isHighSurrogate(a[x++]) && x < limit &&
+ isLowSurrogate(a[x])) {
+ x++;
+ }
+ }
+ if (i < codePointOffset) {
+ throw new IndexOutOfBoundsException();
+ }
+ } else {
+ int i;
+ for (i = codePointOffset; x > start && i < 0; i++) {
+ if (isLowSurrogate(a[--x]) && x > start &&
+ isHighSurrogate(a[x-1])) {
+ x--;
+ }
+ }
+ if (i < 0) {
+ throw new IndexOutOfBoundsException();
+ }
+ }
+ return x;
+ }
+
+ /**
+ * Determines if the specified character is a lowercase character.
+ * <p>
+ * A character is lowercase if its general category type, provided
+ * by {@code Character.getType(ch)}, is
+ * {@code LOWERCASE_LETTER}, or it has contributory property
+ * Other_Lowercase as defined by the Unicode Standard.
+ * <p>
+ * The following are examples of lowercase characters:
+ * <blockquote><pre>
+ * a b c d e f g h i j k l m n o p q r s t u v w x y z
+ * '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6'
+ * '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE'
+ * '\u00EF' '\u00F0' '\u00F1' '\u00F2' '\u00F3' '\u00F4' '\u00F5' '\u00F6'
+ * '\u00F8' '\u00F9' '\u00FA' '\u00FB' '\u00FC' '\u00FD' '\u00FE' '\u00FF'
+ * </pre></blockquote>
+ * <p> Many other Unicode characters are lowercase too.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isLowerCase(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is lowercase;
+ * {@code false} otherwise.
+ * @see Character#isLowerCase(char)
+ * @see Character#isTitleCase(char)
+ * @see Character#toLowerCase(char)
+ * @see Character#getType(char)
+ */
+ public static boolean isLowerCase(char ch) {
+ return isLowerCase((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a
+ * lowercase character.
+ * <p>
+ * A character is lowercase if its general category type, provided
+ * by {@link Character#getType getType(codePoint)}, is
+ * {@code LOWERCASE_LETTER}, or it has contributory property
+ * Other_Lowercase as defined by the Unicode Standard.
+ * <p>
+ * The following are examples of lowercase characters:
+ * <blockquote><pre>
+ * a b c d e f g h i j k l m n o p q r s t u v w x y z
+ * '\u00DF' '\u00E0' '\u00E1' '\u00E2' '\u00E3' '\u00E4' '\u00E5' '\u00E6'
+ * '\u00E7' '\u00E8' '\u00E9' '\u00EA' '\u00EB' '\u00EC' '\u00ED' '\u00EE'
+ * '\u00EF' '\u00F0' '\u00F1' '\u00F2' '\u00F3' '\u00F4' '\u00F5' '\u00F6'
+ * '\u00F8' '\u00F9' '\u00FA' '\u00FB' '\u00FC' '\u00FD' '\u00FE' '\u00FF'
+ * </pre></blockquote>
+ * <p> Many other Unicode characters are lowercase too.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is lowercase;
+ * {@code false} otherwise.
+ * @see Character#isLowerCase(int)
+ * @see Character#isTitleCase(int)
+ * @see Character#toLowerCase(int)
+ * @see Character#getType(int)
+ * @since 1.5
+ */
+ public static boolean isLowerCase(int codePoint) {
+ return getType(codePoint) == Character.LOWERCASE_LETTER ||
+ CharacterData.of(codePoint).isOtherLowercase(codePoint);
+ }
+
+ /**
+ * Determines if the specified character is an uppercase character.
+ * <p>
+ * A character is uppercase if its general category type, provided by
+ * {@code Character.getType(ch)}, is {@code UPPERCASE_LETTER}.
+ * or it has contributory property Other_Uppercase as defined by the Unicode Standard.
+ * <p>
+ * The following are examples of uppercase characters:
+ * <blockquote><pre>
+ * A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+ * '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7'
+ * '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF'
+ * '\u00D0' '\u00D1' '\u00D2' '\u00D3' '\u00D4' '\u00D5' '\u00D6' '\u00D8'
+ * '\u00D9' '\u00DA' '\u00DB' '\u00DC' '\u00DD' '\u00DE'
+ * </pre></blockquote>
+ * <p> Many other Unicode characters are uppercase too.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isUpperCase(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is uppercase;
+ * {@code false} otherwise.
+ * @see Character#isLowerCase(char)
+ * @see Character#isTitleCase(char)
+ * @see Character#toUpperCase(char)
+ * @see Character#getType(char)
+ * @since 1.0
+ */
+ public static boolean isUpperCase(char ch) {
+ return isUpperCase((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is an uppercase character.
+ * <p>
+ * A character is uppercase if its general category type, provided by
+ * {@link Character#getType(int) getType(codePoint)}, is {@code UPPERCASE_LETTER},
+ * or it has contributory property Other_Uppercase as defined by the Unicode Standard.
+ * <p>
+ * The following are examples of uppercase characters:
+ * <blockquote><pre>
+ * A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+ * '\u00C0' '\u00C1' '\u00C2' '\u00C3' '\u00C4' '\u00C5' '\u00C6' '\u00C7'
+ * '\u00C8' '\u00C9' '\u00CA' '\u00CB' '\u00CC' '\u00CD' '\u00CE' '\u00CF'
+ * '\u00D0' '\u00D1' '\u00D2' '\u00D3' '\u00D4' '\u00D5' '\u00D6' '\u00D8'
+ * '\u00D9' '\u00DA' '\u00DB' '\u00DC' '\u00DD' '\u00DE'
+ * </pre></blockquote>
+ * <p> Many other Unicode characters are uppercase too.<p>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is uppercase;
+ * {@code false} otherwise.
+ * @see Character#isLowerCase(int)
+ * @see Character#isTitleCase(int)
+ * @see Character#toUpperCase(int)
+ * @see Character#getType(int)
+ * @since 1.5
+ */
+ public static boolean isUpperCase(int codePoint) {
+ return getType(codePoint) == Character.UPPERCASE_LETTER ||
+ CharacterData.of(codePoint).isOtherUppercase(codePoint);
+ }
+
+ /**
+ * Determines if the specified character is a titlecase character.
+ * <p>
+ * A character is a titlecase character if its general
+ * category type, provided by {@code Character.getType(ch)},
+ * is {@code TITLECASE_LETTER}.
+ * <p>
+ * Some characters look like pairs of Latin letters. For example, there
+ * is an uppercase letter that looks like "LJ" and has a corresponding
+ * lowercase letter that looks like "lj". A third form, which looks like "Lj",
+ * is the appropriate form to use when rendering a word in lowercase
+ * with initial capitals, as for a book title.
+ * <p>
+ * These are some of the Unicode characters for which this method returns
+ * {@code true}:
+ * <ul>
+ * <li>{@code LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON}
+ * <li>{@code LATIN CAPITAL LETTER L WITH SMALL LETTER J}
+ * <li>{@code LATIN CAPITAL LETTER N WITH SMALL LETTER J}
+ * <li>{@code LATIN CAPITAL LETTER D WITH SMALL LETTER Z}
+ * </ul>
+ * <p> Many other Unicode characters are titlecase too.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isTitleCase(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is titlecase;
+ * {@code false} otherwise.
+ * @see Character#isLowerCase(char)
+ * @see Character#isUpperCase(char)
+ * @see Character#toTitleCase(char)
+ * @see Character#getType(char)
+ * @since 1.0.2
+ */
+ public static boolean isTitleCase(char ch) {
+ return isTitleCase((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a titlecase character.
+ * <p>
+ * A character is a titlecase character if its general
+ * category type, provided by {@link Character#getType(int) getType(codePoint)},
+ * is {@code TITLECASE_LETTER}.
+ * <p>
+ * Some characters look like pairs of Latin letters. For example, there
+ * is an uppercase letter that looks like "LJ" and has a corresponding
+ * lowercase letter that looks like "lj". A third form, which looks like "Lj",
+ * is the appropriate form to use when rendering a word in lowercase
+ * with initial capitals, as for a book title.
+ * <p>
+ * These are some of the Unicode characters for which this method returns
+ * {@code true}:
+ * <ul>
+ * <li>{@code LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON}
+ * <li>{@code LATIN CAPITAL LETTER L WITH SMALL LETTER J}
+ * <li>{@code LATIN CAPITAL LETTER N WITH SMALL LETTER J}
+ * <li>{@code LATIN CAPITAL LETTER D WITH SMALL LETTER Z}
+ * </ul>
+ * <p> Many other Unicode characters are titlecase too.<p>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is titlecase;
+ * {@code false} otherwise.
+ * @see Character#isLowerCase(int)
+ * @see Character#isUpperCase(int)
+ * @see Character#toTitleCase(int)
+ * @see Character#getType(int)
+ * @since 1.5
+ */
+ public static boolean isTitleCase(int codePoint) {
+ return getType(codePoint) == Character.TITLECASE_LETTER;
+ }
+
+ /**
+ * Determines if the specified character is a digit.
+ * <p>
+ * A character is a digit if its general category type, provided
+ * by {@code Character.getType(ch)}, is
+ * {@code DECIMAL_DIGIT_NUMBER}.
+ * <p>
+ * Some Unicode character ranges that contain digits:
+ * <ul>
+ * <li>{@code '\u005Cu0030'} through {@code '\u005Cu0039'},
+ * ISO-LATIN-1 digits ({@code '0'} through {@code '9'})
+ * <li>{@code '\u005Cu0660'} through {@code '\u005Cu0669'},
+ * Arabic-Indic digits
+ * <li>{@code '\u005Cu06F0'} through {@code '\u005Cu06F9'},
+ * Extended Arabic-Indic digits
+ * <li>{@code '\u005Cu0966'} through {@code '\u005Cu096F'},
+ * Devanagari digits
+ * <li>{@code '\u005CuFF10'} through {@code '\u005CuFF19'},
+ * Fullwidth digits
+ * </ul>
+ *
+ * Many other character ranges contain digits as well.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isDigit(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is a digit;
+ * {@code false} otherwise.
+ * @see Character#digit(char, int)
+ * @see Character#forDigit(int, int)
+ * @see Character#getType(char)
+ */
+ public static boolean isDigit(char ch) {
+ return isDigit((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a digit.
+ * <p>
+ * A character is a digit if its general category type, provided
+ * by {@link Character#getType(int) getType(codePoint)}, is
+ * {@code DECIMAL_DIGIT_NUMBER}.
+ * <p>
+ * Some Unicode character ranges that contain digits:
+ * <ul>
+ * <li>{@code '\u005Cu0030'} through {@code '\u005Cu0039'},
+ * ISO-LATIN-1 digits ({@code '0'} through {@code '9'})
+ * <li>{@code '\u005Cu0660'} through {@code '\u005Cu0669'},
+ * Arabic-Indic digits
+ * <li>{@code '\u005Cu06F0'} through {@code '\u005Cu06F9'},
+ * Extended Arabic-Indic digits
+ * <li>{@code '\u005Cu0966'} through {@code '\u005Cu096F'},
+ * Devanagari digits
+ * <li>{@code '\u005CuFF10'} through {@code '\u005CuFF19'},
+ * Fullwidth digits
+ * </ul>
+ *
+ * Many other character ranges contain digits as well.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is a digit;
+ * {@code false} otherwise.
+ * @see Character#forDigit(int, int)
+ * @see Character#getType(int)
+ * @since 1.5
+ */
+ public static boolean isDigit(int codePoint) {
+ return getType(codePoint) == Character.DECIMAL_DIGIT_NUMBER;
+ }
+
+ /**
+ * Determines if a character is defined in Unicode.
+ * <p>
+ * A character is defined if at least one of the following is true:
+ * <ul>
+ * <li>It has an entry in the UnicodeData file.
+ * <li>It has a value in a range defined by the UnicodeData file.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isDefined(int)} method.
+ *
+ * @param ch the character to be tested
+ * @return {@code true} if the character has a defined meaning
+ * in Unicode; {@code false} otherwise.
+ * @see Character#isDigit(char)
+ * @see Character#isLetter(char)
+ * @see Character#isLetterOrDigit(char)
+ * @see Character#isLowerCase(char)
+ * @see Character#isTitleCase(char)
+ * @see Character#isUpperCase(char)
+ * @since 1.0.2
+ */
+ public static boolean isDefined(char ch) {
+ return isDefined((int)ch);
+ }
+
+ /**
+ * Determines if a character (Unicode code point) is defined in Unicode.
+ * <p>
+ * A character is defined if at least one of the following is true:
+ * <ul>
+ * <li>It has an entry in the UnicodeData file.
+ * <li>It has a value in a range defined by the UnicodeData file.
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character has a defined meaning
+ * in Unicode; {@code false} otherwise.
+ * @see Character#isDigit(int)
+ * @see Character#isLetter(int)
+ * @see Character#isLetterOrDigit(int)
+ * @see Character#isLowerCase(int)
+ * @see Character#isTitleCase(int)
+ * @see Character#isUpperCase(int)
+ * @since 1.5
+ */
+ public static boolean isDefined(int codePoint) {
+ return getType(codePoint) != Character.UNASSIGNED;
+ }
+
+ /**
+ * Determines if the specified character is a letter.
+ * <p>
+ * A character is considered to be a letter if its general
+ * category type, provided by {@code Character.getType(ch)},
+ * is any of the following:
+ * <ul>
+ * <li> {@code UPPERCASE_LETTER}
+ * <li> {@code LOWERCASE_LETTER}
+ * <li> {@code TITLECASE_LETTER}
+ * <li> {@code MODIFIER_LETTER}
+ * <li> {@code OTHER_LETTER}
+ * </ul>
+ *
+ * Not all letters have case. Many characters are
+ * letters but are neither uppercase nor lowercase nor titlecase.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isLetter(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is a letter;
+ * {@code false} otherwise.
+ * @see Character#isDigit(char)
+ * @see Character#isJavaIdentifierStart(char)
+ * @see Character#isJavaLetter(char)
+ * @see Character#isJavaLetterOrDigit(char)
+ * @see Character#isLetterOrDigit(char)
+ * @see Character#isLowerCase(char)
+ * @see Character#isTitleCase(char)
+ * @see Character#isUnicodeIdentifierStart(char)
+ * @see Character#isUpperCase(char)
+ */
+ public static boolean isLetter(char ch) {
+ return isLetter((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a letter.
+ * <p>
+ * A character is considered to be a letter if its general
+ * category type, provided by {@link Character#getType(int) getType(codePoint)},
+ * is any of the following:
+ * <ul>
+ * <li> {@code UPPERCASE_LETTER}
+ * <li> {@code LOWERCASE_LETTER}
+ * <li> {@code TITLECASE_LETTER}
+ * <li> {@code MODIFIER_LETTER}
+ * <li> {@code OTHER_LETTER}
+ * </ul>
+ *
+ * Not all letters have case. Many characters are
+ * letters but are neither uppercase nor lowercase nor titlecase.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is a letter;
+ * {@code false} otherwise.
+ * @see Character#isDigit(int)
+ * @see Character#isJavaIdentifierStart(int)
+ * @see Character#isLetterOrDigit(int)
+ * @see Character#isLowerCase(int)
+ * @see Character#isTitleCase(int)
+ * @see Character#isUnicodeIdentifierStart(int)
+ * @see Character#isUpperCase(int)
+ * @since 1.5
+ */
+ public static boolean isLetter(int codePoint) {
+ return ((((1 << Character.UPPERCASE_LETTER) |
+ (1 << Character.LOWERCASE_LETTER) |
+ (1 << Character.TITLECASE_LETTER) |
+ (1 << Character.MODIFIER_LETTER) |
+ (1 << Character.OTHER_LETTER)) >> getType(codePoint)) & 1)
+ != 0;
+ }
+
+ /**
+ * Determines if the specified character is a letter or digit.
+ * <p>
+ * A character is considered to be a letter or digit if either
+ * {@code Character.isLetter(char ch)} or
+ * {@code Character.isDigit(char ch)} returns
+ * {@code true} for the character.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isLetterOrDigit(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is a letter or digit;
+ * {@code false} otherwise.
+ * @see Character#isDigit(char)
+ * @see Character#isJavaIdentifierPart(char)
+ * @see Character#isJavaLetter(char)
+ * @see Character#isJavaLetterOrDigit(char)
+ * @see Character#isLetter(char)
+ * @see Character#isUnicodeIdentifierPart(char)
+ * @since 1.0.2
+ */
+ public static boolean isLetterOrDigit(char ch) {
+ return isLetterOrDigit((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a letter or digit.
+ * <p>
+ * A character is considered to be a letter or digit if either
+ * {@link #isLetter(int) isLetter(codePoint)} or
+ * {@link #isDigit(int) isDigit(codePoint)} returns
+ * {@code true} for the character.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is a letter or digit;
+ * {@code false} otherwise.
+ * @see Character#isDigit(int)
+ * @see Character#isJavaIdentifierPart(int)
+ * @see Character#isLetter(int)
+ * @see Character#isUnicodeIdentifierPart(int)
+ * @since 1.5
+ */
+ public static boolean isLetterOrDigit(int codePoint) {
+ return ((((1 << Character.UPPERCASE_LETTER) |
+ (1 << Character.LOWERCASE_LETTER) |
+ (1 << Character.TITLECASE_LETTER) |
+ (1 << Character.MODIFIER_LETTER) |
+ (1 << Character.OTHER_LETTER) |
+ (1 << Character.DECIMAL_DIGIT_NUMBER)) >> getType(codePoint)) & 1)
+ != 0;
+ }
+
+ /**
+ * Determines if the specified character is permissible as the first
+ * character in a Java identifier.
+ * <p>
+ * A character may start a Java identifier if and only if
+ * one of the following is true:
+ * <ul>
+ * <li> {@link #isLetter(char) isLetter(ch)} returns {@code true}
+ * <li> {@link #getType(char) getType(ch)} returns {@code LETTER_NUMBER}
+ * <li> {@code ch} is a currency symbol (such as {@code '$'})
+ * <li> {@code ch} is a connecting punctuation character (such as {@code '_'}).
+ * </ul>
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character may start a Java
+ * identifier; {@code false} otherwise.
+ * @see Character#isJavaLetterOrDigit(char)
+ * @see Character#isJavaIdentifierStart(char)
+ * @see Character#isJavaIdentifierPart(char)
+ * @see Character#isLetter(char)
+ * @see Character#isLetterOrDigit(char)
+ * @see Character#isUnicodeIdentifierStart(char)
+ * @since 1.02
+ * @deprecated Replaced by isJavaIdentifierStart(char).
+ */
+ @Deprecated
+ public static boolean isJavaLetter(char ch) {
+ return isJavaIdentifierStart(ch);
+ }
+
+ /**
+ * Determines if the specified character may be part of a Java
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Java identifier if and only if any
+ * of the following are true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a currency symbol (such as {@code '$'})
+ * <li> it is a connecting punctuation character (such as {@code '_'})
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> {@code isIdentifierIgnorable} returns
+ * {@code true} for the character.
+ * </ul>
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character may be part of a
+ * Java identifier; {@code false} otherwise.
+ * @see Character#isJavaLetter(char)
+ * @see Character#isJavaIdentifierStart(char)
+ * @see Character#isJavaIdentifierPart(char)
+ * @see Character#isLetter(char)
+ * @see Character#isLetterOrDigit(char)
+ * @see Character#isUnicodeIdentifierPart(char)
+ * @see Character#isIdentifierIgnorable(char)
+ * @since 1.02
+ * @deprecated Replaced by isJavaIdentifierPart(char).
+ */
+ @Deprecated
+ public static boolean isJavaLetterOrDigit(char ch) {
+ return isJavaIdentifierPart(ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is an alphabet.
+ * <p>
+ * A character is considered to be alphabetic if its general category type,
+ * provided by {@link Character#getType(int) getType(codePoint)}, is any of
+ * the following:
+ * <ul>
+ * <li> <code>UPPERCASE_LETTER</code>
+ * <li> <code>LOWERCASE_LETTER</code>
+ * <li> <code>TITLECASE_LETTER</code>
+ * <li> <code>MODIFIER_LETTER</code>
+ * <li> <code>OTHER_LETTER</code>
+ * <li> <code>LETTER_NUMBER</code>
+ * </ul>
+ * or it has contributory property Other_Alphabetic as defined by the
+ * Unicode Standard.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is a Unicode alphabet
+ * character, <code>false</code> otherwise.
+ * @since 1.7
+ */
+ public static boolean isAlphabetic(int codePoint) {
+ return (((((1 << Character.UPPERCASE_LETTER) |
+ (1 << Character.LOWERCASE_LETTER) |
+ (1 << Character.TITLECASE_LETTER) |
+ (1 << Character.MODIFIER_LETTER) |
+ (1 << Character.OTHER_LETTER) |
+ (1 << Character.LETTER_NUMBER)) >> getType(codePoint)) & 1) != 0) ||
+ CharacterData.of(codePoint).isOtherAlphabetic(codePoint);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a CJKV
+ * (Chinese, Japanese, Korean and Vietnamese) ideograph, as defined by
+ * the Unicode Standard.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return <code>true</code> if the character is a Unicode ideograph
+ * character, <code>false</code> otherwise.
+ * @since 1.7
+ */
+ public static boolean isIdeographic(int codePoint) {
+ return CharacterData.of(codePoint).isIdeographic(codePoint);
+ }
+
+ /**
+ * Determines if the specified character is
+ * permissible as the first character in a Java identifier.
+ * <p>
+ * A character may start a Java identifier if and only if
+ * one of the following conditions is true:
+ * <ul>
+ * <li> {@link #isLetter(char) isLetter(ch)} returns {@code true}
+ * <li> {@link #getType(char) getType(ch)} returns {@code LETTER_NUMBER}
+ * <li> {@code ch} is a currency symbol (such as {@code '$'})
+ * <li> {@code ch} is a connecting punctuation character (such as {@code '_'}).
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isJavaIdentifierStart(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character may start a Java identifier;
+ * {@code false} otherwise.
+ * @see Character#isJavaIdentifierPart(char)
+ * @see Character#isLetter(char)
+ * @see Character#isUnicodeIdentifierStart(char)
+ * @see javax.lang.model.SourceVersion#isIdentifier(CharSequence)
+ * @since 1.1
+ */
+ public static boolean isJavaIdentifierStart(char ch) {
+ return isJavaIdentifierStart((int)ch);
+ }
+
+ /**
+ * Determines if the character (Unicode code point) is
+ * permissible as the first character in a Java identifier.
+ * <p>
+ * A character may start a Java identifier if and only if
+ * one of the following conditions is true:
+ * <ul>
+ * <li> {@link #isLetter(int) isLetter(codePoint)}
+ * returns {@code true}
+ * <li> {@link #getType(int) getType(codePoint)}
+ * returns {@code LETTER_NUMBER}
+ * <li> the referenced character is a currency symbol (such as {@code '$'})
+ * <li> the referenced character is a connecting punctuation character
+ * (such as {@code '_'}).
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character may start a Java identifier;
+ * {@code false} otherwise.
+ * @see Character#isJavaIdentifierPart(int)
+ * @see Character#isLetter(int)
+ * @see Character#isUnicodeIdentifierStart(int)
+ * @see javax.lang.model.SourceVersion#isIdentifier(CharSequence)
+ * @since 1.5
+ */
+ public static boolean isJavaIdentifierStart(int codePoint) {
+ return CharacterData.of(codePoint).isJavaIdentifierStart(codePoint);
+ }
+
+ /**
+ * Determines if the specified character may be part of a Java
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Java identifier if any of the following
+ * are true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a currency symbol (such as {@code '$'})
+ * <li> it is a connecting punctuation character (such as {@code '_'})
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> {@code isIdentifierIgnorable} returns
+ * {@code true} for the character
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isJavaIdentifierPart(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character may be part of a
+ * Java identifier; {@code false} otherwise.
+ * @see Character#isIdentifierIgnorable(char)
+ * @see Character#isJavaIdentifierStart(char)
+ * @see Character#isLetterOrDigit(char)
+ * @see Character#isUnicodeIdentifierPart(char)
+ * @see javax.lang.model.SourceVersion#isIdentifier(CharSequence)
+ * @since 1.1
+ */
+ public static boolean isJavaIdentifierPart(char ch) {
+ return isJavaIdentifierPart((int)ch);
+ }
+
+ /**
+ * Determines if the character (Unicode code point) may be part of a Java
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Java identifier if any of the following
+ * are true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a currency symbol (such as {@code '$'})
+ * <li> it is a connecting punctuation character (such as {@code '_'})
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> {@link #isIdentifierIgnorable(int)
+ * isIdentifierIgnorable(codePoint)} returns {@code true} for
+ * the character
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character may be part of a
+ * Java identifier; {@code false} otherwise.
+ * @see Character#isIdentifierIgnorable(int)
+ * @see Character#isJavaIdentifierStart(int)
+ * @see Character#isLetterOrDigit(int)
+ * @see Character#isUnicodeIdentifierPart(int)
+ * @see javax.lang.model.SourceVersion#isIdentifier(CharSequence)
+ * @since 1.5
+ */
+ public static boolean isJavaIdentifierPart(int codePoint) {
+ return CharacterData.of(codePoint).isJavaIdentifierPart(codePoint);
+ }
+
+ /**
+ * Determines if the specified character is permissible as the
+ * first character in a Unicode identifier.
+ * <p>
+ * A character may start a Unicode identifier if and only if
+ * one of the following conditions is true:
+ * <ul>
+ * <li> {@link #isLetter(char) isLetter(ch)} returns {@code true}
+ * <li> {@link #getType(char) getType(ch)} returns
+ * {@code LETTER_NUMBER}.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isUnicodeIdentifierStart(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character may start a Unicode
+ * identifier; {@code false} otherwise.
+ * @see Character#isJavaIdentifierStart(char)
+ * @see Character#isLetter(char)
+ * @see Character#isUnicodeIdentifierPart(char)
+ * @since 1.1
+ */
+ public static boolean isUnicodeIdentifierStart(char ch) {
+ return isUnicodeIdentifierStart((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is permissible as the
+ * first character in a Unicode identifier.
+ * <p>
+ * A character may start a Unicode identifier if and only if
+ * one of the following conditions is true:
+ * <ul>
+ * <li> {@link #isLetter(int) isLetter(codePoint)}
+ * returns {@code true}
+ * <li> {@link #getType(int) getType(codePoint)}
+ * returns {@code LETTER_NUMBER}.
+ * </ul>
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character may start a Unicode
+ * identifier; {@code false} otherwise.
+ * @see Character#isJavaIdentifierStart(int)
+ * @see Character#isLetter(int)
+ * @see Character#isUnicodeIdentifierPart(int)
+ * @since 1.5
+ */
+ public static boolean isUnicodeIdentifierStart(int codePoint) {
+ return CharacterData.of(codePoint).isUnicodeIdentifierStart(codePoint);
+ }
+
+ /**
+ * Determines if the specified character may be part of a Unicode
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Unicode identifier if and only if
+ * one of the following statements is true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a connecting punctuation character (such as {@code '_'})
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> {@code isIdentifierIgnorable} returns
+ * {@code true} for this character.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isUnicodeIdentifierPart(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character may be part of a
+ * Unicode identifier; {@code false} otherwise.
+ * @see Character#isIdentifierIgnorable(char)
+ * @see Character#isJavaIdentifierPart(char)
+ * @see Character#isLetterOrDigit(char)
+ * @see Character#isUnicodeIdentifierStart(char)
+ * @since 1.1
+ */
+ public static boolean isUnicodeIdentifierPart(char ch) {
+ return isUnicodeIdentifierPart((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) may be part of a Unicode
+ * identifier as other than the first character.
+ * <p>
+ * A character may be part of a Unicode identifier if and only if
+ * one of the following statements is true:
+ * <ul>
+ * <li> it is a letter
+ * <li> it is a connecting punctuation character (such as {@code '_'})
+ * <li> it is a digit
+ * <li> it is a numeric letter (such as a Roman numeral character)
+ * <li> it is a combining mark
+ * <li> it is a non-spacing mark
+ * <li> {@code isIdentifierIgnorable} returns
+ * {@code true} for this character.
+ * </ul>
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character may be part of a
+ * Unicode identifier; {@code false} otherwise.
+ * @see Character#isIdentifierIgnorable(int)
+ * @see Character#isJavaIdentifierPart(int)
+ * @see Character#isLetterOrDigit(int)
+ * @see Character#isUnicodeIdentifierStart(int)
+ * @since 1.5
+ */
+ public static boolean isUnicodeIdentifierPart(int codePoint) {
+ return CharacterData.of(codePoint).isUnicodeIdentifierPart(codePoint);
+ }
+
+ /**
+ * Determines if the specified character should be regarded as
+ * an ignorable character in a Java identifier or a Unicode identifier.
+ * <p>
+ * The following Unicode characters are ignorable in a Java identifier
+ * or a Unicode identifier:
+ * <ul>
+ * <li>ISO control characters that are not whitespace
+ * <ul>
+ * <li>{@code '\u005Cu0000'} through {@code '\u005Cu0008'}
+ * <li>{@code '\u005Cu000E'} through {@code '\u005Cu001B'}
+ * <li>{@code '\u005Cu007F'} through {@code '\u005Cu009F'}
+ * </ul>
+ *
+ * <li>all characters that have the {@code FORMAT} general
+ * category value
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isIdentifierIgnorable(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is an ignorable control
+ * character that may be part of a Java or Unicode identifier;
+ * {@code false} otherwise.
+ * @see Character#isJavaIdentifierPart(char)
+ * @see Character#isUnicodeIdentifierPart(char)
+ * @since 1.1
+ */
+ public static boolean isIdentifierIgnorable(char ch) {
+ return isIdentifierIgnorable((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) should be regarded as
+ * an ignorable character in a Java identifier or a Unicode identifier.
+ * <p>
+ * The following Unicode characters are ignorable in a Java identifier
+ * or a Unicode identifier:
+ * <ul>
+ * <li>ISO control characters that are not whitespace
+ * <ul>
+ * <li>{@code '\u005Cu0000'} through {@code '\u005Cu0008'}
+ * <li>{@code '\u005Cu000E'} through {@code '\u005Cu001B'}
+ * <li>{@code '\u005Cu007F'} through {@code '\u005Cu009F'}
+ * </ul>
+ *
+ * <li>all characters that have the {@code FORMAT} general
+ * category value
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is an ignorable control
+ * character that may be part of a Java or Unicode identifier;
+ * {@code false} otherwise.
+ * @see Character#isJavaIdentifierPart(int)
+ * @see Character#isUnicodeIdentifierPart(int)
+ * @since 1.5
+ */
+ public static boolean isIdentifierIgnorable(int codePoint) {
+ return CharacterData.of(codePoint).isIdentifierIgnorable(codePoint);
+ }
+
+ /**
+ * Converts the character argument to lowercase using case
+ * mapping information from the UnicodeData file.
+ * <p>
+ * Note that
+ * {@code Character.isLowerCase(Character.toLowerCase(ch))}
+ * does not always return {@code true} for some ranges of
+ * characters, particularly those that are symbols or ideographs.
+ *
+ * <p>In general, {@link String#toLowerCase()} should be used to map
+ * characters to lowercase. {@code String} case mapping methods
+ * have several benefits over {@code Character} case mapping methods.
+ * {@code String} case mapping methods can perform locale-sensitive
+ * mappings, context-sensitive mappings, and 1:M character mappings, whereas
+ * the {@code Character} case mapping methods cannot.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #toLowerCase(int)} method.
+ *
+ * @param ch the character to be converted.
+ * @return the lowercase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see Character#isLowerCase(char)
+ * @see String#toLowerCase()
+ */
+ public static char toLowerCase(char ch) {
+ return (char)toLowerCase((int)ch);
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to
+ * lowercase using case mapping information from the UnicodeData
+ * file.
+ *
+ * <p> Note that
+ * {@code Character.isLowerCase(Character.toLowerCase(codePoint))}
+ * does not always return {@code true} for some ranges of
+ * characters, particularly those that are symbols or ideographs.
+ *
+ * <p>In general, {@link String#toLowerCase()} should be used to map
+ * characters to lowercase. {@code String} case mapping methods
+ * have several benefits over {@code Character} case mapping methods.
+ * {@code String} case mapping methods can perform locale-sensitive
+ * mappings, context-sensitive mappings, and 1:M character mappings, whereas
+ * the {@code Character} case mapping methods cannot.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return the lowercase equivalent of the character (Unicode code
+ * point), if any; otherwise, the character itself.
+ * @see Character#isLowerCase(int)
+ * @see String#toLowerCase()
+ *
+ * @since 1.5
+ */
+ public static int toLowerCase(int codePoint) {
+ return CharacterData.of(codePoint).toLowerCase(codePoint);
+ }
+
+ /**
+ * Converts the character argument to uppercase using case mapping
+ * information from the UnicodeData file.
+ * <p>
+ * Note that
+ * {@code Character.isUpperCase(Character.toUpperCase(ch))}
+ * does not always return {@code true} for some ranges of
+ * characters, particularly those that are symbols or ideographs.
+ *
+ * <p>In general, {@link String#toUpperCase()} should be used to map
+ * characters to uppercase. {@code String} case mapping methods
+ * have several benefits over {@code Character} case mapping methods.
+ * {@code String} case mapping methods can perform locale-sensitive
+ * mappings, context-sensitive mappings, and 1:M character mappings, whereas
+ * the {@code Character} case mapping methods cannot.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #toUpperCase(int)} method.
+ *
+ * @param ch the character to be converted.
+ * @return the uppercase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see Character#isUpperCase(char)
+ * @see String#toUpperCase()
+ */
+ public static char toUpperCase(char ch) {
+ return (char)toUpperCase((int)ch);
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to
+ * uppercase using case mapping information from the UnicodeData
+ * file.
+ *
+ * <p>Note that
+ * {@code Character.isUpperCase(Character.toUpperCase(codePoint))}
+ * does not always return {@code true} for some ranges of
+ * characters, particularly those that are symbols or ideographs.
+ *
+ * <p>In general, {@link String#toUpperCase()} should be used to map
+ * characters to uppercase. {@code String} case mapping methods
+ * have several benefits over {@code Character} case mapping methods.
+ * {@code String} case mapping methods can perform locale-sensitive
+ * mappings, context-sensitive mappings, and 1:M character mappings, whereas
+ * the {@code Character} case mapping methods cannot.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return the uppercase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see Character#isUpperCase(int)
+ * @see String#toUpperCase()
+ *
+ * @since 1.5
+ */
+ public static int toUpperCase(int codePoint) {
+ return CharacterData.of(codePoint).toUpperCase(codePoint);
+ }
+
+ /**
+ * Converts the character argument to titlecase using case mapping
+ * information from the UnicodeData file. If a character has no
+ * explicit titlecase mapping and is not itself a titlecase char
+ * according to UnicodeData, then the uppercase mapping is
+ * returned as an equivalent titlecase mapping. If the
+ * {@code char} argument is already a titlecase
+ * {@code char}, the same {@code char} value will be
+ * returned.
+ * <p>
+ * Note that
+ * {@code Character.isTitleCase(Character.toTitleCase(ch))}
+ * does not always return {@code true} for some ranges of
+ * characters.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #toTitleCase(int)} method.
+ *
+ * @param ch the character to be converted.
+ * @return the titlecase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see Character#isTitleCase(char)
+ * @see Character#toLowerCase(char)
+ * @see Character#toUpperCase(char)
+ * @since 1.0.2
+ */
+ public static char toTitleCase(char ch) {
+ return (char)toTitleCase((int)ch);
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to titlecase using case mapping
+ * information from the UnicodeData file. If a character has no
+ * explicit titlecase mapping and is not itself a titlecase char
+ * according to UnicodeData, then the uppercase mapping is
+ * returned as an equivalent titlecase mapping. If the
+ * character argument is already a titlecase
+ * character, the same character value will be
+ * returned.
+ *
+ * <p>Note that
+ * {@code Character.isTitleCase(Character.toTitleCase(codePoint))}
+ * does not always return {@code true} for some ranges of
+ * characters.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return the titlecase equivalent of the character, if any;
+ * otherwise, the character itself.
+ * @see Character#isTitleCase(int)
+ * @see Character#toLowerCase(int)
+ * @see Character#toUpperCase(int)
+ * @since 1.5
+ */
+ public static int toTitleCase(int codePoint) {
+ return CharacterData.of(codePoint).toTitleCase(codePoint);
+ }
+
+ /**
+ * Returns the numeric value of the character {@code ch} in the
+ * specified radix.
+ * <p>
+ * If the radix is not in the range {@code MIN_RADIX} ≤
+ * {@code radix} ≤ {@code MAX_RADIX} or if the
+ * value of {@code ch} is not a valid digit in the specified
+ * radix, {@code -1} is returned. A character is a valid digit
+ * if at least one of the following is true:
+ * <ul>
+ * <li>The method {@code isDigit} is {@code true} of the character
+ * and the Unicode decimal digit value of the character (or its
+ * single-character decomposition) is less than the specified radix.
+ * In this case the decimal digit value is returned.
+ * <li>The character is one of the uppercase Latin letters
+ * {@code 'A'} through {@code 'Z'} and its code is less than
+ * {@code radix + 'A' - 10}.
+ * In this case, {@code ch - 'A' + 10}
+ * is returned.
+ * <li>The character is one of the lowercase Latin letters
+ * {@code 'a'} through {@code 'z'} and its code is less than
+ * {@code radix + 'a' - 10}.
+ * In this case, {@code ch - 'a' + 10}
+ * is returned.
+ * <li>The character is one of the fullwidth uppercase Latin letters A
+ * ({@code '\u005CuFF21'}) through Z ({@code '\u005CuFF3A'})
+ * and its code is less than
+ * {@code radix + '\u005CuFF21' - 10}.
+ * In this case, {@code ch - '\u005CuFF21' + 10}
+ * is returned.
+ * <li>The character is one of the fullwidth lowercase Latin letters a
+ * ({@code '\u005CuFF41'}) through z ({@code '\u005CuFF5A'})
+ * and its code is less than
+ * {@code radix + '\u005CuFF41' - 10}.
+ * In this case, {@code ch - '\u005CuFF41' + 10}
+ * is returned.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #digit(int, int)} method.
+ *
+ * @param ch the character to be converted.
+ * @param radix the radix.
+ * @return the numeric value represented by the character in the
+ * specified radix.
+ * @see Character#forDigit(int, int)
+ * @see Character#isDigit(char)
+ */
+ public static int digit(char ch, int radix) {
+ return digit((int)ch, radix);
+ }
+
+ /**
+ * Returns the numeric value of the specified character (Unicode
+ * code point) in the specified radix.
+ *
+ * <p>If the radix is not in the range {@code MIN_RADIX} ≤
+ * {@code radix} ≤ {@code MAX_RADIX} or if the
+ * character is not a valid digit in the specified
+ * radix, {@code -1} is returned. A character is a valid digit
+ * if at least one of the following is true:
+ * <ul>
+ * <li>The method {@link #isDigit(int) isDigit(codePoint)} is {@code true} of the character
+ * and the Unicode decimal digit value of the character (or its
+ * single-character decomposition) is less than the specified radix.
+ * In this case the decimal digit value is returned.
+ * <li>The character is one of the uppercase Latin letters
+ * {@code 'A'} through {@code 'Z'} and its code is less than
+ * {@code radix + 'A' - 10}.
+ * In this case, {@code codePoint - 'A' + 10}
+ * is returned.
+ * <li>The character is one of the lowercase Latin letters
+ * {@code 'a'} through {@code 'z'} and its code is less than
+ * {@code radix + 'a' - 10}.
+ * In this case, {@code codePoint - 'a' + 10}
+ * is returned.
+ * <li>The character is one of the fullwidth uppercase Latin letters A
+ * ({@code '\u005CuFF21'}) through Z ({@code '\u005CuFF3A'})
+ * and its code is less than
+ * {@code radix + '\u005CuFF21' - 10}.
+ * In this case,
+ * {@code codePoint - '\u005CuFF21' + 10}
+ * is returned.
+ * <li>The character is one of the fullwidth lowercase Latin letters a
+ * ({@code '\u005CuFF41'}) through z ({@code '\u005CuFF5A'})
+ * and its code is less than
+ * {@code radix + '\u005CuFF41'- 10}.
+ * In this case,
+ * {@code codePoint - '\u005CuFF41' + 10}
+ * is returned.
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @param radix the radix.
+ * @return the numeric value represented by the character in the
+ * specified radix.
+ * @see Character#forDigit(int, int)
+ * @see Character#isDigit(int)
+ * @since 1.5
+ */
+ public static int digit(int codePoint, int radix) {
+ return CharacterData.of(codePoint).digit(codePoint, radix);
+ }
+
+ /**
+ * Returns the {@code int} value that the specified Unicode
+ * character represents. For example, the character
+ * {@code '\u005Cu216C'} (the roman numeral fifty) will return
+ * an int with a value of 50.
+ * <p>
+ * The letters A-Z in their uppercase ({@code '\u005Cu0041'} through
+ * {@code '\u005Cu005A'}), lowercase
+ * ({@code '\u005Cu0061'} through {@code '\u005Cu007A'}), and
+ * full width variant ({@code '\u005CuFF21'} through
+ * {@code '\u005CuFF3A'} and {@code '\u005CuFF41'} through
+ * {@code '\u005CuFF5A'}) forms have numeric values from 10
+ * through 35. This is independent of the Unicode specification,
+ * which does not assign numeric values to these {@code char}
+ * values.
+ * <p>
+ * If the character does not have a numeric value, then -1 is returned.
+ * If the character has a numeric value that cannot be represented as a
+ * nonnegative integer (for example, a fractional value), then -2
+ * is returned.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #getNumericValue(int)} method.
+ *
+ * @param ch the character to be converted.
+ * @return the numeric value of the character, as a nonnegative {@code int}
+ * value; -2 if the character has a numeric value that is not a
+ * nonnegative integer; -1 if the character has no numeric value.
+ * @see Character#forDigit(int, int)
+ * @see Character#isDigit(char)
+ * @since 1.1
+ */
+ public static int getNumericValue(char ch) {
+ return getNumericValue((int)ch);
+ }
+
+ /**
+ * Returns the {@code int} value that the specified
+ * character (Unicode code point) represents. For example, the character
+ * {@code '\u005Cu216C'} (the Roman numeral fifty) will return
+ * an {@code int} with a value of 50.
+ * <p>
+ * The letters A-Z in their uppercase ({@code '\u005Cu0041'} through
+ * {@code '\u005Cu005A'}), lowercase
+ * ({@code '\u005Cu0061'} through {@code '\u005Cu007A'}), and
+ * full width variant ({@code '\u005CuFF21'} through
+ * {@code '\u005CuFF3A'} and {@code '\u005CuFF41'} through
+ * {@code '\u005CuFF5A'}) forms have numeric values from 10
+ * through 35. This is independent of the Unicode specification,
+ * which does not assign numeric values to these {@code char}
+ * values.
+ * <p>
+ * If the character does not have a numeric value, then -1 is returned.
+ * If the character has a numeric value that cannot be represented as a
+ * nonnegative integer (for example, a fractional value), then -2
+ * is returned.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return the numeric value of the character, as a nonnegative {@code int}
+ * value; -2 if the character has a numeric value that is not a
+ * nonnegative integer; -1 if the character has no numeric value.
+ * @see Character#forDigit(int, int)
+ * @see Character#isDigit(int)
+ * @since 1.5
+ */
+ public static int getNumericValue(int codePoint) {
+ return CharacterData.of(codePoint).getNumericValue(codePoint);
+ }
+
+ /**
+ * Determines if the specified character is ISO-LATIN-1 white space.
+ * This method returns {@code true} for the following five
+ * characters only:
+ * <table summary="truechars">
+ * <tr><td>{@code '\t'}</td> <td>{@code U+0009}</td>
+ * <td>{@code HORIZONTAL TABULATION}</td></tr>
+ * <tr><td>{@code '\n'}</td> <td>{@code U+000A}</td>
+ * <td>{@code NEW LINE}</td></tr>
+ * <tr><td>{@code '\f'}</td> <td>{@code U+000C}</td>
+ * <td>{@code FORM FEED}</td></tr>
+ * <tr><td>{@code '\r'}</td> <td>{@code U+000D}</td>
+ * <td>{@code CARRIAGE RETURN}</td></tr>
+ * <tr><td>{@code ' '}</td> <td>{@code U+0020}</td>
+ * <td>{@code SPACE}</td></tr>
+ * </table>
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is ISO-LATIN-1 white
+ * space; {@code false} otherwise.
+ * @see Character#isSpaceChar(char)
+ * @see Character#isWhitespace(char)
+ * @deprecated Replaced by isWhitespace(char).
+ */
+ @Deprecated
+ public static boolean isSpace(char ch) {
+ return (ch <= 0x0020) &&
+ (((((1L << 0x0009) |
+ (1L << 0x000A) |
+ (1L << 0x000C) |
+ (1L << 0x000D) |
+ (1L << 0x0020)) >> ch) & 1L) != 0);
+ }
+
+
+ /**
+ * Determines if the specified character is a Unicode space character.
+ * A character is considered to be a space character if and only if
+ * it is specified to be a space character by the Unicode Standard. This
+ * method returns true if the character's general category type is any of
+ * the following:
+ * <ul>
+ * <li> {@code SPACE_SEPARATOR}
+ * <li> {@code LINE_SEPARATOR}
+ * <li> {@code PARAGRAPH_SEPARATOR}
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isSpaceChar(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is a space character;
+ * {@code false} otherwise.
+ * @see Character#isWhitespace(char)
+ * @since 1.1
+ */
+ public static boolean isSpaceChar(char ch) {
+ return isSpaceChar((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is a
+ * Unicode space character. A character is considered to be a
+ * space character if and only if it is specified to be a space
+ * character by the Unicode Standard. This method returns true if
+ * the character's general category type is any of the following:
+ *
+ * <ul>
+ * <li> {@link #SPACE_SEPARATOR}
+ * <li> {@link #LINE_SEPARATOR}
+ * <li> {@link #PARAGRAPH_SEPARATOR}
+ * </ul>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is a space character;
+ * {@code false} otherwise.
+ * @see Character#isWhitespace(int)
+ * @since 1.5
+ */
+ public static boolean isSpaceChar(int codePoint) {
+ return ((((1 << Character.SPACE_SEPARATOR) |
+ (1 << Character.LINE_SEPARATOR) |
+ (1 << Character.PARAGRAPH_SEPARATOR)) >> getType(codePoint)) & 1)
+ != 0;
+ }
+
+ /**
+ * Determines if the specified character is white space according to Java.
+ * A character is a Java whitespace character if and only if it satisfies
+ * one of the following criteria:
+ * <ul>
+ * <li> It is a Unicode space character ({@code SPACE_SEPARATOR},
+ * {@code LINE_SEPARATOR}, or {@code PARAGRAPH_SEPARATOR})
+ * but is not also a non-breaking space ({@code '\u005Cu00A0'},
+ * {@code '\u005Cu2007'}, {@code '\u005Cu202F'}).
+ * <li> It is {@code '\u005Ct'}, U+0009 HORIZONTAL TABULATION.
+ * <li> It is {@code '\u005Cn'}, U+000A LINE FEED.
+ * <li> It is {@code '\u005Cu000B'}, U+000B VERTICAL TABULATION.
+ * <li> It is {@code '\u005Cf'}, U+000C FORM FEED.
+ * <li> It is {@code '\u005Cr'}, U+000D CARRIAGE RETURN.
+ * <li> It is {@code '\u005Cu001C'}, U+001C FILE SEPARATOR.
+ * <li> It is {@code '\u005Cu001D'}, U+001D GROUP SEPARATOR.
+ * <li> It is {@code '\u005Cu001E'}, U+001E RECORD SEPARATOR.
+ * <li> It is {@code '\u005Cu001F'}, U+001F UNIT SEPARATOR.
+ * </ul>
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isWhitespace(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is a Java whitespace
+ * character; {@code false} otherwise.
+ * @see Character#isSpaceChar(char)
+ * @since 1.1
+ */
+ public static boolean isWhitespace(char ch) {
+ return isWhitespace((int)ch);
+ }
+
+ /**
+ * Determines if the specified character (Unicode code point) is
+ * white space according to Java. A character is a Java
+ * whitespace character if and only if it satisfies one of the
+ * following criteria:
+ * <ul>
+ * <li> It is a Unicode space character ({@link #SPACE_SEPARATOR},
+ * {@link #LINE_SEPARATOR}, or {@link #PARAGRAPH_SEPARATOR})
+ * but is not also a non-breaking space ({@code '\u005Cu00A0'},
+ * {@code '\u005Cu2007'}, {@code '\u005Cu202F'}).
+ * <li> It is {@code '\u005Ct'}, U+0009 HORIZONTAL TABULATION.
+ * <li> It is {@code '\u005Cn'}, U+000A LINE FEED.
+ * <li> It is {@code '\u005Cu000B'}, U+000B VERTICAL TABULATION.
+ * <li> It is {@code '\u005Cf'}, U+000C FORM FEED.
+ * <li> It is {@code '\u005Cr'}, U+000D CARRIAGE RETURN.
+ * <li> It is {@code '\u005Cu001C'}, U+001C FILE SEPARATOR.
+ * <li> It is {@code '\u005Cu001D'}, U+001D GROUP SEPARATOR.
+ * <li> It is {@code '\u005Cu001E'}, U+001E RECORD SEPARATOR.
+ * <li> It is {@code '\u005Cu001F'}, U+001F UNIT SEPARATOR.
+ * </ul>
+ * <p>
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is a Java whitespace
+ * character; {@code false} otherwise.
+ * @see Character#isSpaceChar(int)
+ * @since 1.5
+ */
+ public static boolean isWhitespace(int codePoint) {
+ return CharacterData.of(codePoint).isWhitespace(codePoint);
+ }
+
+ /**
+ * Determines if the specified character is an ISO control
+ * character. A character is considered to be an ISO control
+ * character if its code is in the range {@code '\u005Cu0000'}
+ * through {@code '\u005Cu001F'} or in the range
+ * {@code '\u005Cu007F'} through {@code '\u005Cu009F'}.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isISOControl(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return {@code true} if the character is an ISO control character;
+ * {@code false} otherwise.
+ *
+ * @see Character#isSpaceChar(char)
+ * @see Character#isWhitespace(char)
+ * @since 1.1
+ */
+ public static boolean isISOControl(char ch) {
+ return isISOControl((int)ch);
+ }
+
+ /**
+ * Determines if the referenced character (Unicode code point) is an ISO control
+ * character. A character is considered to be an ISO control
+ * character if its code is in the range {@code '\u005Cu0000'}
+ * through {@code '\u005Cu001F'} or in the range
+ * {@code '\u005Cu007F'} through {@code '\u005Cu009F'}.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is an ISO control character;
+ * {@code false} otherwise.
+ * @see Character#isSpaceChar(int)
+ * @see Character#isWhitespace(int)
+ * @since 1.5
+ */
+ public static boolean isISOControl(int codePoint) {
+ // Optimized form of:
+ // (codePoint >= 0x00 && codePoint <= 0x1F) ||
+ // (codePoint >= 0x7F && codePoint <= 0x9F);
+ return codePoint <= 0x9F &&
+ (codePoint >= 0x7F || (codePoint >>> 5 == 0));
+ }
+
+ /**
+ * Returns a value indicating a character's general category.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #getType(int)} method.
+ *
+ * @param ch the character to be tested.
+ * @return a value of type {@code int} representing the
+ * character's general category.
+ * @see Character#COMBINING_SPACING_MARK
+ * @see Character#CONNECTOR_PUNCTUATION
+ * @see Character#CONTROL
+ * @see Character#CURRENCY_SYMBOL
+ * @see Character#DASH_PUNCTUATION
+ * @see Character#DECIMAL_DIGIT_NUMBER
+ * @see Character#ENCLOSING_MARK
+ * @see Character#END_PUNCTUATION
+ * @see Character#FINAL_QUOTE_PUNCTUATION
+ * @see Character#FORMAT
+ * @see Character#INITIAL_QUOTE_PUNCTUATION
+ * @see Character#LETTER_NUMBER
+ * @see Character#LINE_SEPARATOR
+ * @see Character#LOWERCASE_LETTER
+ * @see Character#MATH_SYMBOL
+ * @see Character#MODIFIER_LETTER
+ * @see Character#MODIFIER_SYMBOL
+ * @see Character#NON_SPACING_MARK
+ * @see Character#OTHER_LETTER
+ * @see Character#OTHER_NUMBER
+ * @see Character#OTHER_PUNCTUATION
+ * @see Character#OTHER_SYMBOL
+ * @see Character#PARAGRAPH_SEPARATOR
+ * @see Character#PRIVATE_USE
+ * @see Character#SPACE_SEPARATOR
+ * @see Character#START_PUNCTUATION
+ * @see Character#SURROGATE
+ * @see Character#TITLECASE_LETTER
+ * @see Character#UNASSIGNED
+ * @see Character#UPPERCASE_LETTER
+ * @since 1.1
+ */
+ public static int getType(char ch) {
+ return getType((int)ch);
+ }
+
+ /**
+ * Returns a value indicating a character's general category.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return a value of type {@code int} representing the
+ * character's general category.
+ * @see Character#COMBINING_SPACING_MARK COMBINING_SPACING_MARK
+ * @see Character#CONNECTOR_PUNCTUATION CONNECTOR_PUNCTUATION
+ * @see Character#CONTROL CONTROL
+ * @see Character#CURRENCY_SYMBOL CURRENCY_SYMBOL
+ * @see Character#DASH_PUNCTUATION DASH_PUNCTUATION
+ * @see Character#DECIMAL_DIGIT_NUMBER DECIMAL_DIGIT_NUMBER
+ * @see Character#ENCLOSING_MARK ENCLOSING_MARK
+ * @see Character#END_PUNCTUATION END_PUNCTUATION
+ * @see Character#FINAL_QUOTE_PUNCTUATION FINAL_QUOTE_PUNCTUATION
+ * @see Character#FORMAT FORMAT
+ * @see Character#INITIAL_QUOTE_PUNCTUATION INITIAL_QUOTE_PUNCTUATION
+ * @see Character#LETTER_NUMBER LETTER_NUMBER
+ * @see Character#LINE_SEPARATOR LINE_SEPARATOR
+ * @see Character#LOWERCASE_LETTER LOWERCASE_LETTER
+ * @see Character#MATH_SYMBOL MATH_SYMBOL
+ * @see Character#MODIFIER_LETTER MODIFIER_LETTER
+ * @see Character#MODIFIER_SYMBOL MODIFIER_SYMBOL
+ * @see Character#NON_SPACING_MARK NON_SPACING_MARK
+ * @see Character#OTHER_LETTER OTHER_LETTER
+ * @see Character#OTHER_NUMBER OTHER_NUMBER
+ * @see Character#OTHER_PUNCTUATION OTHER_PUNCTUATION
+ * @see Character#OTHER_SYMBOL OTHER_SYMBOL
+ * @see Character#PARAGRAPH_SEPARATOR PARAGRAPH_SEPARATOR
+ * @see Character#PRIVATE_USE PRIVATE_USE
+ * @see Character#SPACE_SEPARATOR SPACE_SEPARATOR
+ * @see Character#START_PUNCTUATION START_PUNCTUATION
+ * @see Character#SURROGATE SURROGATE
+ * @see Character#TITLECASE_LETTER TITLECASE_LETTER
+ * @see Character#UNASSIGNED UNASSIGNED
+ * @see Character#UPPERCASE_LETTER UPPERCASE_LETTER
+ * @since 1.5
+ */
+ public static int getType(int codePoint) {
+ return CharacterData.of(codePoint).getType(codePoint);
+ }
+
+ /**
+ * Determines the character representation for a specific digit in
+ * the specified radix. If the value of {@code radix} is not a
+ * valid radix, or the value of {@code digit} is not a valid
+ * digit in the specified radix, the null character
+ * ({@code '\u005Cu0000'}) is returned.
+ * <p>
+ * The {@code radix} argument is valid if it is greater than or
+ * equal to {@code MIN_RADIX} and less than or equal to
+ * {@code MAX_RADIX}. The {@code digit} argument is valid if
+ * {@code 0 <= digit < radix}.
+ * <p>
+ * If the digit is less than 10, then
+ * {@code '0' + digit} is returned. Otherwise, the value
+ * {@code 'a' + digit - 10} is returned.
+ *
+ * @param digit the number to convert to a character.
+ * @param radix the radix.
+ * @return the {@code char} representation of the specified digit
+ * in the specified radix.
+ * @see Character#MIN_RADIX
+ * @see Character#MAX_RADIX
+ * @see Character#digit(char, int)
+ */
+ public static char forDigit(int digit, int radix) {
+ if ((digit >= radix) || (digit < 0)) {
+ return '\0';
+ }
+ if ((radix < Character.MIN_RADIX) || (radix > Character.MAX_RADIX)) {
+ return '\0';
+ }
+ if (digit < 10) {
+ return (char)('0' + digit);
+ }
+ return (char)('a' - 10 + digit);
+ }
+
+ /**
+ * Returns the Unicode directionality property for the given
+ * character. Character directionality is used to calculate the
+ * visual ordering of text. The directionality value of undefined
+ * {@code char} values is {@code DIRECTIONALITY_UNDEFINED}.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #getDirectionality(int)} method.
+ *
+ * @param ch {@code char} for which the directionality property
+ * is requested.
+ * @return the directionality property of the {@code char} value.
+ *
+ * @see Character#DIRECTIONALITY_UNDEFINED
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
+ * @see Character#DIRECTIONALITY_ARABIC_NUMBER
+ * @see Character#DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
+ * @see Character#DIRECTIONALITY_NONSPACING_MARK
+ * @see Character#DIRECTIONALITY_BOUNDARY_NEUTRAL
+ * @see Character#DIRECTIONALITY_PARAGRAPH_SEPARATOR
+ * @see Character#DIRECTIONALITY_SEGMENT_SEPARATOR
+ * @see Character#DIRECTIONALITY_WHITESPACE
+ * @see Character#DIRECTIONALITY_OTHER_NEUTRALS
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
+ * @see Character#DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
+ * @since 1.4
+ */
+ public static byte getDirectionality(char ch) {
+ return getDirectionality((int)ch);
+ }
+
+ /**
+ * Returns the Unicode directionality property for the given
+ * character (Unicode code point). Character directionality is
+ * used to calculate the visual ordering of text. The
+ * directionality value of undefined character is {@link
+ * #DIRECTIONALITY_UNDEFINED}.
+ *
+ * @param codePoint the character (Unicode code point) for which
+ * the directionality property is requested.
+ * @return the directionality property of the character.
+ *
+ * @see Character#DIRECTIONALITY_UNDEFINED DIRECTIONALITY_UNDEFINED
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT DIRECTIONALITY_LEFT_TO_RIGHT
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT DIRECTIONALITY_RIGHT_TO_LEFT
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER DIRECTIONALITY_EUROPEAN_NUMBER
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR
+ * @see Character#DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR
+ * @see Character#DIRECTIONALITY_ARABIC_NUMBER DIRECTIONALITY_ARABIC_NUMBER
+ * @see Character#DIRECTIONALITY_COMMON_NUMBER_SEPARATOR DIRECTIONALITY_COMMON_NUMBER_SEPARATOR
+ * @see Character#DIRECTIONALITY_NONSPACING_MARK DIRECTIONALITY_NONSPACING_MARK
+ * @see Character#DIRECTIONALITY_BOUNDARY_NEUTRAL DIRECTIONALITY_BOUNDARY_NEUTRAL
+ * @see Character#DIRECTIONALITY_PARAGRAPH_SEPARATOR DIRECTIONALITY_PARAGRAPH_SEPARATOR
+ * @see Character#DIRECTIONALITY_SEGMENT_SEPARATOR DIRECTIONALITY_SEGMENT_SEPARATOR
+ * @see Character#DIRECTIONALITY_WHITESPACE DIRECTIONALITY_WHITESPACE
+ * @see Character#DIRECTIONALITY_OTHER_NEUTRALS DIRECTIONALITY_OTHER_NEUTRALS
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING
+ * @see Character#DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING
+ * @see Character#DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE
+ * @see Character#DIRECTIONALITY_POP_DIRECTIONAL_FORMAT DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
+ * @since 1.5
+ */
+ public static byte getDirectionality(int codePoint) {
+ return CharacterData.of(codePoint).getDirectionality(codePoint);
+ }
+
+ /**
+ * Determines whether the character is mirrored according to the
+ * Unicode specification. Mirrored characters should have their
+ * glyphs horizontally mirrored when displayed in text that is
+ * right-to-left. For example, {@code '\u005Cu0028'} LEFT
+ * PARENTHESIS is semantically defined to be an <i>opening
+ * parenthesis</i>. This will appear as a "(" in text that is
+ * left-to-right but as a ")" in text that is right-to-left.
+ *
+ * <p><b>Note:</b> This method cannot handle <a
+ * href="#supplementary"> supplementary characters</a>. To support
+ * all Unicode characters, including supplementary characters, use
+ * the {@link #isMirrored(int)} method.
+ *
+ * @param ch {@code char} for which the mirrored property is requested
+ * @return {@code true} if the char is mirrored, {@code false}
+ * if the {@code char} is not mirrored or is not defined.
+ * @since 1.4
+ */
+ public static boolean isMirrored(char ch) {
+ return isMirrored((int)ch);
+ }
+
+ /**
+ * Determines whether the specified character (Unicode code point)
+ * is mirrored according to the Unicode specification. Mirrored
+ * characters should have their glyphs horizontally mirrored when
+ * displayed in text that is right-to-left. For example,
+ * {@code '\u005Cu0028'} LEFT PARENTHESIS is semantically
+ * defined to be an <i>opening parenthesis</i>. This will appear
+ * as a "(" in text that is left-to-right but as a ")" in text
+ * that is right-to-left.
+ *
+ * @param codePoint the character (Unicode code point) to be tested.
+ * @return {@code true} if the character is mirrored, {@code false}
+ * if the character is not mirrored or is not defined.
+ * @since 1.5
+ */
+ public static boolean isMirrored(int codePoint) {
+ return CharacterData.of(codePoint).isMirrored(codePoint);
+ }
+
+ /**
+ * Compares two {@code Character} objects numerically.
+ *
+ * @param anotherCharacter the {@code Character} to be compared.
+
+ * @return the value {@code 0} if the argument {@code Character}
+ * is equal to this {@code Character}; a value less than
+ * {@code 0} if this {@code Character} is numerically less
+ * than the {@code Character} argument; and a value greater than
+ * {@code 0} if this {@code Character} is numerically greater
+ * than the {@code Character} argument (unsigned comparison).
+ * Note that this is strictly a numerical comparison; it is not
+ * locale-dependent.
+ * @since 1.2
+ */
+ public int compareTo(Character anotherCharacter) {
+ return compare(this.value, anotherCharacter.value);
+ }
+
+ /**
+ * Compares two {@code char} values numerically.
+ * The value returned is identical to what would be returned by:
+ * <pre>
+ * Character.valueOf(x).compareTo(Character.valueOf(y))
+ * </pre>
+ *
+ * @param x the first {@code char} to compare
+ * @param y the second {@code char} to compare
+ * @return the value {@code 0} if {@code x == y};
+ * a value less than {@code 0} if {@code x < y}; and
+ * a value greater than {@code 0} if {@code x > y}
+ * @since 1.7
+ */
+ public static int compare(char x, char y) {
+ return x - y;
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to uppercase using
+ * information from the UnicodeData file.
+ * <p>
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return either the uppercase equivalent of the character, if
+ * any, or an error flag ({@code Character.ERROR})
+ * that indicates that a 1:M {@code char} mapping exists.
+ * @see Character#isLowerCase(char)
+ * @see Character#isUpperCase(char)
+ * @see Character#toLowerCase(char)
+ * @see Character#toTitleCase(char)
+ * @since 1.4
+ */
+ static int toUpperCaseEx(int codePoint) {
+ assert isValidCodePoint(codePoint);
+ return CharacterData.of(codePoint).toUpperCaseEx(codePoint);
+ }
+
+ /**
+ * Converts the character (Unicode code point) argument to uppercase using case
+ * mapping information from the SpecialCasing file in the Unicode
+ * specification. If a character has no explicit uppercase
+ * mapping, then the {@code char} itself is returned in the
+ * {@code char[]}.
+ *
+ * @param codePoint the character (Unicode code point) to be converted.
+ * @return a {@code char[]} with the uppercased character.
+ * @since 1.4
+ */
+ static char[] toUpperCaseCharArray(int codePoint) {
+ // As of Unicode 6.0, 1:M uppercasings only happen in the BMP.
+ assert isBmpCodePoint(codePoint);
+ return CharacterData.of(codePoint).toUpperCaseCharArray(codePoint);
+ }
+
+ /**
+ * The number of bits used to represent a <tt>char</tt> value in unsigned
+ * binary form, constant {@code 16}.
+ *
+ * @since 1.5
+ */
+ public static final int SIZE = 16;
+
+ /**
+ * The number of bytes used to represent a {@code char} value in unsigned
+ * binary form.
+ *
+ * @since 1.8
+ */
+ public static final int BYTES = SIZE / Byte.SIZE;
+
+ /**
+ * Returns the value obtained by reversing the order of the bytes in the
+ * specified <tt>char</tt> value.
+ *
+ * @param ch The {@code char} of which to reverse the byte order.
+ * @return the value obtained by reversing (or, equivalently, swapping)
+ * the bytes in the specified <tt>char</tt> value.
+ * @since 1.5
+ */
+ public static char reverseBytes(char ch) {
+ return (char) (((ch & 0xFF00) >> 8) | (ch << 8));
+ }
+
+ /**
+ * Returns the Unicode name of the specified character
+ * {@code codePoint}, or null if the code point is
+ * {@link #UNASSIGNED unassigned}.
+ * <p>
+ * Note: if the specified character is not assigned a name by
+ * the <i>UnicodeData</i> file (part of the Unicode Character
+ * Database maintained by the Unicode Consortium), the returned
+ * name is the same as the result of expression.
+ *
+ * <blockquote>{@code
+ * Character.UnicodeBlock.of(codePoint).toString().replace('_', ' ')
+ * + " "
+ * + Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH);
+ *
+ * }</blockquote>
+ *
+ * @param codePoint the character (Unicode code point)
+ *
+ * @return the Unicode name of the specified character, or null if
+ * the code point is unassigned.
+ *
+ * @exception IllegalArgumentException if the specified
+ * {@code codePoint} is not a valid Unicode
+ * code point.
+ *
+ * @since 1.7
+ */
+ public static String getName(int codePoint) {
+ if (!isValidCodePoint(codePoint)) {
+ throw new IllegalArgumentException();
+ }
+ String name = CharacterName.get(codePoint);
+ if (name != null)
+ return name;
+ if (getType(codePoint) == UNASSIGNED)
+ return null;
+ UnicodeBlock block = UnicodeBlock.of(codePoint);
+ if (block != null)
+ return block.toString().replace('_', ' ') + " "
+ + Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH);
+ // should never come here
+ return Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH);
+ }
+}
diff --git a/src/main/java/java/lang/Class.java b/src/main/java/java/lang/Class.java
index 3359fea..2685534 100644
--- a/src/main/java/java/lang/Class.java
+++ b/src/main/java/java/lang/Class.java
@@ -27,10 +27,13 @@
import java.util.HashMap;
import java.util.Map;
-import org.cprover.CProver;
+
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
+import org.cprover.CProver;
+import org.cprover.CProverString;
+
public final class Class<T> {
private Class() {}
@@ -118,15 +121,21 @@ public static Class<?> forName(String name, boolean initialize,
public boolean isInterface() { return isInterface; }
public boolean isArray() { return isArray; }
public boolean isPrimitive() {
- return "java.lang.Boolean".equals(name) ||
- "java.lang.Character".equals(name) ||
- "java.lang.Byte".equals(name) ||
- "java.lang.Short".equals(name) ||
- "java.lang.Integer".equals(name) ||
- "java.lang.Long".equals(name) ||
- "java.lang.Float".equals(name) ||
- "java.lang.Double".equals(name) ||
- "java.lang.Void".equals(name);}
+ // DIFFBLUE MODEL LIBRARY
+ // We use pointer equality instead of string equality because
+ // it is more efficient.
+ // This will only work if the name is defined through a constant literal,
+ // which should be the case for primitive classes.
+ return name == "boolean" ||
+ name == "char" ||
+ name == "byte" ||
+ name == "short" ||
+ name == "int" ||
+ name == "long" ||
+ name == "float" ||
+ name == "double"||
+ name == "void";
+ }
public boolean isAnnotation() { return isAnnotation; }
public boolean isSynthetic() { return isSynthetic; }
@@ -201,19 +210,20 @@ public String getSimpleName() {
String name = getName();
int index = name.lastIndexOf('$');
if(index == -1) { // top level class
- return name.substring(name.lastIndexOf('.') + 1); // strip the package name
+ return CProverString.substring(name, name.lastIndexOf('.') + 1); // strip the package name
}
else {
// DIFFBLUE MODEL LIBRARY: in the original JDK getSimpleBinary
// looks for "$1", instead we looked for '$' and assume the next
// character will be '1'
- CProver.assume(name.charAt(index+1) == '1');
+ CProver.assume(CProverString.charAt(name, index + 1) == '1');
// DIFFBLUE MODEL LIBRARY: $1 should be preceded by a class name
CProver.assume(index >= 1);
// DIFFBLUE MODEL LIBRARY: in the original JDK getSimpleName
// removes the digits that follow
- CProver.assume(!isAsciiDigit(name.charAt(index + 2)));
- return name.substring(index + 2);
+ CProver.assume(name.length() > index + 2);
+ CProver.assume(!isAsciiDigit(CProverString.charAt(name, index + 2)));
+ return CProverString.substring(name, index + 2);
}
}
@@ -229,7 +239,7 @@ public Class getEnclosingClass() {
}
else
{
- String enclosing_name = name.substring(0, index);
+ String enclosing_name = CProverString.substring(name, 0, index);
return Class.forName(enclosing_name);
}
}
@@ -265,7 +275,7 @@ private String getSimpleBinaryName() {
return null;
// Otherwise, strip the enclosing class' name
try {
- return getName().substring(enclosingClass.getName().length());
+ return CProverString.substring(getName(), enclosingClass.getName().length());
} catch (IndexOutOfBoundsException ex) {
throw new InternalError("Malformed class name", ex);
}
@@ -285,11 +295,11 @@ private String resolveName(String name) {
String baseName = c.getName();
int index = baseName.lastIndexOf('.');
if (index != -1) {
- name = baseName.substring(0, index).replace('.', '/')
+ name = CProverString.substring(baseName, 0, index).replace('.', '/')
+"/"+name;
}
} else {
- name = name.substring(1);
+ name = CProverString.substring(name, 1);
}
return name;
}
@@ -301,26 +311,26 @@ public Class getSuperclass(){
public static Class getPrimitiveClass(String s){
if("boolean".equals(s))
- return Class.forName("java.lang.Boolean");
+ return Class.forName("boolean");
if("char".equals(s))
- return Class.forName("java.lang.Character");
+ return Class.forName("char");
if("byte".equals(s))
- return Class.forName("java.lang.Byte");
+ return Class.forName("byte");
if("short".equals(s))
- return Class.forName("java.lang.Short");
+ return Class.forName("short");
if("int".equals(s))
- return Class.forName("java.lang.Integer");
+ return Class.forName("int");
if("long".equals(s))
- return Class.forName("java.lang.Long");
+ return Class.forName("long");
if("float".equals(s))
- return Class.forName("java.lang.Float");
+ return Class.forName("float");
if("double".equals(s))
- return Class.forName("java.lang.Double");
+ return Class.forName("double");
if("void".equals(s))
- return Class.forName("java.lang.Void");
- // TODO: we should throw an exception but this does not seem to work well
- // at the moment, so we will assume it does not happen instead.
- // throw new IllegalArgumentException("Not primitive type : " + s);
+ return Class.forName("void");
+ // TODO: we should throw an exception but this does not seem to work well
+ // at the moment, so we will assume it does not happen instead.
+ // throw new IllegalArgumentException("Not primitive type : " + s);
CProver.assume(false);
return Class.forName("");
}
@@ -333,22 +343,22 @@ public static Class getPrimitiveClass(String s){
// takes 8 seconds while the int version takes 3 seconds.
static Class getPrimitiveClass(int i){
if(i==0)
- return Class.forName("java.lang.Boolean");
+ return Class.forName("boolean");
if(i==1)
- return Class.forName("java.lang.Character");
+ return Class.forName("char");
if(i==2)
- return Class.forName("java.lang.Byte");
+ return Class.forName("byte");
if(i==3)
- return Class.forName("java.lang.Short");
+ return Class.forName("short");
if(i==4)
- return Class.forName("java.lang.Integer");
+ return Class.forName("int");
if(i==5)
- return Class.forName("java.lang.Long");
+ return Class.forName("long");
if(i==6)
- return Class.forName("java.lang.Float");
+ return Class.forName("float");
if(i==7)
- return Class.forName("java.lang.Double");
- return Class.forName("java.lang.Void");
+ return Class.forName("double");
+ return Class.forName("void");
}
Map<String, T> enumConstantDirectory() {
@@ -370,7 +380,7 @@ Map<String, T> enumConstantDirectory() {
// would probably need to be modeled internally in our tools
T[] getEnumConstantsShared() {
// DIFFBLUE MODEL LIBRARY @TODO: implement this method internally in CBMC
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
/**
@@ -421,6 +431,20 @@ private static boolean desiredAssertionStatus0(Class<?> clazz) {
return true;
}
+ // DIFFBLUE MODEL LIBRARY
+ // This method is called by CBMC just after nondeterministic object creation,
+ // i.e., the constraints that it specifies are enforced only on objects that
+ // are passed as an argument to a method, and only at the time when they are
+ // first created.
+ // We generally want to make sure that all necessary invariants of the class
+ // are satisfied, and potentially restrict some fields to speed up test
+ // generation.
+ @org.cprover.MustNotThrow
+ protected void cproverNondetInitialize() {
+ CProver.assume(name != null);
+ CProver.assume(enumConstantDirectory == null);
+ }
+
// DIFFBLUE MODEL LIBRARY
// This method is called by CBMC to try to set class constants, which can
// avoid the time-consuming process of enumerating over the constant
diff --git a/src/main/java/java/lang/ClassCastException.java b/src/main/java/java/lang/ClassCastException.java
new file mode 100644
index 0000000..0abb02f
--- /dev/null
+++ b/src/main/java/java/lang/ClassCastException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class ClassCastException extends RuntimeException {
+ private static final long serialVersionUID = -9223365651070458532L;
+
+ public ClassCastException() {
+ super();
+ }
+
+ public ClassCastException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.ClassCastException: " + message)
+ : "java.lang.ClassCastException";
+ }
+}
diff --git a/src/main/java/java/lang/ClassCircularityError.java b/src/main/java/java/lang/ClassCircularityError.java
new file mode 100644
index 0000000..507a9fd
--- /dev/null
+++ b/src/main/java/java/lang/ClassCircularityError.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when the Java Virtual Machine detects a circularity in the
+ * superclass hierarchy of a class being loaded.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public class ClassCircularityError extends LinkageError {
+ private static final long serialVersionUID = 1054362542914539689L;
+
+ /**
+ * Constructs a {@code ClassCircularityError} with no detail message.
+ */
+ public ClassCircularityError() {
+ super();
+ }
+
+ /**
+ * Constructs a {@code ClassCircularityError} with the specified detail
+ * message.
+ *
+ * @param s
+ * The detail message
+ */
+ public ClassCircularityError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.ClassCircularityError: " + message)
+ : "java.lang.ClassCircularityError";
+ }
+}
diff --git a/src/main/java/java/lang/ClassFormatError.java b/src/main/java/java/lang/ClassFormatError.java
new file mode 100644
index 0000000..f9a5f02
--- /dev/null
+++ b/src/main/java/java/lang/ClassFormatError.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when the Java Virtual Machine attempts to read a class
+ * file and determines that the file is malformed or otherwise cannot
+ * be interpreted as a class file.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public
+class ClassFormatError extends LinkageError {
+ private static final long serialVersionUID = -8420114879011949195L;
+
+ /**
+ * Constructs a <code>ClassFormatError</code> with no detail message.
+ */
+ public ClassFormatError() {
+ super();
+ }
+
+ /**
+ * Constructs a <code>ClassFormatError</code> with the specified
+ * detail message.
+ *
+ * @param s the detail message.
+ */
+ public ClassFormatError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.ClassFormatError: " + message)
+ : "java.lang.ClassFormatError";
+ }
+}
diff --git a/src/main/java/java/lang/ClassNotFoundException.java b/src/main/java/java/lang/ClassNotFoundException.java
new file mode 100644
index 0000000..ee48194
--- /dev/null
+++ b/src/main/java/java/lang/ClassNotFoundException.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 1995, 2004, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public class ClassNotFoundException extends ReflectiveOperationException {
+ private static final long serialVersionUID = 9176873029745254542L;
+
+ private Throwable ex;
+
+ public ClassNotFoundException() {
+ super((Throwable)null); // Disallow initCause
+ }
+
+ public ClassNotFoundException(String s) {
+ super(s, null); // Disallow initCause
+ }
+
+ public ClassNotFoundException(String s, Throwable ex) {
+ super(s, null); // Disallow initCause
+ this.ex = ex;
+ }
+
+ public Throwable getException() {
+ return ex;
+ }
+
+ public Throwable getCause() {
+ return ex;
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.ClassNotFoundException: " + message)
+ : "java.lang.ClassNotFoundException";
+ }
+}
diff --git a/src/main/java/java/lang/CloneNotSupportedException.java b/src/main/java/java/lang/CloneNotSupportedException.java
new file mode 100644
index 0000000..b969f60
--- /dev/null
+++ b/src/main/java/java/lang/CloneNotSupportedException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class CloneNotSupportedException extends Exception {
+ private static final long serialVersionUID = 5195511250079656443L;
+
+ public CloneNotSupportedException() {
+ super();
+ }
+
+ public CloneNotSupportedException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.CloneNotSupportedException: " + message)
+ : "java.lang.CloneNotSupportedException";
+ }
+}
diff --git a/src/main/java/java/lang/Enum.java b/src/main/java/java/lang/Enum.java
new file mode 100644
index 0000000..8199eeb
--- /dev/null
+++ b/src/main/java/java/lang/Enum.java
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import java.io.Serializable;
+import java.io.IOException;
+import java.io.InvalidObjectException;
+import java.io.ObjectInputStream;
+import java.io.ObjectStreamException;
+
+/**
+ * This is the common base class of all Java language enumeration types.
+ *
+ * More information about enums, including descriptions of the
+ * implicitly declared methods synthesized by the compiler, can be
+ * found in section 8.9 of
+ * <cite>The Java™ Language Specification</cite>.
+ *
+ * <p> Note that when using an enumeration type as the type of a set
+ * or as the type of the keys in a map, specialized and efficient
+ * {@linkplain java.util.EnumSet set} and {@linkplain
+ * java.util.EnumMap map} implementations are available.
+ *
+ * @param <E> The enum type subclass
+ * @author Josh Bloch
+ * @author Neal Gafter
+ * @see Class#getEnumConstants()
+ * @see java.util.EnumSet
+ * @see java.util.EnumMap
+ * @since 1.5
+ */
+public abstract class Enum<E extends Enum<E>>
+ implements Comparable<E>, Serializable {
+ /**
+ * The name of this enum constant, as declared in the enum declaration.
+ * Most programmers should use the {@link #toString} method rather than
+ * accessing this field.
+ */
+ private final String name;
+
+ /**
+ * Returns the name of this enum constant, exactly as declared in its
+ * enum declaration.
+ *
+ * <b>Most programmers should use the {@link #toString} method in
+ * preference to this one, as the toString method may return
+ * a more user-friendly name.</b> This method is designed primarily for
+ * use in specialized situations where correctness depends on getting the
+ * exact name, which will not vary from release to release.
+ *
+ * @return the name of this enum constant
+ */
+ public final String name() {
+ return name;
+ }
+
+ /**
+ * The ordinal of this enumeration constant (its position
+ * in the enum declaration, where the initial constant is assigned
+ * an ordinal of zero).
+ *
+ * Most programmers will have no use for this field. It is designed
+ * for use by sophisticated enum-based data structures, such as
+ * {@link java.util.EnumSet} and {@link java.util.EnumMap}.
+ */
+ private final int ordinal;
+
+ /**
+ * Returns the ordinal of this enumeration constant (its position
+ * in its enum declaration, where the initial constant is assigned
+ * an ordinal of zero).
+ *
+ * Most programmers will have no use for this method. It is
+ * designed for use by sophisticated enum-based data structures, such
+ * as {@link java.util.EnumSet} and {@link java.util.EnumMap}.
+ *
+ * @return the ordinal of this enumeration constant
+ */
+ public final int ordinal() {
+ return ordinal;
+ }
+
+ /**
+ * Sole constructor. Programmers cannot invoke this constructor.
+ * It is for use by code emitted by the compiler in response to
+ * enum type declarations.
+ *
+ * @param name - The name of this enum constant, which is the identifier
+ * used to declare it.
+ * @param ordinal - The ordinal of this enumeration constant (its position
+ * in the enum declaration, where the initial constant is assigned
+ * an ordinal of zero).
+ */
+ protected Enum(String name, int ordinal) {
+ this.name = name;
+ this.ordinal = ordinal;
+ }
+
+ /**
+ * Returns the name of this enum constant, as contained in the
+ * declaration. This method may be overridden, though it typically
+ * isn't necessary or desirable. An enum type should override this
+ * method when a more "programmer-friendly" string form exists.
+ *
+ * @return the name of this enum constant
+ */
+ public String toString() {
+ return name;
+ }
+
+ /**
+ * Returns true if the specified object is equal to this
+ * enum constant.
+ *
+ * @param other the object to be compared for equality with this object.
+ * @return true if the specified object is equal to this
+ * enum constant.
+ */
+ public final boolean equals(Object other) {
+ return this==other;
+ }
+
+ /**
+ * Returns a hash code for this enum constant.
+ *
+ * @return a hash code for this enum constant.
+ */
+ public final int hashCode() {
+ return super.hashCode();
+ }
+
+ /**
+ * Throws CloneNotSupportedException. This guarantees that enums
+ * are never cloned, which is necessary to preserve their "singleton"
+ * status.
+ *
+ * @return (never returns)
+ */
+ protected final Object clone() throws CloneNotSupportedException {
+ throw new CloneNotSupportedException();
+ }
+
+ /**
+ * Compares this enum with the specified object for order. Returns a
+ * negative integer, zero, or a positive integer as this object is less
+ * than, equal to, or greater than the specified object.
+ *
+ * Enum constants are only comparable to other enum constants of the
+ * same enum type. The natural order implemented by this
+ * method is the order in which the constants are declared.
+ */
+ public final int compareTo(E o) {
+ Enum<?> other = (Enum<?>)o;
+ Enum<E> self = this;
+ if (self.getClass() != other.getClass())
+ throw new ClassCastException();
+ return self.ordinal - other.ordinal;
+ }
+
+ /**
+ * Returns the Class object corresponding to this enum constant's
+ * enum type. Two enum constants e1 and e2 are of the
+ * same enum type if and only if
+ * e1.getDeclaringClass() == e2.getDeclaringClass().
+ * (The value returned by this method may differ from the one returned
+ * by the {@link Object#getClass} method for enum constants with
+ * constant-specific class bodies.)
+ *
+ * @return the Class object corresponding to this enum constant's
+ * enum type
+ */
+ @SuppressWarnings("unchecked")
+ public final Class<E> getDeclaringClass() {
+ Class<?> clazz = getClass();
+ Class<?> zuper = clazz.getSuperclass();
+ return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
+ }
+
+ /**
+ * Returns the enum constant of the specified enum type with the
+ * specified name. The name must match exactly an identifier used
+ * to declare an enum constant in this type. (Extraneous whitespace
+ * characters are not permitted.)
+ *
+ * <p>Note that for a particular enum type {@code T}, the
+ * implicitly declared {@code public static T valueOf(String)}
+ * method on that enum may be used instead of this method to map
+ * from a name to the corresponding enum constant. All the
+ * constants of an enum type can be obtained by calling the
+ * implicit {@code public static T[] values()} method of that
+ * type.
+ *
+ * @param <T> The enum type whose constant is to be returned
+ * @param enumType the {@code Class} object of the enum type from which
+ * to return a constant
+ * @param name the name of the constant to return
+ * @return the enum constant of the specified enum type with the
+ * specified name
+ * @throws IllegalArgumentException if the specified enum type has
+ * no constant with the specified name, or the specified
+ * class object does not represent an enum type
+ * @throws NullPointerException if {@code enumType} or {@code name}
+ * is null
+ * @since 1.5
+ */
+ public static <T extends Enum<T>> T valueOf(Class<T> enumType,
+ String name) {
+ T result = enumType.enumConstantDirectory().get(name);
+ if (result != null)
+ return result;
+ if (name == null)
+ throw new NullPointerException("Name is null");
+ throw new IllegalArgumentException(
+ "No enum constant " + enumType.getCanonicalName() + "." + name);
+ }
+
+ /**
+ * enum classes cannot have finalize methods.
+ */
+ protected final void finalize() { }
+
+ /**
+ * prevent default deserialization
+ */
+ private void readObject(ObjectInputStream in) throws IOException,
+ ClassNotFoundException {
+ throw new InvalidObjectException("can't deserialize enum");
+ }
+
+ private void readObjectNoData() throws ObjectStreamException {
+ throw new InvalidObjectException("can't deserialize enum");
+ }
+}
diff --git a/src/main/java/java/lang/EnumConstantNotPresentException.java b/src/main/java/java/lang/EnumConstantNotPresentException.java
new file mode 100644
index 0000000..79b6a19
--- /dev/null
+++ b/src/main/java/java/lang/EnumConstantNotPresentException.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2004, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+@SuppressWarnings("rawtypes") /* rawtypes are part of the public api */
+public class EnumConstantNotPresentException extends RuntimeException {
+ private static final long serialVersionUID = -6046998521960521108L;
+
+ private Class<? extends Enum> enumType;
+
+ private String constantName;
+
+ public EnumConstantNotPresentException(Class<? extends Enum> enumType,
+ String constantName) {
+ super(enumType.getName() + "." + constantName);
+ this.enumType = enumType;
+ this.constantName = constantName;
+ }
+
+ public Class<? extends Enum> enumType() { return enumType; }
+
+ public String constantName() { return constantName; }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.EnumConstantNotPresentException: " + message)
+ : "java.lang.EnumConstantNotPresentException";
+ }
+}
diff --git a/src/main/java/java/lang/ExceptionInInitializerError.java b/src/main/java/java/lang/ExceptionInInitializerError.java
new file mode 100644
index 0000000..d7640ae
--- /dev/null
+++ b/src/main/java/java/lang/ExceptionInInitializerError.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 1996, 2000, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Signals that an unexpected exception has occurred in a static initializer.
+ * An <code>ExceptionInInitializerError</code> is thrown to indicate that an
+ * exception occurred during evaluation of a static initializer or the
+ * initializer for a static variable.
+ *
+ * <p>As of release 1.4, this exception has been retrofitted to conform to
+ * the general purpose exception-chaining mechanism. The "saved throwable
+ * object" that may be provided at construction time and accessed via
+ * the {@link #getException()} method is now known as the <i>cause</i>,
+ * and may be accessed via the {@link Throwable#getCause()} method, as well
+ * as the aforementioned "legacy method."
+ *
+ * @author Frank Yellin
+ * @since JDK1.1
+ */
+public class ExceptionInInitializerError extends LinkageError {
+ /**
+ * Use serialVersionUID from JDK 1.1.X for interoperability
+ */
+ private static final long serialVersionUID = 1521711792217232256L;
+
+ /**
+ * This field holds the exception if the
+ * ExceptionInInitializerError(Throwable thrown) constructor was
+ * used to instantiate the object
+ *
+ * @serial
+ *
+ */
+ private Throwable exception;
+
+ /**
+ * Constructs an <code>ExceptionInInitializerError</code> with
+ * <code>null</code> as its detail message string and with no saved
+ * throwable object.
+ * A detail message is a String that describes this particular exception.
+ */
+ public ExceptionInInitializerError() {
+ initCause(null); // Disallow subsequent initCause
+ }
+
+ /**
+ * Constructs a new <code>ExceptionInInitializerError</code> class by
+ * saving a reference to the <code>Throwable</code> object thrown for
+ * later retrieval by the {@link #getException()} method. The detail
+ * message string is set to <code>null</code>.
+ *
+ * @param thrown The exception thrown
+ */
+ public ExceptionInInitializerError(Throwable thrown) {
+ initCause(null); // Disallow subsequent initCause
+ this.exception = thrown;
+ }
+
+ /**
+ * Constructs an ExceptionInInitializerError with the specified detail
+ * message string. A detail message is a String that describes this
+ * particular exception. The detail message string is saved for later
+ * retrieval by the {@link Throwable#getMessage()} method. There is no
+ * saved throwable object.
+ *
+ *
+ * @param s the detail message
+ */
+ public ExceptionInInitializerError(String s) {
+ super(s);
+ initCause(null); // Disallow subsequent initCause
+ }
+
+ /**
+ * Returns the exception that occurred during a static initialization that
+ * caused this error to be created.
+ *
+ * <p>This method predates the general-purpose exception chaining facility.
+ * The {@link Throwable#getCause()} method is now the preferred means of
+ * obtaining this information.
+ *
+ * @return the saved throwable object of this
+ * <code>ExceptionInInitializerError</code>, or <code>null</code>
+ * if this <code>ExceptionInInitializerError</code> has no saved
+ * throwable object.
+ */
+ public Throwable getException() {
+ return exception;
+ }
+
+ /**
+ * Returns the cause of this error (the exception that occurred
+ * during a static initialization that caused this error to be created).
+ *
+ * @return the cause of this error or <code>null</code> if the
+ * cause is nonexistent or unknown.
+ * @since 1.4
+ */
+ public Throwable getCause() {
+ return exception;
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.ExceptionInInitializerError: " + message)
+ : "java.lang.ExceptionInInitializerError";
+ }
+}
diff --git a/src/main/java/java/lang/IllegalAccessError.java b/src/main/java/java/lang/IllegalAccessError.java
new file mode 100644
index 0000000..201b917
--- /dev/null
+++ b/src/main/java/java/lang/IllegalAccessError.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown if an application attempts to access or modify a field, or
+ * to call a method that it does not have access to.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public class IllegalAccessError extends IncompatibleClassChangeError {
+ private static final long serialVersionUID = -8988904074992417891L;
+
+ /**
+ * Constructs an <code>IllegalAccessError</code> with no detail message.
+ */
+ public IllegalAccessError() {
+ super();
+ }
+
+ /**
+ * Constructs an <code>IllegalAccessError</code> with the specified
+ * detail message.
+ *
+ * @param s the detail message.
+ */
+ public IllegalAccessError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.IllegalAccessError: " + message)
+ : "java.lang.IllegalAccessError";
+ }
+}
diff --git a/src/main/java/java/lang/IllegalAccessException.java b/src/main/java/java/lang/IllegalAccessException.java
new file mode 100644
index 0000000..6ef0b14
--- /dev/null
+++ b/src/main/java/java/lang/IllegalAccessException.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public class IllegalAccessException extends ReflectiveOperationException {
+ private static final long serialVersionUID = 6616958222490762034L;
+
+ public IllegalAccessException() {
+ super();
+ }
+
+ public IllegalAccessException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.IllegalAccessException: " + message)
+ : "java.lang.IllegalAccessException";
+ }
+}
diff --git a/src/main/java/java/lang/IllegalArgumentException.java b/src/main/java/java/lang/IllegalArgumentException.java
new file mode 100644
index 0000000..c4f366d
--- /dev/null
+++ b/src/main/java/java/lang/IllegalArgumentException.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class IllegalArgumentException extends RuntimeException {
+ public IllegalArgumentException() {
+ super();
+ }
+
+ public IllegalArgumentException(String s) {
+ super(s);
+ }
+
+ public IllegalArgumentException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public IllegalArgumentException(Throwable cause) {
+ super(cause);
+ }
+
+ private static final long serialVersionUID = -5365630128856068164L;
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.IllegalArgumentException: " + message)
+ : "java.lang.IllegalArgumentException";
+ }
+}
diff --git a/src/main/java/java/lang/IllegalStateException.java b/src/main/java/java/lang/IllegalStateException.java
new file mode 100644
index 0000000..5677971
--- /dev/null
+++ b/src/main/java/java/lang/IllegalStateException.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class IllegalStateException extends RuntimeException {
+ public IllegalStateException() {
+ super();
+ }
+
+ public IllegalStateException(String s) {
+ super(s);
+ }
+
+ public IllegalStateException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public IllegalStateException(Throwable cause) {
+ super(cause);
+ }
+
+ static final long serialVersionUID = -1848914673093119416L;
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.IllegalStateException: " + message)
+ : "java.lang.IllegalStateException";
+ }
+}
diff --git a/src/main/java/java/lang/IllegalThreadStateException.java b/src/main/java/java/lang/IllegalThreadStateException.java
new file mode 100644
index 0000000..2567e76
--- /dev/null
+++ b/src/main/java/java/lang/IllegalThreadStateException.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public class IllegalThreadStateException extends IllegalArgumentException {
+ private static final long serialVersionUID = -7626246362397460174L;
+
+ public IllegalThreadStateException() {
+ super();
+ }
+
+ public IllegalThreadStateException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.IllegalThreadStateException: " + message)
+ : "java.lang.IllegalThreadStateException";
+ }
+}
diff --git a/src/main/java/java/lang/IncompatibleClassChangeError.java b/src/main/java/java/lang/IncompatibleClassChangeError.java
new file mode 100644
index 0000000..72a8e09
--- /dev/null
+++ b/src/main/java/java/lang/IncompatibleClassChangeError.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when an incompatible class change has occurred to some class
+ * definition. The definition of some class, on which the currently
+ * executing method depends, has since changed.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public
+class IncompatibleClassChangeError extends LinkageError {
+ private static final long serialVersionUID = -4914975503642802119L;
+
+ /**
+ * Constructs an <code>IncompatibleClassChangeError</code> with no
+ * detail message.
+ */
+ public IncompatibleClassChangeError () {
+ super();
+ }
+
+ /**
+ * Constructs an <code>IncompatibleClassChangeError</code> with the
+ * specified detail message.
+ *
+ * @param s the detail message.
+ */
+ public IncompatibleClassChangeError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.IncompatibleClassChangeError: " + message)
+ : "java.lang.IncompatibleClassChangeError";
+ }
+}
diff --git a/src/main/java/java/lang/IndexOutOfBoundsException.java b/src/main/java/java/lang/IndexOutOfBoundsException.java
new file mode 100644
index 0000000..849f358
--- /dev/null
+++ b/src/main/java/java/lang/IndexOutOfBoundsException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class IndexOutOfBoundsException extends RuntimeException {
+ private static final long serialVersionUID = 234122996006267687L;
+
+ public IndexOutOfBoundsException() {
+ super();
+ }
+
+ public IndexOutOfBoundsException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.IndexOutOfBoundsException: " + message)
+ : "java.lang.IndexOutOfBoundsException";
+ }
+}
diff --git a/src/main/java/java/lang/InstantiationError.java b/src/main/java/java/lang/InstantiationError.java
new file mode 100644
index 0000000..7b19548
--- /dev/null
+++ b/src/main/java/java/lang/InstantiationError.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when an application tries to use the Java <code>new</code>
+ * construct to instantiate an abstract class or an interface.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+
+
+public
+class InstantiationError extends IncompatibleClassChangeError {
+ private static final long serialVersionUID = -4885810657349421204L;
+
+ /**
+ * Constructs an <code>InstantiationError</code> with no detail message.
+ */
+ public InstantiationError() {
+ super();
+ }
+
+ /**
+ * Constructs an <code>InstantiationError</code> with the specified
+ * detail message.
+ *
+ * @param s the detail message.
+ */
+ public InstantiationError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.InstantiationError: " + message)
+ : "java.lang.InstantiationError";
+ }
+}
diff --git a/src/main/java/java/lang/InstantiationException.java b/src/main/java/java/lang/InstantiationException.java
new file mode 100644
index 0000000..ff0101f
--- /dev/null
+++ b/src/main/java/java/lang/InstantiationException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class InstantiationException extends ReflectiveOperationException {
+ private static final long serialVersionUID = -8441929162975509110L;
+
+ public InstantiationException() {
+ super();
+ }
+
+ public InstantiationException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.InstantiationException: " + message)
+ : "java.lang.InstantiationException";
+ }
+}
diff --git a/src/main/java/java/lang/Integer.java b/src/main/java/java/lang/Integer.java
new file mode 100644
index 0000000..b24f974
--- /dev/null
+++ b/src/main/java/java/lang/Integer.java
@@ -0,0 +1,1429 @@
+/*
+ * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+import org.cprover.CProver;
+import org.cprover.CProverString;
+
+/**
+ * The {@code Integer} class wraps a value of the primitive type
+ * {@code int} in an object. An object of type {@code Integer}
+ * contains a single field whose type is {@code int}.
+ *
+ * <p>In addition, this class provides several methods for converting
+ * an {@code int} to a {@code String} and a {@code String} to an
+ * {@code int}, as well as other constants and methods useful when
+ * dealing with an {@code int}.
+ *
+ * <p>Implementation note: The implementations of the "bit twiddling"
+ * methods (such as {@link #highestOneBit(int) highestOneBit} and
+ * {@link #numberOfTrailingZeros(int) numberOfTrailingZeros}) are
+ * based on material from Henry S. Warren, Jr.'s <i>Hacker's
+ * Delight</i>, (Addison Wesley, 2002).
+ *
+ * @author Lee Boynton
+ * @author Arthur van Hoff
+ * @author Josh Bloch
+ * @author Joseph D. Darcy
+ * @since JDK1.0
+ */
+public final class Integer extends Number implements Comparable<Integer> {
+
+ /**
+ * A constant holding the minimum value an {@code int} can
+ * have, -2<sup>31</sup>.
+ */
+ public static final int MIN_VALUE = -2147483648;
+
+ /**
+ * A constant holding the maximum value an {@code int} can
+ * have, 2<sup>31</sup>-1.
+ */
+ public static final int MAX_VALUE = 2147483647;
+
+ /**
+ * The {@code Class} instance representing the primitive type
+ * {@code int}.
+ *
+ * @since JDK1.1
+ */
+ // DIFFBLUE MODEL LIBRARY
+ // We use the int version of getPrimitiveClass instead of
+ // the original String version
+ @SuppressWarnings("unchecked")
+ public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass(4);
+
+ /**
+ * Returns a string representation of the first argument in the
+ * radix specified by the second argument.
+ *
+ * <p>If the radix is smaller than {@code Character.MIN_RADIX}
+ * or larger than {@code Character.MAX_RADIX}, then the radix
+ * {@code 10} is used instead.
+ *
+ * <p>If the first argument is negative, the first element of the
+ * result is the ASCII minus character {@code '-'}
+ * ({@code '\u005Cu002D'}). If the first argument is not
+ * negative, no sign character appears in the result.
+ *
+ * <p>The remaining characters of the result represent the magnitude
+ * of the first argument. If the magnitude is zero, it is
+ * represented by a single zero character {@code '0'}
+ * ({@code '\u005Cu0030'}); otherwise, the first character of
+ * the representation of the magnitude will not be the zero
+ * character. The following ASCII characters are used as digits:
+ *
+ * <blockquote>
+ * {@code 0123456789abcdefghijklmnopqrstuvwxyz}
+ * </blockquote>
+ *
+ * These are {@code '\u005Cu0030'} through
+ * {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through
+ * {@code '\u005Cu007A'}. If {@code radix} is
+ * <var>N</var>, then the first <var>N</var> of these characters
+ * are used as radix-<var>N</var> digits in the order shown. Thus,
+ * the digits for hexadecimal (radix 16) are
+ * {@code 0123456789abcdef}. If uppercase letters are
+ * desired, the {@link java.lang.String#toUpperCase()} method may
+ * be called on the result:
+ *
+ * <blockquote>
+ * {@code Integer.toString(n, 16).toUpperCase()}
+ * </blockquote>
+ *
+ * @param i an integer to be converted to a string.
+ * @param radix the radix to use in the string representation.
+ * @return a string representation of the argument in the specified radix.
+ * @see java.lang.Character#MAX_RADIX
+ * @see java.lang.Character#MIN_RADIX
+ */
+ // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC
+ public static String toString(int i, int radix) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Returns a string representation of the first argument as an
+ * unsigned integer value in the radix specified by the second
+ * argument.
+ *
+ * <p>If the radix is smaller than {@code Character.MIN_RADIX}
+ * or larger than {@code Character.MAX_RADIX}, then the radix
+ * {@code 10} is used instead.
+ *
+ * <p>Note that since the first argument is treated as an unsigned
+ * value, no leading sign character is printed.
+ *
+ * <p>If the magnitude is zero, it is represented by a single zero
+ * character {@code '0'} ({@code '\u005Cu0030'}); otherwise,
+ * the first character of the representation of the magnitude will
+ * not be the zero character.
+ *
+ * <p>The behavior of radixes and the characters used as digits
+ * are the same as {@link #toString(int, int) toString}.
+ *
+ * @param i an integer to be converted to an unsigned string.
+ * @param radix the radix to use in the string representation.
+ * @return an unsigned string representation of the argument in the specified radix.
+ * @see #toString(int, int)
+ * @since 1.8
+ */
+ //TODO
+ public static String toUnsignedString(int i, int radix) {
+ return Long.toUnsignedString(toUnsignedLong(i), radix);
+ }
+
+ /**
+ * Returns a string representation of the integer argument as an
+ * unsigned integer in base 16.
+ *
+ * <p>The unsigned integer value is the argument plus 2<sup>32</sup>
+ * if the argument is negative; otherwise, it is equal to the
+ * argument. This value is converted to a string of ASCII digits
+ * in hexadecimal (base 16) with no extra leading
+ * {@code 0}s.
+ *
+ * <p>The value of the argument can be recovered from the returned
+ * string {@code s} by calling {@link
+ * Integer#parseUnsignedInt(String, int)
+ * Integer.parseUnsignedInt(s, 16)}.
+ *
+ * <p>If the unsigned magnitude is zero, it is represented by a
+ * single zero character {@code '0'} ({@code '\u005Cu0030'});
+ * otherwise, the first character of the representation of the
+ * unsigned magnitude will not be the zero character. The
+ * following characters are used as hexadecimal digits:
+ *
+ * <blockquote>
+ * {@code 0123456789abcdef}
+ * </blockquote>
+ *
+ * These are the characters {@code '\u005Cu0030'} through
+ * {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through
+ * {@code '\u005Cu0066'}. If uppercase letters are
+ * desired, the {@link java.lang.String#toUpperCase()} method may
+ * be called on the result:
+ *
+ * <blockquote>
+ * {@code Integer.toHexString(n).toUpperCase()}
+ * </blockquote>
+ *
+ * @param i an integer to be converted to a string.
+ * @return the string representation of the unsigned integer value
+ * represented by the argument in hexadecimal (base 16).
+ * @see #parseUnsignedInt(String, int)
+ * @see #toUnsignedString(int, int)
+ * @since JDK1.0.2
+ */
+ //TODO
+ public static String toHexString(int i) {
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Returns a string representation of the integer argument as an
+ * unsigned integer in base 8.
+ *
+ * <p>The unsigned integer value is the argument plus 2<sup>32</sup>
+ * if the argument is negative; otherwise, it is equal to the
+ * argument. This value is converted to a string of ASCII digits
+ * in octal (base 8) with no extra leading {@code 0}s.
+ *
+ * <p>The value of the argument can be recovered from the returned
+ * string {@code s} by calling {@link
+ * Integer#parseUnsignedInt(String, int)
+ * Integer.parseUnsignedInt(s, 8)}.
+ *
+ * <p>If the unsigned magnitude is zero, it is represented by a
+ * single zero character {@code '0'} ({@code '\u005Cu0030'});
+ * otherwise, the first character of the representation of the
+ * unsigned magnitude will not be the zero character. The
+ * following characters are used as octal digits:
+ *
+ * <blockquote>
+ * {@code 01234567}
+ * </blockquote>
+ *
+ * These are the characters {@code '\u005Cu0030'} through
+ * {@code '\u005Cu0037'}.
+ *
+ * @param i an integer to be converted to a string.
+ * @return the string representation of the unsigned integer value
+ * represented by the argument in octal (base 8).
+ * @see #parseUnsignedInt(String, int)
+ * @see #toUnsignedString(int, int)
+ * @since JDK1.0.2
+ */
+ //TODO
+ public static String toOctalString(int i) {
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Returns a string representation of the integer argument as an
+ * unsigned integer in base 2.
+ *
+ * <p>The unsigned integer value is the argument plus 2<sup>32</sup>
+ * if the argument is negative; otherwise it is equal to the
+ * argument. This value is converted to a string of ASCII digits
+ * in binary (base 2) with no extra leading {@code 0}s.
+ *
+ * <p>The value of the argument can be recovered from the returned
+ * string {@code s} by calling {@link
+ * Integer#parseUnsignedInt(String, int)
+ * Integer.parseUnsignedInt(s, 2)}.
+ *
+ * <p>If the unsigned magnitude is zero, it is represented by a
+ * single zero character {@code '0'} ({@code '\u005Cu0030'});
+ * otherwise, the first character of the representation of the
+ * unsigned magnitude will not be the zero character. The
+ * characters {@code '0'} ({@code '\u005Cu0030'}) and {@code
+ * '1'} ({@code '\u005Cu0031'}) are used as binary digits.
+ *
+ * @param i an integer to be converted to a string.
+ * @return the string representation of the unsigned integer value
+ * represented by the argument in binary (base 2).
+ * @see #parseUnsignedInt(String, int)
+ * @see #toUnsignedString(int, int)
+ * @since JDK1.0.2
+ */
+ //TODO
+ public static String toBinaryString(int i) {
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Returns a {@code String} object representing the
+ * specified integer. The argument is converted to signed decimal
+ * representation and returned as a string, exactly as if the
+ * argument and radix 10 were given as arguments to the {@link
+ * #toString(int, int)} method.
+ *
+ * @param i an integer to be converted.
+ * @return a string representation of the argument in base 10.
+ */
+ // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC
+ public static String toString(int i) {
+ // this function is handled by cbmc internally
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Returns a string representation of the argument as an unsigned
+ * decimal value.
+ *
+ * The argument is converted to unsigned decimal representation
+ * and returned as a string exactly as if the argument and radix
+ * 10 were given as arguments to the {@link #toUnsignedString(int,
+ * int)} method.
+ *
+ * @param i an integer to be converted to an unsigned string.
+ * @return an unsigned string representation of the argument.
+ * @see #toUnsignedString(int, int)
+ * @since 1.8
+ */
+ //TODO
+ public static String toUnsignedString(int i) {
+ return Long.toString(toUnsignedLong(i));
+ }
+
+ // Requires positive x
+ static int stringSize(int x) {
+ if (x <= 9)
+ return 1;
+ if (x <= 99)
+ return 2;
+ if (x <= 999)
+ return 3;
+ if (x <= 9999)
+ return 4;
+ if (x <= 99999)
+ return 5;
+ if (x <= 999999)
+ return 6;
+ if (x <= 9999999)
+ return 7;
+ if (x <= 99999999)
+ return 8;
+ if (x <= 999999999)
+ return 9;
+
+ return 10;
+ }
+
+ /**
+ * Parses the string argument as a signed integer in the radix
+ * specified by the second argument. The characters in the string
+ * must all be digits of the specified radix (as determined by
+ * whether {@link java.lang.Character#digit(char, int)} returns a
+ * nonnegative value), except that the first character may be an
+ * ASCII minus sign {@code '-'} ({@code '\u005Cu002D'}) to
+ * indicate a negative value or an ASCII plus sign {@code '+'}
+ * ({@code '\u005Cu002B'}) to indicate a positive value. The
+ * resulting integer value is returned.
+ *
+ * <p>An exception of type {@code NumberFormatException} is
+ * thrown if any of the following situations occurs:
+ * <ul>
+ * <li>The first argument is {@code null} or is a string of
+ * length zero.
+ *
+ * <li>The radix is either smaller than
+ * {@link java.lang.Character#MIN_RADIX} or
+ * larger than {@link java.lang.Character#MAX_RADIX}.
+ *
+ * <li>Any character of the string is not a digit of the specified
+ * radix, except that the first character may be a minus sign
+ * {@code '-'} ({@code '\u005Cu002D'}) or plus sign
+ * {@code '+'} ({@code '\u005Cu002B'}) provided that the
+ * string is longer than length 1.
+ *
+ * <li>The value represented by the string is not a value of type
+ * {@code int}.
+ * </ul>
+ *
+ * <p>Examples:
+ * <blockquote><pre>
+ * parseInt("0", 10) returns 0
+ * parseInt("473", 10) returns 473
+ * parseInt("+42", 10) returns 42
+ * parseInt("-0", 10) returns 0
+ * parseInt("-FF", 16) returns -255
+ * parseInt("1100110", 2) returns 102
+ * parseInt("2147483647", 10) returns 2147483647
+ * parseInt("-2147483648", 10) returns -2147483648
+ * parseInt("2147483648", 10) throws a NumberFormatException
+ * parseInt("99", 8) throws a NumberFormatException
+ * parseInt("Kona", 10) throws a NumberFormatException
+ * parseInt("Kona", 27) returns 411787
+ * </pre></blockquote>
+ *
+ * @param s the {@code String} containing the integer
+ * representation to be parsed
+ * @param radix the radix to be used while parsing {@code s}.
+ * @return the integer represented by the string argument in the
+ * specified radix.
+ * @exception NumberFormatException if the {@code String}
+ * does not contain a parsable {@code int}.
+ */
+ public static int parseInt(String s, int radix)
+ throws NumberFormatException
+ {
+ if (s == null) {
+ throw new NumberFormatException("null");
+ }
+
+ if (radix < Character.MIN_RADIX) {
+ throw new NumberFormatException("radix " + radix +
+ " less than Character.MIN_RADIX");
+ }
+
+ if (radix > Character.MAX_RADIX) {
+ throw new NumberFormatException("radix " + radix +
+ " greater than Character.MAX_RADIX");
+ }
+
+ if (radix == 10) {
+ return parseInt(s);
+ }
+
+ //TODO from here on
+ int result = 0;
+ boolean negative = false;
+ int i = 0, len = s.length();
+ int limit = -Integer.MAX_VALUE;
+ int multmin;
+ int digit;
+
+ if (len > 0) {
+ char firstChar = CProverString.charAt(s, 0);
+ if (firstChar < '0') { // Possible leading "+" or "-"
+ if (firstChar == '-') {
+ negative = true;
+ limit = Integer.MIN_VALUE;
+ } else if (firstChar != '+')
+ throw NumberFormatException.forInputString(s);
+
+ if (len == 1) // Cannot have lone "+" or "-"
+ throw NumberFormatException.forInputString(s);
+ i++;
+ }
+ multmin = limit / radix;
+ while (i < len) {
+ // Accumulating negatively avoids surprises near MAX_VALUE
+ digit = Character.digit(CProverString.charAt(s, i++), radix);
+ if (digit < 0) {
+ throw NumberFormatException.forInputString(s);
+ }
+ if (result < multmin) {
+ throw NumberFormatException.forInputString(s);
+ }
+ result *= radix;
+ if (result < limit + digit) {
+ throw NumberFormatException.forInputString(s);
+ }
+ result -= digit;
+ }
+ } else {
+ throw NumberFormatException.forInputString(s);
+ }
+ return negative ? result : -result;
+ }
+
+ /**
+ * Parses the string argument as a signed decimal integer. The
+ * characters in the string must all be decimal digits, except
+ * that the first character may be an ASCII minus sign {@code '-'}
+ * ({@code '\u005Cu002D'}) to indicate a negative value or an
+ * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to
+ * indicate a positive value. The resulting integer value is
+ * returned, exactly as if the argument and the radix 10 were
+ * given as arguments to the {@link #parseInt(java.lang.String,
+ * int)} method.
+ *
+ * @param s a {@code String} containing the {@code int}
+ * representation to be parsed
+ * @return the integer value represented by the argument in decimal.
+ * @exception NumberFormatException if the string does not contain a
+ * parsable integer.
+ */
+ public static int parseInt(String s) throws NumberFormatException {
+ return CProver.nondetInt(); //The function is handled by cbmc internally
+ }
+
+ /**
+ * Parses the string argument as an unsigned integer in the radix
+ * specified by the second argument. An unsigned integer maps the
+ * values usually associated with negative numbers to positive
+ * numbers larger than {@code MAX_VALUE}.
+ *
+ * The characters in the string must all be digits of the
+ * specified radix (as determined by whether {@link
+ * java.lang.Character#digit(char, int)} returns a nonnegative
+ * value), except that the first character may be an ASCII plus
+ * sign {@code '+'} ({@code '\u005Cu002B'}). The resulting
+ * integer value is returned.
+ *
+ * <p>An exception of type {@code NumberFormatException} is
+ * thrown if any of the following situations occurs:
+ * <ul>
+ * <li>The first argument is {@code null} or is a string of
+ * length zero.
+ *
+ * <li>The radix is either smaller than
+ * {@link java.lang.Character#MIN_RADIX} or
+ * larger than {@link java.lang.Character#MAX_RADIX}.
+ *
+ * <li>Any character of the string is not a digit of the specified
+ * radix, except that the first character may be a plus sign
+ * {@code '+'} ({@code '\u005Cu002B'}) provided that the
+ * string is longer than length 1.
+ *
+ * <li>The value represented by the string is larger than the
+ * largest unsigned {@code int}, 2<sup>32</sup>-1.
+ *
+ * </ul>
+ *
+ *
+ * @param s the {@code String} containing the unsigned integer
+ * representation to be parsed
+ * @param radix the radix to be used while parsing {@code s}.
+ * @return the integer represented by the string argument in the
+ * specified radix.
+ * @throws NumberFormatException if the {@code String}
+ * does not contain a parsable {@code int}.
+ * @since 1.8
+ */
+ public static int parseUnsignedInt(String s, int radix)
+ throws NumberFormatException {
+ if (s == null) {
+ throw new NumberFormatException("null");
+ }
+
+ int len = s.length();
+ if (len > 0) {
+ char firstChar = CProverString.charAt(s, 0);
+ if (firstChar == '-') {
+ throw new
+ NumberFormatException(String.format("Illegal leading minus sign " +
+ "on unsigned string %s.", s));
+ } else {
+ if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
+ (radix == 10 && len <= 9) ) { // Integer.MAX_VALUE in base 10 is 10 digits
+ return parseInt(s, radix);
+ } else {
+ long ell = Long.parseLong(s, radix);
+ if ((ell & 0xffff_ffff_0000_0000L) == 0) {
+ return (int) ell;
+ } else {
+ throw new
+ NumberFormatException(String.format("String value %s exceeds " +
+ "range of unsigned int.", s));
+ }
+ }
+ }
+ } else {
+ throw NumberFormatException.forInputString(s);
+ }
+ }
+
+ /**
+ * Parses the string argument as an unsigned decimal integer. The
+ * characters in the string must all be decimal digits, except
+ * that the first character may be an an ASCII plus sign {@code
+ * '+'} ({@code '\u005Cu002B'}). The resulting integer value
+ * is returned, exactly as if the argument and the radix 10 were
+ * given as arguments to the {@link
+ * #parseUnsignedInt(java.lang.String, int)} method.
+ *
+ * @param s a {@code String} containing the unsigned {@code int}
+ * representation to be parsed
+ * @return the unsigned integer value represented by the argument in decimal.
+ * @throws NumberFormatException if the string does not contain a
+ * parsable unsigned integer.
+ * @since 1.8
+ */
+ public static int parseUnsignedInt(String s) throws NumberFormatException {
+ return parseUnsignedInt(s, 10);
+ }
+
+ /**
+ * Returns an {@code Integer} object holding the value
+ * extracted from the specified {@code String} when parsed
+ * with the radix given by the second argument. The first argument
+ * is interpreted as representing a signed integer in the radix
+ * specified by the second argument, exactly as if the arguments
+ * were given to the {@link #parseInt(java.lang.String, int)}
+ * method. The result is an {@code Integer} object that
+ * represents the integer value specified by the string.
+ *
+ * <p>In other words, this method returns an {@code Integer}
+ * object equal to the value of:
+ *
+ * <blockquote>
+ * {@code new Integer(Integer.parseInt(s, radix))}
+ * </blockquote>
+ *
+ * @param s the string to be parsed.
+ * @param radix the radix to be used in interpreting {@code s}
+ * @return an {@code Integer} object holding the value
+ * represented by the string argument in the specified
+ * radix.
+ * @exception NumberFormatException if the {@code String}
+ * does not contain a parsable {@code int}.
+ */
+ public static Integer valueOf(String s, int radix) throws NumberFormatException {
+ return Integer.valueOf(parseInt(s,radix));
+ }
+
+ /**
+ * Returns an {@code Integer} object holding the
+ * value of the specified {@code String}. The argument is
+ * interpreted as representing a signed decimal integer, exactly
+ * as if the argument were given to the {@link
+ * #parseInt(java.lang.String)} method. The result is an
+ * {@code Integer} object that represents the integer value
+ * specified by the string.
+ *
+ * <p>In other words, this method returns an {@code Integer}
+ * object equal to the value of:
+ *
+ * <blockquote>
+ * {@code new Integer(Integer.parseInt(s))}
+ * </blockquote>
+ *
+ * @param s the string to be parsed.
+ * @return an {@code Integer} object holding the value
+ * represented by the string argument.
+ * @exception NumberFormatException if the string cannot be parsed
+ * as an integer.
+ */
+ public static Integer valueOf(String s) throws NumberFormatException {
+ return Integer.valueOf(parseInt(s));
+ }
+
+ /**
+ * Returns an {@code Integer} instance representing the specified
+ * {@code int} value. If a new {@code Integer} instance is not
+ * required, this method should generally be used in preference to
+ * the constructor {@link #Integer(int)}, as this method is likely
+ * to yield significantly better space and time performance by
+ * caching frequently requested values.
+ *
+ * This method will always cache values in the range -128 to 127,
+ * inclusive, and may cache other values outside of this range.
+ *
+ * @param i an {@code int} value.
+ * @return an {@code Integer} instance representing {@code i}.
+ * @since 1.5
+ */
+ public static Integer valueOf(int i) {
+ return new Integer(i);
+ }
+
+ /**
+ * The value of the {@code Integer}.
+ *
+ * @serial
+ */
+ private final int value;
+
+ /**
+ * Constructs a newly allocated {@code Integer} object that
+ * represents the specified {@code int} value.
+ *
+ * @param value the value to be represented by the
+ * {@code Integer} object.
+ */
+ public Integer(int value) {
+ this.value = value;
+ }
+
+ /**
+ * Constructs a newly allocated {@code Integer} object that
+ * represents the {@code int} value indicated by the
+ * {@code String} parameter. The string is converted to an
+ * {@code int} value in exactly the manner used by the
+ * {@code parseInt} method for radix 10.
+ *
+ * @param s the {@code String} to be converted to an
+ * {@code Integer}.
+ * @exception NumberFormatException if the {@code String} does not
+ * contain a parsable integer.
+ * @see java.lang.Integer#parseInt(java.lang.String, int)
+ */
+ public Integer(String s) throws NumberFormatException {
+ this.value = parseInt(s);
+ }
+
+ /**
+ * Returns the value of this {@code Integer} as a {@code byte}
+ * after a narrowing primitive conversion.
+ * @jls 5.1.3 Narrowing Primitive Conversions
+ */
+ public byte byteValue() {
+ return (byte)value;
+ }
+
+ /**
+ * Returns the value of this {@code Integer} as a {@code short}
+ * after a narrowing primitive conversion.
+ * @jls 5.1.3 Narrowing Primitive Conversions
+ */
+ public short shortValue() {
+ return (short)value;
+ }
+
+ /**
+ * Returns the value of this {@code Integer} as an
+ * {@code int}.
+ */
+ public int intValue() {
+ return value;
+ }
+
+ /**
+ * Returns the value of this {@code Integer} as a {@code long}
+ * after a widening primitive conversion.
+ * @jls 5.1.2 Widening Primitive Conversions
+ * @see Integer#toUnsignedLong(int)
+ */
+ public long longValue() {
+ return (long)value;
+ }
+
+ /**
+ * Returns the value of this {@code Integer} as a {@code float}
+ * after a widening primitive conversion.
+ * @jls 5.1.2 Widening Primitive Conversions
+ */
+ public float floatValue() {
+ return (float)value;
+ }
+
+ /**
+ * Returns the value of this {@code Integer} as a {@code double}
+ * after a widening primitive conversion.
+ * @jls 5.1.2 Widening Primitive Conversions
+ */
+ public double doubleValue() {
+ return (double)value;
+ }
+
+ /**
+ * Returns a {@code String} object representing this
+ * {@code Integer}'s value. The value is converted to signed
+ * decimal representation and returned as a string, exactly as if
+ * the integer value were given as an argument to the {@link
+ * java.lang.Integer#toString(int)} method.
+ *
+ * @return a string representation of the value of this object in
+ * base 10.
+ */
+ public String toString() {
+ return toString(value);
+ }
+
+ /**
+ * Returns a hash code for this {@code Integer}.
+ *
+ * @return a hash code value for this object, equal to the
+ * primitive {@code int} value represented by this
+ * {@code Integer} object.
+ */
+ public int hashCode() {
+ return Integer.hashCode(value);
+ }
+
+ /**
+ * Returns a hash code for a {@code int} value; compatible with
+ * {@code Integer.hashCode()}.
+ *
+ * @param value the value to hash
+ * @since 1.8
+ *
+ * @return a hash code value for a {@code int} value.
+ */
+ public static int hashCode(int value) {
+ return value;
+ }
+
+ /**
+ * Compares this object to the specified object. The result is
+ * {@code true} if and only if the argument is not
+ * {@code null} and is an {@code Integer} object that
+ * contains the same {@code int} value as this object.
+ *
+ * @param obj the object to compare with.
+ * @return {@code true} if the objects are the same;
+ * {@code false} otherwise.
+ */
+ public boolean equals(Object obj) {
+ if (obj instanceof Integer) {
+ return value == ((Integer)obj).intValue();
+ }
+ return false;
+ }
+
+ /**
+ * Determines the integer value of the system property with the
+ * specified name.
+ *
+ * <p>The first argument is treated as the name of a system
+ * property. System properties are accessible through the {@link
+ * java.lang.System#getProperty(java.lang.String)} method. The
+ * string value of this property is then interpreted as an integer
+ * value using the grammar supported by {@link Integer#decode decode} and
+ * an {@code Integer} object representing this value is returned.
+ *
+ * <p>If there is no property with the specified name, if the
+ * specified name is empty or {@code null}, or if the property
+ * does not have the correct numeric format, then {@code null} is
+ * returned.
+ *
+ * <p>In other words, this method returns an {@code Integer}
+ * object equal to the value of:
+ *
+ * <blockquote>
+ * {@code getInteger(nm, null)}
+ * </blockquote>
+ *
+ * @param nm property name.
+ * @return the {@code Integer} value of the property.
+ * @throws SecurityException for the same reasons as
+ * {@link System#getProperty(String) System.getProperty}
+ * @see java.lang.System#getProperty(java.lang.String)
+ * @see java.lang.System#getProperty(java.lang.String, java.lang.String)
+ */
+ public static Integer getInteger(String nm) {
+ return getInteger(nm, null);
+ }
+
+ /**
+ * Determines the integer value of the system property with the
+ * specified name.
+ *
+ * <p>The first argument is treated as the name of a system
+ * property. System properties are accessible through the {@link
+ * java.lang.System#getProperty(java.lang.String)} method. The
+ * string value of this property is then interpreted as an integer
+ * value using the grammar supported by {@link Integer#decode decode} and
+ * an {@code Integer} object representing this value is returned.
+ *
+ * <p>The second argument is the default value. An {@code Integer} object
+ * that represents the value of the second argument is returned if there
+ * is no property of the specified name, if the property does not have
+ * the correct numeric format, or if the specified name is empty or
+ * {@code null}.
+ *
+ * <p>In other words, this method returns an {@code Integer} object
+ * equal to the value of:
+ *
+ * <blockquote>
+ * {@code getInteger(nm, new Integer(val))}
+ * </blockquote>
+ *
+ * but in practice it may be implemented in a manner such as:
+ *
+ * <blockquote><pre>
+ * Integer result = getInteger(nm, null);
+ * return (result == null) ? new Integer(val) : result;
+ * </pre></blockquote>
+ *
+ * to avoid the unnecessary allocation of an {@code Integer}
+ * object when the default value is not needed.
+ *
+ * @param nm property name.
+ * @param val default value.
+ * @return the {@code Integer} value of the property.
+ * @throws SecurityException for the same reasons as
+ * {@link System#getProperty(String) System.getProperty}
+ * @see java.lang.System#getProperty(java.lang.String)
+ * @see java.lang.System#getProperty(java.lang.String, java.lang.String)
+ */
+ public static Integer getInteger(String nm, int val) {
+ Integer result = getInteger(nm, null);
+ return (result == null) ? Integer.valueOf(val) : result;
+ }
+
+ /**
+ * Returns the integer value of the system property with the
+ * specified name. The first argument is treated as the name of a
+ * system property. System properties are accessible through the
+ * {@link java.lang.System#getProperty(java.lang.String)} method.
+ * The string value of this property is then interpreted as an
+ * integer value, as per the {@link Integer#decode decode} method,
+ * and an {@code Integer} object representing this value is
+ * returned; in summary:
+ *
+ * <ul><li>If the property value begins with the two ASCII characters
+ * {@code 0x} or the ASCII character {@code #}, not
+ * followed by a minus sign, then the rest of it is parsed as a
+ * hexadecimal integer exactly as by the method
+ * {@link #valueOf(java.lang.String, int)} with radix 16.
+ * <li>If the property value begins with the ASCII character
+ * {@code 0} followed by another character, it is parsed as an
+ * octal integer exactly as by the method
+ * {@link #valueOf(java.lang.String, int)} with radix 8.
+ * <li>Otherwise, the property value is parsed as a decimal integer
+ * exactly as by the method {@link #valueOf(java.lang.String, int)}
+ * with radix 10.
+ * </ul>
+ *
+ * <p>The second argument is the default value. The default value is
+ * returned if there is no property of the specified name, if the
+ * property does not have the correct numeric format, or if the
+ * specified name is empty or {@code null}.
+ *
+ * @param nm property name.
+ * @param val default value.
+ * @return the {@code Integer} value of the property.
+ * @throws SecurityException for the same reasons as
+ * {@link System#getProperty(String) System.getProperty}
+ * @see System#getProperty(java.lang.String)
+ * @see System#getProperty(java.lang.String, java.lang.String)
+ */
+ public static Integer getInteger(String nm, Integer val) {
+ return getInteger(nm, null);
+ }
+
+ /**
+ * Decodes a {@code String} into an {@code Integer}.
+ * Accepts decimal, hexadecimal, and octal numbers given
+ * by the following grammar:
+ *
+ * <blockquote>
+ * <dl>
+ * <dt><i>DecodableString:</i>
+ * <dd><i>Sign<sub>opt</sub> DecimalNumeral</i>
+ * <dd><i>Sign<sub>opt</sub></i> {@code 0x} <i>HexDigits</i>
+ * <dd><i>Sign<sub>opt</sub></i> {@code 0X} <i>HexDigits</i>
+ * <dd><i>Sign<sub>opt</sub></i> {@code #} <i>HexDigits</i>
+ * <dd><i>Sign<sub>opt</sub></i> {@code 0} <i>OctalDigits</i>
+ *
+ * <dt><i>Sign:</i>
+ * <dd>{@code -}
+ * <dd>{@code +}
+ * </dl>
+ * </blockquote>
+ *
+ * <i>DecimalNumeral</i>, <i>HexDigits</i>, and <i>OctalDigits</i>
+ * are as defined in section 3.10.1 of
+ * <cite>The Java™ Language Specification</cite>,
+ * except that underscores are not accepted between digits.
+ *
+ * <p>The sequence of characters following an optional
+ * sign and/or radix specifier ("{@code 0x}", "{@code 0X}",
+ * "{@code #}", or leading zero) is parsed as by the {@code
+ * Integer.parseInt} method with the indicated radix (10, 16, or
+ * 8). This sequence of characters must represent a positive
+ * value or a {@link NumberFormatException} will be thrown. The
+ * result is negated if first character of the specified {@code
+ * String} is the minus sign. No whitespace characters are
+ * permitted in the {@code String}.
+ *
+ * @param nm the {@code String} to decode.
+ * @return an {@code Integer} object holding the {@code int}
+ * value represented by {@code nm}
+ * @exception NumberFormatException if the {@code String} does not
+ * contain a parsable integer.
+ * @see java.lang.Integer#parseInt(java.lang.String, int)
+ */
+ public static Integer decode(String nm) throws NumberFormatException {
+ if (!nm.startsWith("0") &&
+ !nm.startsWith("#") &&
+ !nm.startsWith("-0") &&
+ !nm.startsWith("-#") &&
+ !nm.startsWith("+0") &&
+ !nm.startsWith("+#")) {
+ // MODEL NOTE
+ // we're decoding a decimal number, for which we have
+ // faster implementation
+ return Integer.parseInt(nm);
+ }
+
+ // MODEL NOTE
+ // for non-decimal number, we fall back to a default implementation
+ int radix = 10;
+ int index = 0;
+ boolean negative = false;
+ Integer result;
+
+ if (nm.length() == 0)
+ throw new NumberFormatException("Zero length string");
+ char firstChar = nm.charAt(0);
+ // Handle sign, if present
+ if (firstChar == '-') {
+ negative = true;
+ index++;
+ } else if (firstChar == '+')
+ index++;
+
+ // Handle radix specifier, if present
+ if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
+ index += 2;
+ radix = 16;
+ }
+ else if (nm.startsWith("#", index)) {
+ index ++;
+ radix = 16;
+ }
+ else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
+ index ++;
+ radix = 8;
+ }
+
+ if (nm.startsWith("-", index) || nm.startsWith("+", index))
+ throw new NumberFormatException("Sign character in wrong position");
+
+ // DIFFBLUE MODEL LIBRARY We compute the substring only once
+ String nm_sub_index = CProverString.substring(nm, index);
+ try {
+ // DIFFBLUE MODEL LIBRARY
+ // result = Long.valueOf(nm.substring(index), radix);
+ result = Integer.valueOf(nm_sub_index, radix);
+ result = negative ? Integer.valueOf(-result.intValue()) : result;
+ } catch (NumberFormatException e) {
+ // If number is Integer.MIN_VALUE, we'll end up here. The next line
+ // handles this case, and causes any genuine format error to be
+ // rethrown.
+ // DIFFBLUE MODEL LIBRARY
+ // String constant = negative ? ("-" + nm.substring(index))
+ // : nm.substring(index);
+ String constant = negative ? ("-" + nm_sub_index)
+ : nm_sub_index;
+ result = Integer.valueOf(constant, radix);
+ }
+ return result;
+ }
+
+ /**
+ * Compares two {@code Integer} objects numerically.
+ *
+ * @param anotherInteger the {@code Integer} to be compared.
+ * @return the value {@code 0} if this {@code Integer} is
+ * equal to the argument {@code Integer}; a value less than
+ * {@code 0} if this {@code Integer} is numerically less
+ * than the argument {@code Integer}; and a value greater
+ * than {@code 0} if this {@code Integer} is numerically
+ * greater than the argument {@code Integer} (signed
+ * comparison).
+ * @since 1.2
+ */
+ public int compareTo(Integer anotherInteger) {
+ return compare(this.value, anotherInteger.value);
+ }
+
+ /**
+ * Compares two {@code int} values numerically.
+ * The value returned is identical to what would be returned by:
+ * <pre>
+ * Integer.valueOf(x).compareTo(Integer.valueOf(y))
+ * </pre>
+ *
+ * @param x the first {@code int} to compare
+ * @param y the second {@code int} to compare
+ * @return the value {@code 0} if {@code x == y};
+ * a value less than {@code 0} if {@code x < y}; and
+ * a value greater than {@code 0} if {@code x > y}
+ * @since 1.7
+ */
+ public static int compare(int x, int y) {
+ return (x < y) ? -1 : ((x == y) ? 0 : 1);
+ }
+
+ /**
+ * Compares two {@code int} values numerically treating the values
+ * as unsigned.
+ *
+ * @param x the first {@code int} to compare
+ * @param y the second {@code int} to compare
+ * @return the value {@code 0} if {@code x == y}; a value less
+ * than {@code 0} if {@code x < y} as unsigned values; and
+ * a value greater than {@code 0} if {@code x > y} as
+ * unsigned values
+ * @since 1.8
+ */
+ public static int compareUnsigned(int x, int y) {
+ return compare(x + MIN_VALUE, y + MIN_VALUE);
+ }
+
+ /**
+ * Converts the argument to a {@code long} by an unsigned
+ * conversion. In an unsigned conversion to a {@code long}, the
+ * high-order 32 bits of the {@code long} are zero and the
+ * low-order 32 bits are equal to the bits of the integer
+ * argument.
+ *
+ * Consequently, zero and positive {@code int} values are mapped
+ * to a numerically equal {@code long} value and negative {@code
+ * int} values are mapped to a {@code long} value equal to the
+ * input plus 2<sup>32</sup>.
+ *
+ * @param x the value to convert to an unsigned {@code long}
+ * @return the argument converted to {@code long} by an unsigned
+ * conversion
+ * @since 1.8
+ */
+ //TODO
+ public static long toUnsignedLong(int x) {
+ return ((long) x) & 0xffffffffL;
+ }
+
+ /**
+ * Returns the unsigned quotient of dividing the first argument by
+ * the second where each argument and the result is interpreted as
+ * an unsigned value.
+ *
+ * <p>Note that in two's complement arithmetic, the three other
+ * basic arithmetic operations of add, subtract, and multiply are
+ * bit-wise identical if the two operands are regarded as both
+ * being signed or both being unsigned. Therefore separate {@code
+ * addUnsigned}, etc. methods are not provided.
+ *
+ * @param dividend the value to be divided
+ * @param divisor the value doing the dividing
+ * @return the unsigned quotient of the first argument divided by
+ * the second argument
+ * @see #remainderUnsigned
+ * @since 1.8
+ */
+ //TODO
+ public static int divideUnsigned(int dividend, int divisor) {
+ return (int)(toUnsignedLong(dividend) / toUnsignedLong(divisor));
+ }
+
+ /**
+ * Returns the unsigned remainder from dividing the first argument
+ * by the second where each argument and the result is interpreted
+ * as an unsigned value.
+ *
+ * @param dividend the value to be divided
+ * @param divisor the value doing the dividing
+ * @return the unsigned remainder of the first argument divided by
+ * the second argument
+ * @see #divideUnsigned
+ * @since 1.8
+ */
+ //TODO
+ public static int remainderUnsigned(int dividend, int divisor) {
+ return (int)(toUnsignedLong(dividend) % toUnsignedLong(divisor));
+ }
+
+
+ // Bit twiddling
+
+ /**
+ * The number of bits used to represent an {@code int} value in two's
+ * complement binary form.
+ *
+ * @since 1.5
+ */
+ public static final int SIZE = 32;
+
+ /**
+ * The number of bytes used to represent a {@code int} value in two's
+ * complement binary form.
+ *
+ * @since 1.8
+ */
+ public static final int BYTES = 4;
+
+ /**
+ * Returns an {@code int} value with at most a single one-bit, in the
+ * position of the highest-order ("leftmost") one-bit in the specified
+ * {@code int} value. Returns zero if the specified value has no
+ * one-bits in its two's complement binary representation, that is, if it
+ * is equal to zero.
+ *
+ * @param i the value whose highest one bit is to be computed
+ * @return an {@code int} value with a single one-bit, in the position
+ * of the highest-order one-bit in the specified value, or zero if
+ * the specified value is itself equal to zero.
+ * @since 1.5
+ */
+ //TODO
+ public static int highestOneBit(int i) {
+ i |= (i >> 1);
+ i |= (i >> 2);
+ i |= (i >> 4);
+ i |= (i >> 8);
+ i |= (i >> 16);
+ return i - (i >>> 1);
+ }
+
+ /**
+ * Returns an {@code int} value with at most a single one-bit, in the
+ * position of the lowest-order ("rightmost") one-bit in the specified
+ * {@code int} value. Returns zero if the specified value has no
+ * one-bits in its two's complement binary representation, that is, if it
+ * is equal to zero.
+ *
+ * @param i the value whose lowest one bit is to be computed
+ * @return an {@code int} value with a single one-bit, in the position
+ * of the lowest-order one-bit in the specified value, or zero if
+ * the specified value is itself equal to zero.
+ * @since 1.5
+ */
+ //TODO
+ public static int lowestOneBit(int i) {
+ return i & -i;
+ }
+
+ /**
+ * Returns the number of zero bits preceding the highest-order
+ * ("leftmost") one-bit in the two's complement binary representation
+ * of the specified {@code int} value. Returns 32 if the
+ * specified value has no one-bits in its two's complement representation,
+ * in other words if it is equal to zero.
+ *
+ * <p>Note that this method is closely related to the logarithm base 2.
+ * For all positive {@code int} values x:
+ * <ul>
+ * <li>floor(log<sub>2</sub>(x)) = {@code 31 - numberOfLeadingZeros(x)}
+ * <li>ceil(log<sub>2</sub>(x)) = {@code 32 - numberOfLeadingZeros(x - 1)}
+ * </ul>
+ *
+ * @param i the value whose number of leading zeros is to be computed
+ * @return the number of zero bits preceding the highest-order
+ * ("leftmost") one-bit in the two's complement binary representation
+ * of the specified {@code int} value, or 32 if the value
+ * is equal to zero.
+ * @since 1.5
+ */
+ //TODO
+ public static int numberOfLeadingZeros(int i) {
+ if (i == 0)
+ return 32;
+ int n = 1;
+ if (i >>> 16 == 0) { n += 16; i <<= 16; }
+ if (i >>> 24 == 0) { n += 8; i <<= 8; }
+ if (i >>> 28 == 0) { n += 4; i <<= 4; }
+ if (i >>> 30 == 0) { n += 2; i <<= 2; }
+ n -= i >>> 31;
+ return n;
+ }
+
+ /**
+ * Returns the number of zero bits following the lowest-order ("rightmost")
+ * one-bit in the two's complement binary representation of the specified
+ * {@code int} value. Returns 32 if the specified value has no
+ * one-bits in its two's complement representation, in other words if it is
+ * equal to zero.
+ *
+ * @param i the value whose number of trailing zeros is to be computed
+ * @return the number of zero bits following the lowest-order ("rightmost")
+ * one-bit in the two's complement binary representation of the
+ * specified {@code int} value, or 32 if the value is equal
+ * to zero.
+ * @since 1.5
+ */
+ //TODO
+ public static int numberOfTrailingZeros(int i) {
+ int y;
+ if (i == 0) return 32;
+ int n = 31;
+ y = i <<16; if (y != 0) { n = n -16; i = y; }
+ y = i << 8; if (y != 0) { n = n - 8; i = y; }
+ y = i << 4; if (y != 0) { n = n - 4; i = y; }
+ y = i << 2; if (y != 0) { n = n - 2; i = y; }
+ return n - ((i << 1) >>> 31);
+ }
+
+ /**
+ * Returns the number of one-bits in the two's complement binary
+ * representation of the specified {@code int} value. This function is
+ * sometimes referred to as the <i>population count</i>.
+ *
+ * @param i the value whose bits are to be counted
+ * @return the number of one-bits in the two's complement binary
+ * representation of the specified {@code int} value.
+ * @since 1.5
+ */
+ //TODO
+ public static int bitCount(int i) {
+ i = i - ((i >>> 1) & 0x55555555);
+ i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
+ i = (i + (i >>> 4)) & 0x0f0f0f0f;
+ i = i + (i >>> 8);
+ i = i + (i >>> 16);
+ return i & 0x3f;
+ }
+
+ /**
+ * Returns the value obtained by rotating the two's complement binary
+ * representation of the specified {@code int} value left by the
+ * specified number of bits. (Bits shifted out of the left hand, or
+ * high-order, side reenter on the right, or low-order.)
+ *
+ * <p>Note that left rotation with a negative distance is equivalent to
+ * right rotation: {@code rotateLeft(val, -distance) == rotateRight(val,
+ * distance)}. Note also that rotation by any multiple of 32 is a
+ * no-op, so all but the last five bits of the rotation distance can be
+ * ignored, even if the distance is negative: {@code rotateLeft(val,
+ * distance) == rotateLeft(val, distance & 0x1F)}.
+ *
+ * @param i the value whose bits are to be rotated left
+ * @param distance the number of bit positions to rotate left
+ * @return the value obtained by rotating the two's complement binary
+ * representation of the specified {@code int} value left by the
+ * specified number of bits.
+ * @since 1.5
+ */
+ //TODO
+ public static int rotateLeft(int i, int distance) {
+ return (i << distance) | (i >>> -distance);
+ }
+
+ /**
+ * Returns the value obtained by rotating the two's complement binary
+ * representation of the specified {@code int} value right by the
+ * specified number of bits. (Bits shifted out of the right hand, or
+ * low-order, side reenter on the left, or high-order.)
+ *
+ * <p>Note that right rotation with a negative distance is equivalent to
+ * left rotation: {@code rotateRight(val, -distance) == rotateLeft(val,
+ * distance)}. Note also that rotation by any multiple of 32 is a
+ * no-op, so all but the last five bits of the rotation distance can be
+ * ignored, even if the distance is negative: {@code rotateRight(val,
+ * distance) == rotateRight(val, distance & 0x1F)}.
+ *
+ * @param i the value whose bits are to be rotated right
+ * @param distance the number of bit positions to rotate right
+ * @return the value obtained by rotating the two's complement binary
+ * representation of the specified {@code int} value right by the
+ * specified number of bits.
+ * @since 1.5
+ */
+ //TODO
+ public static int rotateRight(int i, int distance) {
+ return (i >>> distance) | (i << -distance);
+ }
+
+ /**
+ * Returns the value obtained by reversing the order of the bits in the
+ * two's complement binary representation of the specified {@code int}
+ * value.
+ *
+ * @param i the value to be reversed
+ * @return the value obtained by reversing order of the bits in the
+ * specified {@code int} value.
+ * @since 1.5
+ */
+ //TODO
+ public static int reverse(int i) {
+ // HD, Figure 7-1
+ i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
+ i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
+ i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
+ i = (i << 24) | ((i & 0xff00) << 8) |
+ ((i >>> 8) & 0xff00) | (i >>> 24);
+ return i;
+ }
+
+ /**
+ * Returns the signum function of the specified {@code int} value. (The
+ * return value is -1 if the specified value is negative; 0 if the
+ * specified value is zero; and 1 if the specified value is positive.)
+ *
+ * @param i the value whose signum is to be computed
+ * @return the signum function of the specified {@code int} value.
+ * @since 1.5
+ */
+ //TODO
+ public static int signum(int i) {
+ // HD, Section 2-7
+ return (i >> 31) | (-i >>> 31);
+ }
+
+ /**
+ * Returns the value obtained by reversing the order of the bytes in the
+ * two's complement representation of the specified {@code int} value.
+ *
+ * @param i the value whose bytes are to be reversed
+ * @return the value obtained by reversing the bytes in the specified
+ * {@code int} value.
+ * @since 1.5
+ */
+ //TODO
+ public static int reverseBytes(int i) {
+ return ((i >>> 24) ) |
+ ((i >> 8) & 0xFF00) |
+ ((i << 8) & 0xFF0000) |
+ ((i << 24));
+ }
+
+ /**
+ * Adds two integers together as per the + operator.
+ *
+ * @param a the first operand
+ * @param b the second operand
+ * @return the sum of {@code a} and {@code b}
+ * @see java.util.function.BinaryOperator
+ * @since 1.8
+ */
+ public static int sum(int a, int b) {
+ return a + b;
+ }
+
+ /**
+ * Returns the greater of two {@code int} values
+ * as if by calling {@link Math#max(int, int) Math.max}.
+ *
+ * @param a the first operand
+ * @param b the second operand
+ * @return the greater of {@code a} and {@code b}
+ * @see java.util.function.BinaryOperator
+ * @since 1.8
+ */
+ public static int max(int a, int b) {
+ int result = CProver.nondetInt();
+ CProver.assume((result == a || result == b) && result >= a && result >= b);
+ return result;
+ }
+
+ /**
+ * Returns the smaller of two {@code int} values
+ * as if by calling {@link Math#min(int, int) Math.min}.
+ *
+ * @param a the first operand
+ * @param b the second operand
+ * @return the smaller of {@code a} and {@code b}
+ * @see java.util.function.BinaryOperator
+ * @since 1.8
+ */
+ public static int min(int a, int b) {
+ int result = CProver.nondetInt();
+ CProver.assume((result == a || result == b) && result <= a && result <= b);
+ return result;
+ }
+
+ /** use serialVersionUID from JDK 1.0.2 for interoperability */
+ private static final long serialVersionUID = 1360826667806852920L;
+}
diff --git a/src/main/java/java/lang/InterruptedException.java b/src/main/java/java/lang/InterruptedException.java
new file mode 100644
index 0000000..2ca630f
--- /dev/null
+++ b/src/main/java/java/lang/InterruptedException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class InterruptedException extends Exception {
+ private static final long serialVersionUID = 6700697376100628473L;
+
+ public InterruptedException() {
+ super();
+ }
+
+ public InterruptedException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.InterruptedException: " + message)
+ : "java.lang.InterruptedException";
+ }
+}
diff --git a/src/main/java/java/lang/LinkageError.java b/src/main/java/java/lang/LinkageError.java
new file mode 100644
index 0000000..9e8f89f
--- /dev/null
+++ b/src/main/java/java/lang/LinkageError.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Subclasses of {@code LinkageError} indicate that a class has
+ * some dependency on another class; however, the latter class has
+ * incompatibly changed after the compilation of the former class.
+ *
+ *
+ * @author Frank Yellin
+ * @since JDK1.0
+ */
+public
+class LinkageError extends Error {
+ private static final long serialVersionUID = 3579600108157160122L;
+
+ /**
+ * Constructs a {@code LinkageError} with no detail message.
+ */
+ public LinkageError() {
+ super();
+ }
+
+ /**
+ * Constructs a {@code LinkageError} with the specified detail
+ * message.
+ *
+ * @param s the detail message.
+ */
+ public LinkageError(String s) {
+ super(s);
+ }
+
+ /**
+ * Constructs a {@code LinkageError} with the specified detail
+ * message and cause.
+ *
+ * @param s the detail message.
+ * @param cause the cause, may be {@code null}
+ * @since 1.7
+ */
+ public LinkageError(String s, Throwable cause) {
+ super(s, cause);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.LinkageError: " + message)
+ : "java.lang.LinkageError";
+ }
+}
diff --git a/src/main/java/java/lang/Math.java b/src/main/java/java/lang/Math.java
new file mode 100644
index 0000000..539b8d6
--- /dev/null
+++ b/src/main/java/java/lang/Math.java
@@ -0,0 +1,2560 @@
+/*
+ * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+import java.util.Random;
+
+import sun.misc.FloatConsts;
+import sun.misc.DoubleConsts;
+
+import org.cprover.CProver;
+
+/**
+ * The class {@code Math} contains methods for performing basic
+ * numeric operations such as the elementary exponential, logarithm,
+ * square root, and trigonometric functions.
+ *
+ * <p>Unlike some of the numeric methods of class
+ * {@code StrictMath}, all implementations of the equivalent
+ * functions of class {@code Math} are not defined to return the
+ * bit-for-bit same results. This relaxation permits
+ * better-performing implementations where strict reproducibility is
+ * not required.
+ *
+ * <p>By default many of the {@code Math} methods simply call
+ * the equivalent method in {@code StrictMath} for their
+ * implementation. Code generators are encouraged to use
+ * platform-specific native libraries or microprocessor instructions,
+ * where available, to provide higher-performance implementations of
+ * {@code Math} methods. Such higher-performance
+ * implementations still must conform to the specification for
+ * {@code Math}.
+ *
+ * <p>The quality of implementation specifications concern two
+ * properties, accuracy of the returned result and monotonicity of the
+ * method. Accuracy of the floating-point {@code Math} methods is
+ * measured in terms of <i>ulps</i>, units in the last place. For a
+ * given floating-point format, an {@linkplain #ulp(double) ulp} of a
+ * specific real number value is the distance between the two
+ * floating-point values bracketing that numerical value. When
+ * discussing the accuracy of a method as a whole rather than at a
+ * specific argument, the number of ulps cited is for the worst-case
+ * error at any argument. If a method always has an error less than
+ * 0.5 ulps, the method always returns the floating-point number
+ * nearest the exact result; such a method is <i>correctly
+ * rounded</i>. A correctly rounded method is generally the best a
+ * floating-point approximation can be; however, it is impractical for
+ * many floating-point methods to be correctly rounded. Instead, for
+ * the {@code Math} class, a larger error bound of 1 or 2 ulps is
+ * allowed for certain methods. Informally, with a 1 ulp error bound,
+ * when the exact result is a representable number, the exact result
+ * should be returned as the computed result; otherwise, either of the
+ * two floating-point values which bracket the exact result may be
+ * returned. For exact results large in magnitude, one of the
+ * endpoints of the bracket may be infinite. Besides accuracy at
+ * individual arguments, maintaining proper relations between the
+ * method at different arguments is also important. Therefore, most
+ * methods with more than 0.5 ulp errors are required to be
+ * <i>semi-monotonic</i>: whenever the mathematical function is
+ * non-decreasing, so is the floating-point approximation, likewise,
+ * whenever the mathematical function is non-increasing, so is the
+ * floating-point approximation. Not all approximations that have 1
+ * ulp accuracy will automatically meet the monotonicity requirements.
+ *
+ * <p>
+ * The platform uses signed two's complement integer arithmetic with
+ * int and long primitive types. The developer should choose
+ * the primitive type to ensure that arithmetic operations consistently
+ * produce correct results, which in some cases means the operations
+ * will not overflow the range of values of the computation.
+ * The best practice is to choose the primitive type and algorithm to avoid
+ * overflow. In cases where the size is {@code int} or {@code long} and
+ * overflow errors need to be detected, the methods {@code addExact},
+ * {@code subtractExact}, {@code multiplyExact}, and {@code toIntExact}
+ * throw an {@code ArithmeticException} when the results overflow.
+ * For other arithmetic operations such as divide, absolute value,
+ * increment, decrement, and negation overflow occurs only with
+ * a specific minimum or maximum value and should be checked against
+ * the minimum or maximum as appropriate.
+ *
+ * @author unascribed
+ * @author Joseph D. Darcy
+ * @since JDK1.0
+ */
+
+public final class Math {
+
+ /**
+ * Don't let anyone instantiate this class.
+ */
+ private Math() {}
+
+ /**
+ * The {@code double} value that is closer than any other to
+ * <i>e</i>, the base of the natural logarithms.
+ */
+ public static final double E = 2.7182818284590452354;
+
+ /**
+ * The {@code double} value that is closer than any other to
+ * <i>pi</i>, the ratio of the circumference of a circle to its
+ * diameter.
+ */
+ public static final double PI = 3.14159265358979323846;
+
+ /**
+ * Returns the trigonometric sine of an angle. Special cases:
+ * <ul><li>If the argument is NaN or an infinity, then the
+ * result is NaN.
+ * <li>If the argument is zero, then the result is a zero with the
+ * same sign as the argument.</ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a an angle, in radians.
+ * @return the sine of the argument.
+ */
+ public static double sin(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.sin(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the trigonometric cosine of an angle. Special cases:
+ * <ul><li>If the argument is NaN or an infinity, then the
+ * result is NaN.</ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a an angle, in radians.
+ * @return the cosine of the argument.
+ */
+ public static double cos(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.cos(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the trigonometric tangent of an angle. Special cases:
+ * <ul><li>If the argument is NaN or an infinity, then the result
+ * is NaN.
+ * <li>If the argument is zero, then the result is a zero with the
+ * same sign as the argument.</ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a an angle, in radians.
+ * @return the tangent of the argument.
+ */
+ public static double tan(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.tan(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the arc sine of a value; the returned angle is in the
+ * range -<i>pi</i>/2 through <i>pi</i>/2. Special cases:
+ * <ul><li>If the argument is NaN or its absolute value is greater
+ * than 1, then the result is NaN.
+ * <li>If the argument is zero, then the result is a zero with the
+ * same sign as the argument.</ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a the value whose arc sine is to be returned.
+ * @return the arc sine of the argument.
+ */
+ public static double asin(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.asin(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the arc cosine of a value; the returned angle is in the
+ * range 0.0 through <i>pi</i>. Special case:
+ * <ul><li>If the argument is NaN or its absolute value is greater
+ * than 1, then the result is NaN.</ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a the value whose arc cosine is to be returned.
+ * @return the arc cosine of the argument.
+ */
+ public static double acos(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.acos(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the arc tangent of a value; the returned angle is in the
+ * range -<i>pi</i>/2 through <i>pi</i>/2. Special cases:
+ * <ul><li>If the argument is NaN, then the result is NaN.
+ * <li>If the argument is zero, then the result is a zero with the
+ * same sign as the argument.</ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a the value whose arc tangent is to be returned.
+ * @return the arc tangent of the argument.
+ */
+ public static double atan(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.atan(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Converts an angle measured in degrees to an approximately
+ * equivalent angle measured in radians. The conversion from
+ * degrees to radians is generally inexact.
+ *
+ * @param angdeg an angle, in degrees
+ * @return the measurement of the angle {@code angdeg}
+ * in radians.
+ * @since 1.2
+ */
+ public static double toRadians(double angdeg) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return angdeg / 180.0 * PI;
+ }
+
+ /**
+ * Converts an angle measured in radians to an approximately
+ * equivalent angle measured in degrees. The conversion from
+ * radians to degrees is generally inexact; users should
+ * <i>not</i> expect {@code cos(toRadians(90.0))} to exactly
+ * equal {@code 0.0}.
+ *
+ * @param angrad an angle, in radians
+ * @return the measurement of the angle {@code angrad}
+ * in degrees.
+ * @since 1.2
+ */
+ public static double toDegrees(double angrad) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return angrad * 180.0 / PI;
+ }
+
+ /**
+ * Returns Euler's number <i>e</i> raised to the power of a
+ * {@code double} value. Special cases:
+ * <ul><li>If the argument is NaN, the result is NaN.
+ * <li>If the argument is positive infinity, then the result is
+ * positive infinity.
+ * <li>If the argument is negative infinity, then the result is
+ * positive zero.</ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a the exponent to raise <i>e</i> to.
+ * @return the value <i>e</i><sup>{@code a}</sup>,
+ * where <i>e</i> is the base of the natural logarithms.
+ */
+ public static double exp(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.exp(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the natural logarithm (base <i>e</i>) of a {@code double}
+ * value. Special cases:
+ * <ul><li>If the argument is NaN or less than zero, then the result
+ * is NaN.
+ * <li>If the argument is positive infinity, then the result is
+ * positive infinity.
+ * <li>If the argument is positive zero or negative zero, then the
+ * result is negative infinity.</ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a a value
+ * @return the value ln {@code a}, the natural logarithm of
+ * {@code a}.
+ */
+ public static double log(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.log(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the base 10 logarithm of a {@code double} value.
+ * Special cases:
+ *
+ * <ul><li>If the argument is NaN or less than zero, then the result
+ * is NaN.
+ * <li>If the argument is positive infinity, then the result is
+ * positive infinity.
+ * <li>If the argument is positive zero or negative zero, then the
+ * result is negative infinity.
+ * <li> If the argument is equal to 10<sup><i>n</i></sup> for
+ * integer <i>n</i>, then the result is <i>n</i>.
+ * </ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a a value
+ * @return the base 10 logarithm of {@code a}.
+ * @since 1.5
+ */
+ public static double log10(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.log10(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the correctly rounded positive square root of a
+ * {@code double} value.
+ * Special cases:
+ * <ul><li>If the argument is NaN or less than zero, then the result
+ * is NaN.
+ * <li>If the argument is positive infinity, then the result is positive
+ * infinity.
+ * <li>If the argument is positive zero or negative zero, then the
+ * result is the same as the argument.</ul>
+ * Otherwise, the result is the {@code double} value closest to
+ * the true mathematical square root of the argument value.
+ *
+ * @param a a value.
+ * @return the positive square root of {@code a}.
+ * If the argument is NaN or less than zero, the result is NaN.
+ */
+ public static double sqrt(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.sqrt(a); // default impl. delegates to StrictMath
+ // Note that hardware sqrt instructions
+ // frequently can be directly used by JITs
+ // and should be much faster than doing
+ // Math.sqrt in software.
+ }
+
+
+ /**
+ * Returns the cube root of a {@code double} value. For
+ * positive finite {@code x}, {@code cbrt(-x) ==
+ * -cbrt(x)}; that is, the cube root of a negative value is
+ * the negative of the cube root of that value's magnitude.
+ *
+ * Special cases:
+ *
+ * <ul>
+ *
+ * <li>If the argument is NaN, then the result is NaN.
+ *
+ * <li>If the argument is infinite, then the result is an infinity
+ * with the same sign as the argument.
+ *
+ * <li>If the argument is zero, then the result is a zero with the
+ * same sign as the argument.
+ *
+ * </ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ *
+ * @param a a value.
+ * @return the cube root of {@code a}.
+ * @since 1.5
+ */
+ public static double cbrt(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.cbrt(a);
+ }
+
+ /**
+ * Computes the remainder operation on two arguments as prescribed
+ * by the IEEE 754 standard.
+ * The remainder value is mathematically equal to
+ * <code>f1 - f2</code> × <i>n</i>,
+ * where <i>n</i> is the mathematical integer closest to the exact
+ * mathematical value of the quotient {@code f1/f2}, and if two
+ * mathematical integers are equally close to {@code f1/f2},
+ * then <i>n</i> is the integer that is even. If the remainder is
+ * zero, its sign is the same as the sign of the first argument.
+ * Special cases:
+ * <ul><li>If either argument is NaN, or the first argument is infinite,
+ * or the second argument is positive zero or negative zero, then the
+ * result is NaN.
+ * <li>If the first argument is finite and the second argument is
+ * infinite, then the result is the same as the first argument.</ul>
+ *
+ * @param f1 the dividend.
+ * @param f2 the divisor.
+ * @return the remainder when {@code f1} is divided by
+ * {@code f2}.
+ */
+ public static double IEEEremainder(double f1, double f2) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.IEEEremainder(f1, f2); // delegate to StrictMath
+ }
+
+ /**
+ * Returns the smallest (closest to negative infinity)
+ * {@code double} value that is greater than or equal to the
+ * argument and is equal to a mathematical integer. Special cases:
+ * <ul><li>If the argument value is already equal to a
+ * mathematical integer, then the result is the same as the
+ * argument. <li>If the argument is NaN or an infinity or
+ * positive zero or negative zero, then the result is the same as
+ * the argument. <li>If the argument value is less than zero but
+ * greater than -1.0, then the result is negative zero.</ul> Note
+ * that the value of {@code Math.ceil(x)} is exactly the
+ * value of {@code -Math.floor(-x)}.
+ *
+ *
+ * @param a a value.
+ * @return the smallest (closest to negative infinity)
+ * floating-point value that is greater than or equal to
+ * the argument and is equal to a mathematical integer.
+ */
+ public static double ceil(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.ceil(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the largest (closest to positive infinity)
+ * {@code double} value that is less than or equal to the
+ * argument and is equal to a mathematical integer. Special cases:
+ * <ul><li>If the argument value is already equal to a
+ * mathematical integer, then the result is the same as the
+ * argument. <li>If the argument is NaN or an infinity or
+ * positive zero or negative zero, then the result is the same as
+ * the argument.</ul>
+ *
+ * @param a a value.
+ * @return the largest (closest to positive infinity)
+ * floating-point value that less than or equal to the argument
+ * and is equal to a mathematical integer.
+ */
+ public static double floor(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.floor(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the {@code double} value that is closest in value
+ * to the argument and is equal to a mathematical integer. If two
+ * {@code double} values that are mathematical integers are
+ * equally close, the result is the integer value that is
+ * even. Special cases:
+ * <ul><li>If the argument value is already equal to a mathematical
+ * integer, then the result is the same as the argument.
+ * <li>If the argument is NaN or an infinity or positive zero or negative
+ * zero, then the result is the same as the argument.</ul>
+ *
+ * @param a a {@code double} value.
+ * @return the closest floating-point value to {@code a} that is
+ * equal to a mathematical integer.
+ */
+ public static double rint(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.rint(a); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the angle <i>theta</i> from the conversion of rectangular
+ * coordinates ({@code x}, {@code y}) to polar
+ * coordinates (r, <i>theta</i>).
+ * This method computes the phase <i>theta</i> by computing an arc tangent
+ * of {@code y/x} in the range of -<i>pi</i> to <i>pi</i>. Special
+ * cases:
+ * <ul><li>If either argument is NaN, then the result is NaN.
+ * <li>If the first argument is positive zero and the second argument
+ * is positive, or the first argument is positive and finite and the
+ * second argument is positive infinity, then the result is positive
+ * zero.
+ * <li>If the first argument is negative zero and the second argument
+ * is positive, or the first argument is negative and finite and the
+ * second argument is positive infinity, then the result is negative zero.
+ * <li>If the first argument is positive zero and the second argument
+ * is negative, or the first argument is positive and finite and the
+ * second argument is negative infinity, then the result is the
+ * {@code double} value closest to <i>pi</i>.
+ * <li>If the first argument is negative zero and the second argument
+ * is negative, or the first argument is negative and finite and the
+ * second argument is negative infinity, then the result is the
+ * {@code double} value closest to -<i>pi</i>.
+ * <li>If the first argument is positive and the second argument is
+ * positive zero or negative zero, or the first argument is positive
+ * infinity and the second argument is finite, then the result is the
+ * {@code double} value closest to <i>pi</i>/2.
+ * <li>If the first argument is negative and the second argument is
+ * positive zero or negative zero, or the first argument is negative
+ * infinity and the second argument is finite, then the result is the
+ * {@code double} value closest to -<i>pi</i>/2.
+ * <li>If both arguments are positive infinity, then the result is the
+ * {@code double} value closest to <i>pi</i>/4.
+ * <li>If the first argument is positive infinity and the second argument
+ * is negative infinity, then the result is the {@code double}
+ * value closest to 3*<i>pi</i>/4.
+ * <li>If the first argument is negative infinity and the second argument
+ * is positive infinity, then the result is the {@code double} value
+ * closest to -<i>pi</i>/4.
+ * <li>If both arguments are negative infinity, then the result is the
+ * {@code double} value closest to -3*<i>pi</i>/4.</ul>
+ *
+ * <p>The computed result must be within 2 ulps of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param y the ordinate coordinate
+ * @param x the abscissa coordinate
+ * @return the <i>theta</i> component of the point
+ * (<i>r</i>, <i>theta</i>)
+ * in polar coordinates that corresponds to the point
+ * (<i>x</i>, <i>y</i>) in Cartesian coordinates.
+ */
+ public static double atan2(double y, double x) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.atan2(y, x); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the value of the first argument raised to the power of the
+ * second argument. Special cases:
+ *
+ * <ul><li>If the second argument is positive or negative zero, then the
+ * result is 1.0.
+ * <li>If the second argument is 1.0, then the result is the same as the
+ * first argument.
+ * <li>If the second argument is NaN, then the result is NaN.
+ * <li>If the first argument is NaN and the second argument is nonzero,
+ * then the result is NaN.
+ *
+ * <li>If
+ * <ul>
+ * <li>the absolute value of the first argument is greater than 1
+ * and the second argument is positive infinity, or
+ * <li>the absolute value of the first argument is less than 1 and
+ * the second argument is negative infinity,
+ * </ul>
+ * then the result is positive infinity.
+ *
+ * <li>If
+ * <ul>
+ * <li>the absolute value of the first argument is greater than 1 and
+ * the second argument is negative infinity, or
+ * <li>the absolute value of the
+ * first argument is less than 1 and the second argument is positive
+ * infinity,
+ * </ul>
+ * then the result is positive zero.
+ *
+ * <li>If the absolute value of the first argument equals 1 and the
+ * second argument is infinite, then the result is NaN.
+ *
+ * <li>If
+ * <ul>
+ * <li>the first argument is positive zero and the second argument
+ * is greater than zero, or
+ * <li>the first argument is positive infinity and the second
+ * argument is less than zero,
+ * </ul>
+ * then the result is positive zero.
+ *
+ * <li>If
+ * <ul>
+ * <li>the first argument is positive zero and the second argument
+ * is less than zero, or
+ * <li>the first argument is positive infinity and the second
+ * argument is greater than zero,
+ * </ul>
+ * then the result is positive infinity.
+ *
+ * <li>If
+ * <ul>
+ * <li>the first argument is negative zero and the second argument
+ * is greater than zero but not a finite odd integer, or
+ * <li>the first argument is negative infinity and the second
+ * argument is less than zero but not a finite odd integer,
+ * </ul>
+ * then the result is positive zero.
+ *
+ * <li>If
+ * <ul>
+ * <li>the first argument is negative zero and the second argument
+ * is a positive finite odd integer, or
+ * <li>the first argument is negative infinity and the second
+ * argument is a negative finite odd integer,
+ * </ul>
+ * then the result is negative zero.
+ *
+ * <li>If
+ * <ul>
+ * <li>the first argument is negative zero and the second argument
+ * is less than zero but not a finite odd integer, or
+ * <li>the first argument is negative infinity and the second
+ * argument is greater than zero but not a finite odd integer,
+ * </ul>
+ * then the result is positive infinity.
+ *
+ * <li>If
+ * <ul>
+ * <li>the first argument is negative zero and the second argument
+ * is a negative finite odd integer, or
+ * <li>the first argument is negative infinity and the second
+ * argument is a positive finite odd integer,
+ * </ul>
+ * then the result is negative infinity.
+ *
+ * <li>If the first argument is finite and less than zero
+ * <ul>
+ * <li> if the second argument is a finite even integer, the
+ * result is equal to the result of raising the absolute value of
+ * the first argument to the power of the second argument
+ *
+ * <li>if the second argument is a finite odd integer, the result
+ * is equal to the negative of the result of raising the absolute
+ * value of the first argument to the power of the second
+ * argument
+ *
+ * <li>if the second argument is finite and not an integer, then
+ * the result is NaN.
+ * </ul>
+ *
+ * <li>If both arguments are integers, then the result is exactly equal
+ * to the mathematical result of raising the first argument to the power
+ * of the second argument if that result can in fact be represented
+ * exactly as a {@code double} value.</ul>
+ *
+ * <p>(In the foregoing descriptions, a floating-point value is
+ * considered to be an integer if and only if it is finite and a
+ * fixed point of the method {@link #ceil ceil} or,
+ * equivalently, a fixed point of the method {@link #floor
+ * floor}. A value is a fixed point of a one-argument
+ * method if and only if the result of applying the method to the
+ * value is equal to the value.)
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param a the base.
+ * @param b the exponent.
+ * @return the value {@code a}<sup>{@code b}</sup>.
+ */
+ public static double pow(double a, double b) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.pow(a, b); // default impl. delegates to StrictMath
+ }
+
+ /**
+ * Returns the closest {@code int} to the argument, with ties
+ * rounding to positive infinity.
+ *
+ * <p>
+ * Special cases:
+ * <ul><li>If the argument is NaN, the result is 0.
+ * <li>If the argument is negative infinity or any value less than or
+ * equal to the value of {@code Integer.MIN_VALUE}, the result is
+ * equal to the value of {@code Integer.MIN_VALUE}.
+ * <li>If the argument is positive infinity or any value greater than or
+ * equal to the value of {@code Integer.MAX_VALUE}, the result is
+ * equal to the value of {@code Integer.MAX_VALUE}.</ul>
+ *
+ * @param a a floating-point value to be rounded to an integer.
+ * @return the value of the argument rounded to the nearest
+ * {@code int} value.
+ * @see java.lang.Integer#MAX_VALUE
+ * @see java.lang.Integer#MIN_VALUE
+ *
+ * @diffblue.limitedSupport
+ * @diffblue.untested
+ */
+ public static int round(float a) {
+ if(a < 0)
+ return (int)(a - 0.5);
+ else
+ return (int)(a + 0.5);
+ // int intBits = Float.floatToRawIntBits(a);
+ // int biasedExp = (intBits & FloatConsts.EXP_BIT_MASK)
+ // >> (FloatConsts.SIGNIFICAND_WIDTH - 1);
+ // int shift = (FloatConsts.SIGNIFICAND_WIDTH - 2
+ // + FloatConsts.EXP_BIAS) - biasedExp;
+ // if ((shift & -32) == 0) { // shift >= 0 && shift < 32
+ // // a is a finite number such that pow(2,-32) <= ulp(a) < 1
+ // int r = ((intBits & FloatConsts.SIGNIF_BIT_MASK)
+ // | (FloatConsts.SIGNIF_BIT_MASK + 1));
+ // if (intBits < 0) {
+ // r = -r;
+ // }
+ // // In the comments below each Java expression evaluates to the value
+ // // the corresponding mathematical expression:
+ // // (r) evaluates to a / ulp(a)
+ // // (r >> shift) evaluates to floor(a * 2)
+ // // ((r >> shift) + 1) evaluates to floor((a + 1/2) * 2)
+ // // (((r >> shift) + 1) >> 1) evaluates to floor(a + 1/2)
+ // return ((r >> shift) + 1) >> 1;
+ // } else {
+ // // a is either
+ // // - a finite number with abs(a) < exp(2,FloatConsts.SIGNIFICAND_WIDTH-32) < 1/2
+ // // - a finite number with ulp(a) >= 1 and hence a is a mathematical integer
+ // // - an infinity or NaN
+ // return (int) a;
+ // }
+ }
+
+ /**
+ * Returns the closest {@code long} to the argument, with ties
+ * rounding to positive infinity.
+ *
+ * <p>Special cases:
+ * <ul><li>If the argument is NaN, the result is 0.
+ * <li>If the argument is negative infinity or any value less than or
+ * equal to the value of {@code Long.MIN_VALUE}, the result is
+ * equal to the value of {@code Long.MIN_VALUE}.
+ * <li>If the argument is positive infinity or any value greater than or
+ * equal to the value of {@code Long.MAX_VALUE}, the result is
+ * equal to the value of {@code Long.MAX_VALUE}.</ul>
+ *
+ * @param a a floating-point value to be rounded to a
+ * {@code long}.
+ * @return the value of the argument rounded to the nearest
+ * {@code long} value.
+ * @see java.lang.Long#MAX_VALUE
+ * @see java.lang.Long#MIN_VALUE
+ *
+ * @diffblue.limitedSupport
+ * @diffblue.untested
+ */
+ public static long round(double a) {
+ if(a < 0)
+ return (long)(a - 0.5);
+ else
+ return (long)(a + 0.5);
+ // long longBits = Double.doubleToRawLongBits(a);
+ // long biasedExp = (longBits & DoubleConsts.EXP_BIT_MASK)
+ // >> (DoubleConsts.SIGNIFICAND_WIDTH - 1);
+ // long shift = (DoubleConsts.SIGNIFICAND_WIDTH - 2
+ // + DoubleConsts.EXP_BIAS) - biasedExp;
+ // if ((shift & -64) == 0) { // shift >= 0 && shift < 64
+ // // a is a finite number such that pow(2,-64) <= ulp(a) < 1
+ // long r = ((longBits & DoubleConsts.SIGNIF_BIT_MASK)
+ // | (DoubleConsts.SIGNIF_BIT_MASK + 1));
+ // if (longBits < 0) {
+ // r = -r;
+ // }
+ // // In the comments below each Java expression evaluates to the value
+ // // the corresponding mathematical expression:
+ // // (r) evaluates to a / ulp(a)
+ // // (r >> shift) evaluates to floor(a * 2)
+ // // ((r >> shift) + 1) evaluates to floor((a + 1/2) * 2)
+ // // (((r >> shift) + 1) >> 1) evaluates to floor(a + 1/2)
+ // return ((r >> shift) + 1) >> 1;
+ // } else {
+ // // a is either
+ // // - a finite number with abs(a) < exp(2,DoubleConsts.SIGNIFICAND_WIDTH-64) < 1/2
+ // // - a finite number with ulp(a) >= 1 and hence a is a mathematical integer
+ // // - an infinity or NaN
+ // return (long) a;
+ // }
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // Not currently modelled
+ // private static final class RandomNumberGeneratorHolder {
+ // static final Random randomNumberGenerator = new Random();
+ // }
+
+ /**
+ * Returns a {@code double} value with a positive sign, greater
+ * than or equal to {@code 0.0} and less than {@code 1.0}.
+ * Returned values are chosen pseudorandomly with (approximately)
+ * uniform distribution from that range.
+ *
+ * <p>When this method is first called, it creates a single new
+ * pseudorandom-number generator, exactly as if by the expression
+ *
+ * <blockquote>{@code new java.util.Random()}</blockquote>
+ *
+ * This new pseudorandom-number generator is used thereafter for
+ * all calls to this method and is used nowhere else.
+ *
+ * <p>This method is properly synchronized to allow correct use by
+ * more than one thread. However, if many threads need to generate
+ * pseudorandom numbers at a great rate, it may reduce contention
+ * for each thread to have its own pseudorandom-number generator.
+ *
+ * @return a pseudorandom {@code double} greater than or equal
+ * to {@code 0.0} and less than {@code 1.0}.
+ * @see Random#nextDouble()
+ */
+ public static double random() {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
+ }
+
+ /**
+ * Returns the sum of its arguments,
+ * throwing an exception if the result overflows an {@code int}.
+ *
+ * @param x the first value
+ * @param y the second value
+ * @return the result
+ * @throws ArithmeticException if the result overflows an int
+ * @since 1.8
+ */
+ public static int addExact(int x, int y) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // int r = x + y;
+ // // HD 2-12 Overflow iff both arguments have the opposite sign of the result
+ // if (((x ^ r) & (y ^ r)) < 0) {
+ // throw new ArithmeticException("integer overflow");
+ // }
+ // return r;
+ }
+
+ /**
+ * Returns the sum of its arguments,
+ * throwing an exception if the result overflows a {@code long}.
+ *
+ * @param x the first value
+ * @param y the second value
+ * @return the result
+ * @throws ArithmeticException if the result overflows a long
+ * @since 1.8
+ */
+ public static long addExact(long x, long y) {
+ CProver.notModelled();
+ return CProver.nondetLong();
+ // long r = x + y;
+ // // HD 2-12 Overflow iff both arguments have the opposite sign of the result
+ // if (((x ^ r) & (y ^ r)) < 0) {
+ // throw new ArithmeticException("long overflow");
+ // }
+ // return r;
+ }
+
+ /**
+ * Returns the difference of the arguments,
+ * throwing an exception if the result overflows an {@code int}.
+ *
+ * @param x the first value
+ * @param y the second value to subtract from the first
+ * @return the result
+ * @throws ArithmeticException if the result overflows an int
+ * @since 1.8
+ */
+ public static int subtractExact(int x, int y) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // int r = x - y;
+ // // HD 2-12 Overflow iff the arguments have different signs and
+ // // the sign of the result is different than the sign of x
+ // if (((x ^ y) & (x ^ r)) < 0) {
+ // throw new ArithmeticException("integer overflow");
+ // }
+ // return r;
+ }
+
+ /**
+ * Returns the difference of the arguments,
+ * throwing an exception if the result overflows a {@code long}.
+ *
+ * @param x the first value
+ * @param y the second value to subtract from the first
+ * @return the result
+ * @throws ArithmeticException if the result overflows a long
+ * @since 1.8
+ */
+ public static long subtractExact(long x, long y) {
+ CProver.notModelled();
+ return CProver.nondetLong();
+ // long r = x - y;
+ // // HD 2-12 Overflow iff the arguments have different signs and
+ // // the sign of the result is different than the sign of x
+ // if (((x ^ y) & (x ^ r)) < 0) {
+ // throw new ArithmeticException("long overflow");
+ // }
+ // return r;
+ }
+
+ /**
+ * Returns the product of the arguments,
+ * throwing an exception if the result overflows an {@code int}.
+ *
+ * @param x the first value
+ * @param y the second value
+ * @return the result
+ * @throws ArithmeticException if the result overflows an int
+ * @since 1.8
+ */
+ public static int multiplyExact(int x, int y) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // long r = (long)x * (long)y;
+ // if ((int)r != r) {
+ // throw new ArithmeticException("integer overflow");
+ // }
+ // return (int)r;
+ }
+
+ /**
+ * Returns the product of the arguments,
+ * throwing an exception if the result overflows a {@code long}.
+ *
+ * @param x the first value
+ * @param y the second value
+ * @return the result
+ * @throws ArithmeticException if the result overflows a long
+ * @since 1.8
+ */
+ public static long multiplyExact(long x, long y) {
+ CProver.notModelled();
+ return CProver.nondetLong();
+ // long r = x * y;
+ // long ax = Math.abs(x);
+ // long ay = Math.abs(y);
+ // if (((ax | ay) >>> 31 != 0)) {
+ // // Some bits greater than 2^31 that might cause overflow
+ // // Check the result using the divide operator
+ // // and check for the special case of Long.MIN_VALUE * -1
+ // if (((y != 0) && (r / y != x)) ||
+ // (x == Long.MIN_VALUE && y == -1)) {
+ // throw new ArithmeticException("long overflow");
+ // }
+ // }
+ // return r;
+ }
+
+ /**
+ * Returns the argument incremented by one, throwing an exception if the
+ * result overflows an {@code int}.
+ *
+ * @param a the value to increment
+ * @return the result
+ * @throws ArithmeticException if the result overflows an int
+ * @since 1.8
+ */
+ public static int incrementExact(int a) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // if (a == Integer.MAX_VALUE) {
+ // throw new ArithmeticException("integer overflow");
+ // }
+ //
+ // return a + 1;
+ }
+
+ /**
+ * Returns the argument incremented by one, throwing an exception if the
+ * result overflows a {@code long}.
+ *
+ * @param a the value to increment
+ * @return the result
+ * @throws ArithmeticException if the result overflows a long
+ * @since 1.8
+ */
+ public static long incrementExact(long a) {
+ CProver.notModelled();
+ return CProver.nondetLong();
+ // if (a == Long.MAX_VALUE) {
+ // throw new ArithmeticException("long overflow");
+ // }
+ //
+ // return a + 1L;
+ }
+
+ /**
+ * Returns the argument decremented by one, throwing an exception if the
+ * result overflows an {@code int}.
+ *
+ * @param a the value to decrement
+ * @return the result
+ * @throws ArithmeticException if the result overflows an int
+ * @since 1.8
+ */
+ public static int decrementExact(int a) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // if (a == Integer.MIN_VALUE) {
+ // throw new ArithmeticException("integer overflow");
+ // }
+ //
+ // return a - 1;
+ }
+
+ /**
+ * Returns the argument decremented by one, throwing an exception if the
+ * result overflows a {@code long}.
+ *
+ * @param a the value to decrement
+ * @return the result
+ * @throws ArithmeticException if the result overflows a long
+ * @since 1.8
+ */
+ public static long decrementExact(long a) {
+ CProver.notModelled();
+ return CProver.nondetLong();
+ // if (a == Long.MIN_VALUE) {
+ // throw new ArithmeticException("long overflow");
+ // }
+ //
+ // return a - 1L;
+ }
+
+ /**
+ * Returns the negation of the argument, throwing an exception if the
+ * result overflows an {@code int}.
+ *
+ * @param a the value to negate
+ * @return the result
+ * @throws ArithmeticException if the result overflows an int
+ * @since 1.8
+ */
+ public static int negateExact(int a) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // if (a == Integer.MIN_VALUE) {
+ // throw new ArithmeticException("integer overflow");
+ // }
+ //
+ // return -a;
+ }
+
+ /**
+ * Returns the negation of the argument, throwing an exception if the
+ * result overflows a {@code long}.
+ *
+ * @param a the value to negate
+ * @return the result
+ * @throws ArithmeticException if the result overflows a long
+ * @since 1.8
+ */
+ public static long negateExact(long a) {
+ CProver.notModelled();
+ return CProver.nondetLong();
+ // if (a == Long.MIN_VALUE) {
+ // throw new ArithmeticException("long overflow");
+ // }
+ //
+ // return -a;
+ }
+
+ /**
+ * Returns the value of the {@code long} argument;
+ * throwing an exception if the value overflows an {@code int}.
+ *
+ * @param value the long value
+ * @return the argument as an int
+ * @throws ArithmeticException if the {@code argument} overflows an int
+ * @since 1.8
+ */
+ public static int toIntExact(long value) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // if ((int)value != value) {
+ // throw new ArithmeticException("integer overflow");
+ // }
+ // return (int)value;
+ }
+
+ /**
+ * Returns the largest (closest to positive infinity)
+ * {@code int} value that is less than or equal to the algebraic quotient.
+ * There is one special case, if the dividend is the
+ * {@linkplain Integer#MIN_VALUE Integer.MIN_VALUE} and the divisor is {@code -1},
+ * then integer overflow occurs and
+ * the result is equal to the {@code Integer.MIN_VALUE}.
+ * <p>
+ * Normal integer division operates under the round to zero rounding mode
+ * (truncation). This operation instead acts under the round toward
+ * negative infinity (floor) rounding mode.
+ * The floor rounding mode gives different results than truncation
+ * when the exact result is negative.
+ * <ul>
+ * <li>If the signs of the arguments are the same, the results of
+ * {@code floorDiv} and the {@code /} operator are the same. <br>
+ * For example, {@code floorDiv(4, 3) == 1} and {@code (4 / 3) == 1}.</li>
+ * <li>If the signs of the arguments are different, the quotient is negative and
+ * {@code floorDiv} returns the integer less than or equal to the quotient
+ * and the {@code /} operator returns the integer closest to zero.<br>
+ * For example, {@code floorDiv(-4, 3) == -2},
+ * whereas {@code (-4 / 3) == -1}.
+ * </li>
+ * </ul>
+ * <p>
+ *
+ * @param x the dividend
+ * @param y the divisor
+ * @return the largest (closest to positive infinity)
+ * {@code int} value that is less than or equal to the algebraic quotient.
+ * @throws ArithmeticException if the divisor {@code y} is zero
+ * @see #floorMod(int, int)
+ * @see #floor(double)
+ * @since 1.8
+ */
+ public static int floorDiv(int x, int y) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // int r = x / y;
+ // // if the signs are different and modulo not zero, round down
+ // if ((x ^ y) < 0 && (r * y != x)) {
+ // r--;
+ // }
+ // return r;
+ }
+
+ /**
+ * Returns the largest (closest to positive infinity)
+ * {@code long} value that is less than or equal to the algebraic quotient.
+ * There is one special case, if the dividend is the
+ * {@linkplain Long#MIN_VALUE Long.MIN_VALUE} and the divisor is {@code -1},
+ * then integer overflow occurs and
+ * the result is equal to the {@code Long.MIN_VALUE}.
+ * <p>
+ * Normal integer division operates under the round to zero rounding mode
+ * (truncation). This operation instead acts under the round toward
+ * negative infinity (floor) rounding mode.
+ * The floor rounding mode gives different results than truncation
+ * when the exact result is negative.
+ * <p>
+ * For examples, see {@link #floorDiv(int, int)}.
+ *
+ * @param x the dividend
+ * @param y the divisor
+ * @return the largest (closest to positive infinity)
+ * {@code long} value that is less than or equal to the algebraic quotient.
+ * @throws ArithmeticException if the divisor {@code y} is zero
+ * @see #floorMod(long, long)
+ * @see #floor(double)
+ * @since 1.8
+ */
+ public static long floorDiv(long x, long y) {
+ CProver.notModelled();
+ return CProver.nondetLong();
+ // long r = x / y;
+ // // if the signs are different and modulo not zero, round down
+ // if ((x ^ y) < 0 && (r * y != x)) {
+ // r--;
+ // }
+ // return r;
+ }
+
+ /**
+ * Returns the floor modulus of the {@code int} arguments.
+ * <p>
+ * The floor modulus is {@code x - (floorDiv(x, y) * y)},
+ * has the same sign as the divisor {@code y}, and
+ * is in the range of {@code -abs(y) < r < +abs(y)}.
+ *
+ * <p>
+ * The relationship between {@code floorDiv} and {@code floorMod} is such that:
+ * <ul>
+ * <li>{@code floorDiv(x, y) * y + floorMod(x, y) == x}
+ * </ul>
+ * <p>
+ * The difference in values between {@code floorMod} and
+ * the {@code %} operator is due to the difference between
+ * {@code floorDiv} that returns the integer less than or equal to the quotient
+ * and the {@code /} operator that returns the integer closest to zero.
+ * <p>
+ * Examples:
+ * <ul>
+ * <li>If the signs of the arguments are the same, the results
+ * of {@code floorMod} and the {@code %} operator are the same. <br>
+ * <ul>
+ * <li>{@code floorMod(4, 3) == 1}; and {@code (4 % 3) == 1}</li>
+ * </ul>
+ * <li>If the signs of the arguments are different, the results differ from the {@code %} operator.<br>
+ * <ul>
+ * <li>{@code floorMod(+4, -3) == -2}; and {@code (+4 % -3) == +1} </li>
+ * <li>{@code floorMod(-4, +3) == +2}; and {@code (-4 % +3) == -1} </li>
+ * <li>{@code floorMod(-4, -3) == -1}; and {@code (-4 % -3) == -1 } </li>
+ * </ul>
+ * </li>
+ * </ul>
+ * <p>
+ * If the signs of arguments are unknown and a positive modulus
+ * is needed it can be computed as {@code (floorMod(x, y) + abs(y)) % abs(y)}.
+ *
+ * @param x the dividend
+ * @param y the divisor
+ * @return the floor modulus {@code x - (floorDiv(x, y) * y)}
+ * @throws ArithmeticException if the divisor {@code y} is zero
+ * @see #floorDiv(int, int)
+ * @since 1.8
+ */
+ public static int floorMod(int x, int y) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // int r = x - floorDiv(x, y) * y;
+ // return r;
+ }
+
+ /**
+ * Returns the floor modulus of the {@code long} arguments.
+ * <p>
+ * The floor modulus is {@code x - (floorDiv(x, y) * y)},
+ * has the same sign as the divisor {@code y}, and
+ * is in the range of {@code -abs(y) < r < +abs(y)}.
+ *
+ * <p>
+ * The relationship between {@code floorDiv} and {@code floorMod} is such that:
+ * <ul>
+ * <li>{@code floorDiv(x, y) * y + floorMod(x, y) == x}
+ * </ul>
+ * <p>
+ * For examples, see {@link #floorMod(int, int)}.
+ *
+ * @param x the dividend
+ * @param y the divisor
+ * @return the floor modulus {@code x - (floorDiv(x, y) * y)}
+ * @throws ArithmeticException if the divisor {@code y} is zero
+ * @see #floorDiv(long, long)
+ * @since 1.8
+ */
+ public static long floorMod(long x, long y) {
+ CProver.notModelled();
+ return CProver.nondetLong();
+ // return x - floorDiv(x, y) * y;
+ }
+
+ /**
+ * Returns the absolute value of an {@code int} value.
+ * If the argument is not negative, the argument is returned.
+ * If the argument is negative, the negation of the argument is returned.
+ *
+ * <p>Note that if the argument is equal to the value of
+ * {@link Integer#MIN_VALUE}, the most negative representable
+ * {@code int} value, the result is that same value, which is
+ * negative.
+ *
+ * @param a the argument whose absolute value is to be determined
+ * @return the absolute value of the argument.
+ */
+ public static int abs(int a) {
+ CProver.notModelled();
+ return CProver.nondetInt();
+ // return (a < 0) ? -a : a;
+ }
+
+ /**
+ * Returns the absolute value of a {@code long} value.
+ * If the argument is not negative, the argument is returned.
+ * If the argument is negative, the negation of the argument is returned.
+ *
+ * <p>Note that if the argument is equal to the value of
+ * {@link Long#MIN_VALUE}, the most negative representable
+ * {@code long} value, the result is that same value, which
+ * is negative.
+ *
+ * @param a the argument whose absolute value is to be determined
+ * @return the absolute value of the argument.
+ */
+ public static long abs(long a) {
+ CProver.notModelled();
+ return CProver.nondetLong();
+ // return (a < 0) ? -a : a;
+ }
+
+ /**
+ * Returns the absolute value of a {@code float} value.
+ * If the argument is not negative, the argument is returned.
+ * If the argument is negative, the negation of the argument is returned.
+ * Special cases:
+ * <ul><li>If the argument is positive zero or negative zero, the
+ * result is positive zero.
+ * <li>If the argument is infinite, the result is positive infinity.
+ * <li>If the argument is NaN, the result is NaN.</ul>
+ * In other words, the result is the same as the value of the expression:
+ * <p>{@code Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))}
+ *
+ * @param a the argument whose absolute value is to be determined
+ * @return the absolute value of the argument.
+ */
+ public static float abs(float a) {
+ CProver.notModelled();
+ return CProver.nondetFloat();
+ // return (a <= 0.0F) ? 0.0F - a : a;
+ }
+
+ /**
+ * Returns the absolute value of a {@code double} value.
+ * If the argument is not negative, the argument is returned.
+ * If the argument is negative, the negation of the argument is returned.
+ * Special cases:
+ * <ul><li>If the argument is positive zero or negative zero, the result
+ * is positive zero.
+ * <li>If the argument is infinite, the result is positive infinity.
+ * <li>If the argument is NaN, the result is NaN.</ul>
+ * In other words, the result is the same as the value of the expression:
+ * <p>{@code Double.longBitsToDouble((Double.doubleToLongBits(a)<<1)>>>1)}
+ *
+ * @param a the argument whose absolute value is to be determined
+ * @return the absolute value of the argument.
+ */
+ public static double abs(double a) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return (a <= 0.0D) ? 0.0D - a : a;
+ }
+
+ /**
+ * Returns the greater of two {@code int} values. That is, the
+ * result is the argument closer to the value of
+ * {@link Integer#MAX_VALUE}. If the arguments have the same value,
+ * the result is that same value.
+ *
+ * @param a an argument.
+ * @param b another argument.
+ * @return the larger of {@code a} and {@code b}.
+ */
+ public static int max(int a, int b) {
+ // return (a >= b) ? a : b;
+ int result = CProver.nondetInt();
+ CProver.assume((result == a || result == b) && result >= a && result >= b);
+ return result;
+ }
+
+ /**
+ * Returns the greater of two {@code long} values. That is, the
+ * result is the argument closer to the value of
+ * {@link Long#MAX_VALUE}. If the arguments have the same value,
+ * the result is that same value.
+ *
+ * @param a an argument.
+ * @param b another argument.
+ * @return the larger of {@code a} and {@code b}.
+ */
+ public static long max(long a, long b) {
+ // return (a >= b) ? a : b;
+ long result = CProver.nondetLong();
+ CProver.assume((result == a || result == b) && result >= a && result >= b);
+ return result;
+ }
+
+ // Use raw bit-wise conversions on guaranteed non-NaN arguments.
+ private static long negativeZeroFloatBits = Float.floatToRawIntBits(-0.0f);
+ private static long negativeZeroDoubleBits = Double.doubleToRawLongBits(-0.0d);
+
+ /**
+ * Returns the greater of two {@code float} values. That is,
+ * the result is the argument closer to positive infinity. If the
+ * arguments have the same value, the result is that same
+ * value. If either value is NaN, then the result is NaN. Unlike
+ * the numerical comparison operators, this method considers
+ * negative zero to be strictly smaller than positive zero. If one
+ * argument is positive zero and the other negative zero, the
+ * result is positive zero.
+ *
+ * @param a an argument.
+ * @param b another argument.
+ * @return the larger of {@code a} and {@code b}.
+ */
+ public static float max(float a, float b) {
+ // if (a != a)
+ // return a; // a is NaN
+ // if ((a == 0.0f) &&
+ // (b == 0.0f) &&
+ // (Float.floatToRawIntBits(a) == negativeZeroFloatBits)) {
+ // // Raw conversion ok since NaN can't map to -0.0.
+ // return b;
+ // }
+ // return (a >= b) ? a : b;
+ if (Float.isNaN(a) || Float.isNaN(b)) {
+ return Float.NaN;
+ } else {
+ float result = CProver.nondetFloat();
+ CProver.assume((result == a || result == b) && result >= a && result >= b);
+ return result;
+ }
+ }
+
+ /**
+ * Returns the greater of two {@code double} values. That
+ * is, the result is the argument closer to positive infinity. If
+ * the arguments have the same value, the result is that same
+ * value. If either value is NaN, then the result is NaN. Unlike
+ * the numerical comparison operators, this method considers
+ * negative zero to be strictly smaller than positive zero. If one
+ * argument is positive zero and the other negative zero, the
+ * result is positive zero.
+ *
+ * @param a an argument.
+ * @param b another argument.
+ * @return the larger of {@code a} and {@code b}.
+ */
+ public static double max(double a, double b) {
+ // if (a != a)
+ // return a; // a is NaN
+ // if ((a == 0.0d) &&
+ // (b == 0.0d) &&
+ // (Double.doubleToRawLongBits(a) == negativeZeroDoubleBits)) {
+ // // Raw conversion ok since NaN can't map to -0.0.
+ // return b;
+ // }
+ // return (a >= b) ? a : b;
+ if (Double.isNaN(a) || Double.isNaN(b)) {
+ return Double.NaN;
+ } else {
+ double result = CProver.nondetDouble();
+ CProver.assume((result == a || result == b) && result >= a && result >= b);
+ return result;
+ }
+ }
+
+ /**
+ * Returns the smaller of two {@code int} values. That is,
+ * the result the argument closer to the value of
+ * {@link Integer#MIN_VALUE}. If the arguments have the same
+ * value, the result is that same value.
+ *
+ * @param a an argument.
+ * @param b another argument.
+ * @return the smaller of {@code a} and {@code b}.
+ */
+ public static int min(int a, int b) {
+ // return (a <= b) ? a : b;
+ int result = CProver.nondetInt();
+ CProver.assume((result == a || result == b) && result <= a && result <= b);
+ return result;
+ }
+
+ /**
+ * Returns the smaller of two {@code long} values. That is,
+ * the result is the argument closer to the value of
+ * {@link Long#MIN_VALUE}. If the arguments have the same
+ * value, the result is that same value.
+ *
+ * @param a an argument.
+ * @param b another argument.
+ * @return the smaller of {@code a} and {@code b}.
+ */
+ public static long min(long a, long b) {
+ // return (a <= b) ? a : b;
+ long result = CProver.nondetLong();
+ CProver.assume((result == a || result == b) && result <= a && result <= b);
+ return result;
+ }
+
+ /**
+ * Returns the smaller of two {@code float} values. That is,
+ * the result is the value closer to negative infinity. If the
+ * arguments have the same value, the result is that same
+ * value. If either value is NaN, then the result is NaN. Unlike
+ * the numerical comparison operators, this method considers
+ * negative zero to be strictly smaller than positive zero. If
+ * one argument is positive zero and the other is negative zero,
+ * the result is negative zero.
+ *
+ * @param a an argument.
+ * @param b another argument.
+ * @return the smaller of {@code a} and {@code b}.
+ */
+ public static float min(float a, float b) {
+ // if (a != a)
+ // return a; // a is NaN
+ // if ((a == 0.0f) &&
+ // (b == 0.0f) &&
+ // (Float.floatToRawIntBits(b) == negativeZeroFloatBits)) {
+ // // Raw conversion ok since NaN can't map to -0.0.
+ // return b;
+ // }
+ // return (a <= b) ? a : b;
+ if (Float.isNaN(a) || Float.isNaN(b)) {
+ return Float.NaN;
+ } else {
+ float result = CProver.nondetFloat();
+ CProver.assume((result == a || result == b) && result <= a && result <= b);
+ return result;
+ }
+ }
+
+ /**
+ * Returns the smaller of two {@code double} values. That
+ * is, the result is the value closer to negative infinity. If the
+ * arguments have the same value, the result is that same
+ * value. If either value is NaN, then the result is NaN. Unlike
+ * the numerical comparison operators, this method considers
+ * negative zero to be strictly smaller than positive zero. If one
+ * argument is positive zero and the other is negative zero, the
+ * result is negative zero.
+ *
+ * @param a an argument.
+ * @param b another argument.
+ * @return the smaller of {@code a} and {@code b}.
+ */
+ public static double min(double a, double b) {
+ // if (a != a)
+ // return a; // a is NaN
+ // if ((a == 0.0d) &&
+ // (b == 0.0d) &&
+ // (Double.doubleToRawLongBits(b) == negativeZeroDoubleBits)) {
+ // // Raw conversion ok since NaN can't map to -0.0.
+ // return b;
+ // }
+ // return (a <= b) ? a : b;
+ if (Double.isNaN(a) || Double.isNaN(b)) {
+ return Double.NaN;
+ } else {
+ double result = CProver.nondetDouble();
+ CProver.assume((result == a || result == b) && result <= a && result <= b);
+ return result;
+ }
+ }
+
+ /**
+ * Returns the size of an ulp of the argument. An ulp, unit in
+ * the last place, of a {@code double} value is the positive
+ * distance between this floating-point value and the {@code
+ * double} value next larger in magnitude. Note that for non-NaN
+ * <i>x</i>, <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.
+ *
+ * <p>Special Cases:
+ * <ul>
+ * <li> If the argument is NaN, then the result is NaN.
+ * <li> If the argument is positive or negative infinity, then the
+ * result is positive infinity.
+ * <li> If the argument is positive or negative zero, then the result is
+ * {@code Double.MIN_VALUE}.
+ * <li> If the argument is ±{@code Double.MAX_VALUE}, then
+ * the result is equal to 2<sup>971</sup>.
+ * </ul>
+ *
+ * @param d the floating-point value whose ulp is to be returned
+ * @return the size of an ulp of the argument
+ * @author Joseph D. Darcy
+ * @since 1.5
+ */
+ public static double ulp(double d) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // int exp = getExponent(d);
+ //
+ // switch(exp) {
+ // case DoubleConsts.MAX_EXPONENT+1: // NaN or infinity
+ // return Math.abs(d);
+ //
+ // case DoubleConsts.MIN_EXPONENT-1: // zero or subnormal
+ // return Double.MIN_VALUE;
+ //
+ // default:
+ // assert exp <= DoubleConsts.MAX_EXPONENT && exp >= DoubleConsts.MIN_EXPONENT;
+ //
+ // // ulp(x) is usually 2^(SIGNIFICAND_WIDTH-1)*(2^ilogb(x))
+ // exp = exp - (DoubleConsts.SIGNIFICAND_WIDTH-1);
+ // if (exp >= DoubleConsts.MIN_EXPONENT) {
+ // return powerOfTwoD(exp);
+ // }
+ // else {
+ // // return a subnormal result; left shift integer
+ // // representation of Double.MIN_VALUE appropriate
+ // // number of positions
+ // return Double.longBitsToDouble(1L <<
+ // (exp - (DoubleConsts.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1)) ));
+ // }
+ // }
+ }
+
+ /**
+ * Returns the size of an ulp of the argument. An ulp, unit in
+ * the last place, of a {@code float} value is the positive
+ * distance between this floating-point value and the {@code
+ * float} value next larger in magnitude. Note that for non-NaN
+ * <i>x</i>, <code>ulp(-<i>x</i>) == ulp(<i>x</i>)</code>.
+ *
+ * <p>Special Cases:
+ * <ul>
+ * <li> If the argument is NaN, then the result is NaN.
+ * <li> If the argument is positive or negative infinity, then the
+ * result is positive infinity.
+ * <li> If the argument is positive or negative zero, then the result is
+ * {@code Float.MIN_VALUE}.
+ * <li> If the argument is ±{@code Float.MAX_VALUE}, then
+ * the result is equal to 2<sup>104</sup>.
+ * </ul>
+ *
+ * @param f the floating-point value whose ulp is to be returned
+ * @return the size of an ulp of the argument
+ * @author Joseph D. Darcy
+ * @since 1.5
+ */
+ public static float ulp(float f) {
+ CProver.notModelled();
+ return CProver.nondetFloat();
+ // int exp = getExponent(f);
+ //
+ // switch(exp) {
+ // case FloatConsts.MAX_EXPONENT+1: // NaN or infinity
+ // return Math.abs(f);
+ //
+ // case FloatConsts.MIN_EXPONENT-1: // zero or subnormal
+ // return FloatConsts.MIN_VALUE;
+ //
+ // default:
+ // assert exp <= FloatConsts.MAX_EXPONENT && exp >= FloatConsts.MIN_EXPONENT;
+ //
+ // // ulp(x) is usually 2^(SIGNIFICAND_WIDTH-1)*(2^ilogb(x))
+ // exp = exp - (FloatConsts.SIGNIFICAND_WIDTH-1);
+ // if (exp >= FloatConsts.MIN_EXPONENT) {
+ // return powerOfTwoF(exp);
+ // }
+ // else {
+ // // return a subnormal result; left shift integer
+ // // representation of FloatConsts.MIN_VALUE appropriate
+ // // number of positions
+ // return Float.intBitsToFloat(1 <<
+ // (exp - (FloatConsts.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1)) ));
+ // }
+ // }
+ }
+
+ /**
+ * Returns the signum function of the argument; zero if the argument
+ * is zero, 1.0 if the argument is greater than zero, -1.0 if the
+ * argument is less than zero.
+ *
+ * <p>Special Cases:
+ * <ul>
+ * <li> If the argument is NaN, then the result is NaN.
+ * <li> If the argument is positive zero or negative zero, then the
+ * result is the same as the argument.
+ * </ul>
+ *
+ * @param d the floating-point value whose signum is to be returned
+ * @return the signum function of the argument
+ * @author Joseph D. Darcy
+ * @since 1.5
+ */
+ public static double signum(double d) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return (d == 0.0 || Double.isNaN(d))?d:copySign(1.0, d);
+ }
+
+ /**
+ * Returns the signum function of the argument; zero if the argument
+ * is zero, 1.0f if the argument is greater than zero, -1.0f if the
+ * argument is less than zero.
+ *
+ * <p>Special Cases:
+ * <ul>
+ * <li> If the argument is NaN, then the result is NaN.
+ * <li> If the argument is positive zero or negative zero, then the
+ * result is the same as the argument.
+ * </ul>
+ *
+ * @param f the floating-point value whose signum is to be returned
+ * @return the signum function of the argument
+ * @author Joseph D. Darcy
+ * @since 1.5
+ */
+ public static float signum(float f) {
+ CProver.notModelled();
+ return CProver.nondetFloat();
+ // return (f == 0.0f || Float.isNaN(f))?f:copySign(1.0f, f);
+ }
+
+ /**
+ * Returns the hyperbolic sine of a {@code double} value.
+ * The hyperbolic sine of <i>x</i> is defined to be
+ * (<i>e<sup>x</sup> - e<sup>-x</sup></i>)/2
+ * where <i>e</i> is {@linkplain Math#E Euler's number}.
+ *
+ * <p>Special cases:
+ * <ul>
+ *
+ * <li>If the argument is NaN, then the result is NaN.
+ *
+ * <li>If the argument is infinite, then the result is an infinity
+ * with the same sign as the argument.
+ *
+ * <li>If the argument is zero, then the result is a zero with the
+ * same sign as the argument.
+ *
+ * </ul>
+ *
+ * <p>The computed result must be within 2.5 ulps of the exact result.
+ *
+ * @param x The number whose hyperbolic sine is to be returned.
+ * @return The hyperbolic sine of {@code x}.
+ * @since 1.5
+ */
+ public static double sinh(double x) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.sinh(x);
+ }
+
+ /**
+ * Returns the hyperbolic cosine of a {@code double} value.
+ * The hyperbolic cosine of <i>x</i> is defined to be
+ * (<i>e<sup>x</sup> + e<sup>-x</sup></i>)/2
+ * where <i>e</i> is {@linkplain Math#E Euler's number}.
+ *
+ * <p>Special cases:
+ * <ul>
+ *
+ * <li>If the argument is NaN, then the result is NaN.
+ *
+ * <li>If the argument is infinite, then the result is positive
+ * infinity.
+ *
+ * <li>If the argument is zero, then the result is {@code 1.0}.
+ *
+ * </ul>
+ *
+ * <p>The computed result must be within 2.5 ulps of the exact result.
+ *
+ * @param x The number whose hyperbolic cosine is to be returned.
+ * @return The hyperbolic cosine of {@code x}.
+ * @since 1.5
+ */
+ public static double cosh(double x) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.cosh(x);
+ }
+
+ /**
+ * Returns the hyperbolic tangent of a {@code double} value.
+ * The hyperbolic tangent of <i>x</i> is defined to be
+ * (<i>e<sup>x</sup> - e<sup>-x</sup></i>)/(<i>e<sup>x</sup> + e<sup>-x</sup></i>),
+ * in other words, {@linkplain Math#sinh
+ * sinh(<i>x</i>)}/{@linkplain Math#cosh cosh(<i>x</i>)}. Note
+ * that the absolute value of the exact tanh is always less than
+ * 1.
+ *
+ * <p>Special cases:
+ * <ul>
+ *
+ * <li>If the argument is NaN, then the result is NaN.
+ *
+ * <li>If the argument is zero, then the result is a zero with the
+ * same sign as the argument.
+ *
+ * <li>If the argument is positive infinity, then the result is
+ * {@code +1.0}.
+ *
+ * <li>If the argument is negative infinity, then the result is
+ * {@code -1.0}.
+ *
+ * </ul>
+ *
+ * <p>The computed result must be within 2.5 ulps of the exact result.
+ * The result of {@code tanh} for any finite input must have
+ * an absolute value less than or equal to 1. Note that once the
+ * exact result of tanh is within 1/2 of an ulp of the limit value
+ * of ±1, correctly signed ±{@code 1.0} should
+ * be returned.
+ *
+ * @param x The number whose hyperbolic tangent is to be returned.
+ * @return The hyperbolic tangent of {@code x}.
+ * @since 1.5
+ */
+ public static double tanh(double x) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.tanh(x);
+ }
+
+ /**
+ * Returns sqrt(<i>x</i><sup>2</sup> +<i>y</i><sup>2</sup>)
+ * without intermediate overflow or underflow.
+ *
+ * <p>Special cases:
+ * <ul>
+ *
+ * <li> If either argument is infinite, then the result
+ * is positive infinity.
+ *
+ * <li> If either argument is NaN and neither argument is infinite,
+ * then the result is NaN.
+ *
+ * </ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact
+ * result. If one parameter is held constant, the results must be
+ * semi-monotonic in the other parameter.
+ *
+ * @param x a value
+ * @param y a value
+ * @return sqrt(<i>x</i><sup>2</sup> +<i>y</i><sup>2</sup>)
+ * without intermediate overflow or underflow
+ * @since 1.5
+ */
+ public static double hypot(double x, double y) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.hypot(x, y);
+ }
+
+ /**
+ * Returns <i>e</i><sup>x</sup> -1. Note that for values of
+ * <i>x</i> near 0, the exact sum of
+ * {@code expm1(x)} + 1 is much closer to the true
+ * result of <i>e</i><sup>x</sup> than {@code exp(x)}.
+ *
+ * <p>Special cases:
+ * <ul>
+ * <li>If the argument is NaN, the result is NaN.
+ *
+ * <li>If the argument is positive infinity, then the result is
+ * positive infinity.
+ *
+ * <li>If the argument is negative infinity, then the result is
+ * -1.0.
+ *
+ * <li>If the argument is zero, then the result is a zero with the
+ * same sign as the argument.
+ *
+ * </ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic. The result of
+ * {@code expm1} for any finite input must be greater than or
+ * equal to {@code -1.0}. Note that once the exact result of
+ * <i>e</i><sup>{@code x}</sup> - 1 is within 1/2
+ * ulp of the limit value -1, {@code -1.0} should be
+ * returned.
+ *
+ * @param x the exponent to raise <i>e</i> to in the computation of
+ * <i>e</i><sup>{@code x}</sup> -1.
+ * @return the value <i>e</i><sup>{@code x}</sup> - 1.
+ * @since 1.5
+ */
+ public static double expm1(double x) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.expm1(x);
+ }
+
+ /**
+ * Returns the natural logarithm of the sum of the argument and 1.
+ * Note that for small values {@code x}, the result of
+ * {@code log1p(x)} is much closer to the true result of ln(1
+ * + {@code x}) than the floating-point evaluation of
+ * {@code log(1.0+x)}.
+ *
+ * <p>Special cases:
+ *
+ * <ul>
+ *
+ * <li>If the argument is NaN or less than -1, then the result is
+ * NaN.
+ *
+ * <li>If the argument is positive infinity, then the result is
+ * positive infinity.
+ *
+ * <li>If the argument is negative one, then the result is
+ * negative infinity.
+ *
+ * <li>If the argument is zero, then the result is a zero with the
+ * same sign as the argument.
+ *
+ * </ul>
+ *
+ * <p>The computed result must be within 1 ulp of the exact result.
+ * Results must be semi-monotonic.
+ *
+ * @param x a value
+ * @return the value ln({@code x} + 1), the natural
+ * log of {@code x} + 1
+ * @since 1.5
+ */
+ public static double log1p(double x) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return StrictMath.log1p(x);
+ }
+
+ /**
+ * Returns the first floating-point argument with the sign of the
+ * second floating-point argument. Note that unlike the {@link
+ * StrictMath#copySign(double, double) StrictMath.copySign}
+ * method, this method does not require NaN {@code sign}
+ * arguments to be treated as positive values; implementations are
+ * permitted to treat some NaN arguments as positive and other NaN
+ * arguments as negative to allow greater performance.
+ *
+ * @param magnitude the parameter providing the magnitude of the result
+ * @param sign the parameter providing the sign of the result
+ * @return a value with the magnitude of {@code magnitude}
+ * and the sign of {@code sign}.
+ * @since 1.6
+ */
+ public static double copySign(double magnitude, double sign) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ // return Double.longBitsToDouble((Double.doubleToRawLongBits(sign) &
+ // (DoubleConsts.SIGN_BIT_MASK)) |
+ // (Double.doubleToRawLongBits(magnitude) &
+ // (DoubleConsts.EXP_BIT_MASK |
+ // DoubleConsts.SIGNIF_BIT_MASK)));
+ }
+
+ /**
+ * Returns the first floating-point argument with the sign of the
+ * second floating-point argument. Note that unlike the {@link
+ * StrictMath#copySign(float, float) StrictMath.copySign}
+ * method, this method does not require NaN {@code sign}
+ * arguments to be treated as positive values; implementations are
+ * permitted to treat some NaN arguments as positive and other NaN
+ * arguments as negative to allow greater performance.
+ *
+ * @param magnitude the parameter providing the magnitude of the result
+ * @param sign the parameter providing the sign of the result
+ * @return a value with the magnitude of {@code magnitude}
+ * and the sign of {@code sign}.
+ * @since 1.6
+ */
+ public static float copySign(float magnitude, float sign) {
+ CProver.notModelled();
+ return CProver.nondetFloat();
+ // return Float.intBitsToFloat((Float.floatToRawIntBits(sign) &
+ // (FloatConsts.SIGN_BIT_MASK)) |
+ // (Float.floatToRawIntBits(magnitude) &
+ // (FloatConsts.EXP_BIT_MASK |
+ // FloatConsts.SIGNIF_BIT_MASK)));
+ }
+
+ /**
+ * Returns the unbiased exponent used in the representation of a
+ * {@code float}. Special cases:
+ *
+ * <ul>
+ * <li>If the argument is NaN or infinite, then the result is
+ * {@link Float#MAX_EXPONENT} + 1.
+ * <li>If the argument is zero or subnormal, then the result is
+ * {@link Float#MIN_EXPONENT} -1.
+ * </ul>
+ * @param f a {@code float} value
+ * @return the unbiased exponent of the argument
+ * @since 1.6
+ */
+ public static int getExponent(float f) {
+ /*
+ * Bitwise convert f to integer, mask out exponent bits, shift
+ * to the right and then subtract out float's bias adjust to
+ * get true exponent value
+ */
+ // return ((Float.floatToRawIntBits(f) & FloatConsts.EXP_BIT_MASK) >>
+ // (FloatConsts.SIGNIFICAND_WIDTH - 1)) - FloatConsts.EXP_BIAS;
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * Returns the unbiased exponent used in the representation of a
+ * {@code double}. Special cases:
+ *
+ * <ul>
+ * <li>If the argument is NaN or infinite, then the result is
+ * {@link Double#MAX_EXPONENT} + 1.
+ * <li>If the argument is zero or subnormal, then the result is
+ * {@link Double#MIN_EXPONENT} -1.
+ * </ul>
+ * @param d a {@code double} value
+ * @return the unbiased exponent of the argument
+ * @since 1.6
+ */
+ public static int getExponent(double d) {
+ /*
+ * Bitwise convert d to long, mask out exponent bits, shift
+ * to the right and then subtract out double's bias adjust to
+ * get true exponent value.
+ */
+ // return (int)(((Double.doubleToRawLongBits(d) & DoubleConsts.EXP_BIT_MASK) >>
+ // (DoubleConsts.SIGNIFICAND_WIDTH - 1)) - DoubleConsts.EXP_BIAS);
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * Returns the floating-point number adjacent to the first
+ * argument in the direction of the second argument. If both
+ * arguments compare as equal the second argument is returned.
+ *
+ * <p>
+ * Special cases:
+ * <ul>
+ * <li> If either argument is a NaN, then NaN is returned.
+ *
+ * <li> If both arguments are signed zeros, {@code direction}
+ * is returned unchanged (as implied by the requirement of
+ * returning the second argument if the arguments compare as
+ * equal).
+ *
+ * <li> If {@code start} is
+ * ±{@link Double#MIN_VALUE} and {@code direction}
+ * has a value such that the result should have a smaller
+ * magnitude, then a zero with the same sign as {@code start}
+ * is returned.
+ *
+ * <li> If {@code start} is infinite and
+ * {@code direction} has a value such that the result should
+ * have a smaller magnitude, {@link Double#MAX_VALUE} with the
+ * same sign as {@code start} is returned.
+ *
+ * <li> If {@code start} is equal to ±
+ * {@link Double#MAX_VALUE} and {@code direction} has a
+ * value such that the result should have a larger magnitude, an
+ * infinity with same sign as {@code start} is returned.
+ * </ul>
+ *
+ * @param start starting floating-point value
+ * @param direction value indicating which of
+ * {@code start}'s neighbors or {@code start} should
+ * be returned
+ * @return The floating-point number adjacent to {@code start} in the
+ * direction of {@code direction}.
+ * @since 1.6
+ */
+ public static double nextAfter(double start, double direction) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ /*
+ * The cases:
+ *
+ * nextAfter(+infinity, 0) == MAX_VALUE
+ * nextAfter(+infinity, +infinity) == +infinity
+ * nextAfter(-infinity, 0) == -MAX_VALUE
+ * nextAfter(-infinity, -infinity) == -infinity
+ *
+ * are naturally handled without any additional testing
+ */
+
+ // First check for NaN values
+ // if (Double.isNaN(start) || Double.isNaN(direction)) {
+ // // return a NaN derived from the input NaN(s)
+ // return start + direction;
+ // } else if (start == direction) {
+ // return direction;
+ // } else { // start > direction or start < direction
+ // // Add +0.0 to get rid of a -0.0 (+0.0 + -0.0 => +0.0)
+ // // then bitwise convert start to integer.
+ // long transducer = Double.doubleToRawLongBits(start + 0.0d);
+ //
+ // /*
+ // * IEEE 754 floating-point numbers are lexicographically
+ // * ordered if treated as signed- magnitude integers .
+ // * Since Java's integers are two's complement,
+ // * incrementing" the two's complement representation of a
+ // * logically negative floating-point value *decrements*
+ // * the signed-magnitude representation. Therefore, when
+ // * the integer representation of a floating-point values
+ // * is less than zero, the adjustment to the representation
+ // * is in the opposite direction than would be expected at
+ // * first .
+ // */
+ // if (direction > start) { // Calculate next greater value
+ // transducer = transducer + (transducer >= 0L ? 1L:-1L);
+ // } else { // Calculate next lesser value
+ // assert direction < start;
+ // if (transducer > 0L)
+ // --transducer;
+ // else
+ // if (transducer < 0L )
+ // ++transducer;
+ // /*
+ // * transducer==0, the result is -MIN_VALUE
+ // *
+ // * The transition from zero (implicitly
+ // * positive) to the smallest negative
+ // * signed magnitude value must be done
+ // * explicitly.
+ // */
+ // else
+ // transducer = DoubleConsts.SIGN_BIT_MASK | 1L;
+ // }
+ //
+ // return Double.longBitsToDouble(transducer);
+ // }
+ }
+
+ /**
+ * Returns the floating-point number adjacent to the first
+ * argument in the direction of the second argument. If both
+ * arguments compare as equal a value equivalent to the second argument
+ * is returned.
+ *
+ * <p>
+ * Special cases:
+ * <ul>
+ * <li> If either argument is a NaN, then NaN is returned.
+ *
+ * <li> If both arguments are signed zeros, a value equivalent
+ * to {@code direction} is returned.
+ *
+ * <li> If {@code start} is
+ * ±{@link Float#MIN_VALUE} and {@code direction}
+ * has a value such that the result should have a smaller
+ * magnitude, then a zero with the same sign as {@code start}
+ * is returned.
+ *
+ * <li> If {@code start} is infinite and
+ * {@code direction} has a value such that the result should
+ * have a smaller magnitude, {@link Float#MAX_VALUE} with the
+ * same sign as {@code start} is returned.
+ *
+ * <li> If {@code start} is equal to ±
+ * {@link Float#MAX_VALUE} and {@code direction} has a
+ * value such that the result should have a larger magnitude, an
+ * infinity with same sign as {@code start} is returned.
+ * </ul>
+ *
+ * @param start starting floating-point value
+ * @param direction value indicating which of
+ * {@code start}'s neighbors or {@code start} should
+ * be returned
+ * @return The floating-point number adjacent to {@code start} in the
+ * direction of {@code direction}.
+ * @since 1.6
+ */
+ public static float nextAfter(float start, double direction) {
+ CProver.notModelled();
+ return CProver.nondetFloat();
+ /*
+ * The cases:
+ *
+ * nextAfter(+infinity, 0) == MAX_VALUE
+ * nextAfter(+infinity, +infinity) == +infinity
+ * nextAfter(-infinity, 0) == -MAX_VALUE
+ * nextAfter(-infinity, -infinity) == -infinity
+ *
+ * are naturally handled without any additional testing
+ */
+
+ // First check for NaN values
+ // if (Float.isNaN(start) || Double.isNaN(direction)) {
+ // // return a NaN derived from the input NaN(s)
+ // return start + (float)direction;
+ // } else if (start == direction) {
+ // return (float)direction;
+ // } else { // start > direction or start < direction
+ // // Add +0.0 to get rid of a -0.0 (+0.0 + -0.0 => +0.0)
+ // // then bitwise convert start to integer.
+ // int transducer = Float.floatToRawIntBits(start + 0.0f);
+ //
+ // /*
+ // * IEEE 754 floating-point numbers are lexicographically
+ // * ordered if treated as signed- magnitude integers .
+ // * Since Java's integers are two's complement,
+ // * incrementing" the two's complement representation of a
+ // * logically negative floating-point value *decrements*
+ // * the signed-magnitude representation. Therefore, when
+ // * the integer representation of a floating-point values
+ // * is less than zero, the adjustment to the representation
+ // * is in the opposite direction than would be expected at
+ // * first.
+ // */
+ // if (direction > start) {// Calculate next greater value
+ // transducer = transducer + (transducer >= 0 ? 1:-1);
+ // } else { // Calculate next lesser value
+ // assert direction < start;
+ // if (transducer > 0)
+ // --transducer;
+ // else
+ // if (transducer < 0 )
+ // ++transducer;
+ // /*
+ // * transducer==0, the result is -MIN_VALUE
+ // *
+ // * The transition from zero (implicitly
+ // * positive) to the smallest negative
+ // * signed magnitude value must be done
+ // * explicitly.
+ // */
+ // else
+ // transducer = FloatConsts.SIGN_BIT_MASK | 1;
+ // }
+ //
+ // return Float.intBitsToFloat(transducer);
+ //}
+ }
+
+ /**
+ * Returns the floating-point value adjacent to {@code d} in
+ * the direction of positive infinity. This method is
+ * semantically equivalent to {@code nextAfter(d,
+ * Double.POSITIVE_INFINITY)}; however, a {@code nextUp}
+ * implementation may run faster than its equivalent
+ * {@code nextAfter} call.
+ *
+ * <p>Special Cases:
+ * <ul>
+ * <li> If the argument is NaN, the result is NaN.
+ *
+ * <li> If the argument is positive infinity, the result is
+ * positive infinity.
+ *
+ * <li> If the argument is zero, the result is
+ * {@link Double#MIN_VALUE}
+ *
+ * </ul>
+ *
+ * @param d starting floating-point value
+ * @return The adjacent floating-point value closer to positive
+ * infinity.
+ * @since 1.6
+ */
+ public static double nextUp(double d) {
+ // if( Double.isNaN(d) || d == Double.POSITIVE_INFINITY)
+ // return d;
+ // else {
+ // d += 0.0d;
+ // return Double.longBitsToDouble(Double.doubleToRawLongBits(d) +
+ // ((d >= 0.0d)?+1L:-1L));
+ // }
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ }
+
+ /**
+ * Returns the floating-point value adjacent to {@code f} in
+ * the direction of positive infinity. This method is
+ * semantically equivalent to {@code nextAfter(f,
+ * Float.POSITIVE_INFINITY)}; however, a {@code nextUp}
+ * implementation may run faster than its equivalent
+ * {@code nextAfter} call.
+ *
+ * <p>Special Cases:
+ * <ul>
+ * <li> If the argument is NaN, the result is NaN.
+ *
+ * <li> If the argument is positive infinity, the result is
+ * positive infinity.
+ *
+ * <li> If the argument is zero, the result is
+ * {@link Float#MIN_VALUE}
+ *
+ * </ul>
+ *
+ * @param f starting floating-point value
+ * @return The adjacent floating-point value closer to positive
+ * infinity.
+ * @since 1.6
+ */
+ public static float nextUp(float f) {
+ // if( Float.isNaN(f) || f == FloatConsts.POSITIVE_INFINITY)
+ // return f;
+ // else {
+ // f += 0.0f;
+ // return Float.intBitsToFloat(Float.floatToRawIntBits(f) +
+ // ((f >= 0.0f)?+1:-1));
+ // }
+ CProver.notModelled();
+ return CProver.nondetFloat();
+ }
+
+ /**
+ * Returns the floating-point value adjacent to {@code d} in
+ * the direction of negative infinity. This method is
+ * semantically equivalent to {@code nextAfter(d,
+ * Double.NEGATIVE_INFINITY)}; however, a
+ * {@code nextDown} implementation may run faster than its
+ * equivalent {@code nextAfter} call.
+ *
+ * <p>Special Cases:
+ * <ul>
+ * <li> If the argument is NaN, the result is NaN.
+ *
+ * <li> If the argument is negative infinity, the result is
+ * negative infinity.
+ *
+ * <li> If the argument is zero, the result is
+ * {@code -Double.MIN_VALUE}
+ *
+ * </ul>
+ *
+ * @param d starting floating-point value
+ * @return The adjacent floating-point value closer to negative
+ * infinity.
+ * @since 1.8
+ */
+ public static double nextDown(double d) {
+ // if (Double.isNaN(d) || d == Double.NEGATIVE_INFINITY)
+ // return d;
+ // else {
+ // if (d == 0.0)
+ // return -Double.MIN_VALUE;
+ // else
+ // return Double.longBitsToDouble(Double.doubleToRawLongBits(d) +
+ // ((d > 0.0d)?-1L:+1L));
+ // }
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ }
+
+ /**
+ * Returns the floating-point value adjacent to {@code f} in
+ * the direction of negative infinity. This method is
+ * semantically equivalent to {@code nextAfter(f,
+ * Float.NEGATIVE_INFINITY)}; however, a
+ * {@code nextDown} implementation may run faster than its
+ * equivalent {@code nextAfter} call.
+ *
+ * <p>Special Cases:
+ * <ul>
+ * <li> If the argument is NaN, the result is NaN.
+ *
+ * <li> If the argument is negative infinity, the result is
+ * negative infinity.
+ *
+ * <li> If the argument is zero, the result is
+ * {@code -Float.MIN_VALUE}
+ *
+ * </ul>
+ *
+ * @param f starting floating-point value
+ * @return The adjacent floating-point value closer to negative
+ * infinity.
+ * @since 1.8
+ */
+ public static float nextDown(float f) {
+ // if (Float.isNaN(f) || f == Float.NEGATIVE_INFINITY)
+ // return f;
+ // else {
+ // if (f == 0.0f)
+ // return -Float.MIN_VALUE;
+ // else
+ // return Float.intBitsToFloat(Float.floatToRawIntBits(f) +
+ // ((f > 0.0f)?-1:+1));
+ // }
+ CProver.notModelled();
+ return CProver.nondetFloat();
+ }
+
+ /**
+ * Returns {@code d} ×
+ * 2<sup>{@code scaleFactor}</sup> rounded as if performed
+ * by a single correctly rounded floating-point multiply to a
+ * member of the double value set. See the Java
+ * Language Specification for a discussion of floating-point
+ * value sets. If the exponent of the result is between {@link
+ * Double#MIN_EXPONENT} and {@link Double#MAX_EXPONENT}, the
+ * answer is calculated exactly. If the exponent of the result
+ * would be larger than {@code Double.MAX_EXPONENT}, an
+ * infinity is returned. Note that if the result is subnormal,
+ * precision may be lost; that is, when {@code scalb(x, n)}
+ * is subnormal, {@code scalb(scalb(x, n), -n)} may not equal
+ * <i>x</i>. When the result is non-NaN, the result has the same
+ * sign as {@code d}.
+ *
+ * <p>Special cases:
+ * <ul>
+ * <li> If the first argument is NaN, NaN is returned.
+ * <li> If the first argument is infinite, then an infinity of the
+ * same sign is returned.
+ * <li> If the first argument is zero, then a zero of the same
+ * sign is returned.
+ * </ul>
+ *
+ * @param d number to be scaled by a power of two.
+ * @param scaleFactor power of 2 used to scale {@code d}
+ * @return {@code d} × 2<sup>{@code scaleFactor}</sup>
+ * @since 1.6
+ */
+ public static double scalb(double d, int scaleFactor) {
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ /*
+ * This method does not need to be declared strictfp to
+ * compute the same correct result on all platforms. When
+ * scaling up, it does not matter what order the
+ * multiply-store operations are done; the result will be
+ * finite or overflow regardless of the operation ordering.
+ * However, to get the correct result when scaling down, a
+ * particular ordering must be used.
+ *
+ * When scaling down, the multiply-store operations are
+ * sequenced so that it is not possible for two consecutive
+ * multiply-stores to return subnormal results. If one
+ * multiply-store result is subnormal, the next multiply will
+ * round it away to zero. This is done by first multiplying
+ * by 2 ^ (scaleFactor % n) and then multiplying several
+ * times by by 2^n as needed where n is the exponent of number
+ * that is a covenient power of two. In this way, at most one
+ * real rounding error occurs. If the double value set is
+ * being used exclusively, the rounding will occur on a
+ * multiply. If the double-extended-exponent value set is
+ * being used, the products will (perhaps) be exact but the
+ * stores to d are guaranteed to round to the double value
+ * set.
+ *
+ * It is _not_ a valid implementation to first multiply d by
+ * 2^MIN_EXPONENT and then by 2 ^ (scaleFactor %
+ * MIN_EXPONENT) since even in a strictfp program double
+ * rounding on underflow could occur; e.g. if the scaleFactor
+ * argument was (MIN_EXPONENT - n) and the exponent of d was a
+ * little less than -(MIN_EXPONENT - n), meaning the final
+ * result would be subnormal.
+ *
+ * Since exact reproducibility of this method can be achieved
+ * without any undue performance burden, there is no
+ * compelling reason to allow double rounding on underflow in
+ * scalb.
+ */
+
+ // // magnitude of a power of two so large that scaling a finite
+ // // nonzero value by it would be guaranteed to over or
+ // // underflow; due to rounding, scaling down takes takes an
+ // // additional power of two which is reflected here
+ // final int MAX_SCALE = DoubleConsts.MAX_EXPONENT + -DoubleConsts.MIN_EXPONENT +
+ // DoubleConsts.SIGNIFICAND_WIDTH + 1;
+ // int exp_adjust = 0;
+ // int scale_increment = 0;
+ // double exp_delta = Double.NaN;
+ //
+ // // Make sure scaling factor is in a reasonable range
+ //
+ // if(scaleFactor < 0) {
+ // scaleFactor = Math.max(scaleFactor, -MAX_SCALE);
+ // scale_increment = -512;
+ // exp_delta = twoToTheDoubleScaleDown;
+ // }
+ // else {
+ // scaleFactor = Math.min(scaleFactor, MAX_SCALE);
+ // scale_increment = 512;
+ // exp_delta = twoToTheDoubleScaleUp;
+ // }
+ //
+ // // Calculate (scaleFactor % +/-512), 512 = 2^9, using
+ // // technique from "Hacker's Delight" section 10-2.
+ // int t = (scaleFactor >> 9-1) >>> 32 - 9;
+ // exp_adjust = ((scaleFactor + t) & (512 -1)) - t;
+ //
+ // d *= powerOfTwoD(exp_adjust);
+ // scaleFactor -= exp_adjust;
+ //
+ // while(scaleFactor != 0) {
+ // d *= exp_delta;
+ // scaleFactor -= scale_increment;
+ // }
+ // return d;
+ }
+
+ /**
+ * Returns {@code f} ×
+ * 2<sup>{@code scaleFactor}</sup> rounded as if performed
+ * by a single correctly rounded floating-point multiply to a
+ * member of the float value set. See the Java
+ * Language Specification for a discussion of floating-point
+ * value sets. If the exponent of the result is between {@link
+ * Float#MIN_EXPONENT} and {@link Float#MAX_EXPONENT}, the
+ * answer is calculated exactly. If the exponent of the result
+ * would be larger than {@code Float.MAX_EXPONENT}, an
+ * infinity is returned. Note that if the result is subnormal,
+ * precision may be lost; that is, when {@code scalb(x, n)}
+ * is subnormal, {@code scalb(scalb(x, n), -n)} may not equal
+ * <i>x</i>. When the result is non-NaN, the result has the same
+ * sign as {@code f}.
+ *
+ * <p>Special cases:
+ * <ul>
+ * <li> If the first argument is NaN, NaN is returned.
+ * <li> If the first argument is infinite, then an infinity of the
+ * same sign is returned.
+ * <li> If the first argument is zero, then a zero of the same
+ * sign is returned.
+ * </ul>
+ *
+ * @param f number to be scaled by a power of two.
+ * @param scaleFactor power of 2 used to scale {@code f}
+ * @return {@code f} × 2<sup>{@code scaleFactor}</sup>
+ * @since 1.6
+ */
+ public static float scalb(float f, int scaleFactor) {
+ // // magnitude of a power of two so large that scaling a finite
+ // // nonzero value by it would be guaranteed to over or
+ // // underflow; due to rounding, scaling down takes takes an
+ // // additional power of two which is reflected here
+ // final int MAX_SCALE = FloatConsts.MAX_EXPONENT + -FloatConsts.MIN_EXPONENT +
+ // FloatConsts.SIGNIFICAND_WIDTH + 1;
+ //
+ // // Make sure scaling factor is in a reasonable range
+ // scaleFactor = Math.max(Math.min(scaleFactor, MAX_SCALE), -MAX_SCALE);
+ //
+ // /*
+ // * Since + MAX_SCALE for float fits well within the double
+ // * exponent range and + float -> double conversion is exact
+ // * the multiplication below will be exact. Therefore, the
+ // * rounding that occurs when the double product is cast to
+ // * float will be the correctly rounded float result. Since
+ // * all operations other than the final multiply will be exact,
+ // * it is not necessary to declare this method strictfp.
+ // */
+ // return (float)((double)f*powerOfTwoD(scaleFactor));
+ CProver.notModelled();
+ return CProver.nondetFloat();
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // Not currently modelled because we are not modelling method powerOfTwoD
+ // // Constants used in scalb
+ // static double twoToTheDoubleScaleUp = powerOfTwoD(512);
+ // static double twoToTheDoubleScaleDown = powerOfTwoD(-512);
+
+ /**
+ * Returns a floating-point power of two in the normal range.
+ */
+ static double powerOfTwoD(int n) {
+ // assert(n >= DoubleConsts.MIN_EXPONENT && n <= DoubleConsts.MAX_EXPONENT);
+ // return Double.longBitsToDouble((((long)n + (long)DoubleConsts.EXP_BIAS) <<
+ // (DoubleConsts.SIGNIFICAND_WIDTH-1))
+ // & DoubleConsts.EXP_BIT_MASK);
+ CProver.notModelled();
+ return CProver.nondetDouble();
+ }
+
+ /**
+ * Returns a floating-point power of two in the normal range.
+ */
+ static float powerOfTwoF(int n) {
+ CProver.notModelled();
+ return CProver.nondetFloat();
+ // assert(n >= FloatConsts.MIN_EXPONENT && n <= FloatConsts.MAX_EXPONENT);
+ // return Float.intBitsToFloat(((n + FloatConsts.EXP_BIAS) <<
+ // (FloatConsts.SIGNIFICAND_WIDTH-1))
+ // & FloatConsts.EXP_BIT_MASK);
+ }
+}
diff --git a/src/main/java/java/lang/NegativeArraySizeException.java b/src/main/java/java/lang/NegativeArraySizeException.java
new file mode 100644
index 0000000..0a413a1
--- /dev/null
+++ b/src/main/java/java/lang/NegativeArraySizeException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class NegativeArraySizeException extends RuntimeException {
+ private static final long serialVersionUID = -8960118058596991861L;
+
+ public NegativeArraySizeException() {
+ super();
+ }
+
+ public NegativeArraySizeException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.NegativeArraySizeException: " + message)
+ : "java.lang.NegativeArraySizeException";
+ }
+}
diff --git a/src/main/java/java/lang/NoClassDefFoundError.java b/src/main/java/java/lang/NoClassDefFoundError.java
new file mode 100644
index 0000000..767b85b
--- /dev/null
+++ b/src/main/java/java/lang/NoClassDefFoundError.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown if the Java Virtual Machine or a <code>ClassLoader</code> instance
+ * tries to load in the definition of a class (as part of a normal method call
+ * or as part of creating a new instance using the <code>new</code> expression)
+ * and no definition of the class could be found.
+ * <p>
+ * The searched-for class definition existed when the currently
+ * executing class was compiled, but the definition can no longer be
+ * found.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public
+class NoClassDefFoundError extends LinkageError {
+ private static final long serialVersionUID = 9095859863287012458L;
+
+ /**
+ * Constructs a <code>NoClassDefFoundError</code> with no detail message.
+ */
+ public NoClassDefFoundError() {
+ super();
+ }
+
+ /**
+ * Constructs a <code>NoClassDefFoundError</code> with the specified
+ * detail message.
+ *
+ * @param s the detail message.
+ */
+ public NoClassDefFoundError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.NoClassDefFoundError: " + message)
+ : "java.lang.NoClassDefFoundError";
+ }
+}
diff --git a/src/main/java/java/lang/NoSuchFieldError.java b/src/main/java/java/lang/NoSuchFieldError.java
new file mode 100644
index 0000000..da528b3
--- /dev/null
+++ b/src/main/java/java/lang/NoSuchFieldError.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown if an application tries to access or modify a specified
+ * field of an object, and that object no longer has that field.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public
+class NoSuchFieldError extends IncompatibleClassChangeError {
+ private static final long serialVersionUID = -3456430195886129035L;
+
+ /**
+ * Constructs a <code>NoSuchFieldError</code> with no detail message.
+ */
+ public NoSuchFieldError() {
+ super();
+ }
+
+ /**
+ * Constructs a <code>NoSuchFieldError</code> with the specified
+ * detail message.
+ *
+ * @param s the detail message.
+ */
+ public NoSuchFieldError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.NoSuchFieldError: " + message)
+ : "java.lang.NoSuchFieldError";
+ }
+}
diff --git a/src/main/java/java/lang/NoSuchFieldException.java b/src/main/java/java/lang/NoSuchFieldException.java
new file mode 100644
index 0000000..51bbe54
--- /dev/null
+++ b/src/main/java/java/lang/NoSuchFieldException.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1996, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public class NoSuchFieldException extends ReflectiveOperationException {
+ private static final long serialVersionUID = -6143714805279938260L;
+
+ public NoSuchFieldException() {
+ super();
+ }
+
+ public NoSuchFieldException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.NoSuchFieldException: " + message)
+ : "java.lang.NoSuchFieldException";
+ }
+}
diff --git a/src/main/java/java/lang/NoSuchMethodError.java b/src/main/java/java/lang/NoSuchMethodError.java
new file mode 100644
index 0000000..b7c544c
--- /dev/null
+++ b/src/main/java/java/lang/NoSuchMethodError.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown if an application tries to call a specified method of a
+ * class (either static or instance), and that class no longer has a
+ * definition of that method.
+ * <p>
+ * Normally, this error is caught by the compiler; this error can
+ * only occur at run time if the definition of a class has
+ * incompatibly changed.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public
+class NoSuchMethodError extends IncompatibleClassChangeError {
+ private static final long serialVersionUID = -3765521442372831335L;
+
+ /**
+ * Constructs a <code>NoSuchMethodError</code> with no detail message.
+ */
+ public NoSuchMethodError() {
+ super();
+ }
+
+ /**
+ * Constructs a <code>NoSuchMethodError</code> with the
+ * specified detail message.
+ *
+ * @param s the detail message.
+ */
+ public NoSuchMethodError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.NoSuchMethodError: " + message)
+ : "java.lang.NoSuchMethodError";
+ }
+}
diff --git a/src/main/java/java/lang/NoSuchMethodException.java b/src/main/java/java/lang/NoSuchMethodException.java
new file mode 100644
index 0000000..f09659a
--- /dev/null
+++ b/src/main/java/java/lang/NoSuchMethodException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class NoSuchMethodException extends ReflectiveOperationException {
+ private static final long serialVersionUID = 5034388446362600923L;
+
+ public NoSuchMethodException() {
+ super();
+ }
+
+ public NoSuchMethodException(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.NoSuchMethodException: " + message)
+ : "java.lang.NoSuchMethodException";
+ }
+}
diff --git a/src/main/java/java/lang/NumberFormatException.java b/src/main/java/java/lang/NumberFormatException.java
new file mode 100644
index 0000000..96c4046
--- /dev/null
+++ b/src/main/java/java/lang/NumberFormatException.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class NumberFormatException extends IllegalArgumentException {
+ static final long serialVersionUID = -2848938806368998894L;
+
+ public NumberFormatException () {
+ super();
+ }
+
+ public NumberFormatException (String s) {
+ super (s);
+ }
+
+ static NumberFormatException forInputString(String s) {
+ return new NumberFormatException("For input string: \"" + s + "\"");
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.NumberFormatException: " + message)
+ : "java.lang.NumberFormatException";
+ }
+}
diff --git a/src/main/java/java/lang/Object.java b/src/main/java/java/lang/Object.java
index 1d4218a..99b3186 100644
--- a/src/main/java/java/lang/Object.java
+++ b/src/main/java/java/lang/Object.java
@@ -50,7 +50,7 @@ public final Class<?> getClass() {
* }
*/
Class c = Class.forName("");
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
public int hashCode() {
diff --git a/src/main/java/java/lang/OutOfMemoryError.java b/src/main/java/java/lang/OutOfMemoryError.java
new file mode 100644
index 0000000..1f5fa3c
--- /dev/null
+++ b/src/main/java/java/lang/OutOfMemoryError.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when the Java Virtual Machine cannot allocate an object
+ * because it is out of memory, and no more memory could be made
+ * available by the garbage collector.
+ *
+ * {@code OutOfMemoryError} objects may be constructed by the virtual
+ * machine as if {@linkplain Throwable#Throwable(String, Throwable,
+ * boolean, boolean) suppression were disabled and/or the stack trace was not
+ * writable}.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public class OutOfMemoryError extends VirtualMachineError {
+ private static final long serialVersionUID = 8228564086184010517L;
+
+ /**
+ * Constructs an {@code OutOfMemoryError} with no detail message.
+ */
+ public OutOfMemoryError() {
+ super();
+ }
+
+ /**
+ * Constructs an {@code OutOfMemoryError} with the specified
+ * detail message.
+ *
+ * @param s the detail message.
+ */
+ public OutOfMemoryError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.OutOfMemoryError: " + message)
+ : "java.lang.OutOfMemoryError";
+ }
+}
diff --git a/src/main/java/java/lang/ReflectiveOperationException.java b/src/main/java/java/lang/ReflectiveOperationException.java
new file mode 100644
index 0000000..05bbddb
--- /dev/null
+++ b/src/main/java/java/lang/ReflectiveOperationException.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public class ReflectiveOperationException extends Exception {
+ static final long serialVersionUID = 123456789L;
+
+ public ReflectiveOperationException() {
+ super();
+ }
+
+ public ReflectiveOperationException(String message) {
+ super(message);
+ }
+
+ public ReflectiveOperationException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public ReflectiveOperationException(Throwable cause) {
+ super(cause);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.ReflectiveOperationException: " + message)
+ : "java.lang.ReflectiveOperationException";
+ }
+}
diff --git a/src/main/java/java/lang/SecurityException.java b/src/main/java/java/lang/SecurityException.java
new file mode 100644
index 0000000..40bf1bb
--- /dev/null
+++ b/src/main/java/java/lang/SecurityException.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 1995, 2003, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.lang;
+
+public class SecurityException extends RuntimeException {
+
+ private static final long serialVersionUID = 6878364983674394167L;
+
+ public SecurityException() {
+ super();
+ }
+
+ public SecurityException(String s) {
+ super(s);
+ }
+
+ public SecurityException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public SecurityException(Throwable cause) {
+ super(cause);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.SecurityException: " + message)
+ : "java.lang.SecurityException";
+ }
+}
diff --git a/src/main/java/java/lang/StackOverflowError.java b/src/main/java/java/lang/StackOverflowError.java
new file mode 100644
index 0000000..f5794c7
--- /dev/null
+++ b/src/main/java/java/lang/StackOverflowError.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when a stack overflow occurs because an application
+ * recurses too deeply.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public
+class StackOverflowError extends VirtualMachineError {
+ private static final long serialVersionUID = 8609175038441759607L;
+
+ /**
+ * Constructs a <code>StackOverflowError</code> with no detail message.
+ */
+ public StackOverflowError() {
+ super();
+ }
+
+ /**
+ * Constructs a <code>StackOverflowError</code> with the specified
+ * detail message.
+ *
+ * @param s the detail message.
+ */
+ public StackOverflowError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.StackOverflowError: " + message)
+ : "java.lang.StackOverflowError";
+ }
+}
diff --git a/src/main/java/java/lang/String.java b/src/main/java/java/lang/String.java
index df9eea7..277a8dc 100644
--- a/src/main/java/java/lang/String.java
+++ b/src/main/java/java/lang/String.java
@@ -27,18 +27,23 @@
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
+import java.util.Comparator;
+import java.util.Iterator;
import java.util.Locale;
-// DIFFBLUE MODEL LIBRARY : these headers are not used
+// DIFFBLUE MODEL LIBRARY these headers are not used
// import java.io.ObjectStreamField;
// import java.util.ArrayList;
// import java.util.Arrays;
-// import java.util.Comparator;
// import java.util.Formatter;
// import java.util.Objects;
// import java.util.StringJoiner;
// import java.util.regex.Matcher;
// import java.util.regex.Pattern;
// import java.util.regex.PatternSyntaxException;
+
+// DIFFBLUE MODEL LIBRARY new imports in the model
+import java.nio.charset.StandardCharsets;
+
import org.cprover.CProver;
// Used as an interface with CProver internal string functions:
@@ -757,17 +762,15 @@ public char charAt(int index) {
* string.
* @since 1.5
*
- * @diffblue.limitedSupport
- * Does not throw exceptions.
- * @diffblue.untested
+ * @diffblue.fullSupport
+ * @diffblue.untested Tests only cover exception throwing
*/
public int codePointAt(int index) {
- // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetInt();
- // if ((index < 0) || (index >= value.length)) {
- // throw new StringIndexOutOfBoundsException(index);
- // }
+ if ((index < 0) || (index >= this.length())) {
+ throw new StringIndexOutOfBoundsException(index);
+ }
// return Character.codePointAtImpl(value, index, value.length);
+ return CProverString.codePointAt(this, index);
}
/**
@@ -792,18 +795,15 @@ public int codePointAt(int index) {
* of this string.
* @since 1.5
*
- * @diffblue.limitedSupport
- * Does not throw exceptions.
- * @diffblue.untested
+ * @diffblue.fullSupport
*/
public int codePointBefore(int index) {
- // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetInt();
- // int i = index - 1;
- // if ((i < 0) || (i >= value.length)) {
- // throw new StringIndexOutOfBoundsException(index);
- // }
+ int i = index - 1;
+ if ((i < 0) || (i >= this.length())) {
+ throw new StringIndexOutOfBoundsException(index);
+ }
// return Character.codePointBeforeImpl(value, index, 0);
+ return CProverString.codePointBefore(this, index);
}
/**
@@ -828,15 +828,15 @@ public int codePointBefore(int index) {
* @since 1.5
*
* @diffblue.limitedSupport
- * The result of this function is approximated and no exception is thrown.
+ * The result of this function is approximated.
+ * @diffblue.untested Tests only cover exception throwing
*/
public int codePointCount(int beginIndex, int endIndex) {
- // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetInt();
- // if (beginIndex < 0 || endIndex > value.length || beginIndex > endIndex) {
- // throw new IndexOutOfBoundsException();
- // }
+ if (beginIndex < 0 || endIndex > this.length() || beginIndex > endIndex) {
+ throw new IndexOutOfBoundsException();
+ }
// return Character.codePointCountImpl(value, beginIndex, endIndex - beginIndex);
+ return CProverString.codePointCount(this, beginIndex, endIndex);
}
/**
@@ -860,16 +860,17 @@ public int codePointCount(int beginIndex, int endIndex) {
* @since 1.5
*
* @diffblue.limitedSupport
- * The result of this function is approximated and no exception is thrown.
+ * The result of this function is approximated. Only the
+ * {@code IndexOutOfBoundsException} related to {@code index} is thrown.
+ * @diffblue.untested Only exception throwing is tested.
*/
public int offsetByCodePoints(int index, int codePointOffset) {
- // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetInt();
- // if (index < 0 || index > value.length) {
- // throw new IndexOutOfBoundsException();
- // }
+ if (index < 0 || index > this.length()) {
+ throw new IndexOutOfBoundsException();
+ }
// return Character.offsetByCodePointsImpl(value, 0, value.length,
// index, codePointOffset);
+ return CProverString.offsetByCodePoints(this, index, codePointOffset);
}
/**
@@ -1032,6 +1033,9 @@ public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {
* </ul>
* Will enforce the argument is equal to "US-ASCII" in the other cases,
* hence UnsupportedEncodingException will never be thrown.
+ *
+ * Uses loops so is affected by the `unwind` parameter, which needs to be
+ * 1 + length of the string to convert.
*/
public byte[] getBytes(String charsetName)
throws java.io.UnsupportedEncodingException {
@@ -1084,19 +1088,47 @@ public byte[] getBytes(String charsetName)
* @since 1.6
*
* @diffblue.limitedSupport
- * We enforce all characters are ASCII and the encoding is one in which
- * ASCII characters are encoded with one byte. In particular this is
- * wrong if the given charset is UTF16.
- * NullPointerException are not raised by this model.
+ * Works as expected if the argument is:
+ * <ul>
+ * <li> "US-ASCII" </li>
+ * </ul>
+ * Will enforce the string does not contain code points from supplementary
+ * planes https://en.wikipedia.org/wiki/Plane_(Unicode)#Supplementary_Multilingual_Plane
+ * if the argument is:
+ * <ul>
+ * <li> "UTF-16BE" </li>
+ * <li> "UTF-16LE" </li>
+ * <li> "UTF-16" </li>
+ * </ul>
+ * Will enforce the string is composed of ASCII characters if the argument
+ * is one of the following:
+ * <ul>
+ * <li> "ISO-8859-1" </li>
+ * <li> "UTF-8" </li>
+ * </ul>
+ * Will enforce the argument is equal to "US-ASCII" in the other cases.
+ *
+ * Uses loops so is affected by the `unwind` parameter, which needs to be
+ * 1 + length of the string to convert.
*/
public byte[] getBytes(Charset charset) {
- // DIFFBLUE MODEL LIBRARY: this is disabled because a bug makes all static
- // members null TG-1081
// if (charset == null) throw new NullPointerException();
+ // return StringCoding.encode(charset, value, 0, value.length);
// DIFFBLUE MODEL LIBRARY
- // @diffblue.todo: we always enforce ASCII for now because of a bug
- // with static object initialization, which makes all standard charsets
- // (US_ASCII, ISO_8859_1, ...) null.
+ // @diffblue.todo: Write a model for StringCoding, change this method
+ // back to its original implementation and remove the import for
+ // StandardCharsets.
+ if (charset == null) throw new NullPointerException();
+ if (charset.equals(StandardCharsets.US_ASCII))
+ return getBytesAscii();
+ if (charset.equals(StandardCharsets.UTF_16BE))
+ return getBytesUTF_16BE();
+ if (charset.equals(StandardCharsets.UTF_16LE))
+ return getBytesUTF_16LE();
+ if (charset.equals(StandardCharsets.UTF_16))
+ return getBytesUTF_16();
+ // DIFFBLUE MODEL LIBRARY @diffblue.todo: Support further encodings
+ // (StandardCharsets.ISO_8859_1, StandardCharsets.UTF_8, ...)
return getBytesEnforceAscii();
}
@@ -1154,6 +1186,7 @@ private byte[] getBytesUTF_16BE() {
for(int i = 0; i < l; i++)
{
char c = CProverString.charAt(this, i);
+ CProver.assume(c < '\ud800');
result[2*i] = (byte) (c >> 8);
result[2*i+1] = (byte) (c & 0xFF);
}
@@ -1167,6 +1200,7 @@ private byte[] getBytesUTF_16LE() {
for(int i = 0; i < l; i++)
{
char c = CProverString.charAt(this, i);
+ CProver.assume(c < '\ud800');
result[2*i] = (byte) (c & 0xFF);
result[2*i+1] = (byte) (c >> 8);
}
@@ -1180,11 +1214,12 @@ private byte[] getBytesUTF_16() {
byte result[] = new byte[2*l+2];
result[0] = (byte) 0xFE;
result[1] = (byte) 0xFF;
- for(int i = 2; i < l+2; i++)
+ for (int i = 0; i < l; i++)
{
char c = CProverString.charAt(this, i);
- result[2*i] = (byte) (c >> 8);
- result[2*i+1] = (byte) (c & 0xFF);
+ CProver.assume(c < '\ud800');
+ result[2 * i + 2] = (byte) (c >> 8);
+ result[2 * i + 3] = (byte) (c & 0xFF);
}
return result;
}
@@ -1195,11 +1230,12 @@ private byte[] getBytesUTF_8() {
int output_size = 0;
for(int i = 0; i < l; i++)
{
- int c = charAt(i);
+ int c = CProverString.charAt(this, i);
if(c>=0xD800)
{
i++;
- c = 0x10000 | ((c & 0x3FF) << 10) | (charAt(i) & 0x3FF);
+ c = 0x10000 | ((c & 0x3FF) << 10)
+ | (CProverString.charAt(this, i) & 0x3FF);
}
if(c<=0x7F)
output_size += 1;
@@ -1215,11 +1251,12 @@ else if(c<=0xFFFF)
int index = 0;
for(int i = 0; i < l; i++)
{
- int c = charAt(i);
+ int c = CProverString.charAt(this, i);
if(c>=0xD800)
{
i++;
- c = 0x10000 | ((c & 0x3FF) << 10) | (charAt(i) & 0x3FF);
+ c = 0x10000 | ((c & 0x3FF) << 10)
+ | (CProverString.charAt(this, i) & 0x3FF);
}
if(c<=0x7F)
result[index++]=(byte)c;
@@ -1501,10 +1538,17 @@ public int compareTo(String anotherString) {
*
* @see java.text.Collator#compare(String, String)
* @since 1.2
+ *
+ * @diffblue.noSupport
+ * @diffblue.untested
*/
- // DIFFBLUE MODEL LIBRARY Not needed for modelling
// public static final Comparator<String> CASE_INSENSITIVE_ORDER
// = new CaseInsensitiveComparator();
+ // DIFFBLUE MODEL LIBRARY For some reason this needs to be not null for
+ // FileReader tests to pass.
+ public static final Comparator<String> CASE_INSENSITIVE_ORDER
+ = CProver.nondetWithoutNullForNotModelled();
+ // DIFFBLUE MODEL LIBRARY Not needed for modelling
// private static class CaseInsensitiveComparator
// implements Comparator<String>, java.io.Serializable {
// // use serialVersionUID from JDK 1.2.2 for interoperability
@@ -2337,7 +2381,7 @@ static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
* length of this {@code String} object.
*
* @diffblue.fullSupport
- * @diffblue.untested
+ * @diffblue.untested Only exception throwing is tested.
*/
public String substring(int beginIndex) {
// DIFFBLUE MODEL LIBRARY
@@ -2385,7 +2429,7 @@ public String substring(int beginIndex) {
* {@code endIndex}.
*
* @diffblue.fullSupport
- * @diffblue.untested
+ * @diffblue.untested Only exception throwing is tested.
*/
public String substring(int beginIndex, int endIndex) {
// DIFFBLUE MODEL LIBRARY
@@ -2414,7 +2458,12 @@ public String substring(int beginIndex, int endIndex) {
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
- return CProverString.substring(this, beginIndex, endIndex);
+ // DIFFBLUE MODEL LIBRARY Exception case imported from {@code String(char value[], int offset, int count)}
+ // Note: beginIndex or subLen might be near -1>>>1.
+ if (beginIndex > length() - subLen) {
+ throw new StringIndexOutOfBoundsException(beginIndex + subLen);
+ }
+ return CProverString.substring(this, beginIndex, beginIndex + subLen);
}
/**
@@ -2446,14 +2495,11 @@ public String substring(int beginIndex, int endIndex) {
* @since 1.4
* @spec JSR-51
*
- * @diffblue.limitedSupport
- * Does not throw IndexOutOfBoundsException
- * @diffblue.untested
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
*/
public CharSequence subSequence(int beginIndex, int endIndex) {
- // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithNull();
- // return this.substring(beginIndex, endIndex);
+ return this.substring(beginIndex, endIndex);
}
/**
@@ -2481,7 +2527,7 @@ public CharSequence subSequence(int beginIndex, int endIndex) {
*/
public String concat(String str) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// int otherLen = str.length();
// if (otherLen == 0) {
// return this;
@@ -2526,7 +2572,7 @@ public String concat(String str) {
*/
public String replace(char oldChar, char newChar) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// if (oldChar != newChar) {
// int len = value.length;
// int i = -1;
@@ -2650,7 +2696,7 @@ public boolean contains(CharSequence s) {
*/
public String replaceFirst(String regex, String replacement) {
CProver.notModelled();
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
}
@@ -2743,7 +2789,7 @@ public String replaceAll(String regex, String replacement)
*/
public String replace(CharSequence target, CharSequence replacement) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
// this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}
@@ -2838,7 +2884,7 @@ public String replace(CharSequence target, CharSequence replacement) {
*/
public String[] split(String regex, int limit) {
CProver.notModelled();
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// /* fastpath if the regex is a
// (1)one-char String and this character is not one of the
// RegEx's meta characters ".$|()[{^?*+\\", or
@@ -2934,7 +2980,7 @@ public String[] split(String regex, int limit) {
*/
public String[] split(String regex) {
CProver.notModelled();
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// return split(regex, 0);
}
@@ -2963,11 +3009,23 @@ public String[] split(String regex) {
* @see java.util.StringJoiner
* @since 1.8
*
- * @diffblue.noSupport
+ * @diffblue.limitedSupport
+ * The model assumes the delimiter and elements objects are not null
+ * instead of throwing an exception when they are.
+ * The number of elements will be limited by the unwind parameter.
*/
public static String join(CharSequence delimiter, CharSequence... elements) {
- CProver.notModelled();
- return CProver.nondetWithNull();
+ CProver.assume(delimiter != null);
+ CProver.assume(elements != null);
+
+ StringBuilder builder = new StringBuilder();
+ if (elements.length > 0)
+ builder.append(elements[0]);
+ for (int i = 1; i < elements.length; i++) {
+ builder.append(delimiter);
+ builder.append(elements[i]);
+ }
+ return builder.toString();
// Objects.requireNonNull(delimiter);
// Objects.requireNonNull(elements);
// // Number of elements not likely worth Arrays.stream overhead.
@@ -3015,12 +3073,26 @@ public static String join(CharSequence delimiter, CharSequence... elements) {
* @see java.util.StringJoiner
* @since 1.8
*
- * @diffblue.noSupport
+ * @diffblue.limitedSupport
+ * The model assumes the delimiter and elements objects are not null
+ * instead of throwing an exception when they are.
+ * The number of elements will be limited by the unwind parameter.
*/
public static String join(CharSequence delimiter,
Iterable<? extends CharSequence> elements) {
- CProver.notModelled();
- return CProver.nondetWithNull();
+ CProver.assume(delimiter != null);
+ CProver.assume(elements != null);
+ Iterator<? extends CharSequence> iterator = elements.iterator();
+ if (!iterator.hasNext())
+ return "";
+
+ StringBuilder builder = new StringBuilder();
+ builder.append(iterator.next().toString());
+ while (iterator.hasNext()) {
+ builder.append(delimiter.toString());
+ builder.append(iterator.next().toString());
+ }
+ return builder.toString();
// Objects.requireNonNull(delimiter);
// Objects.requireNonNull(elements);
// StringJoiner joiner = new StringJoiner(delimiter);
@@ -3203,7 +3275,7 @@ public String toLowerCase(Locale locale) {
*/
public String toLowerCase() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// return toLowerCase(Locale.getDefault());
}
@@ -3379,7 +3451,7 @@ public String toUpperCase(Locale locale) {
*/
public String toUpperCase() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// return toUpperCase(Locale.getDefault());
}
@@ -3418,7 +3490,7 @@ public String toUpperCase() {
*/
public String trim() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// int len = value.length;
// int st = 0;
// char[] val = value; /* avoid getfield opcode */
@@ -3444,7 +3516,7 @@ public String trim() {
*/
public String toString() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return this;
}
@@ -3532,7 +3604,7 @@ public char[] toCharArray() {
*/
public static String format(String format, Object... args) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return new Formatter().format(format, args).toString();
}
@@ -3578,7 +3650,7 @@ public static String format(String format, Object... args) {
public static String format(Locale l, String format, Object... args) {
// return new Formatter(l).format(format, args).toString();
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
/**
@@ -3596,7 +3668,7 @@ public static String format(Locale l, String format, Object... args) {
public static String valueOf(Object obj) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
// return (obj == null) ? "null" : obj.toString();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
/**
@@ -3614,7 +3686,7 @@ public static String valueOf(Object obj) {
*/
public static String valueOf(char data[]) {
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return new String(data);
}
@@ -3642,7 +3714,7 @@ public static String valueOf(char data[]) {
*/
public static String valueOf(char data[], int offset, int count) {
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return new String(data, offset, count);
}
@@ -3663,7 +3735,7 @@ public static String valueOf(char data[], int offset, int count) {
*/
public static String copyValueOf(char data[], int offset, int count) {
CProver.notModelled();
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// return new String(data, offset, count);
}
@@ -3678,7 +3750,7 @@ public static String copyValueOf(char data[], int offset, int count) {
*/
public static String copyValueOf(char data[]) {
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return new String(data);
}
@@ -3695,7 +3767,7 @@ public static String copyValueOf(char data[]) {
*/
public static String valueOf(boolean b) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return b ? "true" : "false";
}
@@ -3712,7 +3784,7 @@ public static String valueOf(boolean b) {
*/
public static String valueOf(char c) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithNull();
+ return CProver.nondetWithNullForNotModelled();
// char data[] = {c};
// return new String(data, true);
}
@@ -3732,7 +3804,7 @@ public static String valueOf(char c) {
*/
public static String valueOf(int i) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return Integer.toString(i);
}
@@ -3751,7 +3823,7 @@ public static String valueOf(int i) {
*/
public static String valueOf(long l) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return Long.toString(l);
}
@@ -3771,7 +3843,7 @@ public static String valueOf(long l) {
*/
public static String valueOf(float f) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return Float.toString(f);
}
@@ -3791,7 +3863,7 @@ public static String valueOf(float f) {
*/
public static String valueOf(double d) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
// return Double.toString(d);
}
@@ -3823,6 +3895,6 @@ public static String valueOf(double d) {
// public native String intern();
public String intern() {
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
}
diff --git a/src/main/java/java/lang/StringBuffer.java b/src/main/java/java/lang/StringBuffer.java
new file mode 100644
index 0000000..7d3c120
--- /dev/null
+++ b/src/main/java/java/lang/StringBuffer.java
@@ -0,0 +1,1022 @@
+/*
+ * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+// import java.util.Arrays;
+import org.cprover.CProver;
+import org.cprover.CProverString;
+
+/**
+ * A thread-safe, mutable sequence of characters.
+ * A string buffer is like a {@link String}, but can be modified. At any
+ * point in time it contains some particular sequence of characters, but
+ * the length and content of the sequence can be changed through certain
+ * method calls.
+ * <p>
+ * String buffers are safe for use by multiple threads. The methods
+ * are synchronized where necessary so that all the operations on any
+ * particular instance behave as if they occur in some serial order
+ * that is consistent with the order of the method calls made by each of
+ * the individual threads involved.
+ * <p>
+ * The principal operations on a {@code StringBuffer} are the
+ * {@code append} and {@code insert} methods, which are
+ * overloaded so as to accept data of any type. Each effectively
+ * converts a given datum to a string and then appends or inserts the
+ * characters of that string to the string buffer. The
+ * {@code append} method always adds these characters at the end
+ * of the buffer; the {@code insert} method adds the characters at
+ * a specified point.
+ * <p>
+ * For example, if {@code z} refers to a string buffer object
+ * whose current contents are {@code "start"}, then
+ * the method call {@code z.append("le")} would cause the string
+ * buffer to contain {@code "startle"}, whereas
+ * {@code z.insert(4, "le")} would alter the string buffer to
+ * contain {@code "starlet"}.
+ * <p>
+ * In general, if sb refers to an instance of a {@code StringBuffer},
+ * then {@code sb.append(x)} has the same effect as
+ * {@code sb.insert(sb.length(), x)}.
+ * <p>
+ * Whenever an operation occurs involving a source sequence (such as
+ * appending or inserting from a source sequence), this class synchronizes
+ * only on the string buffer performing the operation, not on the source.
+ * Note that while {@code StringBuffer} is designed to be safe to use
+ * concurrently from multiple threads, if the constructor or the
+ * {@code append} or {@code insert} operation is passed a source sequence
+ * that is shared across threads, the calling code must ensure
+ * that the operation has a consistent and unchanging view of the source
+ * sequence for the duration of the operation.
+ * This could be satisfied by the caller holding a lock during the
+ * operation's call, by using an immutable source sequence, or by not
+ * sharing the source sequence across threads.
+ * <p>
+ * Every string buffer has a capacity. As long as the length of the
+ * character sequence contained in the string buffer does not exceed
+ * the capacity, it is not necessary to allocate a new internal
+ * buffer array. If the internal buffer overflows, it is
+ * automatically made larger.
+ * <p>
+ * Unless otherwise noted, passing a {@code null} argument to a constructor
+ * or method in this class will cause a {@link NullPointerException} to be
+ * thrown.
+ * <p>
+ * As of release JDK 5, this class has been supplemented with an equivalent
+ * class designed for use by a single thread, {@link StringBuilder}. The
+ * {@code StringBuilder} class should generally be used in preference to
+ * this one, as it supports all of the same operations but it is faster, as
+ * it performs no synchronization.
+ *
+ * @author Arthur van Hoff
+ * @see java.lang.StringBuilder
+ * @see java.lang.String
+ * @since JDK1.0
+ *
+ * @diffblue.limitedSupport
+ * Most methods are not supported yet.
+ * The methods that are supported have limited support as they do not handle
+ * exceptions.
+ */
+ public final class StringBuffer
+ extends AbstractStringBuilder
+ implements java.io.Serializable, CharSequence
+{
+
+ /**
+ * A cache of the last value returned by toString. Cleared
+ * whenever the StringBuffer is modified.
+ */
+ // private transient char[] toStringCache;
+
+ /** use serialVersionUID from JDK 1.0.2 for interoperability */
+ static final long serialVersionUID = 3388685877147921107L;
+
+ /**
+ * Constructs a string buffer with no characters in it and an
+ * initial capacity of 16 characters.
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ public StringBuffer() {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // super(16);
+ }
+
+ /**
+ * Constructs a string buffer with no characters in it and
+ * the specified initial capacity.
+ *
+ * @param capacity the initial capacity.
+ * @exception NegativeArraySizeException if the {@code capacity}
+ * argument is less than {@code 0}.
+ *
+ * @diffblue.noSupport
+ */
+ public StringBuffer(int capacity) {
+ // super(capacity);
+ }
+
+ /**
+ * Constructs a string buffer initialized to the contents of the
+ * specified string. The initial capacity of the string buffer is
+ * {@code 16} plus the length of the string argument.
+ *
+ * @param str the initial contents of the buffer.
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ public StringBuffer(String str) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // super(str.length() + 16);
+ // append(str);
+ }
+
+ /**
+ * Constructs a string buffer that contains the same characters
+ * as the specified {@code CharSequence}. The initial capacity of
+ * the string buffer is {@code 16} plus the length of the
+ * {@code CharSequence} argument.
+ * <p>
+ * If the length of the specified {@code CharSequence} is
+ * less than or equal to zero, then an empty buffer of capacity
+ * {@code 16} is returned.
+ *
+ * @param seq the sequence to copy.
+ * @since 1.5
+ *
+ * @diffblue.noSupport
+ */
+ public StringBuffer(CharSequence seq) {
+ // this(seq.length() + 16);
+ // append(seq);
+ CProver.notModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized int length() {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // return count;
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized int capacity() {
+ // return value.length;
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized void ensureCapacity(int minimumCapacity) {
+ // super.ensureCapacity(minimumCapacity);
+ CProver.notModelled();
+ }
+
+ /**
+ * @since 1.5
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized void trimToSize() {
+ // super.trimToSize();
+ CProver.notModelled();
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ * @see #length()
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ // TODO: this should be a call to the method of AbstractStringBuilder as in
+ // the orginal implementation
+ public synchronized void setLength(int newLength) {
+ // toStringCache = null;
+ // super.setLength(newLength);
+ if (newLength < 0)
+ throw new StringIndexOutOfBoundsException(newLength);
+ CProverString.setLength(this, newLength);
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ * @see #length()
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public synchronized char charAt(int index) {
+ if ((index < 0) || (index >= this.length()))
+ throw new StringIndexOutOfBoundsException(index);
+ // return value[index];
+ return CProverString.charAt(this, index);
+ }
+
+ /**
+ * @since 1.5
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized int codePointAt(int index) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // return super.codePointAt(index);
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @since 1.5
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized int codePointBefore(int index) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // return super.codePointBefore(index);
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @since 1.5
+ *
+ * @diffblue.limitedSupport
+ * The result is approximate.
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized int codePointCount(int beginIndex, int endIndex) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // return super.codePointCount(beginIndex, endIndex);
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @since 1.5
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized int offsetByCodePoints(int index, int codePointOffset) {
+ // return super.offsetByCodePoints(index, codePointOffset);
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,
+ int dstBegin)
+ {
+ // super.getChars(srcBegin, srcEnd, dst, dstBegin);
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ * @see #length()
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public synchronized void setCharAt(int index, char ch) {
+ if ((index < 0) || (index >= this.length()))
+ throw new StringIndexOutOfBoundsException(index);
+ // toStringCache = null;
+ // value[index] = ch;
+ CProverString.setCharAt(this, index, ch);
+ }
+
+ /**
+ * @diffblue.limitedSupport
+ * This method can be slow to generate tests due to TG-2866 and is
+ * also limited by which {@code toString()} methods have been modelled.
+ */
+ @Override
+ public synchronized StringBuffer append(Object obj) {
+ // toStringCache = null;
+ // super.append(String.valueOf(obj));
+ // return this;
+ String temp = (obj == null) ? "null" : obj.toString();
+ return append(temp);
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized StringBuffer append(String str) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.append(str);
+ // return this;
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Appends the specified {@code StringBuffer} to this sequence.
+ * <p>
+ * The characters of the {@code StringBuffer} argument are appended,
+ * in order, to the contents of this {@code StringBuffer}, increasing the
+ * length of this {@code StringBuffer} by the length of the argument.
+ * If {@code sb} is {@code null}, then the four characters
+ * {@code "null"} are appended to this {@code StringBuffer}.
+ * <p>
+ * Let <i>n</i> be the length of the old character sequence, the one
+ * contained in the {@code StringBuffer} just prior to execution of the
+ * {@code append} method. Then the character at index <i>k</i> in
+ * the new character sequence is equal to the character at index <i>k</i>
+ * in the old character sequence, if <i>k</i> is less than <i>n</i>;
+ * otherwise, it is equal to the character at index <i>k-n</i> in the
+ * argument {@code sb}.
+ * <p>
+ * This method synchronizes on {@code this}, the destination
+ * object, but does not synchronize on the source ({@code sb}).
+ *
+ * @param sb the {@code StringBuffer} to append.
+ * @return a reference to this object.
+ * @since 1.4
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ public synchronized StringBuffer append(StringBuffer sb) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.append(sb);
+ // return this;
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ synchronized StringBuffer append(AbstractStringBuilder asb) {
+ // toStringCache = null;
+ // super.append(asb);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Appends the specified {@code CharSequence} to this
+ * sequence.
+ * <p>
+ * The characters of the {@code CharSequence} argument are appended,
+ * in order, increasing the length of this sequence by the length of the
+ * argument.
+ *
+ * <p>The result of this method is exactly the same as if it were an
+ * invocation of this.append(s, 0, s.length());
+ *
+ * <p>This method synchronizes on {@code this}, the destination
+ * object, but does not synchronize on the source ({@code s}).
+ *
+ * <p>If {@code s} is {@code null}, then the four characters
+ * {@code "null"} are appended.
+ *
+ * @param s the {@code CharSequence} to append.
+ * @return a reference to this object.
+ * @since 1.5
+ *
+ * @diffblue.fullSupport
+ */
+ @Override
+ public synchronized StringBuffer append(CharSequence s) {
+ // toStringCache = null;
+ // super.append(s);
+ // return this;
+ String str = s.toString();
+ return append(str);
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ * @since 1.5
+ *
+ * @diffblue.fullSupport
+ */
+ @Override
+ public synchronized StringBuffer append(CharSequence s, int start, int end)
+ {
+ // toStringCache = null;
+ // super.append(s, start, end);
+ // return this;
+ if ((start < 0) || (start > end) || (end > s.length())) {
+ throw new IndexOutOfBoundsException();
+ }
+ String str = CProverString.substring(s.toString(), start, end);
+ return append(str);
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * Thrown exception has no message.
+ */
+ @Override
+ public synchronized StringBuffer append(char[] str) {
+ // toStringCache = null;
+ // super.append(str);
+ // return this;
+ String s = "";
+ for (int i = 0; i < str.length; i++) {
+ s += str[i];
+ }
+ return append(s);
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * Thrown exception has no message.
+ */
+ @Override
+ public synchronized StringBuffer append(char[] str, int offset, int len) {
+ // toStringCache = null;
+ // super.append(str, offset, len);
+ // return this;
+ if ((offset < 0) || (offset > str.length) || (len < 0) ||
+ ((offset + len) > str.length) || ((offset + len) < 0)) {
+ throw new IndexOutOfBoundsException();
+ }
+ if (len == 0) {
+ return this;
+ }
+ String s = "";
+ for (int i = offset; i < offset+len; i++) {
+ s += str[i];
+ }
+ return append(s);
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized StringBuffer append(boolean b) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.append(b);
+ // return this;
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized StringBuffer append(char c) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.append(c);
+ // return this;
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized StringBuffer append(int i) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.append(i);
+ // return this;
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @since 1.5
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized StringBuffer appendCodePoint(int codePoint) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.appendCodePoint(codePoint);
+ // return this;
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized StringBuffer append(long lng) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.append(lng);
+ // return this;
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized StringBuffer append(float f) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.append(f);
+ // return this;
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized StringBuffer append(double d) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.append(d);
+ // return this;
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ * @since 1.2
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public synchronized StringBuffer delete(int start, int end) {
+ // toStringCache = null;
+ // super.delete(start, end);
+ // return this;
+ if (start < 0)
+ throw new StringIndexOutOfBoundsException(start);
+ if (end > this.length())
+ end = this.length();
+ if (start > end)
+ throw new StringIndexOutOfBoundsException();
+ return CProverString.delete(this, start, end);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ * @since 1.2
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public synchronized StringBuffer deleteCharAt(int index) {
+ // toStringCache = null;
+ // super.deleteCharAt(index);
+ // return this;
+ if ((index < 0) || (index >= this.length()))
+ throw new StringIndexOutOfBoundsException(index);
+ return CProverString.deleteCharAt(this, index);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ * @since 1.2
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized StringBuffer replace(int start, int end, String str) {
+ // toStringCache = null;
+ // super.replace(start, end, str);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ * @since 1.2
+ *
+ * @diffblue.noSupport
+ * Does not throw exceptions.
+ */
+ @Override
+ public synchronized String substring(int start) {
+ // return substring(start, count);
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ * @since 1.4
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized CharSequence subSequence(int start, int end) {
+ // return super.substring(start, end);
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ * @since 1.2
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested.
+ */
+ @Override
+ public synchronized String substring(int start, int end) {
+ // return super.substring(start, end);
+ if (start < 0)
+ throw new StringIndexOutOfBoundsException(start);
+ if (end > this.length())
+ throw new StringIndexOutOfBoundsException(end);
+ if (start > end)
+ throw new StringIndexOutOfBoundsException(end - start);
+ return CProverString.substring(this, start, end);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ * @since 1.2
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized StringBuffer insert(int index, char[] str, int offset,
+ int len)
+ {
+ // toStringCache = null;
+ // super.insert(index, str, offset, len);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized StringBuffer insert(int offset, Object obj) {
+ // toStringCache = null;
+ // super.insert(offset, String.valueOf(obj));
+ // return this;
+ CProver.notModelled();
+ return this.insert(offset, obj.toString());
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public synchronized StringBuffer insert(int offset, String str) {
+ if ((offset < 0) || (offset > length()))
+ throw new StringIndexOutOfBoundsException(offset);
+ // toStringCache = null;
+ // super.insert(offset, str);
+ // return this;
+ return CProverString.insert(this, offset, str);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized StringBuffer insert(int offset, char[] str) {
+ // toStringCache = null;
+ // super.insert(offset, str);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ * @since 1.5
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuffer insert(int dstOffset, CharSequence s) {
+ // // Note, synchronization achieved via invocations of other StringBuffer methods
+ // // after narrowing of s to specific type
+ // // Ditto for toStringCache clearing
+ // super.insert(dstOffset, s);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ * @since 1.5
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized StringBuffer insert(int dstOffset, CharSequence s,
+ int start, int end)
+ {
+ // toStringCache = null;
+ // super.insert(dstOffset, s, start, end);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested.
+ */
+ @Override
+ public StringBuffer insert(int offset, boolean b) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+ // // after conversion of b to String by super class method
+ // // Ditto for toStringCache clearing
+ // super.insert(offset, b);
+ // return this;
+ if (offset < 0)
+ throw new StringIndexOutOfBoundsException(offset);
+ if (offset > this.length())
+ throw new StringIndexOutOfBoundsException(this.length());
+ return CProverString.insert(this, offset, b);
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested.
+ */
+ @Override
+ public synchronized StringBuffer insert(int offset, char c) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // toStringCache = null;
+ // super.insert(offset, c);
+ // return this;
+ if (offset < 0)
+ throw new IndexOutOfBoundsException();
+ if (offset > this.length())
+ throw new IndexOutOfBoundsException();
+ return CProverString.insert(this, offset, c);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested.
+ */
+ @Override
+ public StringBuffer insert(int offset, int i) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+ // // after conversion of i to String by super class method
+ // // Ditto for toStringCache clearing
+ // super.insert(offset, i);
+ // return this;
+ if (offset < 0)
+ throw new StringIndexOutOfBoundsException(offset);
+ if (offset > this.length())
+ throw new StringIndexOutOfBoundsException(this.length());
+ return CProverString.insert(this, offset, i);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested.
+ */
+ @Override
+ public StringBuffer insert(int offset, long l) {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+ // // after conversion of l to String by super class method
+ // // Ditto for toStringCache clearing
+ // super.insert(offset, l);
+ // return this;
+ if (offset < 0)
+ throw new StringIndexOutOfBoundsException(offset);
+ if (offset > this.length())
+ throw new StringIndexOutOfBoundsException(this.length());
+ return CProverString.insert(this, offset, l);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuffer insert(int offset, float f) {
+ // // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+ // // after conversion of f to String by super class method
+ // // Ditto for toStringCache clearing
+ // super.insert(offset, f);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuffer insert(int offset, double d) {
+ // // Note, synchronization achieved via invocation of StringBuffer insert(int, String)
+ // // after conversion of d to String by super class method
+ // // Ditto for toStringCache clearing
+ // super.insert(offset, d);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @since 1.4
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public int indexOf(String str) {
+ // // Note, synchronization achieved via invocations of other StringBuffer methods
+ // return super.indexOf(str);
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @since 1.4
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized int indexOf(String str, int fromIndex) {
+ // return super.indexOf(str, fromIndex);
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @since 1.4
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public int lastIndexOf(String str) {
+ // // Note, synchronization achieved via invocations of other StringBuffer methods
+ // return lastIndexOf(str, count);
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @since 1.4
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized int lastIndexOf(String str, int fromIndex) {
+ // return super.lastIndexOf(str, fromIndex);
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @since JDK1.0.2
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public synchronized StringBuffer reverse() {
+ // toStringCache = null;
+ // super.reverse();
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public synchronized String toString() {
+ // DIFFBLUE MODEL LIBRARY this is replaced internally
+ // if (toStringCache == null) {
+ // toStringCache = Arrays.copyOfRange(value, 0, count);
+ // }
+ // return new String(toStringCache, true);
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Serializable fields for StringBuffer.
+ *
+ * @serialField value char[]
+ * The backing character array of this StringBuffer.
+ * @serialField count int
+ * The number of characters in this StringBuffer.
+ * @serialField shared boolean
+ * A flag indicating whether the backing array is shared.
+ * The value is ignored upon deserialization.
+ */
+ // private static final java.io.ObjectStreamField[] serialPersistentFields =
+ // {
+ // new java.io.ObjectStreamField("value", char[].class),
+ // new java.io.ObjectStreamField("count", Integer.TYPE),
+ // new java.io.ObjectStreamField("shared", Boolean.TYPE),
+ // };
+
+ /**
+ * readObject is called to restore the state of the StringBuffer from
+ * a stream.
+ */
+ // private synchronized void writeObject(java.io.ObjectOutputStream s)
+ // throws java.io.IOException {
+ // java.io.ObjectOutputStream.PutField fields = s.putFields();
+ // fields.put("value", value);
+ // fields.put("count", count);
+ // fields.put("shared", false);
+ // s.writeFields();
+ // }
+
+ /**
+ * readObject is called to restore the state of the StringBuffer from
+ * a stream.
+ */
+ // private void readObject(java.io.ObjectInputStream s)
+ // throws java.io.IOException, ClassNotFoundException {
+ // java.io.ObjectInputStream.GetField fields = s.readFields();
+ // value = (char[])fields.get("value", null);
+ // count = fields.get("count", 0);
+ // }
+}
diff --git a/src/main/java/java/lang/StringBuilder.java b/src/main/java/java/lang/StringBuilder.java
new file mode 100644
index 0000000..77e586b
--- /dev/null
+++ b/src/main/java/java/lang/StringBuilder.java
@@ -0,0 +1,663 @@
+/*
+ * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+ /*
+ * DIFFBLUE MODEL LIBRARY
+ * Some of the methods defined in this file will be replaced in CBMC, so their
+ * definition will be overwritten.
+ * These methods are marked as "Handled internally by CBMC".
+ */
+
+package java.lang;
+
+import org.cprover.CProver;
+import org.cprover.CProverString;
+
+/**
+ * A mutable sequence of characters. This class provides an API compatible
+ * with {@code StringBuffer}, but with no guarantee of synchronization.
+ * This class is designed for use as a drop-in replacement for
+ * {@code StringBuffer} in places where the string buffer was being
+ * used by a single thread (as is generally the case). Where possible,
+ * it is recommended that this class be used in preference to
+ * {@code StringBuffer} as it will be faster under most implementations.
+ *
+ * <p>The principal operations on a {@code StringBuilder} are the
+ * {@code append} and {@code insert} methods, which are
+ * overloaded so as to accept data of any type. Each effectively
+ * converts a given datum to a string and then appends or inserts the
+ * characters of that string to the string builder. The
+ * {@code append} method always adds these characters at the end
+ * of the builder; the {@code insert} method adds the characters at
+ * a specified point.
+ * <p>
+ * For example, if {@code z} refers to a string builder object
+ * whose current contents are "{@code start}", then
+ * the method call {@code z.append("le")} would cause the string
+ * builder to contain "{@code startle}", whereas
+ * {@code z.insert(4, "le")} would alter the string builder to
+ * contain "{@code starlet}".
+ * <p>
+ * In general, if sb refers to an instance of a {@code StringBuilder},
+ * then {@code sb.append(x)} has the same effect as
+ * {@code sb.insert(sb.length(), x)}.
+ * <p>
+ * Every string builder has a capacity. As long as the length of the
+ * character sequence contained in the string builder does not exceed
+ * the capacity, it is not necessary to allocate a new internal
+ * buffer. If the internal buffer overflows, it is automatically made larger.
+ *
+ * <p>Instances of {@code StringBuilder} are not safe for
+ * use by multiple threads. If such synchronization is required then it is
+ * recommended that {@link java.lang.StringBuffer} be used.
+ *
+ * <p>Unless otherwise noted, passing a {@code null} argument to a constructor
+ * or method in this class will cause a {@link NullPointerException} to be
+ * thrown.
+ *
+ * @author Michael McCloskey
+ * @see java.lang.StringBuffer
+ * @see java.lang.String
+ * @since 1.5
+ *
+ * @diffblue.limitedSupport
+ * Most methods are not supported yet.
+ * The methods that are supported have limited support as they do not handle
+ * exceptions.
+ */
+public final class StringBuilder
+ extends AbstractStringBuilder
+ implements java.io.Serializable, CharSequence
+{
+
+ /** use serialVersionUID for interoperability */
+ static final long serialVersionUID = 4383685877147921099L;
+
+ /**
+ * Constructs a string builder with no characters in it and an
+ * initial capacity of 16 characters.
+ *
+ * @diffblue.fullSupport
+ */
+ public StringBuilder() {
+ // DIFFBLUE MODEL LIBRARY modelled internally in CBMC
+ // super(16);
+ }
+
+ /**
+ * Constructs a string builder with no characters in it and an
+ * initial capacity specified by the {@code capacity} argument.
+ *
+ * @param capacity the initial capacity.
+ * @throws NegativeArraySizeException if the {@code capacity}
+ * argument is less than {@code 0}.
+ *
+ * @diffblue.noSupport
+ */
+ public StringBuilder(int capacity) {
+ CProver.notModelled();
+ // super(capacity);
+ }
+
+ /**
+ * Constructs a string builder initialized to the contents of the
+ * specified string. The initial capacity of the string builder is
+ * {@code 16} plus the length of the string argument.
+ *
+ * @param str the initial contents of the buffer.
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ public StringBuilder(String str) {
+ // DIFFBLUE MODEL LIBRARY modelled internally in CBMC
+ // super(str.length() + 16);
+ // append(str);
+ }
+
+ /**
+ * Constructs a string builder that contains the same characters
+ * as the specified {@code CharSequence}. The initial capacity of
+ * the string builder is {@code 16} plus the length of the
+ * {@code CharSequence} argument.
+ *
+ * @param seq the sequence to copy.
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ public StringBuilder(CharSequence seq) {
+ append(seq);
+ // this(seq.length() + 16);
+ // append(seq);
+ }
+
+ /**
+ * @diffblue.limitedSupport
+ * This method can be slow to generate tests due to TG-2866 and is
+ * also limited by which {@code toString()} methods have been modelled.
+ */
+ @Override
+ public StringBuilder append(Object obj) {
+ // return append(String.valueOf(obj));
+ String temp = (obj == null) ? "null" : obj.toString();
+ return append(temp);
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder append(String str) {
+ // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC
+ // super.append(str);
+ // return this;
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Appends the specified {@code StringBuffer} to this sequence.
+ * <p>
+ * The characters of the {@code StringBuffer} argument are appended,
+ * in order, to this sequence, increasing the
+ * length of this sequence by the length of the argument.
+ * If {@code sb} is {@code null}, then the four characters
+ * {@code "null"} are appended to this sequence.
+ * <p>
+ * Let <i>n</i> be the length of this character sequence just prior to
+ * execution of the {@code append} method. Then the character at index
+ * <i>k</i> in the new character sequence is equal to the character at
+ * index <i>k</i> in the old character sequence, if <i>k</i> is less than
+ * <i>n</i>; otherwise, it is equal to the character at index <i>k-n</i>
+ * in the argument {@code sb}.
+ *
+ * @param sb the {@code StringBuffer} to append.
+ * @return a reference to this object.
+ *
+ * @diffblue.noSupport
+ */
+ public StringBuilder append(StringBuffer sb) {
+ // super.append(sb);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder append(CharSequence s) {
+ return append(s.toString());
+ // super.append(s);
+ // return this;
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * Thrown exception has no message.
+ * @diffblue.untested Only exception throwing is tested.
+ */
+ @Override
+ public StringBuilder append(CharSequence s, int start, int end) {
+ // super.append(s, start, end);
+ // return this;
+ if ((start < 0) || (start > end) || (end > s.length())) {
+ throw new IndexOutOfBoundsException();
+ }
+
+ return CProverString.append(this, s, start, end);
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder append(char[] str) {
+ // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC
+ // super.append(str);
+ // return this;
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuilder append(char[] str, int offset, int len) {
+ // super.append(str, offset, len);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder append(boolean b) {
+ // super.append(b);
+ // return this;
+ return append(String.valueOf(b));
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder append(char c) {
+ // super.append(c);
+ // return this;
+ return append(String.valueOf(c));
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder append(int i) {
+ // super.append(i);
+ // return this;
+ return append(String.valueOf(i));
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder append(long lng) {
+ // super.append(lng);
+ // return this;
+ return append(String.valueOf(lng));
+ }
+
+ /**
+ * @diffblue.limitedSupport
+ * Result string is an approximate the value.
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder append(float f) {
+ // super.append(f);
+ // return this;
+ return append(String.valueOf(f));
+ }
+
+ /**
+ * @diffblue.limitedSupport
+ * Result string is an approximate the value.
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder append(double d) {
+ // super.append(d);
+ // return this;
+ return append(String.valueOf(d));
+ }
+
+ /**
+ * @since 1.5
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public StringBuilder appendCodePoint(int codePoint) {
+ // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC
+ // super.appendCodePoint(codePoint);
+ // return this;
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested.
+ */
+ @Override
+ public StringBuilder delete(int start, int end) {
+ // super.delete(start, end);
+ // return this;
+ if (start < 0)
+ throw new StringIndexOutOfBoundsException(start);
+ if (end > this.length())
+ end = this.length();
+ if (start > end)
+ throw new StringIndexOutOfBoundsException();
+ return CProverString.delete(this, start, end);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception support is tested.
+ * */
+ @Override
+ public StringBuilder deleteCharAt(int index) {
+ // super.deleteCharAt(index);
+ // return this;
+ if ((index < 0) || (index >= this.length()))
+ throw new StringIndexOutOfBoundsException(index);
+ return CProverString.deleteCharAt(this, index);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuilder replace(int start, int end, String str) {
+ // super.replace(start, end, str);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuilder insert(int index, char[] str, int offset,
+ int len)
+ {
+ // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC
+ // super.insert(index, str, offset, len);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuilder insert(int offset, Object obj) {
+ // super.insert(offset, obj);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public StringBuilder insert(int offset, String str) {
+ // super.insert(offset, str);
+ // return this;
+ if ((offset < 0) || (offset > length()))
+ throw new StringIndexOutOfBoundsException(offset);
+ return CProverString.insert(this, offset, str);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuilder insert(int offset, char[] str) {
+ // super.insert(offset, str);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuilder insert(int dstOffset, CharSequence s) {
+ // super.insert(dstOffset, s);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuilder insert(int dstOffset, CharSequence s,
+ int start, int end)
+ {
+ // super.insert(dstOffset, s, start, end);
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public StringBuilder insert(int offset, boolean b) {
+ // super.insert(offset, b);
+ // return this;
+ if ((offset < 0) || (offset > length()))
+ throw new StringIndexOutOfBoundsException(offset);
+ return CProverString.insert(this, offset, b);
+ }
+
+ /**
+ * @throws IndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public StringBuilder insert(int offset, char c) {
+ // super.insert(offset, c);
+ // return this;
+ if ((offset < 0) || (offset > length()))
+ throw new IndexOutOfBoundsException();
+ return CProverString.insert(this, offset, c);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public StringBuilder insert(int offset, int i) {
+ // super.insert(offset, i);
+ // return this;
+ if ((offset < 0) || (offset > length()))
+ throw new StringIndexOutOfBoundsException(offset);
+ return CProverString.insert(this, offset, i);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public StringBuilder insert(int offset, long l) {
+ // super.insert(offset, l);
+ // return this;
+ if ((offset < 0) || (offset > length()))
+ throw new StringIndexOutOfBoundsException(offset);
+ return CProverString.insert(this, offset, l);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.limitedSupport
+ * Value of the floating point is approximated.
+ * @diffblue.untested Only exception throwing is tested
+ */
+ @Override
+ public StringBuilder insert(int offset, float f) {
+ // super.insert(offset, f);
+ // return this;
+ if ((offset < 0) || (offset > length()))
+ throw new StringIndexOutOfBoundsException(offset);
+ return CProverString.insert(this, offset, f);
+ }
+
+ /**
+ * @throws StringIndexOutOfBoundsException {@inheritDoc}
+ *
+ * @diffblue.noSupport
+ * Value of the floating point is approximated.
+ * @diffblue.untested Only exception throwing is tested
+ * @diffblue.todo Handle CProverString.insert(StringBuilder, int, double)
+ * in jbmc.
+ */
+ @Override
+ public StringBuilder insert(int offset, double d) {
+ // super.insert(offset, d);
+ // return this;
+ if ((offset < 0) || (offset > length()))
+ throw new StringIndexOutOfBoundsException(offset);
+ return CProverString.insert(this, offset, d);
+ }
+
+ /**
+ * @diffblue.noSupport
+ */
+ @Override
+ public int indexOf(String str) {
+ // return super.indexOf(str);
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @diffblue.noSupport
+ */
+ @Override
+ public int indexOf(String str, int fromIndex) {
+ // return super.indexOf(str, fromIndex);
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @diffblue.noSupport
+ */
+ @Override
+ public int lastIndexOf(String str) {
+ // return super.lastIndexOf(str);
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @diffblue.noSupport
+ */
+ @Override
+ public int lastIndexOf(String str, int fromIndex) {
+ // return super.lastIndexOf(str, fromIndex);
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * @diffblue.noSupport
+ */
+ @Override
+ public StringBuilder reverse() {
+ // super.reverse();
+ // return this;
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * @diffblue.fullSupport
+ * @diffblue.untested
+ */
+ @Override
+ public String toString() {
+ // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC
+ // // Create a copy, don't share the array
+ // return new String(value, 0, count);
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Save the state of the {@code StringBuilder} instance to a stream
+ * (that is, serialize it).
+ *
+ * @serialData the number of characters currently stored in the string
+ * builder ({@code int}), followed by the characters in the
+ * string builder ({@code char[]}). The length of the
+ * {@code char} array may be greater than the number of
+ * characters currently stored in the string builder, in which
+ * case extra characters are ignored.
+ */
+ // private void writeObject(java.io.ObjectOutputStream s)
+ // throws java.io.IOException {
+ // s.defaultWriteObject();
+ // s.writeInt(count);
+ // s.writeObject(value);
+ // }
+
+ /**
+ * readObject is called to restore the state of the StringBuffer from
+ * a stream.
+ */
+ // private void readObject(java.io.ObjectInputStream s)
+ // throws java.io.IOException, ClassNotFoundException {
+ // s.defaultReadObject();
+ // count = s.readInt();
+ // value = (char[]) s.readObject();
+ // }
+
+}
diff --git a/src/main/java/java/lang/StringIndexOutOfBoundsException.java b/src/main/java/java/lang/StringIndexOutOfBoundsException.java
new file mode 100644
index 0000000..c9c4beb
--- /dev/null
+++ b/src/main/java/java/lang/StringIndexOutOfBoundsException.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public
+class StringIndexOutOfBoundsException extends IndexOutOfBoundsException {
+ private static final long serialVersionUID = -6762910422159637258L;
+
+ public StringIndexOutOfBoundsException() {
+ super();
+ }
+
+ public StringIndexOutOfBoundsException(String s) {
+ super(s);
+ }
+
+ public StringIndexOutOfBoundsException(int index) {
+ super("String index out of range: " + index);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.StringIndexOutOfBoundsException: " + message)
+ : "java.lang.StringIndexOutOfBoundsException";
+ }
+}
diff --git a/src/main/java/java/lang/Throwable.java b/src/main/java/java/lang/Throwable.java
index 8cd0ed8..bed9779 100644
--- a/src/main/java/java/lang/Throwable.java
+++ b/src/main/java/java/lang/Throwable.java
@@ -159,7 +159,8 @@ public class Throwable implements Serializable {
/**
* A shared value for an empty stack.
*/
- private static final StackTraceElement[] UNASSIGNED_STACK = new StackTraceElement[0];
+ // DIFFBLUE MODEL LIBRARY
+ // private static final StackTraceElement[] UNASSIGNED_STACK = new StackTraceElement[0];
/*
* To allow Throwable objects to be made immutable and safely
@@ -210,7 +211,8 @@ public class Throwable implements Serializable {
* @serial
* @since 1.4
*/
- private StackTraceElement[] stackTrace = UNASSIGNED_STACK;
+ // DIFFBLUE MODEL LIBRARY
+ // private StackTraceElement[] stackTrace = UNASSIGNED_STACK;
// DIFFBLUE MODEL LIBRARY Uncommenting the following line would be helpful
// for modelling some methods, but deterministic memory in models is not
// currently supported.
@@ -232,20 +234,24 @@ public class Throwable implements Serializable {
* @serial
* @since 1.7
*/
+ // DIFFBLUE MODEL LIBRARY
// private List<Throwable> suppressedExceptions = SUPPRESSED_SENTINEL;
- private List<Throwable> suppressedExceptions;
/** Message for trying to suppress a null exception. */
- private static final String NULL_CAUSE_MESSAGE = "Cannot suppress a null exception.";
+ // DIFFBLUE MODEL LIBRARY
+ // private static final String NULL_CAUSE_MESSAGE = "Cannot suppress a null exception.";
/** Message for trying to suppress oneself. */
- private static final String SELF_SUPPRESSION_MESSAGE = "Self-suppression not permitted";
+ // DIFFBLUE MODEL LIBRARY
+ // private static final String SELF_SUPPRESSION_MESSAGE = "Self-suppression not permitted";
/** Caption for labeling causative exception stack traces */
- private static final String CAUSE_CAPTION = "Caused by: ";
+ // DIFFBLUE MODEL LIBRARY
+ // private static final String CAUSE_CAPTION = "Caused by: ";
/** Caption for labeling suppressed exception stack traces */
- private static final String SUPPRESSED_CAPTION = "Suppressed: ";
+ // DIFFBLUE MODEL LIBRARY
+ // private static final String SUPPRESSED_CAPTION = "Suppressed: ";
/**
* Constructs a new throwable with {@code null} as its detail message.
@@ -365,16 +371,18 @@ public Throwable(Throwable cause) {
protected Throwable(String message, Throwable cause,
boolean enableSuppression,
boolean writableStackTrace) {
- if (writableStackTrace) {
- // fillInStackTrace();
- } else {
- stackTrace = null;
- }
+ // DIFFBLUE MODEL LIBRARY
+ // if (writableStackTrace) {
+ // fillInStackTrace();
+ // } else {
+ // stackTrace = null;
+ // }
detailMessage = message;
this.cause = cause;
- if (!enableSuppression) {
- suppressedExceptions = null;
- }
+ // DIFFBLUE MODEL LIBRARY
+ // if (!enableSuppression) {
+ // suppressedExceptions = null;
+ // }
}
/**
@@ -809,14 +817,14 @@ public synchronized Throwable fillInStackTrace() {
// }
// return this;
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
// DIFFBLUE MODEL LIBRARY We do not model native methods.
// private native Throwable fillInStackTrace(int dummy);
private Throwable fillInStackTrace(int dummy) {
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
/**
@@ -861,7 +869,7 @@ private synchronized StackTraceElement[] getOurStackTrace() {
// }
// return stackTrace;
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
/**
@@ -935,7 +943,7 @@ int getStackTraceDepth() {
// native StackTraceElement getStackTraceElement(int index);
StackTraceElement getStackTraceElement(int index) {
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
/**
@@ -1105,7 +1113,8 @@ public final synchronized void addSuppressed(Throwable exception) {
CProver.notModelled();
}
- private static final Throwable[] EMPTY_THROWABLE_ARRAY = new Throwable[0];
+ // DIFFBLUE MODEL LIBRARY
+ // private static final Throwable[] EMPTY_THROWABLE_ARRAY = new Throwable[0];
/**
* Returns an array containing all of the exceptions that were
@@ -1129,6 +1138,6 @@ public final synchronized Throwable[] getSuppressed() {
// else
// return suppressedExceptions.toArray(EMPTY_THROWABLE_ARRAY);
CProver.notModelled();
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
}
diff --git a/src/main/java/java/lang/TypeNotPresentException.java b/src/main/java/java/lang/TypeNotPresentException.java
new file mode 100644
index 0000000..525214f
--- /dev/null
+++ b/src/main/java/java/lang/TypeNotPresentException.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public class TypeNotPresentException extends RuntimeException {
+ private static final long serialVersionUID = -5101214195716534496L;
+
+ private String typeName;
+
+ public TypeNotPresentException(String typeName, Throwable cause) {
+ super("Type " + typeName + " not present", cause);
+ this.typeName = typeName;
+ }
+
+ public String typeName() { return typeName;}
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.TypeNotPresentException: " + message)
+ : "java.lang.TypeNotPresentException";
+ }
+}
diff --git a/src/main/java/java/lang/UnknownError.java b/src/main/java/java/lang/UnknownError.java
new file mode 100644
index 0000000..e1fffd2
--- /dev/null
+++ b/src/main/java/java/lang/UnknownError.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when an unknown but serious exception has occurred in the
+ * Java Virtual Machine.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public
+class UnknownError extends VirtualMachineError {
+ private static final long serialVersionUID = 2524784860676771849L;
+
+ /**
+ * Constructs an <code>UnknownError</code> with no detail message.
+ */
+ public UnknownError() {
+ super();
+ }
+
+ /**
+ * Constructs an <code>UnknownError</code> with the specified detail
+ * message.
+ *
+ * @param s the detail message.
+ */
+ public UnknownError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.UnknownError: " + message)
+ : "java.lang.UnknownError";
+ }
+}
diff --git a/src/main/java/java/lang/UnsatisfiedLinkError.java b/src/main/java/java/lang/UnsatisfiedLinkError.java
new file mode 100644
index 0000000..fc05b5a
--- /dev/null
+++ b/src/main/java/java/lang/UnsatisfiedLinkError.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 1994, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown if the Java Virtual Machine cannot find an appropriate
+ * native-language definition of a method declared <code>native</code>.
+ *
+ * @author unascribed
+ * @see java.lang.Runtime
+ * @since JDK1.0
+ */
+public
+class UnsatisfiedLinkError extends LinkageError {
+ private static final long serialVersionUID = -4019343241616879428L;
+
+ /**
+ * Constructs an <code>UnsatisfiedLinkError</code> with no detail message.
+ */
+ public UnsatisfiedLinkError() {
+ super();
+ }
+
+ /**
+ * Constructs an <code>UnsatisfiedLinkError</code> with the
+ * specified detail message.
+ *
+ * @param s the detail message.
+ */
+ public UnsatisfiedLinkError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.UnsatisfiedLinkError: " + message)
+ : "java.lang.UnsatisfiedLinkError";
+ }
+}
diff --git a/src/main/java/java/lang/UnsupportedClassVersionError.java b/src/main/java/java/lang/UnsupportedClassVersionError.java
new file mode 100644
index 0000000..eb9294c
--- /dev/null
+++ b/src/main/java/java/lang/UnsupportedClassVersionError.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 1998, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when the Java Virtual Machine attempts to read a class
+ * file and determines that the major and minor version numbers
+ * in the file are not supported.
+ *
+ * @since 1.2
+ */
+public
+class UnsupportedClassVersionError extends ClassFormatError {
+ private static final long serialVersionUID = -7123279212883497373L;
+
+ /**
+ * Constructs a <code>UnsupportedClassVersionError</code>
+ * with no detail message.
+ */
+ public UnsupportedClassVersionError() {
+ super();
+ }
+
+ /**
+ * Constructs a <code>UnsupportedClassVersionError</code> with
+ * the specified detail message.
+ *
+ * @param s the detail message.
+ */
+ public UnsupportedClassVersionError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.UnsupportedClassVersionError: " + message)
+ : "java.lang.UnsupportedClassVersionError";
+ }
+}
diff --git a/src/main/java/java/lang/UnsupportedOperationException.java b/src/main/java/java/lang/UnsupportedOperationException.java
new file mode 100644
index 0000000..a89da96
--- /dev/null
+++ b/src/main/java/java/lang/UnsupportedOperationException.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+public class UnsupportedOperationException extends RuntimeException {
+ public UnsupportedOperationException() {
+ }
+
+ public UnsupportedOperationException(String message) {
+ super(message);
+ }
+
+ public UnsupportedOperationException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public UnsupportedOperationException(Throwable cause) {
+ super(cause);
+ }
+
+ static final long serialVersionUID = -1242599979055084673L;
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.UnsupportedOperationException: " + message)
+ : "java.lang.UnsupportedOperationException";
+ }
+}
diff --git a/src/main/java/java/lang/VerifyError.java b/src/main/java/java/lang/VerifyError.java
new file mode 100644
index 0000000..315a6db
--- /dev/null
+++ b/src/main/java/java/lang/VerifyError.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown when the "verifier" detects that a class file,
+ * though well formed, contains some sort of internal inconsistency
+ * or security problem.
+ *
+ * @author unascribed
+ * @since JDK1.0
+ */
+public
+class VerifyError extends LinkageError {
+ private static final long serialVersionUID = 7001962396098498785L;
+
+ /**
+ * Constructs an <code>VerifyError</code> with no detail message.
+ */
+ public VerifyError() {
+ super();
+ }
+
+ /**
+ * Constructs an <code>VerifyError</code> with the specified detail message.
+ *
+ * @param s the detail message.
+ */
+ public VerifyError(String s) {
+ super(s);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.VerifyError: " + message)
+ : "java.lang.VerifyError";
+ }
+}
diff --git a/src/main/java/java/lang/VirtualMachineError.java b/src/main/java/java/lang/VirtualMachineError.java
new file mode 100644
index 0000000..c20306f
--- /dev/null
+++ b/src/main/java/java/lang/VirtualMachineError.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang;
+
+/**
+ * Thrown to indicate that the Java Virtual Machine is broken or has
+ * run out of resources necessary for it to continue operating.
+ *
+ *
+ * @author Frank Yellin
+ * @since JDK1.0
+ */
+abstract public class VirtualMachineError extends Error {
+ private static final long serialVersionUID = 4161983926571568670L;
+
+ /**
+ * Constructs a <code>VirtualMachineError</code> with no detail message.
+ */
+ public VirtualMachineError() {
+ super();
+ }
+
+ /**
+ * Constructs a <code>VirtualMachineError</code> with the specified
+ * detail message.
+ *
+ * @param message the detail message.
+ */
+ public VirtualMachineError(String message) {
+ super(message);
+ }
+
+ /**
+ * Constructs a {@code VirtualMachineError} with the specified
+ * detail message and cause. <p>Note that the detail message
+ * associated with {@code cause} is <i>not</i> automatically
+ * incorporated in this error's detail message.
+ *
+ * @param message the detail message (which is saved for later retrieval
+ * by the {@link #getMessage()} method).
+ * @param cause the cause (which is saved for later retrieval by the
+ * {@link #getCause()} method). (A {@code null} value is
+ * permitted, and indicates that the cause is nonexistent or
+ * unknown.)
+ * @since 1.8
+ */
+ public VirtualMachineError(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ /**
+ * Constructs an a {@code VirtualMachineError} with the specified
+ * cause and a detail message of {@code (cause==null ? null :
+ * cause.toString())} (which typically contains the class and
+ * detail message of {@code cause}).
+ *
+ * @param cause the cause (which is saved for later retrieval by the
+ * {@link #getCause()} method). (A {@code null} value is
+ * permitted, and indicates that the cause is nonexistent or
+ * unknown.)
+ * @since 1.8
+ */
+ public VirtualMachineError(Throwable cause) {
+ super(cause);
+ }
+
+ // DIFFBLUE MODEL LIBRARY
+ // While Object.getClass() is not modelled, we can get the same
+ // functionality by adding one toString() method per subclass of
+ // Throwable.
+ @Override
+ public String toString() {
+ String message = getLocalizedMessage();
+ return (message != null)
+ ? ("java.lang.VirtualMachineError: " + message)
+ : "java.lang.VirtualMachineError";
+ }
+}
diff --git a/src/main/java/java/util/Random.java b/src/main/java/java/util/Random.java
new file mode 100644
index 0000000..49a5597
--- /dev/null
+++ b/src/main/java/java/util/Random.java
@@ -0,0 +1,1396 @@
+/*
+ * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.util;
+// import java.io.*;
+// import java.util.concurrent.atomic.AtomicLong;
+// import java.util.function.DoubleConsumer;
+// import java.util.function.IntConsumer;
+// import java.util.function.LongConsumer;
+ import java.util.stream.DoubleStream;
+ import java.util.stream.IntStream;
+ import java.util.stream.LongStream;
+// import java.util.stream.StreamSupport;
+
+// import sun.misc.Unsafe;
+
+import org.cprover.CProver;
+
+/**
+ * An instance of this class is used to generate a stream of
+ * pseudorandom numbers. The class uses a 48-bit seed, which is
+ * modified using a linear congruential formula. (See Donald Knuth,
+ * <i>The Art of Computer Programming, Volume 2</i>, Section 3.2.1.)
+ * <p>
+ * If two instances of {@code Random} are created with the same
+ * seed, and the same sequence of method calls is made for each, they
+ * will generate and return identical sequences of numbers. In order to
+ * guarantee this property, particular algorithms are specified for the
+ * class {@code Random}. Java implementations must use all the algorithms
+ * shown here for the class {@code Random}, for the sake of absolute
+ * portability of Java code. However, subclasses of class {@code Random}
+ * are permitted to use other algorithms, so long as they adhere to the
+ * general contracts for all the methods.
+ * <p>
+ * The algorithms implemented by class {@code Random} use a
+ * {@code protected} utility method that on each invocation can supply
+ * up to 32 pseudorandomly generated bits.
+ * <p>
+ * Many applications will find the method {@link Math#random} simpler to use.
+ *
+ * <p>Instances of {@code java.util.Random} are threadsafe.
+ * However, the concurrent use of the same {@code java.util.Random}
+ * instance across threads may encounter contention and consequent
+ * poor performance. Consider instead using
+ * {@link java.util.concurrent.ThreadLocalRandom} in multithreaded
+ * designs.
+ *
+ * <p>Instances of {@code java.util.Random} are not cryptographically
+ * secure. Consider instead using {@link java.security.SecureRandom} to
+ * get a cryptographically secure pseudo-random number generator for use
+ * by security-sensitive applications.
+ *
+ * @author Frank Yellin
+ * @since 1.0
+ *
+ * @diffblue.limitedSupport
+ * Some methods are not yet implemented, and the effect of custom seeds is not
+ * visible in generated tests, which is not a problem as long as this class is
+ * mocked.
+ *
+ * @diffblue.mock
+ */
+public
+class Random implements java.io.Serializable {
+ /** use serialVersionUID from JDK 1.1 for interoperability */
+ // static final long serialVersionUID = 3905348978240129619L;
+
+ /**
+ * The internal state associated with this pseudorandom number generator.
+ * (The specs for the methods in this class describe the ongoing
+ * computation of this value.)
+ */
+ // private final AtomicLong seed;
+
+ // private static final long multiplier = 0x5DEECE66DL;
+ // private static final long addend = 0xBL;
+ // private static final long mask = (1L << 48) - 1;
+
+ private static final double DOUBLE_UNIT = 0x1.0p-53; // 1.0 / (1L << 53)
+
+ // IllegalArgumentException messages
+ // static final String BadBound = "bound must be positive";
+ // static final String BadRange = "bound must be greater than origin";
+ // static final String BadSize = "size must be non-negative";
+
+ /**
+ * Creates a new random number generator. This constructor sets
+ * the seed of the random number generator to a value very likely
+ * to be distinct from any other invocation of this constructor.
+ *
+ * @diffblue.fullSupport
+ * @diffblue.mock
+ */
+ public Random() {
+ // this(seedUniquifier() ^ System.nanoTime());
+ }
+
+ // private static long seedUniquifier() {
+ // L'Ecuyer, "Tables of Linear Congruential Generators of
+ // Different Sizes and Good Lattice Structure", 1999
+ // for (;;) {
+ // long current = seedUniquifier.get();
+ // long next = current * 181783497276652981L;
+ // if (seedUniquifier.compareAndSet(current, next))
+ // return next;
+ // }
+ // CProver.notModelled();
+ // return CProver.nondetLong();
+ // }
+
+ // private static final AtomicLong seedUniquifier
+ // = new AtomicLong(8682522807148012L);
+
+ /**
+ * Creates a new random number generator using a single {@code long} seed.
+ * The seed is the initial value of the internal state of the pseudorandom
+ * number generator which is maintained by method {@link #next}.
+ *
+ * <p>The invocation {@code new Random(seed)} is equivalent to:
+ * <pre> {@code
+ * Random rnd = new Random();
+ * rnd.setSeed(seed);}</pre>
+ *
+ * @param seed the initial seed
+ * @see #setSeed(long)
+ *
+ * @diffblue.limitedSupport
+ * The seed is ignored and the behaviour is exactly the same as that of the
+ * constructor with no arguments.
+ *
+ * @diffblue.mock
+ */
+ public Random(long seed) {
+ // if (getClass() == Random.class)
+ // this.seed = new AtomicLong(initialScramble(seed));
+ // else {
+ // // subclass might have overriden setSeed
+ // this.seed = new AtomicLong();
+ // setSeed(seed);
+ // }
+ }
+
+ // private static long initialScramble(long seed) {
+ // return (seed ^ multiplier) & mask;
+ // return CProver.nondetLong();
+ // }
+
+ /**
+ * Sets the seed of this random number generator using a single
+ * {@code long} seed. The general contract of {@code setSeed} is
+ * that it alters the state of this random number generator object
+ * so as to be in exactly the same state as if it had just been
+ * created with the argument {@code seed} as a seed. The method
+ * {@code setSeed} is implemented by class {@code Random} by
+ * atomically updating the seed to
+ * <pre>{@code (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)}</pre>
+ * and clearing the {@code haveNextNextGaussian} flag used by {@link
+ * #nextGaussian}.
+ *
+ * <p>The implementation of {@code setSeed} by class {@code Random}
+ * happens to use only 48 bits of the given seed. In general, however,
+ * an overriding method may use all 64 bits of the {@code long}
+ * argument as a seed value.
+ *
+ * @param seed the initial seed
+ *
+ * @diffblue.noSupport
+ * Due to TG-2435.<br>
+ * We currently ignore seeds and make test-generator pick return values
+ * for the methods in this class nondeterministically rather than
+ * calculating them according to a probability distribution. So this
+ * method is simply modelled as a no-op.
+ *
+ * @diffblue.mock
+ */
+ synchronized public void setSeed(long seed) {
+ // this.seed.set(initialScramble(seed));
+ // haveNextNextGaussian = false;
+ }
+
+ /**
+ * Generates the next pseudorandom number. Subclasses should
+ * override this, as this is used by all other methods.
+ *
+ * <p>The general contract of {@code next} is that it returns an
+ * {@code int} value and if the argument {@code bits} is between
+ * {@code 1} and {@code 32} (inclusive), then that many low-order
+ * bits of the returned value will be (approximately) independently
+ * chosen bit values, each of which is (approximately) equally
+ * likely to be {@code 0} or {@code 1}. The method {@code next} is
+ * implemented by class {@code Random} by atomically updating the seed to
+ * <pre>{@code (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)}</pre>
+ * and returning
+ * <pre>{@code (int)(seed >>> (48 - bits))}.</pre>
+ *
+ * This is a linear congruential pseudorandom number generator, as
+ * defined by D. H. Lehmer and described by Donald E. Knuth in
+ * <i>The Art of Computer Programming,</i> Volume 3:
+ * <i>Seminumerical Algorithms</i>, section 3.2.1.
+ *
+ * @param bits random bits
+ * @return the next pseudorandom value from this random number
+ * generator's sequence
+ * @since 1.1
+ *
+ * @diffblue.noSupport
+ */
+ protected int next(int bits) {
+ // long oldseed, nextseed;
+ // AtomicLong seed = this.seed;
+ // do {
+ // oldseed = seed.get();
+ // nextseed = (oldseed * multiplier + addend) & mask;
+ // } while (!seed.compareAndSet(oldseed, nextseed));
+ // return (int)(nextseed >>> (48 - bits));
+ CProver.notModelled();
+ return CProver.nondetInt();
+ }
+
+ /**
+ * Generates random bytes and places them into a user-supplied
+ * byte array. The number of random bytes produced is equal to
+ * the length of the byte array.
+ *
+ * <p>The method {@code nextBytes} is implemented by class {@code Random}
+ * as if by:
+ * <pre> {@code
+ * public void nextBytes(byte[] bytes) {
+ * for (int i = 0; i < bytes.length; )
+ * for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4);
+ * n-- > 0; rnd >>= 8)
+ * bytes[i++] = (byte)rnd;
+ * }}</pre>
+ *
+ * @param bytes the byte array to fill with random bytes
+ * @throws NullPointerException if the byte array is null
+ * @since 1.1
+ *
+ * @diffblue.noSupport
+ * Due to TG-2435.<br>
+ * This method sets each entry of the argument to a nondeterministic
+ * {@code byte} value.
+ * The nondeterminism is introduced by test-generator itself, and
+ * probability distributions are ignored.
+ *
+ * @diffblue.mock
+ */
+ public void nextBytes(byte[] bytes) {
+ // for (int i = 0, len = bytes.length; i < len; )
+ // for (int rnd = nextInt(),
+ // n = Math.min(len - i, Integer.SIZE/Byte.SIZE);
+ // n-- > 0; rnd >>= Byte.SIZE)
+ // bytes[i++] = (byte)rnd;
+
+ for (int i = 0; i < bytes.length; i++) {
+ byte b = CProver.nondetByte();
+ bytes[i] = b;
+ }
+ }
+
+ /**
+ * The form of nextLong used by LongStream Spliterators. If
+ * origin is greater than bound, acts as unbounded form of
+ * nextLong, else as bounded form.
+ *
+ * @param origin the least value, unless greater than bound
+ * @param bound the upper bound (exclusive), must not equal origin
+ * @return a pseudorandom value
+ */
+ // DIFFBLUE MODEL LIBRARY
+ // This package-private method is not used in the model.
+ // final long internalNextLong(long origin, long bound) {
+ // long r = nextLong();
+ // if (origin < bound) {
+ // long n = bound - origin, m = n - 1;
+ // if ((n & m) == 0L) // power of two
+ // r = (r & m) + origin;
+ // else if (n > 0L) { // reject over-represented candidates
+ // for (long u = r >>> 1; // ensure nonnegative
+ // u + m - (r = u % n) < 0L; // rejection check
+ // u = nextLong() >>> 1) // retry
+ // ;
+ // r += origin;
+ // }
+ // else { // range not representable as long
+ // while (r < origin || r >= bound)
+ // r = nextLong();
+ // }
+ // }
+ // return r;
+ // }
+
+ /**
+ * The form of nextInt used by IntStream Spliterators.
+ * For the unbounded case: uses nextInt().
+ * For the bounded case with representable range: uses nextInt(int bound)
+ * For the bounded case with unrepresentable range: uses nextInt()
+ *
+ * @param origin the least value, unless greater than bound
+ * @param bound the upper bound (exclusive), must not equal origin
+ * @return a pseudorandom value
+ */
+ // DIFFBLUE MODEL LIBRARY
+ // This package-private method is not used in the model.
+ // final int internalNextInt(int origin, int bound) {
+ // if (origin < bound) {
+ // int n = bound - origin;
+ // if (n > 0) {
+ // return nextInt(n) + origin;
+ // }
+ // else { // range not representable as int
+ // int r;
+ // do {
+ // r = nextInt();
+ // } while (r < origin || r >= bound);
+ // return r;
+ // }
+ // }
+ // else {
+ // return nextInt();
+ // }
+ // }
+
+ /**
+ * The form of nextDouble used by DoubleStream Spliterators.
+ *
+ * @param origin the least value, unless greater than bound
+ * @param bound the upper bound (exclusive), must not equal origin
+ * @return a pseudorandom value
+ */
+ // DIFFBLUE MODEL LIBRARY
+ // This package-private method is not used in the model.
+ // final double internalNextDouble(double origin, double bound) {
+ // double r = nextDouble();
+ // if (origin < bound) {
+ // r = r * (bound - origin) + origin;
+ // if (r >= bound) // correct for rounding
+ // r = Double.longBitsToDouble(Double.doubleToLongBits(bound) - 1);
+ // }
+ // return r;
+ // }
+
+ /**
+ * Returns the next pseudorandom, uniformly distributed {@code int}
+ * value from this random number generator's sequence. The general
+ * contract of {@code nextInt} is that one {@code int} value is
+ * pseudorandomly generated and returned. All 2<sup>32</sup> possible
+ * {@code int} values are produced with (approximately) equal probability.
+ *
+ * <p>The method {@code nextInt} is implemented by class {@code Random}
+ * as if by:
+ * <pre> {@code
+ * public int nextInt() {
+ * return next(32);
+ * }}</pre>
+ *
+ * @return the next pseudorandom, uniformly distributed {@code int}
+ * value from this random number generator's sequence
+ *
+ * @diffblue.fullSupport
+ * This method returns a nondeterministic {@code int} value.
+ * The nondeterminism is introduced by test-generator itself, and
+ * probability distributions are ignored.
+ *
+ * @diffblue.mock
+ */
+ public int nextInt() {
+ // return next(32);
+ return CProver.nondetInt();
+ }
+
+ /**
+ * Returns a pseudorandom, uniformly distributed {@code int} value
+ * between 0 (inclusive) and the specified value (exclusive), drawn from
+ * this random number generator's sequence. The general contract of
+ * {@code nextInt} is that one {@code int} value in the specified range
+ * is pseudorandomly generated and returned. All {@code bound} possible
+ * {@code int} values are produced with (approximately) equal
+ * probability. The method {@code nextInt(int bound)} is implemented by
+ * class {@code Random} as if by:
+ * <pre> {@code
+ * public int nextInt(int bound) {
+ * if (bound <= 0)
+ * throw new IllegalArgumentException("bound must be positive");
+ *
+ * if ((bound & -bound) == bound) // i.e., bound is a power of 2
+ * return (int)((bound * (long)next(31)) >> 31);
+ *
+ * int bits, val;
+ * do {
+ * bits = next(31);
+ * val = bits % bound;
+ * } while (bits - val + (bound-1) < 0);
+ * return val;
+ * }}</pre>
+ *
+ * <p>The hedge "approximately" is used in the foregoing description only
+ * because the next method is only approximately an unbiased source of
+ * independently chosen bits. If it were a perfect source of randomly
+ * chosen bits, then the algorithm shown would choose {@code int}
+ * values from the stated range with perfect uniformity.
+ * <p>
+ * The algorithm is slightly tricky. It rejects values that would result
+ * in an uneven distribution (due to the fact that 2^31 is not divisible
+ * by n). The probability of a value being rejected depends on n. The
+ * worst case is n=2^30+1, for which the probability of a reject is 1/2,
+ * and the expected number of iterations before the loop terminates is 2.
+ * <p>
+ * The algorithm treats the case where n is a power of two specially: it
+ * returns the correct number of high-order bits from the underlying
+ * pseudo-random number generator. In the absence of special treatment,
+ * the correct number of <i>low-order</i> bits would be returned. Linear
+ * congruential pseudo-random number generators such as the one
+ * implemented by this class are known to have short periods in the
+ * sequence of values of their low-order bits. Thus, this special case
+ * greatly increases the length of the sequence of values returned by
+ * successive calls to this method if n is a small power of two.
+ *
+ * @param bound the upper bound (exclusive). Must be positive.
+ * @return the next pseudorandom, uniformly distributed {@code int}
+ * value between zero (inclusive) and {@code bound} (exclusive)
+ * from this random number generator's sequence
+ * @throws IllegalArgumentException if bound is not positive
+ * @since 1.2
+ *
+ * @diffblue.limitedSupport
+ * This method returns a nondeterministic {@code int} value between 0
+ * (inclusive) and {@code bound} (exclusive).
+ * The nondeterminism is introduced by test-generator itself, and
+ * probability distributions are ignored.
+ * Exceptions for mocked methods are currently not supported, see TG-1387.
+ *
+ * @diffblue.mock
+ */
+ public int nextInt(int bound) {
+ // if (bound <= 0)
+ // throw new IllegalArgumentException(BadBound);
+
+ // int r = next(31);
+ // int m = bound - 1;
+ // if ((bound & m) == 0) // i.e., bound is a power of 2
+ // r = (int)((bound * (long)r) >> 31);
+ // else {
+ // for (int u = r;
+ // u - (r = u % bound) + m < 0;
+ // u = next(31))
+ // ;
+ // }
+ // return r;
+
+ CProver.assume(bound > 0);
+ int result = CProver.nondetInt();
+ CProver.assume(0 <= result && result < bound);
+ return result;
+ }
+
+ /**
+ * Returns the next pseudorandom, uniformly distributed {@code long}
+ * value from this random number generator's sequence. The general
+ * contract of {@code nextLong} is that one {@code long} value is
+ * pseudorandomly generated and returned.
+ *
+ * <p>The method {@code nextLong} is implemented by class {@code Random}
+ * as if by:
+ * <pre> {@code
+ * public long nextLong() {
+ * return ((long)next(32) << 32) + next(32);
+ * }}</pre>
+ *
+ * Because class {@code Random} uses a seed with only 48 bits,
+ * this algorithm will not return all possible {@code long} values.
+ *
+ * @return the next pseudorandom, uniformly distributed {@code long}
+ * value from this random number generator's sequence
+ *
+ * @diffblue.limitedSupport
+ * This method returns a nondeterministic {@code long} value. Unlike the
+ * JDK, it can return all possible {@code long} values.
+ *
+ * @diffblue.mock
+ */
+ public long nextLong() {
+ // it's okay that the bottom word remains signed.
+ // return ((long)(next(32)) << 32) + next(32);
+ return CProver.nondetLong();
+ }
+
+ /**
+ * Returns the next pseudorandom, uniformly distributed
+ * {@code boolean} value from this random number generator's
+ * sequence. The general contract of {@code nextBoolean} is that one
+ * {@code boolean} value is pseudorandomly generated and returned. The
+ * values {@code true} and {@code false} are produced with
+ * (approximately) equal probability.
+ *
+ * <p>The method {@code nextBoolean} is implemented by class {@code Random}
+ * as if by:
+ * <pre> {@code
+ * public boolean nextBoolean() {
+ * return next(1) != 0;
+ * }}</pre>
+ *
+ * @return the next pseudorandom, uniformly distributed
+ * {@code boolean} value from this random number generator's
+ * sequence
+ * @since 1.2
+ *
+ * @diffblue.fullSupport
+ * This method returns a nondeterministic {@code boolean} value.
+ * The nondeterminism is introduced by test-generator itself, and
+ * probability distributions are ignored.
+ *
+ * @diffblue.mock
+ */
+ public boolean nextBoolean() {
+ // return next(1) != 0;
+ return CProver.nondetBoolean();
+ }
+
+ /**
+ * Returns the next pseudorandom, uniformly distributed {@code float}
+ * value between {@code 0.0} and {@code 1.0} from this random
+ * number generator's sequence.
+ *
+ * <p>The general contract of {@code nextFloat} is that one
+ * {@code float} value, chosen (approximately) uniformly from the
+ * range {@code 0.0f} (inclusive) to {@code 1.0f} (exclusive), is
+ * pseudorandomly generated and returned. All 2<sup>24</sup> possible
+ * {@code float} values of the form <i>m x </i>2<sup>-24</sup>,
+ * where <i>m</i> is a positive integer less than 2<sup>24</sup>, are
+ * produced with (approximately) equal probability.
+ *
+ * <p>The method {@code nextFloat} is implemented by class {@code Random}
+ * as if by:
+ * <pre> {@code
+ * public float nextFloat() {
+ * return next(24) / ((float)(1 << 24));
+ * }}</pre>
+ *
+ * <p>The hedge "approximately" is used in the foregoing description only
+ * because the next method is only approximately an unbiased source of
+ * independently chosen bits. If it were a perfect source of randomly
+ * chosen bits, then the algorithm shown would choose {@code float}
+ * values from the stated range with perfect uniformity.<p>
+ * [In early versions of Java, the result was incorrectly calculated as:
+ * <pre> {@code
+ * return next(30) / ((float)(1 << 30));}</pre>
+ * This might seem to be equivalent, if not better, but in fact it
+ * introduced a slight nonuniformity because of the bias in the rounding
+ * of floating-point numbers: it was slightly more likely that the
+ * low-order bit of the significand would be 0 than that it would be 1.]
+ *
+ * @return the next pseudorandom, uniformly distributed {@code float}
+ * value between {@code 0.0} and {@code 1.0} from this
+ * random number generator's sequence
+ *
+ * @diffblue.fullSupport
+ * This method returns a nondeterministic {@code float} value between 0.0
+ * (inclusive) and 1.0 (exclusive).
+ * The nondeterminism is introduced by test-generator itself, and
+ * probability distributions are ignored.
+ *
+ * @diffblue.mock
+ */
+ public float nextFloat() {
+ // return next(24) / ((float)(1 << 24));
+ float result = CProver.nondetFloat();
+ CProver.assume(0.0f <= result && result < 1.0f);
+ return result;
+ }
+
+ /**
+ * Returns the next pseudorandom, uniformly distributed
+ * {@code double} value between {@code 0.0} and
+ * {@code 1.0} from this random number generator's sequence.
+ *
+ * <p>The general contract of {@code nextDouble} is that one
+ * {@code double} value, chosen (approximately) uniformly from the
+ * range {@code 0.0d} (inclusive) to {@code 1.0d} (exclusive), is
+ * pseudorandomly generated and returned.
+ *
+ * <p>The method {@code nextDouble} is implemented by class {@code Random}
+ * as if by:
+ * <pre> {@code
+ * public double nextDouble() {
+ * return (((long)next(26) << 27) + next(27))
+ * / (double)(1L << 53);
+ * }}</pre>
+ *
+ * <p>The hedge "approximately" is used in the foregoing description only
+ * because the {@code next} method is only approximately an unbiased
+ * source of independently chosen bits. If it were a perfect source of
+ * randomly chosen bits, then the algorithm shown would choose
+ * {@code double} values from the stated range with perfect uniformity.
+ * <p>[In early versions of Java, the result was incorrectly calculated as:
+ * <pre> {@code
+ * return (((long)next(27) << 27) + next(27))
+ * / (double)(1L << 54);}</pre>
+ * This might seem to be equivalent, if not better, but in fact it
+ * introduced a large nonuniformity because of the bias in the rounding
+ * of floating-point numbers: it was three times as likely that the
+ * low-order bit of the significand would be 0 than that it would be 1!
+ * This nonuniformity probably doesn't matter much in practice, but we
+ * strive for perfection.]
+ *
+ * @return the next pseudorandom, uniformly distributed {@code double}
+ * value between {@code 0.0} and {@code 1.0} from this
+ * random number generator's sequence
+ * @see Math#random
+ *
+ * @diffblue.fullSupport
+ * This method returns a nondeterministic {@code double} value between 0.0
+ * (inclusive) and 1.0 (exclusive).
+ * The nondeterminism is introduced by test-generator itself, and
+ * probability distributions are ignored.
+ *
+ * @diffblue.mock
+ */
+ public double nextDouble() {
+ // return (((long)(next(26)) << 27) + next(27)) * DOUBLE_UNIT;
+ double result = CProver.nondetDouble();
+ CProver.assume(0.0 <= result && result < 1.0);
+ return result;
+ }
+
+ // private double nextNextGaussian;
+ // private boolean haveNextNextGaussian = false;
+
+ /**
+ * Returns the next pseudorandom, Gaussian ("normally") distributed
+ * {@code double} value with mean {@code 0.0} and standard
+ * deviation {@code 1.0} from this random number generator's sequence.
+ * <p>
+ * The general contract of {@code nextGaussian} is that one
+ * {@code double} value, chosen from (approximately) the usual
+ * normal distribution with mean {@code 0.0} and standard deviation
+ * {@code 1.0}, is pseudorandomly generated and returned.
+ *
+ * <p>The method {@code nextGaussian} is implemented by class
+ * {@code Random} as if by a threadsafe version of the following:
+ * <pre> {@code
+ * private double nextNextGaussian;
+ * private boolean haveNextNextGaussian = false;
+ *
+ * public double nextGaussian() {
+ * if (haveNextNextGaussian) {
+ * haveNextNextGaussian = false;
+ * return nextNextGaussian;
+ * } else {
+ * double v1, v2, s;
+ * do {
+ * v1 = 2 * nextDouble() - 1; // between -1.0 and 1.0
+ * v2 = 2 * nextDouble() - 1; // between -1.0 and 1.0
+ * s = v1 * v1 + v2 * v2;
+ * } while (s >= 1 || s == 0);
+ * double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);
+ * nextNextGaussian = v2 * multiplier;
+ * haveNextNextGaussian = true;
+ * return v1 * multiplier;
+ * }
+ * }}</pre>
+ * This uses the <i>polar method</i> of G. E. P. Box, M. E. Muller, and
+ * G. Marsaglia, as described by Donald E. Knuth in <i>The Art of
+ * Computer Programming</i>, Volume 3: <i>Seminumerical Algorithms</i>,
+ * section 3.4.1, subsection C, algorithm P. Note that it generates two
+ * independent values at the cost of only one call to {@code StrictMath.log}
+ * and one call to {@code StrictMath.sqrt}.
+ *
+ * @return the next pseudorandom, Gaussian ("normally") distributed
+ * {@code double} value with mean {@code 0.0} and
+ * standard deviation {@code 1.0} from this random number
+ * generator's sequence
+ *
+ * @diffblue.fullSupport
+ * This method returns a nondeterministic {@code double} value.
+ * The nondeterminism is introduced by test-generator itself, and
+ * probability distributions are ignored.
+ *
+ * @diffblue.mock
+ */
+ synchronized public double nextGaussian() {
+ // See Knuth, ACP, Section 3.4.1 Algorithm C.
+ // if (haveNextNextGaussian) {
+ // haveNextNextGaussian = false;
+ // return nextNextGaussian;
+ // } else {
+ // double v1, v2, s;
+ // do {
+ // v1 = 2 * nextDouble() - 1; // between -1 and 1
+ // v2 = 2 * nextDouble() - 1; // between -1 and 1
+ // s = v1 * v1 + v2 * v2;
+ // } while (s >= 1 || s == 0);
+ // double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);
+ // nextNextGaussian = v2 * multiplier;
+ // haveNextNextGaussian = true;
+ // return v1 * multiplier;
+ // }
+ return CProver.nondetDouble();
+ }
+
+ // stream methods, coded in a way intended to better isolate for
+ // maintenance purposes the small differences across forms.
+
+ /**
+ * Returns a stream producing the given {@code streamSize} number of
+ * pseudorandom {@code int} values.
+ *
+ * <p>A pseudorandom {@code int} value is generated as if it's the result of
+ * calling the method {@link #nextInt()}.
+ *
+ * @param streamSize the number of values to generate
+ * @return a stream of pseudorandom {@code int} values
+ * @throws IllegalArgumentException if {@code streamSize} is
+ * less than zero
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public IntStream ints(long streamSize) {
+ // if (streamSize < 0L)
+ // throw new IllegalArgumentException(BadSize);
+ // return StreamSupport.intStream
+ // (new RandomIntsSpliterator
+ // (this, 0L, streamSize, Integer.MAX_VALUE, 0),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns an effectively unlimited stream of pseudorandom {@code int}
+ * values.
+ *
+ * <p>A pseudorandom {@code int} value is generated as if it's the result of
+ * calling the method {@link #nextInt()}.
+ *
+ * @implNote This method is implemented to be equivalent to {@code
+ * ints(Long.MAX_VALUE)}.
+ *
+ * @return a stream of pseudorandom {@code int} values
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public IntStream ints() {
+ // return StreamSupport.intStream
+ // (new RandomIntsSpliterator
+ // (this, 0L, Long.MAX_VALUE, Integer.MAX_VALUE, 0),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns a stream producing the given {@code streamSize} number
+ * of pseudorandom {@code int} values, each conforming to the given
+ * origin (inclusive) and bound (exclusive).
+ *
+ * <p>A pseudorandom {@code int} value is generated as if it's the result of
+ * calling the following method with the origin and bound:
+ * <pre> {@code
+ * int nextInt(int origin, int bound) {
+ * int n = bound - origin;
+ * if (n > 0) {
+ * return nextInt(n) + origin;
+ * }
+ * else { // range not representable as int
+ * int r;
+ * do {
+ * r = nextInt();
+ * } while (r < origin || r >= bound);
+ * return r;
+ * }
+ * }}</pre>
+ *
+ * @param streamSize the number of values to generate
+ * @param randomNumberOrigin the origin (inclusive) of each random value
+ * @param randomNumberBound the bound (exclusive) of each random value
+ * @return a stream of pseudorandom {@code int} values,
+ * each with the given origin (inclusive) and bound (exclusive)
+ * @throws IllegalArgumentException if {@code streamSize} is
+ * less than zero, or {@code randomNumberOrigin}
+ * is greater than or equal to {@code randomNumberBound}
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public IntStream ints(long streamSize, int randomNumberOrigin,
+ int randomNumberBound) {
+ // if (streamSize < 0L)
+ // throw new IllegalArgumentException(BadSize);
+ // if (randomNumberOrigin >= randomNumberBound)
+ // throw new IllegalArgumentException(BadRange);
+ // return StreamSupport.intStream
+ // (new RandomIntsSpliterator
+ // (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns an effectively unlimited stream of pseudorandom {@code
+ * int} values, each conforming to the given origin (inclusive) and bound
+ * (exclusive).
+ *
+ * <p>A pseudorandom {@code int} value is generated as if it's the result of
+ * calling the following method with the origin and bound:
+ * <pre> {@code
+ * int nextInt(int origin, int bound) {
+ * int n = bound - origin;
+ * if (n > 0) {
+ * return nextInt(n) + origin;
+ * }
+ * else { // range not representable as int
+ * int r;
+ * do {
+ * r = nextInt();
+ * } while (r < origin || r >= bound);
+ * return r;
+ * }
+ * }}</pre>
+ *
+ * @implNote This method is implemented to be equivalent to {@code
+ * ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}.
+ *
+ * @param randomNumberOrigin the origin (inclusive) of each random value
+ * @param randomNumberBound the bound (exclusive) of each random value
+ * @return a stream of pseudorandom {@code int} values,
+ * each with the given origin (inclusive) and bound (exclusive)
+ * @throws IllegalArgumentException if {@code randomNumberOrigin}
+ * is greater than or equal to {@code randomNumberBound}
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public IntStream ints(int randomNumberOrigin, int randomNumberBound) {
+ // if (randomNumberOrigin >= randomNumberBound)
+ // throw new IllegalArgumentException(BadRange);
+ // return StreamSupport.intStream
+ // (new RandomIntsSpliterator
+ // (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns a stream producing the given {@code streamSize} number of
+ * pseudorandom {@code long} values.
+ *
+ * <p>A pseudorandom {@code long} value is generated as if it's the result
+ * of calling the method {@link #nextLong()}.
+ *
+ * @param streamSize the number of values to generate
+ * @return a stream of pseudorandom {@code long} values
+ * @throws IllegalArgumentException if {@code streamSize} is
+ * less than zero
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public LongStream longs(long streamSize) {
+ // if (streamSize < 0L)
+ // throw new IllegalArgumentException(BadSize);
+ // return StreamSupport.longStream
+ // (new RandomLongsSpliterator
+ // (this, 0L, streamSize, Long.MAX_VALUE, 0L),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns an effectively unlimited stream of pseudorandom {@code long}
+ * values.
+ *
+ * <p>A pseudorandom {@code long} value is generated as if it's the result
+ * of calling the method {@link #nextLong()}.
+ *
+ * @implNote This method is implemented to be equivalent to {@code
+ * longs(Long.MAX_VALUE)}.
+ *
+ * @return a stream of pseudorandom {@code long} values
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public LongStream longs() {
+ // return StreamSupport.longStream
+ // (new RandomLongsSpliterator
+ // (this, 0L, Long.MAX_VALUE, Long.MAX_VALUE, 0L),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns a stream producing the given {@code streamSize} number of
+ * pseudorandom {@code long}, each conforming to the given origin
+ * (inclusive) and bound (exclusive).
+ *
+ * <p>A pseudorandom {@code long} value is generated as if it's the result
+ * of calling the following method with the origin and bound:
+ * <pre> {@code
+ * long nextLong(long origin, long bound) {
+ * long r = nextLong();
+ * long n = bound - origin, m = n - 1;
+ * if ((n & m) == 0L) // power of two
+ * r = (r & m) + origin;
+ * else if (n > 0L) { // reject over-represented candidates
+ * for (long u = r >>> 1; // ensure nonnegative
+ * u + m - (r = u % n) < 0L; // rejection check
+ * u = nextLong() >>> 1) // retry
+ * ;
+ * r += origin;
+ * }
+ * else { // range not representable as long
+ * while (r < origin || r >= bound)
+ * r = nextLong();
+ * }
+ * return r;
+ * }}</pre>
+ *
+ * @param streamSize the number of values to generate
+ * @param randomNumberOrigin the origin (inclusive) of each random value
+ * @param randomNumberBound the bound (exclusive) of each random value
+ * @return a stream of pseudorandom {@code long} values,
+ * each with the given origin (inclusive) and bound (exclusive)
+ * @throws IllegalArgumentException if {@code streamSize} is
+ * less than zero, or {@code randomNumberOrigin}
+ * is greater than or equal to {@code randomNumberBound}
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public LongStream longs(long streamSize, long randomNumberOrigin,
+ long randomNumberBound) {
+ // if (streamSize < 0L)
+ // throw new IllegalArgumentException(BadSize);
+ // if (randomNumberOrigin >= randomNumberBound)
+ // throw new IllegalArgumentException(BadRange);
+ // return StreamSupport.longStream
+ // (new RandomLongsSpliterator
+ // (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns an effectively unlimited stream of pseudorandom {@code
+ * long} values, each conforming to the given origin (inclusive) and bound
+ * (exclusive).
+ *
+ * <p>A pseudorandom {@code long} value is generated as if it's the result
+ * of calling the following method with the origin and bound:
+ * <pre> {@code
+ * long nextLong(long origin, long bound) {
+ * long r = nextLong();
+ * long n = bound - origin, m = n - 1;
+ * if ((n & m) == 0L) // power of two
+ * r = (r & m) + origin;
+ * else if (n > 0L) { // reject over-represented candidates
+ * for (long u = r >>> 1; // ensure nonnegative
+ * u + m - (r = u % n) < 0L; // rejection check
+ * u = nextLong() >>> 1) // retry
+ * ;
+ * r += origin;
+ * }
+ * else { // range not representable as long
+ * while (r < origin || r >= bound)
+ * r = nextLong();
+ * }
+ * return r;
+ * }}</pre>
+ *
+ * @implNote This method is implemented to be equivalent to {@code
+ * longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}.
+ *
+ * @param randomNumberOrigin the origin (inclusive) of each random value
+ * @param randomNumberBound the bound (exclusive) of each random value
+ * @return a stream of pseudorandom {@code long} values,
+ * each with the given origin (inclusive) and bound (exclusive)
+ * @throws IllegalArgumentException if {@code randomNumberOrigin}
+ * is greater than or equal to {@code randomNumberBound}
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public LongStream longs(long randomNumberOrigin, long randomNumberBound) {
+ // if (randomNumberOrigin >= randomNumberBound)
+ // throw new IllegalArgumentException(BadRange);
+ // return StreamSupport.longStream
+ // (new RandomLongsSpliterator
+ // (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns a stream producing the given {@code streamSize} number of
+ * pseudorandom {@code double} values, each between zero
+ * (inclusive) and one (exclusive).
+ *
+ * <p>A pseudorandom {@code double} value is generated as if it's the result
+ * of calling the method {@link #nextDouble()}.
+ *
+ * @param streamSize the number of values to generate
+ * @return a stream of {@code double} values
+ * @throws IllegalArgumentException if {@code streamSize} is
+ * less than zero
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public DoubleStream doubles(long streamSize) {
+ // if (streamSize < 0L)
+ // throw new IllegalArgumentException(BadSize);
+ // return StreamSupport.doubleStream
+ // (new RandomDoublesSpliterator
+ // (this, 0L, streamSize, Double.MAX_VALUE, 0.0),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns an effectively unlimited stream of pseudorandom {@code
+ * double} values, each between zero (inclusive) and one
+ * (exclusive).
+ *
+ * <p>A pseudorandom {@code double} value is generated as if it's the result
+ * of calling the method {@link #nextDouble()}.
+ *
+ * @implNote This method is implemented to be equivalent to {@code
+ * doubles(Long.MAX_VALUE)}.
+ *
+ * @return a stream of pseudorandom {@code double} values
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public DoubleStream doubles() {
+ // return StreamSupport.doubleStream
+ // (new RandomDoublesSpliterator
+ // (this, 0L, Long.MAX_VALUE, Double.MAX_VALUE, 0.0),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns a stream producing the given {@code streamSize} number of
+ * pseudorandom {@code double} values, each conforming to the given origin
+ * (inclusive) and bound (exclusive).
+ *
+ * <p>A pseudorandom {@code double} value is generated as if it's the result
+ * of calling the following method with the origin and bound:
+ * <pre> {@code
+ * double nextDouble(double origin, double bound) {
+ * double r = nextDouble();
+ * r = r * (bound - origin) + origin;
+ * if (r >= bound) // correct for rounding
+ * r = Math.nextDown(bound);
+ * return r;
+ * }}</pre>
+ *
+ * @param streamSize the number of values to generate
+ * @param randomNumberOrigin the origin (inclusive) of each random value
+ * @param randomNumberBound the bound (exclusive) of each random value
+ * @return a stream of pseudorandom {@code double} values,
+ * each with the given origin (inclusive) and bound (exclusive)
+ * @throws IllegalArgumentException if {@code streamSize} is
+ * less than zero
+ * @throws IllegalArgumentException if {@code randomNumberOrigin}
+ * is greater than or equal to {@code randomNumberBound}
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public DoubleStream doubles(long streamSize, double randomNumberOrigin,
+ double randomNumberBound) {
+ // if (streamSize < 0L)
+ // throw new IllegalArgumentException(BadSize);
+ // if (!(randomNumberOrigin < randomNumberBound))
+ // throw new IllegalArgumentException(BadRange);
+ // return StreamSupport.doubleStream
+ // (new RandomDoublesSpliterator
+ // (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Returns an effectively unlimited stream of pseudorandom {@code
+ * double} values, each conforming to the given origin (inclusive) and bound
+ * (exclusive).
+ *
+ * <p>A pseudorandom {@code double} value is generated as if it's the result
+ * of calling the following method with the origin and bound:
+ * <pre> {@code
+ * double nextDouble(double origin, double bound) {
+ * double r = nextDouble();
+ * r = r * (bound - origin) + origin;
+ * if (r >= bound) // correct for rounding
+ * r = Math.nextDown(bound);
+ * return r;
+ * }}</pre>
+ *
+ * @implNote This method is implemented to be equivalent to {@code
+ * doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}.
+ *
+ * @param randomNumberOrigin the origin (inclusive) of each random value
+ * @param randomNumberBound the bound (exclusive) of each random value
+ * @return a stream of pseudorandom {@code double} values,
+ * each with the given origin (inclusive) and bound (exclusive)
+ * @throws IllegalArgumentException if {@code randomNumberOrigin}
+ * is greater than or equal to {@code randomNumberBound}
+ * @since 1.8
+ *
+ * @diffblue.noSupport
+ */
+ public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
+ // if (!(randomNumberOrigin < randomNumberBound))
+ // throw new IllegalArgumentException(BadRange);
+ // return StreamSupport.doubleStream
+ // (new RandomDoublesSpliterator
+ // (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
+ // false);
+ CProver.notModelled();
+ return CProver.nondetWithNullForNotModelled();
+ }
+
+ /**
+ * Spliterator for int streams. We multiplex the four int
+ * versions into one class by treating a bound less than origin as
+ * unbounded, and also by treating "infinite" as equivalent to
+ * Long.MAX_VALUE. For splits, it uses the standard divide-by-two
+ * approach. The long and double versions of this class are
+ * identical except for types.
+ */
+ // static final class RandomIntsSpliterator implements Spliterator.OfInt {
+ // final Random rng;
+ // long index;
+ // final long fence;
+ // final int origin;
+ // final int bound;
+ // RandomIntsSpliterator(Random rng, long index, long fence,
+ // int origin, int bound) {
+ // this.rng = rng; this.index = index; this.fence = fence;
+ // this.origin = origin; this.bound = bound;
+ // }
+
+ // public RandomIntsSpliterator trySplit() {
+ // long i = index, m = (i + fence) >>> 1;
+ // return (m <= i) ? null :
+ // new RandomIntsSpliterator(rng, i, index = m, origin, bound);
+ // }
+
+ // public long estimateSize() {
+ // return fence - index;
+ // }
+
+ // public int characteristics() {
+ // return (Spliterator.SIZED | Spliterator.SUBSIZED |
+ // Spliterator.NONNULL | Spliterator.IMMUTABLE);
+ // }
+
+ // public boolean tryAdvance(IntConsumer consumer) {
+ // if (consumer == null) throw new NullPointerException();
+ // long i = index, f = fence;
+ // if (i < f) {
+ // consumer.accept(rng.internalNextInt(origin, bound));
+ // index = i + 1;
+ // return true;
+ // }
+ // return false;
+ // }
+
+ // public void forEachRemaining(IntConsumer consumer) {
+ // if (consumer == null) throw new NullPointerException();
+ // long i = index, f = fence;
+ // if (i < f) {
+ // index = f;
+ // Random r = rng;
+ // int o = origin, b = bound;
+ // do {
+ // consumer.accept(r.internalNextInt(o, b));
+ // } while (++i < f);
+ // }
+ // }
+ // }
+
+ /**
+ * Spliterator for long streams.
+ */
+ // static final class RandomLongsSpliterator implements Spliterator.OfLong {
+ // final Random rng;
+ // long index;
+ // final long fence;
+ // final long origin;
+ // final long bound;
+ // RandomLongsSpliterator(Random rng, long index, long fence,
+ // long origin, long bound) {
+ // this.rng = rng; this.index = index; this.fence = fence;
+ // this.origin = origin; this.bound = bound;
+ // }
+
+ // public RandomLongsSpliterator trySplit() {
+ // long i = index, m = (i + fence) >>> 1;
+ // return (m <= i) ? null :
+ // new RandomLongsSpliterator(rng, i, index = m, origin, bound);
+ // }
+
+ // public long estimateSize() {
+ // return fence - index;
+ // }
+
+ // public int characteristics() {
+ // return (Spliterator.SIZED | Spliterator.SUBSIZED |
+ // Spliterator.NONNULL | Spliterator.IMMUTABLE);
+ // }
+
+ // public boolean tryAdvance(LongConsumer consumer) {
+ // if (consumer == null) throw new NullPointerException();
+ // long i = index, f = fence;
+ // if (i < f) {
+ // consumer.accept(rng.internalNextLong(origin, bound));
+ // index = i + 1;
+ // return true;
+ // }
+ // return false;
+ // }
+
+ // public void forEachRemaining(LongConsumer consumer) {
+ // if (consumer == null) throw new NullPointerException();
+ // long i = index, f = fence;
+ // if (i < f) {
+ // index = f;
+ // Random r = rng;
+ // long o = origin, b = bound;
+ // do {
+ // consumer.accept(r.internalNextLong(o, b));
+ // } while (++i < f);
+ // }
+ // }
+
+ // }
+
+ /**
+ * Spliterator for double streams.
+ */
+ // static final class RandomDoublesSpliterator implements Spliterator.OfDouble {
+ // final Random rng;
+ // long index;
+ // final long fence;
+ // final double origin;
+ // final double bound;
+ // RandomDoublesSpliterator(Random rng, long index, long fence,
+ // double origin, double bound) {
+ // this.rng = rng; this.index = index; this.fence = fence;
+ // this.origin = origin; this.bound = bound;
+ // }
+
+ // public RandomDoublesSpliterator trySplit() {
+ // long i = index, m = (i + fence) >>> 1;
+ // return (m <= i) ? null :
+ // new RandomDoublesSpliterator(rng, i, index = m, origin, bound);
+ // }
+
+ // public long estimateSize() {
+ // return fence - index;
+ // }
+
+ // public int characteristics() {
+ // return (Spliterator.SIZED | Spliterator.SUBSIZED |
+ // Spliterator.NONNULL | Spliterator.IMMUTABLE);
+ // }
+
+ // public boolean tryAdvance(DoubleConsumer consumer) {
+ // if (consumer == null) throw new NullPointerException();
+ // long i = index, f = fence;
+ // if (i < f) {
+ // consumer.accept(rng.internalNextDouble(origin, bound));
+ // index = i + 1;
+ // return true;
+ // }
+ // return false;
+ // }
+
+ // public void forEachRemaining(DoubleConsumer consumer) {
+ // if (consumer == null) throw new NullPointerException();
+ // long i = index, f = fence;
+ // if (i < f) {
+ // index = f;
+ // Random r = rng;
+ // double o = origin, b = bound;
+ // do {
+ // consumer.accept(r.internalNextDouble(o, b));
+ // } while (++i < f);
+ // }
+ // }
+ // }
+
+ /**
+ * Serializable fields for Random.
+ *
+ * @serialField seed long
+ * seed for random computations
+ * @serialField nextNextGaussian double
+ * next Gaussian to be returned
+ * @serialField haveNextNextGaussian boolean
+ * nextNextGaussian is valid
+ */
+ // private static final ObjectStreamField[] serialPersistentFields = {
+ // // new ObjectStreamField("seed", Long.TYPE),
+ // // new ObjectStreamField("nextNextGaussian", Double.TYPE),
+ // // new ObjectStreamField("haveNextNextGaussian", Boolean.TYPE)
+ // };
+
+ /**
+ * Reconstitute the {@code Random} instance from a stream (that is,
+ * deserialize it).
+ */
+ // private void readObject(java.io.ObjectInputStream s)
+ // throws java.io.IOException, ClassNotFoundException {
+
+ // ObjectInputStream.GetField fields = s.readFields();
+
+ // // The seed is read in as {@code long} for
+ // // historical reasons, but it is converted to an AtomicLong.
+ // long seedVal = fields.get("seed", -1L);
+ // if (seedVal < 0)
+ // throw new java.io.StreamCorruptedException(
+ // "Random: invalid seed");
+ // resetSeed(seedVal);
+ // nextNextGaussian = fields.get("nextNextGaussian", 0.0);
+ // haveNextNextGaussian = fields.get("haveNextNextGaussian", false);
+ // }
+
+ /**
+ * Save the {@code Random} instance to a stream.
+ */
+ // synchronized private void writeObject(ObjectOutputStream s)
+ // throws IOException {
+
+ // // set the values of the Serializable fields
+ // ObjectOutputStream.PutField fields = s.putFields();
+
+ // // The seed is serialized as a long for historical reasons.
+ // fields.put("seed", seed.get());
+ // fields.put("nextNextGaussian", nextNextGaussian);
+ // fields.put("haveNextNextGaussian", haveNextNextGaussian);
+
+ // // save them
+ // s.writeFields();
+ // }
+
+ // Support for resetting seed while deserializing
+ // private static final Unsafe unsafe = Unsafe.getUnsafe();
+ // private static final long seedOffset;
+ // static {
+ // try {
+ // seedOffset = unsafe.objectFieldOffset
+ // (Random.class.getDeclaredField("seed"));
+ // } catch (Exception ex) { throw new Error(ex); }
+ // }
+ // private void resetSeed(long seedVal) {
+ // unsafe.putObjectVolatile(this, seedOffset, new AtomicLong(seedVal));
+ // }
+}
diff --git a/src/main/java/org/cprover/CProver.java b/src/main/java/org/cprover/CProver.java
index 1db5f42..52b9913 100644
--- a/src/main/java/org/cprover/CProver.java
+++ b/src/main/java/org/cprover/CProver.java
@@ -1,5 +1,8 @@
package org.cprover;
+import java.io.BufferedInputStream;
+import java.io.PrintStream;
+
public final class CProver
{
public static boolean enableAssume=true;
@@ -94,7 +97,7 @@ public static double nondetDouble()
return 0;
}
- public static <T> T nondetWithNull()
+ private static <T> T nondetWithNull()
{
if (enableNondet)
{
@@ -105,15 +108,65 @@ public static <T> T nondetWithNull()
return null;
}
- public static <T> T nondetWithoutNull()
+ /**
+ *
+ * @param instance an instance of the type T, this is not used but is there
+ * to make sure the class T is loaded. The parameter should
+ * not be `null`.
+ * @param <T> class of the object to return
+ * @return a non-deterministic object of type T, possibly `null`.
+ */
+ public static <T> T nondetWithNull(T instance)
{
- if (enableNondet)
- {
- throw new RuntimeException(
- "Cannot execute program with CProver.nondetWithoutNull<T>(T)");
- }
+ return nondetWithNull();
+ }
- return null;
+ private static <T> T nondetWithoutNull()
+ {
+ T t = nondetWithNull();
+ assume(t != null);
+ return t;
+ }
+
+ /**
+ *
+ * @param instance an instance of the type T, this is not used but is there
+ * to make sure the class T is loaded. The parameter should
+ * not be `null`.
+ * @param <T> class of the object to return
+ * @return a non-deterministic object of type T, assumed to be non-null.
+ */
+ public static <T> T nondetWithoutNull(T instance)
+ {
+ return nondetWithoutNull();
+ }
+
+ public static <T> T nondetWithNullForNotModelled() {
+ return nondetWithNull();
+ }
+
+ public static <T> T nondetWithoutNullForNotModelled() {
+ return nondetWithoutNull();
+ }
+
+ /**
+ * Return a non-deterministic PrintStream.
+ * It is not recommended to use it, since it will not enforce that PrintStream
+ * is loaded, but is necessary for initializing System.out and System.err.
+ */
+ public static PrintStream nondetPrintStream()
+ {
+ return nondetWithoutNull();
+ }
+
+ /**
+ * Return a non-deterministic BufferedInputStream.
+ * It is not recommended to use it, since it will not enforce that
+ * BufferedInputStream is loaded, but is necessary for initializing System.in.
+ */
+ public static BufferedInputStream nondetBufferedInputStream()
+ {
+ return nondetWithoutNull();
}
/**
diff --git a/src/main/java/org/cprover/CProverString.java b/src/main/java/org/cprover/CProverString.java
index a3481b3..b6b6170 100644
--- a/src/main/java/org/cprover/CProverString.java
+++ b/src/main/java/org/cprover/CProverString.java
@@ -5,6 +5,64 @@
/// This is in particular the case for functions that throw exceptions.
public final class CProverString
{
+ /**
+ * Returns the character (Unicode code point) at the specified
+ * index.
+ *
+ * @param instance the String instance
+ * @param index the index to the {@code char} values
+ * @return the code point value of the character at the
+ * {@code index}
+ */
+ public static int codePointAt(String instance, int index) {
+ return CProver.nondetInt();
+ }
+
+ /**
+ * Returns the character (Unicode code point) before the specified
+ * index.
+ *
+ * @param instance the String instance
+ * @param index the index following the code point that should be returned
+ * @return the code point value of the character before the
+ * {@code index}
+ */
+ public static int codePointBefore(String instance, int index) {
+ return CProver.nondetInt();
+ }
+
+ /**
+ * Returns the number of Unicode code points in the specified text
+ * range of this {@code String}.
+ *
+ * @param instance the String instance
+ * @param beginIndex the index to the first {@code char} of
+ * the text range.
+ * @param endIndex the index after the last {@code char} of
+ * the text range.
+ * @return the number of Unicode code points in the specified text
+ * range
+ */
+ public static int codePointCount(
+ String instance, int beginIndex, int endIndex) {
+ return CProver.nondetInt();
+ }
+
+ /**
+ * Returns the index within this {@code String} that is
+ * offset from the given {@code index} by
+ * {@code codePointOffset} code points.
+ *
+ * @param instance the String instance
+ * @param index the index to be offset
+ * @param codePointOffset the offset in code points
+ * @return the index within this {@code String}
+ */
+ public static int offsetByCodePoints(
+ String instance, int index, int codePointOffset) {
+ return CProver.nondetInt();
+ }
+
/// Modeled internally in CBMC.
/// @return '\u0000' if index is out of bounds and behave as s.charAt(i)
/// otherwise.
@@ -16,13 +74,305 @@ public static char charAt(String s, int i) {
/// @return empty string if index is too large, s if index too small and
/// behave as s.substring(i) otherwise.
public static String substring(String s, int i) {
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
}
/// Modeled internally in CBMC.
/// @return empty string if i >= j, s.substring(k, l) where k = max(0, i)
/// and l = min(s.length() - 1, j) otherwise.
public static String substring(String s, int i, int j) {
- return CProver.nondetWithoutNull();
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Returns a character sequence that is a subsequence of this sequence.
+ *
+ * @param instance the String instance
+ * @param beginIndex the begin index, inclusive.
+ * @param endIndex the end index, exclusive.
+ * @return the specified subsequence.
+ */
+ public static CharSequence subSequence(
+ String s, int beginIndex, int endIndex) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Appends a subsequence of the specified {@code CharSequence} to this
+ * sequence.
+ *
+ * @param instance the StringBuilder instance
+ * @param s the sequence to append.
+ * @param start the starting index of the subsequence to be appended.
+ * @param end the end index of the subsequence to be appended.
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder append(
+ StringBuilder instance, CharSequence cs, int start, int end) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Removes the characters in a substring of this sequence.
+ *
+ * @param instance the StringBuilder instance
+ * @param start The beginning index, inclusive.
+ * @param end The ending index, exclusive.
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder delete(
+ StringBuilder instance, int start, int end) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Removes the {@code char} at the specified position in this
+ * sequence. This sequence is shortened by one {@code char}.
+ *
+ * @param instance the StringBuilder instance
+ * @param index Index of {@code char} to remove
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder deleteCharAt(
+ StringBuilder instance, int index) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string into this character sequence.
+ *
+ * @param instance the StringBuilder instance
+ * @param offset the offset.
+ * @param str a string.
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder insert(
+ StringBuilder instance, int offset, String str) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code boolean}
+ * argument into this sequence.
+ *
+ * @param instance the StringBuilder instance
+ * @param offset the offset.
+ * @param b a {@code boolean}.
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder insert(
+ StringBuilder instance, int offset, boolean b) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code char}
+ * argument into this sequence.
+ *
+ * @param instance the StringBuilder instance
+ * @param offset the offset.
+ * @param c a {@code char}.
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder insert(
+ StringBuilder instance, int offset, char c) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code int}
+ * argument into this sequence.
+ *
+ * @param instance the StringBuilder instance
+ * @param offset the offset.
+ * @param b a {@code int}.
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder insert(
+ StringBuilder instance, int offset, int i) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code long}
+ * argument into this sequence.
+ *
+ * @param instance the StringBuilder instance
+ * @param offset the offset.
+ * @param b a {@code long}.
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder insert(
+ StringBuilder instance, int offset, long l) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code float}
+ * argument into this sequence.
+ *
+ * @param instance the StringBuilder instance
+ * @param offset the offset.
+ * @param b a {@code float}.
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder insert(
+ StringBuilder instance, int offset, float f) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code double}
+ * argument into this sequence.
+ *
+ * @param instance the StringBuilder instance
+ * @param offset the offset.
+ * @param b a {@code double}.
+ * @return the modified StringBuilder.
+ */
+ public static StringBuilder insert(
+ StringBuilder instance, int offset, double d) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Sets the length of the character sequence.
+ *
+ * @param instance the StringBuffer instance
+ * @param newLength the new length
+ */
+ public static void setLength(StringBuffer instance, int newLength) {
+ }
+
+ /**
+ * Returns the {@code char} value in this sequence at the specified index.
+ *
+ * @param instance the StringBuffer instance
+ * @param index the index of the desired {@code char} value.
+ * @return the {@code char} value at the specified index.
+ */
+ public static char charAt(StringBuffer instance, int index) {
+ return CProver.nondetChar();
+ }
+
+ /**
+ * The character at the specified index is set to {@code ch}.
+ *
+ * @param instance the StringBuffer instance
+ * @param index the index of the character to modify.
+ * @param ch the new character.
+ */
+ public static void setCharAt(StringBuffer instance, int index, char c) {
+ }
+
+ /**
+ * Removes the characters in a substring of this sequence.
+ *
+ * @param instance the StringBuffer instance
+ * @param start the beginning index, inclusive.
+ * @param end the ending index, exclusive.
+ * @return The modified StringBuffer.
+ */
+ public static StringBuffer delete(
+ StringBuffer instance, int start, int end) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Removes the {@code char} at the specified position in this
+ * sequence. This sequence is shortened by one {@code char}.
+ *
+ * <p>Note: If the character at the given index is a supplementary
+ * character, this method does not remove the entire character. If
+ * correct handling of supplementary characters is required,
+ * determine the number of {@code char}s to remove by calling
+ * {@code Character.charCount(thisSequence.codePointAt(index))},
+ * where {@code thisSequence} is this sequence.
+ *
+ * @param instance the StringBuffer instance.
+ * @param index index of {@code char} to remove
+ * @return this object.
+ */
+ public static StringBuffer deleteCharAt(StringBuffer instance, int index) {
+ return CProver.nondetWithoutNullForNotModelled();
}
+
+ /**
+ * Returns a new {@code String} that contains a subsequence of
+ * characters currently contained in this sequence.
+ *
+ * @param instance the StringBuffer instance.
+ * @param start the beginning index, inclusive.
+ * @param end the ending index, exclusive.
+ * @return The new string.
+ */
+ public static String substring(StringBuffer instance, int start, int end) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string into this character sequence.
+ *
+ * @param instance the StringBuffer instance.
+ * @param offset the offset.
+ * @param str a string.
+ * @return The modified StringBuffer.
+ */
+ public static StringBuffer insert(
+ StringBuffer instance, int offset, String str) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code boolean}
+ * argument into this sequence.
+ *
+ * @param offset the offset.
+ * @param b a {@code boolean}.
+ * @return a reference to this object.
+ */
+ public static StringBuffer insert(
+ StringBuffer instance, int offset, boolean b) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code char}
+ * argument into this sequence.
+ *
+ * @param offset the offset.
+ * @param c a {@code char}.
+ * @return a reference to this object.
+ */
+ public static StringBuffer insert(
+ StringBuffer instance, int offset, char c) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code int}
+ * argument into this sequence.
+ *
+ * @param offset the offset.
+ * @param i a {@code int}.
+ * @return a reference to this object.
+ */
+ public static StringBuffer insert(
+ StringBuffer instance, int offset, int i) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
+ /**
+ * Inserts the string representation of the {@code long}
+ * argument into this sequence.
+ *
+ * @param offset the offset.
+ * @param l a {@code long}.
+ * @return a reference to this object.
+ */
+ public static StringBuffer insert(
+ StringBuffer instance, int offset, long l) {
+ return CProver.nondetWithoutNullForNotModelled();
+ }
+
}