pax_global_header 0000666 0000000 0000000 00000000064 14323475213 0014516 g ustar 00root root 0000000 0000000 52 comment=7973361cbd288e6a265e4aec7a51806bd1ff6eaf
java-models-library-master/ 0000775 0000000 0000000 00000000000 14323475213 0016217 5 ustar 00root root 0000000 0000000 java-models-library-master/.github/ 0000775 0000000 0000000 00000000000 14323475213 0017557 5 ustar 00root root 0000000 0000000 java-models-library-master/.github/workflows/ 0000775 0000000 0000000 00000000000 14323475213 0021614 5 ustar 00root root 0000000 0000000 java-models-library-master/.github/workflows/models_library_pr.yml 0000664 0000000 0000000 00000000647 14323475213 0026056 0 ustar 00root root 0000000 0000000 name: Build JBMC Java Models Library
on:
pull_request:
branches: [ master ]
jobs:
Build-Models-Library:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v3
- name: Setup Java environment
uses: actions/setup-java@v3
with:
java-version: '16'
distribution: 'adopt'
- name: Build with Maven
run: mvn package
java-models-library-master/.gitignore 0000664 0000000 0000000 00000000044 14323475213 0020205 0 ustar 00root root 0000000 0000000 target
*.txt
*.d
*.o
*.a
/.project
java-models-library-master/OpenJDK GPLv2 + Classpath Exception.txt 0000664 0000000 0000000 00000040651 14323475213 0025070 0 ustar 00root root 0000000 0000000 GNU General Public License, version 2,
with the Classpath Exception
The GNU General Public License (GPL)
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your freedom to share
and change it. By contrast, the GNU General Public License is intended to
guarantee your freedom to share and change free software--to make sure the
software is free for all its users. This General Public License applies to
most of the Free Software Foundation's software and to any other program whose
authors commit to using it. (Some other Free Software Foundation software is
covered by the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not price. Our
General Public Licenses are designed to make sure that you have the freedom to
distribute copies of free software (and charge for this service if you wish),
that you receive source code or can get it if you want it, that you can change
the software or use pieces of it in new free programs; and that you know you
can do these things.
To protect your rights, we need to make restrictions that forbid anyone to deny
you these rights or to ask you to surrender the rights. These restrictions
translate to certain responsibilities for you if you distribute copies of the
software, or if you modify it.
For example, if you distribute copies of such a program, whether gratis or for
a fee, you must give the recipients all the rights that you have. You must
make sure that they, too, receive or can get the source code. And you must
show them these terms so they know their rights.
We protect your rights with two steps: (1) copyright the software, and (2)
offer you this license which gives you legal permission to copy, distribute
and/or modify the software.
Also, for each author's protection and ours, we want to make certain that
everyone understands that there is no warranty for this free software. If the
software is modified by someone else and passed on, we want its recipients to
know that what they have is not the original, so that any problems introduced
by others will not reflect on the original authors' reputations.
Finally, any free program is threatened constantly by software patents. We
wish to avoid the danger that redistributors of a free program will
individually obtain patent licenses, in effect making the program proprietary.
To prevent this, we have made it clear that any patent must be licensed for
everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and modification
follow.
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains a notice
placed by the copyright holder saying it may be distributed under the terms of
this General Public License. The "Program", below, refers to any such program
or work, and a "work based on the Program" means either the Program or any
derivative work under copyright law: that is to say, a work containing the
Program or a portion of it, either verbatim or with modifications and/or
translated into another language. (Hereinafter, translation is included
without limitation in the term "modification".) Each licensee is addressed as
"you".
Activities other than copying, distribution and modification are not covered by
this License; they are outside its scope. The act of running the Program is
not restricted, and the output from the Program is covered only if its contents
constitute a work based on the Program (independent of having been made by
running the Program). Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's source code as
you receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice and
disclaimer of warranty; keep intact all the notices that refer to this License
and to the absence of any warranty; and give any other recipients of the
Program a copy of this License along with the Program.
You may charge a fee for the physical act of transferring a copy, and you may
at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion of it, thus
forming a work based on the Program, and copy and distribute such modifications
or work under the terms of Section 1 above, provided that you also meet all of
these conditions:
a) You must cause the modified files to carry prominent notices stating
that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in whole or
in part contains or is derived from the Program or any part thereof, to be
licensed as a whole at no charge to all third parties under the terms of
this License.
c) If the modified program normally reads commands interactively when run,
you must cause it, when started running for such interactive use in the
most ordinary way, to print or display an announcement including an
appropriate copyright notice and a notice that there is no warranty (or
else, saying that you provide a warranty) and that users may redistribute
the program under these conditions, and telling the user how to view a copy
of this License. (Exception: if the Program itself is interactive but does
not normally print such an announcement, your work based on the Program is
not required to print an announcement.)
These requirements apply to the modified work as a whole. If identifiable
sections of that work are not derived from the Program, and can be reasonably
considered independent and separate works in themselves, then this License, and
its terms, do not apply to those sections when you distribute them as separate
works. But when you distribute the same sections as part of a whole which is a
work based on the Program, the distribution of the whole must be on the terms
of this License, whose permissions for other licensees extend to the entire
whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest your
rights to work written entirely by you; rather, the intent is to exercise the
right to control the distribution of derivative or collective works based on
the Program.
In addition, mere aggregation of another work not based on the Program with the
Program (or with a work based on the Program) on a volume of a storage or
distribution medium does not bring the other work under the scope of this
License.
3. You may copy and distribute the Program (or a work based on it, under
Section 2) in object code or executable form under the terms of Sections 1 and
2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable source
code, which must be distributed under the terms of Sections 1 and 2 above
on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three years, to
give any third party, for a charge no more than your cost of physically
performing source distribution, a complete machine-readable copy of the
corresponding source code, to be distributed under the terms of Sections 1
and 2 above on a medium customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer to
distribute corresponding source code. (This alternative is allowed only
for noncommercial distribution and only if you received the program in
object code or executable form with such an offer, in accord with
Subsection b above.)
The source code for a work means the preferred form of the work for making
modifications to it. For an executable work, complete source code means all
the source code for all modules it contains, plus any associated interface
definition files, plus the scripts used to control compilation and installation
of the executable. However, as a special exception, the source code
distributed need not include anything that is normally distributed (in either
source or binary form) with the major components (compiler, kernel, and so on)
of the operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the source
code from the same place counts as distribution of the source code, even though
third parties are not compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program except as
expressly provided under this License. Any attempt otherwise to copy, modify,
sublicense or distribute the Program is void, and will automatically terminate
your rights under this License. However, parties who have received copies, or
rights, from you under this License will not have their licenses terminated so
long as such parties remain in full compliance.
5. You are not required to accept this License, since you have not signed it.
However, nothing else grants you permission to modify or distribute the Program
or its derivative works. These actions are prohibited by law if you do not
accept this License. Therefore, by modifying or distributing the Program (or
any work based on the Program), you indicate your acceptance of this License to
do so, and all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the Program),
the recipient automatically receives a license from the original licensor to
copy, distribute or modify the Program subject to these terms and conditions.
You may not impose any further restrictions on the recipients' exercise of the
rights granted herein. You are not responsible for enforcing compliance by
third parties to this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues), conditions
are imposed on you (whether by court order, agreement or otherwise) that
contradict the conditions of this License, they do not excuse you from the
conditions of this License. If you cannot distribute so as to satisfy
simultaneously your obligations under this License and any other pertinent
obligations, then as a consequence you may not distribute the Program at all.
For example, if a patent license would not permit royalty-free redistribution
of the Program by all those who receive copies directly or indirectly through
you, then the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply and
the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any patents or
other property right claims or to contest validity of any such claims; this
section has the sole purpose of protecting the integrity of the free software
distribution system, which is implemented by public license practices. Many
people have made generous contributions to the wide range of software
distributed through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing to
distribute software through any other system and a licensee cannot impose that
choice.
This section is intended to make thoroughly clear what is believed to be a
consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in certain
countries either by patents or by copyrighted interfaces, the original
copyright holder who places the Program under this License may add an explicit
geographical distribution limitation excluding those countries, so that
distribution is permitted only in or among countries not thus excluded. In
such case, this License incorporates the limitation as if written in the body
of this License.
9. The Free Software Foundation may publish revised and/or new versions of the
General Public License from time to time. Such new versions will be similar in
spirit to the present version, but may differ in detail to address new problems
or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any later
version", you have the option of following the terms and conditions either of
that version or of any later version published by the Free Software Foundation.
If the Program does not specify a version number of this License, you may
choose any version ever published by the Free Software Foundation.
10. If you wish to incorporate parts of the Program into other free programs
whose distribution conditions are different, write to the author to ask for
permission. For software which is copyrighted by the Free Software Foundation,
write to the Free Software Foundation; we sometimes make exceptions for this.
Our decision will be guided by the two goals of preserving the free status of
all derivatives of our free software and of promoting the sharing and reuse of
software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE
STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE
PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE,
YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE
PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER
OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General Public
License instead of this License.
"CLASSPATH" EXCEPTION TO THE GPL
Certain source files distributed by Oracle America and/or its affiliates are
subject to the following clarification and special exception to the GPL, but
only where Oracle has expressly included in the particular source file's header
the words "Oracle designates this particular file as subject to the "Classpath"
exception as provided by Oracle in the LICENSE file that accompanied this code."
Linking this library statically or dynamically with other modules is making
a combined work based on this library. Thus, the terms and conditions of
the GNU General Public License cover the whole combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent modules,
and to copy and distribute the resulting executable under terms of your
choice, provided that you also meet, for each linked independent module,
the terms and conditions of the license of that module. An independent
module is a module which is not derived from or based on this library. If
you modify this library, you may extend this exception to your version of
the library, but you are not obligated to do so. If you do not wish to do
so, delete this exception statement from your version.
java-models-library-master/README.md 0000664 0000000 0000000 00000000417 14323475213 0017500 0 ustar 00root root 0000000 0000000 Java Core Models Library
========================
This repository contains a version of the Java Class Library (`rt.jar`) that can
be used together with
[JBMC](https://github.com/diffblue/cbmc/tree/develop/jbmc) to
model-check Java code that calls the standard library.
java-models-library-master/pom.xml 0000664 0000000 0000000 00000010265 14323475213 0017540 0 ustar 00root root 0000000 0000000 4.0.0org.cprover.modelsmodels1.0-SNAPSHOTjarUTF-8CProver JDK Modelsjava8-doclint-disabled[1.8,)-Xdoclint:noneorg.cprover.utilcprover-api1.0.0compilecore-modelsmaven-dependency-plugin2.8generate-sourcesbuild-classpathmaven.compile.classpathcopy-dependenciespackagecopyorg.cprover.utilcprover-api${project.build.directory}cprover-api.jarorg.apache.maven.pluginsmaven-compiler-plugin3.6.1${java.home}/lib/rt.jar${path.separator}${maven.compile.classpath}1.81.8org.apache.maven.pluginsmaven-javadoc-plugin3.0.0-M1doctruetruesrc/main/javajavasrc/main/overview.htmlDiffblue Library of ModelsDiffblue Library of Modelsdiffblue.fullSupportptcm
DIFFBLUE: Full support
diffblue.limitedSupportptcm
DIFFBLUE: Limited support
diffblue.noSupportptcm
DIFFBLUE: No support
diffblue.untestedptcm
DIFFBLUE: Untested
diffblue.todoptcm
DIFFBLUE: To do
${javadoc.opts}
java-models-library-master/src/ 0000775 0000000 0000000 00000000000 14323475213 0017006 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/ 0000775 0000000 0000000 00000000000 14323475213 0017732 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/ 0000775 0000000 0000000 00000000000 14323475213 0020653 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/java/ 0000775 0000000 0000000 00000000000 14323475213 0021574 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/java/lang/ 0000775 0000000 0000000 00000000000 14323475213 0022515 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/java/lang/AbstractMethodError.java 0000664 0000000 0000000 00000004722 14323475213 0027303 0 ustar 00root root 0000000 0000000 /*
* 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 AbstractMethodError with no detail message.
*/
public AbstractMethodError() {
super();
}
/**
* Constructs an AbstractMethodError 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";
}
}
java-models-library-master/src/main/java/java/lang/AbstractStringBuilder.java 0000664 0000000 0000000 00000017006 14323475213 0027625 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2003, 2016, 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
* At the moment, the methods defined in this class are not called anywhere
* because the classes that extend this class override each method without
* calling methods from this class.
*
* This file is only present to maintain the original inheritance. However, it
* would make sense to implement some of the modelled methods here instead of
* in the StringBuilder and StringBuffer classes, in the case these methods
* are modelled in a similar way.
*/
package java.lang;
import org.cprover.CProver;
abstract class AbstractStringBuilder implements Appendable, CharSequence {
AbstractStringBuilder() {}
AbstractStringBuilder(int capacity) {}
@Override
public int length() {
return CProver.nondetInt();
}
public int capacity() {
CProver.notModelled();
return CProver.nondetInt();
}
public void ensureCapacity(int minimumCapacity) {}
public void trimToSize() {}
public void setLength(int newLength) {}
@Override
public char charAt(int index) {
return 'c';
}
public int codePointAt(int index) {
return CProver.nondetInt();
}
public int codePointBefore(int index) {
return CProver.nondetInt();
}
public int codePointCount(int beginIndex, int endIndex) {
return CProver.nondetInt();
}
public int offsetByCodePoints(int index, int codePointOffset) {
return CProver.nondetInt();
}
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {
CProver.notModelled();
}
public void setCharAt(int index, char ch) {}
public AbstractStringBuilder append(Object obj) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder append(String str) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder append(StringBuffer sb) {
return CProver.nondetWithNullForNotModelled();
}
AbstractStringBuilder append(AbstractStringBuilder asb) {
return CProver.nondetWithNullForNotModelled();
}
@Override
public AbstractStringBuilder append(CharSequence s) {
return CProver.nondetWithNullForNotModelled();
}
@Override
public AbstractStringBuilder append(CharSequence s, int start, int end) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder append(char[] str) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder append(char str[], int offset, int len) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder append(boolean b) {
return CProver.nondetWithNullForNotModelled();
}
@Override
public AbstractStringBuilder append(char c) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder append(int i) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder append(long l) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder append(float f) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder append(double d) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder delete(int start, int end) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder appendCodePoint(int codePoint) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder deleteCharAt(int index) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder replace(int start, int end, String str) {
return CProver.nondetWithNullForNotModelled();
}
public String substring(int start) {
return CProver.nondetWithNullForNotModelled();
}
@Override
public CharSequence subSequence(int start, int end) {
return CProver.nondetWithNullForNotModelled();
}
public String substring(int start, int end) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int index, char[] str, int offset,
int len) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int offset, Object obj) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int offset, String str) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int offset, char[] str) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int dstOffset, CharSequence s) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int dstOffset, CharSequence s,
int start, int end) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int offset, boolean b) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int offset, char c) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int offset, int i) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int offset, long l) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int offset, float f) {
return CProver.nondetWithNullForNotModelled();
}
public AbstractStringBuilder insert(int offset, double d) {
return CProver.nondetWithNullForNotModelled();
}
public int indexOf(String str) {
return CProver.nondetInt();
}
public int indexOf(String str, int fromIndex) {
return CProver.nondetInt();
}
public int lastIndexOf(String str) {
return CProver.nondetInt();
}
public int lastIndexOf(String str, int fromIndex) {
return CProver.nondetInt();
}
public AbstractStringBuilder reverse() {
return CProver.nondetWithNullForNotModelled();
}
@Override
public abstract String toString();
// Method should not be used in the models
// final char[] getValue();
}
java-models-library-master/src/main/java/java/lang/ArithmeticException.java 0000664 0000000 0000000 00000003577 14323475213 0027344 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/ArrayIndexOutOfBoundsException.java 0000664 0000000 0000000 00000004067 14323475213 0031444 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/ArrayStoreException.java 0000664 0000000 0000000 00000003600 14323475213 0027331 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/AssertionError.java 0000664 0000000 0000000 00000014732 14323475213 0026350 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2000, 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 assertion has failed.
*
*
The seven one-argument public constructors provided by this
* class ensure that the assertion error returned by the invocation:
*
* new AssertionError(expression)
*
* has as its detail message the string conversion of
* expression (as defined in section 15.18.1.1 of
* The Java™ Language Specification),
* regardless of the type of expression.
*
* @since 1.4
*/
public class AssertionError extends Error {
private static final long serialVersionUID = -5013299493970297370L;
/**
* Constructs an AssertionError with no detail message.
*/
public AssertionError() {
}
/**
* This internal constructor does no processing on its string argument,
* even if it is a null reference. The public constructors will
* never call this constructor with a null argument.
*/
private AssertionError(String detailMessage) {
super(detailMessage);
}
/**
* Constructs an AssertionError with its detail message derived
* from the specified object, which is converted to a string as
* defined in section 15.18.1.1 of
* The Java™ Language Specification.
*
* If the specified object is an instance of {@code Throwable}, it
* becomes the cause of the newly constructed assertion error.
*
* @param detailMessage value to be used in constructing detail message
* @see Throwable#getCause()
*/
public AssertionError(Object detailMessage) {
this(String.valueOf(detailMessage));
if (detailMessage instanceof Throwable)
initCause((Throwable) detailMessage);
}
/**
* Constructs an AssertionError with its detail message derived
* from the specified boolean, which is converted to
* a string as defined in section 15.18.1.1 of
* The Java™ Language Specification.
*
* @param detailMessage value to be used in constructing detail message
*/
public AssertionError(boolean detailMessage) {
this(String.valueOf(detailMessage));
}
/**
* Constructs an AssertionError with its detail message derived
* from the specified char, which is converted to a
* string as defined in section 15.18.1.1 of
* The Java™ Language Specification.
*
* @param detailMessage value to be used in constructing detail message
*/
public AssertionError(char detailMessage) {
this(String.valueOf(detailMessage));
}
/**
* Constructs an AssertionError with its detail message derived
* from the specified int, which is converted to a
* string as defined in section 15.18.1.1 of
* The Java™ Language Specification.
*
* @param detailMessage value to be used in constructing detail message
*/
public AssertionError(int detailMessage) {
this(String.valueOf(detailMessage));
}
/**
* Constructs an AssertionError with its detail message derived
* from the specified long, which is converted to a
* string as defined in section 15.18.1.1 of
* The Java™ Language Specification.
*
* @param detailMessage value to be used in constructing detail message
*/
public AssertionError(long detailMessage) {
this(String.valueOf(detailMessage));
}
/**
* Constructs an AssertionError with its detail message derived
* from the specified float, which is converted to a
* string as defined in section 15.18.1.1 of
* The Java™ Language Specification.
*
* @param detailMessage value to be used in constructing detail message
*/
public AssertionError(float detailMessage) {
this(String.valueOf(detailMessage));
}
/**
* Constructs an AssertionError with its detail message derived
* from the specified double, which is converted to a
* string as defined in section 15.18.1.1 of
* The Java™ Language Specification.
*
* @param detailMessage value to be used in constructing detail message
*/
public AssertionError(double detailMessage) {
this(String.valueOf(detailMessage));
}
/**
* Constructs a new {@code AssertionError} with the specified
* detail message and cause.
*
*
Note that the detail message associated with
* {@code cause} is not automatically incorporated in
* this error's detail message.
*
* @param message the detail message, may be {@code null}
* @param cause the cause, may be {@code null}
*
* @since 1.7
*/
public AssertionError(String message, Throwable cause) {
super(message, 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.AssertionError: " + message)
: "java.lang.AssertionError";
}
}
java-models-library-master/src/main/java/java/lang/Boolean.java 0000664 0000000 0000000 00000027646 14323475213 0024756 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* The Boolean class wraps a value of the primitive type
* {@code boolean} in an object. An object of type
* {@code Boolean} contains a single field whose type is
* {@code boolean}.
*
* In addition, this class provides many methods for
* converting a {@code boolean} to a {@code String} and a
* {@code String} to a {@code boolean}, as well as other
* constants and methods useful when dealing with a
* {@code boolean}.
*
* @author Arthur van Hoff
* @since JDK1.0
*/
public final class Boolean implements java.io.Serializable,
Comparable
{
/**
* The {@code Boolean} object corresponding to the primitive
* value {@code true}.
*/
public static final Boolean TRUE = new Boolean(true);
/**
* The {@code Boolean} object corresponding to the primitive
* value {@code false}.
*/
public static final Boolean FALSE = new Boolean(false);
/**
* The Class object representing the primitive type boolean.
*
* @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 TYPE = (Class) Class.getPrimitiveClass(0);
/**
* The value of the Boolean.
*
* @serial
*/
private final boolean value;
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -3665804199014368530L;
/**
* Allocates a {@code Boolean} object representing the
* {@code value} argument.
*
*
Note: It is rarely appropriate to use this constructor.
* Unless a new instance is required, the static factory
* {@link #valueOf(boolean)} is generally a better choice. It is
* likely to yield significantly better space and time performance.
*
* @param value the value of the {@code Boolean}.
*/
public Boolean(boolean value) {
this.value = value;
}
/**
* Allocates a {@code Boolean} object representing the value
* {@code true} if the string argument is not {@code null}
* and is equal, ignoring case, to the string {@code "true"}.
* Otherwise, allocate a {@code Boolean} object representing the
* value {@code false}. Examples:
* {@code new Boolean("True")} produces a {@code Boolean} object
* that represents {@code true}.
* {@code new Boolean("yes")} produces a {@code Boolean} object
* that represents {@code false}.
*
* @param s the string to be converted to a {@code Boolean}.
*/
public Boolean(String s) {
this(parseBoolean(s));
}
/**
* Parses the string argument as a boolean. The {@code boolean}
* returned represents the value {@code true} if the string argument
* is not {@code null} and is equal, ignoring case, to the string
* {@code "true"}.
* Example: {@code Boolean.parseBoolean("True")} returns {@code true}.
* Example: {@code Boolean.parseBoolean("yes")} returns {@code false}.
*
* @param s the {@code String} containing the boolean
* representation to be parsed
* @return the boolean represented by the string argument
* @since 1.5
*/
public static boolean parseBoolean(String s) {
return ((s != null) && s.equalsIgnoreCase("true"));
}
/**
* Returns the value of this {@code Boolean} object as a boolean
* primitive.
*
* @return the primitive {@code boolean} value of this object.
*/
public boolean booleanValue() {
return value;
}
/**
* Returns a {@code Boolean} instance representing the specified
* {@code boolean} value. If the specified {@code boolean} value
* is {@code true}, this method returns {@code Boolean.TRUE};
* if it is {@code false}, this method returns {@code Boolean.FALSE}.
* If a new {@code Boolean} instance is not required, this method
* should generally be used in preference to the constructor
* {@link #Boolean(boolean)}, as this method is likely to yield
* significantly better space and time performance.
*
* @param b a boolean value.
* @return a {@code Boolean} instance representing {@code b}.
* @since 1.4
*/
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
/**
* Returns a {@code Boolean} with a value represented by the
* specified string. The {@code Boolean} returned represents a
* true value if the string argument is not {@code null}
* and is equal, ignoring case, to the string {@code "true"}.
*
* @param s a string.
* @return the {@code Boolean} value represented by the string.
*/
public static Boolean valueOf(String s) {
return parseBoolean(s) ? TRUE : FALSE;
}
/**
* Returns a {@code String} object representing the specified
* boolean. If the specified boolean is {@code true}, then
* the string {@code "true"} will be returned, otherwise the
* string {@code "false"} will be returned.
*
* @param b the boolean to be converted
* @return the string representation of the specified {@code boolean}
* @since 1.4
*
* @diffblue.fullSupport
*/
public static String toString(boolean b) {
return b ? "true" : "false";
}
/**
* Returns a {@code String} object representing this Boolean's
* value. If this object represents the value {@code true},
* a string equal to {@code "true"} is returned. Otherwise, a
* string equal to {@code "false"} is returned.
*
* @return a string representation of this object.
*/
public String toString() {
return value ? "true" : "false";
}
/**
* Returns a hash code for this {@code Boolean} object.
*
* @return the integer {@code 1231} if this object represents
* {@code true}; returns the integer {@code 1237} if this
* object represents {@code false}.
*/
@Override
public int hashCode() {
return Boolean.hashCode(value);
}
/**
* Returns a hash code for a {@code boolean} value; compatible with
* {@code Boolean.hashCode()}.
*
* @param value the value to hash
* @return a hash code value for a {@code boolean} value.
* @since 1.8
*/
public static int hashCode(boolean value) {
return value ? 1231 : 1237;
}
/**
* Returns {@code true} if and only if the argument is not
* {@code null} and is a {@code Boolean} object that
* represents the same {@code boolean} value as this object.
*
* @param obj the object to compare with.
* @return {@code true} if the Boolean objects represent the
* same value; {@code false} otherwise.
*/
public boolean equals(Object obj) {
if (obj instanceof Boolean) {
return value == ((Boolean)obj).booleanValue();
}
return false;
}
/**
* Returns {@code true} if and only if the system property
* named by the argument exists and is equal to the string
* {@code "true"}. (Beginning with version 1.0.2 of the
* JavaTM platform, the test of
* this string is case insensitive.) A system property is accessible
* through {@code getProperty}, a method defined by the
* {@code System} class.
*
* If there is no property with the specified name, or if the specified
* name is empty or null, then {@code false} is returned.
*
* @param name the system property name.
* @return the {@code boolean} value of the system 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 boolean getBoolean(String name) {
boolean result = false;
try {
result = parseBoolean(System.getProperty(name));
} catch (IllegalArgumentException | NullPointerException e) {
}
return result;
}
/**
* Compares this {@code Boolean} instance with another.
*
* @param b the {@code Boolean} instance to be compared
* @return zero if this object represents the same boolean value as the
* argument; a positive value if this object represents true
* and the argument represents false; and a negative value if
* this object represents false and the argument represents true
* @throws NullPointerException if the argument is {@code null}
* @see Comparable
* @since 1.5
*/
public int compareTo(Boolean b) {
return compare(this.value, b.value);
}
/**
* Compares two {@code boolean} values.
* The value returned is identical to what would be returned by:
*
*
* @param x the first {@code boolean} to compare
* @param y the second {@code boolean} 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(boolean x, boolean y) {
return (x == y) ? 0 : (x ? 1 : -1);
}
/**
* Returns the result of applying the logical AND operator to the
* specified {@code boolean} operands.
*
* @param a the first operand
* @param b the second operand
* @return the logical AND of {@code a} and {@code b}
* @see java.util.function.BinaryOperator
* @since 1.8
*/
public static boolean logicalAnd(boolean a, boolean b) {
return a && b;
}
/**
* Returns the result of applying the logical OR operator to the
* specified {@code boolean} operands.
*
* @param a the first operand
* @param b the second operand
* @return the logical OR of {@code a} and {@code b}
* @see java.util.function.BinaryOperator
* @since 1.8
*/
public static boolean logicalOr(boolean a, boolean b) {
return a || b;
}
/**
* Returns the result of applying the logical XOR operator to the
* specified {@code boolean} operands.
*
* @param a the first operand
* @param b the second operand
* @return the logical XOR of {@code a} and {@code b}
* @see java.util.function.BinaryOperator
* @since 1.8
*/
public static boolean logicalXor(boolean a, boolean b) {
return a ^ b;
}
}
java-models-library-master/src/main/java/java/lang/BootstrapMethodError.java 0000664 0000000 0000000 00000006213 14323475213 0027512 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/Byte.java 0000664 0000000 0000000 00000044722 14323475213 0024274 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1996, 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 Byte} class wraps a value of primitive type {@code byte}
* in an object. An object of type {@code Byte} contains a single
* field whose type is {@code byte}.
*
*
In addition, this class provides several methods for converting
* a {@code byte} to a {@code String} and a {@code String} to a {@code
* byte}, as well as other constants and methods useful when dealing
* with a {@code byte}.
*
* @author Nakul Saraiya
* @author Joseph D. Darcy
* @see java.lang.Number
* @since JDK1.1
*/
public final class Byte extends Number implements Comparable {
/**
* A constant holding the minimum value a {@code byte} can
* have, -27.
*/
public static final byte MIN_VALUE = -128;
/**
* A constant holding the maximum value a {@code byte} can
* have, 27-1.
*/
public static final byte MAX_VALUE = 127;
/**
* The {@code Class} instance representing the primitive type
* {@code byte}.
*/
@SuppressWarnings("unchecked")
public static final Class TYPE = (Class) Class.getPrimitiveClass(7);
/**
* Returns a new {@code String} object representing the
* specified {@code byte}. The radix is assumed to be 10.
*
* @param b the {@code byte} to be converted
* @return the string representation of the specified {@code byte}
* @see java.lang.Integer#toString(int)
*
* @diffblue.fullSupport
*/
public static String toString(byte b) {
return CProverString.toString((int)b);
}
/**
* Returns a {@code Byte} instance representing the specified
* {@code byte} value.
* If a new {@code Byte} instance is not required, this method
* should generally be used in preference to the constructor
* {@link #Byte(byte)}, as this method is likely to yield
* significantly better space and time performance since
* all byte values are cached.
*
* @param b a byte value.
* @return a {@code Byte} instance representing {@code b}.
* @since 1.5
*/
public static Byte valueOf(byte b) {
return new Byte(b);
}
/**
* Parses the string argument as a signed {@code byte} 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 {@code byte} value is
* returned.
*
*
An exception of type {@code NumberFormatException} is
* thrown if any of the following situations occurs:
*
*
The first argument is {@code null} or is a string of
* length zero.
*
*
The radix is either smaller than {@link
* java.lang.Character#MIN_RADIX} or larger than {@link
* java.lang.Character#MAX_RADIX}.
*
*
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.
*
*
The value represented by the string is not a value of type
* {@code byte}.
*
*
* @param s the {@code String} containing the
* {@code byte}
* representation to be parsed
* @param radix the radix to be used while parsing {@code s}
* @return the {@code byte} value represented by the string
* argument in the specified radix
* @throws NumberFormatException If the string does
* not contain a parsable {@code byte}.
*/
public static byte parseByte(String s, int radix)
throws NumberFormatException {
int i = Integer.parseInt(s, radix);
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException(
"Value out of range. Value:\"" + s + "\" Radix:" + radix);
return (byte)i;
}
/**
* Parses the string argument as a signed decimal {@code
* byte}. 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 {@code byte} value is returned, exactly as if the
* argument and the radix 10 were given as arguments to the {@link
* #parseByte(java.lang.String, int)} method.
*
* @param s a {@code String} containing the
* {@code byte} representation to be parsed
* @return the {@code byte} value represented by the
* argument in decimal
* @throws NumberFormatException if the string does not
* contain a parsable {@code byte}.
*/
public static byte parseByte(String s) throws NumberFormatException {
return CProver.nondetByte(); //The function is handled by cbmc internally
}
/**
* Returns a {@code Byte} 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 {@code byte} in
* the radix specified by the second argument, exactly as if the
* argument were given to the {@link #parseByte(java.lang.String,
* int)} method. The result is a {@code Byte} object that
* represents the {@code byte} value specified by the string.
*
*
In other words, this method returns a {@code Byte} object
* equal to the value of:
*
*
* {@code new Byte(Byte.parseByte(s, radix))}
*
*
* @param s the string to be parsed
* @param radix the radix to be used in interpreting {@code s}
* @return a {@code Byte} object holding the value
* represented by the string argument in the
* specified radix.
* @throws NumberFormatException If the {@code String} does
* not contain a parsable {@code byte}.
*/
public static Byte valueOf(String s, int radix)
throws NumberFormatException {
return valueOf(parseByte(s, radix));
}
/**
* Returns a {@code Byte} object holding the value
* given by the specified {@code String}. The argument is
* interpreted as representing a signed decimal {@code byte},
* exactly as if the argument were given to the {@link
* #parseByte(java.lang.String)} method. The result is a
* {@code Byte} object that represents the {@code byte}
* value specified by the string.
*
*
In other words, this method returns a {@code Byte} object
* equal to the value of:
*
*
* {@code new Byte(Byte.parseByte(s))}
*
*
* @param s the string to be parsed
* @return a {@code Byte} object holding the value
* represented by the string argument
* @throws NumberFormatException If the {@code String} does
* not contain a parsable {@code byte}.
*/
public static Byte valueOf(String s) throws NumberFormatException {
return valueOf(s, 10);
}
/**
* Decodes a {@code String} into a {@code Byte}.
* Accepts decimal, hexadecimal, and octal numbers given by
* the following grammar:
*
*
*
*
DecodableString:
*
Signopt DecimalNumeral
*
Signopt {@code 0x} HexDigits
*
Signopt {@code 0X} HexDigits
*
Signopt {@code #} HexDigits
*
Signopt {@code 0} OctalDigits
*
*
Sign:
*
{@code -}
*
{@code +}
*
*
*
* DecimalNumeral, HexDigits, and OctalDigits
* are as defined in section 3.10.1 of
* The Java™ Language Specification,
* except that underscores are not accepted between digits.
*
*
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
* Byte.parseByte} 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 a {@code Byte} object holding the {@code byte}
* value represented by {@code nm}
* @throws NumberFormatException if the {@code String} does not
* contain a parsable {@code byte}.
* @see java.lang.Byte#parseByte(java.lang.String, int)
*/
public static Byte decode(String nm) throws NumberFormatException {
int i = Integer.decode(nm);
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException(
"Value " + i + " out of range from input " + nm);
return valueOf((byte)i);
}
/**
* The value of the {@code Byte}.
*
* @serial
*/
private final byte value;
/**
* Constructs a newly allocated {@code Byte} object that
* represents the specified {@code byte} value.
*
* @param value the value to be represented by the
* {@code Byte}.
*/
public Byte(byte value) {
this.value = value;
}
/**
* Constructs a newly allocated {@code Byte} object that
* represents the {@code byte} value indicated by the
* {@code String} parameter. The string is converted to a
* {@code byte} value in exactly the manner used by the
* {@code parseByte} method for radix 10.
*
* @param s the {@code String} to be converted to a
* {@code Byte}
* @throws NumberFormatException If the {@code String}
* does not contain a parsable {@code byte}.
* @see java.lang.Byte#parseByte(java.lang.String, int)
*/
public Byte(String s) throws NumberFormatException {
this.value = parseByte(s, 10);
}
/**
* Returns the value of this {@code Byte} as a
* {@code byte}.
*/
public byte byteValue() {
return value;
}
/**
* Returns the value of this {@code Byte} as a {@code short} after
* a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public short shortValue() {
return (short)value;
}
/**
* Returns the value of this {@code Byte} as an {@code int} after
* a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public int intValue() {
return (int)value;
}
/**
* Returns the value of this {@code Byte} as a {@code long} after
* a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public long longValue() {
return (long)value;
}
/**
* Returns the value of this {@code Byte} 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 Byte} 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 Byte}'s value. The value is converted to signed
* decimal representation and returned as a string, exactly as if
* the {@code byte} value were given as an argument to the
* {@link java.lang.Byte#toString(byte)} method.
*
* @return a string representation of the value of this object in
* base 10.
*/
public String toString() {
return Integer.toString((int)value);
}
/**
* Returns a hash code for this {@code Byte}; equal to the result
* of invoking {@code intValue()}.
*
* @return a hash code value for this {@code Byte}
*/
@Override
public int hashCode() {
return Byte.hashCode(value);
}
/**
* Returns a hash code for a {@code byte} value; compatible with
* {@code Byte.hashCode()}.
*
* @param value the value to hash
* @return a hash code value for a {@code byte} value.
* @since 1.8
*/
public static int hashCode(byte value) {
return (int)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 a {@code Byte} object that
* contains the same {@code byte} 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 Byte) {
return value == ((Byte)obj).byteValue();
}
return false;
}
/**
* Compares two {@code Byte} objects numerically.
*
* @param anotherByte the {@code Byte} to be compared.
* @return the value {@code 0} if this {@code Byte} is
* equal to the argument {@code Byte}; a value less than
* {@code 0} if this {@code Byte} is numerically less
* than the argument {@code Byte}; and a value greater than
* {@code 0} if this {@code Byte} is numerically
* greater than the argument {@code Byte} (signed
* comparison).
* @since 1.2
*/
public int compareTo(Byte anotherByte) {
return compare(this.value, anotherByte.value);
}
/**
* Compares two {@code byte} values numerically.
* The value returned is identical to what would be returned by:
*
* Byte.valueOf(x).compareTo(Byte.valueOf(y))
*
*
* @param x the first {@code byte} to compare
* @param y the second {@code byte} 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(byte x, byte y) {
return x - y;
}
/**
* Converts the argument to an {@code int} by an unsigned
* conversion. In an unsigned conversion to an {@code int}, the
* high-order 24 bits of the {@code int} are zero and the
* low-order 8 bits are equal to the bits of the {@code byte} argument.
*
* Consequently, zero and positive {@code byte} values are mapped
* to a numerically equal {@code int} value and negative {@code
* byte} values are mapped to an {@code int} value equal to the
* input plus 28.
*
* @param x the value to convert to an unsigned {@code int}
* @return the argument converted to {@code int} by an unsigned
* conversion
* @since 1.8
*/
public static int toUnsignedInt(byte x) {
return ((int) x) & 0xff;
}
/**
* Converts the argument to a {@code long} by an unsigned
* conversion. In an unsigned conversion to a {@code long}, the
* high-order 56 bits of the {@code long} are zero and the
* low-order 8 bits are equal to the bits of the {@code byte} argument.
*
* Consequently, zero and positive {@code byte} values are mapped
* to a numerically equal {@code long} value and negative {@code
* byte} values are mapped to a {@code long} value equal to the
* input plus 28.
*
* @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
*/
public static long toUnsignedLong(byte x) {
return ((long) x) & 0xffL;
}
/**
* The number of bits used to represent a {@code byte} value in two's
* complement binary form.
*
* @since 1.5
*/
public static final int SIZE = 8;
/**
* The number of bytes used to represent a {@code byte} value in two's
* complement binary form.
*
* @since 1.8
*/
public static final int BYTES = SIZE / Byte.SIZE;
/** use serialVersionUID from JDK 1.1. for interoperability */
private static final long serialVersionUID = -7183698231559129828L;
}
java-models-library-master/src/main/java/java/lang/CharSequence.java 0000664 0000000 0000000 00000021411 14323475213 0025725 0 ustar 00root root 0000000 0000000 /*
* 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 CharSequence is a readable sequence of char values. This
* interface provides uniform, read-only access to many different kinds of
* char sequences.
* A char value represents a character in the Basic
* Multilingual Plane (BMP) or a surrogate. Refer to Unicode Character Representation for details.
*
*
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 CharSequence 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 CharSequence instances as elements in a set or as keys in
* a map.
*
* @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 chars in the sequence.
*
* @return the number of chars in this sequence
*/
int length();
/**
* Returns the char value at the specified index. An index ranges from zero
* to length() - 1. The first char value of the sequence is at
* index zero, the next at index one, and so on, as for array
* indexing.
*
*
If the char value specified by the index is a
* surrogate, the surrogate
* value is returned.
*
* @param index the index of the char value to be returned
*
* @return the specified char value
*
* @throws IndexOutOfBoundsException
* if the index argument is negative or not less than
* length()
*/
char charAt(int index);
/**
* Returns a CharSequence that is a subsequence of this sequence.
* The subsequence starts with the char value at the specified index and
* ends with the char value at index end - 1. The length
* (in chars) of the
* returned sequence is end - start, so if start == end
* 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 start or end are negative,
* if end is greater than length(),
* or if start is greater than end
*/
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 surrogate code
* point is passed through uninterpreted.
*
*
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.
*
*
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);
}
}
java-models-library-master/src/main/java/java/lang/Character.java 0000664 0000000 0000000 00001013260 14323475213 0025257 0 ustar 00root root 0000000 0000000 /*
* 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;
import org.cprover.CProver;
import org.cprover.CProverString;
/**
* 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}.
*
* 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.
*
* Character information is based on the Unicode Standard, version 6.2.0.
*
* The methods and data of class {@code Character} are defined by
* the information in the UnicodeData 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.
*
* The file and its description are available from the Unicode Consortium at:
*
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 code points is now
* U+0000 to U+10FFFF, known as Unicode scalar value.
* (Refer to the
* definition of the U+n notation in the Unicode
* Standard.)
*
*
The set of characters from U+0000 to U+FFFF is
* sometimes referred to as the Basic Multilingual Plane (BMP).
* Characters whose code points are greater
* than U+FFFF are called supplementary characters. 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 high-surrogates
* range, (\uD800-\uDBFF), the second from the
* low-surrogates range (\uDC00-\uDFFF).
*
*
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:
*
*
*
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.
*
*
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).
*
*
*
In the Java SE API documentation, Unicode code point is
* used for character values in the range between U+0000 and U+10FFFF,
* and Unicode code unit is used for 16-bit
* {@code char} values that are code units of the UTF-16
* encoding. For more information on Unicode terminology, refer to the
* Unicode Glossary.
*
* @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 {
/**
* 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 TYPE = (Class) 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
*
* Unicode high-surrogate code unit
* in the UTF-16 encoding, constant {@code '\u005CuD800'}.
* A high-surrogate is also known as a leading-surrogate.
*
* @since 1.5
*/
public static final char MIN_HIGH_SURROGATE = '\uD800';
/**
* The maximum value of a
*
* Unicode high-surrogate code unit
* in the UTF-16 encoding, constant {@code '\u005CuDBFF'}.
* A high-surrogate is also known as a leading-surrogate.
*
* @since 1.5
*/
public static final char MAX_HIGH_SURROGATE = '\uDBFF';
/**
* The minimum value of a
*
* Unicode low-surrogate code unit
* in the UTF-16 encoding, constant {@code '\u005CuDC00'}.
* A low-surrogate is also known as a trailing-surrogate.
*
* @since 1.5
*/
public static final char MIN_LOW_SURROGATE = '\uDC00';
/**
* The maximum value of a
*
* Unicode low-surrogate code unit
* in the UTF-16 encoding, constant {@code '\u005CuDFFF'}.
* A low-surrogate is also known as a trailing-surrogate.
*
* @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
*
* Unicode supplementary code point, constant {@code U+10000}.
*
* @since 1.5
*/
public static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x010000;
/**
* The minimum value of a
*
* Unicode code point, constant {@code U+0000}.
*
* @since 1.5
*/
public static final int MIN_CODE_POINT = 0x000000;
/**
* The maximum value of a
*
* Unicode code point, 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 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.
*
* 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.
*
* 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.
*
*
Note: This method cannot handle
* supplementary
* characters. 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.
*
* This method accepts block names in the following forms:
*
*
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.
*
Canonical block names with all spaces removed. For example, "BasicLatin"
* is a valid block name for the "Basic Latin" block.
*
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.
*
* 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.
*
* 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.
*
*
* @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 Character instance representing the specified
* char value.
* If a new Character 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 Character instance representing c.
* @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
*
* @diffblue.fullSupport
*/
public static String toString(char c) {
char data[] = {c};
return CProverString.ofCharArray(data, 0, 1);
}
/**
* Determines whether the specified code point is a valid
*
* Unicode code point value.
*
* @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 Basic Multilingual Plane (BMP).
* 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 supplementary character 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
*
* Unicode high-surrogate code unit
* (also known as leading-surrogate code unit).
*
*
Such values do not represent characters by themselves,
* but are used in the representation of
* supplementary characters
* 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
*
* Unicode low-surrogate code unit
* (also known as trailing-surrogate code unit).
*
*
Such values do not represent characters by themselves,
* but are used in the representation of
* supplementary characters
* 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
* surrogate code unit.
*
*
Such values do not represent characters by themselves,
* but are used in the representation of
* supplementary characters
* in the UTF-16 encoding.
*
*
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
*
* Unicode surrogate pair.
*
*
* @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.
*
*
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
*
* high surrogate code unit) of the
*
* surrogate pair
* representing the specified supplementary character (Unicode
* code point) in the UTF-16 encoding. If the specified character
* is not a
* supplementary character,
* an unspecified {@code char} is returned.
*
*
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
*
* low surrogate code unit) of the
*
* surrogate pair
* representing the specified supplementary character (Unicode
* code point) in the UTF-16 encoding. If the specified character
* is not a
* supplementary character,
* an unspecified {@code char} is returned.
*
*
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.
*
* 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.
*
* The following are examples of lowercase characters:
*
* 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'
*
*
Many other Unicode characters are lowercase too.
*
*
Note: This method cannot handle supplementary characters. 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.
*
* 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.
*
* The following are examples of lowercase characters:
*
* 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'
*
*
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;
// This code has been simplified in the upstream JDK repository
// at https://github.com/openjdk/jdk/pull/2846/files. The change
// below is to bring the code at parity with openJDK.
// || CharacterData.of(codePoint).isOtherLowercase(codePoint);
}
/**
* Determines if the specified character is an uppercase character.
*
* 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.
*
* The following are examples of uppercase characters:
*
* 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'
*
*
Many other Unicode characters are uppercase too.
*
*
Note: This method cannot handle supplementary characters. 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.
*
* 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.
*
* The following are examples of uppercase characters:
*
* 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'
*
*
Many other Unicode characters are uppercase too.
*
* @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;
// // This code has been simplified in the upstream JDK repository
// at https://github.com/openjdk/jdk/pull/2846/files. The change
// below is to bring the code at parity with openJDK.
// || CharacterData.of(codePoint).isOtherUppercase(codePoint);
}
/**
* Determines if the specified character is a titlecase character.
*
* A character is a titlecase character if its general
* category type, provided by {@code Character.getType(ch)},
* is {@code TITLECASE_LETTER}.
*
* 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.
*
* These are some of the Unicode characters for which this method returns
* {@code true}:
*
*
{@code LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON}
*
{@code LATIN CAPITAL LETTER L WITH SMALL LETTER J}
*
{@code LATIN CAPITAL LETTER N WITH SMALL LETTER J}
*
{@code LATIN CAPITAL LETTER D WITH SMALL LETTER Z}
*
*
Many other Unicode characters are titlecase too.
*
*
Note: This method cannot handle supplementary characters. 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.
*
* A character is a titlecase character if its general
* category type, provided by {@link Character#getType(int) getType(codePoint)},
* is {@code TITLECASE_LETTER}.
*
* 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.
*
* These are some of the Unicode characters for which this method returns
* {@code true}:
*
*
{@code LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON}
*
{@code LATIN CAPITAL LETTER L WITH SMALL LETTER J}
*
{@code LATIN CAPITAL LETTER N WITH SMALL LETTER J}
*
{@code LATIN CAPITAL LETTER D WITH SMALL LETTER Z}
*
*
Many other Unicode characters are titlecase too.
*
* @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.
*
* A character is a digit if its general category type, provided
* by {@code Character.getType(ch)}, is
* {@code DECIMAL_DIGIT_NUMBER}.
*
* Some Unicode character ranges that contain digits:
*
*
{@code '\u005Cu0030'} through {@code '\u005Cu0039'},
* ISO-LATIN-1 digits ({@code '0'} through {@code '9'})
*
{@code '\u005Cu0660'} through {@code '\u005Cu0669'},
* Arabic-Indic digits
*
{@code '\u005Cu06F0'} through {@code '\u005Cu06F9'},
* Extended Arabic-Indic digits
*
{@code '\u005Cu0966'} through {@code '\u005Cu096F'},
* Devanagari digits
*
{@code '\u005CuFF10'} through {@code '\u005CuFF19'},
* Fullwidth digits
*
*
* Many other character ranges contain digits as well.
*
*
Note: This method cannot handle supplementary characters. 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.
*
* A character is a digit if its general category type, provided
* by {@link Character#getType(int) getType(codePoint)}, is
* {@code DECIMAL_DIGIT_NUMBER}.
*
* Some Unicode character ranges that contain digits:
*
*
{@code '\u005Cu0030'} through {@code '\u005Cu0039'},
* ISO-LATIN-1 digits ({@code '0'} through {@code '9'})
*
{@code '\u005Cu0660'} through {@code '\u005Cu0669'},
* Arabic-Indic digits
*
{@code '\u005Cu06F0'} through {@code '\u005Cu06F9'},
* Extended Arabic-Indic digits
*
{@code '\u005Cu0966'} through {@code '\u005Cu096F'},
* Devanagari digits
*
{@code '\u005CuFF10'} through {@code '\u005CuFF19'},
* Fullwidth digits
*
*
* 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.
*
* A character is defined if at least one of the following is true:
*
*
It has an entry in the UnicodeData file.
*
It has a value in a range defined by the UnicodeData file.
*
*
*
Note: This method cannot handle supplementary characters. 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.
*
* A character is defined if at least one of the following is true:
*
*
It has an entry in the UnicodeData file.
*
It has a value in a range defined by the UnicodeData file.
*
*
* @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.
*
* A character is considered to be a letter if its general
* category type, provided by {@code Character.getType(ch)},
* is any of the following:
*
*
{@code UPPERCASE_LETTER}
*
{@code LOWERCASE_LETTER}
*
{@code TITLECASE_LETTER}
*
{@code MODIFIER_LETTER}
*
{@code OTHER_LETTER}
*
*
* Not all letters have case. Many characters are
* letters but are neither uppercase nor lowercase nor titlecase.
*
*
Note: This method cannot handle supplementary characters. 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.
*
* 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:
*
*
{@code UPPERCASE_LETTER}
*
{@code LOWERCASE_LETTER}
*
{@code TITLECASE_LETTER}
*
{@code MODIFIER_LETTER}
*
{@code OTHER_LETTER}
*
*
* 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.
*
* 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.
*
*
Note: This method cannot handle supplementary characters. 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.
*
* 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.
*
* A character may start a Java identifier if and only if
* one of the following is true:
*
{@code ch} is a currency symbol (such as {@code '$'})
*
{@code ch} is a connecting punctuation character (such as {@code '_'}).
*
*
* @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.
*
* A character may be part of a Java identifier if and only if any
* of the following are true:
*
*
it is a letter
*
it is a currency symbol (such as {@code '$'})
*
it is a connecting punctuation character (such as {@code '_'})
*
it is a digit
*
it is a numeric letter (such as a Roman numeral character)
*
it is a combining mark
*
it is a non-spacing mark
*
{@code isIdentifierIgnorable} returns
* {@code true} for the character.
*
*
* @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.
*
* 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:
*
*
UPPERCASE_LETTER
*
LOWERCASE_LETTER
*
TITLECASE_LETTER
*
MODIFIER_LETTER
*
OTHER_LETTER
*
LETTER_NUMBER
*
* or it has contributory property Other_Alphabetic as defined by the
* Unicode Standard.
*
* @param codePoint the character (Unicode code point) to be tested.
* @return true if the character is a Unicode alphabet
* character, false 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 true if the character is a Unicode ideograph
* character, false 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.
*
* A character may start a Java identifier if and only if
* one of the following conditions is true:
*
{@code ch} is a currency symbol (such as {@code '$'})
*
{@code ch} is a connecting punctuation character (such as {@code '_'}).
*
*
*
Note: This method cannot handle supplementary characters. 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.
*
* A character may start a Java identifier if and only if
* one of the following conditions is true:
*
the referenced character is a currency symbol (such as {@code '$'})
*
the referenced character is a connecting punctuation character
* (such as {@code '_'}).
*
*
* @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.
*
* A character may be part of a Java identifier if any of the following
* are true:
*
*
it is a letter
*
it is a currency symbol (such as {@code '$'})
*
it is a connecting punctuation character (such as {@code '_'})
*
it is a digit
*
it is a numeric letter (such as a Roman numeral character)
*
it is a combining mark
*
it is a non-spacing mark
*
{@code isIdentifierIgnorable} returns
* {@code true} for the character
*
*
*
Note: This method cannot handle supplementary characters. 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.
*
* A character may be part of a Java identifier if any of the following
* are true:
*
*
it is a letter
*
it is a currency symbol (such as {@code '$'})
*
it is a connecting punctuation character (such as {@code '_'})
*
it is a digit
*
it is a numeric letter (such as a Roman numeral character)
*
it is a combining mark
*
it is a non-spacing mark
*
{@link #isIdentifierIgnorable(int)
* isIdentifierIgnorable(codePoint)} returns {@code true} for
* the character
*
*
* @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.
*
* A character may start a Unicode identifier if and only if
* one of the following conditions is true:
*
Note: This method cannot handle supplementary characters. 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.
*
* A character may start a Unicode identifier if and only if
* one of the following conditions is true:
*
* @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.
*
* A character may be part of a Unicode identifier if and only if
* one of the following statements is true:
*
*
it is a letter
*
it is a connecting punctuation character (such as {@code '_'})
*
it is a digit
*
it is a numeric letter (such as a Roman numeral character)
*
it is a combining mark
*
it is a non-spacing mark
*
{@code isIdentifierIgnorable} returns
* {@code true} for this character.
*
*
*
Note: This method cannot handle supplementary characters. 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.
*
* A character may be part of a Unicode identifier if and only if
* one of the following statements is true:
*
*
it is a letter
*
it is a connecting punctuation character (such as {@code '_'})
*
it is a digit
*
it is a numeric letter (such as a Roman numeral character)
*
it is a combining mark
*
it is a non-spacing mark
*
{@code isIdentifierIgnorable} returns
* {@code true} for this character.
*
* @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.
*
* The following Unicode characters are ignorable in a Java identifier
* or a Unicode identifier:
*
*
ISO control characters that are not whitespace
*
*
{@code '\u005Cu0000'} through {@code '\u005Cu0008'}
*
{@code '\u005Cu000E'} through {@code '\u005Cu001B'}
*
{@code '\u005Cu007F'} through {@code '\u005Cu009F'}
*
*
*
all characters that have the {@code FORMAT} general
* category value
*
*
*
Note: This method cannot handle supplementary characters. 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.
*
* The following Unicode characters are ignorable in a Java identifier
* or a Unicode identifier:
*
*
ISO control characters that are not whitespace
*
*
{@code '\u005Cu0000'} through {@code '\u005Cu0008'}
*
{@code '\u005Cu000E'} through {@code '\u005Cu001B'}
*
{@code '\u005Cu007F'} through {@code '\u005Cu009F'}
*
*
*
all characters that have the {@code FORMAT} general
* category value
*
*
* @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.
*
* 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.
*
*
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.
*
*
Note: This method cannot handle supplementary characters. 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.
*
*
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.
*
*
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.
*
* 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.
*
*
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.
*
*
Note: This method cannot handle supplementary characters. 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.
*
*
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.
*
*
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.
*
* Note that
* {@code Character.isTitleCase(Character.toTitleCase(ch))}
* does not always return {@code true} for some ranges of
* characters.
*
*
Note: This method cannot handle supplementary characters. 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.
*
*
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.
*
* 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:
*
*
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.
*
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.
*
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.
*
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.
*
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.
*
*
*
Note: This method cannot handle supplementary characters. 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.
*
*
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:
*
*
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.
*
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.
*
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.
*
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.
*
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.
*
*
* @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.
*
* 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.
*
* 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.
*
*
Note: This method cannot handle supplementary characters. 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.
*
* 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.
*
* 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:
*
*
{@code '\t'}
{@code U+0009}
*
{@code HORIZONTAL TABULATION}
*
{@code '\n'}
{@code U+000A}
*
{@code NEW LINE}
*
{@code '\f'}
{@code U+000C}
*
{@code FORM FEED}
*
{@code '\r'}
{@code U+000D}
*
{@code CARRIAGE RETURN}
*
{@code ' '}
{@code U+0020}
*
{@code SPACE}
*
*
* @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:
*
*
{@code SPACE_SEPARATOR}
*
{@code LINE_SEPARATOR}
*
{@code PARAGRAPH_SEPARATOR}
*
*
*
Note: This method cannot handle supplementary characters. 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:
*
*
*
{@link #SPACE_SEPARATOR}
*
{@link #LINE_SEPARATOR}
*
{@link #PARAGRAPH_SEPARATOR}
*
*
* @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:
*
*
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'}).
*
It is {@code '\u005Ct'}, U+0009 HORIZONTAL TABULATION.
*
It is {@code '\u005Cn'}, U+000A LINE FEED.
*
It is {@code '\u005Cu000B'}, U+000B VERTICAL TABULATION.
*
It is {@code '\u005Cf'}, U+000C FORM FEED.
*
It is {@code '\u005Cr'}, U+000D CARRIAGE RETURN.
*
It is {@code '\u005Cu001C'}, U+001C FILE SEPARATOR.
*
It is {@code '\u005Cu001D'}, U+001D GROUP SEPARATOR.
*
It is {@code '\u005Cu001E'}, U+001E RECORD SEPARATOR.
*
It is {@code '\u005Cu001F'}, U+001F UNIT SEPARATOR.
*
*
*
Note: This method cannot handle supplementary characters. 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:
*
*
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'}).
*
It is {@code '\u005Ct'}, U+0009 HORIZONTAL TABULATION.
*
It is {@code '\u005Cn'}, U+000A LINE FEED.
*
It is {@code '\u005Cu000B'}, U+000B VERTICAL TABULATION.
*
It is {@code '\u005Cf'}, U+000C FORM FEED.
*
It is {@code '\u005Cr'}, U+000D CARRIAGE RETURN.
*
It is {@code '\u005Cu001C'}, U+001C FILE SEPARATOR.
*
It is {@code '\u005Cu001D'}, U+001D GROUP SEPARATOR.
*
It is {@code '\u005Cu001E'}, U+001E RECORD SEPARATOR.
*
It is {@code '\u005Cu001F'}, U+001F UNIT SEPARATOR.
*
*
*
* @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'}.
*
*
Note: This method cannot handle supplementary characters. 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.
*
*
Note: This method cannot handle supplementary characters. 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.
*
* 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}.
*
* 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}.
*
*
Note: This method cannot handle supplementary characters. 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 opening
* parenthesis. This will appear as a "(" in text that is
* left-to-right but as a ")" in text that is right-to-left.
*
*
Note: This method cannot handle supplementary characters. 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 opening parenthesis. 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:
*
*
* @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.
*
*
* @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 char 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 char 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 char 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}.
*
* Note: if the specified character is not assigned a name by
* the UnicodeData file (part of the Unicode Character
* Database maintained by the Unicode Consortium), the returned
* name is the same as the result of expression.
*
*
*
* @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
*
* @diffblue.limitedSupport Only works for capital latin letters.
*/
public static String getName(int codePoint) {
if (!isValidCodePoint(codePoint)) {
throw new IllegalArgumentException();
}
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// 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);
return cproverGetNameRestricted(codePoint);
}
public static String cproverGetNameRestricted(int codePoint)
{
CProver.assume(codePoint >= 65 && codePoint <= 90);
return "LATIN CAPITAL LETTER " + ((char) codePoint);
}
}
java-models-library-master/src/main/java/java/lang/Class.java 0000664 0000000 0000000 00000061772 14323475213 0024442 0 ustar 00root root 0000000 0000000 /*
* 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.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.cprover.CProverString;
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// import sun.reflect.CallerSensitive;
// import sun.reflect.Reflection;
import org.cprover.CProver;
public final class Class {
private Class() {}
private transient String name;
// TODO: these boolean fields model the internal encoding of classes
// they should be set by the getClass methods of the different classes
private boolean cproverIsAnnotation;
private boolean cproverIsArray;
private boolean cproverIsInterface;
private boolean cproverIsSynthetic;
private boolean cproverIsLocalClass;
private boolean cproverIsMemberClass;
private boolean cproverIsEnum;
public String toString() {
return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
+ getName();
}
public String toGenericString() {
if (isPrimitive()) {
return toString();
} else {
StringBuilder sb = new StringBuilder();
// Class modifiers are a superset of interface modifiers
/* TODO: No implementation for modifiers yet
int modifiers = getModifiers() & Modifier.classModifiers();
if (modifiers != 0) {
sb.append(Modifier.toString(modifiers));
sb.append(' ');
}
*/
if (isAnnotation()) {
sb.append('@');
}
if (isInterface()) { // Note: all annotation types are interfaces
sb.append("interface");
} else {
if (isEnum())
sb.append("enum");
else
sb.append("class");
}
sb.append(' ');
sb.append(getName());
/* TODO: No implementation for TypeVariable yet
TypeVariable[] typeparms = getTypeParameters();
if (typeparms.length > 0) {
boolean first = true;
sb.append('<');
for(TypeVariable typeparm: typeparms) {
if (!first)
sb.append(',');
sb.append(typeparm.getTypeName());
first = false;
}
sb.append('>');
}
*/
return sb.toString();
}
}
// TODO: This is a very partial model of the actual behaviour of the Java
// forName method. The goal is to correctly model combinations of forName
// and getName, but precisely following the JDK behaviour is more involved.
public static Class forName(String className) {
Class c=new Class();
c.name=className;
return c;
}
public static Class forName(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException {
return Class.forName(name);
}
public boolean isInstance(Object obj) { return obj.getClass()==this; }
public boolean isInterface() { return cproverIsInterface; }
public boolean isArray() { return cproverIsArray; }
public boolean isPrimitive() {
// 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 cproverIsAnnotation; }
public boolean isSynthetic() { return cproverIsSynthetic; }
public boolean isLocalClass() { return cproverIsLocalClass; }
public boolean isMemberClass() { return cproverIsMemberClass; }
public boolean isAnonymousClass() { return "".equals(getSimpleName()); }
public boolean isEnum() { return cproverIsEnum; }
private boolean isLocalOrAnonymousClass() {
return isLocalClass() || isAnonymousClass();
}
public String getName() {
// TODO: this is only for objects, and primitive types and arrays need
// a special treatment
return this.name;
}
/**
* Returns the class loader for the class. Some implementations may use
* null to represent the bootstrap class loader. This method will return
* null in such implementations if this class was loaded by the bootstrap
* class loader.
*
*
If a security manager is present, and the caller's class loader is
* not null and the caller's class loader is not the same as or an ancestor of
* the class loader for the class whose class loader is requested, then
* this method calls the security manager's {@code checkPermission}
* method with a {@code RuntimePermission("getClassLoader")}
* permission to ensure it's ok to access the class loader for the class.
*
*
If this object
* represents a primitive type or void, null is returned.
*
* @return the class loader that loaded the class or interface
* represented by this object.
* @throws SecurityException
* if a security manager exists and its
* {@code checkPermission} method denies
* access to the class loader for the class.
* @see java.lang.ClassLoader
* @see SecurityManager#checkPermission
* @see java.lang.RuntimePermission
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public ClassLoader getClassLoader() {
ClassLoader cl = getClassLoader0();
if (cl == null)
return null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());
ClassLoader.checkClassLoaderPermission(cl, null);
}
return cl;
}
ClassLoader getClassLoader0() {
// DIFFBLUE MODEL LIBRARY The real java.lang.Class stores a
// `private final ClassLoader classLoader` which is initialised by the
// jvm rather than by the constructor of this object.
// TODO test-gen should understand this method natively.
return null;
}
public String getSimpleName() {
/* DIFFBLUE MODEL LIBRARY TODO: No implementation for getComponentType
if (isArray())
return getComponentType().getSimpleName()+"[]";
*/
// DIFFBLUE MODEL LIBRARY: instead of calling getSimpleBinaryName()
// we inline function calls and simplify
String name = getName();
int index = name.lastIndexOf('$');
if(index == -1) { // top level class
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(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(name.length() > index + 2);
CProver.assume(!isAsciiDigit(CProverString.charAt(name, index + 2)));
return CProverString.substring(name, index + 2);
}
}
private static boolean isAsciiDigit(char c) {
return '0' <= c && c <= '9';
}
public Class getEnclosingClass() {
int index = name.lastIndexOf("$1");
if(index==-1)
{
return null;
}
else
{
String enclosing_name = CProverString.substring(name, 0, index);
return Class.forName(enclosing_name);
}
}
public String getCanonicalName() {
if (isArray()) {
String canonicalName = "";
/* TODO: No implementation for getComponentType yet
String canonicalName = getComponentType().getCanonicalName();
*/
if (canonicalName != null)
return canonicalName + "[]";
else
return null;
}
if (isLocalOrAnonymousClass())
return null;
Class enclosingClass = getEnclosingClass();
if (enclosingClass == null) { // top level class
return getName();
}
else {
String enclosingName = enclosingClass.getCanonicalName();
if (enclosingName == null)
return null;
return enclosingName + "." + getSimpleName();
}
}
private String getSimpleBinaryName() {
Class enclosingClass = getEnclosingClass();
if (enclosingClass == null) // top level class
return null;
// Otherwise, strip the enclosing class' name
try {
return CProverString.substring(getName(), enclosingClass.getName().length());
} catch (IndexOutOfBoundsException ex) {
throw new InternalError("Malformed class name", ex);
}
}
private String resolveName(String name) {
if (name == null) {
return name;
}
if (!name.startsWith("/")) {
Class c = this;
/* TODO: No implementation for getComponentType yet
while (c.isArray()) {
c = c.getComponentType();
}
*/
String baseName = c.getName();
int index = baseName.lastIndexOf('.');
if (index != -1) {
name = CProverString.substring(baseName, 0, index).replace('.', '/')
+"/"+name;
}
} else {
name = CProverString.substring(name, 1);
}
return name;
}
public Class getSuperclass(){
// TODO: here we assume no superclass which may not be correct
return Class.forName(null);
}
public static Class getPrimitiveClass(String s){
if("boolean".equals(s))
return Class.forName("boolean");
if("char".equals(s))
return Class.forName("char");
if("byte".equals(s))
return Class.forName("byte");
if("short".equals(s))
return Class.forName("short");
if("int".equals(s))
return Class.forName("int");
if("long".equals(s))
return Class.forName("long");
if("float".equals(s))
return Class.forName("float");
if("double".equals(s))
return Class.forName("double");
if("void".equals(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("");
}
// This version is nicer for the symbolic execution as it knows how to
// compare integers but not Strings.
// This method should be used instead of the String version whenever
// possible by our models.
// Experimenting with the test booleanValue_Fail, the String version
// takes 8 seconds while the int version takes 3 seconds.
static Class getPrimitiveClass(int i){
if(i==0)
return Class.forName("boolean");
if(i==1)
return Class.forName("char");
if(i==2)
return Class.forName("byte");
if(i==3)
return Class.forName("short");
if(i==4)
return Class.forName("int");
if(i==5)
return Class.forName("long");
if(i==6)
return Class.forName("float");
if(i==7)
return Class.forName("double");
return Class.forName("void");
}
Map enumConstantDirectory() {
if (enumConstantDirectory == null) {
T[] universe = getEnumConstantsShared();
if (universe == null)
throw new IllegalArgumentException(
getName() + " is not an enum type");
Map m = new HashMap<>(2 * universe.length);
for (T constant : universe)
m.put(((Enum)constant).name(), constant);
enumConstantDirectory = m;
}
return enumConstantDirectory;
}
private volatile transient Map enumConstantDirectory = null;
// This method use calls that we cannot model here and
// would probably need to be modeled internally in our tools
T[] getEnumConstantsShared() {
// DIFFBLUE MODEL LIBRARY @TODO: implement this method internally in CBMC
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns the assertion status that would be assigned to this
* class if it were to be initialized at the time this method is invoked.
* If this class has had its assertion status set, the most recent
* setting will be returned; otherwise, if any package default assertion
* status pertains to this class, the most recent setting for the most
* specific pertinent package default assertion status is returned;
* otherwise, if this class is not a system class (i.e., it has a
* class loader) its class loader's default assertion status is returned;
* otherwise, the system class default assertion status is returned.
*
* Few programmers will have any need for this method; it is provided
* for the benefit of the JRE itself. (It allows a class to determine at
* the time that it is initialized whether assertions should be enabled.)
* Note that this method is not guaranteed to return the actual
* assertion status that was (or will be) associated with the specified
* class when it was (or will be) initialized.
*
* @return the desired assertion status of the specified class.
* @see java.lang.ClassLoader#setClassAssertionStatus
* @see java.lang.ClassLoader#setPackageAssertionStatus
* @see java.lang.ClassLoader#setDefaultAssertionStatus
* @since 1.4
*/
public boolean desiredAssertionStatus() {
ClassLoader loader = getClassLoader();
// If the loader is null this is a system class, so ask the VM
if (loader == null)
return desiredAssertionStatus0(this);
// If the classloader has been initialized with the assertion
// directives, ask it. Otherwise, ask the VM.
synchronized(loader.assertionLock) {
if (loader.classAssertionStatus != null) {
return loader.desiredAssertionStatus(getName());
}
}
return desiredAssertionStatus0(this);
}
// Retrieves the desired assertion status of this class from the VM
private static boolean desiredAssertionStatus0(Class clazz) {
// DIFFBLUE MODEL LIBRARY This would normally be a native method which
// queries the JVM.
// TODO does this need native handling, or is this acceptable?
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
// dictionary's internal array, when generating the Class object non-
// deterministically.
@org.cprover.MustNotThrow
public void cproverInitializeClassLiteral(
String name,
boolean isAnnotation,
boolean isArray,
boolean isInterface,
boolean isSynthetic,
boolean isLocalClass,
boolean isMemberClass,
boolean isEnum) {
this.name = name;
this.cproverIsAnnotation = isAnnotation;
this.cproverIsArray = isArray;
this.cproverIsInterface = isInterface;
this.cproverIsSynthetic = isSynthetic;
this.cproverIsLocalClass = isLocalClass;
this.cproverIsMemberClass = isMemberClass;
this.cproverIsEnum = isEnum;
}
/**
* Returns a {@code Field} object that reflects the specified public member
* field of the class or interface represented by this {@code Class}
* object. The {@code name} parameter is a {@code String} specifying the
* simple name of the desired field.
*
*
The field to be reflected is determined by the algorithm that
* follows. Let C be the class or interface represented by this object:
*
*
*
If C declares a public field with the name specified, that is the
* field to be reflected.
*
If no field was found in step 1 above, this algorithm is applied
* recursively to each direct superinterface of C. The direct
* superinterfaces are searched in the order they were declared.
*
If no field was found in steps 1 and 2 above, and C has a
* superclass S, then this algorithm is invoked recursively upon S.
* If C has no superclass, then a {@code NoSuchFieldException}
* is thrown.
*
*
*
If this {@code Class} object represents an array type, then this
* method does not find the {@code length} field of the array type.
*
* @param name the field name
* @return the {@code Field} object of this class specified by
* {@code name}
* @throws NoSuchFieldException if a field with the specified name is
* not found.
* @throws NullPointerException if {@code name} is {@code null}
* @throws SecurityException
* If a security manager, s, is present and
* the caller's class loader is not the same as or an
* ancestor of the class loader for the current class and
* invocation of {@link SecurityManager#checkPackageAccess
* s.checkPackageAccess()} denies access to the package
* of this class.
*
* @since JDK1.1
* @jls 8.2 Class Members
* @jls 8.3 Field Declarations
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public Field getField(String name) throws NoSuchFieldException, SecurityException {
return new Field(this, name);
}
/**
* Returns a {@code Method} object that reflects the specified public
* member method of the class or interface represented by this
* {@code Class} object. The {@code name} parameter is a
* {@code String} specifying the simple name of the desired method. The
* {@code parameterTypes} parameter is an array of {@code Class}
* objects that identify the method's formal parameter types, in declared
* order. If {@code parameterTypes} is {@code null}, it is
* treated as if it were an empty array.
*
*
If the {@code name} is "{@code }" or "{@code }" a
* {@code NoSuchMethodException} is raised. Otherwise, the method to
* be reflected is determined by the algorithm that follows. Let C be the
* class or interface represented by this object:
*
*
C is searched for a matching method, as defined below. If a
* matching method is found, it is reflected.
*
If no matching method is found by step 1 then:
*
*
If C is a class other than {@code Object}, then this algorithm is
* invoked recursively on the superclass of C.
*
If C is the class {@code Object}, or if C is an interface, then
* the superinterfaces of C (if any) are searched for a matching
* method. If any such method is found, it is reflected.
*
*
*
*
To find a matching method in a class or interface C: If C
* declares exactly one public method with the specified name and exactly
* the same formal parameter types, that is the method reflected. If more
* than one such method is found in C, and one of these methods has a
* return type that is more specific than any of the others, that method is
* reflected; otherwise one of the methods is chosen arbitrarily.
*
*
Note that there may be more than one matching method in a
* class because while the Java language forbids a class to
* declare multiple methods with the same signature but different
* return types, the Java virtual machine does not. This
* increased flexibility in the virtual machine can be used to
* implement various language features. For example, covariant
* returns can be implemented with {@linkplain
* java.lang.reflect.Method#isBridge bridge methods}; the bridge
* method and the method being overridden would have the same
* signature but different return types.
*
*
If this {@code Class} object represents an array type, then this
* method does not find the {@code clone()} method.
*
*
Static methods declared in superinterfaces of the class or interface
* represented by this {@code Class} object are not considered members of
* the class or interface.
*
* @param name the name of the method
* @param parameterTypes the list of parameters
* @return the {@code Method} object that matches the specified
* {@code name} and {@code parameterTypes}
* @throws NoSuchMethodException if a matching method is not found
* or if the name is "<init>"or "<clinit>".
* @throws NullPointerException if {@code name} is {@code null}
* @throws SecurityException
* If a security manager, s, is present and
* the caller's class loader is not the same as or an
* ancestor of the class loader for the current class and
* invocation of {@link SecurityManager#checkPackageAccess
* s.checkPackageAccess()} denies access to the package
* of this class.
*
* @jls 8.2 Class Members
* @jls 8.4 Method Declarations
* @since JDK1.1
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public Method getMethod(String name, Class... parameterTypes) throws NoSuchMethodException, SecurityException {
return new Method(this, name, parameterTypes);
}
/**
* Returns the {@code Class} representing the component type of an
* array. If this class does not represent an array class this method
* returns null.
*
* @return the {@code Class} representing the component type of this
* class if this class is an array
* @see java.lang.reflect.Array
* @since 1.1
*/
public Class getComponentType() {
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
}
java-models-library-master/src/main/java/java/lang/ClassCastException.java 0000664 0000000 0000000 00000003573 14323475213 0027127 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/ClassCircularityError.java 0000664 0000000 0000000 00000004466 14323475213 0027664 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/ClassFormatError.java 0000664 0000000 0000000 00000004501 14323475213 0026610 0 ustar 00root root 0000000 0000000 /*
* 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 ClassFormatError with no detail message.
*/
public ClassFormatError() {
super();
}
/**
* Constructs a ClassFormatError 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";
}
}
java-models-library-master/src/main/java/java/lang/ClassNotFoundException.java 0000664 0000000 0000000 00000004377 14323475213 0027774 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/CloneNotSupportedException.java 0000664 0000000 0000000 00000003633 14323475213 0030673 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/Double.java 0000664 0000000 0000000 00000126350 14323475213 0024601 0 ustar 00root root 0000000 0000000 /*
* 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.CProverString;
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// import sun.misc.FloatingDecimal;
// import sun.misc.FpUtils;
import sun.misc.DoubleConsts;
import org.cprover.CProver;
/**
* The {@code Double} class wraps a value of the primitive type
* {@code double} in an object. An object of type
* {@code Double} contains a single field whose type is
* {@code double}.
*
*
In addition, this class provides several methods for converting a
* {@code double} to a {@code String} and a
* {@code String} to a {@code double}, as well as other
* constants and methods useful when dealing with a
* {@code double}.
*
* @author Lee Boynton
* @author Arthur van Hoff
* @author Joseph D. Darcy
* @since JDK1.0
*/
public final class Double extends Number implements Comparable {
/**
* A constant holding the positive infinity of type
* {@code double}. It is equal to the value returned by
* {@code Double.longBitsToDouble(0x7ff0000000000000L)}.
*/
public static final double POSITIVE_INFINITY = 1.0 / 0.0;
/**
* A constant holding the negative infinity of type
* {@code double}. It is equal to the value returned by
* {@code Double.longBitsToDouble(0xfff0000000000000L)}.
*/
public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
/**
* A constant holding a Not-a-Number (NaN) value of type
* {@code double}. It is equivalent to the value returned by
* {@code Double.longBitsToDouble(0x7ff8000000000000L)}.
*/
public static final double NaN = 0.0d / 0.0;
/**
* A constant holding the largest positive finite value of type
* {@code double},
* (2-2-52)·21023. It is equal to
* the hexadecimal floating-point literal
* {@code 0x1.fffffffffffffP+1023} and also equal to
* {@code Double.longBitsToDouble(0x7fefffffffffffffL)}.
*/
public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308
/**
* A constant holding the smallest positive normal value of type
* {@code double}, 2-1022. It is equal to the
* hexadecimal floating-point literal {@code 0x1.0p-1022} and also
* equal to {@code Double.longBitsToDouble(0x0010000000000000L)}.
*
* @since 1.6
*/
public static final double MIN_NORMAL = 0x1.0p-1022; // 2.2250738585072014E-308
/**
* A constant holding the smallest positive nonzero value of type
* {@code double}, 2-1074. It is equal to the
* hexadecimal floating-point literal
* {@code 0x0.0000000000001P-1022} and also equal to
* {@code Double.longBitsToDouble(0x1L)}.
*/
public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324
/**
* Maximum exponent a finite {@code double} variable may have.
* It is equal to the value returned by
* {@code Math.getExponent(Double.MAX_VALUE)}.
*
* @since 1.6
*/
public static final int MAX_EXPONENT = 1023;
/**
* Minimum exponent a normalized {@code double} variable may
* have. It is equal to the value returned by
* {@code Math.getExponent(Double.MIN_NORMAL)}.
*
* @since 1.6
*/
public static final int MIN_EXPONENT = -1022;
/**
* The number of bits used to represent a {@code double} value.
*
* @since 1.5
*/
public static final int SIZE = 64;
/**
* The number of bytes used to represent a {@code double} value.
*
* @since 1.8
*/
public static final int BYTES = SIZE / Byte.SIZE;
/**
* The {@code Class} instance representing the primitive type
* {@code double}.
*
* @since JDK1.1
*/
/*
* MODELS-LIBRARY {
* We use the int version of getPrimitiveClass instead of
* the original String version for efficiency reasons.
* }
*/
@SuppressWarnings("unchecked")
public static final Class TYPE = (Class) Class.getPrimitiveClass(7);
/**
* Returns a string representation of the {@code double}
* argument. All characters mentioned below are ASCII characters.
*
*
If the argument is NaN, the result is the string
* "{@code NaN}".
*
Otherwise, the result is a string that represents the sign and
* magnitude (absolute value) of the argument. If the sign is negative,
* the first character of the result is '{@code -}'
* ({@code '\u005Cu002D'}); if the sign is positive, no sign character
* appears in the result. As for the magnitude m:
*
*
If m is infinity, it is represented by the characters
* {@code "Infinity"}; thus, positive infinity produces the result
* {@code "Infinity"} and negative infinity produces the result
* {@code "-Infinity"}.
*
*
If m is zero, it is represented by the characters
* {@code "0.0"}; thus, negative zero produces the result
* {@code "-0.0"} and positive zero produces the result
* {@code "0.0"}.
*
*
If m is greater than or equal to 10-3 but less
* than 107, then it is represented as the integer part of
* m, in decimal form with no leading zeroes, followed by
* '{@code .}' ({@code '\u005Cu002E'}), followed by one or
* more decimal digits representing the fractional part of m.
*
*
If m is less than 10-3 or greater than or
* equal to 107, then it is represented in so-called
* "computerized scientific notation." Let n be the unique
* integer such that 10n ≤ m {@literal <}
* 10n+1; then let a be the
* mathematically exact quotient of m and
* 10n so that 1 ≤ a {@literal <} 10. The
* magnitude is then represented as the integer part of a,
* as a single decimal digit, followed by '{@code .}'
* ({@code '\u005Cu002E'}), followed by decimal digits
* representing the fractional part of a, followed by the
* letter '{@code E}' ({@code '\u005Cu0045'}), followed
* by a representation of n as a decimal integer, as
* produced by the method {@link Integer#toString(int)}.
*
*
* How many digits must be printed for the fractional part of
* m or a? There must be at least one digit to represent
* the fractional part, and beyond that as many, but only as many, more
* digits as are needed to uniquely distinguish the argument value from
* adjacent values of type {@code double}. That is, suppose that
* x is the exact mathematical value represented by the decimal
* representation produced by this method for a finite nonzero argument
* d. Then d must be the {@code double} value nearest
* to x; or if two {@code double} values are equally close
* to x, then d must be one of them and the least
* significant bit of the significand of d must be {@code 0}.
*
*
To create localized string representations of a floating-point
* value, use subclasses of {@link java.text.NumberFormat}.
*
* @param d the {@code double} to be converted.
* @return a string representation of the argument.
*
* @diffblue.limitedSupport
* The precision in the produced string may not match that of the
* actual program.
*/
public static String toString(double d) {
// return FloatingDecimal.toJavaFormatString(d);
return CProverString.toString(d);
}
/**
* Returns a hexadecimal string representation of the
* {@code double} argument. All characters mentioned below
* are ASCII characters.
*
*
*
If the argument is NaN, the result is the string
* "{@code NaN}".
*
Otherwise, the result is a string that represents the sign
* and magnitude of the argument. If the sign is negative, the
* first character of the result is '{@code -}'
* ({@code '\u005Cu002D'}); if the sign is positive, no sign
* character appears in the result. As for the magnitude m:
*
*
*
If m is infinity, it is represented by the string
* {@code "Infinity"}; thus, positive infinity produces the
* result {@code "Infinity"} and negative infinity produces
* the result {@code "-Infinity"}.
*
*
If m is zero, it is represented by the string
* {@code "0x0.0p0"}; thus, negative zero produces the result
* {@code "-0x0.0p0"} and positive zero produces the result
* {@code "0x0.0p0"}.
*
*
If m is a {@code double} value with a
* normalized representation, substrings are used to represent the
* significand and exponent fields. The significand is
* represented by the characters {@code "0x1."}
* followed by a lowercase hexadecimal representation of the rest
* of the significand as a fraction. Trailing zeros in the
* hexadecimal representation are removed unless all the digits
* are zero, in which case a single zero is used. Next, the
* exponent is represented by {@code "p"} followed
* by a decimal string of the unbiased exponent as if produced by
* a call to {@link Integer#toString(int) Integer.toString} on the
* exponent value.
*
*
If m is a {@code double} value with a subnormal
* representation, the significand is represented by the
* characters {@code "0x0."} followed by a
* hexadecimal representation of the rest of the significand as a
* fraction. Trailing zeros in the hexadecimal representation are
* removed. Next, the exponent is represented by
* {@code "p-1022"}. Note that there must be at
* least one nonzero digit in a subnormal significand.
*
*
*
*
*
*
*
Examples
*
Floating-point Value
Hexadecimal String
*
{@code 1.0}
{@code 0x1.0p0}
*
{@code -1.0}
{@code -0x1.0p0}
*
{@code 2.0}
{@code 0x1.0p1}
*
{@code 3.0}
{@code 0x1.8p1}
*
{@code 0.5}
{@code 0x1.0p-1}
*
{@code 0.25}
{@code 0x1.0p-2}
*
{@code Double.MAX_VALUE}
*
{@code 0x1.fffffffffffffp1023}
*
{@code Minimum Normal Value}
*
{@code 0x1.0p-1022}
*
{@code Maximum Subnormal Value}
*
{@code 0x0.fffffffffffffp-1022}
*
{@code Double.MIN_VALUE}
*
{@code 0x0.0000000000001p-1022}
*
* @param d the {@code double} to be converted.
* @return a hex string representation of the argument.
* @since 1.5
* @author Joseph D. Darcy
*/
public static String toHexString(double d) {
/*
* Modeled after the "a" conversion specifier in C99, section
* 7.19.6.1; however, the output of this method is more
* tightly specified.
*/
if (!isFinite(d) )
// For infinity and NaN, use the decimal output.
return Double.toString(d);
else {
// Initialized to maximum size of output.
StringBuilder answer = new StringBuilder(24);
if (Math.copySign(1.0, d) == -1.0) // value is negative,
answer.append("-"); // so append sign info
answer.append("0x");
d = Math.abs(d);
if(d == 0.0) {
answer.append("0.0p0");
} else {
boolean subnormal = (d < DoubleConsts.MIN_NORMAL);
// Isolate significand bits and OR in a high-order bit
// so that the string representation has a known
// length.
long signifBits = (Double.doubleToLongBits(d)
& DoubleConsts.SIGNIF_BIT_MASK) |
0x1000000000000000L;
// Subnormal values have a 0 implicit bit; normal
// values have a 1 implicit bit.
answer.append(subnormal ? "0." : "1.");
// Isolate the low-order 13 digits of the hex
// representation. If all the digits are zero,
// replace with a single 0; otherwise, remove all
// trailing zeros.
String signif = CProverString.substring(Long.toHexString(signifBits), 3, 16);
answer.append(signif.equals("0000000000000") ? // 13 zeros
"0":
signif.replaceFirst("0{1,12}$", ""));
answer.append('p');
// If the value is subnormal, use the E_min exponent
// value for double; otherwise, extract and report d's
// exponent (the representation of a subnormal uses
// E_min -1).
answer.append(subnormal ?
DoubleConsts.MIN_EXPONENT:
Math.getExponent(d));
}
return answer.toString();
}
}
/**
* Returns a {@code Double} object holding the
* {@code double} value represented by the argument string
* {@code s}.
*
*
If {@code s} is {@code null}, then a
* {@code NullPointerException} is thrown.
*
*
Leading and trailing whitespace characters in {@code s}
* are ignored. Whitespace is removed as if by the {@link
* String#trim} method; that is, both ASCII space and control
* characters are removed. The rest of {@code s} should
* constitute a FloatValue as described by the lexical
* syntax rules:
*
*
*
* where Sign, FloatingPointLiteral,
* HexNumeral, HexDigits, SignedInteger and
* FloatTypeSuffix are as defined in the lexical structure
* sections of
* The Java™ Language Specification,
* except that underscores are not accepted between digits.
* If {@code s} does not have the form of
* a FloatValue, then a {@code NumberFormatException}
* is thrown. Otherwise, {@code s} is regarded as
* representing an exact decimal value in the usual
* "computerized scientific notation" or as an exact
* hexadecimal value; this exact numerical value is then
* conceptually converted to an "infinitely precise"
* binary value that is then rounded to type {@code double}
* by the usual round-to-nearest rule of IEEE 754 floating-point
* arithmetic, which includes preserving the sign of a zero
* value.
*
* Note that the round-to-nearest rule also implies overflow and
* underflow behaviour; if the exact value of {@code s} is large
* enough in magnitude (greater than or equal to ({@link
* #MAX_VALUE} + {@link Math#ulp(double) ulp(MAX_VALUE)}/2),
* rounding to {@code double} will result in an infinity and if the
* exact value of {@code s} is small enough in magnitude (less
* than or equal to {@link #MIN_VALUE}/2), rounding to float will
* result in a zero.
*
* Finally, after rounding a {@code Double} object representing
* this {@code double} value is returned.
*
*
To interpret localized string representations of a
* floating-point value, use subclasses of {@link
* java.text.NumberFormat}.
*
*
Note that trailing format specifiers, specifiers that
* determine the type of a floating-point literal
* ({@code 1.0f} is a {@code float} value;
* {@code 1.0d} is a {@code double} value), do
* not influence the results of this method. In other
* words, the numerical value of the input string is converted
* directly to the target floating-point type. The two-step
* sequence of conversions, string to {@code float} followed
* by {@code float} to {@code double}, is not
* equivalent to converting a string directly to
* {@code double}. For example, the {@code float}
* literal {@code 0.1f} is equal to the {@code double}
* value {@code 0.10000000149011612}; the {@code float}
* literal {@code 0.1f} represents a different numerical
* value than the {@code double} literal
* {@code 0.1}. (The numerical value 0.1 cannot be exactly
* represented in a binary floating-point number.)
*
*
To avoid calling this method on an invalid string and having
* a {@code NumberFormatException} be thrown, the regular
* expression below can be used to screen the input string:
*
*
{@code
* final String Digits = "(\\p{Digit}+)";
* final String HexDigits = "(\\p{XDigit}+)";
* // an exponent is 'e' or 'E' followed by an optionally
* // signed decimal integer.
* final String Exp = "[eE][+-]?"+Digits;
* final String fpRegex =
* ("[\\x00-\\x20]*"+ // Optional leading "whitespace"
* "[+-]?(" + // Optional sign character
* "NaN|" + // "NaN" string
* "Infinity|" + // "Infinity" string
*
* // A decimal floating-point string representing a finite positive
* // number without a leading sign has at most five basic pieces:
* // Digits . Digits ExponentPart FloatTypeSuffix
* //
* // Since this method allows integer-only strings as input
* // in addition to strings of floating-point literals, the
* // two sub-patterns below are simplifications of the grammar
* // productions from section 3.10.2 of
* // The Java Language Specification.
*
* // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt
* "((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+
*
* // . Digits ExponentPart_opt FloatTypeSuffix_opt
* "(\\.("+Digits+")("+Exp+")?)|"+
*
* // Hexadecimal strings
* "((" +
* // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt
* "(0[xX]" + HexDigits + "(\\.)?)|" +
*
* // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt
* "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" +
*
* ")[pP][+-]?" + Digits + "))" +
* "[fFdD]?))" +
* "[\\x00-\\x20]*");// Optional trailing "whitespace"
*
* if (Pattern.matches(fpRegex, myString))
* Double.valueOf(myString); // Will not throw NumberFormatException
* else {
* // Perform suitable alternative action
* }
* }
*
* @param s the string to be parsed.
* @return a {@code Double} object holding the value
* represented by the {@code String} argument.
* @throws NumberFormatException if the string does not contain a
* parsable number.
*/
public static Double valueOf(String s) throws NumberFormatException {
return new Double(parseDouble(s));
}
/**
* Returns a {@code Double} instance representing the specified
* {@code double} value.
* If a new {@code Double} instance is not required, this method
* should generally be used in preference to the constructor
* {@link #Double(double)}, as this method is likely to yield
* significantly better space and time performance by caching
* frequently requested values.
*
* @param d a double value.
* @return a {@code Double} instance representing {@code d}.
* @since 1.5
*/
public static Double valueOf(double d) {
return new Double(d);
}
/**
* Returns a new {@code double} initialized to the value
* represented by the specified {@code String}, as performed
* by the {@code valueOf} method of class
* {@code Double}.
*
* @param s the string to be parsed.
* @return the {@code double} value represented by the string
* argument.
* @throws NullPointerException if the string is null
* @throws NumberFormatException if the string does not contain
* a parsable {@code double}.
* @see java.lang.Double#valueOf(String)
* @since 1.2
*
* @diffblue.noSupport
*/
public static double parseDouble(String s) throws NumberFormatException {
CProver.notModelled();
return CProver.nondetDouble();
}
/**
* Returns {@code true} if the specified number is a
* Not-a-Number (NaN) value, {@code false} otherwise.
*
* @param v the value to be tested.
* @return {@code true} if the value of the argument is NaN;
* {@code false} otherwise.
*/
public static boolean isNaN(double v) {
return (v != v);
}
/**
* Returns {@code true} if the specified number is infinitely
* large in magnitude, {@code false} otherwise.
*
* @param v the value to be tested.
* @return {@code true} if the value of the argument is positive
* infinity or negative infinity; {@code false} otherwise.
*/
public static boolean isInfinite(double v) {
return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
}
/**
* Returns {@code true} if the argument is a finite floating-point
* value; returns {@code false} otherwise (for NaN and infinity
* arguments).
*
* @param d the {@code double} value to be tested
* @return {@code true} if the argument is a finite
* floating-point value, {@code false} otherwise.
* @since 1.8
*/
public static boolean isFinite(double d) {
return DoubleConsts.MIN_VALUE <= d && d <= DoubleConsts.MAX_VALUE;
}
/**
* The value of the Double.
*
* @serial
*/
private final double value;
/**
* Constructs a newly allocated {@code Double} object that
* represents the primitive {@code double} argument.
*
* @param value the value to be represented by the {@code Double}.
*/
public Double(double value) {
this.value = value;
}
/**
* Constructs a newly allocated {@code Double} object that
* represents the floating-point value of type {@code double}
* represented by the string. The string is converted to a
* {@code double} value as if by the {@code valueOf} method.
*
* @param s a string to be converted to a {@code Double}.
* @throws NumberFormatException if the string does not contain a
* parsable number.
* @see java.lang.Double#valueOf(java.lang.String)
*/
public Double(String s) throws NumberFormatException {
value = parseDouble(s);
}
/**
* Returns {@code true} if this {@code Double} value is
* a Not-a-Number (NaN), {@code false} otherwise.
*
* @return {@code true} if the value represented by this object is
* NaN; {@code false} otherwise.
*/
public boolean isNaN() {
return isNaN(value);
}
/**
* Returns {@code true} if this {@code Double} value is
* infinitely large in magnitude, {@code false} otherwise.
*
* @return {@code true} if the value represented by this object is
* positive infinity or negative infinity;
* {@code false} otherwise.
*/
public boolean isInfinite() {
return isInfinite(value);
}
/**
* Returns a string representation of this {@code Double} object.
* The primitive {@code double} value represented by this
* object is converted to a string exactly as if by the method
* {@code toString} of one argument.
*
* @return a {@code String} representation of this object.
* @see java.lang.Double#toString(double)
*/
public String toString() {
return toString(value);
}
/**
* Returns the value of this {@code Double} as a {@code byte}
* after a narrowing primitive conversion.
*
* @return the {@code double} value represented by this object
* converted to type {@code byte}
* @jls 5.1.3 Narrowing Primitive Conversions
* @since JDK1.1
*/
public byte byteValue() {
return (byte)value;
}
/**
* Returns the value of this {@code Double} as a {@code short}
* after a narrowing primitive conversion.
*
* @return the {@code double} value represented by this object
* converted to type {@code short}
* @jls 5.1.3 Narrowing Primitive Conversions
* @since JDK1.1
*/
public short shortValue() {
return (short)value;
}
/**
* Returns the value of this {@code Double} as an {@code int}
* after a narrowing primitive conversion.
* @jls 5.1.3 Narrowing Primitive Conversions
*
* @return the {@code double} value represented by this object
* converted to type {@code int}
*/
public int intValue() {
return (int)value;
}
/**
* Returns the value of this {@code Double} as a {@code long}
* after a narrowing primitive conversion.
*
* @return the {@code double} value represented by this object
* converted to type {@code long}
* @jls 5.1.3 Narrowing Primitive Conversions
*/
public long longValue() {
return (long)value;
}
/**
* Returns the value of this {@code Double} as a {@code float}
* after a narrowing primitive conversion.
*
* @return the {@code double} value represented by this object
* converted to type {@code float}
* @jls 5.1.3 Narrowing Primitive Conversions
* @since JDK1.0
*/
public float floatValue() {
return (float)value;
}
/**
* Returns the {@code double} value of this {@code Double} object.
*
* @return the {@code double} value represented by this object
*/
public double doubleValue() {
return value;
}
/**
* Returns a hash code for this {@code Double} object. The
* result is the exclusive OR of the two halves of the
* {@code long} integer bit representation, exactly as
* produced by the method {@link #doubleToLongBits(double)}, of
* the primitive {@code double} value represented by this
* {@code Double} object. That is, the hash code is the value
* of the expression:
*
*
* {@code (int)(v^(v>>>32))}
*
*
* where {@code v} is defined by:
*
*
* {@code long v = Double.doubleToLongBits(this.doubleValue());}
*
*
* @return a {@code hash code} value for this object.
*/
@Override
public int hashCode() {
// return Double.hashCode(value);
return 0;
}
/**
* Returns a hash code for a {@code double} value; compatible with
* {@code Double.hashCode()}.
*
* @param value the value to hash
* @return a hash code value for a {@code double} value.
* @since 1.8
*/
public static int hashCode(double value) {
// long bits = doubleToLongBits(value);
// return (int)(bits ^ (bits >>> 32));
return 0;
}
/**
* 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 Double} object that
* represents a {@code double} that has the same value as the
* {@code double} represented by this object. For this
* purpose, two {@code double} values are considered to be
* the same if and only if the method {@link
* #doubleToLongBits(double)} returns the identical
* {@code long} value when applied to each.
*
*
Note that in most cases, for two instances of class
* {@code Double}, {@code d1} and {@code d2}, the
* value of {@code d1.equals(d2)} is {@code true} if and
* only if
*
*
* {@code d1.doubleValue() == d2.doubleValue()}
*
*
*
also has the value {@code true}. However, there are two
* exceptions:
*
*
If {@code d1} and {@code d2} both represent
* {@code Double.NaN}, then the {@code equals} method
* returns {@code true}, even though
* {@code Double.NaN==Double.NaN} has the value
* {@code false}.
*
If {@code d1} represents {@code +0.0} while
* {@code d2} represents {@code -0.0}, or vice versa,
* the {@code equal} test has the value {@code false},
* even though {@code +0.0==-0.0} has the value {@code true}.
*
* This definition allows hash tables to operate properly.
* @param obj the object to compare with.
* @return {@code true} if the objects are the same;
* {@code false} otherwise.
* @see java.lang.Double#doubleToLongBits(double)
*
* @diffblue.fullSupport
*
* Until the native method doubleToRawLongBits(D) is implemented in
* CBMC, this model will allow test generation for checking equality
* between two Doubles.
*/
public boolean equals(Object obj) {
// return (obj instanceof Double)
// && (doubleToLongBits(((Double)obj).value) ==
// doubleToLongBits(value));
// DIFFBLUE MODEL LIBRARY
if (!(obj instanceof Double))
return false;
Double d = (Double) obj;
double dValue = d.doubleValue();
// We inline isNaN here to avoid calls to a static method
boolean bothAreNaN = (dValue != dValue) && (value != value);
return bothAreNaN ||(
(value == 0.0 && dValue == 0.0)
? ((1/value == POSITIVE_INFINITY && 1/dValue == POSITIVE_INFINITY)
|| (1/value == NEGATIVE_INFINITY && 1/dValue == NEGATIVE_INFINITY))
: ((value == POSITIVE_INFINITY && dValue == POSITIVE_INFINITY)
|| (value == NEGATIVE_INFINITY && dValue == NEGATIVE_INFINITY)
|| value == dValue));
}
/**
* Returns a representation of the specified floating-point value
* according to the IEEE 754 floating-point "double
* format" bit layout.
*
*
Bit 63 (the bit that is selected by the mask
* {@code 0x8000000000000000L}) represents the sign of the
* floating-point number. Bits
* 62-52 (the bits that are selected by the mask
* {@code 0x7ff0000000000000L}) represent the exponent. Bits 51-0
* (the bits that are selected by the mask
* {@code 0x000fffffffffffffL}) represent the significand
* (sometimes called the mantissa) of the floating-point number.
*
*
If the argument is positive infinity, the result is
* {@code 0x7ff0000000000000L}.
*
*
If the argument is negative infinity, the result is
* {@code 0xfff0000000000000L}.
*
*
If the argument is NaN, the result is
* {@code 0x7ff8000000000000L}.
*
*
In all cases, the result is a {@code long} integer that, when
* given to the {@link #longBitsToDouble(long)} method, will produce a
* floating-point value the same as the argument to
* {@code doubleToLongBits} (except all NaN values are
* collapsed to a single "canonical" NaN value).
*
* @param value a {@code double} precision floating-point number.
* @return the bits that represent the floating-point number.
*/
public static long doubleToLongBits(double value) {
long result = doubleToRawLongBits(value);
// Check for NaN based on values of bit fields, maximum
// exponent and nonzero significand.
if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
DoubleConsts.EXP_BIT_MASK) &&
(result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
result = 0x7ff8000000000000L;
return result;
}
/**
* Returns a representation of the specified floating-point value
* according to the IEEE 754 floating-point "double
* format" bit layout, preserving Not-a-Number (NaN) values.
*
*
Bit 63 (the bit that is selected by the mask
* {@code 0x8000000000000000L}) represents the sign of the
* floating-point number. Bits
* 62-52 (the bits that are selected by the mask
* {@code 0x7ff0000000000000L}) represent the exponent. Bits 51-0
* (the bits that are selected by the mask
* {@code 0x000fffffffffffffL}) represent the significand
* (sometimes called the mantissa) of the floating-point number.
*
*
If the argument is positive infinity, the result is
* {@code 0x7ff0000000000000L}.
*
*
If the argument is negative infinity, the result is
* {@code 0xfff0000000000000L}.
*
*
If the argument is NaN, the result is the {@code long}
* integer representing the actual NaN value. Unlike the
* {@code doubleToLongBits} method,
* {@code doubleToRawLongBits} does not collapse all the bit
* patterns encoding a NaN to a single "canonical" NaN
* value.
*
*
In all cases, the result is a {@code long} integer that,
* when given to the {@link #longBitsToDouble(long)} method, will
* produce a floating-point value the same as the argument to
* {@code doubleToRawLongBits}.
*
* @param value a {@code double} precision floating-point number.
* @return the bits that represent the floating-point number.
* @since 1.3
*/
public static long doubleToRawLongBits(double value){
//@TODO: implement this method internally in CBMC
return CProver.nondetLong();
}
/**
* Returns the {@code double} value corresponding to a given
* bit representation.
* The argument is considered to be a representation of a
* floating-point value according to the IEEE 754 floating-point
* "double format" bit layout.
*
*
If the argument is {@code 0x7ff0000000000000L}, the result
* is positive infinity.
*
*
If the argument is {@code 0xfff0000000000000L}, the result
* is negative infinity.
*
*
If the argument is any value in the range
* {@code 0x7ff0000000000001L} through
* {@code 0x7fffffffffffffffL} or in the range
* {@code 0xfff0000000000001L} through
* {@code 0xffffffffffffffffL}, the result is a NaN. No IEEE
* 754 floating-point operation provided by Java can distinguish
* between two NaN values of the same type with different bit
* patterns. Distinct values of NaN are only distinguishable by
* use of the {@code Double.doubleToRawLongBits} method.
*
*
In all other cases, let s, e, and m be three
* values that can be computed from the argument:
*
*
{@code
* int s = ((bits >> 63) == 0) ? 1 : -1;
* int e = (int)((bits >> 52) & 0x7ffL);
* long m = (e == 0) ?
* (bits & 0xfffffffffffffL) << 1 :
* (bits & 0xfffffffffffffL) | 0x10000000000000L;
* }
*
* Then the floating-point result equals the value of the mathematical
* expression s·m·2e-1075.
*
*
Note that this method may not be able to return a
* {@code double} NaN with exactly same bit pattern as the
* {@code long} argument. IEEE 754 distinguishes between two
* kinds of NaNs, quiet NaNs and signaling NaNs. The
* differences between the two kinds of NaN are generally not
* visible in Java. Arithmetic operations on signaling NaNs turn
* them into quiet NaNs with a different, but often similar, bit
* pattern. However, on some processors merely copying a
* signaling NaN also performs that conversion. In particular,
* copying a signaling NaN to return it to the calling method
* may perform this conversion. So {@code longBitsToDouble}
* may not be able to return a {@code double} with a
* signaling NaN bit pattern. Consequently, for some
* {@code long} values,
* {@code doubleToRawLongBits(longBitsToDouble(start))} may
* not equal {@code start}. Moreover, which
* particular bit patterns represent signaling NaNs is platform
* dependent; although all NaN bit patterns, quiet or signaling,
* must be in the NaN range identified above.
*
* @param bits any {@code long} integer.
* @return the {@code double} floating-point value with the same
* bit pattern.
*/
public static double longBitsToDouble(long bits){
//@TODO: implement this method internally in CBMC
return CProver.nondetDouble();
}
/**
* Compares two {@code Double} objects numerically. There
* are two ways in which comparisons performed by this method
* differ from those performed by the Java language numerical
* comparison operators ({@code <, <=, ==, >=, >})
* when applied to primitive {@code double} values:
*
* {@code Double.NaN} is considered by this method
* to be equal to itself and greater than all other
* {@code double} values (including
* {@code Double.POSITIVE_INFINITY}).
*
* {@code 0.0d} is considered by this method to be greater
* than {@code -0.0d}.
*
* This ensures that the natural ordering of
* {@code Double} objects imposed by this method is consistent
* with equals.
*
* @param anotherDouble the {@code Double} to be compared.
* @return the value {@code 0} if {@code anotherDouble} is
* numerically equal to this {@code Double}; a value
* less than {@code 0} if this {@code Double}
* is numerically less than {@code anotherDouble};
* and a value greater than {@code 0} if this
* {@code Double} is numerically greater than
* {@code anotherDouble}.
*
* @since 1.2
*/
public int compareTo(Double anotherDouble) {
return Double.compare(value, anotherDouble.value);
}
/**
* Compares the two specified {@code double} values. The sign
* of the integer value returned is the same as that of the
* integer that would be returned by the call:
*
* new Double(d1).compareTo(new Double(d2))
*
*
* @param d1 the first {@code double} to compare
* @param d2 the second {@code double} to compare
* @return the value {@code 0} if {@code d1} is
* numerically equal to {@code d2}; a value less than
* {@code 0} if {@code d1} is numerically less than
* {@code d2}; and a value greater than {@code 0}
* if {@code d1} is numerically greater than
* {@code d2}.
* @since 1.4
*/
public static int compare(double d1, double d2) {
if (d1 < d2)
return -1; // Neither val is NaN, thisVal is smaller
if (d1 > d2)
return 1; // Neither val is NaN, thisVal is larger
// Cannot use doubleToRawLongBits because of possibility of NaNs.
long thisBits = Double.doubleToLongBits(d1);
long anotherBits = Double.doubleToLongBits(d2);
return (thisBits == anotherBits ? 0 : // Values are equal
(thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
1)); // (0.0, -0.0) or (NaN, !NaN)
}
/**
* Adds two {@code double} values together as per the + operator.
*
* @param a the first operand
* @param b the second operand
* @return the sum of {@code a} and {@code b}
* @jls 4.2.4 Floating-Point Operations
* @see java.util.function.BinaryOperator
* @since 1.8
*/
public static double sum(double a, double b) {
return a + b;
}
/**
* Returns the greater of two {@code double} values
* as if by calling {@link Math#max(double, double) 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 double max(double a, double b) {
double result = CProver.nondetDouble();
CProver.assume((result == a || result == b) && result >= a && result >= b);
return result;
}
/**
* Returns the smaller of two {@code double} values
* as if by calling {@link Math#min(double, double) 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 double min(double a, double b) {
double result = CProver.nondetDouble();
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 = -9172774392245257468L;
}
java-models-library-master/src/main/java/java/lang/Enum.java 0000664 0000000 0000000 00000022663 14323475213 0024275 0 ustar 00root root 0000000 0000000 /*
* 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
* The Java™ Language Specification.
*
*
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 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>
implements Comparable, 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.
*
* Most programmers should use the {@link #toString} method in
* preference to this one, as the toString method may return
* a more user-friendly name. 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 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 getDeclaringClass() {
Class clazz = getClass();
Class zuper = clazz.getSuperclass();
return (zuper == Enum.class) ? (Class)clazz : (Class)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.)
*
*
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 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 valueOf(Class 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");
}
}
java-models-library-master/src/main/java/java/lang/EnumConstantNotPresentException.java 0000664 0000000 0000000 00000004522 14323475213 0031702 0 ustar 00root root 0000000 0000000 /*
* 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 enumType;
private String constantName;
public EnumConstantNotPresentException(Class enumType,
String constantName) {
super(enumType.getName() + "." + constantName);
this.enumType = enumType;
this.constantName = constantName;
}
public Class 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";
}
}
java-models-library-master/src/main/java/java/lang/Error.java 0000664 0000000 0000000 00000012642 14323475213 0024456 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* An {@code Error} is a subclass of {@code Throwable}
* that indicates serious problems that a reasonable application
* should not try to catch. Most such errors are abnormal conditions.
* The {@code ThreadDeath} error, though a "normal" condition,
* is also a subclass of {@code Error} because most applications
* should not try to catch it.
*
* A method is not required to declare in its {@code throws}
* clause any subclasses of {@code Error} that might be thrown
* during the execution of the method but not caught, since these
* errors are abnormal conditions that should never occur.
*
* That is, {@code Error} and its subclasses are regarded as unchecked
* exceptions for the purposes of compile-time checking of exceptions.
*
* @author Frank Yellin
* @see java.lang.ThreadDeath
* @jls 11.2 Compile-Time Checking of Exceptions
* @since JDK1.0
*/
public class Error extends Throwable {
static final long serialVersionUID = 4980196508277280342L;
/**
* Constructs a new error with {@code null} as its detail message.
* The cause is not initialized, and may subsequently be initialized by a
* call to {@link #initCause}.
*/
public Error() {
super();
}
/**
* Constructs a new error with the specified detail message. The
* cause is not initialized, and may subsequently be initialized by
* a call to {@link #initCause}.
*
* @param message the detail message. The detail message is saved for
* later retrieval by the {@link #getMessage()} method.
*/
public Error(String message) {
super(message);
}
/**
* Constructs a new error with the specified detail message and
* cause.
Note that the detail message associated with
* {@code cause} is not 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.4
*/
public Error(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructs a new error 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}).
* This constructor is useful for errors that are little more than
* wrappers for other throwables.
*
* @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.4
*/
public Error(Throwable cause) {
super(cause);
}
/**
* Constructs a new error with the specified detail message,
* cause, suppression enabled or disabled, and writable stack
* trace enabled or disabled.
*
* @param message the detail message.
* @param cause the cause. (A {@code null} value is permitted,
* and indicates that the cause is nonexistent or unknown.)
* @param enableSuppression whether or not suppression is enabled
* or disabled
* @param writableStackTrace whether or not the stack trace should
* be writable
*
* @since 1.7
*/
protected Error(String message, Throwable cause,
boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
// 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.Error: " + message)
: "java.lang.Error";
}
}
java-models-library-master/src/main/java/java/lang/Exception.java 0000664 0000000 0000000 00000012525 14323475213 0025323 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* The class {@code Exception} and its subclasses are a form of
* {@code Throwable} that indicates conditions that a reasonable
* application might want to catch.
*
*
The class {@code Exception} and any subclasses that are not also
* subclasses of {@link RuntimeException} are checked
* exceptions. Checked exceptions need to be declared in a
* method or constructor's {@code throws} clause if they can be thrown
* by the execution of the method or constructor and propagate outside
* the method or constructor boundary.
*
* @author Frank Yellin
* @see java.lang.Error
* @jls 11.2 Compile-Time Checking of Exceptions
* @since JDK1.0
*/
public class Exception extends Throwable {
static final long serialVersionUID = -3387516993124229948L;
/**
* Constructs a new exception with {@code null} as its detail message.
* The cause is not initialized, and may subsequently be initialized by a
* call to {@link #initCause}.
*/
public Exception() {
super();
}
/**
* Constructs a new exception with the specified detail message. The
* cause is not initialized, and may subsequently be initialized by
* a call to {@link #initCause}.
*
* @param message the detail message. The detail message is saved for
* later retrieval by the {@link #getMessage()} method.
*/
public Exception(String message) {
super(message);
}
/**
* Constructs a new exception with the specified detail message and
* cause.
Note that the detail message associated with
* {@code cause} is not automatically incorporated in
* this exception'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 null value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.4
*/
public Exception(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructs a new exception with the specified cause and a detail
* message of (cause==null ? null : cause.toString()) (which
* typically contains the class and detail message of cause).
* This constructor is useful for exceptions that are little more than
* wrappers for other throwables (for example, {@link
* java.security.PrivilegedActionException}).
*
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A null value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.4
*/
public Exception(Throwable cause) {
super(cause);
}
/**
* Constructs a new exception with the specified detail message,
* cause, suppression enabled or disabled, and writable stack
* trace enabled or disabled.
*
* @param message the detail message.
* @param cause the cause. (A {@code null} value is permitted,
* and indicates that the cause is nonexistent or unknown.)
* @param enableSuppression whether or not suppression is enabled
* or disabled
* @param writableStackTrace whether or not the stack trace should
* be writable
* @since 1.7
*/
protected Exception(String message, Throwable cause,
boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
// 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.Exception: " + message)
: "java.lang.Exception";
}
}
java-models-library-master/src/main/java/java/lang/ExceptionInInitializerError.java 0000664 0000000 0000000 00000012223 14323475213 0031023 0 ustar 00root root 0000000 0000000 /*
* 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 ExceptionInInitializerError is thrown to indicate that an
* exception occurred during evaluation of a static initializer or the
* initializer for a static variable.
*
*
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 cause,
* 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 ExceptionInInitializerError with
* null 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 ExceptionInInitializerError class by
* saving a reference to the Throwable object thrown for
* later retrieval by the {@link #getException()} method. The detail
* message string is set to null.
*
* @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.
*
*
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
* ExceptionInInitializerError, or null
* if this ExceptionInInitializerError 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 null 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";
}
}
java-models-library-master/src/main/java/java/lang/Float.java 0000664 0000000 0000000 00000115440 14323475213 0024432 0 ustar 00root root 0000000 0000000 /*
* 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;
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// import sun.misc.FloatingDecimal;
import sun.misc.FloatConsts;
import sun.misc.DoubleConsts;
import org.cprover.CProver;
import org.cprover.CProverString;
/**
* The {@code Float} class wraps a value of primitive type
* {@code float} in an object. An object of type
* {@code Float} contains a single field whose type is
* {@code float}.
*
*
In addition, this class provides several methods for converting a
* {@code float} to a {@code String} and a
* {@code String} to a {@code float}, as well as other
* constants and methods useful when dealing with a
* {@code float}.
*
* @author Lee Boynton
* @author Arthur van Hoff
* @author Joseph D. Darcy
* @since JDK1.0
*/
public final class Float extends Number implements Comparable {
/**
* A constant holding the positive infinity of type
* {@code float}. It is equal to the value returned by
* {@code Float.intBitsToFloat(0x7f800000)}.
*/
public static final float POSITIVE_INFINITY = 1.0f / 0.0f;
/**
* A constant holding the negative infinity of type
* {@code float}. It is equal to the value returned by
* {@code Float.intBitsToFloat(0xff800000)}.
*/
public static final float NEGATIVE_INFINITY = -1.0f / 0.0f;
/**
* A constant holding a Not-a-Number (NaN) value of type
* {@code float}. It is equivalent to the value returned by
* {@code Float.intBitsToFloat(0x7fc00000)}.
*/
public static final float NaN = 0.0f / 0.0f;
/**
* A constant holding the largest positive finite value of type
* {@code float}, (2-2-23)·2127.
* It is equal to the hexadecimal floating-point literal
* {@code 0x1.fffffeP+127f} and also equal to
* {@code Float.intBitsToFloat(0x7f7fffff)}.
*/
public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f
/**
* A constant holding the smallest positive normal value of type
* {@code float}, 2-126. It is equal to the
* hexadecimal floating-point literal {@code 0x1.0p-126f} and also
* equal to {@code Float.intBitsToFloat(0x00800000)}.
*
* @since 1.6
*/
public static final float MIN_NORMAL = 0x1.0p-126f; // 1.17549435E-38f
/**
* A constant holding the smallest positive nonzero value of type
* {@code float}, 2-149. It is equal to the
* hexadecimal floating-point literal {@code 0x0.000002P-126f}
* and also equal to {@code Float.intBitsToFloat(0x1)}.
*/
public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f
/**
* Maximum exponent a finite {@code float} variable may have. It
* is equal to the value returned by {@code
* Math.getExponent(Float.MAX_VALUE)}.
*
* @since 1.6
*/
public static final int MAX_EXPONENT = 127;
/**
* Minimum exponent a normalized {@code float} variable may have.
* It is equal to the value returned by {@code
* Math.getExponent(Float.MIN_NORMAL)}.
*
* @since 1.6
*/
public static final int MIN_EXPONENT = -126;
/**
* The number of bits used to represent a {@code float} value.
*
* @since 1.5
*/
public static final int SIZE = 32;
/**
* The number of bytes used to represent a {@code float} value.
*
* @since 1.8
*/
public static final int BYTES = SIZE / Byte.SIZE;
/**
* The {@code Class} instance representing the primitive type
* {@code float}.
*
* @since JDK1.1
*/
@SuppressWarnings("unchecked")
public static final Class TYPE = (Class) Class.getPrimitiveClass(7);
/**
* Returns a string representation of the {@code float}
* argument. All characters mentioned below are ASCII characters.
*
*
If the argument is NaN, the result is the string
* "{@code NaN}".
*
Otherwise, the result is a string that represents the sign and
* magnitude (absolute value) of the argument. If the sign is
* negative, the first character of the result is
* '{@code -}' ({@code '\u005Cu002D'}); if the sign is
* positive, no sign character appears in the result. As for
* the magnitude m:
*
*
If m is infinity, it is represented by the characters
* {@code "Infinity"}; thus, positive infinity produces
* the result {@code "Infinity"} and negative infinity
* produces the result {@code "-Infinity"}.
*
If m is zero, it is represented by the characters
* {@code "0.0"}; thus, negative zero produces the result
* {@code "-0.0"} and positive zero produces the result
* {@code "0.0"}.
*
If m is greater than or equal to 10-3 but
* less than 107, then it is represented as the
* integer part of m, in decimal form with no leading
* zeroes, followed by '{@code .}'
* ({@code '\u005Cu002E'}), followed by one or more
* decimal digits representing the fractional part of
* m.
*
If m is less than 10-3 or greater than or
* equal to 107, then it is represented in
* so-called "computerized scientific notation." Let n
* be the unique integer such that 10n≤
* m {@literal <} 10n+1; then let a
* be the mathematically exact quotient of m and
* 10n so that 1 ≤ a {@literal <} 10.
* The magnitude is then represented as the integer part of
* a, as a single decimal digit, followed by
* '{@code .}' ({@code '\u005Cu002E'}), followed by
* decimal digits representing the fractional part of
* a, followed by the letter '{@code E}'
* ({@code '\u005Cu0045'}), followed by a representation
* of n as a decimal integer, as produced by the
* method {@link java.lang.Integer#toString(int)}.
*
*
*
* How many digits must be printed for the fractional part of
* m or a? There must be at least one digit
* to represent the fractional part, and beyond that as many, but
* only as many, more digits as are needed to uniquely distinguish
* the argument value from adjacent values of type
* {@code float}. That is, suppose that x is the
* exact mathematical value represented by the decimal
* representation produced by this method for a finite nonzero
* argument f. Then f must be the {@code float}
* value nearest to x; or, if two {@code float} values are
* equally close to x, then f must be one of
* them and the least significant bit of the significand of
* f must be {@code 0}.
*
*
To create localized string representations of a floating-point
* value, use subclasses of {@link java.text.NumberFormat}.
*
* @param f the float to be converted.
* @return a string representation of the argument.
*
* @diffblue.limitedSupport
* The precision in the produced string may not match that of the
* actual program.
*/
public static String toString(float f) {
return CProverString.toString(f);
}
/**
* Returns a hexadecimal string representation of the
* {@code float} argument. All characters mentioned below are
* ASCII characters.
*
*
*
If the argument is NaN, the result is the string
* "{@code NaN}".
*
Otherwise, the result is a string that represents the sign and
* magnitude (absolute value) of the argument. If the sign is negative,
* the first character of the result is '{@code -}'
* ({@code '\u005Cu002D'}); if the sign is positive, no sign character
* appears in the result. As for the magnitude m:
*
*
*
If m is infinity, it is represented by the string
* {@code "Infinity"}; thus, positive infinity produces the
* result {@code "Infinity"} and negative infinity produces
* the result {@code "-Infinity"}.
*
*
If m is zero, it is represented by the string
* {@code "0x0.0p0"}; thus, negative zero produces the result
* {@code "-0x0.0p0"} and positive zero produces the result
* {@code "0x0.0p0"}.
*
*
If m is a {@code float} value with a
* normalized representation, substrings are used to represent the
* significand and exponent fields. The significand is
* represented by the characters {@code "0x1."}
* followed by a lowercase hexadecimal representation of the rest
* of the significand as a fraction. Trailing zeros in the
* hexadecimal representation are removed unless all the digits
* are zero, in which case a single zero is used. Next, the
* exponent is represented by {@code "p"} followed
* by a decimal string of the unbiased exponent as if produced by
* a call to {@link Integer#toString(int) Integer.toString} on the
* exponent value.
*
*
If m is a {@code float} value with a subnormal
* representation, the significand is represented by the
* characters {@code "0x0."} followed by a
* hexadecimal representation of the rest of the significand as a
* fraction. Trailing zeros in the hexadecimal representation are
* removed. Next, the exponent is represented by
* {@code "p-126"}. Note that there must be at
* least one nonzero digit in a subnormal significand.
*
*
*
*
*
*
*
Examples
*
Floating-point Value
Hexadecimal String
*
{@code 1.0}
{@code 0x1.0p0}
*
{@code -1.0}
{@code -0x1.0p0}
*
{@code 2.0}
{@code 0x1.0p1}
*
{@code 3.0}
{@code 0x1.8p1}
*
{@code 0.5}
{@code 0x1.0p-1}
*
{@code 0.25}
{@code 0x1.0p-2}
*
{@code Float.MAX_VALUE}
*
{@code 0x1.fffffep127}
*
{@code Minimum Normal Value}
*
{@code 0x1.0p-126}
*
{@code Maximum Subnormal Value}
*
{@code 0x0.fffffep-126}
*
{@code Float.MIN_VALUE}
*
{@code 0x0.000002p-126}
*
* @param f the {@code float} to be converted.
* @return a hex string representation of the argument.
* @since 1.5
* @author Joseph D. Darcy
*/
public static String toHexString(float f) {
if (Math.abs(f) < FloatConsts.MIN_NORMAL
&& f != 0.0f ) {// float subnormal
// Adjust exponent to create subnormal double, then
// replace subnormal double exponent with subnormal float
// exponent
String s = Double.toHexString(Math.scalb((double)f,
/* -1022+126 */
DoubleConsts.MIN_EXPONENT-
FloatConsts.MIN_EXPONENT));
return s.replaceFirst("p-1022$", "p-126");
}
else // double string will be the same as float string
return Double.toHexString(f);
}
/**
* Returns a {@code Float} object holding the
* {@code float} value represented by the argument string
* {@code s}.
*
*
If {@code s} is {@code null}, then a
* {@code NullPointerException} is thrown.
*
*
Leading and trailing whitespace characters in {@code s}
* are ignored. Whitespace is removed as if by the {@link
* String#trim} method; that is, both ASCII space and control
* characters are removed. The rest of {@code s} should
* constitute a FloatValue as described by the lexical
* syntax rules:
*
*
*
* where Sign, FloatingPointLiteral,
* HexNumeral, HexDigits, SignedInteger and
* FloatTypeSuffix are as defined in the lexical structure
* sections of
* The Java™ Language Specification,
* except that underscores are not accepted between digits.
* If {@code s} does not have the form of
* a FloatValue, then a {@code NumberFormatException}
* is thrown. Otherwise, {@code s} is regarded as
* representing an exact decimal value in the usual
* "computerized scientific notation" or as an exact
* hexadecimal value; this exact numerical value is then
* conceptually converted to an "infinitely precise"
* binary value that is then rounded to type {@code float}
* by the usual round-to-nearest rule of IEEE 754 floating-point
* arithmetic, which includes preserving the sign of a zero
* value.
*
* Note that the round-to-nearest rule also implies overflow and
* underflow behaviour; if the exact value of {@code s} is large
* enough in magnitude (greater than or equal to ({@link
* #MAX_VALUE} + {@link Math#ulp(float) ulp(MAX_VALUE)}/2),
* rounding to {@code float} will result in an infinity and if the
* exact value of {@code s} is small enough in magnitude (less
* than or equal to {@link #MIN_VALUE}/2), rounding to float will
* result in a zero.
*
* Finally, after rounding a {@code Float} object representing
* this {@code float} value is returned.
*
*
To interpret localized string representations of a
* floating-point value, use subclasses of {@link
* java.text.NumberFormat}.
*
*
Note that trailing format specifiers, specifiers that
* determine the type of a floating-point literal
* ({@code 1.0f} is a {@code float} value;
* {@code 1.0d} is a {@code double} value), do
* not influence the results of this method. In other
* words, the numerical value of the input string is converted
* directly to the target floating-point type. In general, the
* two-step sequence of conversions, string to {@code double}
* followed by {@code double} to {@code float}, is
* not equivalent to converting a string directly to
* {@code float}. For example, if first converted to an
* intermediate {@code double} and then to
* {@code float}, the string
* {@code "1.00000017881393421514957253748434595763683319091796875001d"}
* results in the {@code float} value
* {@code 1.0000002f}; if the string is converted directly to
* {@code float}, 1.0000001f results.
*
*
To avoid calling this method on an invalid string and having
* a {@code NumberFormatException} be thrown, the documentation
* for {@link Double#valueOf Double.valueOf} lists a regular
* expression which can be used to screen the input.
*
* @param s the string to be parsed.
* @return a {@code Float} object holding the value
* represented by the {@code String} argument.
* @throws NumberFormatException if the string does not contain a
* parsable number.
*/
public static Float valueOf(String s) throws NumberFormatException {
return new Float(parseFloat(s));
}
/**
* Returns a {@code Float} instance representing the specified
* {@code float} value.
* If a new {@code Float} instance is not required, this method
* should generally be used in preference to the constructor
* {@link #Float(float)}, as this method is likely to yield
* significantly better space and time performance by caching
* frequently requested values.
*
* @param f a float value.
* @return a {@code Float} instance representing {@code f}.
* @since 1.5
*/
public static Float valueOf(float f) {
return new Float(f);
}
/**
* Returns a new {@code float} initialized to the value
* represented by the specified {@code String}, as performed
* by the {@code valueOf} method of class {@code Float}.
*
* @param s the string to be parsed.
* @return the {@code float} value represented by the string
* argument.
* @throws NullPointerException if the string is null
* @throws NumberFormatException if the string does not contain a
* parsable {@code float}.
* @see java.lang.Float#valueOf(String)
* @since 1.2
*/
public static float parseFloat(String s) throws NumberFormatException {
return CProver.nondetFloat(); //The function is handled by cbmc internally
}
/**
* Returns {@code true} if the specified number is a
* Not-a-Number (NaN) value, {@code false} otherwise.
*
* @param v the value to be tested.
* @return {@code true} if the argument is NaN;
* {@code false} otherwise.
*/
public static boolean isNaN(float v) {
return (v != v);
}
/**
* Returns {@code true} if the specified number is infinitely
* large in magnitude, {@code false} otherwise.
*
* @param v the value to be tested.
* @return {@code true} if the argument is positive infinity or
* negative infinity; {@code false} otherwise.
*/
public static boolean isInfinite(float v) {
return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
}
/**
* Returns {@code true} if the argument is a finite floating-point
* value; returns {@code false} otherwise (for NaN and infinity
* arguments).
*
* @param f the {@code float} value to be tested
* @return {@code true} if the argument is a finite
* floating-point value, {@code false} otherwise.
* @since 1.8
*/
public static boolean isFinite(float f) {
return FloatConsts.MIN_VALUE <= f && f <= FloatConsts.MAX_VALUE;
}
/**
* The value of the Float.
*
* @serial
*/
private final float value;
/**
* Constructs a newly allocated {@code Float} object that
* represents the primitive {@code float} argument.
*
* @param value the value to be represented by the {@code Float}.
*/
public Float(float value) {
this.value = value;
}
/**
* Constructs a newly allocated {@code Float} object that
* represents the argument converted to type {@code float}.
*
* @param value the value to be represented by the {@code Float}.
*/
public Float(double value) {
this.value = (float)value;
}
/**
* Constructs a newly allocated {@code Float} object that
* represents the floating-point value of type {@code float}
* represented by the string. The string is converted to a
* {@code float} value as if by the {@code valueOf} method.
*
* @param s a string to be converted to a {@code Float}.
* @throws NumberFormatException if the string does not contain a
* parsable number.
* @see java.lang.Float#valueOf(java.lang.String)
*/
public Float(String s) throws NumberFormatException {
value = parseFloat(s);
}
/**
* Returns {@code true} if this {@code Float} value is a
* Not-a-Number (NaN), {@code false} otherwise.
*
* @return {@code true} if the value represented by this object is
* NaN; {@code false} otherwise.
*/
public boolean isNaN() {
return isNaN(value);
}
/**
* Returns {@code true} if this {@code Float} value is
* infinitely large in magnitude, {@code false} otherwise.
*
* @return {@code true} if the value represented by this object is
* positive infinity or negative infinity;
* {@code false} otherwise.
*/
public boolean isInfinite() {
return isInfinite(value);
}
/**
* Returns a string representation of this {@code Float} object.
* The primitive {@code float} value represented by this object
* is converted to a {@code String} exactly as if by the method
* {@code toString} of one argument.
*
* @return a {@code String} representation of this object.
* @see java.lang.Float#toString(float)
*/
public String toString() {
return Float.toString(value);
}
/**
* Returns the value of this {@code Float} as a {@code byte} after
* a narrowing primitive conversion.
*
* @return the {@code float} value represented by this object
* converted to type {@code byte}
* @jls 5.1.3 Narrowing Primitive Conversions
*/
public byte byteValue() {
return (byte)value;
}
/**
* Returns the value of this {@code Float} as a {@code short}
* after a narrowing primitive conversion.
*
* @return the {@code float} value represented by this object
* converted to type {@code short}
* @jls 5.1.3 Narrowing Primitive Conversions
* @since JDK1.1
*/
public short shortValue() {
return (short)value;
}
/**
* Returns the value of this {@code Float} as an {@code int} after
* a narrowing primitive conversion.
*
* @return the {@code float} value represented by this object
* converted to type {@code int}
* @jls 5.1.3 Narrowing Primitive Conversions
*/
public int intValue() {
return (int)value;
}
/**
* Returns value of this {@code Float} as a {@code long} after a
* narrowing primitive conversion.
*
* @return the {@code float} value represented by this object
* converted to type {@code long}
* @jls 5.1.3 Narrowing Primitive Conversions
*/
public long longValue() {
return (long)value;
}
/**
* Returns the {@code float} value of this {@code Float} object.
*
* @return the {@code float} value represented by this object
*/
public float floatValue() {
return value;
}
/**
* Returns the value of this {@code Float} as a {@code double}
* after a widening primitive conversion.
*
* @return the {@code float} value represented by this
* object converted to type {@code double}
* @jls 5.1.2 Widening Primitive Conversions
*/
public double doubleValue() {
return (double)value;
}
/**
* Returns a hash code for this {@code Float} object. The
* result is the integer bit representation, exactly as produced
* by the method {@link #floatToIntBits(float)}, of the primitive
* {@code float} value represented by this {@code Float}
* object.
*
* @return a hash code value for this object.
*/
@Override
public int hashCode() {
// return Float.hashCode(value);
return 0;
}
/**
* Returns a hash code for a {@code float} value; compatible with
* {@code Float.hashCode()}.
*
* @param value the value to hash
* @return a hash code value for a {@code float} value.
* @since 1.8
*/
public static int hashCode(float value) {
// return floatToIntBits(value);
return 0;
}
/**
* 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 Float} object that
* represents a {@code float} with the same value as the
* {@code float} represented by this object. For this
* purpose, two {@code float} values are considered to be the
* same if and only if the method {@link #floatToIntBits(float)}
* returns the identical {@code int} value when applied to
* each.
*
*
Note that in most cases, for two instances of class
* {@code Float}, {@code f1} and {@code f2}, the value
* of {@code f1.equals(f2)} is {@code true} if and only if
*
*
* f1.floatValue() == f2.floatValue()
*
*
*
also has the value {@code true}. However, there are two exceptions:
*
*
If {@code f1} and {@code f2} both represent
* {@code Float.NaN}, then the {@code equals} method returns
* {@code true}, even though {@code Float.NaN==Float.NaN}
* has the value {@code false}.
*
If {@code f1} represents {@code +0.0f} while
* {@code f2} represents {@code -0.0f}, or vice
* versa, the {@code equal} test has the value
* {@code false}, even though {@code 0.0f==-0.0f}
* has the value {@code true}.
*
*
* This definition allows hash tables to operate properly.
*
* @param obj the object to be compared
* @return {@code true} if the objects are the same;
* {@code false} otherwise.
* @see java.lang.Float#floatToIntBits(float)
*
* @diffblue.fullSupport
*
* Until the native method floatToRawIntBits(F) is implemented in
* CBMC, this model will allow test generation for checking equality
* between two Floats.
*/
public boolean equals(Object obj) {
// return (obj instanceof Float)
// && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
// DIFFBLUE MODEL LIBRARY
if (!(obj instanceof Float))
return false;
Float f = (Float) obj;
float fValue = f.floatValue();
// We inline isNaN here to avoid calls to a static method
boolean bothAreNaN = (value != value) && (fValue != fValue);
return bothAreNaN ||
((value == 0.0 && fValue == 0.0)
? ((1/value == POSITIVE_INFINITY && 1/fValue == POSITIVE_INFINITY)
|| (1/value == NEGATIVE_INFINITY && 1/fValue == NEGATIVE_INFINITY))
: ((value == POSITIVE_INFINITY && fValue == POSITIVE_INFINITY)
|| (value == NEGATIVE_INFINITY && fValue == NEGATIVE_INFINITY)
|| value == fValue));
}
/**
* Returns a representation of the specified floating-point value
* according to the IEEE 754 floating-point "single format" bit
* layout.
*
*
Bit 31 (the bit that is selected by the mask
* {@code 0x80000000}) represents the sign of the floating-point
* number.
* Bits 30-23 (the bits that are selected by the mask
* {@code 0x7f800000}) represent the exponent.
* Bits 22-0 (the bits that are selected by the mask
* {@code 0x007fffff}) represent the significand (sometimes called
* the mantissa) of the floating-point number.
*
*
If the argument is positive infinity, the result is
* {@code 0x7f800000}.
*
*
If the argument is negative infinity, the result is
* {@code 0xff800000}.
*
*
If the argument is NaN, the result is {@code 0x7fc00000}.
*
*
In all cases, the result is an integer that, when given to the
* {@link #intBitsToFloat(int)} method, will produce a floating-point
* value the same as the argument to {@code floatToIntBits}
* (except all NaN values are collapsed to a single
* "canonical" NaN value).
*
* @param value a floating-point number.
* @return the bits that represent the floating-point number.
*/
public static int floatToIntBits(float value) {
int result = floatToRawIntBits(value);
// Check for NaN based on values of bit fields, maximum
// exponent and nonzero significand.
if ( ((result & FloatConsts.EXP_BIT_MASK) ==
FloatConsts.EXP_BIT_MASK) &&
(result & FloatConsts.SIGNIF_BIT_MASK) != 0)
result = 0x7fc00000;
return result;
}
/**
* Returns a representation of the specified floating-point value
* according to the IEEE 754 floating-point "single format" bit
* layout, preserving Not-a-Number (NaN) values.
*
*
Bit 31 (the bit that is selected by the mask
* {@code 0x80000000}) represents the sign of the floating-point
* number.
* Bits 30-23 (the bits that are selected by the mask
* {@code 0x7f800000}) represent the exponent.
* Bits 22-0 (the bits that are selected by the mask
* {@code 0x007fffff}) represent the significand (sometimes called
* the mantissa) of the floating-point number.
*
*
If the argument is positive infinity, the result is
* {@code 0x7f800000}.
*
*
If the argument is negative infinity, the result is
* {@code 0xff800000}.
*
*
If the argument is NaN, the result is the integer representing
* the actual NaN value. Unlike the {@code floatToIntBits}
* method, {@code floatToRawIntBits} does not collapse all the
* bit patterns encoding a NaN to a single "canonical"
* NaN value.
*
*
In all cases, the result is an integer that, when given to the
* {@link #intBitsToFloat(int)} method, will produce a
* floating-point value the same as the argument to
* {@code floatToRawIntBits}.
*
* @param value a floating-point number.
* @return the bits that represent the floating-point number.
* @since 1.3
*/
public static int floatToRawIntBits(float value){
//@TODO: implement this method internally in CBMC
return CProver.nondetInt();
}
/**
* Returns the {@code float} value corresponding to a given
* bit representation.
* The argument is considered to be a representation of a
* floating-point value according to the IEEE 754 floating-point
* "single format" bit layout.
*
*
If the argument is {@code 0x7f800000}, the result is positive
* infinity.
*
*
If the argument is {@code 0xff800000}, the result is negative
* infinity.
*
*
If the argument is any value in the range
* {@code 0x7f800001} through {@code 0x7fffffff} or in
* the range {@code 0xff800001} through
* {@code 0xffffffff}, the result is a NaN. No IEEE 754
* floating-point operation provided by Java can distinguish
* between two NaN values of the same type with different bit
* patterns. Distinct values of NaN are only distinguishable by
* use of the {@code Float.floatToRawIntBits} method.
*
*
In all other cases, let s, e, and m be three
* values that can be computed from the argument:
*
*
{@code
* int s = ((bits >> 31) == 0) ? 1 : -1;
* int e = ((bits >> 23) & 0xff);
* int m = (e == 0) ?
* (bits & 0x7fffff) << 1 :
* (bits & 0x7fffff) | 0x800000;
* }
*
* Then the floating-point result equals the value of the mathematical
* expression s·m·2e-150.
*
*
Note that this method may not be able to return a
* {@code float} NaN with exactly same bit pattern as the
* {@code int} argument. IEEE 754 distinguishes between two
* kinds of NaNs, quiet NaNs and signaling NaNs. The
* differences between the two kinds of NaN are generally not
* visible in Java. Arithmetic operations on signaling NaNs turn
* them into quiet NaNs with a different, but often similar, bit
* pattern. However, on some processors merely copying a
* signaling NaN also performs that conversion. In particular,
* copying a signaling NaN to return it to the calling method may
* perform this conversion. So {@code intBitsToFloat} may
* not be able to return a {@code float} with a signaling NaN
* bit pattern. Consequently, for some {@code int} values,
* {@code floatToRawIntBits(intBitsToFloat(start))} may
* not equal {@code start}. Moreover, which
* particular bit patterns represent signaling NaNs is platform
* dependent; although all NaN bit patterns, quiet or signaling,
* must be in the NaN range identified above.
*
* @param bits an integer.
* @return the {@code float} floating-point value with the same bit
* pattern.
*/
public static float intBitsToFloat(int bits){
//@TODO: implement this method internally in CBMC
return CProver.nondetFloat();
}
/**
* Compares two {@code Float} objects numerically. There are
* two ways in which comparisons performed by this method differ
* from those performed by the Java language numerical comparison
* operators ({@code <, <=, ==, >=, >}) when
* applied to primitive {@code float} values:
*
*
* {@code Float.NaN} is considered by this method to
* be equal to itself and greater than all other
* {@code float} values
* (including {@code Float.POSITIVE_INFINITY}).
*
* {@code 0.0f} is considered by this method to be greater
* than {@code -0.0f}.
*
*
* This ensures that the natural ordering of {@code Float}
* objects imposed by this method is consistent with equals.
*
* @param anotherFloat the {@code Float} to be compared.
* @return the value {@code 0} if {@code anotherFloat} is
* numerically equal to this {@code Float}; a value
* less than {@code 0} if this {@code Float}
* is numerically less than {@code anotherFloat};
* and a value greater than {@code 0} if this
* {@code Float} is numerically greater than
* {@code anotherFloat}.
*
* @since 1.2
* @see Comparable#compareTo(Object)
*/
public int compareTo(Float anotherFloat) {
return Float.compare(value, anotherFloat.value);
}
/**
* Compares the two specified {@code float} values. The sign
* of the integer value returned is the same as that of the
* integer that would be returned by the call:
*
* new Float(f1).compareTo(new Float(f2))
*
*
* @param f1 the first {@code float} to compare.
* @param f2 the second {@code float} to compare.
* @return the value {@code 0} if {@code f1} is
* numerically equal to {@code f2}; a value less than
* {@code 0} if {@code f1} is numerically less than
* {@code f2}; and a value greater than {@code 0}
* if {@code f1} is numerically greater than
* {@code f2}.
* @since 1.4
*/
public static int compare(float f1, float f2) {
if (f1 < f2)
return -1; // Neither val is NaN, thisVal is smaller
if (f1 > f2)
return 1; // Neither val is NaN, thisVal is larger
// Cannot use floatToRawIntBits because of possibility of NaNs.
int thisBits = Float.floatToIntBits(f1);
int anotherBits = Float.floatToIntBits(f2);
return (thisBits == anotherBits ? 0 : // Values are equal
(thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
1)); // (0.0, -0.0) or (NaN, !NaN)
}
/**
* Adds two {@code float} values together as per the + operator.
*
* @param a the first operand
* @param b the second operand
* @return the sum of {@code a} and {@code b}
* @jls 4.2.4 Floating-Point Operations
* @see java.util.function.BinaryOperator
* @since 1.8
*/
public static float sum(float a, float b) {
return a + b;
}
/**
* Returns the greater of two {@code float} values
* as if by calling {@link Math#max(float, float) 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 float max(float a, float b) {
float result = CProver.nondetFloat();
CProver.assume((result == a || result == b) && result >= a && result >= b);
return result;
}
/**
* Returns the smaller of two {@code float} values
* as if by calling {@link Math#min(float, float) 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 float min(float a, float b) {
float result = CProver.nondetFloat();
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 = -2671257302660747028L;
}
java-models-library-master/src/main/java/java/lang/IllegalAccessError.java 0000664 0000000 0000000 00000004716 14323475213 0027075 0 ustar 00root root 0000000 0000000 /*
* 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.
*
* 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 IllegalAccessError with no detail message.
*/
public IllegalAccessError() {
super();
}
/**
* Constructs an IllegalAccessError 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";
}
}
java-models-library-master/src/main/java/java/lang/IllegalAccessException.java 0000664 0000000 0000000 00000003632 14323475213 0027736 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/IllegalArgumentException.java 0000664 0000000 0000000 00000004132 14323475213 0030313 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/IllegalMonitorStateException.java 0000664 0000000 0000000 00000003654 14323475213 0031171 0 ustar 00root root 0000000 0000000 /*
* 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 IllegalMonitorStateException extends RuntimeException {
private static final long serialVersionUID = 3713306369498869069L;
public IllegalMonitorStateException() {
super();
}
public IllegalMonitorStateException(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.IllegalMonitorStateException: " + message)
: "java.lang.IllegalMonitorStateException";
}
}
java-models-library-master/src/main/java/java/lang/IllegalStateException.java 0000664 0000000 0000000 00000004075 14323475213 0027617 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/IllegalThreadStateException.java 0000664 0000000 0000000 00000003660 14323475213 0030746 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/IncompatibleClassChangeError.java 0000664 0000000 0000000 00000004660 14323475213 0031102 0 ustar 00root root 0000000 0000000 /*
* 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 IncompatibleClassChangeError with no
* detail message.
*/
public IncompatibleClassChangeError () {
super();
}
/**
* Constructs an IncompatibleClassChangeError 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";
}
}
java-models-library-master/src/main/java/java/lang/IndexOutOfBoundsException.java 0000664 0000000 0000000 00000003634 14323475213 0030444 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/InstantiationError.java 0000664 0000000 0000000 00000004733 14323475213 0027225 0 ustar 00root root 0000000 0000000 /*
* 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 new
* construct to instantiate an abstract class or an interface.
*
* 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 InstantiationError with no detail message.
*/
public InstantiationError() {
super();
}
/**
* Constructs an InstantiationError 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";
}
}
java-models-library-master/src/main/java/java/lang/InstantiationException.java 0000664 0000000 0000000 00000003633 14323475213 0030070 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/Integer.java 0000664 0000000 0000000 00000151116 14323475213 0024762 0 ustar 00root root 0000000 0000000 /*
* 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}.
*
*
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}.
*
*
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 Hacker's
* Delight, (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 {
/**
* A constant holding the minimum value an {@code int} can
* have, -231.
*/
public static final int MIN_VALUE = -2147483648;
/**
* A constant holding the maximum value an {@code int} can
* have, 231-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 TYPE = (Class) Class.getPrimitiveClass(4);
/**
* Returns a string representation of the first argument in the
* radix specified by the second argument.
*
*
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.
*
*
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.
*
*
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:
*
*
* {@code 0123456789abcdefghijklmnopqrstuvwxyz}
*
*
* These are {@code '\u005Cu0030'} through
* {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through
* {@code '\u005Cu007A'}. If {@code radix} is
* N, then the first N of these characters
* are used as radix-N 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:
*
*
* {@code Integer.toString(n, 16).toUpperCase()}
*
*
* @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.fullSupport
*/
public static String toString(int i, int radix) {
return CProverString.toString(i, radix);
}
/**
* Returns a string representation of the first argument as an
* unsigned integer value in the radix specified by the second
* argument.
*
*
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.
*
*
Note that since the first argument is treated as an unsigned
* value, no leading sign character is printed.
*
*
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 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.
*
*
The unsigned integer value is the argument plus 232
* 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.
*
*
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)}.
*
*
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:
*
*
* {@code 0123456789abcdef}
*
*
* 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:
*
*
* {@code Integer.toHexString(n).toUpperCase()}
*
*
* @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.
*
*
The unsigned integer value is the argument plus 232
* 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.
*
*
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)}.
*
*
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:
*
*
* {@code 01234567}
*
*
* 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.
*
*
The unsigned integer value is the argument plus 232
* 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.
*
*
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)}.
*
*
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.fullSupport
*/
public static String toString(int i) {
return CProverString.toString(i);
}
/**
* 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.
*
*
An exception of type {@code NumberFormatException} is
* thrown if any of the following situations occurs:
*
*
The first argument is {@code null} or is a string of
* length zero.
*
*
The radix is either smaller than
* {@link java.lang.Character#MIN_RADIX} or
* larger than {@link java.lang.Character#MAX_RADIX}.
*
*
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.
*
*
The value represented by the string is not a value of type
* {@code int}.
*
*
* @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(!CProverString.isValidInt(s, radix)) {
throw new NumberFormatException(s + " isn't a valid integer");
}
return CProverString.parseInt(s, radix);
}
/**
* 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 parseInt(s, 10);
}
/**
* 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.
*
*
An exception of type {@code NumberFormatException} is
* thrown if any of the following situations occurs:
*
*
The first argument is {@code null} or is a string of
* length zero.
*
*
The radix is either smaller than
* {@link java.lang.Character#MIN_RADIX} or
* larger than {@link java.lang.Character#MAX_RADIX}.
*
*
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.
*
*
The value represented by the string is larger than the
* largest unsigned {@code int}, 232-1.
*
*
*
*
* @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.
*
*
In other words, this method returns an {@code Integer}
* object equal to the value of:
*
*
* {@code new Integer(Integer.parseInt(s, radix))}
*
*
* @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.
*
*
In other words, this method returns an {@code Integer}
* object equal to the value of:
*
*
* {@code new Integer(Integer.parseInt(s))}
*
*
* @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.
*
*
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.
*
*
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.
*
*
In other words, this method returns an {@code Integer}
* object equal to the value of:
*
*
* {@code getInteger(nm, null)}
*
*
* @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.
*
*
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.
*
*
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}.
*
*
In other words, this method returns an {@code Integer} object
* equal to the value of:
*
*
* {@code getInteger(nm, new Integer(val))}
*
*
* but in practice it may be implemented in a manner such as:
*
*
* Integer result = getInteger(nm, null);
* return (result == null) ? new Integer(val) : result;
*
*
* 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:
*
*
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.
*
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.
*
Otherwise, the property value is parsed as a decimal integer
* exactly as by the method {@link #valueOf(java.lang.String, int)}
* with radix 10.
*
*
*
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:
*
*
*
*
DecodableString:
*
Signopt DecimalNumeral
*
Signopt {@code 0x} HexDigits
*
Signopt {@code 0X} HexDigits
*
Signopt {@code #} HexDigits
*
Signopt {@code 0} OctalDigits
*
*
Sign:
*
{@code -}
*
{@code +}
*
*
*
* DecimalNumeral, HexDigits, and OctalDigits
* are as defined in section 3.10.1 of
* The Java™ Language Specification,
* except that underscores are not accepted between digits.
*
*
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:
*
*
* @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 232.
*
* @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.
*
*
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.
*
*
Note that this method is closely related to the logarithm base 2.
* For all positive {@code int} values x:
*
*
* @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 population count.
*
* @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.)
*
*
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.)
*
*
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;
}
java-models-library-master/src/main/java/java/lang/InternalError.java 0000664 0000000 0000000 00000007106 14323475213 0026152 0 ustar 00root root 0000000 0000000 /*
* 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 to indicate some unexpected internal error has occurred in
* the Java Virtual Machine.
*
* @author unascribed
* @since JDK1.0
*/
public class InternalError extends VirtualMachineError {
private static final long serialVersionUID = -9062593416125562365L;
/**
* Constructs an InternalError with no detail message.
*/
public InternalError() {
super();
}
/**
* Constructs an InternalError with the specified
* detail message.
*
* @param message the detail message.
*/
public InternalError(String message) {
super(message);
}
/**
* Constructs an {@code InternalError} with the specified detail
* message and cause.
Note that the detail message associated
* with {@code cause} is not 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 InternalError(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructs an {@code InternalError} 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 InternalError(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.InternalError: " + message)
: "java.lang.InternalError";
}
}
java-models-library-master/src/main/java/java/lang/InterruptedException.java 0000664 0000000 0000000 00000003575 14323475213 0027556 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/LinkageError.java 0000664 0000000 0000000 00000005152 14323475213 0025747 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/Long.java 0000664 0000000 0000000 00000162661 14323475213 0024273 0 ustar 00root root 0000000 0000000 /*
* 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.lang.annotation.Native;
import java.math.*;
import org.cprover.CProver;
import org.cprover.CProverString;
/**
* The {@code Long} class wraps a value of the primitive type {@code
* long} in an object. An object of type {@code Long} contains a
* single field whose type is {@code long}.
*
*
In addition, this class provides several methods for converting
* a {@code long} to a {@code String} and a {@code String} to a {@code
* long}, as well as other constants and methods useful when dealing
* with a {@code long}.
*
*
Implementation note: The implementations of the "bit twiddling"
* methods (such as {@link #highestOneBit(long) highestOneBit} and
* {@link #numberOfTrailingZeros(long) numberOfTrailingZeros}) are
* based on material from Henry S. Warren, Jr.'s Hacker's
* Delight, (Addison Wesley, 2002).
*
* @author Lee Boynton
* @author Arthur van Hoff
* @author Josh Bloch
* @author Joseph D. Darcy
* @since JDK1.0
*/
public final class Long extends Number implements Comparable {
/**
* A constant holding the minimum value a {@code long} can
* have, -263.
*/
@Native public static final long MIN_VALUE = 0x8000000000000000L;
/**
* A constant holding the maximum value a {@code long} can
* have, 263-1.
*/
@Native public static final long MAX_VALUE = 0x7fffffffffffffffL;
/**
* The {@code Class} instance representing the primitive type
* {@code long}.
*
* @since JDK1.1
*/
/*
* MODELS-LIBRARY {
* We use the int version of getPrimitiveClass instead of
* the original String version
* }
*/
@SuppressWarnings("unchecked")
public static final Class TYPE = (Class) Class.getPrimitiveClass(5);
/**
* Returns a string representation of the first argument in the
* radix specified by the second argument.
*
*
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.
*
*
If the first argument is negative, the first element of the
* result is the ASCII minus sign {@code '-'}
* ({@code '\u005Cu002d'}). If the first argument is not
* negative, no sign character appears in the result.
*
*
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:
*
*
* {@code 0123456789abcdefghijklmnopqrstuvwxyz}
*
*
* These are {@code '\u005Cu0030'} through
* {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through
* {@code '\u005Cu007a'}. If {@code radix} is
* N, then the first N of these characters
* are used as radix-N 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:
*
*
* {@code Long.toString(n, 16).toUpperCase()}
*
*
* @param i a {@code long} 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.fullSupport
*/
public static String toString(long i, int radix) {
return CProverString.toString(i, radix);
}
/**
* Returns a string representation of the first argument as an
* unsigned integer value in the radix specified by the second
* argument.
*
*
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.
*
*
Note that since the first argument is treated as an unsigned
* value, no leading sign character is printed.
*
*
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 behavior of radixes and the characters used as digits
* are the same as {@link #toString(long, 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(long, int)
* @since 1.8
*/
public static String toUnsignedString(long i, int radix) {
if (i >= 0)
return toString(i, radix);
else {
switch (radix) {
case 2:
return toBinaryString(i);
case 4:
return toUnsignedString0(i, 2);
case 8:
return toOctalString(i);
case 10:
/*
* We can get the effect of an unsigned division by 10
* on a long value by first shifting right, yielding a
* positive value, and then dividing by 5. This
* allows the last digit and preceding digits to be
* isolated more quickly than by an initial conversion
* to BigInteger.
*/
long quot = (i >>> 1) / 5;
long rem = i - quot * 10;
return toString(quot) + rem;
case 16:
return toHexString(i);
case 32:
return toUnsignedString0(i, 5);
default:
return toUnsignedBigInteger(i).toString(radix);
}
}
}
/**
* Return a BigInteger equal to the unsigned value of the
* argument.
*/
private static BigInteger toUnsignedBigInteger(long i) {
if (i >= 0L)
return BigInteger.valueOf(i);
else {
int upper = (int) (i >>> 32);
int lower = (int) i;
// return (upper << 32) + lower
return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).
add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));
}
}
/**
* Returns a string representation of the {@code long}
* argument as an unsigned integer in base 16.
*
*
The unsigned {@code long} value is the argument plus
* 264 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.
*
*
The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Long#parseUnsignedLong(String, int) Long.parseUnsignedLong(s,
* 16)}.
*
*
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:
*
*
* {@code 0123456789abcdef}
*
*
* 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:
*
*
* {@code Long.toHexString(n).toUpperCase()}
*
*
* @param i a {@code long} to be converted to a string.
* @return the string representation of the unsigned {@code long}
* value represented by the argument in hexadecimal
* (base 16).
* @see #parseUnsignedLong(String, int)
* @see #toUnsignedString(long, int)
* @since JDK 1.0.2
*/
public static String toHexString(long i) {
return toUnsignedString0(i, 4);
}
/**
* Returns a string representation of the {@code long}
* argument as an unsigned integer in base 8.
*
*
The unsigned {@code long} value is the argument plus
* 264 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.
*
*
The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Long#parseUnsignedLong(String, int) Long.parseUnsignedLong(s,
* 8)}.
*
*
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:
*
*
* {@code 01234567}
*
*
* These are the characters {@code '\u005Cu0030'} through
* {@code '\u005Cu0037'}.
*
* @param i a {@code long} to be converted to a string.
* @return the string representation of the unsigned {@code long}
* value represented by the argument in octal (base 8).
* @see #parseUnsignedLong(String, int)
* @see #toUnsignedString(long, int)
* @since JDK 1.0.2
*/
public static String toOctalString(long i) {
return toUnsignedString0(i, 3);
}
/**
* Returns a string representation of the {@code long}
* argument as an unsigned integer in base 2.
*
*
The unsigned {@code long} value is the argument plus
* 264 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.
*
*
The value of the argument can be recovered from the returned
* string {@code s} by calling {@link
* Long#parseUnsignedLong(String, int) Long.parseUnsignedLong(s,
* 2)}.
*
*
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 a {@code long} to be converted to a string.
* @return the string representation of the unsigned {@code long}
* value represented by the argument in binary (base 2).
* @see #parseUnsignedLong(String, int)
* @see #toUnsignedString(long, int)
* @since JDK 1.0.2
*/
public static String toBinaryString(long i) {
return toUnsignedString0(i, 1);
}
/**
* Format a long (treated as unsigned) into a String.
* @param val the value to format
* @param shift the log2 of the base to format in (4 for hex, 3 for octal, 1 for binary)
*/
// DIFFBLUE MODEL LIBRARY: Handled internally by CBMC
static String toUnsignedString0(long val, int shift) {
CProver.assume(0 <= val && val <= Integer.MAX_VALUE);
return Integer.toString((int)val, 1 << shift);
}
/**
* Returns a {@code String} object representing the specified
* {@code long}. The argument is converted to signed decimal
* representation and returned as a string, exactly as if the
* argument and the radix 10 were given as arguments to the {@link
* #toString(long, int)} method.
*
* @param i a {@code long} to be converted.
* @return a string representation of the argument in base 10.
*
* @diffblue.fullSupport
*/
public static String toString(long i) {
return CProverString.toString(i);
}
/**
* 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(long,
* int)} method.
*
* @param i an integer to be converted to an unsigned string.
* @return an unsigned string representation of the argument.
* @see #toUnsignedString(long, int)
* @since 1.8
*/
public static String toUnsignedString(long i) {
return toUnsignedString(i, 10);
}
/**
* Places characters representing the integer i into the
* character array buf. The characters are placed into
* the buffer backwards starting with the least significant
* digit at the specified index (exclusive), and working
* backwards from there.
*
* Will fail if i == Long.MIN_VALUE
*/
// Requires positive x
static int stringSize(long x) {
long p = 10;
for (int i=1; i<19; i++) {
if (x < p)
return i;
p = 10*p;
}
return 19;
}
/**
* Parses the string argument as a signed {@code long} 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 {@code long} value is returned.
*
*
Note that neither the character {@code L}
* ({@code '\u005Cu004C'}) nor {@code l}
* ({@code '\u005Cu006C'}) is permitted to appear at the end
* of the string as a type indicator, as would be permitted in
* Java programming language source code - except that either
* {@code L} or {@code l} may appear as a digit for a
* radix greater than or equal to 22.
*
*
An exception of type {@code NumberFormatException} is
* thrown if any of the following situations occurs:
*
*
*
The first argument is {@code null} or is a string of
* length zero.
*
*
The {@code radix} is either smaller than {@link
* java.lang.Character#MIN_RADIX} or larger than {@link
* java.lang.Character#MAX_RADIX}.
*
*
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.
*
*
The value represented by the string is not a value of type
* {@code long}.
*
*
* @param s the {@code String} containing the
* {@code long} representation to be parsed.
* @param radix the radix to be used while parsing {@code s}.
* @return the {@code long} represented by the string argument in
* the specified radix.
* @throws NumberFormatException if the string does not contain a
* parsable {@code long}.
*/
public static long parseLong(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 (!CProverString.isValidLong(s, radix)) {
throw new NumberFormatException(s + " isn't a valid long");
}
return CProverString.parseLong(s, radix);
}
/**
* Parses the string argument as a signed decimal {@code long}.
* 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 {@code long} value is
* returned, exactly as if the argument and the radix {@code 10}
* were given as arguments to the {@link
* #parseLong(java.lang.String, int)} method.
*
*
Note that neither the character {@code L}
* ({@code '\u005Cu004C'}) nor {@code l}
* ({@code '\u005Cu006C'}) is permitted to appear at the end
* of the string as a type indicator, as would be permitted in
* Java programming language source code.
*
* @param s a {@code String} containing the {@code long}
* representation to be parsed
* @return the {@code long} represented by the argument in
* decimal.
* @throws NumberFormatException if the string does not contain a
* parsable {@code long}.
*/
public static long parseLong(String s) throws NumberFormatException {
return parseLong(s, 10);
}
/**
* Parses the string argument as an unsigned {@code long} 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.
*
*
An exception of type {@code NumberFormatException} is
* thrown if any of the following situations occurs:
*
*
The first argument is {@code null} or is a string of
* length zero.
*
*
The radix is either smaller than
* {@link java.lang.Character#MIN_RADIX} or
* larger than {@link java.lang.Character#MAX_RADIX}.
*
*
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.
*
*
The value represented by the string is larger than the
* largest unsigned {@code long}, 264-1.
*
*
*
*
* @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 unsigned {@code long} represented by the string
* argument in the specified radix.
* @throws NumberFormatException if the {@code String}
* does not contain a parsable {@code long}.
* @since 1.8
*/
public static long parseUnsignedLong(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 <= 12 || // Long.MAX_VALUE in Character.MAX_RADIX is 13 digits
(radix == 10 && len <= 18) ) { // Long.MAX_VALUE in base 10 is 19 digits
return parseLong(s, radix);
}
// No need for range checks on len due to testing above.
long first = parseLong(CProverString.substring(s, 0, len - 1), radix);
int second = Character.digit(CProverString.charAt(s, len - 1), radix);
if (second < 0) {
throw new NumberFormatException("Bad digit at end of " + s);
}
long result = first * radix + second;
if (compareUnsigned(result, first) < 0) {
/*
* The maximum unsigned value, (2^64)-1, takes at
* most one more digit to represent than the
* maximum signed value, (2^63)-1. Therefore,
* parsing (len - 1) digits will be appropriately
* in-range of the signed parsing. In other
* words, if parsing (len -1) digits overflows
* signed parsing, parsing len digits will
* certainly overflow unsigned parsing.
*
* The compareUnsigned check above catches
* situations where an unsigned overflow occurs
* incorporating the contribution of the final
* digit.
*/
throw new NumberFormatException(String.format("String value %s exceeds " +
"range of unsigned long.", s));
}
return result;
}
} else {
throw NumberFormatException.forInputString(s);
}
}
/**
* Parses the string argument as an unsigned decimal {@code long}. 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
* #parseUnsignedLong(java.lang.String, int)} method.
*
* @param s a {@code String} containing the unsigned {@code long}
* representation to be parsed
* @return the unsigned {@code long} value represented by the decimal string argument
* @throws NumberFormatException if the string does not contain a
* parsable unsigned integer.
* @since 1.8
*/
public static long parseUnsignedLong(String s) throws NumberFormatException {
return parseUnsignedLong(s, 10);
}
/**
* Returns a {@code Long} 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
* {@code long} in the radix specified by the second
* argument, exactly as if the arguments were given to the {@link
* #parseLong(java.lang.String, int)} method. The result is a
* {@code Long} object that represents the {@code long}
* value specified by the string.
*
*
In other words, this method returns a {@code Long} object equal
* to the value of:
*
*
* {@code new Long(Long.parseLong(s, radix))}
*
*
* @param s the string to be parsed
* @param radix the radix to be used in interpreting {@code s}
* @return a {@code Long} object holding the value
* represented by the string argument in the specified
* radix.
* @throws NumberFormatException If the {@code String} does not
* contain a parsable {@code long}.
*/
public static Long valueOf(String s, int radix) throws NumberFormatException {
return Long.valueOf(parseLong(s, radix));
}
/**
* Returns a {@code Long} object holding the value
* of the specified {@code String}. The argument is
* interpreted as representing a signed decimal {@code long},
* exactly as if the argument were given to the {@link
* #parseLong(java.lang.String)} method. The result is a
* {@code Long} object that represents the integer value
* specified by the string.
*
*
In other words, this method returns a {@code Long} object
* equal to the value of:
*
*
* {@code new Long(Long.parseLong(s))}
*
*
* @param s the string to be parsed.
* @return a {@code Long} object holding the value
* represented by the string argument.
* @throws NumberFormatException If the string cannot be parsed
* as a {@code long}.
*/
public static Long valueOf(String s) throws NumberFormatException
{
return Long.valueOf(parseLong(s, 10));
}
private static class LongCache {
private LongCache(){}
static final Long cache[] = new Long[-(-128) + 127 + 1];
static {
for(int i = 0; i < cache.length; i++)
cache[i] = new Long(i - 128);
}
}
/**
* Returns a {@code Long} instance representing the specified
* {@code long} value.
* If a new {@code Long} instance is not required, this method
* should generally be used in preference to the constructor
* {@link #Long(long)}, as this method is likely to yield
* significantly better space and time performance by caching
* frequently requested values.
*
* Note that unlike the {@linkplain Integer#valueOf(int)
* corresponding method} in the {@code Integer} class, this method
* is not required to cache values within a particular
* range.
*
* @param l a long value.
* @return a {@code Long} instance representing {@code l}.
* @since 1.5
*/
public static Long valueOf(long l) {
return new Long(l);
}
/**
* Decodes a {@code String} into a {@code Long}.
* Accepts decimal, hexadecimal, and octal numbers given by the
* following grammar:
*
*
*
*
DecodableString:
*
Signopt DecimalNumeral
*
Signopt {@code 0x} HexDigits
*
Signopt {@code 0X} HexDigits
*
Signopt {@code #} HexDigits
*
Signopt {@code 0} OctalDigits
*
*
Sign:
*
{@code -}
*
{@code +}
*
*
*
* DecimalNumeral, HexDigits, and OctalDigits
* are as defined in section 3.10.1 of
* The Java™ Language Specification,
* except that underscores are not accepted between digits.
*
*
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
* Long.parseLong} 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 a {@code Long} object holding the {@code long}
* value represented by {@code nm}
* @throws NumberFormatException if the {@code String} does not
* contain a parsable {@code long}.
* @see java.lang.Long#parseLong(String, int)
* @since 1.2
*/
public static Long decode(String nm) throws NumberFormatException {
int radix = 10;
int index = 0;
boolean negative = false;
Long result;
if (nm.length() == 0)
throw new NumberFormatException("Zero length string");
char firstChar = CProverString.charAt(nm, 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 sub index only once
String nm_sub_index = CProverString.substring(nm, index);
try {
// DIFFBLUE MODEL LIBRARY
// result = Long.valueOf(nm.substring(index), radix);
result = Long.valueOf(nm_sub_index, radix);
result = negative ? Long.valueOf(-result.longValue()) : result;
} catch (NumberFormatException e) {
// If number is Long.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_sub_index)
// : nm.substring(index);
String constant = negative ? ("-" + nm_sub_index)
: nm_sub_index;
result = Long.valueOf(constant, radix);
}
return result;
}
/**
* The value of the {@code Long}.
*
* @serial
*/
private final long value;
/**
* Constructs a newly allocated {@code Long} object that
* represents the specified {@code long} argument.
*
* @param value the value to be represented by the
* {@code Long} object.
*/
public Long(long value) {
this.value = value;
}
/**
* Constructs a newly allocated {@code Long} object that
* represents the {@code long} value indicated by the
* {@code String} parameter. The string is converted to a
* {@code long} value in exactly the manner used by the
* {@code parseLong} method for radix 10.
*
* @param s the {@code String} to be converted to a
* {@code Long}.
* @throws NumberFormatException if the {@code String} does not
* contain a parsable {@code long}.
* @see java.lang.Long#parseLong(java.lang.String, int)
*/
public Long(String s) throws NumberFormatException {
this.value = parseLong(s, 10);
}
/**
* Returns the value of this {@code Long} 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 Long} 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 Long} as an {@code int} after
* a narrowing primitive conversion.
* @jls 5.1.3 Narrowing Primitive Conversions
*/
public int intValue() {
return (int)value;
}
/**
* Returns the value of this {@code Long} as a
* {@code long} value.
*/
public long longValue() {
return value;
}
/**
* Returns the value of this {@code Long} 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 Long} 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 Long}'s value. The value is converted to signed
* decimal representation and returned as a string, exactly as if
* the {@code long} value were given as an argument to the
* {@link java.lang.Long#toString(long)} 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 Long}. The result is
* the exclusive OR of the two halves of the primitive
* {@code long} value held by this {@code Long}
* object. That is, the hashcode is the value of the expression:
*
*
*
* @return a hash code value for this object.
*/
@Override
public int hashCode() {
return Long.hashCode(value);
}
/**
* Returns a hash code for a {@code long} value; compatible with
* {@code Long.hashCode()}.
*
* @param value the value to hash
* @return a hash code value for a {@code long} value.
* @since 1.8
*/
public static int hashCode(long value) {
return (int)(value ^ (value >>> 32));
}
/**
* Compares this object to the specified object. The result is
* {@code true} if and only if the argument is not
* {@code null} and is a {@code Long} object that
* contains the same {@code long} 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 Long) {
return value == ((Long)obj).longValue();
}
return false;
}
/**
* Determines the {@code long} 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 a {@code
* long} value using the grammar supported by {@link Long#decode decode}
* and a {@code Long} object representing this value is returned.
*
*
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.
*
*
In other words, this method returns a {@code Long} object
* equal to the value of:
*
*
* {@code getLong(nm, null)}
*
*
* @param nm property name.
* @return the {@code Long} 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 Long getLong(String nm) {
return getLong(nm, null);
}
/**
* Determines the {@code long} 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 a {@code
* long} value using the grammar supported by {@link Long#decode decode}
* and a {@code Long} object representing this value is returned.
*
*
The second argument is the default value. A {@code Long} 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 null.
*
*
In other words, this method returns a {@code Long} object equal
* to the value of:
*
*
* {@code getLong(nm, new Long(val))}
*
*
* but in practice it may be implemented in a manner such as:
*
*
* Long result = getLong(nm, null);
* return (result == null) ? new Long(val) : result;
*
*
* to avoid the unnecessary allocation of a {@code Long} object when
* the default value is not needed.
*
* @param nm property name.
* @param val default value.
* @return the {@code Long} 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 Long getLong(String nm, long val) {
Long result = Long.getLong(nm, null);
return (result == null) ? Long.valueOf(val) : result;
}
/**
* Returns the {@code long} 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 a {@code long} value, as per the
* {@link Long#decode decode} method, and a {@code Long} object
* representing this value is returned; in summary:
*
*
*
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 for the method {@link #valueOf(java.lang.String, int)}
* with radix 16.
*
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.
*
Otherwise the property value is parsed as a decimal
* integer exactly as by the method
* {@link #valueOf(java.lang.String, int)} with radix 10.
*
*
*
Note that, in every case, neither {@code L}
* ({@code '\u005Cu004C'}) nor {@code l}
* ({@code '\u005Cu006C'}) is permitted to appear at the end
* of the property value as a type indicator, as would be
* permitted in Java programming language source code.
*
*
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 Long} 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 Long getLong(String nm, Long val) {
String v = null;
try {
v = System.getProperty(nm);
} catch (IllegalArgumentException | NullPointerException e) {
}
if (v != null) {
try {
return Long.decode(v);
} catch (NumberFormatException e) {
}
}
return val;
}
/**
* Compares two {@code Long} objects numerically.
*
* @param anotherLong the {@code Long} to be compared.
* @return the value {@code 0} if this {@code Long} is
* equal to the argument {@code Long}; a value less than
* {@code 0} if this {@code Long} is numerically less
* than the argument {@code Long}; and a value greater
* than {@code 0} if this {@code Long} is numerically
* greater than the argument {@code Long} (signed
* comparison).
* @since 1.2
*/
public int compareTo(Long anotherLong) {
return compare(this.value, anotherLong.value);
}
/**
* Compares two {@code long} values numerically.
* The value returned is identical to what would be returned by:
*
* Long.valueOf(x).compareTo(Long.valueOf(y))
*
*
* @param x the first {@code long} to compare
* @param y the second {@code long} 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(long x, long y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
/**
* Compares two {@code long} values numerically treating the values
* as unsigned.
*
* @param x the first {@code long} to compare
* @param y the second {@code long} 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(long x, long y) {
return compare(x + MIN_VALUE, y + MIN_VALUE);
}
/**
* Returns the unsigned quotient of dividing the first argument by
* the second where each argument and the result is interpreted as
* an unsigned value.
*
*
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
*/
public static long divideUnsigned(long dividend, long divisor) {
if (divisor < 0L) { // signed comparison
// Answer must be 0 or 1 depending on relative magnitude
// of dividend and divisor.
return (compareUnsigned(dividend, divisor)) < 0 ? 0L :1L;
}
if (dividend > 0) // Both inputs non-negative
return dividend/divisor;
else {
/*
* For simple code, leveraging BigInteger. Longer and faster
* code written directly in terms of operations on longs is
* possible; see "Hacker's Delight" for divide and remainder
* algorithms.
*/
return toUnsignedBigInteger(dividend).
divide(toUnsignedBigInteger(divisor)).longValue();
}
}
/**
* 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
*/
public static long remainderUnsigned(long dividend, long divisor) {
if (dividend > 0 && divisor > 0) { // signed comparisons
return dividend % divisor;
} else {
if (compareUnsigned(dividend, divisor) < 0) // Avoid explicit check for 0 divisor
return dividend;
else
return toUnsignedBigInteger(dividend).
remainder(toUnsignedBigInteger(divisor)).longValue();
}
}
// Bit Twiddling
/**
* The number of bits used to represent a {@code long} value in two's
* complement binary form.
*
* @since 1.5
*/
@Native public static final int SIZE = 64;
/**
* The number of bytes used to represent a {@code long} value in two's
* complement binary form.
*
* @since 1.8
*/
public static final int BYTES = SIZE / Byte.SIZE;
/**
* Returns a {@code long} value with at most a single one-bit, in the
* position of the highest-order ("leftmost") one-bit in the specified
* {@code long} 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 a {@code long} 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
*/
public static long highestOneBit(long i) {
// HD, Figure 3-1
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
i |= (i >> 32);
return i - (i >>> 1);
}
/**
* Returns a {@code long} value with at most a single one-bit, in the
* position of the lowest-order ("rightmost") one-bit in the specified
* {@code long} 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 a {@code long} 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
*/
public static long lowestOneBit(long i) {
// HD, Section 2-1
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 long} value. Returns 64 if the
* specified value has no one-bits in its two's complement representation,
* in other words if it is equal to zero.
*
*
Note that this method is closely related to the logarithm base 2.
* For all positive {@code long} values x:
*
*
* @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 long} value, or 64 if the value
* is equal to zero.
* @since 1.5
*/
public static int numberOfLeadingZeros(long i) {
// HD, Figure 5-6
if (i == 0)
return 64;
int n = 1;
int x = (int)(i >>> 32);
if (x == 0) { n += 32; x = (int)i; }
if (x >>> 16 == 0) { n += 16; x <<= 16; }
if (x >>> 24 == 0) { n += 8; x <<= 8; }
if (x >>> 28 == 0) { n += 4; x <<= 4; }
if (x >>> 30 == 0) { n += 2; x <<= 2; }
n -= x >>> 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 long} value. Returns 64 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 long} value, or 64 if the value is equal
* to zero.
* @since 1.5
*/
public static int numberOfTrailingZeros(long i) {
// HD, Figure 5-14
int x, y;
if (i == 0) return 64;
int n = 63;
y = (int)i; if (y != 0) { n = n -32; x = y; } else x = (int)(i>>>32);
y = x <<16; if (y != 0) { n = n -16; x = y; }
y = x << 8; if (y != 0) { n = n - 8; x = y; }
y = x << 4; if (y != 0) { n = n - 4; x = y; }
y = x << 2; if (y != 0) { n = n - 2; x = y; }
return n - ((x << 1) >>> 31);
}
/**
* Returns the number of one-bits in the two's complement binary
* representation of the specified {@code long} value. This function is
* sometimes referred to as the population count.
*
* @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 long} value.
* @since 1.5
*/
public static int bitCount(long i) {
// HD, Figure 5-14
i = i - ((i >>> 1) & 0x5555555555555555L);
i = (i & 0x3333333333333333L) + ((i >>> 2) & 0x3333333333333333L);
i = (i + (i >>> 4)) & 0x0f0f0f0f0f0f0f0fL;
i = i + (i >>> 8);
i = i + (i >>> 16);
i = i + (i >>> 32);
return (int)i & 0x7f;
}
/**
* Returns the value obtained by rotating the two's complement binary
* representation of the specified {@code long} 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.)
*
*
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 64 is a
* no-op, so all but the last six bits of the rotation distance can be
* ignored, even if the distance is negative: {@code rotateLeft(val,
* distance) == rotateLeft(val, distance & 0x3F)}.
*
* @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 long} value left by the
* specified number of bits.
* @since 1.5
*/
public static long rotateLeft(long i, int distance) {
return (i << distance) | (i >>> -distance);
}
/**
* Returns the value obtained by rotating the two's complement binary
* representation of the specified {@code long} 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.)
*
*
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 64 is a
* no-op, so all but the last six bits of the rotation distance can be
* ignored, even if the distance is negative: {@code rotateRight(val,
* distance) == rotateRight(val, distance & 0x3F)}.
*
* @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 long} value right by the
* specified number of bits.
* @since 1.5
*/
public static long rotateRight(long 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 long}
* value.
*
* @param i the value to be reversed
* @return the value obtained by reversing order of the bits in the
* specified {@code long} value.
* @since 1.5
*/
public static long reverse(long i) {
// HD, Figure 7-1
i = (i & 0x5555555555555555L) << 1 | (i >>> 1) & 0x5555555555555555L;
i = (i & 0x3333333333333333L) << 2 | (i >>> 2) & 0x3333333333333333L;
i = (i & 0x0f0f0f0f0f0f0f0fL) << 4 | (i >>> 4) & 0x0f0f0f0f0f0f0f0fL;
i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
i = (i << 48) | ((i & 0xffff0000L) << 16) |
((i >>> 16) & 0xffff0000L) | (i >>> 48);
return i;
}
/**
* Returns the signum function of the specified {@code long} 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 long} value.
* @since 1.5
*/
public static int signum(long i) {
// HD, Section 2-7
return (int) ((i >> 63) | (-i >>> 63));
}
/**
* Returns the value obtained by reversing the order of the bytes in the
* two's complement representation of the specified {@code long} value.
*
* @param i the value whose bytes are to be reversed
* @return the value obtained by reversing the bytes in the specified
* {@code long} value.
* @since 1.5
*/
public static long reverseBytes(long i) {
i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
return (i << 48) | ((i & 0xffff0000L) << 16) |
((i >>> 16) & 0xffff0000L) | (i >>> 48);
}
/**
* Adds two {@code long} values 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 long sum(long a, long b) {
return a + b;
}
/**
* Returns the greater of two {@code long} values
* as if by calling {@link Math#max(long, long) 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 long max(long a, long b) {
long result = CProver.nondetLong();
CProver.assume((result == a || result == b) && result >= a && result >= b);
return result;
}
/**
* Returns the smaller of two {@code long} values
* as if by calling {@link Math#min(long, long) 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 long min(long a, long b) {
long result = CProver.nondetLong();
CProver.assume((result == a || result == b) && result <= a && result <= b);
return result;
}
/** use serialVersionUID from JDK 1.0.2 for interoperability */
@Native private static final long serialVersionUID = 4290774380558885855L;
}
java-models-library-master/src/main/java/java/lang/Math.java 0000664 0000000 0000000 00000311225 14323475213 0024255 0 ustar 00root root 0000000 0000000 /*
* 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.
*
*
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.
*
*
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}.
*
*
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 ulps, 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 correctly
* rounded. 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
* semi-monotonic: 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.
*
*
* 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
* e, the base of the natural logarithms.
*/
public static final double E = 2.7182818284590452354;
/**
* The {@code double} value that is closer than any other to
* pi, 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:
*
If the argument is NaN or an infinity, then the
* result is NaN.
*
If the argument is zero, then the result is a zero with the
* same sign as the argument.
*
*
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:
*
If the argument is NaN or an infinity, then the
* result is NaN.
*
*
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:
*
If the argument is NaN or an infinity, then the result
* is NaN.
*
If the argument is zero, then the result is a zero with the
* same sign as the argument.
*
*
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 -pi/2 through pi/2. Special cases:
*
If the argument is NaN or its absolute value is greater
* than 1, then the result is NaN.
*
If the argument is zero, then the result is a zero with the
* same sign as the argument.
*
*
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 pi. Special case:
*
If the argument is NaN or its absolute value is greater
* than 1, then the result is NaN.
*
*
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 -pi/2 through pi/2. Special cases:
*
If the argument is NaN, then the result is NaN.
*
If the argument is zero, then the result is a zero with the
* same sign as the argument.
*
*
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
*
* @diffblue.fullSupport
*/
public static double toRadians(double angdeg) {
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
* not 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 e raised to the power of a
* {@code double} value. Special cases:
*
If the argument is NaN, the result is NaN.
*
If the argument is positive infinity, then the result is
* positive infinity.
*
If the argument is negative infinity, then the result is
* positive zero.
*
*
The computed result must be within 1 ulp of the exact result.
* Results must be semi-monotonic.
*
* @param a the exponent to raise e to.
* @return the value e{@code a},
* where e 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 e) of a {@code double}
* value. Special cases:
*
If the argument is NaN or less than zero, then the result
* is NaN.
*
If the argument is positive infinity, then the result is
* positive infinity.
*
If the argument is positive zero or negative zero, then the
* result is negative infinity.
*
*
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:
*
*
If the argument is NaN or less than zero, then the result
* is NaN.
*
If the argument is positive infinity, then the result is
* positive infinity.
*
If the argument is positive zero or negative zero, then the
* result is negative infinity.
*
If the argument is equal to 10n for
* integer n, then the result is n.
*
*
*
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:
*
If the argument is NaN or less than zero, then the result
* is NaN.
*
If the argument is positive infinity, then the result is positive
* infinity.
*
If the argument is positive zero or negative zero, then the
* result is the same as the argument.
* 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.
*
* @diffblue.limitedSupport
* This implementation using solver constraints only works if squaring the
* result of sqrt is equal to the original number, which is not always
* true. As a result, the solver will return UNSAT in many cases.
* For instance, {@code Math.sqrt(2.0)} will cause the solver to be UNSAT.
* Reported in: TG-5598
*
* Also, there are precision issues on very small numbers. For instance,
* for values between 0 and {@code 0x0.0000000000001p-900}, the sqrt method
* is likely to not be equal to the result of the real Math.sqrt method.
* Reported in: TG-5602
*/
public static double sqrt(double a) {
// 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.
if (Double.isNaN(a) || a < 0.0) {
return Double.NaN;
}
if (a == Double.POSITIVE_INFINITY || a == 0.0) {
return a;
}
double sqrt = CProver.nondetDouble();
CProver.assume(sqrt >= 0);
CProver.assume(sqrt * sqrt == a);
// To solve the satisfiability issue, we should adapt the constraints
// to something like:
//
// double reMultiplied = sqrt * sqrt;
// CProver.assume(reMultiplied > lower);
// CProver.assume(reMultiplied <= upper);
//
// Where lower and upper only differ by one bit in their
// representation, which should ensure that they are the double values
// that are the closest to reMultiplied.
// This implementation cannot be done yet because it would require
// Double.doubleToRawLongBits() to be supported.
return sqrt;
}
/**
* 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:
*
*
*
*
If the argument is NaN, then the result is NaN.
*
*
If the argument is infinite, then the result is an infinity
* with the same sign as the argument.
*
*
If the argument is zero, then the result is a zero with the
* same sign as the argument.
*
*
*
*
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
* f1 - f2 × n,
* where n 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 n 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:
*
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.
*
If the first argument is finite and the second argument is
* infinite, then the result is the same as the first argument.
*
* @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:
*
If the argument value is already equal to a
* mathematical integer, then the result is the same as the
* argument.
If the argument is NaN or an infinity or
* positive zero or negative zero, then the result is the same as
* the argument.
If the argument value is less than zero but
* greater than -1.0, then the result is negative zero.
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:
*
If the argument value is already equal to a
* mathematical integer, then the result is the same as the
* argument.
If the argument is NaN or an infinity or
* positive zero or negative zero, then the result is the same as
* the argument.
*
* @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:
*
If the argument value is already equal to a mathematical
* integer, then the result is the same as the argument.
*
If the argument is NaN or an infinity or positive zero or negative
* zero, then the result is the same as the argument.
*
* @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 theta from the conversion of rectangular
* coordinates ({@code x}, {@code y}) to polar
* coordinates (r, theta).
* This method computes the phase theta by computing an arc tangent
* of {@code y/x} in the range of -pi to pi. Special
* cases:
*
If either argument is NaN, then the result is NaN.
*
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.
*
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.
*
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 pi.
*
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 -pi.
*
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 pi/2.
*
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 -pi/2.
*
If both arguments are positive infinity, then the result is the
* {@code double} value closest to pi/4.
*
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*pi/4.
*
If the first argument is negative infinity and the second argument
* is positive infinity, then the result is the {@code double} value
* closest to -pi/4.
*
If both arguments are negative infinity, then the result is the
* {@code double} value closest to -3*pi/4.
*
*
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 theta component of the point
* (r, theta)
* in polar coordinates that corresponds to the point
* (x, y) 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:
*
*
If the second argument is positive or negative zero, then the
* result is 1.0.
*
If the second argument is 1.0, then the result is the same as the
* first argument.
*
If the second argument is NaN, then the result is NaN.
*
If the first argument is NaN and the second argument is nonzero,
* then the result is NaN.
*
*
If
*
*
the absolute value of the first argument is greater than 1
* and the second argument is positive infinity, or
*
the absolute value of the first argument is less than 1 and
* the second argument is negative infinity,
*
* then the result is positive infinity.
*
*
If
*
*
the absolute value of the first argument is greater than 1 and
* the second argument is negative infinity, or
*
the absolute value of the
* first argument is less than 1 and the second argument is positive
* infinity,
*
* then the result is positive zero.
*
*
If the absolute value of the first argument equals 1 and the
* second argument is infinite, then the result is NaN.
*
*
If
*
*
the first argument is positive zero and the second argument
* is greater than zero, or
*
the first argument is positive infinity and the second
* argument is less than zero,
*
* then the result is positive zero.
*
*
If
*
*
the first argument is positive zero and the second argument
* is less than zero, or
*
the first argument is positive infinity and the second
* argument is greater than zero,
*
* then the result is positive infinity.
*
*
If
*
*
the first argument is negative zero and the second argument
* is greater than zero but not a finite odd integer, or
*
the first argument is negative infinity and the second
* argument is less than zero but not a finite odd integer,
*
* then the result is positive zero.
*
*
If
*
*
the first argument is negative zero and the second argument
* is a positive finite odd integer, or
*
the first argument is negative infinity and the second
* argument is a negative finite odd integer,
*
* then the result is negative zero.
*
*
If
*
*
the first argument is negative zero and the second argument
* is less than zero but not a finite odd integer, or
*
the first argument is negative infinity and the second
* argument is greater than zero but not a finite odd integer,
*
* then the result is positive infinity.
*
*
If
*
*
the first argument is negative zero and the second argument
* is a negative finite odd integer, or
*
the first argument is negative infinity and the second
* argument is a positive finite odd integer,
*
* then the result is negative infinity.
*
*
If the first argument is finite and less than zero
*
*
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
*
*
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
*
*
if the second argument is finite and not an integer, then
* the result is NaN.
*
*
*
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.
*
*
(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.)
*
*
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}{@code b}.
*/
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.
*
*
* Special cases:
*
If the argument is NaN, the result is 0.
*
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}.
*
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}.
*
* @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.
*
*
Special cases:
*
If the argument is NaN, the result is 0.
*
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}.
*
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}.
*
* @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.
*
*
When this method is first called, it creates a single new
* pseudorandom-number generator, exactly as if by the expression
*
*
{@code new java.util.Random()}
*
* This new pseudorandom-number generator is used thereafter for
* all calls to this method and is used nowhere else.
*
*
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}.
*
* 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.
*
*
If the signs of the arguments are the same, the results of
* {@code floorDiv} and the {@code /} operator are the same.
* For example, {@code floorDiv(4, 3) == 1} and {@code (4 / 3) == 1}.
*
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.
* For example, {@code floorDiv(-4, 3) == -2},
* whereas {@code (-4 / 3) == -1}.
*
*
*
*
* @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}.
*
* 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.
*
* 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.
*
* 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)}.
*
*
* The relationship between {@code floorDiv} and {@code floorMod} is such that:
*
* 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.
*
* Examples:
*
*
If the signs of the arguments are the same, the results
* of {@code floorMod} and the {@code %} operator are the same.
*
* 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.
*
* 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)}.
*
*
* The relationship between {@code floorDiv} and {@code floorMod} is such that:
*
* 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.
*
*
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.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public static int abs(int a) {
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.
*
*
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.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public static long abs(long a) {
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:
*
If the argument is positive zero or negative zero, the
* result is positive zero.
*
If the argument is infinite, the result is positive infinity.
*
If the argument is NaN, the result is NaN.
* In other words, the result is the same as the value of the expression:
*
{@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.
*
* @diffblue.fullSupport
*/
public static float abs(float a) {
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:
*
If the argument is positive zero or negative zero, the result
* is positive zero.
*
If the argument is infinite, the result is positive infinity.
*
If the argument is NaN, the result is NaN.
* In other words, the result is the same as the value of the expression:
*
{@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.
*
* @diffblue.fullSupport
*/
public static double abs(double a) {
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
* x, ulp(-x) == ulp(x).
*
*
Special Cases:
*
*
If the argument is NaN, then the result is NaN.
*
If the argument is positive or negative infinity, then the
* result is positive infinity.
*
If the argument is positive or negative zero, then the result is
* {@code Double.MIN_VALUE}.
*
If the argument is ±{@code Double.MAX_VALUE}, then
* the result is equal to 2971.
*
*
* @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
* x, ulp(-x) == ulp(x).
*
*
Special Cases:
*
*
If the argument is NaN, then the result is NaN.
*
If the argument is positive or negative infinity, then the
* result is positive infinity.
*
If the argument is positive or negative zero, then the result is
* {@code Float.MIN_VALUE}.
*
If the argument is ±{@code Float.MAX_VALUE}, then
* the result is equal to 2104.
*
*
* @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.
*
*
Special Cases:
*
*
If the argument is NaN, then the result is NaN.
*
If the argument is positive zero or negative zero, then the
* result is the same as the argument.
*
*
* @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
*
* @diffblue.fullSupport
*/
public static double signum(double d) {
// return (d == 0.0 || Double.isNaN(d))?d:copySign(1.0, d);
if (d == 0 || Double.isNaN(d)) {
return d;
}
return d > 0.0 ? 1.0 : -1.0;
}
/**
* 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.
*
*
Special Cases:
*
*
If the argument is NaN, then the result is NaN.
*
If the argument is positive zero or negative zero, then the
* result is the same as the argument.
*
*
* @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
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public static float signum(float f) {
// return (f == 0.0f || Float.isNaN(f))?f:copySign(1.0f, f);
if (f == 0 || Float.isNaN(f)) {
return f;
}
return f > 0.0f ? 1.0f : -1.0f;
}
/**
* Returns the hyperbolic sine of a {@code double} value.
* The hyperbolic sine of x is defined to be
* (ex - e-x)/2
* where e is {@linkplain Math#E Euler's number}.
*
*
Special cases:
*
*
*
If the argument is NaN, then the result is NaN.
*
*
If the argument is infinite, then the result is an infinity
* with the same sign as the argument.
*
*
If the argument is zero, then the result is a zero with the
* same sign as the argument.
*
*
*
*
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 x is defined to be
* (ex + e-x)/2
* where e is {@linkplain Math#E Euler's number}.
*
*
Special cases:
*
*
*
If the argument is NaN, then the result is NaN.
*
*
If the argument is infinite, then the result is positive
* infinity.
*
*
If the argument is zero, then the result is {@code 1.0}.
*
*
*
*
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 x is defined to be
* (ex - e-x)/(ex + e-x),
* in other words, {@linkplain Math#sinh
* sinh(x)}/{@linkplain Math#cosh cosh(x)}. Note
* that the absolute value of the exact tanh is always less than
* 1.
*
*
Special cases:
*
*
*
If the argument is NaN, then the result is NaN.
*
*
If the argument is zero, then the result is a zero with the
* same sign as the argument.
*
*
If the argument is positive infinity, then the result is
* {@code +1.0}.
*
*
If the argument is negative infinity, then the result is
* {@code -1.0}.
*
*
*
*
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(x2 +y2)
* without intermediate overflow or underflow.
*
*
Special cases:
*
*
*
If either argument is infinite, then the result
* is positive infinity.
*
*
If either argument is NaN and neither argument is infinite,
* then the result is NaN.
*
*
*
*
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(x2 +y2)
* 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 ex -1. Note that for values of
* x near 0, the exact sum of
* {@code expm1(x)} + 1 is much closer to the true
* result of ex than {@code exp(x)}.
*
*
Special cases:
*
*
If the argument is NaN, the result is NaN.
*
*
If the argument is positive infinity, then the result is
* positive infinity.
*
*
If the argument is negative infinity, then the result is
* -1.0.
*
*
If the argument is zero, then the result is a zero with the
* same sign as the argument.
*
*
*
*
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
* e{@code x} - 1 is within 1/2
* ulp of the limit value -1, {@code -1.0} should be
* returned.
*
* @param x the exponent to raise e to in the computation of
* e{@code x} -1.
* @return the value e{@code x} - 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)}.
*
*
Special cases:
*
*
*
*
If the argument is NaN or less than -1, then the result is
* NaN.
*
*
If the argument is positive infinity, then the result is
* positive infinity.
*
*
If the argument is negative one, then the result is
* negative infinity.
*
*
If the argument is zero, then the result is a zero with the
* same sign as the argument.
*
*
*
*
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:
*
*
*
If the argument is NaN or infinite, then the result is
* {@link Float#MAX_EXPONENT} + 1.
*
If the argument is zero or subnormal, then the result is
* {@link Float#MIN_EXPONENT} -1.
*
* @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:
*
*
*
If the argument is NaN or infinite, then the result is
* {@link Double#MAX_EXPONENT} + 1.
*
If the argument is zero or subnormal, then the result is
* {@link Double#MIN_EXPONENT} -1.
*
* @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.
*
*
* Special cases:
*
*
If either argument is a NaN, then NaN is returned.
*
*
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).
*
*
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.
*
*
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.
*
*
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.
*
*
* @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.
*
*
* Special cases:
*
*
If either argument is a NaN, then NaN is returned.
*
*
If both arguments are signed zeros, a value equivalent
* to {@code direction} is returned.
*
*
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.
*
*
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.
*
*
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.
*
*
* @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.
*
*
Special Cases:
*
*
If the argument is NaN, the result is NaN.
*
*
If the argument is positive infinity, the result is
* positive infinity.
*
*
If the argument is zero, the result is
* {@link Double#MIN_VALUE}
*
*
*
* @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.
*
*
Special Cases:
*
*
If the argument is NaN, the result is NaN.
*
*
If the argument is positive infinity, the result is
* positive infinity.
*
*
If the argument is zero, the result is
* {@link Float#MIN_VALUE}
*
*
*
* @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.
*
*
Special Cases:
*
*
If the argument is NaN, the result is NaN.
*
*
If the argument is negative infinity, the result is
* negative infinity.
*
*
If the argument is zero, the result is
* {@code -Double.MIN_VALUE}
*
*
*
* @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.
*
*
Special Cases:
*
*
If the argument is NaN, the result is NaN.
*
*
If the argument is negative infinity, the result is
* negative infinity.
*
*
If the argument is zero, the result is
* {@code -Float.MIN_VALUE}
*
*
*
* @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{@code scaleFactor} 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
* x. When the result is non-NaN, the result has the same
* sign as {@code d}.
*
*
Special cases:
*
*
If the first argument is NaN, NaN is returned.
*
If the first argument is infinite, then an infinity of the
* same sign is returned.
*
If the first argument is zero, then a zero of the same
* sign is returned.
*
*
* @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{@code scaleFactor}
* @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{@code scaleFactor} 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
* x. When the result is non-NaN, the result has the same
* sign as {@code f}.
*
*
Special cases:
*
*
If the first argument is NaN, NaN is returned.
*
If the first argument is infinite, then an infinity of the
* same sign is returned.
*
If the first argument is zero, then a zero of the same
* sign is returned.
*
*
* @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{@code scaleFactor}
* @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);
}
}
java-models-library-master/src/main/java/java/lang/NegativeArraySizeException.java 0000664 0000000 0000000 00000003643 14323475213 0030641 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/NoClassDefFoundError.java 0000664 0000000 0000000 00000005146 14323475213 0027355 0 ustar 00root root 0000000 0000000 /*
* 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 ClassLoader 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 new expression)
* and no definition of the class could be found.
*
* 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 NoClassDefFoundError with no detail message.
*/
public NoClassDefFoundError() {
super();
}
/**
* Constructs a NoClassDefFoundError 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";
}
}
java-models-library-master/src/main/java/java/lang/NoSuchFieldError.java 0000664 0000000 0000000 00000004707 14323475213 0026545 0 ustar 00root root 0000000 0000000 /*
* 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.
*
* 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 NoSuchFieldError with no detail message.
*/
public NoSuchFieldError() {
super();
}
/**
* Constructs a NoSuchFieldError 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";
}
}
java-models-library-master/src/main/java/java/lang/NoSuchFieldException.java 0000664 0000000 0000000 00000003621 14323475213 0027404 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/NoSuchMethodError.java 0000664 0000000 0000000 00000004760 14323475213 0026741 0 ustar 00root root 0000000 0000000 /*
* 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.
*
* 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 NoSuchMethodError with no detail message.
*/
public NoSuchMethodError() {
super();
}
/**
* Constructs a NoSuchMethodError 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";
}
}
java-models-library-master/src/main/java/java/lang/NoSuchMethodException.java 0000664 0000000 0000000 00000003625 14323475213 0027605 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/NullPointerException.java 0000664 0000000 0000000 00000003604 14323475213 0027515 0 ustar 00root root 0000000 0000000 /*
* 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 NullPointerException extends RuntimeException {
private static final long serialVersionUID = 5162710183389028792L;
public NullPointerException() {
super();
}
public NullPointerException(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.NullPointerException: " + message)
: "java.lang.NullPointerException";
}
}
java-models-library-master/src/main/java/java/lang/Number.java 0000664 0000000 0000000 00000011121 14323475213 0024604 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* The abstract class {@code Number} is the superclass of platform
* classes representing numeric values that are convertible to the
* primitive types {@code byte}, {@code double}, {@code float}, {@code
* int}, {@code long}, and {@code short}.
*
* The specific semantics of the conversion from the numeric value of
* a particular {@code Number} implementation to a given primitive
* type is defined by the {@code Number} implementation in question.
*
* For platform classes, the conversion is often analogous to a
* narrowing primitive conversion or a widening primitive conversion
* as defining in The Java™ Language Specification
* for converting between primitive types. Therefore, conversions may
* lose information about the overall magnitude of a numeric value, may
* lose precision, and may even return a result of a different sign
* than the input.
*
* See the documentation of a given {@code Number} implementation for
* conversion details.
*
* @author Lee Boynton
* @author Arthur van Hoff
* @jls 5.1.2 Widening Primitive Conversions
* @jls 5.1.3 Narrowing Primitive Conversions
* @since JDK1.0
*/
public abstract class Number implements java.io.Serializable {
/**
* Returns the value of the specified number as an {@code int},
* which may involve rounding or truncation.
*
* @return the numeric value represented by this object after conversion
* to type {@code int}.
*/
public abstract int intValue();
/**
* Returns the value of the specified number as a {@code long},
* which may involve rounding or truncation.
*
* @return the numeric value represented by this object after conversion
* to type {@code long}.
*/
public abstract long longValue();
/**
* Returns the value of the specified number as a {@code float},
* which may involve rounding.
*
* @return the numeric value represented by this object after conversion
* to type {@code float}.
*/
public abstract float floatValue();
/**
* Returns the value of the specified number as a {@code double},
* which may involve rounding.
*
* @return the numeric value represented by this object after conversion
* to type {@code double}.
*/
public abstract double doubleValue();
/**
* Returns the value of the specified number as a {@code byte},
* which may involve rounding or truncation.
*
*
This implementation returns the result of {@link #intValue} cast
* to a {@code byte}.
*
* @return the numeric value represented by this object after conversion
* to type {@code byte}.
* @since JDK1.1
*/
public byte byteValue() {
return (byte)intValue();
}
/**
* Returns the value of the specified number as a {@code short},
* which may involve rounding or truncation.
*
*
This implementation returns the result of {@link #intValue} cast
* to a {@code short}.
*
* @return the numeric value represented by this object after conversion
* to type {@code short}.
* @since JDK1.1
*/
public short shortValue() {
return (short)intValue();
}
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -8742448824652078965L;
}
java-models-library-master/src/main/java/java/lang/NumberFormatException.java 0000664 0000000 0000000 00000004035 14323475213 0027642 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/Object.java 0000664 0000000 0000000 00000012604 14323475213 0024571 0 ustar 00root root 0000000 0000000 /*
* 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;
import org.cprover.CProver;
import java.lang.NullPointerException;
import java.lang.IllegalMonitorStateException;
public class Object {
// lock needed for synchronization in JBMC
// used by monitorenter, monitorexit, wait, and notify
// Not present in the original Object class
public int cproverMonitorCount;
public Object() {
cproverMonitorCount = 0;
}
/**
* @diffblue.limitedSupport
* This relies on Class.forName whose model is only partial. The model of
* Class is made to work for combinations of calls to Object.getClass,
* Class.forName and Class.getName but other operations are unlikely to
* work.
*/
public final Class getClass() {
// DIFFBLUE MODEL LIBRARY
return Class.forName(CProver.classIdentifier(this));
}
public int hashCode() {
return 0;
}
public boolean equals(Object obj) {
return (this == obj);
}
protected Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
public final void notify() {
// TODO: the thread must own the lock when it calls notify
}
public final void notifyAll() {
// TODO: the thread must own the lock when it calls notifyAll
}
public final void wait(long timeout) throws InterruptedException {
// TODO: the thread must own the lock when it calls wait
// should only throw if the interrupted flag in Thread is enabled
throw new InterruptedException();
}
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos > 0) {
timeout++;
}
wait(timeout);
}
public final void wait() throws InterruptedException {
wait(0);
}
protected void finalize() throws Throwable { }
/**
* This method is not present in the original Object class.
* It will be called by JBMC when the monitor in this instance
* is being acquired as a result of either the execution of a
* monitorenter bytecode instruction or the call to a synchronized
* method. It uses a counter to enable reentrance and an atomic section
* to ensure multiple threads do not race in the access/modification of
* the counter.
*/
public static void monitorenter(Object object)
{
// TODO: we shoud remove the call to this method from the call
// stack appended to the thrown exception
if (object == null)
throw new NullPointerException();
CProver.atomicBegin();
// this assume blocks this execution path in JBMC and simulates
// the thread having to wait because the monitor is not available
CProver.assume(object.cproverMonitorCount == 0);
object.cproverMonitorCount++;
CProver.atomicEnd();
}
/**
* This method is not present in the original Object class.
* It will be called by JBMC when the monitor in this instance
* is being released as a result of either the execution of a
* monitorexit bytecode instruction or the return (normal or exceptional)
* of a synchronized method. It decrements the cproverMonitorCount that
* had been incremented in monitorenter().
*/
public static void monitorexit(Object object)
{
// TODO: we shoud remove the call to this method from the call
// stack appended to the thrown exception
// TODO: Enabling these exceptions makes
// jbmc/synchronized-blocks/test_sync.desc
// run into an infinite loop during symex
// if (object == null)
// throw new NullPointerException();
// if (object.cproverMonitorCount == 0)
// throw new IllegalMonitorStateException();
CProver.atomicBegin();
object.cproverMonitorCount--;
CProver.atomicEnd();
}
}
java-models-library-master/src/main/java/java/lang/OutOfMemoryError.java 0000664 0000000 0000000 00000005050 14323475213 0026617 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/ReflectiveOperationException.java 0000664 0000000 0000000 00000004142 14323475213 0031211 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/Runnable.java 0000664 0000000 0000000 00000005741 14323475213 0025135 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* The Runnable interface should be implemented by any
* class whose instances are intended to be executed by a thread. The
* class must define a method of no arguments called run.
*
* This interface is designed to provide a common protocol for objects that
* wish to execute code while they are active. For example,
* Runnable is implemented by class Thread.
* Being active simply means that a thread has been started and has not
* yet been stopped.
*
* In addition, Runnable provides the means for a class to be
* active while not subclassing Thread. A class that implements
* Runnable can run without subclassing Thread
* by instantiating a Thread instance and passing itself in
* as the target. In most cases, the Runnable interface should
* be used if you are only planning to override the run()
* method and no other Thread methods.
* This is important because classes should not be subclassed
* unless the programmer intends on modifying or enhancing the fundamental
* behavior of the class.
*
* @author Arthur van Hoff
* @see java.lang.Thread
* @see java.util.concurrent.Callable
* @since JDK1.0
*/
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface Runnable is used
* to create a thread, starting the thread causes the object's
* run method to be called in that separately executing
* thread.
*
* The general contract of the method run is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
java-models-library-master/src/main/java/java/lang/RuntimeException.java 0000664 0000000 0000000 00000004443 14323475213 0026667 0 ustar 00root root 0000000 0000000 /*
* 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;
public class RuntimeException extends Exception {
static final long serialVersionUID = -7034897190745766939L;
public RuntimeException() {
super();
}
public RuntimeException(String message) {
super(message);
}
public RuntimeException(String message, Throwable cause) {
super(message, cause);
}
public RuntimeException(Throwable cause) {
super(cause);
}
protected RuntimeException(String message, Throwable cause,
boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
// 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.RuntimeException: " + message)
: "java.lang.RuntimeException";
}
}
java-models-library-master/src/main/java/java/lang/SecurityException.java 0000664 0000000 0000000 00000004050 14323475213 0027045 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/Short.java 0000664 0000000 0000000 00000046151 14323475213 0024466 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1996, 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 Short} class wraps a value of primitive type {@code
* short} in an object. An object of type {@code Short} contains a
* single field whose type is {@code short}.
*
*
In addition, this class provides several methods for converting
* a {@code short} to a {@code String} and a {@code String} to a
* {@code short}, as well as other constants and methods useful when
* dealing with a {@code short}.
*
* @author Nakul Saraiya
* @author Joseph D. Darcy
* @see java.lang.Number
* @since JDK1.1
*/
public final class Short extends Number implements Comparable {
/**
* A constant holding the minimum value a {@code short} can
* have, -215.
*/
public static final short MIN_VALUE = -32768;
/**
* A constant holding the maximum value a {@code short} can
* have, 215-1.
*/
public static final short MAX_VALUE = 32767;
/**
* The {@code Class} instance representing the primitive type
* {@code short}.
*/
@SuppressWarnings("unchecked")
public static final Class TYPE = (Class) Class.getPrimitiveClass(7);
/**
* Returns a new {@code String} object representing the
* specified {@code short}. The radix is assumed to be 10.
*
* @param s the {@code short} to be converted
* @return the string representation of the specified {@code short}
* @see java.lang.Integer#toString(int)
*
* @diffblue.fullSupport
*/
public static String toString(short s) {
return CProverString.toString((int)s);
}
/**
* Parses the string argument as a signed {@code short} 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 {@code short} value
* is returned.
*
*
An exception of type {@code NumberFormatException} is
* thrown if any of the following situations occurs:
*
*
The first argument is {@code null} or is a string of
* length zero.
*
*
The radix is either smaller than {@link
* java.lang.Character#MIN_RADIX} or larger than {@link
* java.lang.Character#MAX_RADIX}.
*
*
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.
*
*
The value represented by the string is not a value of type
* {@code short}.
*
*
* @param s the {@code String} containing the
* {@code short} representation to be parsed
* @param radix the radix to be used while parsing {@code s}
* @return the {@code short} represented by the string
* argument in the specified radix.
* @throws NumberFormatException If the {@code String}
* does not contain a parsable {@code short}.
*/
public static short parseShort(String s, int radix)
throws NumberFormatException {
int i = Integer.parseInt(s, radix);
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException(
"Value out of range. Value:\"" + s + "\" Radix:" + radix);
return (short)i;
}
/**
* Parses the string argument as a signed decimal {@code
* short}. 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 {@code short} value is returned, exactly as if the
* argument and the radix 10 were given as arguments to the {@link
* #parseShort(java.lang.String, int)} method.
*
* @param s a {@code String} containing the {@code short}
* representation to be parsed
* @return the {@code short} value represented by the
* argument in decimal.
* @throws NumberFormatException If the string does not
* contain a parsable {@code short}.
*/
public static short parseShort(String s) throws NumberFormatException {
return CProver.nondetShort(); //The function is handled by cbmc internally
}
/**
* Returns a {@code Short} 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 {@code short} in
* the radix specified by the second argument, exactly as if the
* argument were given to the {@link #parseShort(java.lang.String,
* int)} method. The result is a {@code Short} object that
* represents the {@code short} value specified by the string.
*
*
In other words, this method returns a {@code Short} object
* equal to the value of:
*
*
* {@code new Short(Short.parseShort(s, radix))}
*
*
* @param s the string to be parsed
* @param radix the radix to be used in interpreting {@code s}
* @return a {@code Short} object holding the value
* represented by the string argument in the
* specified radix.
* @throws NumberFormatException If the {@code String} does
* not contain a parsable {@code short}.
*/
public static Short valueOf(String s, int radix)
throws NumberFormatException {
return valueOf(parseShort(s, radix));
}
/**
* Returns a {@code Short} object holding the
* value given by the specified {@code String}. The argument
* is interpreted as representing a signed decimal
* {@code short}, exactly as if the argument were given to
* the {@link #parseShort(java.lang.String)} method. The result is
* a {@code Short} object that represents the
* {@code short} value specified by the string.
*
*
In other words, this method returns a {@code Short} object
* equal to the value of:
*
*
* {@code new Short(Short.parseShort(s))}
*
*
* @param s the string to be parsed
* @return a {@code Short} object holding the value
* represented by the string argument
* @throws NumberFormatException If the {@code String} does
* not contain a parsable {@code short}.
*/
public static Short valueOf(String s) throws NumberFormatException {
return valueOf(s, 10);
}
/**
* Returns a {@code Short} instance representing the specified
* {@code short} value.
* If a new {@code Short} instance is not required, this method
* should generally be used in preference to the constructor
* {@link #Short(short)}, 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 s a short value.
* @return a {@code Short} instance representing {@code s}.
* @since 1.5
*/
public static Short valueOf(short s) {
return new Short(s);
}
/**
* Decodes a {@code String} into a {@code Short}.
* Accepts decimal, hexadecimal, and octal numbers given by
* the following grammar:
*
*
*
*
DecodableString:
*
Signopt DecimalNumeral
*
Signopt {@code 0x} HexDigits
*
Signopt {@code 0X} HexDigits
*
Signopt {@code #} HexDigits
*
Signopt {@code 0} OctalDigits
*
*
Sign:
*
{@code -}
*
{@code +}
*
*
*
* DecimalNumeral, HexDigits, and OctalDigits
* are as defined in section 3.10.1 of
* The Java™ Language Specification,
* except that underscores are not accepted between digits.
*
*
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
* Short.parseShort} 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 a {@code Short} object holding the {@code short}
* value represented by {@code nm}
* @throws NumberFormatException if the {@code String} does not
* contain a parsable {@code short}.
* @see java.lang.Short#parseShort(java.lang.String, int)
*/
public static Short decode(String nm) throws NumberFormatException {
int i = Integer.decode(nm);
if (i < MIN_VALUE || i > MAX_VALUE)
throw new NumberFormatException(
"Value " + i + " out of range from input " + nm);
return valueOf((short)i);
}
/**
* The value of the {@code Short}.
*
* @serial
*/
private final short value;
/**
* Constructs a newly allocated {@code Short} object that
* represents the specified {@code short} value.
*
* @param value the value to be represented by the
* {@code Short}.
*/
public Short(short value) {
this.value = value;
}
/**
* Constructs a newly allocated {@code Short} object that
* represents the {@code short} value indicated by the
* {@code String} parameter. The string is converted to a
* {@code short} value in exactly the manner used by the
* {@code parseShort} method for radix 10.
*
* @param s the {@code String} to be converted to a
* {@code Short}
* @throws NumberFormatException If the {@code String}
* does not contain a parsable {@code short}.
* @see java.lang.Short#parseShort(java.lang.String, int)
*/
public Short(String s) throws NumberFormatException {
this.value = parseShort(s, 10);
}
/**
* Returns the value of this {@code Short} 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 Short} as a
* {@code short}.
*/
public short shortValue() {
return value;
}
/**
* Returns the value of this {@code Short} as an {@code int} after
* a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public int intValue() {
return (int)value;
}
/**
* Returns the value of this {@code Short} as a {@code long} after
* a widening primitive conversion.
* @jls 5.1.2 Widening Primitive Conversions
*/
public long longValue() {
return (long)value;
}
/**
* Returns the value of this {@code Short} 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 Short} 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 Short}'s value. The value is converted to signed
* decimal representation and returned as a string, exactly as if
* the {@code short} value were given as an argument to the
* {@link java.lang.Short#toString(short)} method.
*
* @return a string representation of the value of this object in
* base 10.
*/
public String toString() {
return Integer.toString((int)value);
}
/**
* Returns a hash code for this {@code Short}; equal to the result
* of invoking {@code intValue()}.
*
* @return a hash code value for this {@code Short}
*/
@Override
public int hashCode() {
return Short.hashCode(value);
}
/**
* Returns a hash code for a {@code short} value; compatible with
* {@code Short.hashCode()}.
*
* @param value the value to hash
* @return a hash code value for a {@code short} value.
* @since 1.8
*/
public static int hashCode(short value) {
return (int)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 a {@code Short} object that
* contains the same {@code short} 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 Short) {
return value == ((Short)obj).shortValue();
}
return false;
}
/**
* Compares two {@code Short} objects numerically.
*
* @param anotherShort the {@code Short} to be compared.
* @return the value {@code 0} if this {@code Short} is
* equal to the argument {@code Short}; a value less than
* {@code 0} if this {@code Short} is numerically less
* than the argument {@code Short}; and a value greater than
* {@code 0} if this {@code Short} is numerically
* greater than the argument {@code Short} (signed
* comparison).
* @since 1.2
*/
public int compareTo(Short anotherShort) {
return compare(this.value, anotherShort.value);
}
/**
* Compares two {@code short} values numerically.
* The value returned is identical to what would be returned by:
*
* Short.valueOf(x).compareTo(Short.valueOf(y))
*
*
* @param x the first {@code short} to compare
* @param y the second {@code short} 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(short x, short y) {
return x - y;
}
/**
* The number of bits used to represent a {@code short} value in two's
* complement binary form.
* @since 1.5
*/
public static final int SIZE = 16;
/**
* The number of bytes used to represent a {@code short} value in two's
* complement 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
* two's complement representation of the specified {@code short} value.
*
* @param i the value whose bytes are to be reversed
* @return the value obtained by reversing (or, equivalently, swapping)
* the bytes in the specified {@code short} value.
* @since 1.5
*/
public static short reverseBytes(short i) {
return (short) (((i & 0xFF00) >> 8) | (i << 8));
}
/**
* Converts the argument to an {@code int} by an unsigned
* conversion. In an unsigned conversion to an {@code int}, the
* high-order 16 bits of the {@code int} are zero and the
* low-order 16 bits are equal to the bits of the {@code short} argument.
*
* Consequently, zero and positive {@code short} values are mapped
* to a numerically equal {@code int} value and negative {@code
* short} values are mapped to an {@code int} value equal to the
* input plus 216.
*
* @param x the value to convert to an unsigned {@code int}
* @return the argument converted to {@code int} by an unsigned
* conversion
* @since 1.8
*/
public static int toUnsignedInt(short x) {
return ((int) x) & 0xffff;
}
/**
* Converts the argument to a {@code long} by an unsigned
* conversion. In an unsigned conversion to a {@code long}, the
* high-order 48 bits of the {@code long} are zero and the
* low-order 16 bits are equal to the bits of the {@code short} argument.
*
* Consequently, zero and positive {@code short} values are mapped
* to a numerically equal {@code long} value and negative {@code
* short} values are mapped to a {@code long} value equal to the
* input plus 216.
*
* @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
*/
public static long toUnsignedLong(short x) {
return ((long) x) & 0xffffL;
}
/** use serialVersionUID from JDK 1.1. for interoperability */
private static final long serialVersionUID = 7515723908773894738L;
}
java-models-library-master/src/main/java/java/lang/StackOverflowError.java 0000664 0000000 0000000 00000004400 14323475213 0027161 0 ustar 00root root 0000000 0000000 /*
* 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 StackOverflowError with no detail message.
*/
public StackOverflowError() {
super();
}
/**
* Constructs a StackOverflowError 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";
}
}
java-models-library-master/src/main/java/java/lang/String.java 0000664 0000000 0000000 00000525417 14323475213 0024644 0 ustar 00root root 0000000 0000000 /*
* 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.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
// import java.io.ObjectStreamField;
// import java.util.ArrayList;
// import java.util.Arrays;
// 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:
import org.cprover.CProverString;
/**
* The {@code String} class represents character strings. All
* string literals in Java programs, such as {@code "abc"}, are
* implemented as instances of this class.
*
* Strings are constant; their values cannot be changed after they
* are created. String buffers support mutable strings.
* Because String objects are immutable they can be shared. For example:
*
* The class {@code String} includes methods for examining
* individual characters of the sequence, for comparing strings, for
* searching strings, for extracting substrings, and for creating a
* copy of a string with all characters translated to uppercase or to
* lowercase. Case mapping is based on the Unicode Standard version
* specified by the {@link java.lang.Character Character} class.
*
* The Java language provides special support for the string
* concatenation operator ( + ), and for conversion of
* other objects to strings. String concatenation is implemented
* through the {@code StringBuilder}(or {@code StringBuffer})
* class and its {@code append} method.
* String conversions are implemented through the method
* {@code toString}, defined by {@code Object} and
* inherited by all classes in Java. For additional information on
* string concatenation and conversion, see Gosling, Joy, and Steele,
* The Java Language Specification.
*
*
Unless otherwise noted, passing a null argument to a constructor
* or method in this class will cause a {@link NullPointerException} to be
* thrown.
*
*
A {@code String} represents a string in the UTF-16 format
* in which supplementary characters are represented by surrogate
* pairs (see the section Unicode
* Character Representations in the {@code Character} class for
* more information).
* Index values refer to {@code char} code units, so a supplementary
* character uses two positions in a {@code String}.
*
The {@code String} class provides methods for dealing with
* Unicode code points (i.e., characters), in addition to those for
* dealing with Unicode code units (i.e., {@code char} values).
*
* @author Lee Boynton
* @author Arthur van Hoff
* @author Martin Buchholz
* @author Ulf Zibis
* @see java.lang.Object#toString()
* @see java.lang.StringBuffer
* @see java.lang.StringBuilder
* @see java.nio.charset.Charset
* @since JDK1.0
*
* @diffblue.limitedSupport
* Not all methods are fully supported.
*/
public final class String
implements java.io.Serializable, Comparable, CharSequence {
/** The value is used for character storage. */
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
// private final char value[];
/** Cache the hash code for the string */
// DIFFBLUE MODEL LIBRARY This is not necessary for modelling
// private int hash; // Default to 0
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;
/**
* Class String is special cased within the Serialization Stream Protocol.
*
* A String instance is written into an ObjectOutputStream according to
*
* Object Serialization Specification, Section 6.2, "Stream Elements"
*/
// DIFFBLUE MODEL LIBRARY This is not necessary for modelling
// private static final ObjectStreamField[] serialPersistentFields =
// new ObjectStreamField[0];
/**
* Initializes a newly created {@code String} object so that it represents
* an empty character sequence. Note that use of this constructor is
* unnecessary since Strings are immutable.
*
* @diffblue.fullSupport
*/
public String() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
// this.value = new char[0];
}
/**
* Initializes a newly created {@code String} object so that it represents
* the same sequence of characters as the argument; in other words, the
* newly created string is a copy of the argument string. Unless an
* explicit copy of {@code original} is needed, use of this constructor is
* unnecessary since Strings are immutable.
*
* @param original
* A {@code String}
*
* @diffblue.fullSupport
*/
public String(String original) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
// this.value = original.value;
// this.hash = original.hash;
}
/**
* Intermediary function for modelling the constructor String(char value[]).
*/
private static String CProverStringOfCharArray(char value[]) {
if (value == null) {
throw new NullPointerException();
}
return CProverString.ofCharArray(value, 0, value.length);
}
/**
* Allocates a new {@code String} so that it represents the sequence of
* characters currently contained in the character array argument. The
* contents of the character array are copied; subsequent modification of
* the character array does not affect the newly created string.
*
* @param value
* The initial value of the string
*
* @diffblue.limitedSupport
* The length of the String constructed is limited by the unwind
* parameter.
*/
public String(char value[]) {
// this.value = Arrays.copyOf(value, value.length);
// DIFFBLUE MODEL LIBRARY
this(CProverStringOfCharArray(value));
}
/**
* Intermediary function for modelling the constructor for
* String(char value[], int offset, int count).
* The code is copied from the original String(char value[], int offset, int count).
*/
private static String CProverStringOfCharArray(char value[], int offset, int count) {
if (offset < 0) {
throw new StringIndexOutOfBoundsException(offset);
}
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
// Note: offset or count might be near -1>>>1.
if (offset > value.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
// DIFFBLUE MODEL LIBRARY Use CProverString function instead of array copy
return CProverString.ofCharArray(value, offset, count);
// this.value = Arrays.copyOfRange(value, offset, offset+count);
}
/**
* Allocates a new {@code String} that contains characters from a subarray
* of the character array argument. The {@code offset} argument is the
* index of the first character of the subarray and the {@code count}
* argument specifies the length of the subarray. The contents of the
* subarray are copied; subsequent modification of the character array does
* not affect the newly created string.
*
* @param value
* Array that is the source of characters
*
* @param offset
* The initial offset
*
* @param count
* The length
*
* @throws IndexOutOfBoundsException
* If the {@code offset} and {@code count} arguments index
* characters outside the bounds of the {@code value} array
*
* @diffblue.limitedSupport
* @diffblue.untested
*/
public String(char value[], int offset, int count) {
// DIFFBLUE MODEL LIBRARY
this(CProverStringOfCharArray(value, offset, count));
// if (offset < 0) {
// throw new StringIndexOutOfBoundsException(offset);
// }
// if (count < 0) {
// throw new StringIndexOutOfBoundsException(count);
// }
// // Note: offset or count might be near -1>>>1.
// if (offset > value.length - count) {
// throw new StringIndexOutOfBoundsException(offset + count);
// }
// this.value = Arrays.copyOfRange(value, offset, offset+count);
}
/**
* DIFFBLUE MODEL LIBRARY
* Helper for generating non-deterministic strings.
*/
private static String cproverNonDet()
{
return CProver.nondetWithoutNull("");
}
/**
* Allocates a new {@code String} that contains characters from a subarray
* of the Unicode code point array
* argument. The {@code offset} argument is the index of the first code
* point of the subarray and the {@code count} argument specifies the
* length of the subarray. The contents of the subarray are converted to
* {@code char}s; subsequent modification of the {@code int} array does not
* affect the newly created string.
*
* @param codePoints
* Array that is the source of Unicode code points
*
* @param offset
* The initial offset
*
* @param count
* The length
*
* @throws IllegalArgumentException
* If any invalid Unicode code point is found in {@code
* codePoints}
*
* @throws IndexOutOfBoundsException
* If the {@code offset} and {@code count} arguments index
* characters outside the bounds of the {@code codePoints} array
*
* @since 1.5
*
* @diffblue.limitedSupport
* Assumes all codePoints are in the Basic Multilingual Plane.
* An implication of this limitation is that no trace is generated for
* the cases where IllegalArgumentException would be thrown.
*/
public String(int[] codePoints, int offset, int count) {
// if (offset < 0) {
// throw new StringIndexOutOfBoundsException(offset);
// }
// if (count < 0) {
// throw new StringIndexOutOfBoundsException(count);
// }
// // Note: offset or count might be near -1>>>1.
// if (offset > codePoints.length - count) {
// throw new StringIndexOutOfBoundsException(offset + count);
// }
// final int end = offset + count;
// // Pass 1: Compute precise size of char[]
// int n = count;
// for (int i = offset; i < end; i++) {
// int c = codePoints[i];
// if (Character.isBmpCodePoint(c))
// continue;
// else if (Character.isValidCodePoint(c))
// n++;
// else throw new IllegalArgumentException(Integer.toString(c));
// }
// // Pass 2: Allocate and fill in char[]
// final char[] v = new char[n];
// for (int i = offset, j = 0; i < end; i++, j++) {
// int c = codePoints[i];
// if (Character.isBmpCodePoint(c))
// v[j] = (char)c;
// else
// Character.toSurrogates(c, v, j++);
// }
// this.value = v;
// DIFFBLUE MODEL LIBRARY
// We initialize the string non-deterministically and add constraints on
// it, instead of using an array of characters.
this(cproverNonDet());
if (offset < 0) {
throw new StringIndexOutOfBoundsException(offset);
}
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
if (offset > codePoints.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
final int end = offset + count;
CProver.assume(length() == count);
for (int i = offset, j = 0; i < end; i++, j++) {
int c = codePoints[i];
CProver.assume(Character.isBmpCodePoint(c));
CProver.assume(CProverString.charAt(this, j) == (char)c);
}
}
/**
* Allocates a new {@code String} constructed from a subarray of an array
* of 8-bit integer values.
*
*
The {@code offset} argument is the index of the first byte of the
* subarray, and the {@code count} argument specifies the length of the
* subarray.
*
*
Each {@code byte} in the subarray is converted to a {@code char} as
* specified in the method above.
*
* @deprecated This method does not properly convert bytes into characters.
* As of JDK 1.1, the preferred way to do this is via the
* {@code String} constructors that take a {@link
* java.nio.charset.Charset}, charset name, or that use the platform's
* default charset.
*
* @param ascii
* The bytes to be converted to characters
*
* @param hibyte
* The top 8 bits of each 16-bit Unicode code unit
*
* @param offset
* The initial offset
* @param count
* The length
*
* @throws IndexOutOfBoundsException
* If the {@code offset} or {@code count} argument is invalid
*
* @see #String(byte[], int)
* @see #String(byte[], int, int, java.lang.String)
* @see #String(byte[], int, int, java.nio.charset.Charset)
* @see #String(byte[], int, int)
* @see #String(byte[], java.lang.String)
* @see #String(byte[], java.nio.charset.Charset)
* @see #String(byte[])
*
* @diffblue.limitedSupport
* The length of the String constructed is limited by the unwind
* parameter.
*/
@Deprecated
public String(byte ascii[], int hibyte, int offset, int count) {
// checkBounds(ascii, offset, count);
// char value[] = new char[count];
// if (hibyte == 0) {
// for (int i = count; i-- > 0;) {
// value[i] = (char)(ascii[i + offset] & 0xff);
// }
// } else {
// hibyte <<= 8;
// for (int i = count; i-- > 0;) {
// value[i] = (char)(hibyte | (ascii[i + offset] & 0xff));
// }
// }
// this.value = value;
// DIFFBLUE MODEL LIBRARY
// We initialize the string non-deterministically and add constraints on
// it, instead of using an array of characters.
this(cproverNonDet());
checkBounds(ascii, offset, count);
CProver.assume(length() == count);
if (hibyte == 0) {
for (int i = count; i-- > 0;) {
CProver.assume(CProverString.charAt(this, i) == (char)(ascii[i + offset] & 0xff));
}
} else {
hibyte <<= 8;
for (int i = count; i-- > 0;) {
CProver.assume(CProverString.charAt(this, i) == (char)(hibyte | (ascii[i + offset] & 0xff)));
}
}
}
/**
* Allocates a new {@code String} containing characters constructed from
* an array of 8-bit integer values. Each character cin the
* resulting string is constructed from the corresponding component
* b in the byte array such that:
*
*
*
* @deprecated This method does not properly convert bytes into
* characters. As of JDK 1.1, the preferred way to do this is via the
* {@code String} constructors that take a {@link
* java.nio.charset.Charset}, charset name, or that use the platform's
* default charset.
*
* @param ascii
* The bytes to be converted to characters
*
* @param hibyte
* The top 8 bits of each 16-bit Unicode code unit
*
* @see #String(byte[], int, int, java.lang.String)
* @see #String(byte[], int, int, java.nio.charset.Charset)
* @see #String(byte[], int, int)
* @see #String(byte[], java.lang.String)
* @see #String(byte[], java.nio.charset.Charset)
* @see #String(byte[])
*
* @diffblue.limitedSupport
* The length of the String constructed is limited by the unwind
* parameter.
*/
@Deprecated
public String(byte ascii[], int hibyte) {
this(ascii, hibyte, 0, ascii.length);
}
/* Common private utility method used to bounds check the byte array
* and requested offset & length values used by the String(byte[],..)
* constructors.
*/
private static void checkBounds(byte[] bytes, int offset, int length) {
if (length < 0)
throw new StringIndexOutOfBoundsException(length);
if (offset < 0)
throw new StringIndexOutOfBoundsException(offset);
if (offset > bytes.length - length)
throw new StringIndexOutOfBoundsException(offset + length);
}
/**
* Constructs a new {@code String} by decoding the specified subarray of
* bytes using the specified charset. The length of the new {@code String}
* is a function of the charset, and hence may not be equal to the length
* of the subarray.
*
*
The behavior of this constructor when the given bytes are not valid
* in the given charset is unspecified. The {@link
* java.nio.charset.CharsetDecoder} class should be used when more control
* over the decoding process is required.
*
* @param bytes
* The bytes to be decoded into characters
*
* @param offset
* The index of the first byte to decode
*
* @param length
* The number of bytes to decode
* @param charsetName
* The name of a supported {@linkplain java.nio.charset.Charset
* charset}
*
* @throws UnsupportedEncodingException
* If the named charset is not supported
*
* @throws IndexOutOfBoundsException
* If the {@code offset} and {@code length} arguments index
* characters outside the bounds of the {@code bytes} array
*
* @since JDK1.1
*
* @diffblue.limitedSupport
* The length of the String constructed is limited by the unwind
* parameter.
*/
public String(byte bytes[], int offset, int length, String charsetName)
throws UnsupportedEncodingException {
// if (charsetName == null)
// throw new NullPointerException("charsetName");
// checkBounds(bytes, offset, length);
// this.value = StringCoding.decode(charsetName, bytes, offset, length);
// DIFFBLUE MODEL LIBRARY
// We initialize the string non-deterministically and add constraints on
// it, instead of using an array of characters.
this(cproverNonDet());
if (charsetName == null)
throw new NullPointerException("charsetName");
checkBounds(bytes, offset, length);
byte[] getBytesResult = cproverReversibleGetBytes(charsetName);
CProver.assume(getBytesResult.length == length);
for (int i = 0; i < length; i++) {
CProver.assume(bytes[i + offset] == getBytesResult[i]);
}
}
/**
* Constructs a new {@code String} by decoding the specified subarray of
* bytes using the specified {@linkplain java.nio.charset.Charset charset}.
* The length of the new {@code String} is a function of the charset, and
* hence may not be equal to the length of the subarray.
*
*
This method always replaces malformed-input and unmappable-character
* sequences with this charset's default replacement string. The {@link
* java.nio.charset.CharsetDecoder} class should be used when more control
* over the decoding process is required.
*
* @param bytes
* The bytes to be decoded into characters
*
* @param offset
* The index of the first byte to decode
*
* @param length
* The number of bytes to decode
*
* @param charset
* The {@linkplain java.nio.charset.Charset charset} to be used to
* decode the {@code bytes}
*
* @throws IndexOutOfBoundsException
* If the {@code offset} and {@code length} arguments index
* characters outside the bounds of the {@code bytes} array
*
* @since 1.6
*
* @diffblue.limitedSupport
* The length of the String constructed is limited by the unwind
* parameter.
*/
public String(byte bytes[], int offset, int length, Charset charset)
{
// if (charset == null)
// throw new NullPointerException("charset");
// checkBounds(bytes, offset, length);
// this.value = StringCoding.decode(charset, bytes, offset, length);
// DIFFBLUE MODEL LIBRARY
// We initialize the string non-deterministically and add constraints on
// it, instead of using an array of characters.
this(cproverNonDet());
if (charset == null)
throw new NullPointerException("charset");
checkBounds(bytes, offset, length);
byte[] getBytesResult = cproverReversibleGetBytes(charset);
CProver.assume(getBytesResult.length == length);
for (int i = 0; i < length; i++) {
CProver.assume(bytes[i + offset] == getBytesResult[i]);
}
}
/**
* Constructs a new {@code String} by decoding the specified array of bytes
* using the specified {@linkplain java.nio.charset.Charset charset}. The
* length of the new {@code String} is a function of the charset, and hence
* may not be equal to the length of the byte array.
*
*
The behavior of this constructor when the given bytes are not valid
* in the given charset is unspecified. The {@link
* java.nio.charset.CharsetDecoder} class should be used when more control
* over the decoding process is required.
*
* @param bytes
* The bytes to be decoded into characters
*
* @param charsetName
* The name of a supported {@linkplain java.nio.charset.Charset
* charset}
*
* @throws UnsupportedEncodingException
* If the named charset is not supported
*
* @since JDK1.1
*
* @diffblue.limitedSupport
* The length of the String constructed is limited by the unwind
* parameter.
*/
public String(byte bytes[], String charsetName)
throws UnsupportedEncodingException {
this(bytes, 0, bytes.length, charsetName);
}
/**
* DIFFBLUE MODEL LIBRARY
* Used to construct a string from a byte array and a charset.
*
* It does so by generating a non-deterministic string `s` and assuming
* `bytes` is equal to the result of `s.getBytes(charset)`.
*
* @param bytes
* The bytes to be decoded into characters
*
* @param charset
* a supported {@linkplain java.nio.charset.Charset charset}
*
* @return the constructed string
*/
private static String cproverOfByteArray(byte[] bytes, Charset charset)
{
String s = CProver.nondetWithoutNull("");
byte[] getBytesResult = s.cproverReversibleGetBytes(charset);
CProver.assume(getBytesResult.length == bytes.length);
for (int i = 0; i < bytes.length; i++) {
CProver.assume(bytes[i] == getBytesResult[i]);
}
return s;
}
/**
* Constructs a new {@code String} by decoding the specified array of
* bytes using the specified {@linkplain java.nio.charset.Charset charset}.
* The length of the new {@code String} is a function of the charset, and
* hence may not be equal to the length of the byte array.
*
*
This method always replaces malformed-input and unmappable-character
* sequences with this charset's default replacement string. The {@link
* java.nio.charset.CharsetDecoder} class should be used when more control
* over the decoding process is required.
*
* @param bytes
* The bytes to be decoded into characters
*
* @param charset
* The {@linkplain java.nio.charset.Charset charset} to be used to
* decode the {@code bytes}
*
* @since 1.6
*
* @diffblue.limitedSupport
* Only standard charsets are supported and for ASCII, UTF-8 and ISO-8859-1
* we restrict all the characters to be ASCII.
*/
public String(byte bytes[], Charset charset)
{
// this(bytes, 0, bytes.length, charset);
// DIFFBLUE MODEL LIBRARY
this(cproverOfByteArray(bytes, charset));
}
/**
* Constructs a new {@code String} by decoding the specified subarray of
* bytes using the platform's default charset. The length of the new
* {@code String} is a function of the charset, and hence may not be equal
* to the length of the subarray.
*
*
The behavior of this constructor when the given bytes are not valid
* in the default charset is unspecified. The {@link
* java.nio.charset.CharsetDecoder} class should be used when more control
* over the decoding process is required.
*
* @param bytes
* The bytes to be decoded into characters
*
* @param offset
* The index of the first byte to decode
*
* @param length
* The number of bytes to decode
*
* @throws IndexOutOfBoundsException
* If the {@code offset} and the {@code length} arguments index
* characters outside the bounds of the {@code bytes} array
*
* @since JDK1.1
*
* @diffblue.limitedSupport We assume all the bytes are ASCII characters,
* and that the default charset encodes ASCII characters with one byte.
*/
public String(byte bytes[], int offset, int length) {
// DIFFBLUE MODEL LIBRARY
// We initialize the string non-deterministically and add constraints on
// it, instead of using an array of characters.
this(cproverNonDet());
checkBounds(bytes, offset, length);
// DIFFBLUE MODEL LIBRARY We replace StringCoding.decode by the implementation below
// this.value = StringCoding.decode(bytes, offset, length);
CProver.assume(length() == length);
byte[] getBytesResult = cproverGetBytesEnforceAscii();
CProver.assume(getBytesResult.length == length);
for (int i = 0; i < length; i++) {
CProver.assume(bytes[i + offset] == getBytesResult[i]);
}
}
/**
* Constructs a new {@code String} by decoding the specified array of bytes
* using the platform's default charset. The length of the new {@code
* String} is a function of the charset, and hence may not be equal to the
* length of the byte array.
*
*
The behavior of this constructor when the given bytes are not valid
* in the default charset is unspecified. The {@link
* java.nio.charset.CharsetDecoder} class should be used when more control
* over the decoding process is required.
*
* @param bytes
* The bytes to be decoded into characters
*
* @since JDK1.1
*
* @diffblue.limitedSupport We assume all the bytes are ASCII characters,
* and that the default charset encodes ASCII characters with one byte.
*/
public String(byte bytes[]) {
this(bytes, 0, bytes.length);
}
/**
* Allocates a new string that contains the sequence of characters
* currently contained in the string buffer argument. The contents of the
* string buffer are copied; subsequent modification of the string buffer
* does not affect the newly created string.
*
* @param buffer
* A {@code StringBuffer}
*
* @diffblue.fullSupport
*/
public String(StringBuffer buffer) {
this(buffer.toString());
// synchronized(buffer) {
// this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
// }
}
/**
* Allocates a new string that contains the sequence of characters
* currently contained in the string builder argument. The contents of the
* string builder are copied; subsequent modification of the string builder
* does not affect the newly created string.
*
*
This constructor is provided to ease migration to {@code
* StringBuilder}. Obtaining a string from a string builder via the {@code
* toString} method is likely to run faster and is generally preferred.
*
* @param builder
* A {@code StringBuilder}
*
* @since 1.5
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public String(StringBuilder builder) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
// this.value = Arrays.copyOf(builder.getValue(), builder.length());
}
/*
* Package private constructor which shares value array for speed.
* this constructor is always expected to be called with share==true.
* a separate constructor is needed because we already have a public
* String(char[]) constructor that makes a copy of the given char[].
*/
// DIFFBLUE MODEL LIBRARY Unused package private method
// String(char[] value, boolean share) {
// // assert share : "unshared not supported";
// this.value = value;
// }
/**
* Returns the length of this string.
* The length is equal to the number of Unicode
* code units in the string.
*
* @return the length of the sequence of characters represented by this
* object.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public int length() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
// return value.length;
return CProver.nondetInt();
}
/**
* Returns {@code true} if, and only if, {@link #length()} is {@code 0}.
*
* @return {@code true} if {@link #length()} is {@code 0}, otherwise
* {@code false}
*
* @since 1.6
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public boolean isEmpty() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
// return value.length == 0;
return CProver.nondetBoolean();
}
/**
* Returns the {@code char} value at the
* specified index. An index ranges from {@code 0} to
* {@code length() - 1}. The first {@code char} value of the sequence
* is at index {@code 0}, the next at index {@code 1},
* and so on, as for array indexing.
*
*
If the {@code char} value specified by the index is a
* surrogate, the surrogate
* value is returned.
*
* @param index the index of the {@code char} value.
* @return the {@code char} value at the specified index of this string.
* The first {@code char} value is at index {@code 0}.
* @exception IndexOutOfBoundsException if the {@code index}
* argument is negative or not less than the length of this
* string.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public char charAt(int index) {
// DIFFBLUE MODEL LIBRARY
// Our implementation differs slightly from the original
// as we use the internal CProverString.charAt of CBMC,
// however the behavior is the same as the JDK version.
// if ((index < 0) || (index >= value.length)) {
// throw new StringIndexOutOfBoundsException(index);
// }
// return value[index];
if ((index < 0) || (index >= length())) {
throw new StringIndexOutOfBoundsException(index);
}
return CProverString.charAt(this, index);
}
/**
* Returns the character (Unicode code point) at the specified
* index. The index refers to {@code char} values
* (Unicode code units) and ranges from {@code 0} to
* {@link #length()}{@code - 1}.
*
*
If the {@code char} value specified at the given index
* is in the high-surrogate range, the following index is less
* than the length of this {@code String}, 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 index the index to the {@code char} values
* @return the code point value of the character at the
* {@code index}
* @exception IndexOutOfBoundsException if the {@code index}
* argument is negative or not less than the length of this
* string.
* @since 1.5
*
* @diffblue.fullSupport
* @diffblue.untested Tests only cover exception throwing
*/
public int codePointAt(int index) {
if ((index < 0) || (index >= this.length())) {
throw new StringIndexOutOfBoundsException(index);
}
// return Character.codePointAtImpl(value, index, value.length);
return CProverString.codePointAt(this, index);
}
/**
* Returns the character (Unicode code point) before the specified
* index. The index refers to {@code char} values
* (Unicode code units) and ranges from {@code 1} to {@link
* CharSequence#length() length}.
*
*
If the {@code char} value at {@code (index - 1)}
* is in the low-surrogate range, {@code (index - 2)} is not
* negative, and the {@code char} value at {@code (index -
* 2)} is in the high-surrogate range, then the
* supplementary code point value of the surrogate pair is
* returned. If the {@code char} value at {@code index -
* 1} is an unpaired low-surrogate or a high-surrogate, the
* surrogate value is returned.
*
* @param index the index following the code point that should be returned
* @return the Unicode code point value before the given index.
* @exception IndexOutOfBoundsException if the {@code index}
* argument is less than 1 or greater than the length
* of this string.
* @since 1.5
*
* @diffblue.fullSupport
*/
public int codePointBefore(int 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);
}
/**
* Returns the number of Unicode code points in the specified text
* range of this {@code String}. 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 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 IndexOutOfBoundsException if the
* {@code beginIndex} is negative, or {@code endIndex}
* is larger than the length of this {@code String}, or
* {@code beginIndex} is larger than {@code endIndex}.
* @since 1.5
*
* @diffblue.limitedSupport
* The result of this function is approximated.
* @diffblue.untested Tests only cover exception throwing
*/
public int codePointCount(int beginIndex, int endIndex) {
if (beginIndex < 0 || endIndex > this.length() || beginIndex > endIndex) {
throw new IndexOutOfBoundsException();
}
// return Character.codePointCountImpl(value, beginIndex, endIndex - beginIndex);
return CProverString.codePointCount(this, beginIndex, endIndex);
}
/**
* Returns the index within this {@code String} 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 index the index to be offset
* @param codePointOffset the offset in code points
* @return the index within this {@code String}
* @exception IndexOutOfBoundsException if {@code index}
* is negative or larger then the length of this
* {@code String}, or if {@code codePointOffset} is positive
* and the substring starting with {@code index} has fewer
* than {@code codePointOffset} code points,
* or if {@code codePointOffset} is negative and the substring
* before {@code index} has fewer than the absolute value
* of {@code codePointOffset} code points.
* @since 1.5
*
* @diffblue.limitedSupport
* 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) {
if (index < 0 || index > this.length()) {
throw new IndexOutOfBoundsException();
}
// return Character.offsetByCodePointsImpl(value, 0, value.length,
// index, codePointOffset);
return CProverString.offsetByCodePoints(this, index, codePointOffset);
}
/**
* Copy characters from this string into dst starting at dstBegin.
* This method doesn't perform any range checking.
*/
// DIFFBLUE MODEL LIBRARY Unused private method
// void getChars(char dst[], int dstBegin) {
// System.arraycopy(value, 0, dst, dstBegin, value.length);
// }
/**
* Copies characters from this string into the destination character
* array.
*
* The first character to be copied is at index {@code srcBegin};
* the last character to be copied is at index {@code srcEnd-1}
* (thus the total number of characters to be copied is
* {@code srcEnd-srcBegin}). The characters are copied into the
* subarray of {@code dst} starting at index {@code dstBegin}
* and ending at index:
*
* dstbegin + (srcEnd-srcBegin) - 1
*
*
* @param srcBegin index of the first character in the string
* to copy.
* @param srcEnd index after the last character in the string
* to copy.
* @param dst the destination array.
* @param dstBegin the start offset in the destination array.
* @exception IndexOutOfBoundsException If any of the following
* is true:
*
{@code srcBegin} is negative.
*
{@code srcBegin} is greater than {@code srcEnd}
*
{@code srcEnd} is greater than the length of this
* string
*
{@code dstBegin} is negative
*
{@code dstBegin+(srcEnd-srcBegin)} is larger than
* {@code dst.length}
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
if (srcBegin < 0) {
throw new StringIndexOutOfBoundsException(srcBegin);
}
// if (srcEnd > value.length) {
// DIFFBLUE MODEL LIBRARY we have no value member
if (srcEnd > length()) {
throw new StringIndexOutOfBoundsException(srcEnd);
}
if (srcBegin > srcEnd) {
throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
}
// System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
// DIFFBLUE MODEL LIBRARY we inline System.arraycopy here so that we
// can specialize it for characters.
for(int i = 0; i < srcEnd - srcBegin; i++) {
dst[dstBegin + i] = CProverString.charAt(this, srcBegin + i);
}
}
/**
* Copies characters from this string into the destination byte array. Each
* byte receives the 8 low-order bits of the corresponding character. The
* eight high-order bits of each character are not copied and do not
* participate in the transfer in any way.
*
*
The first character to be copied is at index {@code srcBegin}; the
* last character to be copied is at index {@code srcEnd-1}. The total
* number of characters to be copied is {@code srcEnd-srcBegin}. The
* characters, converted to bytes, are copied into the subarray of {@code
* dst} starting at index {@code dstBegin} and ending at index:
*
*
* dstbegin + (srcEnd-srcBegin) - 1
*
*
* @deprecated This method does not properly convert characters into
* bytes. As of JDK 1.1, the preferred way to do this is via the
* {@link #getBytes()} method, which uses the platform's default charset.
*
* @param srcBegin
* Index of the first character in the string to copy
*
* @param srcEnd
* Index after the last character in the string to copy
*
* @param dst
* The destination array
*
* @param dstBegin
* The start offset in the destination array
*
* @throws IndexOutOfBoundsException
* If any of the following is true:
*
*
{@code srcBegin} is negative
*
{@code srcBegin} is greater than {@code srcEnd}
*
{@code srcEnd} is greater than the length of this String
*
{@code dstBegin} is negative
*
{@code dstBegin+(srcEnd-srcBegin)} is larger than {@code
* dst.length}
*
*
* @diffblue.noSupport
*/
@Deprecated
public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {
CProver.notModelled();
// if (srcBegin < 0) {
// throw new StringIndexOutOfBoundsException(srcBegin);
// }
// if (srcEnd > value.length) {
// throw new StringIndexOutOfBoundsException(srcEnd);
// }
// if (srcBegin > srcEnd) {
// throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
// }
// Objects.requireNonNull(dst);
//
// int j = dstBegin;
// int n = srcEnd;
// int i = srcBegin;
// char[] val = value; /* avoid getfield opcode */
//
// while (i < n) {
// dst[j++] = (byte)val[i++];
// }
}
/**
* Encodes this {@code String} into a sequence of bytes using the named
* charset, storing the result into a new byte array.
*
*
The behavior of this method when this string cannot be encoded in
* the given charset is unspecified. The {@link
* java.nio.charset.CharsetEncoder} class should be used when more control
* over the encoding process is required.
*
* @param charsetName
* The name of a supported {@linkplain java.nio.charset.Charset
* charset}
*
* @return The resultant byte array
*
* @throws UnsupportedEncodingException
* If the named charset is not supported
*
* @since JDK1.1
*
* @diffblue.limitedSupport
* Works as expected when the argument equals one of the following:
*
*
"US-ASCII"
*
"UTF-16BE"
*
"UTF-16LE"
*
"UTF-16"
*
* Will enforce the string is composed of ASCII characters when the argument
* equals one of the following:
*
*
"ISO-8859-1"
*
"UTF-8"
*
* 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 {
if (charsetName == null) throw new NullPointerException();
// return StringCoding.encode(charsetName, value, 0, value.length);
if(CProverString.equals(charsetName, "US-ASCII"))
return getBytesAscii();
if(CProverString.equals(charsetName, "UTF-16BE"))
return getBytesUTF_16BE();
if(CProverString.equals(charsetName, "UTF-16LE"))
return getBytesUTF_16LE();
if(CProverString.equals(charsetName, "UTF-16"))
return getBytesUTF_16();
// DIFFBLUE MODEL LIBRARY For now these conversions are not efficient so
// we force the string to be ASCII.
// DIFFBLUE MODEL LIBRARY @diffblue.todo: Support further encodings
if(CProverString.equals(charsetName, "ISO-8859-1"))
return cproverGetBytesEnforceAscii();
CProver.assume(CProverString.equals(charsetName, "UTF-8"));
return cproverGetBytesEnforceAscii();
// DIFFBLUE MODEL LIBRARY We do not know the complete list of supported
// encodings so we cannot be sure an exception will be thrown.
// throw new java.io.UnsupportedEncodingException();
}
/**
* Encodes this {@code String} into a sequence of bytes using the given
* {@linkplain java.nio.charset.Charset charset}, storing the result into a
* new byte array.
*
*
This method always replaces malformed-input and unmappable-character
* sequences with this charset's default replacement byte array. The
* {@link java.nio.charset.CharsetEncoder} class should be used when more
* control over the encoding process is required.
*
* @param charset
* The {@linkplain java.nio.charset.Charset} to be used to encode
* the {@code String}
*
* @return The resultant byte array
*
* @since 1.6
*
* @diffblue.limitedSupport
* Works as expected if the argument is:
*
*
"US-ASCII"
*
* 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:
*
*
"UTF-16BE"
*
"UTF-16LE"
*
"UTF-16"
*
* Will enforce the string is composed of ASCII characters if the argument
* is one of the following:
*
*
"ISO-8859-1"
*
"UTF-8"
*
*
* 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) {
// if (charset == null) throw new NullPointerException();
// return StringCoding.encode(charset, value, 0, value.length);
// DIFFBLUE MODEL LIBRARY
// @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 (CProverString.equals(charset.name(), "US-ASCII")) {
return getBytesAscii();
}
if (CProverString.equals(charset.name(), "UTF-16BE")) {
return getBytesUTF_16BE();
}
if (CProverString.equals(charset.name(), "UTF-16LE")) {
return getBytesUTF_16LE();
}
if (CProverString.equals(charset.name(), "UTF-16")) {
return getBytesUTF_16();
}
// DIFFBLUE MODEL LIBRARY @diffblue.todo: Support further encodings
// (StandardCharsets.ISO_8859_1, StandardCharsets.UTF_8, ...)
CProver.assume(CProverString.equals(charset.name(), "UTF-8")
|| CProverString.equals(charset.name(), "ISO-8859-1"));
return cproverGetBytesEnforceAscii();
}
// DIFFBLUE MODELS LIBRARY
// The following private methods are utility function for our model of
// getBytes and are not present in the original implementation.
private byte[] getBytesAscii() {
int l = length();
byte result[] = new byte[l];
for(int i = 0; i < l; i++)
{
char c = CProverString.charAt(this, i);
if(c>127)
result[i] = (byte) '?';
else
result[i] = (byte) c;
}
return result;
}
// DIFFBLUE MODELS LIBRARY utility function
// This converts the String to a byte array and adds assumptions enforcing
// all characters are valid ASCII
private byte[] cproverGetBytesEnforceAscii() {
int l = length();
byte result[] = new byte[l];
for(int i = 0; i < l; i++)
{
char c = CProverString.charAt(this, i);
CProver.assume(c<=127);
result[i] = (byte) c;
}
return result;
}
// DIFFBLUE MODELS LIBRARY utility function
private byte[] getBytesISO_8859_1() {
int l = length();
byte result[] = new byte[l];
for(int i = 0; i < l; i++)
{
char c = CProverString.charAt(this, i);
if(c>255)
result[i] = (byte) '?';
else
result[i] = (byte) c;
}
return result;
}
// DIFFBLUE MODELS LIBRARY utility function
private byte[] getBytesUTF_16BE() {
int l = length();
byte result[] = new byte[2*l];
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);
}
return result;
}
// DIFFBLUE MODELS LIBRARY utility function
private byte[] getBytesUTF_16LE() {
int l = length();
byte result[] = new byte[2*l];
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);
}
return result;
}
// DIFFBLUE MODELS LIBRARY utility function
private byte[] getBytesUTF_16() {
// Like UTF_16BE with FE FF at the beginning to mark byte order
int l = length();
byte result[] = new byte[2*l+2];
result[0] = (byte) 0xFE;
result[1] = (byte) 0xFF;
for (int i = 0; i < l; i++)
{
char c = CProverString.charAt(this, i);
CProver.assume(c < '\ud800');
result[2 * i + 2] = (byte) (c >> 8);
result[2 * i + 3] = (byte) (c & 0xFF);
}
return result;
}
// DIFFBLUE MODELS LIBRARY utility function
private byte[] getBytesUTF_8() {
int l = length();
int output_size = 0;
for(int i = 0; i < l; i++)
{
int c = CProverString.charAt(this, i);
if(c>=0xD800)
{
i++;
c = 0x10000 | ((c & 0x3FF) << 10)
| (CProverString.charAt(this, i) & 0x3FF);
}
if(c<=0x7F)
output_size += 1;
else if(c<=0x7FF)
output_size += 2;
else if(c<=0xFFFF)
output_size += 3;
else
output_size += 4;
}
byte result[] = new byte[output_size];
int index = 0;
for(int i = 0; i < l; i++)
{
int c = CProverString.charAt(this, i);
if(c>=0xD800)
{
i++;
c = 0x10000 | ((c & 0x3FF) << 10)
| (CProverString.charAt(this, i) & 0x3FF);
}
if(c<=0x7F)
result[index++]=(byte)c;
else if(c<=0x7FF)
{
result[index++]=(byte)((c >> 6) | 0xC0);
result[index++]=(byte)((c & 0x3F) | 0x80);
}
else if(c<=0xFFFF)
{
result[index++]=(byte)((c >> 12) | 0xE0);
result[index++]=(byte)(((c >> 6) &0x3F) | 0x80);
result[index++]=(byte)((c & 0x3F) | 0x80);
}
else
{
result[index++]=(byte)((c >> 18) | 0xF0);
result[index++]=(byte)(((c >> 12) & 0x3F)| 0x80);
result[index++]=(byte)(((c >> 6) & 0x3F) | 0x80);
result[index++]=(byte)((c & 0x3F) | 0x80);
}
}
return result;
}
/**
* DIFFBLUE MODEL LIBRARY
* `getBytes` is not an injective function because there are several ways
* of getting `?` in some encoding. This version makes sure there is only
* one possible way to get a character, by assuming characters are ASCII
* for non-UTF-16 encodings. This is useful for models of methods which
* do the inverse transformation of getBytes.
*
* @param charsetName
* The name of the Charset used to encode the {@code String}
*/
private byte[] cproverReversibleGetBytes(String charsetName)
throws UnsupportedEncodingException
{
if (CProverString.equals(charsetName, "UTF-16BE")) {
return getBytesUTF_16BE();
}
if (CProverString.equals(charsetName, "UTF-16LE")) {
return getBytesUTF_16LE();
}
if (CProverString.equals(charsetName, "UTF-16")) {
return getBytesUTF_16();
}
if (CProverString.equals(charsetName, "UTF-8")
|| CProverString.equals(charsetName, "ISO-8859-1")
|| CProverString.equals(charsetName, "US-ASCII")) {
return cproverGetBytesEnforceAscii();
}
throw new UnsupportedEncodingException(charsetName);
}
/**
* Overload of cproverReversibleGetBytes(String charsetName) with a Charset
* parameter instead of a String.
*
* @param charset
* The {@linkplain java.nio.charset.Charset} to be used to encode
* the {@code String}
*/
private byte[] cproverReversibleGetBytes(Charset charset) {
if (charset == null) {
throw new NullPointerException();
}
try {
return cproverReversibleGetBytes(charset.name());
} catch (UnsupportedEncodingException e) {
CProver.assume(false);
return new byte[0];
}
}
/**
* Encodes this {@code String} into a sequence of bytes using the
* platform's default charset, storing the result into a new byte array.
*
*
The behavior of this method when this string cannot be encoded in
* the default charset is unspecified. The {@link
* java.nio.charset.CharsetEncoder} class should be used when more control
* over the encoding process is required.
*
* @return The resultant byte array
*
* @since JDK1.1
*
* @diffblue.limitedSupport
* We enforce all characters are ASCII and the standard encoding is one
* in which ASCII characters are encoded with one byte.
* In particular this is wrong if the standard charset is UTF16.
*/
public byte[] getBytes() {
// DIFFBLUE MODEL LIBRARY
// Instead of looking for standard charset, we enforce all characters
// are ASCII. This will be correct if the default encoding of the system
// encodes ASCII characters as one byte: this is the case of ASCII,
// UTF-8 and ISO-8859-1 but not UTF-16.
// return StringCoding.encode(value, 0, value.length);
return cproverGetBytesEnforceAscii();
}
/**
* Compares this string to the specified object. The result is {@code
* true} if and only if the argument is not {@code null} and is a {@code
* String} object that represents the same sequence of characters as this
* object.
*
* @param anObject
* The object to compare this {@code String} against
*
* @return {@code true} if the given object represents a {@code String}
* equivalent to this string, {@code false} otherwise
*
* @see #compareTo(String)
* @see #equalsIgnoreCase(String)
*
* @diffblue.fullSupport
*/
public boolean equals(Object anObject) {
// if (this == anObject) {
// return true;
// }
// if (anObject instanceof String) {
// String anotherString = (String)anObject;
// int n = value.length;
// if (n == anotherString.value.length) {
// char v1[] = value;
// char v2[] = anotherString.value;
// int i = 0;
// while (n-- != 0) {
// if (v1[i] != v2[i])
// return false;
// i++;
// }
// return true;
// }
// }
// return false;
// DIFFBLUE MODEL use a CProverString function
if (anObject instanceof String) {
return CProverString.equals((String) anObject, this);
}
return false;
}
/**
* Compares this string to the specified {@code StringBuffer}. The result
* is {@code true} if and only if this {@code String} represents the same
* sequence of characters as the specified {@code StringBuffer}. This method
* synchronizes on the {@code StringBuffer}.
*
* @param sb
* The {@code StringBuffer} to compare this {@code String} against
*
* @return {@code true} if this {@code String} represents the same
* sequence of characters as the specified {@code StringBuffer},
* {@code false} otherwise
*
* @since 1.4
*
* @diffblue.noSupport
*/
public boolean contentEquals(StringBuffer sb) {
// return contentEquals((CharSequence)sb);
CProver.notModelled();
return CProver.nondetBoolean();
}
// DIFFBLUE MODEL LIBRARY Unused private method
// private boolean nonSyncContentEquals(AbstractStringBuilder sb) {
// char v1[] = value;
// char v2[] = sb.getValue();
// int n = v1.length;
// if (n != sb.length()) {
// return false;
// }
// for (int i = 0; i < n; i++) {
// if (v1[i] != v2[i]) {
// return false;
// }
// }
// return true;
// }
/**
* Compares this string to the specified {@code CharSequence}. The
* result is {@code true} if and only if this {@code String} represents the
* same sequence of char values as the specified sequence. Note that if the
* {@code CharSequence} is a {@code StringBuffer} then the method
* synchronizes on it.
*
* @param cs
* The sequence to compare this {@code String} against
*
* @return {@code true} if this {@code String} represents the same
* sequence of char values as the specified sequence, {@code
* false} otherwise
*
* @since 1.5
*
* @diffblue.noSupport
* @diffblue.todo implement internally in CBMC
*/
public boolean contentEquals(CharSequence cs) {
CProver.notModelled();
return CProver.nondetBoolean();
// // Argument is a StringBuffer, StringBuilder
// if (cs instanceof AbstractStringBuilder) {
// if (cs instanceof StringBuffer) {
// synchronized(cs) {
// return nonSyncContentEquals((AbstractStringBuilder)cs);
// }
// } else {
// return nonSyncContentEquals((AbstractStringBuilder)cs);
// }
// }
// // Argument is a String
// if (cs.equals(this))
// return true;
// // Argument is a generic CharSequence
// char v1[] = value;
// int n = v1.length;
// if (n != cs.length()) {
// return false;
// }
// for (int i = 0; i < n; i++) {
// if (v1[i] != cs.charAt(i)) {
// return false;
// }
// }
// return true;
}
/**
* Compares this {@code String} to another {@code String}, ignoring case
* considerations. Two strings are considered equal ignoring case if they
* are of the same length and corresponding characters in the two strings
* are equal ignoring case.
*
*
Two characters {@code c1} and {@code c2} are considered the same
* ignoring case if at least one of the following is true:
*
*
The two characters are the same (as compared by the
* {@code ==} operator)
*
Applying the method {@link
* java.lang.Character#toUpperCase(char)} to each character
* produces the same result
*
Applying the method {@link
* java.lang.Character#toLowerCase(char)} to each character
* produces the same result
*
*
* @param anotherString
* The {@code String} to compare this {@code String} against
*
* @return {@code true} if the argument is not {@code null} and it
* represents an equivalent {@code String} ignoring case; {@code
* false} otherwise
*
* @see #equals(Object)
*
* @diffblue.limitedSupport
* This may not be correct for the case where the argument can be null.
* @diffblue.untested
*/
public boolean equalsIgnoreCase(String anotherString) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetBoolean();
// return (this == anotherString) ? true
// : (anotherString != null)
// && (anotherString.value.length == value.length)
// && regionMatches(true, 0, anotherString, 0, value.length);
}
/**
* Compares two strings lexicographically.
* The comparison is based on the Unicode value of each character in
* the strings. The character sequence represented by this
* {@code String} object is compared lexicographically to the
* character sequence represented by the argument string. The result is
* a negative integer if this {@code String} object
* lexicographically precedes the argument string. The result is a
* positive integer if this {@code String} object lexicographically
* follows the argument string. The result is zero if the strings
* are equal; {@code compareTo} returns {@code 0} exactly when
* the {@link #equals(Object)} method would return {@code true}.
*
* This is the definition of lexicographic ordering. If two strings are
* different, then either they have different characters at some index
* that is a valid index for both strings, or their lengths are different,
* or both. If they have different characters at one or more index
* positions, let k be the smallest such index; then the string
* whose character at position k has the smaller value, as
* determined by using the < operator, lexicographically precedes the
* other string. In this case, {@code compareTo} returns the
* difference of the two character values at position {@code k} in
* the two string -- that is, the value:
*
* this.charAt(k)-anotherString.charAt(k)
*
* If there is no index position at which they differ, then the shorter
* string lexicographically precedes the longer string. In this case,
* {@code compareTo} returns the difference of the lengths of the
* strings -- that is, the value:
*
* this.length()-anotherString.length()
*
*
* @param anotherString the {@code String} to be compared.
* @return the value {@code 0} if the argument string is equal to
* this string; a value less than {@code 0} if this string
* is lexicographically less than the string argument; and a
* value greater than {@code 0} if this string is
* lexicographically greater than the string argument.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public int compareTo(String anotherString) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetInt();
// int len1 = value.length;
// int len2 = anotherString.value.length;
// int lim = Math.min(len1, len2);
// char v1[] = value;
// char v2[] = anotherString.value;
//
// int k = 0;
// while (k < lim) {
// char c1 = v1[k];
// char c2 = v2[k];
// if (c1 != c2) {
// return c1 - c2;
// }
// k++;
// }
// return len1 - len2;
}
/**
* A Comparator that orders {@code String} objects as by
* {@code compareToIgnoreCase}. This comparator is serializable.
*
* Note that this Comparator does not take locale into account,
* and will result in an unsatisfactory ordering for certain locales.
* The java.text package provides Collators to allow
* locale-sensitive ordering.
*
* @see java.text.Collator#compare(String, String)
* @since 1.2
*
* @diffblue.noSupport
* @diffblue.untested
*/
// public static final Comparator 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 CASE_INSENSITIVE_ORDER
= CProver.nondetWithoutNullForNotModelled();
// DIFFBLUE MODEL LIBRARY Not needed for modelling
// private static class CaseInsensitiveComparator
// implements Comparator, java.io.Serializable {
// // use serialVersionUID from JDK 1.2.2 for interoperability
// private static final long serialVersionUID = 8575799808933029326L;
//
// public int compare(String s1, String s2) {
// int n1 = s1.length();
// int n2 = s2.length();
// int min = Math.min(n1, n2);
// for (int i = 0; i < min; i++) {
// char c1 = s1.charAt(i);
// char c2 = s2.charAt(i);
// if (c1 != c2) {
// c1 = Character.toUpperCase(c1);
// c2 = Character.toUpperCase(c2);
// if (c1 != c2) {
// c1 = Character.toLowerCase(c1);
// c2 = Character.toLowerCase(c2);
// if (c1 != c2) {
// // No overflow because of numeric promotion
// return c1 - c2;
// }
// }
// }
// }
// return n1 - n2;
// }
//
// /** Replaces the de-serialized object. */
// private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
// }
/**
* Compares two strings lexicographically, ignoring case
* differences. This method returns an integer whose sign is that of
* calling {@code compareTo} with normalized versions of the strings
* where case differences have been eliminated by calling
* {@code Character.toLowerCase(Character.toUpperCase(character))} on
* each character.
*
* Note that this method does not take locale into account,
* and will result in an unsatisfactory ordering for certain locales.
* The java.text package provides collators to allow
* locale-sensitive ordering.
*
* @param str the {@code String} to be compared.
* @return a negative integer, zero, or a positive integer as the
* specified String is greater than, equal to, or less
* than this String, ignoring case considerations.
* @see java.text.Collator#compare(String, String)
* @since 1.2
*
* @diffblue.noSupport
*/
public int compareToIgnoreCase(String str) {
CProver.notModelled();
return CProver.nondetInt();
// return CASE_INSENSITIVE_ORDER.compare(this, str);
}
/**
* Tests if two string regions are equal.
*
* A substring of this {@code String} object is compared to a substring
* of the argument other. The result is true if these substrings
* represent identical character sequences. The substring of this
* {@code String} object to be compared begins at index {@code toffset}
* and has length {@code len}. The substring of other to be compared
* begins at index {@code ooffset} and has length {@code len}. The
* result is {@code false} if and only if at least one of the following
* is true:
*
{@code toffset} is negative.
*
{@code ooffset} is negative.
*
{@code toffset+len} is greater than the length of this
* {@code String} object.
*
{@code ooffset+len} is greater than the length of the other
* argument.
*
There is some nonnegative integer k less than {@code len}
* such that:
* {@code this.charAt(toffset + }k{@code ) != other.charAt(ooffset + }
* k{@code )}
*
*
* @param toffset the starting offset of the subregion in this string.
* @param other the string argument.
* @param ooffset the starting offset of the subregion in the string
* argument.
* @param len the number of characters to compare.
* @return {@code true} if the specified subregion of this string
* exactly matches the specified subregion of the string argument;
* {@code false} otherwise.
*
* @diffblue.noSupport
*/
public boolean regionMatches(int toffset, String other, int ooffset,
int len) {
CProver.notModelled();
return CProver.nondetBoolean();
// char ta[] = value;
// int to = toffset;
// char pa[] = other.value;
// int po = ooffset;
// // Note: toffset, ooffset, or len might be near -1>>>1.
// if ((ooffset < 0) || (toffset < 0)
// || (toffset > (long)value.length - len)
// || (ooffset > (long)other.value.length - len)) {
// return false;
// }
// while (len-- > 0) {
// if (ta[to++] != pa[po++]) {
// return false;
// }
// }
// return true;
}
/**
* Tests if two string regions are equal.
*
* A substring of this {@code String} object is compared to a substring
* of the argument {@code other}. The result is {@code true} if these
* substrings represent character sequences that are the same, ignoring
* case if and only if {@code ignoreCase} is true. The substring of
* this {@code String} object to be compared begins at index
* {@code toffset} and has length {@code len}. The substring of
* {@code other} to be compared begins at index {@code ooffset} and
* has length {@code len}. The result is {@code false} if and only if
* at least one of the following is true:
*
{@code toffset} is negative.
*
{@code ooffset} is negative.
*
{@code toffset+len} is greater than the length of this
* {@code String} object.
*
{@code ooffset+len} is greater than the length of the other
* argument.
*
{@code ignoreCase} is {@code false} and there is some nonnegative
* integer k less than {@code len} such that:
*
*
* @param ignoreCase if {@code true}, ignore case when comparing
* characters.
* @param toffset the starting offset of the subregion in this
* string.
* @param other the string argument.
* @param ooffset the starting offset of the subregion in the string
* argument.
* @param len the number of characters to compare.
* @return {@code true} if the specified subregion of this string
* matches the specified subregion of the string argument;
* {@code false} otherwise. Whether the matching is exact
* or case insensitive depends on the {@code ignoreCase}
* argument.
*
* @diffblue.noSupport
*/
public boolean regionMatches(boolean ignoreCase, int toffset,
String other, int ooffset, int len) {
CProver.notModelled();
return CProver.nondetBoolean();
// char ta[] = value;
// int to = toffset;
// char pa[] = other.value;
// int po = ooffset;
// // Note: toffset, ooffset, or len might be near -1>>>1.
// if ((ooffset < 0) || (toffset < 0)
// || (toffset > (long)value.length - len)
// || (ooffset > (long)other.value.length - len)) {
// return false;
// }
// while (len-- > 0) {
// char c1 = ta[to++];
// char c2 = pa[po++];
// if (c1 == c2) {
// continue;
// }
// if (ignoreCase) {
// // If characters don't match but case may be ignored,
// // try converting both characters to uppercase.
// // If the results match, then the comparison scan should
// // continue.
// char u1 = Character.toUpperCase(c1);
// char u2 = Character.toUpperCase(c2);
// if (u1 == u2) {
// continue;
// }
// // Unfortunately, conversion to uppercase does not work properly
// // for the Georgian alphabet, which has strange rules about case
// // conversion. So we need to make one last check before
// // exiting.
// if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
// continue;
// }
// }
// return false;
// }
// return true;
}
/**
* Tests if the substring of this string beginning at the
* specified index starts with the specified prefix.
*
* @param prefix the prefix.
* @param toffset where to begin looking in this string.
* @return {@code true} if the character sequence represented by the
* argument is a prefix of the substring of this object starting
* at index {@code toffset}; {@code false} otherwise.
* The result is {@code false} if {@code toffset} is
* negative or greater than the length of this
* {@code String} object; otherwise the result is the same
* as the result of the expression
*
* this.substring(toffset).startsWith(prefix)
*
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public boolean startsWith(String prefix, int toffset) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetBoolean();
// char ta[] = value;
// int to = toffset;
// char pa[] = prefix.value;
// int po = 0;
// int pc = prefix.value.length;
// // Note: toffset might be near -1>>>1.
// if ((toffset < 0) || (toffset > value.length - pc)) {
// return false;
// }
// while (--pc >= 0) {
// if (ta[to++] != pa[po++]) {
// return false;
// }
// }
// return true;
}
/**
* Tests if this string starts with the specified prefix.
*
* @param prefix the prefix.
* @return {@code true} if the character sequence represented by the
* argument is a prefix of the character sequence represented by
* this string; {@code false} otherwise.
* Note also that {@code true} will be returned if the
* argument is an empty string or is equal to this
* {@code String} object as determined by the
* {@link #equals(Object)} method.
* @since 1. 0
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public boolean startsWith(String prefix) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetBoolean();
// return startsWith(prefix, 0);
}
/**
* Tests if this string ends with the specified suffix.
*
* @param suffix the suffix.
* @return {@code true} if the character sequence represented by the
* argument is a suffix of the character sequence represented by
* this object; {@code false} otherwise. Note that the
* result will be {@code true} if the argument is the
* empty string or is equal to this {@code String} object
* as determined by the {@link #equals(Object)} method.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public boolean endsWith(String suffix) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetBoolean();
// return startsWith(suffix, value.length - suffix.value.length);
}
/**
* Returns a hash code for this string. The hash code for a
* {@code String} object is computed as
*
* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
*
* using {@code int} arithmetic, where {@code s[i]} is the
* ith character of the string, {@code n} is the length of
* the string, and {@code ^} indicates exponentiation.
* (The hash value of the empty string is zero.)
*
* @return a hash code value for this object.
*
* @diffblue.fullSupport length of the string is limited by unwind value
*/
public int hashCode() {
// DIFFBLUE MODEL LIBRARY
// int h = hash;
// if (h == 0 && value.length > 0) {
// char val[] = value;
//
// for (int i = 0; i < value.length; i++) {
// h = 31 * h + val[i];
// }
// hash = h;
// }
// return h;
int len = length();
int h = 0;
for (int i = 0; i < len; i++) {
h = 31 * h + CProverString.charAt(this, i);
}
return h;
}
/**
* Returns the index within this string of the first occurrence of
* the specified character. If a character with value
* {@code ch} occurs in the character sequence represented by
* this {@code String} object, then the index (in Unicode
* code units) of the first such occurrence is returned. For
* values of {@code ch} in the range from 0 to 0xFFFF
* (inclusive), this is the smallest value k such that:
*
* this.charAt(k) == ch
*
* is true. For other values of {@code ch}, it is the
* smallest value k such that:
*
* this.codePointAt(k) == ch
*
* is true. In either case, if no such character occurs in this
* string, then {@code -1} is returned.
*
* @param ch a character (Unicode code point).
* @return the index of the first occurrence of the character in the
* character sequence represented by this object, or
* {@code -1} if the character does not occur.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public int indexOf(int ch) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetInt();
// return indexOf(ch, 0);
}
/**
* Returns the index within this string of the first occurrence of the
* specified character, starting the search at the specified index.
*
* If a character with value {@code ch} occurs in the
* character sequence represented by this {@code String}
* object at an index no smaller than {@code fromIndex}, then
* the index of the first such occurrence is returned. For values
* of {@code ch} in the range from 0 to 0xFFFF (inclusive),
* this is the smallest value k such that:
*
* is true. In either case, if no such character occurs in this
* string at or after position {@code fromIndex}, then
* {@code -1} is returned.
*
*
* There is no restriction on the value of {@code fromIndex}. If it
* is negative, it has the same effect as if it were zero: this entire
* string may be searched. If it is greater than the length of this
* string, it has the same effect as if it were equal to the length of
* this string: {@code -1} is returned.
*
*
All indices are specified in {@code char} values
* (Unicode code units).
*
* @param ch a character (Unicode code point).
* @param fromIndex the index to start the search from.
* @return the index of the first occurrence of the character in the
* character sequence represented by this object that is greater
* than or equal to {@code fromIndex}, or {@code -1}
* if the character does not occur.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public int indexOf(int ch, int fromIndex) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetInt();
// final int max = value.length;
// if (fromIndex < 0) {
// fromIndex = 0;
// } else if (fromIndex >= max) {
// // Note: fromIndex might be near -1>>>1.
// return -1;
// }
//
// if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
// // handle most cases here (ch is a BMP code point or a
// // negative value (invalid code point))
// final char[] value = this.value;
// for (int i = fromIndex; i < max; i++) {
// if (value[i] == ch) {
// return i;
// }
// }
// return -1;
// } else {
// return indexOfSupplementary(ch, fromIndex);
// }
}
/**
* Handles (rare) calls of indexOf with a supplementary character.
*/
// DIFFBLUE MODEL LIBRARY Unused private method
// private int indexOfSupplementary(int ch, int fromIndex) {
// if (Character.isValidCodePoint(ch)) {
// final char[] value = this.value;
// final char hi = Character.highSurrogate(ch);
// final char lo = Character.lowSurrogate(ch);
// final int max = value.length - 1;
// for (int i = fromIndex; i < max; i++) {
// if (value[i] == hi && value[i + 1] == lo) {
// return i;
// }
// }
// }
// return -1;
// }
/**
* Returns the index within this string of the last occurrence of
* the specified character. For values of {@code ch} in the
* range from 0 to 0xFFFF (inclusive), the index (in Unicode code
* units) returned is the largest value k such that:
*
* this.charAt(k) == ch
*
* is true. For other values of {@code ch}, it is the
* largest value k such that:
*
* this.codePointAt(k) == ch
*
* is true. In either case, if no such character occurs in this
* string, then {@code -1} is returned. The
* {@code String} is searched backwards starting at the last
* character.
*
* @param ch a character (Unicode code point).
* @return the index of the last occurrence of the character in the
* character sequence represented by this object, or
* {@code -1} if the character does not occur.
*
* @diffblue.limitedSupport
* This is not correct for supplementary code points.
* @diffblue.untested
*/
public int lastIndexOf(int ch) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetInt();
// return lastIndexOf(ch, value.length - 1);
}
/**
* Returns the index within this string of the last occurrence of
* the specified character, searching backward starting at the
* specified index. For values of {@code ch} in the range
* from 0 to 0xFFFF (inclusive), the index returned is the largest
* value k such that:
*
* is true. In either case, if no such character occurs in this
* string at or before position {@code fromIndex}, then
* {@code -1} is returned.
*
*
All indices are specified in {@code char} values
* (Unicode code units).
*
* @param ch a character (Unicode code point).
* @param fromIndex the index to start the search from. There is no
* restriction on the value of {@code fromIndex}. If it is
* greater than or equal to the length of this string, it has
* the same effect as if it were equal to one less than the
* length of this string: this entire string may be searched.
* If it is negative, it has the same effect as if it were -1:
* -1 is returned.
* @return the index of the last occurrence of the character in the
* character sequence represented by this object that is less
* than or equal to {@code fromIndex}, or {@code -1}
* if the character does not occur before that point.
*
* @diffblue.limitedSupport
* This is not correct for supplementary code points.
*/
public int lastIndexOf(int ch, int fromIndex) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetInt();
// if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
// // handle most cases here (ch is a BMP code point or a
// // negative value (invalid code point))
// final char[] value = this.value;
// int i = Math.min(fromIndex, value.length - 1);
// for (; i >= 0; i--) {
// if (value[i] == ch) {
// return i;
// }
// }
// return -1;
// } else {
// return lastIndexOfSupplementary(ch, fromIndex);
// }
}
/**
* Handles (rare) calls of lastIndexOf with a supplementary character.
*/
// DIFFBLUE MODEL LIBRARY Unused private method
// private int lastIndexOfSupplementary(int ch, int fromIndex) {
// if (Character.isValidCodePoint(ch)) {
// final char[] value = this.value;
// char hi = Character.highSurrogate(ch);
// char lo = Character.lowSurrogate(ch);
// int i = Math.min(fromIndex, value.length - 2);
// for (; i >= 0; i--) {
// if (value[i] == hi && value[i + 1] == lo) {
// return i;
// }
// }
// }
// return -1;
// }
/**
* Returns the index within this string of the first occurrence of the
* specified substring.
*
*
The returned index is the smallest value k for which:
*
* this.startsWith(str, k)
*
* If no such value of k exists, then {@code -1} is returned.
*
* @param str the substring to search for.
* @return the index of the first occurrence of the specified substring,
* or {@code -1} if there is no such occurrence.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public int indexOf(String str) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetInt();
// return indexOf(str, 0);
}
/**
* Returns the index within this string of the first occurrence of the
* specified substring, starting at the specified index.
*
*
The returned index is the smallest value k for which:
*
* k >= fromIndex {@code &&} this.startsWith(str, k)
*
* If no such value of k exists, then {@code -1} is returned.
*
* @param str the substring to search for.
* @param fromIndex the index from which to start the search.
* @return the index of the first occurrence of the specified substring,
* starting at the specified index,
* or {@code -1} if there is no such occurrence.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public int indexOf(String str, int fromIndex) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetInt();
// return indexOf(value, 0, value.length,
// str.value, 0, str.value.length, fromIndex);
}
/**
* Code shared by String and AbstractStringBuilder to do searches. The
* source is the character array being searched, and the target
* is the string being searched for.
*
* @param source the characters being searched.
* @param sourceOffset offset of the source string.
* @param sourceCount count of the source string.
* @param target the characters being searched for.
* @param fromIndex the index to begin searching from.
*
* @diffblue.noSupport
*/
static int indexOf(char[] source, int sourceOffset, int sourceCount,
String target, int fromIndex) {
CProver.notModelled();
return CProver.nondetInt();
// return indexOf(source, sourceOffset, sourceCount,
// target.value, 0, target.value.length,
// fromIndex);
}
/**
* Code shared by String and StringBuffer to do searches. The
* source is the character array being searched, and the target
* is the string being searched for.
*
* @param source the characters being searched.
* @param sourceOffset offset of the source string.
* @param sourceCount count of the source string.
* @param target the characters being searched for.
* @param targetOffset offset of the target string.
* @param targetCount count of the target string.
* @param fromIndex the index to begin searching from.
*
* @diffblue.noSupport
*/
static int indexOf(char[] source, int sourceOffset, int sourceCount,
char[] target, int targetOffset, int targetCount,
int fromIndex) {
CProver.notModelled();
return CProver.nondetInt();
// if (fromIndex >= sourceCount) {
// return (targetCount == 0 ? sourceCount : -1);
// }
// if (fromIndex < 0) {
// fromIndex = 0;
// }
// if (targetCount == 0) {
// return fromIndex;
// }
//
// char first = target[targetOffset];
// int max = sourceOffset + (sourceCount - targetCount);
//
// for (int i = sourceOffset + fromIndex; i <= max; i++) {
// /* Look for first character. */
// if (source[i] != first) {
// while (++i <= max && source[i] != first);
// }
//
// /* Found first character, now look at the rest of v2 */
// if (i <= max) {
// int j = i + 1;
// int end = j + targetCount - 1;
// for (int k = targetOffset + 1; j < end && source[j]
// == target[k]; j++, k++);
//
// if (j == end) {
// /* Found whole string. */
// return i - sourceOffset;
// }
// }
// }
// return -1;
}
/**
* Returns the index within this string of the last occurrence of the
* specified substring. The last occurrence of the empty string ""
* is considered to occur at the index value {@code this.length()}.
*
*
The returned index is the largest value k for which:
*
* this.startsWith(str, k)
*
* If no such value of k exists, then {@code -1} is returned.
*
* @param str the substring to search for.
* @return the index of the last occurrence of the specified substring,
* or {@code -1} if there is no such occurrence.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public int lastIndexOf(String str) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetInt();
// return lastIndexOf(str, value.length);
}
/**
* Returns the index within this string of the last occurrence of the
* specified substring, searching backward starting at the specified index.
*
*
The returned index is the largest value k for which:
*
* k {@code <=} fromIndex {@code &&} this.startsWith(str, k)
*
* If no such value of k exists, then {@code -1} is returned.
*
* @param str the substring to search for.
* @param fromIndex the index to start the search from.
* @return the index of the last occurrence of the specified substring,
* searching backward from the specified index,
* or {@code -1} if there is no such occurrence.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public int lastIndexOf(String str, int fromIndex) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetInt();
// return lastIndexOf(value, 0, value.length,
// str.value, 0, str.value.length, fromIndex);
}
/**
* Code shared by String and AbstractStringBuilder to do searches. The
* source is the character array being searched, and the target
* is the string being searched for.
*
* @param source the characters being searched.
* @param sourceOffset offset of the source string.
* @param sourceCount count of the source string.
* @param target the characters being searched for.
* @param fromIndex the index to begin searching from.
*
* @diffblue.noSupport
*/
static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
String target, int fromIndex) {
CProver.notModelled();
return CProver.nondetInt();
// return lastIndexOf(source, sourceOffset, sourceCount,
// target.value, 0, target.value.length,
// fromIndex);
}
/**
* Code shared by String and StringBuffer to do searches. The
* source is the character array being searched, and the target
* is the string being searched for.
*
* @param source the characters being searched.
* @param sourceOffset offset of the source string.
* @param sourceCount count of the source string.
* @param target the characters being searched for.
* @param targetOffset offset of the target string.
* @param targetCount count of the target string.
* @param fromIndex the index to begin searching from.
*
* @diffblue.noSupport
*/
static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
char[] target, int targetOffset, int targetCount,
int fromIndex) {
CProver.notModelled();
return CProver.nondetInt();
// /*
// * Check arguments; return immediately where possible. For
// * consistency, don't check for null str.
// */
// int rightIndex = sourceCount - targetCount;
// if (fromIndex < 0) {
// return -1;
// }
// if (fromIndex > rightIndex) {
// fromIndex = rightIndex;
// }
// /* Empty string always matches. */
// if (targetCount == 0) {
// return fromIndex;
// }
//
// int strLastIndex = targetOffset + targetCount - 1;
// char strLastChar = target[strLastIndex];
// int min = sourceOffset + targetCount - 1;
// int i = min + fromIndex;
//
// startSearchForLastChar:
// while (true) {
// while (i >= min && source[i] != strLastChar) {
// i--;
// }
// if (i < min) {
// return -1;
// }
// int j = i - 1;
// int start = j - (targetCount - 1);
// int k = strLastIndex - 1;
//
// while (j > start) {
// if (source[j--] != target[k--]) {
// i--;
// continue startSearchForLastChar;
// }
// }
// return start - sourceOffset + 1;
// }
}
/**
* Returns a string that is a substring of this string. The
* substring begins with the character at the specified index and
* extends to the end of this string.
*
* @param beginIndex the beginning index, inclusive.
* @return the specified substring.
* @exception IndexOutOfBoundsException if
* {@code beginIndex} is negative or larger than the
* length of this {@code String} object.
*
* @diffblue.fullSupport
* @diffblue.untested Only exception throwing is tested.
*/
public String substring(int beginIndex) {
// DIFFBLUE MODEL LIBRARY
// Our implementation differs from the original
// in that we use the internal CProverString.substring.
// However the behavior is the same as the JDK version.
// if (beginIndex < 0) {
// throw new StringIndexOutOfBoundsException(beginIndex);
// }
// int subLen = value.length - beginIndex;
// if (subLen < 0) {
// throw new StringIndexOutOfBoundsException(subLen);
// }
// return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = length() - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return CProverString.substring(this, beginIndex);
}
/**
* Returns a string that is a substring of this string. The
* substring begins at the specified {@code beginIndex} and
* extends to the character at index {@code endIndex - 1}.
* Thus the length of the substring is {@code endIndex-beginIndex}.
*
*
* @param beginIndex the beginning index, inclusive.
* @param endIndex the ending index, exclusive.
* @return the specified substring.
* @exception IndexOutOfBoundsException if the
* {@code beginIndex} is negative, or
* {@code endIndex} is larger than the length of
* this {@code String} object, or
* {@code beginIndex} is larger than
* {@code endIndex}.
*
* @diffblue.fullSupport
* @diffblue.untested Only exception throwing is tested.
*/
public String substring(int beginIndex, int endIndex) {
// DIFFBLUE MODEL LIBRARY
// Our implementation differs from the original
// in that we use the internal CProverString.substring.
// However the behavior is the same as the JDK version.
// if (beginIndex < 0) {
// throw new StringIndexOutOfBoundsException(beginIndex);
// }
// if (endIndex > value.length) {
// throw new StringIndexOutOfBoundsException(endIndex);
// }
// int subLen = endIndex - beginIndex;
// if (subLen < 0) {
// throw new StringIndexOutOfBoundsException(subLen);
// }
// return ((beginIndex == 0) && (endIndex == value.length)) ? this
// : new String(value, beginIndex, subLen);
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > length()) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
// 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);
}
/**
* Returns a character sequence that is a subsequence of this sequence.
*
*
An invocation of this method of the form
*
*
* str.subSequence(begin, end)
*
* behaves in exactly the same way as the invocation
*
*
* str.substring(begin, end)
*
* @apiNote
* This method is defined so that the {@code String} class can implement
* the {@link CharSequence} interface.
*
* @param beginIndex the begin index, inclusive.
* @param endIndex the end index, exclusive.
* @return the specified subsequence.
*
* @throws IndexOutOfBoundsException
* if {@code beginIndex} or {@code endIndex} is negative,
* if {@code endIndex} is greater than {@code length()},
* or if {@code beginIndex} is greater than {@code endIndex}
*
* @since 1.4
* @spec JSR-51
*
* @diffblue.fullSupport
* @diffblue.untested Only exception throwing is tested
*/
public CharSequence subSequence(int beginIndex, int endIndex) {
return this.substring(beginIndex, endIndex);
}
/**
* Concatenates the specified string to the end of this string.
*
* If the length of the argument string is {@code 0}, then this
* {@code String} object is returned. Otherwise, a
* {@code String} object is returned that represents a character
* sequence that is the concatenation of the character sequence
* represented by this {@code String} object and the character
* sequence represented by the argument string.
*
* @param str the {@code String} that is concatenated to the end
* of this {@code String}.
* @return a string that represents the concatenation of this object's
* characters followed by the string argument's characters.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public String concat(String str) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetWithNullForNotModelled();
// int otherLen = str.length();
// if (otherLen == 0) {
// return this;
// }
// int len = value.length;
// char buf[] = Arrays.copyOf(value, len + otherLen);
// str.getChars(buf, len);
// return new String(buf, true);
}
/**
* Returns a string resulting from replacing all occurrences of
* {@code oldChar} in this string with {@code newChar}.
*
* If the character {@code oldChar} does not occur in the
* character sequence represented by this {@code String} object,
* then a reference to this {@code String} object is returned.
* Otherwise, a {@code String} object is returned that
* represents a character sequence identical to the character sequence
* represented by this {@code String} object, except that every
* occurrence of {@code oldChar} is replaced by an occurrence
* of {@code newChar}.
*
* Examples:
*
* "mesquite in your cellar".replace('e', 'o')
* returns "mosquito in your collar"
* "the war of baronets".replace('r', 'y')
* returns "the way of bayonets"
* "sparring with a purple porpoise".replace('p', 't')
* returns "starring with a turtle tortoise"
* "JonL".replace('q', 'x') returns "JonL" (no change)
*
*
* @param oldChar the old character.
* @param newChar the new character.
* @return a string derived from this string by replacing every
* occurrence of {@code oldChar} with {@code newChar}.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public String replace(char oldChar, char newChar) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetWithNullForNotModelled();
// if (oldChar != newChar) {
// int len = value.length;
// int i = -1;
// char[] val = value; /* avoid getfield opcode */
//
// while (++i < len) {
// if (val[i] == oldChar) {
// break;
// }
// }
// if (i < len) {
// char buf[] = new char[len];
// for (int j = 0; j < i; j++) {
// buf[j] = val[j];
// }
// while (i < len) {
// char c = val[i];
// buf[i] = (c == oldChar) ? newChar : c;
// i++;
// }
// return new String(buf, true);
// }
// }
// return this;
}
/**
* Tells whether or not this string matches the given regular expression.
*
*
An invocation of this method of the form
* str{@code .matches(}regex{@code )} yields exactly the
* same result as the expression
*
*
*
* @param regex
* the regular expression to which this string is to be matched
*
* @return {@code true} if, and only if, this string matches the
* given regular expression
*
* @throws PatternSyntaxException
* if the regular expression's syntax is invalid
*
* @see java.util.regex.Pattern
*
* @since 1.4
* @spec JSR-51
*
* @diffblue.noSupport
*/
public boolean matches(String regex) {
CProver.notModelled();
return CProver.nondetBoolean();
// return Pattern.matches(regex, this);
}
/**
* Returns true if and only if this string contains the specified
* sequence of char values.
*
* @param s the sequence to search for
* @return true if this string contains {@code s}, false otherwise
* @since 1.5
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public boolean contains(CharSequence s) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetBoolean();
// return indexOf(s.toString()) > -1;
}
/**
* Replaces the first substring of this string that matches the given regular expression with the
* given replacement.
*
*
An invocation of this method of the form
* str{@code .replaceFirst(}regex{@code ,} repl{@code )}
* yields exactly the same result as the expression
*
*
* Note that backslashes ({@code \}) and dollar signs ({@code $}) in the
* replacement string may cause the results to be different than if it were
* being treated as a literal replacement string; see
* {@link java.util.regex.Matcher#replaceFirst}.
* Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special
* meaning of these characters, if desired.
*
* @param regex
* the regular expression to which this string is to be matched
* @param replacement
* the string to be substituted for the first match
*
* @return The resulting {@code String}
*
* @throws PatternSyntaxException
* if the regular expression's syntax is invalid
*
* @see java.util.regex.Pattern
*
* @since 1.4
* @spec JSR-51
*
* @diffblue.noSupport
*/
public String replaceFirst(String regex, String replacement) {
CProver.notModelled();
return CProver.nondetWithNullForNotModelled();
// return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
}
/**
* Replaces each substring of this string that matches the given regular expression with the
* given replacement.
*
*
An invocation of this method of the form
* str{@code .replaceAll(}regex{@code ,} repl{@code )}
* yields exactly the same result as the expression
*
*
* Note that backslashes ({@code \}) and dollar signs ({@code $}) in the
* replacement string may cause the results to be different than if it were
* being treated as a literal replacement string; see
* {@link java.util.regex.Matcher#replaceAll Matcher.replaceAll}.
* Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special
* meaning of these characters, if desired.
*
* @param regex
* the regular expression to which this string is to be matched
* @param replacement
* the string to be substituted for each match
*
* @return The resulting {@code String}
*
* @throws PatternSyntaxException
* if the regular expression's syntax is invalid
*
* @see java.util.regex.Pattern
*
* @since 1.4
* @spec JSR-51
*
* @diffblue.limitedSupport
* We enforce the regex argument is a string literal without any special
* characters used in regular expressions:
* '[', ']','.', '\\', '?', '^', '$', '*', '+', '{', '}', '|', '(', ')',
* hence PatternSyntaxException will never be thrown.
*/
public String replaceAll(String regex, String replacement)
{
// return Pattern.compile(regex).matcher(this).replaceAll(replacement);
// DIFFBLUE MODELS LIBRARY: we assume the expression is just a string literal
CProver.assume(
regex.indexOf('[') == -1 &&
regex.indexOf(']') == -1 &&
regex.indexOf('.') == -1 &&
regex.indexOf('\\') == -1 &&
regex.indexOf('?') == -1 &&
regex.indexOf('^') == -1 &&
regex.indexOf('$') == -1 &&
regex.indexOf('*') == -1 &&
regex.indexOf('+') == -1 &&
regex.indexOf('{') == -1 &&
regex.indexOf('}') == -1 &&
regex.indexOf('|') == -1 &&
regex.indexOf('(') == -1 &&
regex.indexOf(')') == -1);
return replace(regex, replacement);
}
/**
* Replaces each substring of this string that matches the literal target
* sequence with the specified literal replacement sequence. The
* replacement proceeds from the beginning of the string to the end, for
* example, replacing "aa" with "b" in the string "aaa" will result in
* "ba" rather than "ab".
*
* @param target The sequence of char values to be replaced
* @param replacement The replacement sequence of char values
* @return The resulting string
* @since 1.5
*
* @diffblue.limitedSupport
* Only works for arguments that are constant strings with only 1 character.
* For instance, we can generate traces for s.replace("a", "b") but not
* s.replace("a", "bc") or s.replace(arg, "b").
* @diffblue.untested
*/
public String replace(CharSequence target, CharSequence replacement) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetWithNullForNotModelled();
// return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
// this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}
/**
* Splits this string around matches of the given
* regular expression.
*
*
The array returned by this method contains each substring of this
* string that is terminated by another substring that matches the given
* expression or is terminated by the end of the string. The substrings in
* the array are in the order in which they occur in this string. If the
* expression does not match any part of the input then the resulting array
* has just one element, namely this string.
*
*
When there is a positive-width match at the beginning of this
* string then an empty leading substring is included at the beginning
* of the resulting array. A zero-width match at the beginning however
* never produces such empty leading substring.
*
*
The {@code limit} parameter controls the number of times the
* pattern is applied and therefore affects the length of the resulting
* array. If the limit n is greater than zero then the pattern
* will be applied at most n - 1 times, the array's
* length will be no greater than n, and the array's last entry
* will contain all input beyond the last matched delimiter. If n
* is non-positive then the pattern will be applied as many times as
* possible and the array can have any length. If n is zero then
* the pattern will be applied as many times as possible, the array can
* have any length, and trailing empty strings will be discarded.
*
*
The string {@code "boo:and:foo"}, for example, yields the
* following results with these parameters:
*
*
*
*
Regex
*
Limit
*
Result
*
*
:
*
2
*
{@code { "boo", "and:foo" }}
*
:
*
5
*
{@code { "boo", "and", "foo" }}
*
:
*
-2
*
{@code { "boo", "and", "foo" }}
*
o
*
5
*
{@code { "b", "", ":and:f", "", "" }}
*
o
*
-2
*
{@code { "b", "", ":and:f", "", "" }}
*
o
*
0
*
{@code { "b", "", ":and:f" }}
*
*
*
An invocation of this method of the form
* str.{@code split(}regex{@code ,} n{@code )}
* yields the same result as the expression
*
*
*
*
* @param regex
* the delimiting regular expression
*
* @param limit
* the result threshold, as described above
*
* @return the array of strings computed by splitting this string
* around matches of the given regular expression
*
* @throws PatternSyntaxException
* if the regular expression's syntax is invalid
*
* @see java.util.regex.Pattern
*
* @since 1.4
* @spec JSR-51
*
* @diffblue.limitedSupport
* This forces the regex argument to contain at most one character.
* The model assumes the regex is not a special regex character:
* \.[{()<>*+-=?^$| .
* So no trace can be generated for these characters.
* In particular this prevents any trace for the PatternSyntaxException case
* from being generated.
*
* The size of the computed array is limited by the unwind parameter.
* No trace can be generated for which the resulting array would be greater
* than the unwind value.
*/
public String[] split(String regex, int limit) {
// /* fastpath if the regex is a
// (1)one-char String and this character is not one of the
// RegEx's meta characters ".$|()[{^?*+\\", or
// (2)two-char String and the first char is the backslash and
// the second is not the ascii digit or ascii letter.
// */
// char ch = 0;
// if (((regex.value.length == 1 &&
// ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
// (regex.length() == 2 &&
// regex.charAt(0) == '\\' &&
// (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
// ((ch-'a')|('z'-ch)) < 0 &&
// ((ch-'A')|('Z'-ch)) < 0)) &&
// (ch < Character.MIN_HIGH_SURROGATE ||
// ch > Character.MAX_LOW_SURROGATE))
// {
// int off = 0;
// int next = 0;
// boolean limited = limit > 0;
// ArrayList list = new ArrayList<>();
// while ((next = indexOf(ch, off)) != -1) {
// if (!limited || list.size() < limit - 1) {
// list.add(substring(off, next));
// off = next + 1;
// } else { // last one
// //assert (list.size() == limit - 1);
// list.add(substring(off, value.length));
// off = value.length;
// break;
// }
// }
// // If no match was found, return this
// if (off == 0)
// return new String[]{this};
//
// // Add remaining segment
// if (!limited || list.size() < limit)
// list.add(substring(off, value.length));
//
// // Construct result
// int resultSize = list.size();
// if (limit == 0) {
// while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
// resultSize--;
// }
// }
// String[] result = new String[resultSize];
// return list.subList(0, resultSize).toArray(result);
// }
// return Pattern.compile(regex).split(this, limit);
// DIFFBLUE MODEL LIBRARY
if (limit == 0) {
return split(regex);
}
int size = CProver.nondetInt();
CProver.assume(size > 0);
String[] result = new String[size];
if (regex.length() == 0) {
int tokenIndex = 0;
while (tokenIndex < length() && tokenIndex != limit - 1) {
result[tokenIndex] =
CProverString.substring(this, tokenIndex, tokenIndex + 1);
tokenIndex++;
}
// extract the remainder of the string
if (tokenIndex < length()) {
result[tokenIndex] =
CProverString.substring(this, tokenIndex, length());
tokenIndex++;
} else {
result[tokenIndex] = "";
tokenIndex++;
}
// Ensure the size of the array corresponds to the number of tokens
CProver.assume(tokenIndex == size);
return result;
}
// We only handle empty or single character delimiters
CProver.assume(regex.length() == 1);
char delimiter = CProverString.charAt(regex, 0);
// We don't handle special regex characters \.[{()<>*+-=?^$|
CProver.assume(delimiter != '\\' && delimiter != '.' && delimiter != '['
&& delimiter != '{' && delimiter != '('
&& delimiter != ')' && delimiter != '<'
&& delimiter != '>' && delimiter != '*'
&& delimiter != '+' && delimiter != '-'
&& delimiter != '=' && delimiter != '?'
&& delimiter != '^' && delimiter != '$'
&& delimiter != '|');
int tokenStart = 0;
int tokenIndex = 0;
int tokenEnd = indexOf(delimiter, tokenStart);
while (tokenIndex < size - 1) {
// extract the token prior to the delimiter
CProver.assume(tokenEnd != -1);
result[tokenIndex] =
CProverString.substring(this, tokenStart, tokenEnd);
tokenIndex++;
tokenStart = tokenEnd + 1;
tokenEnd = indexOf(delimiter, tokenStart);
}
// extract the remainder of the string
result[tokenIndex] =
CProverString.substring(this, tokenStart, length());
tokenIndex++;
CProver.assume(tokenIndex == limit || tokenEnd == -1);
CProver.assume(limit <= 0 || size <= limit);
return result;
}
/**
* Splits this string around matches of the given regular expression.
*
*
This method works as if by invoking the two-argument {@link
* #split(String, int) split} method with the given expression and a limit
* argument of zero. Trailing empty strings are therefore not included in
* the resulting array.
*
*
The string {@code "boo:and:foo"}, for example, yields the following
* results with these expressions:
*
*
*
*
Regex
*
Result
*
*
:
*
{@code { "boo", "and", "foo" }}
*
o
*
{@code { "b", "", ":and:f" }}
*
*
*
* @param regex
* the delimiting regular expression
*
* @return the array of strings computed by splitting this string
* around matches of the given regular expression
*
* @throws PatternSyntaxException
* if the regular expression's syntax is invalid
*
* @see java.util.regex.Pattern
*
* @since 1.4
* @spec JSR-51
*
* @diffblue.limitedSupport
* This forces the regex argument to contain at most one character.
* The model assumes the regex is not a special regex character:
* \.[{()<>*+-=?^$| .
* So no trace can be generated for these characters.
* In particular this prevents any trace for the PatternSyntaxException case
* from being generated.
*
* The size of the computed array is limited by the unwind parameter.
* No trace can be generated for which the resulting array would be greater
* than the unwind value.
*/
public String[] split(String regex) {
// return split(regex, 0);
// DIFFBLUE MODEL LIBRARY
// The (String, int) version in our model calls the String version,
// which the other way in the original implementation.
// This way, if the String version is called in the code we analyse,
// only the code for this one is loaded.
// The 0 case is a bit special compared to the others in that it disregard trailing empty strings.
int size = CProver.nondetInt();
CProver.assume(size > 0);
String[] result = new String[size];
if (regex.length() == 0) {
int tokenIndex = 0;
if (length() == 0) {
CProver.assume(size == 1);
result[tokenIndex] = "";
return result;
}
while (tokenIndex < length()) {
result[tokenIndex] =
CProverString.substring(this, tokenIndex, tokenIndex + 1);
tokenIndex++;
}
// Ensure the size of the array corresponds to the number of tokens
CProver.assume(tokenIndex == size);
return result;
}
// We only handle empty or single character delimiters
CProver.assume(regex.length() == 1);
char delimiter = CProverString.charAt(regex, 0);
// We don't handle special regex characters \.[{()<>*+-=?^$|
CProver.assume(delimiter != '\\' && delimiter != '.' && delimiter != '['
&& delimiter != '{' && delimiter != '('
&& delimiter != ')' && delimiter != '<'
&& delimiter != '>' && delimiter != '*'
&& delimiter != '+' && delimiter != '-'
&& delimiter != '=' && delimiter != '?'
&& delimiter != '^' && delimiter != '$'
&& delimiter != '|');
int tokenIndex = 0;
int tokenStart = 0;
int tokenEnd = indexOf(delimiter, tokenStart);
while (tokenIndex < size - 1) {
CProver.assume(tokenEnd != -1);
result[tokenIndex++] =
CProverString.substring(this, tokenStart, tokenEnd);
tokenStart = tokenEnd + 1;
tokenEnd = indexOf(delimiter, tokenStart);
}
// extract the remainder of the string
if (tokenEnd == -1) {
// Exclude trailing empty strings
CProver.assume(tokenStart != length());
result[tokenIndex] =
CProverString.substring(this, tokenStart, length());
} else {
// Exclude trailing empty strings
CProver.assume(tokenStart != tokenEnd);
result[tokenIndex] =
CProverString.substring(this, tokenStart, tokenEnd);
// ignore trailing empty strings
for (int i = tokenEnd + 1; i < length(); i++) {
CProver.assume(charAt(i) == delimiter);
}
}
return result;
}
/**
* Returns a new String composed of copies of the
* {@code CharSequence elements} joined together with a copy of
* the specified {@code delimiter}.
*
*
For example,
*
{@code
* String message = String.join("-", "Java", "is", "cool");
* // message returned is: "Java-is-cool"
* }
*
* Note that if an element is null, then {@code "null"} is added.
*
* @param delimiter the delimiter that separates each element
* @param elements the elements to join together.
*
* @return a new {@code String} that is composed of the {@code elements}
* separated by the {@code delimiter}
*
* @throws NullPointerException If {@code delimiter} or {@code elements}
* is {@code null}
*
* @see java.util.StringJoiner
* @since 1.8
*
* @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.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.
// StringJoiner joiner = new StringJoiner(delimiter);
// for (CharSequence cs: elements) {
// joiner.add(cs);
// }
// return joiner.toString();
}
/**
* Returns a new {@code String} composed of copies of the
* {@code CharSequence elements} joined together with a copy of the
* specified {@code delimiter}.
*
*
For example,
*
{@code
* List strings = new LinkedList<>();
* strings.add("Java");strings.add("is");
* strings.add("cool");
* String message = String.join(" ", strings);
* //message returned is: "Java is cool"
*
* Set strings = new LinkedHashSet<>();
* strings.add("Java"); strings.add("is");
* strings.add("very"); strings.add("cool");
* String message = String.join("-", strings);
* //message returned is: "Java-is-very-cool"
* }
*
* Note that if an individual element is {@code null}, then {@code "null"} is added.
*
* @param delimiter a sequence of characters that is used to separate each
* of the {@code elements} in the resulting {@code String}
* @param elements an {@code Iterable} that will have its {@code elements}
* joined together.
*
* @return a new {@code String} that is composed from the {@code elements}
* argument
*
* @throws NullPointerException If {@code delimiter} or {@code elements}
* is {@code null}
*
* @see #join(CharSequence,CharSequence...)
* @see java.util.StringJoiner
* @since 1.8
*
* @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 elements) {
CProver.assume(delimiter != null);
CProver.assume(elements != null);
Iterator 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);
// for (CharSequence cs: elements) {
// joiner.add(cs);
// }
// return joiner.toString();
}
/**
* Converts all of the characters in this {@code String} to lower
* case using the rules of the given {@code Locale}. Case mapping is based
* on the Unicode Standard version specified by the {@link java.lang.Character Character}
* class. Since case mappings are not always 1:1 char mappings, the resulting
* {@code String} may be a different length than the original {@code String}.
*
* Examples of lowercase mappings are in the following table:
*
*
*
Language Code of Locale
*
Upper Case
*
Lower Case
*
Description
*
*
*
tr (Turkish)
*
\u0130
*
\u0069
*
capital letter I with dot above -> small letter i
*
*
*
tr (Turkish)
*
\u0049
*
\u0131
*
capital letter I -> small letter dotless i
*
*
*
(all)
*
French Fries
*
french fries
*
lowercased all chars in String
*
*
*
(all)
*
*
*
*
*
*
*
lowercased all chars in String
*
*
*
* @param locale use the case transformation rules for this locale
* @return the {@code String}, converted to lowercase.
* @see java.lang.String#toLowerCase()
* @see java.lang.String#toUpperCase()
* @see java.lang.String#toUpperCase(Locale)
* @since 1.1
*
* @diffblue.limitedSupport
* This is only correct for ASCII characters.
* This ignores the locale, making it incorrect for Turkish, Azeri and Lithuanian
* @diffblue.untested
*/
public String toLowerCase(Locale locale) {
// DIFFBLUE MODEL LIBRARY We just ignore the argument as it does not
// make a difference in most cases
return toLowerCase();
// if (locale == null) {
// throw new NullPointerException();
// }
//
// int firstUpper;
// final int len = value.length;
//
// /* Now check if there are any characters that need to be changed. */
// scan: {
// for (firstUpper = 0 ; firstUpper < len; ) {
// char c = value[firstUpper];
// if ((c >= Character.MIN_HIGH_SURROGATE)
// && (c <= Character.MAX_HIGH_SURROGATE)) {
// int supplChar = codePointAt(firstUpper);
// if (supplChar != Character.toLowerCase(supplChar)) {
// break scan;
// }
// firstUpper += Character.charCount(supplChar);
// } else {
// if (c != Character.toLowerCase(c)) {
// break scan;
// }
// firstUpper++;
// }
// }
// return this;
// }
//
// char[] result = new char[len];
// int resultOffset = 0; /* result may grow, so i+resultOffset
// * is the write location in result */
//
// /* Just copy the first few lowerCase characters. */
// System.arraycopy(value, 0, result, 0, firstUpper);
//
// String lang = locale.getLanguage();
// boolean localeDependent =
// (lang == "tr" || lang == "az" || lang == "lt");
// char[] lowerCharArray;
// int lowerChar;
// int srcChar;
// int srcCount;
// for (int i = firstUpper; i < len; i += srcCount) {
// srcChar = (int)value[i];
// if ((char)srcChar >= Character.MIN_HIGH_SURROGATE
// && (char)srcChar <= Character.MAX_HIGH_SURROGATE) {
// srcChar = codePointAt(i);
// srcCount = Character.charCount(srcChar);
// } else {
// srcCount = 1;
// }
// if (localeDependent || srcChar == '\u03A3') { // GREEK CAPITAL LETTER SIGMA
// lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale);
// } else {
// lowerChar = Character.toLowerCase(srcChar);
// }
// if ((lowerChar == Character.ERROR)
// || (lowerChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
// if (lowerChar == Character.ERROR) {
// lowerCharArray =
// ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale);
// } else if (srcCount == 2) {
// resultOffset += Character.toChars(lowerChar, result, i + resultOffset) - srcCount;
// continue;
// } else {
// lowerCharArray = Character.toChars(lowerChar);
// }
//
// /* Grow result if needed */
// int mapLen = lowerCharArray.length;
// if (mapLen > srcCount) {
// char[] result2 = new char[result.length + mapLen - srcCount];
// System.arraycopy(result, 0, result2, 0, i + resultOffset);
// result = result2;
// }
// for (int x = 0; x < mapLen; ++x) {
// result[i + resultOffset + x] = lowerCharArray[x];
// }
// resultOffset += (mapLen - srcCount);
// } else {
// result[i + resultOffset] = (char)lowerChar;
// }
// }
// return new String(result, 0, len + resultOffset);
}
/**
* Converts all of the characters in this {@code String} to lower
* case using the rules of the default locale. This is equivalent to calling
* {@code toLowerCase(Locale.getDefault())}.
*
* Note: This method is locale sensitive, and may produce unexpected
* results if used for strings that are intended to be interpreted locale
* independently.
* Examples are programming language identifiers, protocol keys, and HTML
* tags.
* For instance, {@code "TITLE".toLowerCase()} in a Turkish locale
* returns {@code "t\u005Cu0131tle"}, where '\u005Cu0131' is the
* LATIN SMALL LETTER DOTLESS I character.
* To obtain correct results for locale insensitive strings, use
* {@code toLowerCase(Locale.ROOT)}.
*
* @return the {@code String}, converted to lowercase.
* @see java.lang.String#toLowerCase(Locale)
*
* @diffblue.limitedSupport
* This is only correct for ASCII characters.
* This ignores the locale, making it incorrect for Turkish, Azeri and Lithuanian
* @diffblue.untested
*/
public String toLowerCase() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetWithNullForNotModelled();
// return toLowerCase(Locale.getDefault());
}
/**
* Converts all of the characters in this {@code String} to upper
* case using the rules of the given {@code Locale}. Case mapping is based
* on the Unicode Standard version specified by the {@link java.lang.Character Character}
* class. Since case mappings are not always 1:1 char mappings, the resulting
* {@code String} may be a different length than the original {@code String}.
*
* Examples of locale-sensitive and 1:M case mappings are in the following table.
*
*
*
*
Language Code of Locale
*
Lower Case
*
Upper Case
*
Description
*
*
*
tr (Turkish)
*
\u0069
*
\u0130
*
small letter i -> capital letter I with dot above
*
*
*
tr (Turkish)
*
\u0131
*
\u0049
*
small letter dotless i -> capital letter I
*
*
*
(all)
*
\u00df
*
\u0053 \u0053
*
small letter sharp s -> two letters: SS
*
*
*
(all)
*
Fahrvergnügen
*
FAHRVERGNÜGEN
*
*
*
* @param locale use the case transformation rules for this locale
* @return the {@code String}, converted to uppercase.
* @see java.lang.String#toUpperCase()
* @see java.lang.String#toLowerCase()
* @see java.lang.String#toLowerCase(Locale)
* @since 1.1
*
* @diffblue.limitedSupport
* This is only correct for ASCII characters.
* This ignores the locale, making it incorrect for Turkish, Azeri and Lithuanian.
* @diffblue.untested
*/
public String toUpperCase(Locale locale) {
return toUpperCase();
// if (locale == null) {
// throw new NullPointerException();
// }
//
// int firstLower;
// final int len = value.length;
//
// /* Now check if there are any characters that need to be changed. */
// scan: {
// for (firstLower = 0 ; firstLower < len; ) {
// int c = (int)value[firstLower];
// int srcCount;
// if ((c >= Character.MIN_HIGH_SURROGATE)
// && (c <= Character.MAX_HIGH_SURROGATE)) {
// c = codePointAt(firstLower);
// srcCount = Character.charCount(c);
// } else {
// srcCount = 1;
// }
// int upperCaseChar = Character.toUpperCaseEx(c);
// if ((upperCaseChar == Character.ERROR)
// || (c != upperCaseChar)) {
// break scan;
// }
// firstLower += srcCount;
// }
// return this;
// }
//
// /* result may grow, so i+resultOffset is the write location in result */
// int resultOffset = 0;
// char[] result = new char[len]; /* may grow */
//
// /* Just copy the first few upperCase characters. */
// System.arraycopy(value, 0, result, 0, firstLower);
//
// String lang = locale.getLanguage();
// boolean localeDependent =
// (lang == "tr" || lang == "az" || lang == "lt");
// char[] upperCharArray;
// int upperChar;
// int srcChar;
// int srcCount;
// for (int i = firstLower; i < len; i += srcCount) {
// srcChar = (int)value[i];
// if ((char)srcChar >= Character.MIN_HIGH_SURROGATE &&
// (char)srcChar <= Character.MAX_HIGH_SURROGATE) {
// srcChar = codePointAt(i);
// srcCount = Character.charCount(srcChar);
// } else {
// srcCount = 1;
// }
// if (localeDependent) {
// upperChar = ConditionalSpecialCasing.toUpperCaseEx(this, i, locale);
// } else {
// upperChar = Character.toUpperCaseEx(srcChar);
// }
// if ((upperChar == Character.ERROR)
// || (upperChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
// if (upperChar == Character.ERROR) {
// if (localeDependent) {
// upperCharArray =
// ConditionalSpecialCasing.toUpperCaseCharArray(this, i, locale);
// } else {
// upperCharArray = Character.toUpperCaseCharArray(srcChar);
// }
// } else if (srcCount == 2) {
// resultOffset += Character.toChars(upperChar, result, i + resultOffset) - srcCount;
// continue;
// } else {
// upperCharArray = Character.toChars(upperChar);
// }
//
// /* Grow result if needed */
// int mapLen = upperCharArray.length;
// if (mapLen > srcCount) {
// char[] result2 = new char[result.length + mapLen - srcCount];
// System.arraycopy(result, 0, result2, 0, i + resultOffset);
// result = result2;
// }
// for (int x = 0; x < mapLen; ++x) {
// result[i + resultOffset + x] = upperCharArray[x];
// }
// resultOffset += (mapLen - srcCount);
// } else {
// result[i + resultOffset] = (char)upperChar;
// }
// }
// return new String(result, 0, len + resultOffset);
}
/**
* Converts all of the characters in this {@code String} to upper
* case using the rules of the default locale. This method is equivalent to
* {@code toUpperCase(Locale.getDefault())}.
*
* Note: This method is locale sensitive, and may produce unexpected
* results if used for strings that are intended to be interpreted locale
* independently.
* Examples are programming language identifiers, protocol keys, and HTML
* tags.
* For instance, {@code "title".toUpperCase()} in a Turkish locale
* returns {@code "T\u005Cu0130TLE"}, where '\u005Cu0130' is the
* LATIN CAPITAL LETTER I WITH DOT ABOVE character.
* To obtain correct results for locale insensitive strings, use
* {@code toUpperCase(Locale.ROOT)}.
*
* @return the {@code String}, converted to uppercase.
* @see java.lang.String#toUpperCase(Locale)
*
* @diffblue.limitedSupport
* This is only correct for ASCII characters.
* This ignores the locale, making it incorrect for Turkish, Azeri and Lithuanian
* @diffblue.untested
*/
public String toUpperCase() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetWithNullForNotModelled();
// return toUpperCase(Locale.getDefault());
}
/**
* Returns a string whose value is this string, with any leading and trailing
* whitespace removed.
*
* If this {@code String} object represents an empty character
* sequence, or the first and last characters of character sequence
* represented by this {@code String} object both have codes
* greater than {@code '\u005Cu0020'} (the space character), then a
* reference to this {@code String} object is returned.
*
* Otherwise, if there is no character with a code greater than
* {@code '\u005Cu0020'} in the string, then a
* {@code String} object representing an empty string is
* returned.
*
* Otherwise, let k be the index of the first character in the
* string whose code is greater than {@code '\u005Cu0020'}, and let
* m be the index of the last character in the string whose code
* is greater than {@code '\u005Cu0020'}. A {@code String}
* object is returned, representing the substring of this string that
* begins with the character at index k and ends with the
* character at index m-that is, the result of
* {@code this.substring(k, m + 1)}.
*
* This method may be used to trim whitespace (as defined above) from
* the beginning and end of a string.
*
* @return A string whose value is this string, with any leading and trailing white
* space removed, or this string if it has no leading or
* trailing white space.
*
* @diffblue.fullSupport
*/
public String trim() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetWithNullForNotModelled();
// int len = value.length;
// int st = 0;
// char[] val = value; /* avoid getfield opcode */
//
// while ((st < len) && (val[st] <= ' ')) {
// st++;
// }
// while ((st < len) && (val[len - 1] <= ' ')) {
// len--;
// }
// return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}
/**
* This object (which is already a string!) is itself returned.
*
* @return the string itself.
*
* @diffblue.limitedSupport
* This returns a copy of the string rather than the string itself.
* @diffblue.todo Correct this by restoring the original code and make CBMC
* stop overwriting the method.
*/
public String toString() {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
return CProver.nondetWithoutNullForNotModelled();
// return this;
}
/**
* Converts this string to a new character array.
*
* @return a newly allocated character array whose length is the length
* of this string and whose contents are initialized to contain
* the character sequence represented by this string.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public char[] toCharArray() {
// DIFFBLUE MODEL LIBRARY Not using arraycopy as its support is limited
// // Cannot use Arrays.copyOf because of class initialization order issues
// char result[] = new char[value.length];
// System.arraycopy(value, 0, result, 0, value.length);
char[] result = new char[this.length()];
for(int i = 0; i < this.length(); i++)
result[i] = CProverString.charAt(this, i);
return result;
}
/**
* Helper function for the {@code format} function.
* Serialize potential String.format argument to a String.
* The returned String is never null.
*/
static String cproverFormatArgument(Object obj) {
if (obj == null) {
return "null";
}
if (obj instanceof String) {
return (String) obj;
}
// All primitive types are cast to a long
long longValue = 0;
if (obj instanceof Integer) {
longValue = (Integer) obj;
} else if (obj instanceof Long) {
longValue = (Long) obj;
} else if (obj instanceof Float) {
longValue = (long) ((Float) obj).doubleValue();
} else if (obj instanceof Double) {
longValue = (long) ((Double) obj).doubleValue();
} else if (obj instanceof Character) {
char charValue = (Character) obj;
longValue = (long) charValue;
} else if (obj instanceof Byte) {
byte byteValue = ((Byte) obj);
longValue = (long) byteValue;
} else if (obj instanceof Short) {
short shortValue = ((Short) obj);
longValue = (long) shortValue;
} else if (obj instanceof Boolean) {
longValue = ((Boolean) obj) ? 1 : 0;
} else {
CProver.assume(false);
}
// The long value is encoded using a string of 4 characters
StringBuilder builder = new StringBuilder();
builder.append((char) (longValue >> 48 & 0xFFFF));
builder.append((char) (longValue >> 32 & 0xFFFF));
builder.append((char) (longValue >> 16 & 0xFFFF));
builder.append((char) (longValue & 0xFFFF));
String str = builder.toString();
// These redundant constraints are necessary in case the string solver
// decides not to propagate the constraints for the concatenation above.
// This happens, for instance, when the method under test calls
// String.format on an integer and returns the length. In this case,
// only the constraints for the length are propagated in the
// dependency graph, but the length of the formatted string depends
// on the value of the integer, whose conversion is not normally
// propagated in the dependency graph.
CProver.assume(str.charAt(0) == (char) (longValue >> 48 & 0xFFFF));
CProver.assume(str.charAt(1) == (char) (longValue >> 32 & 0xFFFF));
CProver.assume(str.charAt(2) == (char) (longValue >> 16 & 0xFFFF));
CProver.assume(str.charAt(3) == (char) (longValue & 0xFFFF));
return str;
}
/**
* Returns a formatted string using the specified format string and
* arguments.
*
*
The locale always used is the one returned by {@link
* java.util.Locale#getDefault() Locale.getDefault()}.
*
* @param format
* A format string
*
* @param args
* Arguments referenced by the format specifiers in the format
* string. If there are more arguments than format specifiers, the
* extra arguments are ignored. The number of arguments is
* variable and may be zero. The maximum number of arguments is
* limited by the maximum dimension of a Java array as defined by
* The Java™ Virtual Machine Specification.
* The behaviour on a
* {@code null} argument depends on the conversion.
*
* @throws java.util.IllegalFormatException
* If a format string contains an illegal syntax, a format
* specifier that is incompatible with the given arguments,
* insufficient arguments given the format string, or other
* illegal conditions. For specification of all possible
* formatting errors, see the Details section of the
* formatter class specification.
*
* @return A formatted string
*
* @see java.util.Formatter
* @since 1.5
*
* @diffblue.limitedSupport
* The limitation of the current implementation are:
*
*
* 'dateTime', 'hashcode' and 'octal' format specifiers are not
* implemented, which can lead to incorrect trace when they are used
*
*
* precision and width are ignored
*
*
* no trace will be generated if the format specifier is not a constant
* String with correct syntax and compatible with the arguments,
* in particular no trace can throw IllegalFormatException
*
*
* we arbitrary limit the number of arguments to 10 (increasing
* this number slows down the solver and when the number of
* arguments exceeds the limit the result will be incorrect)
*
*
* having 5 arguments or more makes the solver slow
*
*
* @diffblue.untested
*/
public static String format(String format, Object... args) {
// return new Formatter().format(format, args).toString();
// DIFFBLUE MODEL LIBRARY
CProver.assume(args.length <= 10);
String arg0 = args.length > 0 ? cproverFormatArgument(args[0]) : "";
String arg1 = args.length > 1 ? cproverFormatArgument(args[1]) : "";
String arg2 = args.length > 2 ? cproverFormatArgument(args[2]) : "";
String arg3 = args.length > 3 ? cproverFormatArgument(args[3]) : "";
String arg4 = args.length > 4 ? cproverFormatArgument(args[4]) : "";
String arg5 = args.length > 5 ? cproverFormatArgument(args[5]) : "";
String arg6 = args.length > 6 ? cproverFormatArgument(args[6]) : "";
String arg7 = args.length > 7 ? cproverFormatArgument(args[7]) : "";
String arg8 = args.length > 8 ? cproverFormatArgument(args[8]) : "";
String arg9 = args.length > 9 ? cproverFormatArgument(args[9]) : "";
return CProverString.format(format, arg0, arg1, arg2, arg3, arg4, arg5, arg6,
arg7, arg8, arg9);
}
/**
* Returns a formatted string using the specified locale, format string,
* and arguments.
*
* @param l
* The {@linkplain java.util.Locale locale} to apply during
* formatting. If {@code l} is {@code null} then no localization
* is applied.
*
* @param format
* A format string
*
* @param args
* Arguments referenced by the format specifiers in the format
* string. If there are more arguments than format specifiers, the
* extra arguments are ignored. The number of arguments is
* variable and may be zero. The maximum number of arguments is
* limited by the maximum dimension of a Java array as defined by
* The Java™ Virtual Machine Specification.
* The behaviour on a
* {@code null} argument depends on the
* conversion.
*
* @throws java.util.IllegalFormatException
* If a format string contains an illegal syntax, a format
* specifier that is incompatible with the given arguments,
* insufficient arguments given the format string, or other
* illegal conditions. For specification of all possible
* formatting errors, see the Details section of the
* formatter class specification
*
* @return A formatted string
*
* @see java.util.Formatter
* @since 1.5
*
* @diffblue.noSupport
*/
public static String format(Locale l, String format, Object... args) {
// return new Formatter(l).format(format, args).toString();
return format(format, args);
}
/**
* Returns the string representation of the {@code Object} argument.
*
* @param obj an {@code Object}.
* @return if the argument is {@code null}, then a string equal to
* {@code "null"}; otherwise, the value of
* {@code obj.toString()} is returned.
* @see java.lang.Object#toString()
*
* @diffblue.noSupport
* @diffblue.todo add this by using the original implementation
*/
public static String valueOf(Object obj) {
// DIFFBLUE MODEL LIBRARY This is treated internally in CBMC
// return (obj == null) ? "null" : obj.toString();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns the string representation of the {@code char} array
* argument. The contents of the character array are copied; subsequent
* modification of the character array does not affect the returned
* string.
*
* @param data the character array.
* @return a {@code String} that contains the characters of the
* character array.
*
* @diffblue.noSupport
* @diffblue.todo implement this using the String([C) constructor
*/
public static String valueOf(char data[]) {
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
// return new String(data);
}
/**
* Returns the string representation of a specific subarray of the
* {@code char} array argument.
*
* The {@code offset} argument is the index of the first
* character of the subarray. The {@code count} argument
* specifies the length of the subarray. The contents of the subarray
* are copied; subsequent modification of the character array does not
* affect the returned string.
*
* @param data the character array.
* @param offset initial offset of the subarray.
* @param count length of the subarray.
* @return a {@code String} that contains the characters of the
* specified subarray of the character array.
* @exception IndexOutOfBoundsException if {@code offset} is
* negative, or {@code count} is negative, or
* {@code offset+count} is larger than
* {@code data.length}.
*
* @diffblue.noSupport
*/
public static String valueOf(char data[], int offset, int count) {
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
// return new String(data, offset, count);
}
/**
* Equivalent to {@link #valueOf(char[], int, int)}.
*
* @param data the character array.
* @param offset initial offset of the subarray.
* @param count length of the subarray.
* @return a {@code String} that contains the characters of the
* specified subarray of the character array.
* @exception IndexOutOfBoundsException if {@code offset} is
* negative, or {@code count} is negative, or
* {@code offset+count} is larger than
* {@code data.length}.
*
* @diffblue.noSupport
*/
public static String copyValueOf(char data[], int offset, int count) {
CProver.notModelled();
return CProver.nondetWithNullForNotModelled();
// return new String(data, offset, count);
}
/**
* Equivalent to {@link #valueOf(char[])}.
*
* @param data the character array.
* @return a {@code String} that contains the characters of the
* character array.
*
* @diffblue.noSupport
*/
public static String copyValueOf(char data[]) {
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
// return new String(data);
}
/**
* Returns the string representation of the {@code boolean} argument.
*
* @param b a {@code boolean}.
* @return if the argument is {@code true}, a string equal to
* {@code "true"} is returned; otherwise, a string equal to
* {@code "false"} is returned.
*
* @diffblue.fullSupport
*/
public static String valueOf(boolean b) {
return b ? "true" : "false";
}
/**
* Returns the string representation of the {@code char}
* argument.
*
* @param c a {@code char}.
* @return a string of length {@code 1} containing
* as its single character the argument {@code c}.
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public static String valueOf(char c) {
char data[] = {c};
return CProverString.ofCharArray(data, 0, 1);
// char data[] = {c};
// return new String(data, true);
}
/**
* Returns the string representation of the {@code int} argument.
*
* The representation is exactly the one returned by the
* {@code Integer.toString} method of one argument.
*
* @param i an {@code int}.
* @return a string representation of the {@code int} argument.
* @see java.lang.Integer#toString(int, int)
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public static String valueOf(int i) {
return CProverString.toString(i);
// return Integer.toString(i);
}
/**
* Returns the string representation of the {@code long} argument.
*
* The representation is exactly the one returned by the
* {@code Long.toString} method of one argument.
*
* @param l a {@code long}.
* @return a string representation of the {@code long} argument.
* @see java.lang.Long#toString(long)
*
* @diffblue.fullSupport
* @diffblue.untested
*/
public static String valueOf(long l) {
return CProverString.toString(l);
// return Long.toString(l);
}
/**
* Returns the string representation of the {@code float} argument.
*
* The representation is exactly the one returned by the
* {@code Float.toString} method of one argument.
*
* @param f a {@code float}.
* @return a string representation of the {@code float} argument.
* @see java.lang.Float#toString(float)
*
* @diffblue.limitedSupport
* The precision in the produced string may not match that of the
* actual program.
*/
public static String valueOf(float f) {
return CProverString.toString(f);
// return Float.toString(f);
}
/**
* Returns the string representation of the {@code double} argument.
*
* The representation is exactly the one returned by the
* {@code Double.toString} method of one argument.
*
* @param d a {@code double}.
* @return a string representation of the {@code double} argument.
* @see java.lang.Double#toString(double)
*
* @diffblue.limitedSupport
* The precision in the produced string may not match that of the
* actual program.
*/
public static String valueOf(double d) {
// string solver only knows how to convert floats to string
return CProverString.toString(d);
// return Double.toString(d);
}
/**
* Pool of strings used by the {@code String}.intern model.
*/
static String[] cproverInternPool = null;
/**
* Number of elements stored in the pool for {@code String.intern}.
* This can be smaller than {@code cproverInternPool.length} which
* represents the capacity of the array and is fixed for each execution.
*/
static int cproverInternPoolSize = 0;
/**
* Returns a canonical representation for the string object.
*
* A pool of strings, initially empty, is maintained privately by the
* class {@code String}.
*
* When the intern method is invoked, if the pool already contains a
* string equal to this {@code String} object as determined by
* the {@link #equals(Object)} method, then the string from the pool is
* returned. Otherwise, this {@code String} object is added to the
* pool and a reference to this {@code String} object is returned.
*
* It follows that for any two strings {@code s} and {@code t},
* {@code s.intern() == t.intern()} is {@code true}
* if and only if {@code s.equals(t)} is {@code true}.
*
* All literal strings and string-valued constant expressions are
* interned. String literals are defined in section 3.10.5 of the
* The Java™ Language Specification.
*
* @return a string that has the same contents as this string, but is
* guaranteed to be from a pool of unique strings.
*
* @diffblue.limitedSupport literal strings and string-valued constant
* expressions are not interned.
* @diffblue.untested
*/
// DIFFBLUE MODEL LIBRARY
// public native String intern();
public String intern() {
// Initialize the pool if needed
if (cproverInternPool == null) {
int capacity = CProver.nondetInt();
CProver.assume(capacity > 0);
cproverInternPool = new String[capacity];
cproverInternPool[0] = this;
return this;
}
// Look for an entry in the pool equal to `this`
for (int i = 0; i < cproverInternPoolSize; ++i) {
if (CProverString.equals(cproverInternPool[i], this)) {
return cproverInternPool[i];
}
}
// Add `this` to the pool
CProver.assume(cproverInternPool.length > cproverInternPoolSize);
cproverInternPool[cproverInternPoolSize++] = this;
return this;
}
}
java-models-library-master/src/main/java/java/lang/StringBuffer.java 0000664 0000000 0000000 00000077344 14323475213 0025777 0 ustar 00root root 0000000 0000000 /*
* 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.
*
* 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.
*
* 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.
*
* 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"}.
*
* 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)}.
*
* 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.
*
* 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.
*
* Unless otherwise noted, passing a {@code null} argument to a constructor
* or method in this class will cause a {@link NullPointerException} to be
* thrown.
*
* 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.
*
* 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.
*
* 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}.
*
* Let n 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 k in
* the new character sequence is equal to the character at index k
* in the old character sequence, if k is less than n;
* otherwise, it is equal to the character at index k-n in the
* argument {@code sb}.
*
* 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.
*
* The characters of the {@code CharSequence} argument are appended,
* in order, increasing the length of this sequence by the length of the
* argument.
*
*
The result of this method is exactly the same as if it were an
* invocation of this.append(s, 0, s.length());
*
*
This method synchronizes on {@code this}, the destination
* object, but does not synchronize on the source ({@code s}).
*
*
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
*/
@Override
public synchronized StringBuffer append(int i) {
// toStringCache = null;
// super.append(i);
// return this;
return append(String.valueOf(i));
}
/**
* @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
*/
@Override
public synchronized StringBuffer append(float f) {
// toStringCache = null;
// super.append(f);
// return this;
return append(String.valueOf(f));
}
/**
* @diffblue.partialSupport This uses float approximation, so might return incorrect results
*/
@Override
public synchronized StringBuffer append(double d) {
// toStringCache = null;
// super.append(d);
// return this;
return append(String.valueOf(d));
}
/**
* @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);
// }
}
java-models-library-master/src/main/java/java/lang/StringBuilder.java 0000664 0000000 0000000 00000052647 14323475213 0026153 0 ustar 00root root 0000000 0000000 /*
* 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.
*
*
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.
*
* 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}".
*
* 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)}.
*
* 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.
*
*
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.
*
*
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.
*
* 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.
*
* Let n be the length of this character sequence just prior to
* execution of the {@code append} method. Then the character at index
* k in the new character sequence is equal to the character at
* index k in the old character sequence, if k is less than
* n; otherwise, it is equal to the character at index k-n
* 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
String string = CProverString.ofCharArray(str, 0, str.length);
return append(string);
// super.append(str);
// return this;
}
/**
* @throws IndexOutOfBoundsException {@inheritDoc}
* @diffblue.fullSupport
* @diffblue.untested
*/
@Override
public StringBuilder append(char[] str, int offset, int len) {
// DIFFBLUE MODEL LIBRARY
String string = new String(str, offset, len);
return append(string);
// super.append(str, offset, len);
// return this;
}
/**
* @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, String.valueOf(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, String.valueOf(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, String.valueOf(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, String.valueOf(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, String.valueOf(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, String.valueOf(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.fullSupport
* @diffblue.untested
*/
@Override
public StringBuilder reverse() {
// super.reverse();
// return this;
int size = this.length();
if (size < 2)
return this;
String tmp = this.toString();
CProverString.delete(this, 0, size);
for (int i=size-1; i>=0; --i) {
this.append(CProverString.charAt(tmp, i));
}
return this;
}
/**
* @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();
// }
// DIFFBLUE MODEL LIBRARY This should be inherited from AbstractStringBuilder
/**
* @diffblue.fullSupport
* @diffblue.untested
*/
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
toString().getChars(srcBegin, srcEnd, dst, dstBegin);
}
/**
* @throws IndexOutOfBoundsException {@inheritDoc}
* @see #length()
*
* @diffblue.fullSupport
*/
@Override
public void setLength(int newLength) {
if (newLength < 0)
throw new StringIndexOutOfBoundsException(newLength);
CProverString.setLength(this, newLength);
}
/**
* @throws IndexOutOfBoundsException {@inheritDoc}
* @see #length()
*
* @diffblue.fullSupport
*/
@Override
public void setCharAt(int index, char ch) {
if ((index < 0) || (index >= this.length()))
throw new StringIndexOutOfBoundsException(index);
CProverString.setCharAt(this, index, ch);
}
}
java-models-library-master/src/main/java/java/lang/StringIndexOutOfBoundsException.java 0000664 0000000 0000000 00000004072 14323475213 0031630 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/Thread.java 0000664 0000000 0000000 00000242531 14323475213 0024576 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1994, 2016, 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;
/**
* A thread is a thread of execution in a program. The Java
* Virtual Machine allows an application to have multiple threads of
* execution running concurrently.
*
* Every thread has a priority. Threads with higher priority are
* executed in preference to threads with lower priority. Each thread
* may or may not also be marked as a daemon. When code running in
* some thread creates a new Thread object, the new
* thread has its priority initially set equal to the priority of the
* creating thread, and is a daemon thread if and only if the
* creating thread is a daemon.
*
* When a Java Virtual Machine starts up, there is usually a single
* non-daemon thread (which typically calls the method named
* main of some designated class). The Java Virtual
* Machine continues to execute threads until either of the following
* occurs:
*
*
The exit method of class Runtime has been
* called and the security manager has permitted the exit operation
* to take place.
*
All threads that are not daemon threads have died, either by
* returning from the call to the run method or by
* throwing an exception that propagates beyond the run
* method.
*
*
* There are two ways to create a new thread of execution. One is to
* declare a class to be a subclass of Thread. This
* subclass should override the run method of class
* Thread. An instance of the subclass can then be
* allocated and started. For example, a thread that computes primes
* larger than a stated value could be written as follows:
*
* The following code would then create a thread and start it running:
*
* PrimeThread p = new PrimeThread(143);
* p.start();
*
*
* The other way to create a thread is to declare a class that
* implements the Runnable interface. That class then
* implements the run method. An instance of the class can
* then be allocated, passed as an argument when creating
* Thread, and started. The same example in this other
* style looks like the following:
*
* The following code would then create a thread and start it running:
*
* PrimeRun p = new PrimeRun(143);
* new Thread(p).start();
*
*
* Every thread has a name for identification purposes. More than
* one thread may have the same name. If a name is not specified when
* a thread is created, a new name is generated for it.
*
* 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 unascribed
* @see Runnable
* @see Runtime#exit(int)
* @see #run()
* @see #stop()
* @since JDK1.0
*/
public class Thread implements Runnable
{
// /* Make sure registerNatives is the first thing does. */
// private static native void registerNatives();
// static {
// registerNatives();
// }
// private volatile String name;
// private int priority;
// private Thread threadQ;
// private long eetop;
// /* Whether or not to single_step this thread. */
// private boolean single_step;
// /* Whether or not the thread is a daemon thread. */
// private boolean daemon = false;
// /* JVM state */
// private boolean stillborn = false;
/* What will be run. */
private Runnable target;
// /* The group of this thread */
// private ThreadGroup group;
// /* The context ClassLoader for this thread */
// private ClassLoader contextClassLoader;
// /* The inherited AccessControlContext of this thread */
// private AccessControlContext inheritedAccessControlContext;
// /* For autonumbering anonymous threads. */
// private static int threadInitNumber;
// private static synchronized int nextThreadNum() {
// return threadInitNumber++;
// }
// /* ThreadLocal values pertaining to this thread. This map is maintained
// * by the ThreadLocal class. */
// ThreadLocal.ThreadLocalMap threadLocals = null;
// /*
// * InheritableThreadLocal values pertaining to this thread. This map is
// * maintained by the InheritableThreadLocal class.
// */
// ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
// /*
// * The requested stack size for this thread, or 0 if the creator did
// * not specify a stack size. It is up to the VM to do whatever it
// * likes with this number; some VMs will ignore it.
// */
// private long stackSize;
// /*
// * JVM-private state that persists after native thread termination.
// */
// private long nativeParkEventPointer;
/*
* Thread ID
*/
private long tid;
/* For generating thread ID */
private volatile static long threadSeqNumber;
// /* Java thread status for tools,
// * initialized to indicate thread 'not yet started'
// */
// private volatile int threadStatus = 0;
private static long nextThreadID()
{
CProver.atomicBegin();
long result = ++threadSeqNumber;
CProver.atomicEnd();
return result;
}
// /**
// * The argument supplied to the current call to
// * java.util.concurrent.locks.LockSupport.park.
// * Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
// * Accessed using java.util.concurrent.locks.LockSupport.getBlocker
// */
// volatile Object parkBlocker;
// /* The object in which this thread is blocked in an interruptible I/O
// * operation, if any. The blocker's interrupt method should be invoked
// * after setting this thread's interrupt status.
// */
// private volatile Interruptible blocker;
// private final Object blockerLock = new Object();
// /* Set the blocker field; invoked via sun.misc.SharedSecrets from java.nio code
// */
// void blockedOn(Interruptible b) {
// synchronized (blockerLock) {
// blocker = b;
// }
// }
// /**
// * The minimum priority that a thread can have.
// */
// public final static int MIN_PRIORITY = 1;
// /**
// * The default priority that is assigned to a thread.
// */
// public final static int NORM_PRIORITY = 5;
// /**
// * The maximum priority that a thread can have.
// */
// public final static int MAX_PRIORITY = 10;
// /**
// * Returns a reference to the currently executing thread object.
// *
// * @return the currently executing thread.
// */
// public static native Thread currentThread();
/**
* A hint to the scheduler that the current thread is willing to yield
* its current use of a processor. The scheduler is free to ignore this
* hint.
*
*
Yield is a heuristic attempt to improve relative progression
* between threads that would otherwise over-utilise a CPU. Its use
* should be combined with detailed profiling and benchmarking to
* ensure that it actually has the desired effect.
*
*
It is rarely appropriate to use this method. It may be useful
* for debugging or testing purposes, where it may help to reproduce
* bugs due to race conditions. It may also be useful when designing
* concurrency control constructs such as the ones in the
* {@link java.util.concurrent.locks} package.
*/
public static void yield()
{
CProver.notModelled();
}
/**
* Causes the currently executing thread to sleep (temporarily cease
* execution) for the specified number of milliseconds, subject to
* the precision and accuracy of system timers and schedulers. The thread
* does not lose ownership of any monitors.
*
* @param millis
* the length of time to sleep in milliseconds
*
* @throws IllegalArgumentException
* if the value of {@code millis} is negative
*
* @throws InterruptedException
* if any thread has interrupted the current thread. The
* interrupted status of the current thread is
* cleared when this exception is thrown.
*/
public static void sleep(long millis) throws InterruptedException
{
CProver.notModelled();
}
/**
* Causes the currently executing thread to sleep (temporarily cease
* execution) for the specified number of milliseconds plus the specified
* number of nanoseconds, subject to the precision and accuracy of system
* timers and schedulers. The thread does not lose ownership of any
* monitors.
*
* @param millis
* the length of time to sleep in milliseconds
*
* @param nanos
* {@code 0-999999} additional nanoseconds to sleep
*
* @throws IllegalArgumentException
* if the value of {@code millis} is negative, or the value of
* {@code nanos} is not in the range {@code 0-999999}
*
* @throws InterruptedException
* if any thread has interrupted the current thread. The
* interrupted status of the current thread is
* cleared when this exception is thrown.
*/
public static void sleep(long millis, int nanos) throws InterruptedException
{
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
sleep(millis);
}
/**
* Initializes a Thread with the current AccessControlContext.
* @see #init(ThreadGroup,Runnable,String,long,AccessControlContext,boolean)
*/
private void init(ThreadGroup g, Runnable target, String name, long stackSize)
{
CProver.notModelled();
//init(g, target, name, stackSize, null, true);
}
// /**
// * Initializes a Thread.
// *
// * @param g the Thread group
// * @param target the object whose run() method gets called
// * @param name the name of the new Thread
// * @param stackSize the desired stack size for the new thread, or
// * zero to indicate that this parameter is to be ignored.
// * @param acc the AccessControlContext to inherit, or
// * AccessController.getContext() if null
// * @param inheritThreadLocals if {@code true}, inherit initial values for
// * inheritable thread-locals from the constructing thread
// */
// private void init(ThreadGroup g, Runnable target, String name,
// long stackSize, AccessControlContext acc,
// boolean inheritThreadLocals) {
// if (name == null)
// {
// throw new NullPointerException("name cannot be null");
// }
// this.name = name;
// this.target = target;
// tid = nextThreadID();
// // Indicate this function is not fully modelled
// CProver.notModelled();
// }
/**
* Throws CloneNotSupportedException as a Thread can not be meaningfully
* cloned. Construct a new Thread instead.
*
* @throws CloneNotSupportedException
* always
*/
//@Override
protected Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
/**
* Allocates a new {@code Thread} object. This constructor has the same
* effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
* {@code (null, null, gname)}, where {@code gname} is a newly generated
* name. Automatically generated names are of the form
* {@code "Thread-"+}n, where n is an integer.
*/
public Thread()
{
target = this;
tid = nextThreadID();
}
/**
* Allocates a new {@code Thread} object. This constructor has the same
* effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
* {@code (null, target, gname)}, where {@code gname} is a newly generated
* name. Automatically generated names are of the form
* {@code "Thread-"+}n, where n is an integer.
*
* @param target
* the object whose {@code run} method is invoked when this thread
* is started. If {@code null}, this classes {@code run} method does
* nothing.
*/
public Thread(Runnable target)
{
this.target = target;
tid = nextThreadID();
}
// /**
// * Creates a new Thread that inherits the given AccessControlContext.
// * This is not a public constructor.
// */
// Thread(Runnable target, AccessControlContext acc) {
// init(null, target, "Thread-" + nextThreadNum(), 0, acc, false);
// }
// /**
// * Allocates a new {@code Thread} object. This constructor has the same
// * effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
// * {@code (group, target, gname)} ,where {@code gname} is a newly generated
// * name. Automatically generated names are of the form
// * {@code "Thread-"+}n, where n is an integer.
// *
// * @param group
// * the thread group. If {@code null} and there is a security
// * manager, the group is determined by {@linkplain
// * SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.
// * If there is not a security manager or {@code
// * SecurityManager.getThreadGroup()} returns {@code null}, the group
// * is set to the current thread's thread group.
// *
// * @param target
// * the object whose {@code run} method is invoked when this thread
// * is started. If {@code null}, this thread's run method is invoked.
// *
// * @throws SecurityException
// * if the current thread cannot create a thread in the specified
// * thread group
// */
// public Thread(ThreadGroup group, Runnable target) {
// init(group, target, "Thread-" + nextThreadNum(), 0);
// }
/**
* Allocates a new {@code Thread} object. This constructor has the same
* effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
* {@code (null, null, name)}.
*
* @param name
* the name of the new thread
*/
public Thread(String name) {
init(null, null, name, 0);
}
/**
* Allocates a new {@code Thread} object. This constructor has the same
* effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
* {@code (group, null, name)}.
*
* @param group
* the thread group. If {@code null} and there is a security
* manager, the group is determined by {@linkplain
* SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.
* If there is not a security manager or {@code
* SecurityManager.getThreadGroup()} returns {@code null}, the group
* is set to the current thread's thread group.
*
* @param name
* the name of the new thread
*
* @throws SecurityException
* if the current thread cannot create a thread in the specified
* thread group
*/
public Thread(ThreadGroup group, String name) {
init(group, null, name, 0);
}
/**
* Allocates a new {@code Thread} object. This constructor has the same
* effect as {@linkplain #Thread(ThreadGroup,Runnable,String) Thread}
* {@code (null, target, name)}.
*
* @param target
* the object whose {@code run} method is invoked when this thread
* is started. If {@code null}, this thread's run method is invoked.
*
* @param name
* the name of the new thread
*/
public Thread(Runnable target, String name) {
init(null, target, name, 0);
}
/**
* Allocates a new {@code Thread} object so that it has {@code target}
* as its run object, has the specified {@code name} as its name,
* and belongs to the thread group referred to by {@code group}.
*
*
If there is a security manager, its
* {@link SecurityManager#checkAccess(ThreadGroup) checkAccess}
* method is invoked with the ThreadGroup as its argument.
*
*
In addition, its {@code checkPermission} method is invoked with
* the {@code RuntimePermission("enableContextClassLoaderOverride")}
* permission when invoked directly or indirectly by the constructor
* of a subclass which overrides the {@code getContextClassLoader}
* or {@code setContextClassLoader} methods.
*
*
The priority of the newly created thread is set equal to the
* priority of the thread creating it, that is, the currently running
* thread. The method {@linkplain #setPriority setPriority} may be
* used to change the priority to a new value.
*
*
The newly created thread is initially marked as being a daemon
* thread if and only if the thread creating it is currently marked
* as a daemon thread. The method {@linkplain #setDaemon setDaemon}
* may be used to change whether or not a thread is a daemon.
*
* @param group
* the thread group. If {@code null} and there is a security
* manager, the group is determined by {@linkplain
* SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.
* If there is not a security manager or {@code
* SecurityManager.getThreadGroup()} returns {@code null}, the group
* is set to the current thread's thread group.
*
* @param target
* the object whose {@code run} method is invoked when this thread
* is started. If {@code null}, this thread's run method is invoked.
*
* @param name
* the name of the new thread
*
* @throws SecurityException
* if the current thread cannot create a thread in the specified
* thread group or cannot override the context class loader methods.
*/
public Thread(ThreadGroup group, Runnable target, String name) {
init(group, target, name, 0);
}
/**
* Allocates a new {@code Thread} object so that it has {@code target}
* as its run object, has the specified {@code name} as its name,
* and belongs to the thread group referred to by {@code group}, and has
* the specified stack size.
*
*
This constructor is identical to {@link
* #Thread(ThreadGroup,Runnable,String)} with the exception of the fact
* that it allows the thread stack size to be specified. The stack size
* is the approximate number of bytes of address space that the virtual
* machine is to allocate for this thread's stack. The effect of the
* {@code stackSize} parameter, if any, is highly platform dependent.
*
*
On some platforms, specifying a higher value for the
* {@code stackSize} parameter may allow a thread to achieve greater
* recursion depth before throwing a {@link StackOverflowError}.
* Similarly, specifying a lower value may allow a greater number of
* threads to exist concurrently without throwing an {@link
* OutOfMemoryError} (or other internal error). The details of
* the relationship between the value of the stackSize parameter
* and the maximum recursion depth and concurrency level are
* platform-dependent. On some platforms, the value of the
* {@code stackSize} parameter may have no effect whatsoever.
*
*
The virtual machine is free to treat the {@code stackSize}
* parameter as a suggestion. If the specified value is unreasonably low
* for the platform, the virtual machine may instead use some
* platform-specific minimum value; if the specified value is unreasonably
* high, the virtual machine may instead use some platform-specific
* maximum. Likewise, the virtual machine is free to round the specified
* value up or down as it sees fit (or to ignore it completely).
*
*
Specifying a value of zero for the {@code stackSize} parameter will
* cause this constructor to behave exactly like the
* {@code Thread(ThreadGroup, Runnable, String)} constructor.
*
*
Due to the platform-dependent nature of the behavior of this
* constructor, extreme care should be exercised in its use.
* The thread stack size necessary to perform a given computation will
* likely vary from one JRE implementation to another. In light of this
* variation, careful tuning of the stack size parameter may be required,
* and the tuning may need to be repeated for each JRE implementation on
* which an application is to run.
*
*
Implementation note: Java platform implementers are encouraged to
* document their implementation's behavior with respect to the
* {@code stackSize} parameter.
*
*
* @param group
* the thread group. If {@code null} and there is a security
* manager, the group is determined by {@linkplain
* SecurityManager#getThreadGroup SecurityManager.getThreadGroup()}.
* If there is not a security manager or {@code
* SecurityManager.getThreadGroup()} returns {@code null}, the group
* is set to the current thread's thread group.
*
* @param target
* the object whose {@code run} method is invoked when this thread
* is started. If {@code null}, this thread's run method is invoked.
*
* @param name
* the name of the new thread
*
* @param stackSize
* the desired stack size for the new thread, or zero to indicate
* that this parameter is to be ignored.
*
* @throws SecurityException
* if the current thread cannot create a thread in the specified
* thread group
*
* @since 1.4
*/
public Thread(ThreadGroup group, Runnable target, String name, long stackSize)
{
init(group, target, name, stackSize);
}
/**
* Causes this thread to begin execution; the Java Virtual Machine
* calls the run method of this thread.
*
* The result is that two threads are running concurrently: the
* current thread (which returns from the call to the
* start method) and the other thread (which executes its
* run method).
*
* It is never legal to start a thread more than once.
* In particular, a thread may not be restarted once it has completed
* execution.
*
* @exception IllegalThreadStateException if the thread was already
* started.
* @see #run()
* @see #stop()
*/
// used to be synchronized. We defer this to CProver.startThread
public void start()
{
// The call to `startThread` creates a thread in JBMC. The number provided (333)
// allows JBMC to syntactically match the `startThread` with the call to `endThread`
// and understand where the thread finishes.
// This "matching" is necessary to support the creation of two or more threads in
// the same function.
CProver.startThread(333);
target.run();
CProver.endThread(333);
}
// private native void start0();
/**
* If this thread was constructed using a separate
* Runnable run object, then that
* Runnable object's run method is called;
* otherwise, this method does nothing and returns.
*
* Subclasses of Thread should override this method.
*
* @see #start()
* @see #stop()
* @see #Thread(ThreadGroup, Runnable, String)
*/
@Override
public void run()
{
// FIXME:, uncommenting the following code leads to infinite recursion.
// if (target != null)
// {
// target.run();
// }
}
/**
* This method is called by the system to give a Thread
* a chance to clean up before it actually exits.
*/
// private void exit() {
// CProver.assume(0);
// // if (group != null) {
// // group.threadTerminated(this);
// // group = null;
// // }
// // /* Aggressively null out all reference fields: see bug 4006245 */
// // target = null;
// // /* Speed the release of some of these resources */
// // threadLocals = null;
// // inheritableThreadLocals = null;
// // inheritedAccessControlContext = null;
// // blocker = null;
// // uncaughtExceptionHandler = null;
// }
// /**
// * Forces the thread to stop executing.
// *
// * If there is a security manager installed, its checkAccess
// * method is called with this
// * as its argument. This may result in a
// * SecurityException being raised (in the current thread).
// *
// * If this thread is different from the current thread (that is, the current
// * thread is trying to stop a thread other than itself), the
// * security manager's checkPermission method (with a
// * RuntimePermission("stopThread") argument) is called in
// * addition.
// * Again, this may result in throwing a
// * SecurityException (in the current thread).
// *
// * The thread represented by this thread is forced to stop whatever
// * it is doing abnormally and to throw a newly created
// * ThreadDeath object as an exception.
// *
// * It is permitted to stop a thread that has not yet been started.
// * If the thread is eventually started, it immediately terminates.
// *
// * An application should not normally try to catch
// * ThreadDeath unless it must do some extraordinary
// * cleanup operation (note that the throwing of
// * ThreadDeath causes finally clauses of
// * try statements to be executed before the thread
// * officially dies). If a catch clause catches a
// * ThreadDeath object, it is important to rethrow the
// * object so that the thread actually dies.
// *
// * The top-level error handler that reacts to otherwise uncaught
// * exceptions does not print out a message or otherwise notify the
// * application if the uncaught exception is an instance of
// * ThreadDeath.
// *
// * @exception SecurityException if the current thread cannot
// * modify this thread.
// * @see #interrupt()
// * @see #checkAccess()
// * @see #run()
// * @see #start()
// * @see ThreadDeath
// * @see ThreadGroup#uncaughtException(Thread,Throwable)
// * @see SecurityManager#checkAccess(Thread)
// * @see SecurityManager#checkPermission
// * @deprecated This method is inherently unsafe. Stopping a thread with
// * Thread.stop causes it to unlock all of the monitors that it
// * has locked (as a natural consequence of the unchecked
// * ThreadDeath exception propagating up the stack). If
// * any of the objects previously protected by these monitors were in
// * an inconsistent state, the damaged objects become visible to
// * other threads, potentially resulting in arbitrary behavior. Many
// * uses of stop should be replaced by code that simply
// * modifies some variable to indicate that the target thread should
// * stop running. The target thread should check this variable
// * regularly, and return from its run method in an orderly fashion
// * if the variable indicates that it is to stop running. If the
// * target thread waits for long periods (on a condition variable,
// * for example), the interrupt method should be used to
// * interrupt the wait.
// * For more information, see
// * Why
// * are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
// */
// @Deprecated
// public final void stop() {
// CProver.assume(false);
// // SecurityManager security = System.getSecurityManager();
// // if (security != null) {
// // checkAccess();
// // if (this != Thread.currentThread()) {
// // security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
// // }
// // }
// // // A zero status value corresponds to "NEW", it can't change to
// // // not-NEW because we hold the lock.
// // if (threadStatus != 0) {
// // resume(); // Wake up thread if it was suspended; no-op otherwise
// // }
// // // The VM can handle all thread states
// // stop0(new ThreadDeath());
// }
// /**
// * Throws {@code UnsupportedOperationException}.
// *
// * @param obj ignored
// *
// * @deprecated This method was originally designed to force a thread to stop
// * and throw a given {@code Throwable} as an exception. It was
// * inherently unsafe (see {@link #stop()} for details), and furthermore
// * could be used to generate exceptions that the target thread was
// * not prepared to handle.
// * For more information, see
// * Why
// * are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
// */
// @Deprecated
// public final synchronized void stop(Throwable obj) {
// throw new UnsupportedOperationException();
// }
// /**
// * Interrupts this thread.
// *
// *
Unless the current thread is interrupting itself, which is
// * always permitted, the {@link #checkAccess() checkAccess} method
// * of this thread is invoked, which may cause a {@link
// * SecurityException} to be thrown.
// *
// *
If this thread is blocked in an invocation of the {@link
// * Object#wait() wait()}, {@link Object#wait(long) wait(long)}, or {@link
// * Object#wait(long, int) wait(long, int)} methods of the {@link Object}
// * class, or of the {@link #join()}, {@link #join(long)}, {@link
// * #join(long, int)}, {@link #sleep(long)}, or {@link #sleep(long, int)},
// * methods of this class, then its interrupt status will be cleared and it
// * will receive an {@link InterruptedException}.
// *
// *
If this thread is blocked in an I/O operation upon an {@link
// * java.nio.channels.InterruptibleChannel InterruptibleChannel}
// * then the channel will be closed, the thread's interrupt
// * status will be set, and the thread will receive a {@link
// * java.nio.channels.ClosedByInterruptException}.
// *
// *
If this thread is blocked in a {@link java.nio.channels.Selector}
// * then the thread's interrupt status will be set and it will return
// * immediately from the selection operation, possibly with a non-zero
// * value, just as if the selector's {@link
// * java.nio.channels.Selector#wakeup wakeup} method were invoked.
// *
// *
If none of the previous conditions hold then this thread's interrupt
// * status will be set.
// *
// *
Interrupting a thread that is not alive need not have any effect.
// *
// * @throws SecurityException
// * if the current thread cannot modify this thread
// *
// * @revised 6.0
// * @spec JSR-51
// */
// // public void interrupt() {
// // CProver.assume(false);`
// // // if (this != Thread.currentThread())
// // // checkAccess();
// // // synchronized (blockerLock) {
// // // Interruptible b = blocker;
// // // if (b != null) {
// // // interrupt0(); // Just to set the interrupt flag
// // // b.interrupt(this);
// // // return;
// // // }
// // // }
// // // interrupt0();
// // }
// /**
// * Tests whether the current thread has been interrupted. The
// * interrupted status of the thread is cleared by this method. In
// * other words, if this method were to be called twice in succession, the
// * second call would return false (unless the current thread were
// * interrupted again, after the first call had cleared its interrupted
// * status and before the second call had examined it).
// *
// *
A thread interruption ignored because a thread was not alive
// * at the time of the interrupt will be reflected by this method
// * returning false.
// *
// * @return true if the current thread has been interrupted;
// * false otherwise.
// * @see #isInterrupted()
// * @revised 6.0
// */
// // public static boolean interrupted() {
// // CProver.assume(false);
// // return false;
// // // return currentThread().isInterrupted(true);
// // }
// /**
// * Tests whether this thread has been interrupted. The interrupted
// * status of the thread is unaffected by this method.
// *
// *
A thread interruption ignored because a thread was not alive
// * at the time of the interrupt will be reflected by this method
// * returning false.
// *
// * @return true if this thread has been interrupted;
// * false otherwise.
// * @see #interrupted()
// * @revised 6.0
// */
// // public boolean isInterrupted() {
// // return isInterrupted(false);
// // }
// /**
// * Tests if some Thread has been interrupted. The interrupted state
// * is reset or not based on the value of ClearInterrupted that is
// * passed.
// */
// // private native boolean isInterrupted(boolean ClearInterrupted);
// /**
// * Throws {@link NoSuchMethodError}.
// *
// * @deprecated This method was originally designed to destroy this
// * thread without any cleanup. Any monitors it held would have
// * remained locked. However, the method was never implemented.
// * If if were to be implemented, it would be deadlock-prone in
// * much the manner of {@link #suspend}. If the target thread held
// * a lock protecting a critical system resource when it was
// * destroyed, no thread could ever access this resource again.
// * If another thread ever attempted to lock this resource, deadlock
// * would result. Such deadlocks typically manifest themselves as
// * "frozen" processes. For more information, see
// *
// * Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
// * @throws NoSuchMethodError always
// */
// // @Deprecated
// // public void destroy() {
// // throw new NoSuchMethodError();
// // }
// /**
// * Tests if this thread is alive. A thread is alive if it has
// * been started and has not yet died.
// *
// * @return true if this thread is alive;
// * false otherwise.
// */
// // public final native boolean isAlive();
// /**
// * Suspends this thread.
// *
// * First, the checkAccess method of this thread is called
// * with no arguments. This may result in throwing a
// * SecurityException (in the current thread).
// *
// * If the thread is alive, it is suspended and makes no further
// * progress unless and until it is resumed.
// *
// * @exception SecurityException if the current thread cannot modify
// * this thread.
// * @see #checkAccess
// * @deprecated This method has been deprecated, as it is
// * inherently deadlock-prone. If the target thread holds a lock on the
// * monitor protecting a critical system resource when it is suspended, no
// * thread can access this resource until the target thread is resumed. If
// * the thread that would resume the target thread attempts to lock this
// * monitor prior to calling resume, deadlock results. Such
// * deadlocks typically manifest themselves as "frozen" processes.
// * For more information, see
// * Why
// * are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
// */
// // @Deprecated
// // public final void suspend() {
// // checkAccess();
// // suspend0();
// // }
// /**
// * Resumes a suspended thread.
// *
// * First, the checkAccess method of this thread is called
// * with no arguments. This may result in throwing a
// * SecurityException (in the current thread).
// *
// * If the thread is alive but suspended, it is resumed and is
// * permitted to make progress in its execution.
// *
// * @exception SecurityException if the current thread cannot modify this
// * thread.
// * @see #checkAccess
// * @see #suspend()
// * @deprecated This method exists solely for use with {@link #suspend},
// * which has been deprecated because it is deadlock-prone.
// * For more information, see
// * Why
// * are Thread.stop, Thread.suspend and Thread.resume Deprecated?.
// */
// @Deprecated
// // public final void resume() {
// // checkAccess();
// // resume0();
// // }
// /**
// * Changes the priority of this thread.
// *
// * First the checkAccess method of this thread is called
// * with no arguments. This may result in throwing a
// * SecurityException.
// *
// * Otherwise, the priority of this thread is set to the smaller of
// * the specified newPriority and the maximum permitted
// * priority of the thread's thread group.
// *
// * @param newPriority priority to set this thread to
// * @exception IllegalArgumentException If the priority is not in the
// * range MIN_PRIORITY to
// * MAX_PRIORITY.
// * @exception SecurityException if the current thread cannot modify
// * this thread.
// * @see #getPriority
// * @see #checkAccess()
// * @see #getThreadGroup()
// * @see #MAX_PRIORITY
// * @see #MIN_PRIORITY
// * @see ThreadGroup#getMaxPriority()
// */
// // public final void setPriority(int newPriority) {
// // ThreadGroup g;
// // checkAccess();
// // if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
// // throw new IllegalArgumentException();
// // }
// // if((g = getThreadGroup()) != null) {
// // if (newPriority > g.getMaxPriority()) {
// // newPriority = g.getMaxPriority();
// // }
// // setPriority0(priority = newPriority);
// // }
// // }
// // /**
// // * Returns this thread's priority.
// // *
// // * @return this thread's priority.
// // * @see #setPriority
// // */
// // public final int getPriority() {
// // return priority;
// // }
// /**
// * Changes the name of this thread to be equal to the argument
// * name.
// *
// * First the checkAccess method of this thread is called
// * with no arguments. This may result in throwing a
// * SecurityException.
// *
// * @param name the new name for this thread.
// * @exception SecurityException if the current thread cannot modify this
// * thread.
// * @see #getName
// * @see #checkAccess()
// */
// // public final synchronized void setName(String name) {
// // checkAccess();
// // if (name == null) {
// // throw new NullPointerException("name cannot be null");
// // }
// // this.name = name;
// // if (threadStatus != 0) {
// // setNativeName(name);
// // }
// // }
// /**
// * Returns this thread's name.
// *
// * @return this thread's name.
// * @see #setName(String)
// */
// // public final String getName() {
// // return name;
// // }
// /**
// * Returns the thread group to which this thread belongs.
// * This method returns null if this thread has died
// * (been stopped).
// *
// * @return this thread's thread group.
// */
// // public final ThreadGroup getThreadGroup() {
// // return group;
// // }
// /**
// * Returns an estimate of the number of active threads in the current
// * thread's {@linkplain java.lang.ThreadGroup thread group} and its
// * subgroups. Recursively iterates over all subgroups in the current
// * thread's thread group.
// *
// *
The value returned is only an estimate because the number of
// * threads may change dynamically while this method traverses internal
// * data structures, and might be affected by the presence of certain
// * system threads. This method is intended primarily for debugging
// * and monitoring purposes.
// *
// * @return an estimate of the number of active threads in the current
// * thread's thread group and in any other thread group that
// * has the current thread's thread group as an ancestor
// */
// // public static int activeCount() {
// // return currentThread().getThreadGroup().activeCount();
// // }
// /**
// * Copies into the specified array every active thread in the current
// * thread's thread group and its subgroups. This method simply
// * invokes the {@link java.lang.ThreadGroup#enumerate(Thread[])}
// * method of the current thread's thread group.
// *
// *
An application might use the {@linkplain #activeCount activeCount}
// * method to get an estimate of how big the array should be, however
// * if the array is too short to hold all the threads, the extra threads
// * are silently ignored. If it is critical to obtain every active
// * thread in the current thread's thread group and its subgroups, the
// * invoker should verify that the returned int value is strictly less
// * than the length of {@code tarray}.
// *
// *
Due to the inherent race condition in this method, it is recommended
// * that the method only be used for debugging and monitoring purposes.
// *
// * @param tarray
// * an array into which to put the list of threads
// *
// * @return the number of threads put into the array
// *
// * @throws SecurityException
// * if {@link java.lang.ThreadGroup#checkAccess} determines that
// * the current thread cannot access its thread group
// */
// // public static int enumerate(Thread tarray[]) {
// // return currentThread().getThreadGroup().enumerate(tarray);
// // }
// /**
// * Counts the number of stack frames in this thread. The thread must
// * be suspended.
// *
// * @return the number of stack frames in this thread.
// * @exception IllegalThreadStateException if this thread is not
// * suspended.
// * @deprecated The definition of this call depends on {@link #suspend},
// * which is deprecated. Further, the results of this call
// * were never well-defined.
// */
// @Deprecated
// // public native int countStackFrames();
// /**
// * Waits at most {@code millis} milliseconds for this thread to
// * die. A timeout of {@code 0} means to wait forever.
// *
// *
This implementation uses a loop of {@code this.wait} calls
// * conditioned on {@code this.isAlive}. As a thread terminates the
// * {@code this.notifyAll} method is invoked. It is recommended that
// * applications not use {@code wait}, {@code notify}, or
// * {@code notifyAll} on {@code Thread} instances.
// *
// * @param millis
// * the time to wait in milliseconds
// *
// * @throws IllegalArgumentException
// * if the value of {@code millis} is negative
// *
// * @throws InterruptedException
// * if any thread has interrupted the current thread. The
// * interrupted status of the current thread is
// * cleared when this exception is thrown.
// */
// // public final synchronized void join(long millis)
// // throws InterruptedException {
// // long base = System.currentTimeMillis();
// // long now = 0;
// // if (millis < 0) {
// // throw new IllegalArgumentException("timeout value is negative");
// // }
// // if (millis == 0) {
// // while (isAlive()) {
// // wait(0);
// // }
// // } else {
// // while (isAlive()) {
// // long delay = millis - now;
// // if (delay <= 0) {
// // break;
// // }
// // wait(delay);
// // now = System.currentTimeMillis() - base;
// // }
// // }
// // }
// /**
// * Waits at most {@code millis} milliseconds plus
// * {@code nanos} nanoseconds for this thread to die.
// *
// *
This implementation uses a loop of {@code this.wait} calls
// * conditioned on {@code this.isAlive}. As a thread terminates the
// * {@code this.notifyAll} method is invoked. It is recommended that
// * applications not use {@code wait}, {@code notify}, or
// * {@code notifyAll} on {@code Thread} instances.
// *
// * @param millis
// * the time to wait in milliseconds
// *
// * @param nanos
// * {@code 0-999999} additional nanoseconds to wait
// *
// * @throws IllegalArgumentException
// * if the value of {@code millis} is negative, or the value
// * of {@code nanos} is not in the range {@code 0-999999}
// *
// * @throws InterruptedException
// * if any thread has interrupted the current thread. The
// * interrupted status of the current thread is
// * cleared when this exception is thrown.
// */
// // public final synchronized void join(long millis, int nanos)
// // throws InterruptedException {
// // if (millis < 0) {
// // throw new IllegalArgumentException("timeout value is negative");
// // }
// // if (nanos < 0 || nanos > 999999) {
// // throw new IllegalArgumentException(
// // "nanosecond timeout value out of range");
// // }
// // if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
// // millis++;
// // }
// // join(millis);
// // }
// // /**
// // * Waits for this thread to die.
// // *
// // *
An invocation of this method behaves in exactly the same
// // * way as the invocation
// // *
// // *
// // *
// // * @throws InterruptedException
// // * if any thread has interrupted the current thread. The
// // * interrupted status of the current thread is
// // * cleared when this exception is thrown.
// // */
// // public final void join() throws InterruptedException {
// // join(0);
// // }
// // /**
// // * Prints a stack trace of the current thread to the standard error stream.
// // * This method is used only for debugging.
// // *
// // * @see Throwable#printStackTrace()
// // */
// // public static void dumpStack() {
// // new Exception("Stack trace").printStackTrace();
// // }
// // /**
// // * Marks this thread as either a {@linkplain #isDaemon daemon} thread
// // * or a user thread. The Java Virtual Machine exits when the only
// // * threads running are all daemon threads.
// // *
// // *
This method must be invoked before the thread is started.
// // *
// // * @param on
// // * if {@code true}, marks this thread as a daemon thread
// // *
// // * @throws IllegalThreadStateException
// // * if this thread is {@linkplain #isAlive alive}
// // *
// // * @throws SecurityException
// // * if {@link #checkAccess} determines that the current
// // * thread cannot modify this thread
// // */
// // public final void setDaemon(boolean on) {
// // checkAccess();
// // if (isAlive()) {
// // throw new IllegalThreadStateException();
// // }
// // daemon = on;
// // }
// // /**
// // * Tests if this thread is a daemon thread.
// // *
// // * @return true if this thread is a daemon thread;
// // * false otherwise.
// // * @see #setDaemon(boolean)
// // */
// // public final boolean isDaemon() {
// // return daemon;
// // }
// // /**
// // * Determines if the currently running thread has permission to
// // * modify this thread.
// // *
// // * If there is a security manager, its checkAccess method
// // * is called with this thread as its argument. This may result in
// // * throwing a SecurityException.
// // *
// // * @exception SecurityException if the current thread is not allowed to
// // * access this thread.
// // * @see SecurityManager#checkAccess(Thread)
// // */
// // public final void checkAccess() {
// // SecurityManager security = System.getSecurityManager();
// // if (security != null) {
// // security.checkAccess(this);
// // }
// // }
// // /**
// // * Returns a string representation of this thread, including the
// // * thread's name, priority, and thread group.
// // *
// // * @return a string representation of this thread.
// // */
// // public String toString() {
// // ThreadGroup group = getThreadGroup();
// // if (group != null) {
// // return "Thread[" + getName() + "," + getPriority() + "," +
// // group.getName() + "]";
// // } else {
// // return "Thread[" + getName() + "," + getPriority() + "," +
// // "" + "]";
// // }
// // }
// // /**
// // * Returns the context ClassLoader for this Thread. The context
// // * ClassLoader is provided by the creator of the thread for use
// // * by code running in this thread when loading classes and resources.
// // * If not {@linkplain #setContextClassLoader set}, the default is the
// // * ClassLoader context of the parent Thread. The context ClassLoader of the
// // * primordial thread is typically set to the class loader used to load the
// // * application.
// // *
// // *
If a security manager is present, and the invoker's class loader is not
// // * {@code null} and is not the same as or an ancestor of the context class
// // * loader, then this method invokes the security manager's {@link
// // * SecurityManager#checkPermission(java.security.Permission) checkPermission}
// // * method with a {@link RuntimePermission RuntimePermission}{@code
// // * ("getClassLoader")} permission to verify that retrieval of the context
// // * class loader is permitted.
// // *
// // * @return the context ClassLoader for this Thread, or {@code null}
// // * indicating the system class loader (or, failing that, the
// // * bootstrap class loader)
// // *
// // * @throws SecurityException
// // * if the current thread cannot get the context ClassLoader
// // *
// // * @since 1.2
// // */
// // @CallerSensitive
// // public ClassLoader getContextClassLoader() {
// // if (contextClassLoader == null)
// // return null;
// // SecurityManager sm = System.getSecurityManager();
// // if (sm != null) {
// // ClassLoader.checkClassLoaderPermission(contextClassLoader,
// // Reflection.getCallerClass());
// // }
// // return contextClassLoader;
// // }
// // /**
// // * Sets the context ClassLoader for this Thread. The context
// // * ClassLoader can be set when a thread is created, and allows
// // * the creator of the thread to provide the appropriate class loader,
// // * through {@code getContextClassLoader}, to code running in the thread
// // * when loading classes and resources.
// // *
// // *
If a security manager is present, its {@link
// // * SecurityManager#checkPermission(java.security.Permission) checkPermission}
// // * method is invoked with a {@link RuntimePermission RuntimePermission}{@code
// // * ("setContextClassLoader")} permission to see if setting the context
// // * ClassLoader is permitted.
// // *
// // * @param cl
// // * the context ClassLoader for this Thread, or null indicating the
// // * system class loader (or, failing that, the bootstrap class loader)
// // *
// // * @throws SecurityException
// // * if the current thread cannot set the context ClassLoader
// // *
// // * @since 1.2
// // */
// // public void setContextClassLoader(ClassLoader cl) {
// // SecurityManager sm = System.getSecurityManager();
// // if (sm != null) {
// // sm.checkPermission(new RuntimePermission("setContextClassLoader"));
// // }
// // contextClassLoader = cl;
// // }
// // /**
// // * Returns true if and only if the current thread holds the
// // * monitor lock on the specified object.
// // *
// // *
This method is designed to allow a program to assert that
// // * the current thread already holds a specified lock:
// // *
// // * assert Thread.holdsLock(obj);
// // *
// // *
// // * @param obj the object on which to test lock ownership
// // * @throws NullPointerException if obj is null
// // * @return true if the current thread holds the monitor lock on
// // * the specified object.
// // * @since 1.4
// // */
// // public static native boolean holdsLock(Object obj);
// // private static final StackTraceElement[] EMPTY_STACK_TRACE
// // = new StackTraceElement[0];
// // /**
// // * Returns an array of stack trace elements representing the stack dump
// // * of this thread. This method will return a zero-length array if
// // * this thread has not started, has started but has not yet been
// // * scheduled to run by the system, or has terminated.
// // * If the returned array is of non-zero length then the first element of
// // * the array represents the top of the stack, which is the most recent
// // * method invocation in the sequence. The last element of the array
// // * represents the bottom of the stack, which is the least recent method
// // * invocation in the sequence.
// // *
// // *
If there is a security manager, and this thread is not
// // * the current thread, then the security manager's
// // * checkPermission method is called with a
// // * RuntimePermission("getStackTrace") permission
// // * to see if it's ok to get the stack trace.
// // *
// // *
Some virtual machines may, under some circumstances, omit one
// // * or more stack frames from the stack trace. In the extreme case,
// // * a virtual machine that has no stack trace information concerning
// // * this thread is permitted to return a zero-length array from this
// // * method.
// // *
// // * @return an array of StackTraceElement,
// // * each represents one stack frame.
// // *
// // * @throws SecurityException
// // * if a security manager exists and its
// // * checkPermission method doesn't allow
// // * getting the stack trace of thread.
// // * @see SecurityManager#checkPermission
// // * @see RuntimePermission
// // * @see Throwable#getStackTrace
// // *
// // * @since 1.5
// // */
// // public StackTraceElement[] getStackTrace() {
// // if (this != Thread.currentThread()) {
// // // check for getStackTrace permission
// // SecurityManager security = System.getSecurityManager();
// // if (security != null) {
// // security.checkPermission(
// // SecurityConstants.GET_STACK_TRACE_PERMISSION);
// // }
// // // optimization so we do not call into the vm for threads that
// // // have not yet started or have terminated
// // if (!isAlive()) {
// // return EMPTY_STACK_TRACE;
// // }
// // StackTraceElement[][] stackTraceArray = dumpThreads(new Thread[] {this});
// // StackTraceElement[] stackTrace = stackTraceArray[0];
// // // a thread that was alive during the previous isAlive call may have
// // // since terminated, therefore not having a stacktrace.
// // if (stackTrace == null) {
// // stackTrace = EMPTY_STACK_TRACE;
// // }
// // return stackTrace;
// // } else {
// // // Don't need JVM help for current thread
// // return (new Exception()).getStackTrace();
// // }
// // }
// // /**
// // * Returns a map of stack traces for all live threads.
// // * The map keys are threads and each map value is an array of
// // * StackTraceElement that represents the stack dump
// // * of the corresponding Thread.
// // * The returned stack traces are in the format specified for
// // * the {@link #getStackTrace getStackTrace} method.
// // *
// // *
The threads may be executing while this method is called.
// // * The stack trace of each thread only represents a snapshot and
// // * each stack trace may be obtained at different time. A zero-length
// // * array will be returned in the map value if the virtual machine has
// // * no stack trace information about a thread.
// // *
// // *
If there is a security manager, then the security manager's
// // * checkPermission method is called with a
// // * RuntimePermission("getStackTrace") permission as well as
// // * RuntimePermission("modifyThreadGroup") permission
// // * to see if it is ok to get the stack trace of all threads.
// // *
// // * @return a Map from Thread to an array of
// // * StackTraceElement that represents the stack trace of
// // * the corresponding thread.
// // *
// // * @throws SecurityException
// // * if a security manager exists and its
// // * checkPermission method doesn't allow
// // * getting the stack trace of thread.
// // * @see #getStackTrace
// // * @see SecurityManager#checkPermission
// // * @see RuntimePermission
// // * @see Throwable#getStackTrace
// // *
// // * @since 1.5
// // */
// // public static Map getAllStackTraces() {
// // // check for getStackTrace permission
// // SecurityManager security = System.getSecurityManager();
// // if (security != null) {
// // security.checkPermission(
// // SecurityConstants.GET_STACK_TRACE_PERMISSION);
// // security.checkPermission(
// // SecurityConstants.MODIFY_THREADGROUP_PERMISSION);
// // }
// // // Get a snapshot of the list of all threads
// // Thread[] threads = getThreads();
// // StackTraceElement[][] traces = dumpThreads(threads);
// // Map m = new HashMap<>(threads.length);
// // for (int i = 0; i < threads.length; i++) {
// // StackTraceElement[] stackTrace = traces[i];
// // if (stackTrace != null) {
// // m.put(threads[i], stackTrace);
// // }
// // // else terminated so we don't put it in the map
// // }
// // return m;
// // }
// // private static final RuntimePermission SUBCLASS_IMPLEMENTATION_PERMISSION =
// // new RuntimePermission("enableContextClassLoaderOverride");
// // /** cache of subclass security audit results */
// // /* Replace with ConcurrentReferenceHashMap when/if it appears in a future
// // * release */
// // private static class Caches {
// // /** cache of subclass security audit results */
// // static final ConcurrentMap subclassAudits =
// // new ConcurrentHashMap<>();
// // /** queue for WeakReferences to audited subclasses */
// // static final ReferenceQueue> subclassAuditsQueue =
// // new ReferenceQueue<>();
// // }
// // /**
// // * Verifies that this (possibly subclass) instance can be constructed
// // * without violating security constraints: the subclass must not override
// // * security-sensitive non-final methods, or else the
// // * "enableContextClassLoaderOverride" RuntimePermission is checked.
// // */
// // private static boolean isCCLOverridden(Class cl) {
// // if (cl == Thread.class)
// // return false;
// // processQueue(Caches.subclassAuditsQueue, Caches.subclassAudits);
// // WeakClassKey key = new WeakClassKey(cl, Caches.subclassAuditsQueue);
// // Boolean result = Caches.subclassAudits.get(key);
// // if (result == null) {
// // result = Boolean.valueOf(auditSubclass(cl));
// // Caches.subclassAudits.putIfAbsent(key, result);
// // }
// // return result.booleanValue();
// // }
// // /**
// // * Performs reflective checks on given subclass to verify that it doesn't
// // * override security-sensitive non-final methods. Returns true if the
// // * subclass overrides any of the methods, false otherwise.
// // */
// // private static boolean auditSubclass(final Class subcl) {
// // Boolean result = AccessController.doPrivileged(
// // new PrivilegedAction() {
// // public Boolean run() {
// // for (Class cl = subcl;
// // cl != Thread.class;
// // cl = cl.getSuperclass())
// // {
// // try {
// // cl.getDeclaredMethod("getContextClassLoader", new Class[0]);
// // return Boolean.TRUE;
// // } catch (NoSuchMethodException ex) {
// // }
// // try {
// // Class[] params = {ClassLoader.class};
// // cl.getDeclaredMethod("setContextClassLoader", params);
// // return Boolean.TRUE;
// // } catch (NoSuchMethodException ex) {
// // }
// // }
// // return Boolean.FALSE;
// // }
// // }
// // );
// // return result.booleanValue();
// // }
// // private native static StackTraceElement[][] dumpThreads(Thread[] threads);
// // private native static Thread[] getThreads();
/**
* Returns the identifier of this Thread. The thread ID is a positive
* long number generated when this thread was created.
* The thread ID is unique and remains unchanged during its lifetime.
* When a thread is terminated, this thread ID may be reused.
*
* @return this thread's ID.
* @since 1.5
*/
public long getId()
{
return tid;
}
// // /**
// // * A thread state. A thread can be in one of the following states:
// // *
// // *
{@link #NEW}
// // * A thread that has not yet started is in this state.
// // *
// // *
{@link #RUNNABLE}
// // * A thread executing in the Java virtual machine is in this state.
// // *
// // *
{@link #BLOCKED}
// // * A thread that is blocked waiting for a monitor lock
// // * is in this state.
// // *
// // *
{@link #WAITING}
// // * A thread that is waiting indefinitely for another thread to
// // * perform a particular action is in this state.
// // *
// // *
{@link #TIMED_WAITING}
// // * A thread that is waiting for another thread to perform an action
// // * for up to a specified waiting time is in this state.
// // *
// // *
{@link #TERMINATED}
// // * A thread that has exited is in this state.
// // *
// // *
// // *
// // *
// // * A thread can be in only one state at a given point in time.
// // * These states are virtual machine states which do not reflect
// // * any operating system thread states.
// // *
// // * @since 1.5
// // * @see #getState
// // */
// // public enum State {
// // /**
// // * Thread state for a thread which has not yet started.
// // */
// // NEW,
// // /**
// // * Thread state for a runnable thread. A thread in the runnable
// // * state is executing in the Java virtual machine but it may
// // * be waiting for other resources from the operating system
// // * such as processor.
// // */
// // RUNNABLE,
// // /**
// // * Thread state for a thread blocked waiting for a monitor lock.
// // * A thread in the blocked state is waiting for a monitor lock
// // * to enter a synchronized block/method or
// // * reenter a synchronized block/method after calling
// // * {@link Object#wait() Object.wait}.
// // */
// // BLOCKED,
// // /**
// // * Thread state for a waiting thread.
// // * A thread is in the waiting state due to calling one of the
// // * following methods:
// // *
// // *
{@link Object#wait() Object.wait} with no timeout
// // *
{@link #join() Thread.join} with no timeout
// // *
{@link LockSupport#park() LockSupport.park}
// // *
// // *
// // *
A thread in the waiting state is waiting for another thread to
// // * perform a particular action.
// // *
// // * For example, a thread that has called Object.wait()
// // * on an object is waiting for another thread to call
// // * Object.notify() or Object.notifyAll() on
// // * that object. A thread that has called Thread.join()
// // * is waiting for a specified thread to terminate.
// // */
// // WAITING,
// // /**
// // * Thread state for a waiting thread with a specified waiting time.
// // * A thread is in the timed waiting state due to calling one of
// // * the following methods with a specified positive waiting time:
// // *
// // *
{@link #sleep Thread.sleep}
// // *
{@link Object#wait(long) Object.wait} with timeout
// // */
// // TIMED_WAITING,
// // /**
// // * Thread state for a terminated thread.
// // * The thread has completed execution.
// // */
// // TERMINATED;
// // }
// // /**
// // * Returns the state of this thread.
// // * This method is designed for use in monitoring of the system state,
// // * not for synchronization control.
// // *
// // * @return this thread's state.
// // * @since 1.5
// // */
// // public State getState() {
// // // get current thread state
// // return sun.misc.VM.toThreadState(threadStatus);
// // }
// // // Added in JSR-166
// // /**
// // * Interface for handlers invoked when a Thread abruptly
// // * terminates due to an uncaught exception.
// // *
When a thread is about to terminate due to an uncaught exception
// // * the Java Virtual Machine will query the thread for its
// // * UncaughtExceptionHandler using
// // * {@link #getUncaughtExceptionHandler} and will invoke the handler's
// // * uncaughtException method, passing the thread and the
// // * exception as arguments.
// // * If a thread has not had its UncaughtExceptionHandler
// // * explicitly set, then its ThreadGroup object acts as its
// // * UncaughtExceptionHandler. If the ThreadGroup object
// // * has no
// // * special requirements for dealing with the exception, it can forward
// // * the invocation to the {@linkplain #getDefaultUncaughtExceptionHandler
// // * default uncaught exception handler}.
// // *
// // * @see #setDefaultUncaughtExceptionHandler
// // * @see #setUncaughtExceptionHandler
// // * @see ThreadGroup#uncaughtException
// // * @since 1.5
// // */
// // @FunctionalInterface
// // public interface UncaughtExceptionHandler {
// // /**
// // * Method invoked when the given thread terminates due to the
// // * given uncaught exception.
// // *
Any exception thrown by this method will be ignored by the
// // * Java Virtual Machine.
// // * @param t the thread
// // * @param e the exception
// // */
// // void uncaughtException(Thread t, Throwable e);
// // }
// // // null unless explicitly set
// // private volatile UncaughtExceptionHandler uncaughtExceptionHandler;
// // // null unless explicitly set
// // private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;
// // /**
// // * Set the default handler invoked when a thread abruptly terminates
// // * due to an uncaught exception, and no other handler has been defined
// // * for that thread.
// // *
// // *
Uncaught exception handling is controlled first by the thread, then
// // * by the thread's {@link ThreadGroup} object and finally by the default
// // * uncaught exception handler. If the thread does not have an explicit
// // * uncaught exception handler set, and the thread's thread group
// // * (including parent thread groups) does not specialize its
// // * uncaughtException method, then the default handler's
// // * uncaughtException method will be invoked.
// // *
By setting the default uncaught exception handler, an application
// // * can change the way in which uncaught exceptions are handled (such as
// // * logging to a specific device, or file) for those threads that would
// // * already accept whatever "default" behavior the system
// // * provided.
// // *
// // *
Note that the default uncaught exception handler should not usually
// // * defer to the thread's ThreadGroup object, as that could cause
// // * infinite recursion.
// // *
// // * @param eh the object to use as the default uncaught exception handler.
// // * If null then there is no default handler.
// // *
// // * @throws SecurityException if a security manager is present and it
// // * denies {@link RuntimePermission}
// // * ("setDefaultUncaughtExceptionHandler")
// // *
// // * @see #setUncaughtExceptionHandler
// // * @see #getUncaughtExceptionHandler
// // * @see ThreadGroup#uncaughtException
// // * @since 1.5
// // */
// // public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
// // SecurityManager sm = System.getSecurityManager();
// // if (sm != null) {
// // sm.checkPermission(
// // new RuntimePermission("setDefaultUncaughtExceptionHandler")
// // );
// // }
// // defaultUncaughtExceptionHandler = eh;
// // }
// // /**
// // * Returns the default handler invoked when a thread abruptly terminates
// // * due to an uncaught exception. If the returned value is null,
// // * there is no default.
// // * @since 1.5
// // * @see #setDefaultUncaughtExceptionHandler
// // * @return the default uncaught exception handler for all threads
// // */
// // public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler(){
// // return defaultUncaughtExceptionHandler;
// // }
// // /**
// // * Returns the handler invoked when this thread abruptly terminates
// // * due to an uncaught exception. If this thread has not had an
// // * uncaught exception handler explicitly set then this thread's
// // * ThreadGroup object is returned, unless this thread
// // * has terminated, in which case null is returned.
// // * @since 1.5
// // * @return the uncaught exception handler for this thread
// // */
// // public UncaughtExceptionHandler getUncaughtExceptionHandler() {
// // return uncaughtExceptionHandler != null ?
// // uncaughtExceptionHandler : group;
// // }
// // /**
// // * Set the handler invoked when this thread abruptly terminates
// // * due to an uncaught exception.
// // *
A thread can take full control of how it responds to uncaught
// // * exceptions by having its uncaught exception handler explicitly set.
// // * If no such handler is set then the thread's ThreadGroup
// // * object acts as its handler.
// // * @param eh the object to use as this thread's uncaught exception
// // * handler. If null then this thread has no explicit handler.
// // * @throws SecurityException if the current thread is not allowed to
// // * modify this thread.
// // * @see #setDefaultUncaughtExceptionHandler
// // * @see ThreadGroup#uncaughtException
// // * @since 1.5
// // */
// // public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
// // checkAccess();
// // uncaughtExceptionHandler = eh;
// // }
// // /**
// // * Dispatch an uncaught exception to the handler. This method is
// // * intended to be called only by the JVM.
// // */
// // private void dispatchUncaughtException(Throwable e) {
// // getUncaughtExceptionHandler().uncaughtException(this, e);
// // }
// // /**
// // * Removes from the specified map any keys that have been enqueued
// // * on the specified reference queue.
// // */
// // static void processQueue(ReferenceQueue> queue,
// // ConcurrentMap>, ?> map)
// // {
// // Reference> ref;
// // while((ref = queue.poll()) != null) {
// // map.remove(ref);
// // }
// // }
// // /**
// // * Weak key for Class objects.
// // **/
// // static class WeakClassKey extends WeakReference> {
// // /**
// // * saved value of the referent's identity hash code, to maintain
// // * a consistent hash code after the referent has been cleared
// // */
// // private final int hash;
// // /**
// // * Create a new WeakClassKey to the given object, registered
// // * with a queue.
// // */
// // WeakClassKey(Class cl, ReferenceQueue> refQueue) {
// // super(cl, refQueue);
// // hash = System.identityHashCode(cl);
// // }
// // /**
// // * Returns the identity hash code of the original referent.
// // */
// // @Override
// // public int hashCode() {
// // return hash;
// // }
// // /**
// // * Returns true if the given object is this identical
// // * WeakClassKey instance, or, if this object's referent has not
// // * been cleared, if the given object is another WeakClassKey
// // * instance with the identical non-null referent as this one.
// // */
// // @Override
// // public boolean equals(Object obj) {
// // if (obj == this)
// // return true;
// // if (obj instanceof WeakClassKey) {
// // Object referent = get();
// // return (referent != null) &&
// // (referent == ((WeakClassKey) obj).get());
// // } else {
// // return false;
// // }
// // }
// // }
// // // The following three initially uninitialized fields are exclusively
// // // managed by class java.util.concurrent.ThreadLocalRandom. These
// // // fields are used to build the high-performance PRNGs in the
// // // concurrent code, and we can not risk accidental false sharing.
// // // Hence, the fields are isolated with @Contended.
// // // /** The current seed for a ThreadLocalRandom */
// // // @sun.misc.Contended("tlr")
// // // long threadLocalRandomSeed;
// // // /** Probe hash value; nonzero if threadLocalRandomSeed initialized */
// // // @sun.misc.Contended("tlr")
// // // int threadLocalRandomProbe;
// // // /** Secondary seed isolated from public ThreadLocalRandom sequence */
// // // @sun.misc.Contended("tlr")
// // // int threadLocalRandomSecondarySeed;
// // // /* Some private helper methods */
// // // private native void setPriority0(int newPriority);
// // // private native void stop0(Object o);
// // // private native void suspend0();
// // // private native void resume0();
// // // private native void interrupt0();
// // // private native void setNativeName(String name);
}
java-models-library-master/src/main/java/java/lang/Throwable.java 0000664 0000000 0000000 00000137204 14323475213 0025316 0 ustar 00root root 0000000 0000000 /*
* 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.io.*;
import java.util.*;
import org.cprover.CProver;
/**
* The {@code Throwable} class is the superclass of all errors and
* exceptions in the Java language. Only objects that are instances of this
* class (or one of its subclasses) are thrown by the Java Virtual Machine or
* can be thrown by the Java {@code throw} statement. Similarly, only
* this class or one of its subclasses can be the argument type in a
* {@code catch} clause.
*
* For the purposes of compile-time checking of exceptions, {@code
* Throwable} and any subclass of {@code Throwable} that is not also a
* subclass of either {@link RuntimeException} or {@link Error} are
* regarded as checked exceptions.
*
*
Instances of two subclasses, {@link java.lang.Error} and
* {@link java.lang.Exception}, are conventionally used to indicate
* that exceptional situations have occurred. Typically, these instances
* are freshly created in the context of the exceptional situation so
* as to include relevant information (such as stack trace data).
*
*
A throwable contains a snapshot of the execution stack of its
* thread at the time it was created. It can also contain a message
* string that gives more information about the error. Over time, a
* throwable can {@linkplain Throwable#addSuppressed suppress} other
* throwables from being propagated. Finally, the throwable can also
* contain a cause: another throwable that caused this
* throwable to be constructed. The recording of this causal information
* is referred to as the chained exception facility, as the
* cause can, itself, have a cause, and so on, leading to a "chain" of
* exceptions, each caused by another.
*
*
One reason that a throwable may have a cause is that the class that
* throws it is built atop a lower layered abstraction, and an operation on
* the upper layer fails due to a failure in the lower layer. It would be bad
* design to let the throwable thrown by the lower layer propagate outward, as
* it is generally unrelated to the abstraction provided by the upper layer.
* Further, doing so would tie the API of the upper layer to the details of
* its implementation, assuming the lower layer's exception was a checked
* exception. Throwing a "wrapped exception" (i.e., an exception containing a
* cause) allows the upper layer to communicate the details of the failure to
* its caller without incurring either of these shortcomings. It preserves
* the flexibility to change the implementation of the upper layer without
* changing its API (in particular, the set of exceptions thrown by its
* methods).
*
*
A second reason that a throwable may have a cause is that the method
* that throws it must conform to a general-purpose interface that does not
* permit the method to throw the cause directly. For example, suppose
* a persistent collection conforms to the {@link java.util.Collection
* Collection} interface, and that its persistence is implemented atop
* {@code java.io}. Suppose the internals of the {@code add} method
* can throw an {@link java.io.IOException IOException}. The implementation
* can communicate the details of the {@code IOException} to its caller
* while conforming to the {@code Collection} interface by wrapping the
* {@code IOException} in an appropriate unchecked exception. (The
* specification for the persistent collection should indicate that it is
* capable of throwing such exceptions.)
*
*
A cause can be associated with a throwable in two ways: via a
* constructor that takes the cause as an argument, or via the
* {@link #initCause(Throwable)} method. New throwable classes that
* wish to allow causes to be associated with them should provide constructors
* that take a cause and delegate (perhaps indirectly) to one of the
* {@code Throwable} constructors that takes a cause.
*
* Because the {@code initCause} method is public, it allows a cause to be
* associated with any throwable, even a "legacy throwable" whose
* implementation predates the addition of the exception chaining mechanism to
* {@code Throwable}.
*
*
By convention, class {@code Throwable} and its subclasses have two
* constructors, one that takes no arguments and one that takes a
* {@code String} argument that can be used to produce a detail message.
* Further, those subclasses that might likely have a cause associated with
* them should have two more constructors, one that takes a
* {@code Throwable} (the cause), and one that takes a
* {@code String} (the detail message) and a {@code Throwable} (the
* cause).
*
* @author unascribed
* @author Josh Bloch (Added exception chaining and programmatic access to
* stack trace in 1.4.)
* @jls 11.2 Compile-Time Checking of Exceptions
* @since JDK1.0
*/
public class Throwable implements Serializable {
private static final long serialVersionUID = -3042686055658047285L;
/**
* Native code saves some indication of the stack backtrace in this slot.
*/
// private transient Object backtrace;
/**
* Specific details about the Throwable. For example, for
* {@code FileNotFoundException}, this contains the name of
* the file that could not be found.
*
* @serial
*/
private String detailMessage;
/**
* Holder class to defer initializing sentinel objects only used
* for serialization.
*/
// DIFFBLUE MODEL LIBRARY We do not currently support this class.
// private static class SentinelHolder {
// /**
// * {@linkplain #setStackTrace(StackTraceElement[]) Setting the
// * stack trace} to a one-element array containing this sentinel
// * value indicates future attempts to set the stack trace will be
// * ignored. The sentinal is equal to the result of calling:
// * {@code new StackTraceElement("", "", null, Integer.MIN_VALUE)}
// */
// public static final StackTraceElement STACK_TRACE_ELEMENT_SENTINEL =
// new StackTraceElement("", "", null, Integer.MIN_VALUE);
// /**
// * Sentinel value used in the serial form to indicate an immutable
// * stack trace.
// */
// public static final StackTraceElement[] STACK_TRACE_SENTINEL =
// new StackTraceElement[] {STACK_TRACE_ELEMENT_SENTINEL};
// }
/**
* A shared value for an empty stack.
*/
// DIFFBLUE MODEL LIBRARY
// private static final StackTraceElement[] UNASSIGNED_STACK = new StackTraceElement[0];
/*
* To allow Throwable objects to be made immutable and safely
* reused by the JVM, such as OutOfMemoryErrors, fields of
* Throwable that are writable in response to user actions, cause,
* stackTrace, and suppressedExceptions obey the following
* protocol:
*
* 1) The fields are initialized to a non-null sentinel value
* which indicates the value has logically not been set.
*
* 2) Writing a null to the field indicates further writes
* are forbidden
*
* 3) The sentinel value may be replaced with another non-null
* value.
*
* For example, implementations of the HotSpot JVM have
* preallocated OutOfMemoryError objects to provide for better
* diagnosability of that situation. These objects are created
* without calling the constructor for that class and the fields
* in question are initialized to null. To support this
* capability, any new fields added to Throwable that require
* being initialized to a non-null value require a coordinated JVM
* change.
*/
/**
* The throwable that caused this throwable to get thrown, or null if this
* throwable was not caused by another throwable, or if the causative
* throwable is unknown. If this field is equal to this throwable itself,
* it indicates that the cause of this throwable has not yet been
* initialized.
*
* @serial
* @since 1.4
*/
private Throwable cause = this;
/**
* The stack trace, as returned by {@link #getStackTrace()}.
*
* The field is initialized to a zero-length array. A {@code
* null} value of this field indicates subsequent calls to {@link
* #setStackTrace(StackTraceElement[])} and {@link
* #fillInStackTrace()} will be be no-ops.
*
* @serial
* @since 1.4
*/
// 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.
// private boolean allowSuppressedExceptions = true;
// Setting this static field introduces an acceptable
// initialization dependency on a few java.util classes.
// DIFFBLUE MODEL LIBRARY Generics are not supported.
// private static final List SUPPRESSED_SENTINEL =
// Collections.unmodifiableList(new ArrayList(0));
/**
* The list of suppressed exceptions, as returned by {@link
* #getSuppressed()}. The list is initialized to a zero-element
* unmodifiable sentinel list. When a serialized Throwable is
* read in, if the {@code suppressedExceptions} field points to a
* zero-element list, the field is reset to the sentinel value.
*
* @serial
* @since 1.7
*/
// DIFFBLUE MODEL LIBRARY
// private List suppressedExceptions = SUPPRESSED_SENTINEL;
/** Message for trying to 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. */
// DIFFBLUE MODEL LIBRARY
// private static final String SELF_SUPPRESSION_MESSAGE = "Self-suppression not permitted";
/** Caption for labeling causative exception stack traces */
// DIFFBLUE MODEL LIBRARY
// private static final String CAUSE_CAPTION = "Caused by: ";
/** Caption for labeling suppressed exception stack traces */
// DIFFBLUE MODEL LIBRARY
// private static final String SUPPRESSED_CAPTION = "Suppressed: ";
/**
* Constructs a new throwable with {@code null} as its detail message.
* The cause is not initialized, and may subsequently be initialized by a
* call to {@link #initCause}.
*
*
The {@link #fillInStackTrace()} method is called to initialize
* the stack trace data in the newly created throwable.
*/
public Throwable() {
// fillInStackTrace();
detailMessage = null;
}
/**
* Constructs a new throwable with the specified detail message. The
* cause is not initialized, and may subsequently be initialized by
* a call to {@link #initCause}.
*
*
The {@link #fillInStackTrace()} method is called to initialize
* the stack trace data in the newly created throwable.
*
* @param message the detail message. The detail message is saved for
* later retrieval by the {@link #getMessage()} method.
*/
public Throwable(String message) {
// fillInStackTrace();
detailMessage = message;
}
/**
* Constructs a new throwable with the specified detail message and
* cause.
Note that the detail message associated with
* {@code cause} is not automatically incorporated in
* this throwable's detail message.
*
*
The {@link #fillInStackTrace()} method is called to initialize
* the stack trace data in the newly created throwable.
*
* @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.4
*/
public Throwable(String message, Throwable cause) {
// fillInStackTrace();
detailMessage = message;
this.cause = cause;
}
/**
* Constructs a new throwable 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}).
* This constructor is useful for throwables that are little more than
* wrappers for other throwables (for example, {@link
* java.security.PrivilegedActionException}).
*
*
The {@link #fillInStackTrace()} method is called to initialize
* the stack trace data in the newly created throwable.
*
* @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.4
*/
public Throwable(Throwable cause) {
// fillInStackTrace();
detailMessage = (cause==null ? null : cause.toString());
this.cause = cause;
}
/**
* Constructs a new throwable with the specified detail message,
* cause, {@linkplain #addSuppressed suppression} enabled or
* disabled, and writable stack trace enabled or disabled. If
* suppression is disabled, {@link #getSuppressed} for this object
* will return a zero-length array and calls to {@link
* #addSuppressed} that would otherwise append an exception to the
* suppressed list will have no effect. If the writable stack
* trace is false, this constructor will not call {@link
* #fillInStackTrace()}, a {@code null} will be written to the
* {@code stackTrace} field, and subsequent calls to {@code
* fillInStackTrace} and {@link
* #setStackTrace(StackTraceElement[])} will not set the stack
* trace. If the writable stack trace is false, {@link
* #getStackTrace} will return a zero length array.
*
*
Note that the other constructors of {@code Throwable} treat
* suppression as being enabled and the stack trace as being
* writable. Subclasses of {@code Throwable} should document any
* conditions under which suppression is disabled and document
* conditions under which the stack trace is not writable.
* Disabling of suppression should only occur in exceptional
* circumstances where special requirements exist, such as a
* virtual machine reusing exception objects under low-memory
* situations. Circumstances where a given exception object is
* repeatedly caught and rethrown, such as to implement control
* flow between two sub-systems, is another situation where
* immutable throwable objects would be appropriate.
*
* @param message the detail message.
* @param cause the cause. (A {@code null} value is permitted,
* and indicates that the cause is nonexistent or unknown.)
* @param enableSuppression whether or not suppression is enabled or disabled
* @param writableStackTrace whether or not the stack trace should be
* writable
*
* @see OutOfMemoryError
* @see NullPointerException
* @see ArithmeticException
* @since 1.7
*/
protected Throwable(String message, Throwable cause,
boolean enableSuppression,
boolean writableStackTrace) {
// DIFFBLUE MODEL LIBRARY
// if (writableStackTrace) {
// fillInStackTrace();
// } else {
// stackTrace = null;
// }
detailMessage = message;
this.cause = cause;
// DIFFBLUE MODEL LIBRARY
// if (!enableSuppression) {
// suppressedExceptions = null;
// }
}
/**
* Returns the detail message string of this throwable.
*
* @return the detail message string of this {@code Throwable} instance
* (which may be {@code null}).
*/
public String getMessage() {
return detailMessage;
}
/**
* Creates a localized description of this throwable.
* Subclasses may override this method in order to produce a
* locale-specific message. For subclasses that do not override this
* method, the default implementation returns the same result as
* {@code getMessage()}.
*
* @return The localized description of this throwable.
* @since JDK1.1
*/
public String getLocalizedMessage() {
return getMessage();
}
/**
* Returns the cause of this throwable or {@code null} if the
* cause is nonexistent or unknown. (The cause is the throwable that
* caused this throwable to get thrown.)
*
*
This implementation returns the cause that was supplied via one of
* the constructors requiring a {@code Throwable}, or that was set after
* creation with the {@link #initCause(Throwable)} method. While it is
* typically unnecessary to override this method, a subclass can override
* it to return a cause set by some other means. This is appropriate for
* a "legacy chained throwable" that predates the addition of chained
* exceptions to {@code Throwable}. Note that it is not
* necessary to override any of the {@code PrintStackTrace} methods,
* all of which invoke the {@code getCause} method to determine the
* cause of a throwable.
*
* @return the cause of this throwable or {@code null} if the
* cause is nonexistent or unknown.
* @since 1.4
*/
public synchronized Throwable getCause() {
return (cause==this ? null : cause);
}
/**
* Initializes the cause of this throwable to the specified value.
* (The cause is the throwable that caused this throwable to get thrown.)
*
*
This method can be called at most once. It is generally called from
* within the constructor, or immediately after creating the
* throwable. If this throwable was created
* with {@link #Throwable(Throwable)} or
* {@link #Throwable(String,Throwable)}, this method cannot be called
* even once.
*
*
An example of using this method on a legacy throwable type
* without other support for setting the cause is:
*
*
*
* @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.)
* @return a reference to this {@code Throwable} instance.
* @throws IllegalArgumentException if {@code cause} is this
* throwable. (A throwable cannot be its own cause.)
* @throws IllegalStateException if this throwable was
* created with {@link #Throwable(Throwable)} or
* {@link #Throwable(String,Throwable)}, or this method has already
* been called on this throwable.
* @since 1.4
*/
public synchronized Throwable initCause(Throwable cause) {
if (this.cause != this)
throw new IllegalStateException("Can't overwrite cause with " +
Objects.toString(cause, "a null"), this);
if (cause == this)
throw new IllegalArgumentException("Self-causation not permitted", this);
this.cause = cause;
return this;
}
/**
* Returns a short description of this throwable.
* The result is the concatenation of:
*
*
the {@linkplain Class#getName() name} of the class of this object
*
": " (a colon and a space)
*
the result of invoking this object's {@link #getLocalizedMessage}
* method
*
* If {@code getLocalizedMessage} returns {@code null}, then just
* the class name is returned.
*
* @return a string representation of this throwable.
*/
public String toString() {
// DIFFBLUE MODEL LIBRARY
// Object.getClass() is not supported for all classes.
// String s = getClass().getName();
String message = getLocalizedMessage();
return (message != null)
? ("java.lang.Throwable: " + message)
: "java.lang.Throwable";
}
/**
* Prints this throwable and its backtrace to the
* standard error stream. This method prints a stack trace for this
* {@code Throwable} object on the error output stream that is
* the value of the field {@code System.err}. The first line of
* output contains the result of the {@link #toString()} method for
* this object. Remaining lines represent data previously recorded by
* the method {@link #fillInStackTrace()}. The format of this
* information depends on the implementation, but the following
* example may be regarded as typical:
*
* java.lang.NullPointerException
* at MyClass.mash(MyClass.java:9)
* at MyClass.crunch(MyClass.java:6)
* at MyClass.main(MyClass.java:3)
*
* This example was produced by running the program:
*
* class MyClass {
* public static void main(String[] args) {
* crunch(null);
* }
* static void crunch(int[] a) {
* mash(a);
* }
* static void mash(int[] b) {
* System.out.println(b[0]);
* }
* }
*
* The backtrace for a throwable with an initialized, non-null cause
* should generally include the backtrace for the cause. The format
* of this information depends on the implementation, but the following
* example may be regarded as typical:
*
* HighLevelException: MidLevelException: LowLevelException
* at Junk.a(Junk.java:13)
* at Junk.main(Junk.java:4)
* Caused by: MidLevelException: LowLevelException
* at Junk.c(Junk.java:23)
* at Junk.b(Junk.java:17)
* at Junk.a(Junk.java:11)
* ... 1 more
* Caused by: LowLevelException
* at Junk.e(Junk.java:30)
* at Junk.d(Junk.java:27)
* at Junk.c(Junk.java:21)
* ... 3 more
*
* Note the presence of lines containing the characters {@code "..."}.
* These lines indicate that the remainder of the stack trace for this
* exception matches the indicated number of frames from the bottom of the
* stack trace of the exception that was caused by this exception (the
* "enclosing" exception). This shorthand can greatly reduce the length
* of the output in the common case where a wrapped exception is thrown
* from same method as the "causative exception" is caught. The above
* example was produced by running the program:
*
* As of release 7, the platform supports the notion of
* suppressed exceptions (in conjunction with the {@code
* try}-with-resources statement). Any exceptions that were
* suppressed in order to deliver an exception are printed out
* beneath the stack trace. The format of this information
* depends on the implementation, but the following example may be
* regarded as typical:
*
*
* Exception in thread "main" java.lang.Exception: Something happened
* at Foo.bar(Foo.java:10)
* at Foo.main(Foo.java:5)
* Suppressed: Resource$CloseFailException: Resource ID = 0
* at Resource.close(Resource.java:26)
* at Foo.bar(Foo.java:9)
* ... 1 more
*
* Note that the "... n more" notation is used on suppressed exceptions
* just at it is used on causes. Unlike causes, suppressed exceptions are
* indented beyond their "containing exceptions."
*
*
An exception can have both a cause and one or more suppressed
* exceptions:
*
* Exception in thread "main" java.lang.Exception: Main block
* at Foo3.main(Foo3.java:7)
* Suppressed: Resource$CloseFailException: Resource ID = 2
* at Resource.close(Resource.java:26)
* at Foo3.main(Foo3.java:5)
* Suppressed: Resource$CloseFailException: Resource ID = 1
* at Resource.close(Resource.java:26)
* at Foo3.main(Foo3.java:5)
* Caused by: java.lang.Exception: I did it
* at Foo3.main(Foo3.java:8)
*
* Likewise, a suppressed exception can have a cause:
*
* Exception in thread "main" java.lang.Exception: Main block
* at Foo4.main(Foo4.java:6)
* Suppressed: Resource2$CloseFailException: Resource ID = 1
* at Resource2.close(Resource2.java:20)
* at Foo4.main(Foo4.java:5)
* Caused by: java.lang.Exception: Rats, you caught me
* at Resource2$CloseFailException.<init>(Resource2.java:45)
* ... 2 more
*
*/
public void printStackTrace() {
// printStackTrace(System.err);
CProver.notModelled();
}
/**
* Prints this throwable and its backtrace to the specified print stream.
*
* @param s {@code PrintStream} to use for output
*/
public void printStackTrace(PrintStream s) {
// printStackTrace(new WrappedPrintStream(s));
CProver.notModelled();
}
// DIFFBLUE MODEL LIBRARY We do not model this private method.
// private void printStackTrace(PrintStreamOrWriter s) {
// // Guard against malicious overrides of Throwable.equals by
// // using a Set with identity equality semantics.
// Set dejaVu =
// Collections.newSetFromMap(new IdentityHashMap());
// dejaVu.add(this);
// synchronized (s.lock()) {
// // Print our stack trace
// s.println(this);
// StackTraceElement[] trace = getOurStackTrace();
// for (StackTraceElement traceElement : trace)
// s.println("\tat " + traceElement);
// // Print suppressed exceptions, if any
// for (Throwable se : getSuppressed())
// se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION, "\t", dejaVu);
// // Print cause, if any
// Throwable ourCause = getCause();
// if (ourCause != null)
// ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, "", dejaVu);
// }
// }
/**
* Print our stack trace as an enclosed exception for the specified
* stack trace.
*/
// DIFFBLUE MODEL LIBRARY We do not model this private method.
// private void printEnclosedStackTrace(PrintStreamOrWriter s,
// StackTraceElement[] enclosingTrace,
// String caption,
// String prefix,
// Set dejaVu) {
// assert Thread.holdsLock(s.lock());
// if (dejaVu.contains(this)) {
// s.println("\t[CIRCULAR REFERENCE:" + this + "]");
// } else {
// dejaVu.add(this);
// // Compute number of frames in common between this and enclosing trace
// StackTraceElement[] trace = getOurStackTrace();
// int m = trace.length - 1;
// int n = enclosingTrace.length - 1;
// while (m >= 0 && n >=0 && trace[m].equals(enclosingTrace[n])) {
// m--; n--;
// }
// int framesInCommon = trace.length - 1 - m;
// // Print our stack trace
// s.println(prefix + caption + this);
// for (int i = 0; i <= m; i++)
// s.println(prefix + "\tat " + trace[i]);
// if (framesInCommon != 0)
// s.println(prefix + "\t... " + framesInCommon + " more");
// // Print suppressed exceptions, if any
// for (Throwable se : getSuppressed())
// se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION,
// prefix +"\t", dejaVu);
// // Print cause, if any
// Throwable ourCause = getCause();
// if (ourCause != null)
// ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, prefix, dejaVu);
// }
// }
/**
* Prints this throwable and its backtrace to the specified
* print writer.
*
* @param s {@code PrintWriter} to use for output
* @since JDK1.1
*/
public void printStackTrace(PrintWriter s) {
// printStackTrace(new WrappedPrintWriter(s));
CProver.notModelled();
}
/**
* Wrapper class for PrintStream and PrintWriter to enable a single
* implementation of printStackTrace.
*/
// DIFFBLUE MODEL LIBRARY
// We do not currently model these classes.
// private abstract static class PrintStreamOrWriter {
// /** Returns the object to be locked when using this StreamOrWriter */
// abstract Object lock();
// /** Prints the specified string as a line on this StreamOrWriter */
// abstract void println(Object o);
// }
// private static class WrappedPrintStream extends PrintStreamOrWriter {
// private final PrintStream printStream;
// WrappedPrintStream(PrintStream printStream) {
// this.printStream = printStream;
// }
// Object lock() {
// return printStream;
// }
// void println(Object o) {
// printStream.println(o);
// }
// }
// private static class WrappedPrintWriter extends PrintStreamOrWriter {
// private final PrintWriter printWriter;
// WrappedPrintWriter(PrintWriter printWriter) {
// this.printWriter = printWriter;
// }
// Object lock() {
// return printWriter;
// }
// void println(Object o) {
// printWriter.println(o);
// }
// }
/**
* Fills in the execution stack trace. This method records within this
* {@code Throwable} object information about the current state of
* the stack frames for the current thread.
*
*
If the stack trace of this {@code Throwable} {@linkplain
* Throwable#Throwable(String, Throwable, boolean, boolean) is not
* writable}, calling this method has no effect.
*
* @return a reference to this {@code Throwable} instance.
* @see java.lang.Throwable#printStackTrace()
*/
// DIFFBLUE MODEL LIBRARY
// Not modelled due to call to native method fillInStackTrace(0)
public synchronized Throwable fillInStackTrace() {
// if (stackTrace != null ||
// backtrace != null /* Out of protocol state */ ) {
// fillInStackTrace(0);
// stackTrace = UNASSIGNED_STACK;
// }
// return this;
CProver.notModelled();
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.nondetWithoutNullForNotModelled();
}
/**
* Provides programmatic access to the stack trace information printed by
* {@link #printStackTrace()}. Returns an array of stack trace elements,
* each representing one stack frame. The zeroth element of the array
* (assuming the array's length is non-zero) represents the top of the
* stack, which is the last method invocation in the sequence. Typically,
* this is the point at which this throwable was created and thrown.
* The last element of the array (assuming the array's length is non-zero)
* represents the bottom of the stack, which is the first method invocation
* in the sequence.
*
*
Some virtual machines may, under some circumstances, omit one
* or more stack frames from the stack trace. In the extreme case,
* a virtual machine that has no stack trace information concerning
* this throwable is permitted to return a zero-length array from this
* method. Generally speaking, the array returned by this method will
* contain one element for every frame that would be printed by
* {@code printStackTrace}. Writes to the returned array do not
* affect future calls to this method.
*
* @return an array of stack trace elements representing the stack trace
* pertaining to this throwable.
* @since 1.4
*/
public StackTraceElement[] getStackTrace() {
return getOurStackTrace().clone();
}
private synchronized StackTraceElement[] getOurStackTrace() {
// // Initialize stack trace field with information from
// // backtrace if this is the first call to this method
// if (stackTrace == UNASSIGNED_STACK ||
// (stackTrace == null && backtrace != null) /* Out of protocol state */) {
// int depth = getStackTraceDepth();
// stackTrace = new StackTraceElement[depth];
// for (int i=0; i < depth; i++)
// stackTrace[i] = getStackTraceElement(i);
// } else if (stackTrace == null) {
// return UNASSIGNED_STACK;
// }
// return stackTrace;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Sets the stack trace elements that will be returned by
* {@link #getStackTrace()} and printed by {@link #printStackTrace()}
* and related methods.
*
* This method, which is designed for use by RPC frameworks and other
* advanced systems, allows the client to override the default
* stack trace that is either generated by {@link #fillInStackTrace()}
* when a throwable is constructed or deserialized when a throwable is
* read from a serialization stream.
*
*
If the stack trace of this {@code Throwable} {@linkplain
* Throwable#Throwable(String, Throwable, boolean, boolean) is not
* writable}, calling this method has no effect other than
* validating its argument.
*
* @param stackTrace the stack trace elements to be associated with
* this {@code Throwable}. The specified array is copied by this
* call; changes in the specified array after the method invocation
* returns will have no affect on this {@code Throwable}'s stack
* trace.
*
* @throws NullPointerException if {@code stackTrace} is
* {@code null} or if any of the elements of
* {@code stackTrace} are {@code null}
*
* @since 1.4
*/
public void setStackTrace(StackTraceElement[] stackTrace) {
// // Validate argument
// StackTraceElement[] defensiveCopy = stackTrace.clone();
// for (int i = 0; i < defensiveCopy.length; i++) {
// if (defensiveCopy[i] == null)
// throw new NullPointerException("stackTrace[" + i + "]");
// }
// synchronized (this) {
// if (this.stackTrace == null && // Immutable stack
// backtrace == null) // Test for out of protocol state
// return;
// this.stackTrace = defensiveCopy;
// }
CProver.notModelled();
}
/**
* Returns the number of elements in the stack trace (or 0 if the stack
* trace is unavailable).
*
* package-protection for use by SharedSecrets.
*/
// DIFFBLUE MODEL LIBRARY We do not model native methods.
// native int getStackTraceDepth();
int getStackTraceDepth() {
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Returns the specified element of the stack trace.
*
* package-protection for use by SharedSecrets.
*
* @param index index of the element to return.
* @throws IndexOutOfBoundsException if {@code index < 0 ||
* index >= getStackTraceDepth() }
*/
// DIFFBLUE MODEL LIBRARY We do not model native methods.
// native StackTraceElement getStackTraceElement(int index);
StackTraceElement getStackTraceElement(int index) {
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Reads a {@code Throwable} from a stream, enforcing
* well-formedness constraints on fields. Null entries and
* self-pointers are not allowed in the list of {@code
* suppressedExceptions}. Null entries are not allowed for stack
* trace elements. A null stack trace in the serial form results
* in a zero-length stack element array. A single-element stack
* trace whose entry is equal to {@code new StackTraceElement("",
* "", null, Integer.MIN_VALUE)} results in a {@code null} {@code
* stackTrace} field.
*
* Note that there are no constraints on the value the {@code
* cause} field can hold; both {@code null} and {@code this} are
* valid values for the field.
*/
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
// s.defaultReadObject(); // read in all fields
// if (suppressedExceptions != null) {
// List suppressed = null;
// if (suppressedExceptions.isEmpty()) {
// // Use the sentinel for a zero-length list
// suppressed = SUPPRESSED_SENTINEL;
// } else { // Copy Throwables to new list
// suppressed = new ArrayList<>(1);
// for (Throwable t : suppressedExceptions) {
// // Enforce constraints on suppressed exceptions in
// // case of corrupt or malicious stream.
// if (t == null)
// throw new NullPointerException(NULL_CAUSE_MESSAGE);
// if (t == this)
// throw new IllegalArgumentException(SELF_SUPPRESSION_MESSAGE);
// suppressed.add(t);
// }
// }
// suppressedExceptions = suppressed;
// } // else a null suppressedExceptions field remains null
// /*
// * For zero-length stack traces, use a clone of
// * UNASSIGNED_STACK rather than UNASSIGNED_STACK itself to
// * allow identity comparison against UNASSIGNED_STACK in
// * getOurStackTrace. The identity of UNASSIGNED_STACK in
// * stackTrace indicates to the getOurStackTrace method that
// * the stackTrace needs to be constructed from the information
// * in backtrace.
// */
// if (stackTrace != null) {
// if (stackTrace.length == 0) {
// stackTrace = UNASSIGNED_STACK.clone();
// } else if (stackTrace.length == 1 &&
// // Check for the marker of an immutable stack trace
// SentinelHolder.STACK_TRACE_ELEMENT_SENTINEL.equals(stackTrace[0])) {
// stackTrace = null;
// } else { // Verify stack trace elements are non-null.
// for(StackTraceElement ste : stackTrace) {
// if (ste == null)
// throw new NullPointerException("null StackTraceElement in serial stream. ");
// }
// }
// } else {
// // A null stackTrace field in the serial form can result
// // from an exception serialized without that field in
// // older JDK releases; treat such exceptions as having
// // empty stack traces.
// stackTrace = UNASSIGNED_STACK.clone();
// }
CProver.notModelled();
}
/**
* Write a {@code Throwable} object to a stream.
*
* A {@code null} stack trace field is represented in the serial
* form as a one-element array whose element is equal to {@code
* new StackTraceElement("", "", null, Integer.MIN_VALUE)}.
*/
private synchronized void writeObject(ObjectOutputStream s)
throws IOException {
// // Ensure that the stackTrace field is initialized to a
// // non-null value, if appropriate. As of JDK 7, a null stack
// // trace field is a valid value indicating the stack trace
// // should not be set.
// getOurStackTrace();
// StackTraceElement[] oldStackTrace = stackTrace;
// try {
// if (stackTrace == null)
// stackTrace = SentinelHolder.STACK_TRACE_SENTINEL;
// s.defaultWriteObject();
// } finally {
// stackTrace = oldStackTrace;
// }
CProver.notModelled();
}
/**
* Appends the specified exception to the exceptions that were
* suppressed in order to deliver this exception. This method is
* thread-safe and typically called (automatically and implicitly)
* by the {@code try}-with-resources statement.
*
*
The suppression behavior is enabled unless disabled
* {@linkplain #Throwable(String, Throwable, boolean, boolean) via
* a constructor}. When suppression is disabled, this method does
* nothing other than to validate its argument.
*
*
Note that when one exception {@linkplain
* #initCause(Throwable) causes} another exception, the first
* exception is usually caught and then the second exception is
* thrown in response. In other words, there is a causal
* connection between the two exceptions.
*
* In contrast, there are situations where two independent
* exceptions can be thrown in sibling code blocks, in particular
* in the {@code try} block of a {@code try}-with-resources
* statement and the compiler-generated {@code finally} block
* which closes the resource.
*
* In these situations, only one of the thrown exceptions can be
* propagated. In the {@code try}-with-resources statement, when
* there are two such exceptions, the exception originating from
* the {@code try} block is propagated and the exception from the
* {@code finally} block is added to the list of exceptions
* suppressed by the exception from the {@code try} block. As an
* exception unwinds the stack, it can accumulate multiple
* suppressed exceptions.
*
*
An exception may have suppressed exceptions while also being
* caused by another exception. Whether or not an exception has a
* cause is semantically known at the time of its creation, unlike
* whether or not an exception will suppress other exceptions
* which is typically only determined after an exception is
* thrown.
*
*
Note that programmer written code is also able to take
* advantage of calling this method in situations where there are
* multiple sibling exceptions and only one can be propagated.
*
* @param exception the exception to be added to the list of
* suppressed exceptions
* @throws IllegalArgumentException if {@code exception} is this
* throwable; a throwable cannot suppress itself.
* @throws NullPointerException if {@code exception} is {@code null}
* @since 1.7
*/
public final synchronized void addSuppressed(Throwable exception) {
// if (exception == this)
// // throw new IllegalArgumentException(SELF_SUPPRESSION_MESSAGE, exception);
// throw new IllegalArgumentException("Self-suppression not permitted", exception);
// if (exception == null)
// // throw new NullPointerException(NULL_CAUSE_MESSAGE);
// throw new NullPointerException("Cannot suppress a null exception.");
// // if (suppressedExceptions == null) // Suppressed exceptions not recorded
// if (!allowSuppressedExceptions)
// return;
// // if (suppressedExceptions == SUPPRESSED_SENTINEL)
// if (allowSuppressedExceptions && suppressedExceptions == null)
// suppressedExceptions = new ArrayList<>(1);
// suppressedExceptions.add(exception);
CProver.notModelled();
}
// DIFFBLUE MODEL LIBRARY
// private static final Throwable[] EMPTY_THROWABLE_ARRAY = new Throwable[0];
/**
* Returns an array containing all of the exceptions that were
* suppressed, typically by the {@code try}-with-resources
* statement, in order to deliver this exception.
*
* If no exceptions were suppressed or {@linkplain
* #Throwable(String, Throwable, boolean, boolean) suppression is
* disabled}, an empty array is returned. This method is
* thread-safe. Writes to the returned array do not affect future
* calls to this method.
*
* @return an array containing all of the exceptions that were
* suppressed to deliver this exception.
* @since 1.7
*/
public final synchronized Throwable[] getSuppressed() {
// if (suppressedExceptions == SUPPRESSED_SENTINEL ||
// suppressedExceptions == null)
// return EMPTY_THROWABLE_ARRAY;
// else
// return suppressedExceptions.toArray(EMPTY_THROWABLE_ARRAY);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
}
java-models-library-master/src/main/java/java/lang/TypeNotPresentException.java 0000664 0000000 0000000 00000004010 14323475213 0030175 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/UnknownError.java 0000664 0000000 0000000 00000004337 14323475213 0026040 0 ustar 00root root 0000000 0000000 /*
* 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 UnknownError with no detail message.
*/
public UnknownError() {
super();
}
/**
* Constructs an UnknownError 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";
}
}
java-models-library-master/src/main/java/java/lang/UnsatisfiedLinkError.java 0000664 0000000 0000000 00000004533 14323475213 0027473 0 ustar 00root root 0000000 0000000 /*
* 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 native.
*
* @author unascribed
* @see java.lang.Runtime
* @since JDK1.0
*/
public
class UnsatisfiedLinkError extends LinkageError {
private static final long serialVersionUID = -4019343241616879428L;
/**
* Constructs an UnsatisfiedLinkError with no detail message.
*/
public UnsatisfiedLinkError() {
super();
}
/**
* Constructs an UnsatisfiedLinkError 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";
}
}
java-models-library-master/src/main/java/java/lang/UnsupportedClassVersionError.java 0000664 0000000 0000000 00000004577 14323475213 0031273 0 ustar 00root root 0000000 0000000 /*
* 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 UnsupportedClassVersionError
* with no detail message.
*/
public UnsupportedClassVersionError() {
super();
}
/**
* Constructs a UnsupportedClassVersionError 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";
}
}
java-models-library-master/src/main/java/java/lang/UnsupportedOperationException.java 0000664 0000000 0000000 00000004160 14323475213 0031451 0 ustar 00root root 0000000 0000000 /*
* 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";
}
}
java-models-library-master/src/main/java/java/lang/VerifyError.java 0000664 0000000 0000000 00000004403 14323475213 0025637 0 ustar 00root root 0000000 0000000 /*
* 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 VerifyError with no detail message.
*/
public VerifyError() {
super();
}
/**
* Constructs an VerifyError 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";
}
}
java-models-library-master/src/main/java/java/lang/VirtualMachineError.java 0000664 0000000 0000000 00000007250 14323475213 0027311 0 ustar 00root root 0000000 0000000 /*
* 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 VirtualMachineError with no detail message.
*/
public VirtualMachineError() {
super();
}
/**
* Constructs a VirtualMachineError 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.
Note that the detail message
* associated with {@code cause} is not 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";
}
}
java-models-library-master/src/main/java/java/lang/reflect/ 0000775 0000000 0000000 00000000000 14323475213 0024141 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/java/lang/reflect/AccessibleObject.java 0000664 0000000 0000000 00000032713 14323475213 0030176 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1997, 2014, 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.reflect;
import org.cprover.CProver;
import java.security.AccessController;
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// import sun.reflect.Reflection;
// import sun.reflect.ReflectionFactory;
import java.lang.annotation.Annotation;
/**
* The AccessibleObject class is the base class for Field, Method and
* Constructor objects. It provides the ability to flag a reflected
* object as suppressing default Java language access control checks
* when it is used. The access checks--for public, default (package)
* access, protected, and private members--are performed when Fields,
* Methods or Constructors are used to set or get fields, to invoke
* methods, or to create and initialize new instances of classes,
* respectively.
*
*
Setting the {@code accessible} flag in a reflected object
* permits sophisticated applications with sufficient privilege, such
* as Java Object Serialization or other persistence mechanisms, to
* manipulate objects in a manner that would normally be prohibited.
*
*
By default, a reflected object is not accessible.
*
* @see Field
* @see Method
* @see Constructor
* @see ReflectPermission
*
* @since 1.2
*
* @diffblue.untested
* @diffblue.noSupport
* This model was automatically generated by the JDK Processor tool.
*/
public class AccessibleObject implements AnnotatedElement {
/**
* The Permission object that is used to check whether a client
* has sufficient privilege to defeat Java language access
* control checks.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final private java.security.Permission ACCESS_PERMISSION =
// new ReflectPermission("suppressAccessChecks");
/**
* Convenience method to set the {@code accessible} flag for an
* array of objects with a single security check (for efficiency).
*
*
First, if there is a security manager, its
* {@code checkPermission} method is called with a
* {@code ReflectPermission("suppressAccessChecks")} permission.
*
*
A {@code SecurityException} is raised if {@code flag} is
* {@code true} but accessibility of any of the elements of the input
* {@code array} may not be changed (for example, if the element
* object is a {@link Constructor} object for the class {@link
* java.lang.Class}). In the event of such a SecurityException, the
* accessibility of objects is set to {@code flag} for array elements
* upto (and excluding) the element for which the exception occurred; the
* accessibility of elements beyond (and including) the element for which
* the exception occurred is unchanged.
*
* @param array the array of AccessibleObjects
* @param flag the new value for the {@code accessible} flag
* in each object
* @throws SecurityException if the request is denied.
* @see SecurityManager#checkPermission
* @see java.lang.RuntimePermission
*
* @diffblue.untested
* @diffblue.noSupport
*/
public static void setAccessible(AccessibleObject[] array, boolean flag)
throws SecurityException {
// SecurityManager sm = System.getSecurityManager();
// if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
// for (int i = 0; i < array.length; i++) {
// setAccessible0(array[i], flag);
// }
CProver.notModelled();
}
/**
* Set the {@code accessible} flag for this object to
* the indicated boolean value. A value of {@code true} indicates that
* the reflected object should suppress Java language access
* checking when it is used. A value of {@code false} indicates
* that the reflected object should enforce Java language access checks.
*
*
First, if there is a security manager, its
* {@code checkPermission} method is called with a
* {@code ReflectPermission("suppressAccessChecks")} permission.
*
*
A {@code SecurityException} is raised if {@code flag} is
* {@code true} but accessibility of this object may not be changed
* (for example, if this element object is a {@link Constructor} object for
* the class {@link java.lang.Class}).
*
*
A {@code SecurityException} is raised if this object is a {@link
* java.lang.reflect.Constructor} object for the class
* {@code java.lang.Class}, and {@code flag} is true.
*
* @param flag the new value for the {@code accessible} flag
* @throws SecurityException if the request is denied.
* @see SecurityManager#checkPermission
* @see java.lang.RuntimePermission
*
* @diffblue.untested
* @diffblue.noSupport
*/
public void setAccessible(boolean flag) throws SecurityException {
// SecurityManager sm = System.getSecurityManager();
// if (sm != null) sm.checkPermission(ACCESS_PERMISSION);
// setAccessible0(this, flag);
CProver.notModelled();
}
/* Check that you aren't exposing java.lang.Class. or sensitive
fields in java.lang.Class. */
// DIFFBLUE MODEL LIBRARY - not used in model
// private static void setAccessible0(AccessibleObject obj, boolean flag)
// throws SecurityException
// {
// if (obj instanceof Constructor && flag == true) {
// Constructor c = (Constructor)obj;
// if (c.getDeclaringClass() == Class.class) {
// throw new SecurityException("Cannot make a java.lang.Class" +
// " constructor accessible");
// }
// }
// obj.override = flag;
// }
/**
* Get the value of the {@code accessible} flag for this object.
*
* @return the value of the object's {@code accessible} flag
*
* @diffblue.untested
* @diffblue.fullSupport
*/
public boolean isAccessible() {
return override;
}
/**
* Constructor: only used by the Java Virtual Machine.
*/
protected AccessibleObject() {}
// Indicates whether language-level access checks are overridden
// by this object. Initializes to "false". This field is used by
// Field, Method, and Constructor.
//
// NOTE: for security purposes, this field must not be visible
// outside this package.
boolean override;
// Reflection factory used by subclasses for creating field,
// method, and constructor accessors. Note that this is called
// very early in the bootstrapping process.
// DIFFBLUE MODEL LIBRARY - not used in model
// static final ReflectionFactory reflectionFactory =
// AccessController.doPrivileged(
// new sun.reflect.ReflectionFactory.GetReflectionFactoryAction());
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.5
*
* @diffblue.untested
* @diffblue.fullSupport
*/
public T getAnnotation(Class annotationClass) {
throw new AssertionError("All subclasses should override this method");
}
/**
* {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
public boolean isAnnotationPresent(Class annotationClass) {
// return AnnotatedElement.super.isAnnotationPresent(annotationClass);
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.8
*
* @diffblue.untested
* @diffblue.fullSupport
*/
@Override
public T[] getAnnotationsByType(Class annotationClass) {
throw new AssertionError("All subclasses should override this method");
}
/**
* @since 1.5
*
* @diffblue.untested
* @diffblue.fullSupport
*/
public Annotation[] getAnnotations() {
return getDeclaredAnnotations();
}
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.8
*
* @diffblue.untested
* @diffblue.fullSupport
*/
@Override
public T getDeclaredAnnotation(Class annotationClass) {
// Only annotations on classes are inherited, for all other
// objects getDeclaredAnnotation is the same as
// getAnnotation.
return getAnnotation(annotationClass);
}
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.8
*
* @diffblue.untested
* @diffblue.fullSupport
*/
@Override
public T[] getDeclaredAnnotationsByType(Class annotationClass) {
// Only annotations on classes are inherited, for all other
// objects getDeclaredAnnotationsByType is the same as
// getAnnotationsByType.
return getAnnotationsByType(annotationClass);
}
/**
* @since 1.5
*
* @diffblue.untested
* @diffblue.fullSupport
*/
public Annotation[] getDeclaredAnnotations() {
throw new AssertionError("All subclasses should override this method");
}
// Shared access checking logic.
// For non-public members or members in package-private classes,
// it is necessary to perform somewhat expensive security checks.
// If the security check succeeds for a given class, it will
// always succeed (it is not affected by the granting or revoking
// of permissions); we speed up the check in the common case by
// remembering the last Class for which the check succeeded.
//
// The simple security check for Constructor is to see if
// the caller has already been seen, verified, and cached.
// (See also Class.newInstance(), which uses a similar method.)
//
// A more complicated security check cache is needed for Method and Field
// The cache can be either null (empty cache), a 2-array of {caller,target},
// or a caller (with target implicitly equal to this.clazz).
// In the 2-array case, the target is always different from the clazz.
// DIFFBLUE MODEL LIBRARY - not used in model
// volatile Object securityCheckCache;
// DIFFBLUE MODEL LIBRARY - not used in model
// void checkAccess(Class caller, Class clazz, Object obj, int modifiers)
// throws IllegalAccessException
// {
// if (caller == clazz) { // quick check
// return; // ACCESS IS OK
// }
// Object cache = securityCheckCache; // read volatile
// Class targetClass = clazz;
// if (obj != null
// && Modifier.isProtected(modifiers)
// && ((targetClass = obj.getClass()) != clazz)) {
// // Must match a 2-list of { caller, targetClass }.
// if (cache instanceof Class[]) {
// Class[] cache2 = (Class[]) cache;
// if (cache2[1] == targetClass &&
// cache2[0] == caller) {
// return; // ACCESS IS OK
// }
// // (Test cache[1] first since range check for [1]
// // subsumes range check for [0].)
// }
// } else if (cache == caller) {
// // Non-protected case (or obj.class == this.clazz).
// return; // ACCESS IS OK
// }
// // If no return, fall through to the slow path.
// slowCheckMemberAccess(caller, clazz, obj, modifiers, targetClass);
// }
// Keep all this slow stuff out of line:
// DIFFBLUE MODEL LIBRARY - not used in model
// void slowCheckMemberAccess(Class caller, Class clazz, Object obj, int modifiers,
// Class targetClass)
// throws IllegalAccessException
// {
// Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);
// // Success: Update the cache.
// Object cache = ((targetClass == clazz)
// ? caller
// : new Class[] { caller, targetClass });
// // Note: The two cache elements are not volatile,
// // but they are effectively final. The Java memory model
// // guarantees that the initializing stores for the cache
// // elements will occur before the volatile write.
// securityCheckCache = cache; // write volatile
// }
}
java-models-library-master/src/main/java/java/lang/reflect/Executable.java 0000664 0000000 0000000 00000076523 14323475213 0027102 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2012, 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.reflect;
import org.cprover.CProver;
import java.lang.annotation.*;
import java.util.Map;
import java.util.Objects;
import sun.reflect.annotation.AnnotationParser;
import sun.reflect.annotation.AnnotationSupport;
import sun.reflect.annotation.TypeAnnotationParser;
import sun.reflect.annotation.TypeAnnotation;
import sun.reflect.generics.repository.ConstructorRepository;
/**
* A shared superclass for the common functionality of {@link Method}
* and {@link Constructor}.
*
* @since 1.8
*
* @diffblue.untested
* @diffblue.noSupport
* This model was automatically generated by the JDK Processor tool.
*/
public abstract class Executable extends AccessibleObject
implements Member, GenericDeclaration {
/*
* Only grant package-visibility to the constructor.
*/
Executable() {}
/**
* Accessor method to allow code sharing
*/
abstract byte[] getAnnotationBytes();
/**
* Accessor method to allow code sharing
*/
abstract Executable getRoot();
/**
* Does the Executable have generic information.
*/
abstract boolean hasGenericInformation();
abstract ConstructorRepository getGenericInfo();
boolean equalParamTypes(Class[] params1, Class[] params2) {
/* Avoid unnecessary cloning */
if (params1.length == params2.length) {
for (int i = 0; i < params1.length; i++) {
if (params1[i] != params2[i])
return false;
}
return true;
}
return false;
}
// DIFFBLUE MODEL LIBRARY - not used in model
// Annotation[][] parseParameterAnnotations(byte[] parameterAnnotations) {
// return AnnotationParser.parseParameterAnnotations(
// parameterAnnotations,
// sun.misc.SharedSecrets.getJavaLangAccess().
// getConstantPool(getDeclaringClass()),
// getDeclaringClass());
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// void separateWithCommas(Class[] types, StringBuilder sb) {
// for (int j = 0; j < types.length; j++) {
// sb.append(types[j].getTypeName());
// if (j < (types.length - 1))
// sb.append(",");
// }
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// void printModifiersIfNonzero(StringBuilder sb, int mask, boolean isDefault) {
// int mod = getModifiers() & mask;
// if (mod != 0 && !isDefault) {
// sb.append(Modifier.toString(mod)).append(' ');
// } else {
// int access_mod = mod & Modifier.ACCESS_MODIFIERS;
// if (access_mod != 0)
// sb.append(Modifier.toString(access_mod)).append(' ');
// if (isDefault)
// sb.append("default ");
// mod = (mod & ~Modifier.ACCESS_MODIFIERS);
// if (mod != 0)
// sb.append(Modifier.toString(mod)).append(' ');
// }
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// String sharedToString(int modifierMask,
// boolean isDefault,
// Class[] parameterTypes,
// Class[] exceptionTypes) {
// try {
// StringBuilder sb = new StringBuilder();
// printModifiersIfNonzero(sb, modifierMask, isDefault);
// specificToStringHeader(sb);
// sb.append('(');
// separateWithCommas(parameterTypes, sb);
// sb.append(')');
// if (exceptionTypes.length > 0) {
// sb.append(" throws ");
// separateWithCommas(exceptionTypes, sb);
// }
// return sb.toString();
// } catch (Exception e) {
// return "<" + e + ">";
// }
// }
/**
* Generate toString header information specific to a method or
* constructor.
*/
abstract void specificToStringHeader(StringBuilder sb);
String sharedToGenericString(int modifierMask, boolean isDefault) {
// try {
// StringBuilder sb = new StringBuilder();
// printModifiersIfNonzero(sb, modifierMask, isDefault);
// TypeVariable[] typeparms = getTypeParameters();
// if (typeparms.length > 0) {
// boolean first = true;
// sb.append('<');
// for(TypeVariable typeparm: typeparms) {
// if (!first)
// sb.append(',');
// // Class objects can't occur here; no need to test
// // and call Class.getName().
// sb.append(typeparm.toString());
// first = false;
// }
// sb.append("> ");
// }
// specificToGenericStringHeader(sb);
// sb.append('(');
// Type[] params = getGenericParameterTypes();
// for (int j = 0; j < params.length; j++) {
// String param = params[j].getTypeName();
// if (isVarArgs() && (j == params.length - 1)) // replace T[] with T...
// param = param.replaceFirst("\\[\\]$", "...");
// sb.append(param);
// if (j < (params.length - 1))
// sb.append(',');
// }
// sb.append(')');
// Type[] exceptions = getGenericExceptionTypes();
// if (exceptions.length > 0) {
// sb.append(" throws ");
// for (int k = 0; k < exceptions.length; k++) {
// sb.append((exceptions[k] instanceof Class)?
// ((Class)exceptions[k]).getName():
// exceptions[k].toString());
// if (k < (exceptions.length - 1))
// sb.append(',');
// }
// }
// return sb.toString();
// } catch (Exception e) {
// return "<" + e + ">";
// }
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Generate toGenericString header information specific to a
* method or constructor.
*/
abstract void specificToGenericStringHeader(StringBuilder sb);
/**
* Returns the {@code Class} object representing the class or interface
* that declares the executable represented by this object.
*/
public abstract Class getDeclaringClass();
/**
* Returns the name of the executable represented by this object.
*/
public abstract String getName();
/**
* Returns the Java language {@linkplain Modifier modifiers} for
* the executable represented by this object.
*/
public abstract int getModifiers();
/**
* Returns an array of {@code TypeVariable} objects that represent the
* type variables declared by the generic declaration represented by this
* {@code GenericDeclaration} object, in declaration order. Returns an
* array of length 0 if the underlying generic declaration declares no type
* variables.
*
* @return an array of {@code TypeVariable} objects that represent
* the type variables declared by this generic declaration
* @throws GenericSignatureFormatError if the generic
* signature of this generic declaration does not conform to
* the format specified in
* The Java™ Virtual Machine Specification
*/
public abstract TypeVariable[] getTypeParameters();
/**
* Returns an array of {@code Class} objects that represent the formal
* parameter types, in declaration order, of the executable
* represented by this object. Returns an array of length
* 0 if the underlying executable takes no parameters.
*
* @return the parameter types for the executable this object
* represents
*/
public abstract Class[] getParameterTypes();
/**
* Returns the number of formal parameters (whether explicitly
* declared or implicitly declared or neither) for the executable
* represented by this object.
*
* @return The number of formal parameters for the executable this
* object represents
*
* @diffblue.untested
* @diffblue.fullSupport
*/
public int getParameterCount() {
throw new AbstractMethodError();
}
/**
* Returns an array of {@code Type} objects that represent the formal
* parameter types, in declaration order, of the executable represented by
* this object. Returns an array of length 0 if the
* underlying executable takes no parameters.
*
*
If a formal parameter type is a parameterized type,
* the {@code Type} object returned for it must accurately reflect
* the actual type parameters used in the source code.
*
*
If a formal parameter type is a type variable or a parameterized
* type, it is created. Otherwise, it is resolved.
*
* @return an array of {@code Type}s that represent the formal
* parameter types of the underlying executable, in declaration order
* @throws GenericSignatureFormatError
* if the generic method signature does not conform to the format
* specified in
* The Java™ Virtual Machine Specification
* @throws TypeNotPresentException if any of the parameter
* types of the underlying executable refers to a non-existent type
* declaration
* @throws MalformedParameterizedTypeException if any of
* the underlying executable's parameter types refer to a parameterized
* type that cannot be instantiated for any reason
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Type[] getGenericParameterTypes() {
// if (hasGenericInformation())
// return getGenericInfo().getParameterTypes();
// else
// return getParameterTypes();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Behaves like {@code getGenericParameterTypes}, but returns type
* information for all parameters, including synthetic parameters.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// Type[] getAllGenericParameterTypes() {
// final boolean genericInfo = hasGenericInformation();
// // Easy case: we don't have generic parameter information. In
// // this case, we just return the result of
// // getParameterTypes().
// if (!genericInfo) {
// return getParameterTypes();
// } else {
// final boolean realParamData = hasRealParameterData();
// final Type[] genericParamTypes = getGenericParameterTypes();
// final Type[] nonGenericParamTypes = getParameterTypes();
// final Type[] out = new Type[nonGenericParamTypes.length];
// final Parameter[] params = getParameters();
// int fromidx = 0;
// // If we have real parameter data, then we use the
// // synthetic and mandate flags to our advantage.
// if (realParamData) {
// for (int i = 0; i < out.length; i++) {
// final Parameter param = params[i];
// if (param.isSynthetic() || param.isImplicit()) {
// // If we hit a synthetic or mandated parameter,
// // use the non generic parameter info.
// out[i] = nonGenericParamTypes[i];
// } else {
// // Otherwise, use the generic parameter info.
// out[i] = genericParamTypes[fromidx];
// fromidx++;
// }
// }
// } else {
// // Otherwise, use the non-generic parameter data.
// // Without method parameter reflection data, we have
// // no way to figure out which parameters are
// // synthetic/mandated, thus, no way to match up the
// // indexes.
// return genericParamTypes.length == nonGenericParamTypes.length ?
// genericParamTypes : nonGenericParamTypes;
// }
// return out;
// }
// }
/**
* Returns an array of {@code Parameter} objects that represent
* all the parameters to the underlying executable represented by
* this object. Returns an array of length 0 if the executable
* has no parameters.
*
*
The parameters of the underlying executable do not necessarily
* have unique names, or names that are legal identifiers in the
* Java programming language (JLS 3.8).
*
* @throws MalformedParametersException if the class file contains
* a MethodParameters attribute that is improperly formatted.
* @return an array of {@code Parameter} objects representing all
* the parameters to the executable this object represents.
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Parameter[] getParameters() {
// // TODO: This may eventually need to be guarded by security
// // mechanisms similar to those in Field, Method, etc.
// //
// // Need to copy the cached array to prevent users from messing
// // with it. Since parameters are immutable, we can
// // shallow-copy.
// return privateGetParameters().clone();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
// DIFFBLUE MODEL LIBRARY - not used in model
// private Parameter[] synthesizeAllParams() {
// final int realparams = getParameterCount();
// final Parameter[] out = new Parameter[realparams];
// for (int i = 0; i < realparams; i++)
// // TODO: is there a way to synthetically derive the
// // modifiers? Probably not in the general case, since
// // we'd have no way of knowing about them, but there
// // may be specific cases.
// out[i] = new Parameter("arg" + i, 0, this, i);
// return out;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private void verifyParameters(final Parameter[] parameters) {
// final int mask = Modifier.FINAL | Modifier.SYNTHETIC | Modifier.MANDATED;
// if (getParameterTypes().length != parameters.length)
// throw new MalformedParametersException("Wrong number of parameters in MethodParameters attribute");
// for (Parameter parameter : parameters) {
// final String name = parameter.getRealName();
// final int mods = parameter.getModifiers();
// if (name != null) {
// if (name.isEmpty() || name.indexOf('.') != -1 ||
// name.indexOf(';') != -1 || name.indexOf('[') != -1 ||
// name.indexOf('/') != -1) {
// throw new MalformedParametersException("Invalid parameter name \"" + name + "\"");
// }
// }
// if (mods != (mods & mask)) {
// throw new MalformedParametersException("Invalid parameter modifiers");
// }
// }
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private Parameter[] privateGetParameters() {
// // Use tmp to avoid multiple writes to a volatile.
// Parameter[] tmp = parameters;
// if (tmp == null) {
// // Otherwise, go to the JVM to get them
// try {
// tmp = getParameters0();
// } catch(IllegalArgumentException e) {
// // Rethrow ClassFormatErrors
// throw new MalformedParametersException("Invalid constant pool index");
// }
// // If we get back nothing, then synthesize parameters
// if (tmp == null) {
// hasRealParameterData = false;
// tmp = synthesizeAllParams();
// } else {
// hasRealParameterData = true;
// verifyParameters(tmp);
// }
// parameters = tmp;
// }
// return tmp;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// boolean hasRealParameterData() {
// // If this somehow gets called before parameters gets
// // initialized, force it into existence.
// if (parameters == null) {
// privateGetParameters();
// }
// return hasRealParameterData;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient volatile boolean hasRealParameterData;
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient volatile Parameter[] parameters;
// DIFFBLUE MODEL LIBRARY - not used in model
// private native Parameter[] getParameters0();
// DIFFBLUE MODEL LIBRARY - not used in model
// native byte[] getTypeAnnotationBytes0();
// Needed by reflectaccess
// DIFFBLUE MODEL LIBRARY - not used in model
// byte[] getTypeAnnotationBytes() {
// return getTypeAnnotationBytes0();
// }
/**
* Returns an array of {@code Class} objects that represent the
* types of exceptions declared to be thrown by the underlying
* executable represented by this object. Returns an array of
* length 0 if the executable declares no exceptions in its {@code
* throws} clause.
*
* @return the exception types declared as being thrown by the
* executable this object represents
*/
public abstract Class[] getExceptionTypes();
/**
* Returns an array of {@code Type} objects that represent the
* exceptions declared to be thrown by this executable object.
* Returns an array of length 0 if the underlying executable declares
* no exceptions in its {@code throws} clause.
*
*
If an exception type is a type variable or a parameterized
* type, it is created. Otherwise, it is resolved.
*
* @return an array of Types that represent the exception types
* thrown by the underlying executable
* @throws GenericSignatureFormatError
* if the generic method signature does not conform to the format
* specified in
* The Java™ Virtual Machine Specification
* @throws TypeNotPresentException if the underlying executable's
* {@code throws} clause refers to a non-existent type declaration
* @throws MalformedParameterizedTypeException if
* the underlying executable's {@code throws} clause refers to a
* parameterized type that cannot be instantiated for any reason
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Type[] getGenericExceptionTypes() {
// Type[] result;
// if (hasGenericInformation() &&
// ((result = getGenericInfo().getExceptionTypes()).length > 0))
// return result;
// else
// return getExceptionTypes();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns a string describing this {@code Executable}, including
* any type parameters.
* @return a string describing this {@code Executable}, including
* any type parameters
*/
public abstract String toGenericString();
/**
* Returns {@code true} if this executable was declared to take a
* variable number of arguments; returns {@code false} otherwise.
*
* @return {@code true} if an only if this executable was declared
* to take a variable number of arguments.
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean isVarArgs() {
// return (getModifiers() & Modifier.VARARGS) != 0;
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Returns {@code true} if this executable is a synthetic
* construct; returns {@code false} otherwise.
*
* @return true if and only if this executable is a synthetic
* construct as defined by
* The Java™ Language Specification.
* @jls 13.1 The Form of a Binary
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean isSynthetic() {
// return Modifier.isSynthetic(getModifiers());
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Returns an array of arrays of {@code Annotation}s that
* represent the annotations on the formal parameters, in
* declaration order, of the {@code Executable} represented by
* this object. Synthetic and mandated parameters (see
* explanation below), such as the outer "this" parameter to an
* inner class constructor will be represented in the returned
* array. If the executable has no parameters (meaning no formal,
* no synthetic, and no mandated parameters), a zero-length array
* will be returned. If the {@code Executable} has one or more
* parameters, a nested array of length zero is returned for each
* parameter with no annotations. The annotation objects contained
* in the returned arrays are serializable. The caller of this
* method is free to modify the returned arrays; it will have no
* effect on the arrays returned to other callers.
*
* A compiler may add extra parameters that are implicitly
* declared in source ("mandated"), as well as parameters that
* are neither implicitly nor explicitly declared in source
* ("synthetic") to the parameter list for a method. See {@link
* java.lang.reflect.Parameter} for more information.
*
* @see java.lang.reflect.Parameter
* @see java.lang.reflect.Parameter#getAnnotations
* @return an array of arrays that represent the annotations on
* the formal and implicit parameters, in declaration order, of
* the executable represented by this object
*/
public abstract Annotation[][] getParameterAnnotations();
// DIFFBLUE MODEL LIBRARY - not used in model
// Annotation[][] sharedGetParameterAnnotations(Class[] parameterTypes,
// byte[] parameterAnnotations) {
// int numParameters = parameterTypes.length;
// if (parameterAnnotations == null)
// return new Annotation[numParameters][0];
// Annotation[][] result = parseParameterAnnotations(parameterAnnotations);
// if (result.length != numParameters)
// handleParameterNumberMismatch(result.length, numParameters);
// return result;
// }
abstract void handleParameterNumberMismatch(int resultLength, int numParameters);
/**
* {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*
* @diffblue.untested
* @diffblue.noSupport
*/
public T getAnnotation(Class annotationClass) {
// Objects.requireNonNull(annotationClass);
// return annotationClass.cast(declaredAnnotations().get(annotationClass));
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
public T[] getAnnotationsByType(Class annotationClass) {
// Objects.requireNonNull(annotationClass);
// return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* {@inheritDoc}
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Annotation[] getDeclaredAnnotations() {
// return AnnotationParser.toArray(declaredAnnotations());
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient Map, Annotation> declaredAnnotations;
// DIFFBLUE MODEL LIBRARY - not used in model
// private synchronized Map, Annotation> declaredAnnotations() {
// if (declaredAnnotations == null) {
// Executable root = getRoot();
// if (root != null) {
// declaredAnnotations = root.declaredAnnotations();
// } else {
// declaredAnnotations = AnnotationParser.parseAnnotations(
// getAnnotationBytes(),
// sun.misc.SharedSecrets.getJavaLangAccess().
// getConstantPool(getDeclaringClass()),
// getDeclaringClass());
// }
// }
// return declaredAnnotations;
// }
/**
* Returns an {@code AnnotatedType} object that represents the use of a type to
* specify the return type of the method/constructor represented by this
* Executable.
*
* If this {@code Executable} object represents a constructor, the {@code
* AnnotatedType} object represents the type of the constructed object.
*
* If this {@code Executable} object represents a method, the {@code
* AnnotatedType} object represents the use of a type to specify the return
* type of the method.
*
* @return an object representing the return type of the method
* or constructor represented by this {@code Executable}
*/
public abstract AnnotatedType getAnnotatedReturnType();
/* Helper for subclasses of Executable.
*
* Returns an AnnotatedType object that represents the use of a type to
* specify the return type of the method/constructor represented by this
* Executable.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// AnnotatedType getAnnotatedReturnType0(Type returnType) {
// return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
// sun.misc.SharedSecrets.getJavaLangAccess().
// getConstantPool(getDeclaringClass()),
// this,
// getDeclaringClass(),
// returnType,
// TypeAnnotation.TypeAnnotationTarget.METHOD_RETURN);
// }
/**
* Returns an {@code AnnotatedType} object that represents the use of a
* type to specify the receiver type of the method/constructor represented
* by this Executable object. The receiver type of a method/constructor is
* available only if the method/constructor has a receiver
* parameter (JLS 8.4.1).
*
* If this {@code Executable} object represents a constructor or instance
* method that does not have a receiver parameter, or has a receiver
* parameter with no annotations on its type, then the return value is an
* {@code AnnotatedType} object representing an element with no
* annotations.
*
* If this {@code Executable} object represents a static method, then the
* return value is null.
*
* @return an object representing the receiver type of the method or
* constructor represented by this {@code Executable}
*
* @diffblue.untested
* @diffblue.noSupport
*/
public AnnotatedType getAnnotatedReceiverType() {
// if (Modifier.isStatic(this.getModifiers()))
// return null;
// return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
// sun.misc.SharedSecrets.getJavaLangAccess().
// getConstantPool(getDeclaringClass()),
// this,
// getDeclaringClass(),
// getDeclaringClass(),
// TypeAnnotation.TypeAnnotationTarget.METHOD_RECEIVER);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns an array of {@code AnnotatedType} objects that represent the use
* of types to specify formal parameter types of the method/constructor
* represented by this Executable. The order of the objects in the array
* corresponds to the order of the formal parameter types in the
* declaration of the method/constructor.
*
* Returns an array of length 0 if the method/constructor declares no
* parameters.
*
* @return an array of objects representing the types of the
* formal parameters of the method or constructor represented by this
* {@code Executable}
*
* @diffblue.untested
* @diffblue.noSupport
*/
public AnnotatedType[] getAnnotatedParameterTypes() {
// return TypeAnnotationParser.buildAnnotatedTypes(getTypeAnnotationBytes0(),
// sun.misc.SharedSecrets.getJavaLangAccess().
// getConstantPool(getDeclaringClass()),
// this,
// getDeclaringClass(),
// getAllGenericParameterTypes(),
// TypeAnnotation.TypeAnnotationTarget.METHOD_FORMAL_PARAMETER);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns an array of {@code AnnotatedType} objects that represent the use
* of types to specify the declared exceptions of the method/constructor
* represented by this Executable. The order of the objects in the array
* corresponds to the order of the exception types in the declaration of
* the method/constructor.
*
* Returns an array of length 0 if the method/constructor declares no
* exceptions.
*
* @return an array of objects representing the declared
* exceptions of the method or constructor represented by this {@code
* Executable}
*
* @diffblue.untested
* @diffblue.noSupport
*/
public AnnotatedType[] getAnnotatedExceptionTypes() {
// return TypeAnnotationParser.buildAnnotatedTypes(getTypeAnnotationBytes0(),
// sun.misc.SharedSecrets.getJavaLangAccess().
// getConstantPool(getDeclaringClass()),
// this,
// getDeclaringClass(),
// getGenericExceptionTypes(),
// TypeAnnotation.TypeAnnotationTarget.THROWS);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
}
java-models-library-master/src/main/java/java/lang/reflect/Field.java 0000664 0000000 0000000 00000157436 14323475213 0026047 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1996, 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.reflect;
import org.cprover.CProver;
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// import sun.reflect.CallerSensitive;
// import sun.reflect.Reflection;
// import sun.reflect.FieldAccessor;
// import sun.reflect.generics.repository.FieldRepository;
// import sun.reflect.generics.factory.CoreReflectionFactory;
// import sun.reflect.generics.factory.GenericsFactory;
// import sun.reflect.generics.scope.ClassScope;
import java.lang.annotation.Annotation;
import java.util.Map;
import java.util.Objects;
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// import sun.reflect.annotation.AnnotationParser;
// import sun.reflect.annotation.AnnotationSupport;
// import sun.reflect.annotation.TypeAnnotation;
// import sun.reflect.annotation.TypeAnnotationParser;
/**
* A {@code Field} provides information about, and dynamic access to, a
* single field of a class or an interface. The reflected field may
* be a class (static) field or an instance field.
*
*
A {@code Field} permits widening conversions to occur during a get or
* set access operation, but throws an {@code IllegalArgumentException} if a
* narrowing conversion would occur.
*
* @see Member
* @see java.lang.Class
* @see java.lang.Class#getFields()
* @see java.lang.Class#getField(String)
* @see java.lang.Class#getDeclaredFields()
* @see java.lang.Class#getDeclaredField(String)
*
* @author Kenneth Russell
* @author Nakul Saraiya
*
* @diffblue.untested
* @diffblue.noSupport
* This model was automatically generated by the JDK Processor tool.
*/
public final
class Field extends AccessibleObject implements Member {
private Class clazz;
// DIFFBLUE MODEL LIBRARY - not used in model
// private int slot;
// This is guaranteed to be interned by the VM in the 1.4
// reflection implementation
private String name;
// DIFFBLUE MODEL LIBRARY - not used in model
// private Class type;
// DIFFBLUE MODEL LIBRARY - not used in model
// private int modifiers;
// Generics and annotations support
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient String signature;
// generic info repository; lazily initialized
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient FieldRepository genericInfo;
// DIFFBLUE MODEL LIBRARY - not used in model
// private byte[] annotations;
// Cached field accessor created without override
// DIFFBLUE MODEL LIBRARY - not used in model
// private FieldAccessor fieldAccessor;
// Cached field accessor created with override
// DIFFBLUE MODEL LIBRARY - not used in model
// private FieldAccessor overrideFieldAccessor;
// For sharing of FieldAccessors. This branching structure is
// currently only two levels deep (i.e., one root Field and
// potentially many Field objects pointing to it.)
//
// If this branching structure would ever contain cycles, deadlocks can
// occur in annotation code.
// DIFFBLUE MODEL LIBRARY - not used in model
// private Field root;
// Generics infrastructure
// DIFFBLUE MODEL LIBRARY - not used in model
// private String getGenericSignature() {return signature;}
// Accessor for factory
// DIFFBLUE MODEL LIBRARY - not used in model
// private GenericsFactory getFactory() {
// Class c = getDeclaringClass();
// // create scope and factory
// return CoreReflectionFactory.make(c, ClassScope.make(c));
// }
// Accessor for generic info repository
// DIFFBLUE MODEL LIBRARY - not used in model
// private FieldRepository getGenericInfo() {
// // lazily initialize repository if necessary
// if (genericInfo == null) {
// // create and cache generic info repository
// genericInfo = FieldRepository.make(getGenericSignature(),
// getFactory());
// }
// return genericInfo; //return cached repository
// }
/**
* Package-private constructor used by ReflectAccess to enable
* instantiation of these objects in Java code from the java.lang
* package via sun.reflect.LangReflectAccess.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// Field(Class declaringClass,
// String name,
// Class type,
// int modifiers,
// int slot,
// String signature,
// byte[] annotations)
// {
// this.clazz = declaringClass;
// this.name = name;
// this.type = type;
// this.modifiers = modifiers;
// this.slot = slot;
// this.signature = signature;
// this.annotations = annotations;
// }
/**
* This constructor does not exist in the JDK, only in the model
*/
public Field(
Class declaringClass,
String name)
{
this.clazz = declaringClass;
this.name = name;
}
/**
* Package-private routine (exposed to java.lang.Class via
* ReflectAccess) which returns a copy of this Field. The copy's
* "root" field points to this Field.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// Field copy() {
// // This routine enables sharing of FieldAccessor objects
// // among Field objects which refer to the same underlying
// // method in the VM. (All of this contortion is only necessary
// // because of the "accessibility" bit in AccessibleObject,
// // which implicitly requires that new java.lang.reflect
// // objects be fabricated for each reflective call on Class
// // objects.)
// if (this.root != null)
// throw new IllegalArgumentException("Can not copy a non-root Field");
// Field res = new Field(clazz, name, type, modifiers, slot, signature, annotations);
// res.root = this;
// // Might as well eagerly propagate this if already present
// res.fieldAccessor = fieldAccessor;
// res.overrideFieldAccessor = overrideFieldAccessor;
// return res;
// }
/**
* Returns the {@code Class} object representing the class or interface
* that declares the field represented by this {@code Field} object.
*
* @diffblue.fullSupport
*/
public Class getDeclaringClass() {
return clazz;
}
/**
* Returns the name of the field represented by this {@code Field} object.
*
* @diffblue.fullSupport
*/
public String getName() {
return name;
}
/**
* Returns the Java language modifiers for the field represented
* by this {@code Field} object, as an integer. The {@code Modifier} class should
* be used to decode the modifiers.
*
* @see Modifier
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int getModifiers() {
// return modifiers;
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Returns {@code true} if this field represents an element of
* an enumerated type; returns {@code false} otherwise.
*
* @return {@code true} if and only if this field represents an element of
* an enumerated type.
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean isEnumConstant() {
// return (getModifiers() & Modifier.ENUM) != 0;
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Returns {@code true} if this field is a synthetic
* field; returns {@code false} otherwise.
*
* @return true if and only if this field is a synthetic
* field as defined by the Java Language Specification.
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean isSynthetic() {
// return Modifier.isSynthetic(getModifiers());
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Returns a {@code Class} object that identifies the
* declared type for the field represented by this
* {@code Field} object.
*
* @return a {@code Class} object identifying the declared
* type of the field represented by this object
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Class getType() {
// return type;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns a {@code Type} object that represents the declared type for
* the field represented by this {@code Field} object.
*
*
If the {@code Type} is a parameterized type, the
* {@code Type} object returned must accurately reflect the
* actual type parameters used in the source code.
*
*
If the type of the underlying field is a type variable or a
* parameterized type, it is created. Otherwise, it is resolved.
*
* @return a {@code Type} object that represents the declared type for
* the field represented by this {@code Field} object
* @throws GenericSignatureFormatError if the generic field
* signature does not conform to the format specified in
* The Java™ Virtual Machine Specification
* @throws TypeNotPresentException if the generic type
* signature of the underlying field refers to a non-existent
* type declaration
* @throws MalformedParameterizedTypeException if the generic
* signature of the underlying field refers to a parameterized type
* that cannot be instantiated for any reason
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Type getGenericType() {
// if (getGenericSignature() != null)
// return getGenericInfo().getGenericType();
// else
// return getType();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Compares this {@code Field} against the specified object. Returns
* true if the objects are the same. Two {@code Field} objects are the same if
* they were declared by the same class and have the same name
* and type.
*
* @diffblue.limitedSupport
*/
public boolean equals(Object obj) {
if (obj != null && obj instanceof Field) {
Field other = (Field)obj;
return (getDeclaringClass() == other.getDeclaringClass())
&& (getName() == other.getName());
}
return false;
}
/**
* Returns a hashcode for this {@code Field}. This is computed as the
* exclusive-or of the hashcodes for the underlying field's
* declaring class name and its name.
*
* @diffblue.untested
* @diffblue.fullSupport
*/
public int hashCode() {
return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
}
/**
* Returns a string describing this {@code Field}. The format is
* the access modifiers for the field, if any, followed
* by the field type, followed by a space, followed by
* the fully-qualified name of the class declaring the field,
* followed by a period, followed by the name of the field.
* For example:
*
* public static final int java.lang.Thread.MIN_PRIORITY
* private int java.io.FileDescriptor.fd
*
*
*
The modifiers are placed in canonical order as specified by
* "The Java Language Specification". This is {@code public},
* {@code protected} or {@code private} first, and then other
* modifiers in the following order: {@code static}, {@code final},
* {@code transient}, {@code volatile}.
*
* @return a string describing this {@code Field}
* @jls 8.3.1 Field Modifiers
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String toString() {
// int mod = getModifiers();
// return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
// + getType().getTypeName() + " "
// + getDeclaringClass().getTypeName() + "."
// + getName());
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns a string describing this {@code Field}, including
* its generic type. The format is the access modifiers for the
* field, if any, followed by the generic field type, followed by
* a space, followed by the fully-qualified name of the class
* declaring the field, followed by a period, followed by the name
* of the field.
*
*
The modifiers are placed in canonical order as specified by
* "The Java Language Specification". This is {@code public},
* {@code protected} or {@code private} first, and then other
* modifiers in the following order: {@code static}, {@code final},
* {@code transient}, {@code volatile}.
*
* @return a string describing this {@code Field}, including
* its generic type
*
* @since 1.5
* @jls 8.3.1 Field Modifiers
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String toGenericString() {
// int mod = getModifiers();
// Type fieldType = getGenericType();
// return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))
// + fieldType.getTypeName() + " "
// + getDeclaringClass().getTypeName() + "."
// + getName());
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns the value of the field represented by this {@code Field}, on
* the specified object. The value is automatically wrapped in an
* object if it has a primitive type.
*
*
The underlying field's value is obtained as follows:
*
*
If the underlying field is a static field, the {@code obj} argument
* is ignored; it may be null.
*
*
Otherwise, the underlying field is an instance field. If the
* specified {@code obj} argument is null, the method throws a
* {@code NullPointerException}. If the specified object is not an
* instance of the class or interface declaring the underlying
* field, the method throws an {@code IllegalArgumentException}.
*
*
If this {@code Field} object is enforcing Java language access control, and
* the underlying field is inaccessible, the method throws an
* {@code IllegalAccessException}.
* If the underlying field is static, the class that declared the
* field is initialized if it has not already been initialized.
*
*
Otherwise, the value is retrieved from the underlying instance
* or static field. If the field has a primitive type, the value
* is wrapped in an object before being returned, otherwise it is
* returned as is.
*
*
If the field is hidden in the type of {@code obj},
* the field's value is obtained according to the preceding rules.
*
* @param obj object from which the represented field's value is
* to be extracted
* @return the value of the represented field in object
* {@code obj}; primitive values are wrapped in an appropriate
* object before being returned
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof).
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public Object get(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// return getFieldAccessor(obj).get(obj);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Gets the value of a static or instance {@code boolean} field.
*
* @param obj the object to extract the {@code boolean} value
* from
* @return the value of the {@code boolean} field
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @exception IllegalArgumentException if the specified object is not
* an instance of the class or interface declaring the
* underlying field (or a subclass or implementor
* thereof), or if the field value cannot be
* converted to the type {@code boolean} by a
* widening conversion.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public boolean getBoolean(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// return getFieldAccessor(obj).getBoolean(obj);
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Gets the value of a static or instance {@code byte} field.
*
* @param obj the object to extract the {@code byte} value
* from
* @return the value of the {@code byte} field
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @exception IllegalArgumentException if the specified object is not
* an instance of the class or interface declaring the
* underlying field (or a subclass or implementor
* thereof), or if the field value cannot be
* converted to the type {@code byte} by a
* widening conversion.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public byte getByte(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// return getFieldAccessor(obj).getByte(obj);
CProver.notModelled();
return CProver.nondetByte();
}
/**
* Gets the value of a static or instance field of type
* {@code char} or of another primitive type convertible to
* type {@code char} via a widening conversion.
*
* @param obj the object to extract the {@code char} value
* from
* @return the value of the field converted to type {@code char}
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @exception IllegalArgumentException if the specified object is not
* an instance of the class or interface declaring the
* underlying field (or a subclass or implementor
* thereof), or if the field value cannot be
* converted to the type {@code char} by a
* widening conversion.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public char getChar(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// return getFieldAccessor(obj).getChar(obj);
CProver.notModelled();
return CProver.nondetChar();
}
/**
* Gets the value of a static or instance field of type
* {@code short} or of another primitive type convertible to
* type {@code short} via a widening conversion.
*
* @param obj the object to extract the {@code short} value
* from
* @return the value of the field converted to type {@code short}
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @exception IllegalArgumentException if the specified object is not
* an instance of the class or interface declaring the
* underlying field (or a subclass or implementor
* thereof), or if the field value cannot be
* converted to the type {@code short} by a
* widening conversion.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public short getShort(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// return getFieldAccessor(obj).getShort(obj);
CProver.notModelled();
return CProver.nondetShort();
}
/**
* Gets the value of a static or instance field of type
* {@code int} or of another primitive type convertible to
* type {@code int} via a widening conversion.
*
* @param obj the object to extract the {@code int} value
* from
* @return the value of the field converted to type {@code int}
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @exception IllegalArgumentException if the specified object is not
* an instance of the class or interface declaring the
* underlying field (or a subclass or implementor
* thereof), or if the field value cannot be
* converted to the type {@code int} by a
* widening conversion.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public int getInt(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// return getFieldAccessor(obj).getInt(obj);
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Gets the value of a static or instance field of type
* {@code long} or of another primitive type convertible to
* type {@code long} via a widening conversion.
*
* @param obj the object to extract the {@code long} value
* from
* @return the value of the field converted to type {@code long}
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @exception IllegalArgumentException if the specified object is not
* an instance of the class or interface declaring the
* underlying field (or a subclass or implementor
* thereof), or if the field value cannot be
* converted to the type {@code long} by a
* widening conversion.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public long getLong(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// return getFieldAccessor(obj).getLong(obj);
CProver.notModelled();
return CProver.nondetLong();
}
/**
* Gets the value of a static or instance field of type
* {@code float} or of another primitive type convertible to
* type {@code float} via a widening conversion.
*
* @param obj the object to extract the {@code float} value
* from
* @return the value of the field converted to type {@code float}
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @exception IllegalArgumentException if the specified object is not
* an instance of the class or interface declaring the
* underlying field (or a subclass or implementor
* thereof), or if the field value cannot be
* converted to the type {@code float} by a
* widening conversion.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public float getFloat(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// return getFieldAccessor(obj).getFloat(obj);
CProver.notModelled();
return CProver.nondetFloat();
}
/**
* Gets the value of a static or instance field of type
* {@code double} or of another primitive type convertible to
* type {@code double} via a widening conversion.
*
* @param obj the object to extract the {@code double} value
* from
* @return the value of the field converted to type {@code double}
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is inaccessible.
* @exception IllegalArgumentException if the specified object is not
* an instance of the class or interface declaring the
* underlying field (or a subclass or implementor
* thereof), or if the field value cannot be
* converted to the type {@code double} by a
* widening conversion.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#get
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public double getDouble(Object obj)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// return getFieldAccessor(obj).getDouble(obj);
CProver.notModelled();
return CProver.nondetDouble();
}
/**
* Sets the field represented by this {@code Field} object on the
* specified object argument to the specified new value. The new
* value is automatically unwrapped if the underlying field has a
* primitive type.
*
*
The operation proceeds as follows:
*
*
If the underlying field is static, the {@code obj} argument is
* ignored; it may be null.
*
*
Otherwise the underlying field is an instance field. If the
* specified object argument is null, the method throws a
* {@code NullPointerException}. If the specified object argument is not
* an instance of the class or interface declaring the underlying
* field, the method throws an {@code IllegalArgumentException}.
*
*
If this {@code Field} object is enforcing Java language access control, and
* the underlying field is inaccessible, the method throws an
* {@code IllegalAccessException}.
*
*
If the underlying field is final, the method throws an
* {@code IllegalAccessException} unless {@code setAccessible(true)}
* has succeeded for this {@code Field} object
* and the field is non-static. Setting a final field in this way
* is meaningful only during deserialization or reconstruction of
* instances of classes with blank final fields, before they are
* made available for access by other parts of a program. Use in
* any other context may have unpredictable effects, including cases
* in which other parts of a program continue to use the original
* value of this field.
*
*
If the underlying field is of a primitive type, an unwrapping
* conversion is attempted to convert the new value to a value of
* a primitive type. If this attempt fails, the method throws an
* {@code IllegalArgumentException}.
*
*
If, after possible unwrapping, the new value cannot be
* converted to the type of the underlying field by an identity or
* widening conversion, the method throws an
* {@code IllegalArgumentException}.
*
*
If the underlying field is static, the class that declared the
* field is initialized if it has not already been initialized.
*
*
The field is set to the possibly unwrapped and widened new value.
*
*
If the field is hidden in the type of {@code obj},
* the field's value is set according to the preceding rules.
*
* @param obj the object whose field should be modified
* @param value the new value for the field of {@code obj}
* being modified
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof),
* or if an unwrapping conversion fails.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public void set(Object obj, Object value)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// getFieldAccessor(obj).set(obj, value);
CProver.notModelled();
}
/**
* Sets the value of a field as a {@code boolean} on the specified object.
* This method is equivalent to
* {@code set(obj, zObj)},
* where {@code zObj} is a {@code Boolean} object and
* {@code zObj.booleanValue() == z}.
*
* @param obj the object whose field should be modified
* @param z the new value for the field of {@code obj}
* being modified
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof),
* or if an unwrapping conversion fails.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public void setBoolean(Object obj, boolean z)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// getFieldAccessor(obj).setBoolean(obj, z);
CProver.notModelled();
}
/**
* Sets the value of a field as a {@code byte} on the specified object.
* This method is equivalent to
* {@code set(obj, bObj)},
* where {@code bObj} is a {@code Byte} object and
* {@code bObj.byteValue() == b}.
*
* @param obj the object whose field should be modified
* @param b the new value for the field of {@code obj}
* being modified
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof),
* or if an unwrapping conversion fails.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public void setByte(Object obj, byte b)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// getFieldAccessor(obj).setByte(obj, b);
CProver.notModelled();
}
/**
* Sets the value of a field as a {@code char} on the specified object.
* This method is equivalent to
* {@code set(obj, cObj)},
* where {@code cObj} is a {@code Character} object and
* {@code cObj.charValue() == c}.
*
* @param obj the object whose field should be modified
* @param c the new value for the field of {@code obj}
* being modified
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof),
* or if an unwrapping conversion fails.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public void setChar(Object obj, char c)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// getFieldAccessor(obj).setChar(obj, c);
CProver.notModelled();
}
/**
* Sets the value of a field as a {@code short} on the specified object.
* This method is equivalent to
* {@code set(obj, sObj)},
* where {@code sObj} is a {@code Short} object and
* {@code sObj.shortValue() == s}.
*
* @param obj the object whose field should be modified
* @param s the new value for the field of {@code obj}
* being modified
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof),
* or if an unwrapping conversion fails.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public void setShort(Object obj, short s)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// getFieldAccessor(obj).setShort(obj, s);
CProver.notModelled();
}
/**
* Sets the value of a field as an {@code int} on the specified object.
* This method is equivalent to
* {@code set(obj, iObj)},
* where {@code iObj} is a {@code Integer} object and
* {@code iObj.intValue() == i}.
*
* @param obj the object whose field should be modified
* @param i the new value for the field of {@code obj}
* being modified
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof),
* or if an unwrapping conversion fails.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public void setInt(Object obj, int i)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// getFieldAccessor(obj).setInt(obj, i);
CProver.notModelled();
}
/**
* Sets the value of a field as a {@code long} on the specified object.
* This method is equivalent to
* {@code set(obj, lObj)},
* where {@code lObj} is a {@code Long} object and
* {@code lObj.longValue() == l}.
*
* @param obj the object whose field should be modified
* @param l the new value for the field of {@code obj}
* being modified
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof),
* or if an unwrapping conversion fails.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public void setLong(Object obj, long l)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// getFieldAccessor(obj).setLong(obj, l);
CProver.notModelled();
}
/**
* Sets the value of a field as a {@code float} on the specified object.
* This method is equivalent to
* {@code set(obj, fObj)},
* where {@code fObj} is a {@code Float} object and
* {@code fObj.floatValue() == f}.
*
* @param obj the object whose field should be modified
* @param f the new value for the field of {@code obj}
* being modified
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof),
* or if an unwrapping conversion fails.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public void setFloat(Object obj, float f)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// getFieldAccessor(obj).setFloat(obj, f);
CProver.notModelled();
}
/**
* Sets the value of a field as a {@code double} on the specified object.
* This method is equivalent to
* {@code set(obj, dObj)},
* where {@code dObj} is a {@code Double} object and
* {@code dObj.doubleValue() == d}.
*
* @param obj the object whose field should be modified
* @param d the new value for the field of {@code obj}
* being modified
*
* @exception IllegalAccessException if this {@code Field} object
* is enforcing Java language access control and the underlying
* field is either inaccessible or final.
* @exception IllegalArgumentException if the specified object is not an
* instance of the class or interface declaring the underlying
* field (or a subclass or implementor thereof),
* or if an unwrapping conversion fails.
* @exception NullPointerException if the specified object is null
* and the field is an instance field.
* @exception ExceptionInInitializerError if the initialization provoked
* by this method fails.
* @see Field#set
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public void setDouble(Object obj, double d)
throws IllegalArgumentException, IllegalAccessException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// getFieldAccessor(obj).setDouble(obj, d);
CProver.notModelled();
}
// security check is done before calling this method
// DIFFBLUE MODEL LIBRARY - not used in model
// private FieldAccessor getFieldAccessor(Object obj)
// throws IllegalAccessException
// {
// boolean ov = override;
// FieldAccessor a = (ov) ? overrideFieldAccessor : fieldAccessor;
// return (a != null) ? a : acquireFieldAccessor(ov);
// }
// NOTE that there is no synchronization used here. It is correct
// (though not efficient) to generate more than one FieldAccessor
// for a given Field. However, avoiding synchronization will
// probably make the implementation more scalable.
// DIFFBLUE MODEL LIBRARY - not used in model
// private FieldAccessor acquireFieldAccessor(boolean overrideFinalCheck) {
// // First check to see if one has been created yet, and take it
// // if so
// FieldAccessor tmp = null;
// if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);
// if (tmp != null) {
// if (overrideFinalCheck)
// overrideFieldAccessor = tmp;
// else
// fieldAccessor = tmp;
// } else {
// // Otherwise fabricate one and propagate it up to the root
// tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);
// setFieldAccessor(tmp, overrideFinalCheck);
// }
// return tmp;
// }
// Returns FieldAccessor for this Field object, not looking up
// the chain to the root
// DIFFBLUE MODEL LIBRARY - not used in model
// private FieldAccessor getFieldAccessor(boolean overrideFinalCheck) {
// return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;
// }
// Sets the FieldAccessor for this Field object and
// (recursively) its root
// DIFFBLUE MODEL LIBRARY - not used in model
// private void setFieldAccessor(FieldAccessor accessor, boolean overrideFinalCheck) {
// if (overrideFinalCheck)
// overrideFieldAccessor = accessor;
// else
// fieldAccessor = accessor;
// // Propagate up
// if (root != null) {
// root.setFieldAccessor(accessor, overrideFinalCheck);
// }
// }
/**
* @throws NullPointerException {@inheritDoc}
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public T getAnnotation(Class annotationClass) {
// Objects.requireNonNull(annotationClass);
// return annotationClass.cast(declaredAnnotations().get(annotationClass));
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @since 1.8
*
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
public T[] getAnnotationsByType(Class annotationClass) {
// Objects.requireNonNull(annotationClass);
// return AnnotationSupport.getDirectlyAndIndirectlyPresent(declaredAnnotations(), annotationClass);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* {@inheritDoc}
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Annotation[] getDeclaredAnnotations() {
// return AnnotationParser.toArray(declaredAnnotations());
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient Map, Annotation> declaredAnnotations;
// DIFFBLUE MODEL LIBRARY - not used in model
// private synchronized Map, Annotation> declaredAnnotations() {
// if (declaredAnnotations == null) {
// Field root = this.root;
// if (root != null) {
// declaredAnnotations = root.declaredAnnotations();
// } else {
// declaredAnnotations = AnnotationParser.parseAnnotations(
// annotations,
// sun.misc.SharedSecrets.getJavaLangAccess().getConstantPool(getDeclaringClass()),
// getDeclaringClass());
// }
// }
// return declaredAnnotations;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private native byte[] getTypeAnnotationBytes0();
/**
* Returns an AnnotatedType object that represents the use of a type to specify
* the declared type of the field represented by this Field.
* @return an object representing the declared type of the field
* represented by this Field
*
* @since 1.8
*
* @diffblue.untested
* @diffblue.noSupport
*/
public AnnotatedType getAnnotatedType() {
// return TypeAnnotationParser.buildAnnotatedType(getTypeAnnotationBytes0(),
// sun.misc.SharedSecrets.getJavaLangAccess().
// getConstantPool(getDeclaringClass()),
// this,
// getDeclaringClass(),
// getGenericType(),
// TypeAnnotation.TypeAnnotationTarget.FIELD);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
}
java-models-library-master/src/main/java/java/lang/reflect/GenericSignatureFormatError.java 0000664 0000000 0000000 00000004663 14323475213 0032436 0 ustar 00root root 0000000 0000000 /*
* 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.reflect;
/**
* Thrown when a syntactically malformed signature attribute is
* encountered by a reflective method that needs to interpret the
* generic signature information for a type, method or constructor.
*
* @since 1.5
*/
public class GenericSignatureFormatError extends ClassFormatError {
private static final long serialVersionUID = 6709919147137911034L;
/**
* Constructs a new {@code GenericSignatureFormatError}.
*
*/
public GenericSignatureFormatError() {
super();
}
/**
* Constructs a new {@code GenericSignatureFormatError} with the
* specified message.
*
* @param message the detail message, may be {@code null}
*/
public GenericSignatureFormatError(String message) {
super(message);
}
// 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.reflect.GenericSignatureFormatError: " + message)
: "java.lang.reflect.GenericSignatureFormatError";
}
}
java-models-library-master/src/main/java/java/lang/reflect/InvocationTargetException.java 0000664 0000000 0000000 00000010245 14323475213 0032145 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1996, 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.reflect;
/**
* InvocationTargetException is a checked exception that wraps
* an exception thrown by an invoked method or constructor.
*
*
As of release 1.4, this exception has been retrofitted to conform to
* the general purpose exception-chaining mechanism. The "target exception"
* that is provided at construction time and accessed via the
* {@link #getTargetException()} method is now known as the cause,
* and may be accessed via the {@link Throwable#getCause()} method,
* as well as the aforementioned "legacy method."
*
* @see Method
* @see Constructor
*/
public class InvocationTargetException extends ReflectiveOperationException {
/**
* Use serialVersionUID from JDK 1.1.X for interoperability
*/
private static final long serialVersionUID = 4085088731926701167L;
/**
* This field holds the target if the
* InvocationTargetException(Throwable target) constructor was
* used to instantiate the object
*
* @serial
*
*/
private Throwable target;
/**
* Constructs an {@code InvocationTargetException} with
* {@code null} as the target exception.
*/
protected InvocationTargetException() {
super((Throwable)null); // Disallow initCause
}
/**
* Constructs a InvocationTargetException with a target exception.
*
* @param target the target exception
*/
public InvocationTargetException(Throwable target) {
super((Throwable)null); // Disallow initCause
this.target = target;
}
/**
* Constructs a InvocationTargetException with a target exception
* and a detail message.
*
* @param target the target exception
* @param s the detail message
*/
public InvocationTargetException(Throwable target, String s) {
super(s, null); // Disallow initCause
this.target = target;
}
/**
* Get the thrown target exception.
*
*
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 thrown target exception (cause of this exception).
*/
public Throwable getTargetException() {
return target;
}
/**
* Returns the cause of this exception (the thrown target exception,
* which may be {@code null}).
*
* @return the cause of this exception.
* @since 1.4
*/
public Throwable getCause() {
return target;
}
// 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.reflect.InvocationTargetException: " + message)
: "java.lang.reflect.InvocationTargetException";
}
}
java-models-library-master/src/main/java/java/lang/reflect/MalformedParameterizedTypeException.java 0000664 0000000 0000000 00000004072 14323475213 0034153 0 ustar 00root root 0000000 0000000 /*
* 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.reflect;
/**
* Thrown when a semantically malformed parameterized type is
* encountered by a reflective method that needs to instantiate it.
* For example, if the number of type arguments to a parameterized type
* is wrong.
*
* @since 1.5
*/
public class MalformedParameterizedTypeException extends RuntimeException {
private static final long serialVersionUID = -5696557788586220964L;
// 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.reflect.MalformedParameterizedTypeException: " + message)
: "java.lang.reflect.MalformedParameterizedTypeException";
}
}
java-models-library-master/src/main/java/java/lang/reflect/MalformedParametersException.java 0000664 0000000 0000000 00000006014 14323475213 0032616 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 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.reflect;
/**
* Thrown when {@link java.lang.reflect.Executable#getParameters the
* java.lang.reflect package} attempts to read method parameters from
* a class file and determines that one or more parameters are
* malformed.
*
*
The following is a list of conditions under which this exception
* can be thrown:
*
*
The number of parameters (parameter_count) is wrong for the method
*
A constant pool index is out of bounds.
*
A constant pool index does not refer to a UTF-8 entry
*
A parameter's name is "", or contains an illegal character
*
The flags field contains an illegal flag (something other than
* FINAL, SYNTHETIC, or MANDATED)
*
*
* See {@link java.lang.reflect.Executable#getParameters} for more
* information.
*
* @see java.lang.reflect.Executable#getParameters
* @since 1.8
*/
public class MalformedParametersException extends RuntimeException {
/**
* Version for serialization.
*/
private static final long serialVersionUID = 20130919L;
/**
* Create a {@code MalformedParametersException} with an empty
* reason.
*/
public MalformedParametersException() {}
/**
* Create a {@code MalformedParametersException}.
*
* @param reason The reason for the exception.
*/
public MalformedParametersException(String reason) {
super(reason);
}
// 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.reflect.MalformedParametersException: " + message)
: "java.lang.reflect.MalformedParametersException";
}
}
java-models-library-master/src/main/java/java/lang/reflect/Method.java 0000664 0000000 0000000 00000071645 14323475213 0026241 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1996, 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.reflect;
import org.cprover.CProver;
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// import sun.reflect.CallerSensitive;
// import sun.reflect.MethodAccessor;
// import sun.reflect.Reflection;
import sun.reflect.generics.repository.MethodRepository;
import sun.reflect.generics.factory.CoreReflectionFactory;
import sun.reflect.generics.factory.GenericsFactory;
import sun.reflect.generics.scope.MethodScope;
import sun.reflect.annotation.AnnotationType;
import sun.reflect.annotation.AnnotationParser;
import java.lang.annotation.Annotation;
import java.lang.annotation.AnnotationFormatError;
import java.nio.ByteBuffer;
/**
* A {@code Method} provides information about, and access to, a single method
* on a class or interface. The reflected method may be a class method
* or an instance method (including an abstract method).
*
*
A {@code Method} permits widening conversions to occur when matching the
* actual parameters to invoke with the underlying method's formal
* parameters, but it throws an {@code IllegalArgumentException} if a
* narrowing conversion would occur.
*
* @see Member
* @see java.lang.Class
* @see java.lang.Class#getMethods()
* @see java.lang.Class#getMethod(String, Class[])
* @see java.lang.Class#getDeclaredMethods()
* @see java.lang.Class#getDeclaredMethod(String, Class[])
*
* @author Kenneth Russell
* @author Nakul Saraiya
*
* @diffblue.untested
* @diffblue.noSupport
* This model was automatically generated by the JDK Processor tool.
*/
public final class Method extends Executable {
private Class clazz;
// DIFFBLUE MODEL LIBRARY - not used in model
// private int slot;
// This is guaranteed to be interned by the VM in the 1.4
// reflection implementation
private String name;
// DIFFBLUE MODEL LIBRARY - not used in model
// private Class returnType;
private Class[] parameterTypes;
// DIFFBLUE MODEL LIBRARY - not used in model
// private Class[] exceptionTypes;
// DIFFBLUE MODEL LIBRARY - not used in model
// private int modifiers;
// Generics and annotations support
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient String signature;
// generic info repository; lazily initialized
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient MethodRepository genericInfo;
// DIFFBLUE MODEL LIBRARY - not used in model
// private byte[] annotations;
// DIFFBLUE MODEL LIBRARY - not used in model
// private byte[] parameterAnnotations;
// DIFFBLUE MODEL LIBRARY - not used in model
// private byte[] annotationDefault;
// DIFFBLUE MODEL LIBRARY - not used in model
// private volatile MethodAccessor methodAccessor;
// For sharing of MethodAccessors. This branching structure is
// currently only two levels deep (i.e., one root Method and
// potentially many Method objects pointing to it.)
//
// If this branching structure would ever contain cycles, deadlocks can
// occur in annotation code.
// DIFFBLUE MODEL LIBRARY - not used in model
// private Method root;
// Generics infrastructure
// DIFFBLUE MODEL LIBRARY - not used in model
// private String getGenericSignature() {return signature;}
// Accessor for factory
// DIFFBLUE MODEL LIBRARY - not used in model
// private GenericsFactory getFactory() {
// // create scope and factory
// return CoreReflectionFactory.make(this, MethodScope.make(this));
// }
/**
* Accessor for generic info repository
*
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
// DIFFBLUE MODEL LIBRARY - not used in model
MethodRepository getGenericInfo() {
// // lazily initialize repository if necessary
// if (genericInfo == null) {
// // create and cache generic info repository
// genericInfo = MethodRepository.make(getGenericSignature(),
// getFactory());
// }
// return genericInfo; //return cached repository
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Package-private constructor used by ReflectAccess to enable
* instantiation of these objects in Java code from the java.lang
* package via sun.reflect.LangReflectAccess.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// Method(Class declaringClass,
// String name,
// Class[] parameterTypes,
// Class returnType,
// Class[] checkedExceptions,
// int modifiers,
// int slot,
// String signature,
// byte[] annotations,
// byte[] parameterAnnotations,
// byte[] annotationDefault) {
// this.clazz = declaringClass;
// this.name = name;
// this.parameterTypes = parameterTypes;
// this.returnType = returnType;
// this.exceptionTypes = checkedExceptions;
// this.modifiers = modifiers;
// this.slot = slot;
// this.signature = signature;
// this.annotations = annotations;
// this.parameterAnnotations = parameterAnnotations;
// this.annotationDefault = annotationDefault;
// }
/**
* This constructor does not exist in the JDK, only in the model
*/
public Method(
Class declaringClass,
String name,
Class[] parameterTypes)
{
this.clazz = declaringClass;
this.name = name;
this.parameterTypes = parameterTypes;
}
/**
* Package-private routine (exposed to java.lang.Class via
* ReflectAccess) which returns a copy of this Method. The copy's
* "root" field points to this Method.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// Method copy() {
// // This routine enables sharing of MethodAccessor objects
// // among Method objects which refer to the same underlying
// // method in the VM. (All of this contortion is only necessary
// // because of the "accessibility" bit in AccessibleObject,
// // which implicitly requires that new java.lang.reflect
// // objects be fabricated for each reflective call on Class
// // objects.)
// if (this.root != null)
// throw new IllegalArgumentException("Can not copy a non-root Method");
// Method res = new Method(clazz, name, parameterTypes, returnType,
// exceptionTypes, modifiers, slot, signature,
// annotations, parameterAnnotations, annotationDefault);
// res.root = this;
// // Might as well eagerly propagate this if already present
// res.methodAccessor = methodAccessor;
// return res;
// }
/**
* Used by Excecutable for annotation sharing.
*
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
// DIFFBLUE MODEL LIBRARY - not used in model
Executable getRoot() {
// return root;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
// DIFFBLUE MODEL LIBRARY - not used in model
boolean hasGenericInformation() {
// return (getGenericSignature() != null);
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
// DIFFBLUE MODEL LIBRARY - not used in model
byte[] getAnnotationBytes() {
// return annotations;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* {@inheritDoc}
*
* @diffblue.fullSupport
*/
@Override
public Class getDeclaringClass() {
return clazz;
}
/**
* Returns the name of the method represented by this {@code Method}
* object, as a {@code String}.
*
* @diffblue.fullSupport
*/
@Override
public String getName() {
return name;
}
/**
* {@inheritDoc}
*
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
public int getModifiers() {
// return modifiers;
CProver.notModelled();
return CProver.nondetInt();
}
/**
* {@inheritDoc}
* @throws GenericSignatureFormatError {@inheritDoc}
* @since 1.5
*/
@Override
@SuppressWarnings({"rawtypes", "unchecked"})
public TypeVariable[] getTypeParameters() {
// if (getGenericSignature() != null)
// return (TypeVariable[])getGenericInfo().getTypeParameters();
// else
// return (TypeVariable[])new TypeVariable[0];
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns a {@code Class} object that represents the formal return type
* of the method represented by this {@code Method} object.
*
* @return the return type for the method this object represents
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Class getReturnType() {
// return returnType;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns a {@code Type} object that represents the formal return
* type of the method represented by this {@code Method} object.
*
*
If the return type is a parameterized type,
* the {@code Type} object returned must accurately reflect
* the actual type parameters used in the source code.
*
*
If the return type is a type variable or a parameterized type, it
* is created. Otherwise, it is resolved.
*
* @return a {@code Type} object that represents the formal return
* type of the underlying method
* @throws GenericSignatureFormatError
* if the generic method signature does not conform to the format
* specified in
* The Java™ Virtual Machine Specification
* @throws TypeNotPresentException if the underlying method's
* return type refers to a non-existent type declaration
* @throws MalformedParameterizedTypeException if the
* underlying method's return typed refers to a parameterized
* type that cannot be instantiated for any reason
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Type getGenericReturnType() {
// if (getGenericSignature() != null) {
// return getGenericInfo().getReturnType();
// } else { return getReturnType();}
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* {@inheritDoc}
*
* @diffblue.untested
* @diffblue.fullSupport
*/
@Override
public Class[] getParameterTypes() {
return parameterTypes.clone();
}
/**
* {@inheritDoc}
* @since 1.8
*
* @diffblue.untested
* @diffblue.fullSupport
*/
public int getParameterCount() {
return parameterTypes.length;
}
/**
* {@inheritDoc}
* @throws GenericSignatureFormatError {@inheritDoc}
* @throws TypeNotPresentException {@inheritDoc}
* @throws MalformedParameterizedTypeException {@inheritDoc}
* @since 1.5
*
* @diffblue.untested
*/
@Override
public Type[] getGenericParameterTypes() {
return super.getGenericParameterTypes();
}
/**
* {@inheritDoc}
*
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
public Class[] getExceptionTypes() {
// return exceptionTypes.clone();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* {@inheritDoc}
* @throws GenericSignatureFormatError {@inheritDoc}
* @throws TypeNotPresentException {@inheritDoc}
* @throws MalformedParameterizedTypeException {@inheritDoc}
* @since 1.5
*
* @diffblue.untested
*/
@Override
public Type[] getGenericExceptionTypes() {
return super.getGenericExceptionTypes();
}
/**
* Compares this {@code Method} against the specified object. Returns
* true if the objects are the same. Two {@code Methods} are the same if
* they were declared by the same class and have the same name
* and formal parameter types and return type.
*
* @diffblue.limitedSupport
*/
public boolean equals(Object obj) {
if (obj != null && obj instanceof Method) {
Method other = (Method)obj;
if ((getDeclaringClass() == other.getDeclaringClass())
&& (getName() == other.getName())) {
return equalParamTypes(parameterTypes, other.parameterTypes);
}
}
return false;
}
/**
* Returns a hashcode for this {@code Method}. The hashcode is computed
* as the exclusive-or of the hashcodes for the underlying
* method's declaring class name and the method's name.
*
* @diffblue.untested
*/
public int hashCode() {
return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
}
/**
* Returns a string describing this {@code Method}. The string is
* formatted as the method access modifiers, if any, followed by
* the method return type, followed by a space, followed by the
* class declaring the method, followed by a period, followed by
* the method name, followed by a parenthesized, comma-separated
* list of the method's formal parameter types. If the method
* throws checked exceptions, the parameter list is followed by a
* space, followed by the word throws followed by a
* comma-separated list of the thrown exception types.
* For example:
*
* public boolean java.lang.Object.equals(java.lang.Object)
*
*
*
The access modifiers are placed in canonical order as
* specified by "The Java Language Specification". This is
* {@code public}, {@code protected} or {@code private} first,
* and then other modifiers in the following order:
* {@code abstract}, {@code default}, {@code static}, {@code final},
* {@code synchronized}, {@code native}, {@code strictfp}.
*
* @return a string describing this {@code Method}
*
* @jls 8.4.3 Method Modifiers
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String toString() {
// return sharedToString(Modifier.methodModifiers(),
// isDefault(),
// parameterTypes,
// exceptionTypes);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
// DIFFBLUE MODEL LIBRARY - not used in model
void specificToStringHeader(StringBuilder sb) {
// sb.append(getReturnType().getTypeName()).append(' ');
// sb.append(getDeclaringClass().getTypeName()).append('.');
// sb.append(getName());
CProver.notModelled();
}
/**
* Returns a string describing this {@code Method}, including
* type parameters. The string is formatted as the method access
* modifiers, if any, followed by an angle-bracketed
* comma-separated list of the method's type parameters, if any,
* followed by the method's generic return type, followed by a
* space, followed by the class declaring the method, followed by
* a period, followed by the method name, followed by a
* parenthesized, comma-separated list of the method's generic
* formal parameter types.
*
* If this method was declared to take a variable number of
* arguments, instead of denoting the last parameter as
* "Type[]", it is denoted as
* "Type...".
*
* A space is used to separate access modifiers from one another
* and from the type parameters or return type. If there are no
* type parameters, the type parameter list is elided; if the type
* parameter list is present, a space separates the list from the
* class name. If the method is declared to throw exceptions, the
* parameter list is followed by a space, followed by the word
* throws followed by a comma-separated list of the generic thrown
* exception types.
*
*
The access modifiers are placed in canonical order as
* specified by "The Java Language Specification". This is
* {@code public}, {@code protected} or {@code private} first,
* and then other modifiers in the following order:
* {@code abstract}, {@code default}, {@code static}, {@code final},
* {@code synchronized}, {@code native}, {@code strictfp}.
*
* @return a string describing this {@code Method},
* include type parameters
*
* @since 1.5
*
* @jls 8.4.3 Method Modifiers
*
* @diffblue.untested
*/
@Override
public String toGenericString() {
return sharedToGenericString(Modifier.methodModifiers(), isDefault());
}
/**
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
// DIFFBLUE MODEL LIBRARY - not used in model
void specificToGenericStringHeader(StringBuilder sb) {
// Type genRetType = getGenericReturnType();
// sb.append(genRetType.getTypeName()).append(' ');
// sb.append(getDeclaringClass().getTypeName()).append('.');
// sb.append(getName());
CProver.notModelled();
}
/**
* Invokes the underlying method represented by this {@code Method}
* object, on the specified object with the specified parameters.
* Individual parameters are automatically unwrapped to match
* primitive formal parameters, and both primitive and reference
* parameters are subject to method invocation conversions as
* necessary.
*
*
If the underlying method is static, then the specified {@code obj}
* argument is ignored. It may be null.
*
*
If the number of formal parameters required by the underlying method is
* 0, the supplied {@code args} array may be of length 0 or null.
*
*
If the underlying method is an instance method, it is invoked
* using dynamic method lookup as documented in The Java Language
* Specification, Second Edition, section 15.12.4.4; in particular,
* overriding based on the runtime type of the target object will occur.
*
*
If the underlying method is static, the class that declared
* the method is initialized if it has not already been initialized.
*
*
If the method completes normally, the value it returns is
* returned to the caller of invoke; if the value has a primitive
* type, it is first appropriately wrapped in an object. However,
* if the value has the type of an array of a primitive type, the
* elements of the array are not wrapped in objects; in
* other words, an array of primitive type is returned. If the
* underlying method return type is void, the invocation returns
* null.
*
* @param obj the object the underlying method is invoked from
* @param args the arguments used for the method call
* @return the result of dispatching the method represented by
* this object on {@code obj} with parameters
* {@code args}
*
* @exception IllegalAccessException if this {@code Method} object
* is enforcing Java language access control and the underlying
* method is inaccessible.
* @exception IllegalArgumentException if the method is an
* instance method and the specified object argument
* is not an instance of the class or interface
* declaring the underlying method (or of a subclass
* or implementor thereof); if the number of actual
* and formal parameters differ; if an unwrapping
* conversion for primitive arguments fails; or if,
* after possible unwrapping, a parameter value
* cannot be converted to the corresponding formal
* parameter type by a method invocation conversion.
* @exception InvocationTargetException if the underlying method
* throws an exception.
* @exception NullPointerException if the specified object is null
* and the method is an instance method.
* @exception ExceptionInInitializerError if the initialization
* provoked by this method fails.
*
* @diffblue.untested
* @diffblue.noSupport
*/
// DIFFBLUE MODEL LIBRARY
// removed for compatibility with Java 9 and newer
// @CallerSensitive
public Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException,
InvocationTargetException
{
// if (!override) {
// if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
// Class caller = Reflection.getCallerClass();
// checkAccess(caller, clazz, obj, modifiers);
// }
// }
// MethodAccessor ma = methodAccessor; // read volatile
// if (ma == null) {
// ma = acquireMethodAccessor();
// }
// return ma.invoke(obj, args);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns {@code true} if this method is a bridge
* method; returns {@code false} otherwise.
*
* @return true if and only if this method is a bridge
* method as defined by the Java Language Specification.
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean isBridge() {
// return (getModifiers() & Modifier.BRIDGE) != 0;
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* {@inheritDoc}
* @since 1.5
*
* @diffblue.untested
*/
@Override
public boolean isVarArgs() {
return super.isVarArgs();
}
/**
* {@inheritDoc}
* @jls 13.1 The Form of a Binary
* @since 1.5
*
* @diffblue.untested
*/
@Override
public boolean isSynthetic() {
return super.isSynthetic();
}
/**
* Returns {@code true} if this method is a default
* method; returns {@code false} otherwise.
*
* A default method is a public non-abstract instance method, that
* is, a non-static method with a body, declared in an interface
* type.
*
* @return true if and only if this method is a default
* method as defined by the Java Language Specification.
* @since 1.8
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean isDefault() {
// // Default methods are public non-abstract instance methods
// // declared in an interface.
// return ((getModifiers() & (Modifier.ABSTRACT | Modifier.PUBLIC | Modifier.STATIC)) ==
// Modifier.PUBLIC) && getDeclaringClass().isInterface();
CProver.notModelled();
return CProver.nondetBoolean();
}
// NOTE that there is no synchronization used here. It is correct
// (though not efficient) to generate more than one MethodAccessor
// for a given Method. However, avoiding synchronization will
// probably make the implementation more scalable.
// DIFFBLUE MODEL LIBRARY - not used in model
// private MethodAccessor acquireMethodAccessor() {
// // First check to see if one has been created yet, and take it
// // if so
// MethodAccessor tmp = null;
// if (root != null) tmp = root.getMethodAccessor();
// if (tmp != null) {
// methodAccessor = tmp;
// } else {
// // Otherwise fabricate one and propagate it up to the root
// tmp = reflectionFactory.newMethodAccessor(this);
// setMethodAccessor(tmp);
// }
// return tmp;
// }
// Returns MethodAccessor for this Method object, not looking up
// the chain to the root
// DIFFBLUE MODEL LIBRARY - not used in model
// MethodAccessor getMethodAccessor() {
// return methodAccessor;
// }
// Sets the MethodAccessor for this Method object and
// (recursively) its root
// DIFFBLUE MODEL LIBRARY - not used in model
// void setMethodAccessor(MethodAccessor accessor) {
// methodAccessor = accessor;
// // Propagate up
// if (root != null) {
// root.setMethodAccessor(accessor);
// }
// }
/**
* Returns the default value for the annotation member represented by
* this {@code Method} instance. If the member is of a primitive type,
* an instance of the corresponding wrapper type is returned. Returns
* null if no default is associated with the member, or if the method
* instance does not represent a declared member of an annotation type.
*
* @return the default value for the annotation member represented
* by this {@code Method} instance.
* @throws TypeNotPresentException if the annotation is of type
* {@link Class} and no definition can be found for the
* default class value.
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Object getDefaultValue() {
// if (annotationDefault == null)
// return null;
// Class memberType = AnnotationType.invocationHandlerReturnType(
// getReturnType());
// Object result = AnnotationParser.parseMemberValue(
// memberType, ByteBuffer.wrap(annotationDefault),
// sun.misc.SharedSecrets.getJavaLangAccess().
// getConstantPool(getDeclaringClass()),
// getDeclaringClass());
// if (result instanceof sun.reflect.annotation.ExceptionProxy)
// throw new AnnotationFormatError("Invalid default: " + this);
// return result;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @since 1.5
*
* @diffblue.untested
*/
public T getAnnotation(Class annotationClass) {
return super.getAnnotation(annotationClass);
}
/**
* {@inheritDoc}
* @since 1.5
*
* @diffblue.untested
*/
public Annotation[] getDeclaredAnnotations() {
return super.getDeclaredAnnotations();
}
/**
* {@inheritDoc}
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
public Annotation[][] getParameterAnnotations() {
// return sharedGetParameterAnnotations(parameterTypes, parameterAnnotations);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* {@inheritDoc}
* @since 1.8
*
* @diffblue.untested
* @diffblue.noSupport
*/
@Override
public AnnotatedType getAnnotatedReturnType() {
// return getAnnotatedReturnType0(getGenericReturnType());
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* @diffblue.untested
*/
@Override
// DIFFBLUE MODEL LIBRARY - not used in model
void handleParameterNumberMismatch(int resultLength, int numParameters) {
throw new AnnotationFormatError("Parameter annotations don't match number of parameters");
}
}
java-models-library-master/src/main/java/java/lang/reflect/UndeclaredThrowableException.java 0000664 0000000 0000000 00000012026 14323475213 0032602 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1999, 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.reflect;
/**
* Thrown by a method invocation on a proxy instance if its invocation
* handler's {@link InvocationHandler#invoke invoke} method throws a
* checked exception (a {@code Throwable} that is not assignable
* to {@code RuntimeException} or {@code Error}) that
* is not assignable to any of the exception types declared in the
* {@code throws} clause of the method that was invoked on the
* proxy instance and dispatched to the invocation handler.
*
*
An {@code UndeclaredThrowableException} instance contains
* the undeclared checked exception that was thrown by the invocation
* handler, and it can be retrieved with the
* {@code getUndeclaredThrowable()} method.
* {@code UndeclaredThrowableException} extends
* {@code RuntimeException}, so it is an unchecked exception
* that wraps a checked exception.
*
*
As of release 1.4, this exception has been retrofitted to
* conform to the general purpose exception-chaining mechanism. The
* "undeclared checked exception that was thrown by the invocation
* handler" that may be provided at construction time and accessed via
* the {@link #getUndeclaredThrowable()} method is now known as the
* cause, and may be accessed via the {@link
* Throwable#getCause()} method, as well as the aforementioned "legacy
* method."
*
* @author Peter Jones
* @see InvocationHandler
* @since 1.3
*/
public class UndeclaredThrowableException extends RuntimeException {
static final long serialVersionUID = 330127114055056639L;
/**
* the undeclared checked exception that was thrown
* @serial
*/
private Throwable undeclaredThrowable;
/**
* Constructs an {@code UndeclaredThrowableException} with the
* specified {@code Throwable}.
*
* @param undeclaredThrowable the undeclared checked exception
* that was thrown
*/
public UndeclaredThrowableException(Throwable undeclaredThrowable) {
super((Throwable) null); // Disallow initCause
this.undeclaredThrowable = undeclaredThrowable;
}
/**
* Constructs an {@code UndeclaredThrowableException} with the
* specified {@code Throwable} and a detail message.
*
* @param undeclaredThrowable the undeclared checked exception
* that was thrown
* @param s the detail message
*/
public UndeclaredThrowableException(Throwable undeclaredThrowable,
String s)
{
super(s, null); // Disallow initCause
this.undeclaredThrowable = undeclaredThrowable;
}
/**
* Returns the {@code Throwable} instance wrapped in this
* {@code UndeclaredThrowableException}, which may be {@code null}.
*
*
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 undeclared checked exception that was thrown
*/
public Throwable getUndeclaredThrowable() {
return undeclaredThrowable;
}
/**
* Returns the cause of this exception (the {@code Throwable}
* instance wrapped in this {@code UndeclaredThrowableException},
* which may be {@code null}).
*
* @return the cause of this exception.
* @since 1.4
*/
public Throwable getCause() {
return undeclaredThrowable;
}
// 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.reflect.UndeclaredThrowableException: " + message)
: "java.lang.reflect.UndeclaredThrowableException";
}
}
java-models-library-master/src/main/java/java/util/ 0000775 0000000 0000000 00000000000 14323475213 0022551 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/java/util/Random.java 0000664 0000000 0000000 00000154614 14323475213 0024647 0 ustar 00root root 0000000 0000000 /*
* 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,
* The Art of Computer Programming, Volume 2, Section 3.2.1.)
*
* 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.
*
* 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.
*
* Many applications will find the method {@link Math#random} simpler to use.
*
*
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.
*
*
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}.
*
*
The invocation {@code new Random(seed)} is equivalent to:
*
{@code
* Random rnd = new Random();
* rnd.setSeed(seed);}
*
* @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
*
{@code (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)}
* and clearing the {@code haveNextNextGaussian} flag used by {@link
* #nextGaussian}.
*
*
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.mock
* @diffblue.limitedSupport
* 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.
*
*/
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.
*
*
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
*
*
* This is a linear congruential pseudorandom number generator, as
* defined by D. H. Lehmer and described by Donald E. Knuth in
* The Art of Computer Programming, Volume 3:
* Seminumerical Algorithms, 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.
*
*
The method {@code nextBytes} is implemented by class {@code Random}
* as if by:
*
{@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;
* }}
*
* @param bytes the byte array to fill with random bytes
* @throws NullPointerException if the byte array is null
* @since 1.1
*
* @diffblue.mock
* @diffblue.limitedSupport
*
*/
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 232 possible
* {@code int} values are produced with (approximately) equal probability.
*
*
The method {@code nextInt} is implemented by class {@code Random}
* as if by:
*
{@code
* public int nextInt() {
* return next(32);
* }}
*
* @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:
*
{@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;
* }}
*
*
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.
*
* 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.
*
* 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 low-order 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.
*
*
The method {@code nextLong} is implemented by class {@code Random}
* as if by:
*
{@code
* public long nextLong() {
* return ((long)next(32) << 32) + next(32);
* }}
*
* 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.
*
*
The method {@code nextBoolean} is implemented by class {@code Random}
* as if by:
*
*
* @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.
*
*
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 224 possible
* {@code float} values of the form m x 2-24,
* where m is a positive integer less than 224, are
* produced with (approximately) equal probability.
*
*
The method {@code nextFloat} is implemented by class {@code Random}
* as if by:
*
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.
* [In early versions of Java, the result was incorrectly calculated as:
*
{@code
* return next(30) / ((float)(1 << 30));}
* 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.
*
*
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.
*
*
The method {@code nextDouble} is implemented by class {@code Random}
* as if by:
*
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.
*
[In early versions of Java, the result was incorrectly calculated as:
*
* 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.
*
* 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.
*
*
The method {@code nextGaussian} is implemented by class
* {@code Random} as if by a threadsafe version of the following:
*
* This uses the polar method of G. E. P. Box, M. E. Muller, and
* G. Marsaglia, as described by Donald E. Knuth in The Art of
* Computer Programming, Volume 3: Seminumerical Algorithms,
* 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.
*
*
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.
*
*
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).
*
*
A pseudorandom {@code int} value is generated as if it's the result of
* calling the following method with the origin and bound:
*
{@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;
* }
* }}
*
* @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).
*
*
A pseudorandom {@code int} value is generated as if it's the result of
* calling the following method with the origin and bound:
*
{@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;
* }
* }}
*
* @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.
*
*
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.
*
*
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).
*
*
A pseudorandom {@code long} value is generated as if it's the result
* of calling the following method with the origin and bound:
*
{@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;
* }}
*
* @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).
*
*
A pseudorandom {@code long} value is generated as if it's the result
* of calling the following method with the origin and bound:
*
{@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;
* }}
*
* @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).
*
*
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).
*
*
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).
*
*
A pseudorandom {@code double} value is generated as if it's the result
* of calling the following method with the origin and bound:
*
{@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;
* }}
*
* @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).
*
*
A pseudorandom {@code double} value is generated as if it's the result
* of calling the following method with the origin and bound:
*
{@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;
* }}
*
* @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));
// }
}
java-models-library-master/src/main/java/java/util/regex/ 0000775 0000000 0000000 00000000000 14323475213 0023663 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/java/util/regex/Matcher.java 0000664 0000000 0000000 00000161257 14323475213 0026125 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1999, 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.regex;
import org.cprover.CProver;
import java.util.Objects;
/**
* An engine that performs match operations on a {@linkplain java.lang.CharSequence
* character sequence} by interpreting a {@link Pattern}.
*
*
A matcher is created from a pattern by invoking the pattern's {@link
* Pattern#matcher matcher} method. Once created, a matcher can be used to
* perform three different kinds of match operations:
*
*
*
*
The {@link #matches matches} method attempts to match the entire
* input sequence against the pattern.
*
*
The {@link #lookingAt lookingAt} method attempts to match the
* input sequence, starting at the beginning, against the pattern.
*
*
The {@link #find find} method scans the input sequence looking for
* the next subsequence that matches the pattern.
*
*
*
*
Each of these methods returns a boolean indicating success or failure.
* More information about a successful match can be obtained by querying the
* state of the matcher.
*
*
A matcher finds matches in a subset of its input called the
* region. By default, the region contains all of the matcher's input.
* The region can be modified via the{@link #region region} method and queried
* via the {@link #regionStart regionStart} and {@link #regionEnd regionEnd}
* methods. The way that the region boundaries interact with some pattern
* constructs can be changed. See {@link #useAnchoringBounds
* useAnchoringBounds} and {@link #useTransparentBounds useTransparentBounds}
* for more details.
*
*
This class also defines methods for replacing matched subsequences with
* new strings whose contents can, if desired, be computed from the match
* result. The {@link #appendReplacement appendReplacement} and {@link
* #appendTail appendTail} methods can be used in tandem in order to collect
* the result into an existing string buffer, or the more convenient {@link
* #replaceAll replaceAll} method can be used to create a string in which every
* matching subsequence in the input sequence is replaced.
*
*
The explicit state of a matcher includes the start and end indices of
* the most recent successful match. It also includes the start and end
* indices of the input subsequence captured by each capturing group in the pattern as well as a total
* count of such subsequences. As a convenience, methods are also provided for
* returning these captured subsequences in string form.
*
*
The explicit state of a matcher is initially undefined; attempting to
* query any part of it before a successful match will cause an {@link
* IllegalStateException} to be thrown. The explicit state of a matcher is
* recomputed by every match operation.
*
*
The implicit state of a matcher includes the input character sequence as
* well as the append position, which is initially zero and is updated
* by the {@link #appendReplacement appendReplacement} method.
*
*
A matcher may be reset explicitly by invoking its {@link #reset()}
* method or, if a new input sequence is desired, its {@link
* #reset(java.lang.CharSequence) reset(CharSequence)} method. Resetting a
* matcher discards its explicit state information and sets the append position
* to zero.
*
*
Instances of this class are not safe for use by multiple concurrent
* threads.
*
*
* @author Mike McCloskey
* @author Mark Reinhold
* @author JSR-51 Expert Group
* @since 1.4
* @spec JSR-51
*
* @diffblue.untested
* @diffblue.noSupport
* This model was automatically generated by the JDK Processor tool.
*/
public final class Matcher implements MatchResult {
/**
* The Pattern object that created this Matcher.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// Pattern parentPattern;
/**
* The storage used by groups. They may contain invalid values if
* a group was skipped during the matching.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// int[] groups;
/**
* The range within the sequence that is to be matched. Anchors
* will match at these "hard" boundaries. Changing the region
* changes these values.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// int from, to;
/**
* Lookbehind uses this value to ensure that the subexpression
* match ends at the point where the lookbehind was encountered.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// int lookbehindTo;
/**
* The original string being matched.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// CharSequence text;
/**
* Matcher state used by the last node. NOANCHOR is used when a
* match does not have to consume all of the input. ENDANCHOR is
* the mode used for matching all the input.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final int ENDANCHOR = 1;
// DIFFBLUE MODEL LIBRARY - not used in model
// static final int NOANCHOR = 0;
// DIFFBLUE MODEL LIBRARY - not used in model
// int acceptMode = NOANCHOR;
/**
* The range of string that last matched the pattern. If the last
* match failed then first is -1; last initially holds 0 then it
* holds the index of the end of the last match (which is where the
* next search starts).
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// int first = -1, last = 0;
/**
* The end index of what matched in the last match operation.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// int oldLast = -1;
/**
* The index of the last position appended in a substitution.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// int lastAppendPosition = 0;
/**
* Storage used by nodes to tell what repetition they are on in
* a pattern, and where groups begin. The nodes themselves are stateless,
* so they rely on this field to hold state during a match.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// int[] locals;
/**
* Boolean indicating whether or not more input could change
* the results of the last match.
*
* If hitEnd is true, and a match was found, then more input
* might cause a different match to be found.
* If hitEnd is true and a match was not found, then more
* input could cause a match to be found.
* If hitEnd is false and a match was found, then more input
* will not change the match.
* If hitEnd is false and a match was not found, then more
* input will not cause a match to be found.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// boolean hitEnd;
/**
* Boolean indicating whether or not more input could change
* a positive match into a negative one.
*
* If requireEnd is true, and a match was found, then more
* input could cause the match to be lost.
* If requireEnd is false and a match was found, then more
* input might change the match but the match won't be lost.
* If a match was not found, then requireEnd has no meaning.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// boolean requireEnd;
/**
* If transparentBounds is true then the boundaries of this
* matcher's region are transparent to lookahead, lookbehind,
* and boundary matching constructs that try to see beyond them.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// boolean transparentBounds = false;
/**
* If anchoringBounds is true then the boundaries of this
* matcher's region match anchors such as ^ and $.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// boolean anchoringBounds = true;
/**
* No default constructor.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// Matcher() {
// }
/**
* All matchers have the state used by Pattern during a match.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// Matcher(Pattern parent, CharSequence text) {
// this.parentPattern = parent;
// this.text = text;
// // Allocate state storage
// int parentGroupCount = Math.max(parent.capturingGroupCount, 10);
// groups = new int[parentGroupCount * 2];
// locals = new int[parent.localCount];
// // Put fields into initial states
// reset();
// }
/**
* Returns the pattern that is interpreted by this matcher.
*
* @return The pattern for which this matcher was created
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Pattern pattern() {
// return parentPattern;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns the match state of this matcher as a {@link MatchResult}.
* The result is unaffected by subsequent operations performed upon this
* matcher.
*
* @return a MatchResult with the state of this matcher
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public MatchResult toMatchResult() {
// Matcher result = new Matcher(this.parentPattern, text.toString());
// result.first = this.first;
// result.last = this.last;
// result.groups = this.groups.clone();
// return result;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Changes the Pattern that this Matcher uses to
* find matches with.
*
*
This method causes this matcher to lose information
* about the groups of the last match that occurred. The
* matcher's position in the input is maintained and its
* last append position is unaffected.
*
* @param newPattern
* The new pattern used by this matcher
* @return This matcher
* @throws IllegalArgumentException
* If newPattern is null
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Matcher usePattern(Pattern newPattern) {
// if (newPattern == null)
// throw new IllegalArgumentException("Pattern cannot be null");
// parentPattern = newPattern;
// // Reallocate state storage
// int parentGroupCount = Math.max(newPattern.capturingGroupCount, 10);
// groups = new int[parentGroupCount * 2];
// locals = new int[newPattern.localCount];
// for (int i = 0; i < groups.length; i++)
// groups[i] = -1;
// for (int i = 0; i < locals.length; i++)
// locals[i] = -1;
// return this;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Resets this matcher.
*
*
Resetting a matcher discards all of its explicit state information
* and sets its append position to zero. The matcher's region is set to the
* default region, which is its entire character sequence. The anchoring
* and transparency of this matcher's region boundaries are unaffected.
*
* @return This matcher
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Matcher reset() {
// first = -1;
// last = 0;
// oldLast = -1;
// for(int i=0; i Resetting a matcher discards all of its explicit state information
* and sets its append position to zero. The matcher's region is set to
* the default region, which is its entire character sequence. The
* anchoring and transparency of this matcher's region boundaries are
* unaffected.
*
* @param input
* The new input character sequence
*
* @return This matcher
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Matcher reset(CharSequence input) {
// text = input;
// return reset();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns the start index of the previous match.
*
* @return The index of the first character matched
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int start() {
// if (first < 0)
// throw new IllegalStateException("No match available");
// return first;
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Returns the start index of the subsequence captured by the given group
* during the previous match operation.
*
*
Capturing groups are indexed from left
* to right, starting at one. Group zero denotes the entire pattern, so
* the expression m.start(0) is equivalent to
* m.start().
*
* @param group
* The index of a capturing group in this matcher's pattern
*
* @return The index of the first character captured by the group,
* or -1 if the match was successful but the group
* itself did not match anything
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @throws IndexOutOfBoundsException
* If there is no capturing group in the pattern
* with the given index
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int start(int group) {
// if (first < 0)
// throw new IllegalStateException("No match available");
// if (group < 0 || group > groupCount())
// throw new IndexOutOfBoundsException("No group " + group);
// return groups[group * 2];
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Returns the start index of the subsequence captured by the given
* named-capturing group during the
* previous match operation.
*
* @param name
* The name of a named-capturing group in this matcher's pattern
*
* @return The index of the first character captured by the group,
* or {@code -1} if the match was successful but the group
* itself did not match anything
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @throws IllegalArgumentException
* If there is no capturing group in the pattern
* with the given name
* @since 1.8
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int start(String name) {
// return groups[getMatchedGroupIndex(name) * 2];
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Returns the offset after the last character matched.
*
* @return The offset after the last character matched
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int end() {
// if (first < 0)
// throw new IllegalStateException("No match available");
// return last;
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Returns the offset after the last character of the subsequence
* captured by the given group during the previous match operation.
*
*
Capturing groups are indexed from left
* to right, starting at one. Group zero denotes the entire pattern, so
* the expression m.end(0) is equivalent to
* m.end().
*
* @param group
* The index of a capturing group in this matcher's pattern
*
* @return The offset after the last character captured by the group,
* or -1 if the match was successful
* but the group itself did not match anything
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @throws IndexOutOfBoundsException
* If there is no capturing group in the pattern
* with the given index
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int end(int group) {
// if (first < 0)
// throw new IllegalStateException("No match available");
// if (group < 0 || group > groupCount())
// throw new IndexOutOfBoundsException("No group " + group);
// return groups[group * 2 + 1];
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Returns the offset after the last character of the subsequence
* captured by the given named-capturing
* group during the previous match operation.
*
* @param name
* The name of a named-capturing group in this matcher's pattern
*
* @return The offset after the last character captured by the group,
* or {@code -1} if the match was successful
* but the group itself did not match anything
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @throws IllegalArgumentException
* If there is no capturing group in the pattern
* with the given name
* @since 1.8
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int end(String name) {
// return groups[getMatchedGroupIndex(name) * 2 + 1];
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Returns the input subsequence matched by the previous match.
*
*
For a matcher m with input sequence s,
* the expressions m.group() and
* s.substring(m.start(),m.end())
* are equivalent.
*
*
Note that some patterns, for example a*, match the empty
* string. This method will return the empty string when the pattern
* successfully matches the empty string in the input.
*
* @return The (possibly empty) subsequence matched by the previous match,
* in string form
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String group() {
// return group(0);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns the input subsequence captured by the given group during the
* previous match operation.
*
*
For a matcher m, input sequence s, and group index
* g, the expressions m.group(g) and
* s.substring(m.start(g),m.end(g))
* are equivalent.
*
*
Capturing groups are indexed from left
* to right, starting at one. Group zero denotes the entire pattern, so
* the expression m.group(0) is equivalent to m.group().
*
*
*
If the match was successful but the group specified failed to match
* any part of the input sequence, then null is returned. Note
* that some groups, for example (a*), match the empty string.
* This method will return the empty string when such a group successfully
* matches the empty string in the input.
*
* @param group
* The index of a capturing group in this matcher's pattern
*
* @return The (possibly empty) subsequence captured by the group
* during the previous match, or null if the group
* failed to match part of the input
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @throws IndexOutOfBoundsException
* If there is no capturing group in the pattern
* with the given index
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String group(int group) {
// if (first < 0)
// throw new IllegalStateException("No match found");
// if (group < 0 || group > groupCount())
// throw new IndexOutOfBoundsException("No group " + group);
// if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
// return null;
// return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns the input subsequence captured by the given
* named-capturing group during the previous
* match operation.
*
*
If the match was successful but the group specified failed to match
* any part of the input sequence, then null is returned. Note
* that some groups, for example (a*), match the empty string.
* This method will return the empty string when such a group successfully
* matches the empty string in the input.
*
* @param name
* The name of a named-capturing group in this matcher's pattern
*
* @return The (possibly empty) subsequence captured by the named group
* during the previous match, or null if the group
* failed to match part of the input
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @throws IllegalArgumentException
* If there is no capturing group in the pattern
* with the given name
* @since 1.7
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String group(String name) {
// int group = getMatchedGroupIndex(name);
// if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
// return null;
// return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns the number of capturing groups in this matcher's pattern.
*
*
Group zero denotes the entire pattern by convention. It is not
* included in this count.
*
*
Any non-negative integer smaller than or equal to the value
* returned by this method is guaranteed to be a valid group index for
* this matcher.
*
* @return The number of capturing groups in this matcher's pattern
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int groupCount() {
// return parentPattern.capturingGroupCount - 1;
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Attempts to match the entire region against the pattern.
*
*
If the match succeeds then more information can be obtained via the
* start, end, and group methods.
*
* @return true if, and only if, the entire region sequence
* matches this matcher's pattern
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean matches() {
// return match(from, ENDANCHOR);
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Attempts to find the next subsequence of the input sequence that matches
* the pattern.
*
*
This method starts at the beginning of this matcher's region, or, if
* a previous invocation of the method was successful and the matcher has
* not since been reset, at the first character not matched by the previous
* match.
*
*
If the match succeeds then more information can be obtained via the
* start, end, and group methods.
*
* @return true if, and only if, a subsequence of the input
* sequence matches this matcher's pattern
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean find() {
// int nextSearchIndex = last;
// if (nextSearchIndex == first)
// nextSearchIndex++;
// // If next search starts before region, start it at region
// if (nextSearchIndex < from)
// nextSearchIndex = from;
// // If next search starts beyond region then it fails
// if (nextSearchIndex > to) {
// for (int i = 0; i < groups.length; i++)
// groups[i] = -1;
// return false;
// }
// return search(nextSearchIndex);
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Resets this matcher and then attempts to find the next subsequence of
* the input sequence that matches the pattern, starting at the specified
* index.
*
*
If the match succeeds then more information can be obtained via the
* start, end, and group methods, and subsequent
* invocations of the {@link #find()} method will start at the first
* character not matched by this match.
*
* @param start the index to start searching for a match
* @throws IndexOutOfBoundsException
* If start is less than zero or if start is greater than the
* length of the input sequence.
*
* @return true if, and only if, a subsequence of the input
* sequence starting at the given index matches this matcher's
* pattern
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean find(int start) {
// int limit = getTextLength();
// if ((start < 0) || (start > limit))
// throw new IndexOutOfBoundsException("Illegal start index");
// reset();
// return search(start);
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Attempts to match the input sequence, starting at the beginning of the
* region, against the pattern.
*
*
Like the {@link #matches matches} method, this method always starts
* at the beginning of the region; unlike that method, it does not
* require that the entire region be matched.
*
*
If the match succeeds then more information can be obtained via the
* start, end, and group methods.
*
* @return true if, and only if, a prefix of the input
* sequence matches this matcher's pattern
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean lookingAt() {
// return match(from, NOANCHOR);
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Returns a literal replacement String for the specified
* String.
*
* This method produces a String that will work
* as a literal replacement s in the
* appendReplacement method of the {@link Matcher} class.
* The String produced will match the sequence of characters
* in s treated as a literal sequence. Slashes ('\') and
* dollar signs ('$') will be given no special meaning.
*
* @param s The string to be literalized
* @return A literal string replacement
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public static String quoteReplacement(String s) {
// if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))
// return s;
// StringBuilder sb = new StringBuilder();
// for (int i=0; i This method performs the following actions:
*
*
*
*
It reads characters from the input sequence, starting at the
* append position, and appends them to the given string buffer. It
* stops after reading the last character preceding the previous match,
* that is, the character at index {@link
* #start()} -1.
*
*
It appends the given replacement string to the string buffer.
*
*
*
It sets the append position of this matcher to the index of
* the last character matched, plus one, that is, to {@link #end()}.
*
*
*
*
*
The replacement string may contain references to subsequences
* captured during the previous match: Each occurrence of
* ${name} or $g
* will be replaced by the result of evaluating the corresponding
* {@link #group(String) group(name)} or {@link #group(int) group(g)}
* respectively. For $g,
* the first number after the $ is always treated as part of
* the group reference. Subsequent numbers are incorporated into g if
* they would form a legal group reference. Only the numerals '0'
* through '9' are considered as potential components of the group
* reference. If the second group matched the string "foo", for
* example, then passing the replacement string "$2bar" would
* cause "foobar" to be appended to the string buffer. A dollar
* sign ($) may be included as a literal in the replacement
* string by preceding it with a backslash (\$).
*
*
Note that backslashes (\) and dollar signs ($) in
* the replacement string may cause the results to be different than if it
* were being treated as a literal replacement string. Dollar signs may be
* treated as references to captured subsequences as described above, and
* backslashes are used to escape literal characters in the replacement
* string.
*
*
This method is intended to be used in a loop together with the
* {@link #appendTail appendTail} and {@link #find find} methods. The
* following code, for example, writes one dog two dogs in the
* yard to the standard-output stream:
*
*
* Pattern p = Pattern.compile("cat");
* Matcher m = p.matcher("one cat two cats in the yard");
* StringBuffer sb = new StringBuffer();
* while (m.find()) {
* m.appendReplacement(sb, "dog");
* }
* m.appendTail(sb);
* System.out.println(sb.toString());
*
* @param sb
* The target string buffer
*
* @param replacement
* The replacement string
*
* @return This matcher
*
* @throws IllegalStateException
* If no match has yet been attempted,
* or if the previous match operation failed
*
* @throws IllegalArgumentException
* If the replacement string refers to a named-capturing
* group that does not exist in the pattern
*
* @throws IndexOutOfBoundsException
* If the replacement string refers to a capturing group
* that does not exist in the pattern
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Matcher appendReplacement(StringBuffer sb, String replacement) {
// // If no match, return error
// if (first < 0)
// throw new IllegalStateException("No match available");
// // Process substitution string to replace group references with groups
// int cursor = 0;
// StringBuilder result = new StringBuilder();
// while (cursor < replacement.length()) {
// char nextChar = replacement.charAt(cursor);
// if (nextChar == '\\') {
// cursor++;
// if (cursor == replacement.length())
// throw new IllegalArgumentException(
// "character to be escaped is missing");
// nextChar = replacement.charAt(cursor);
// result.append(nextChar);
// cursor++;
// } else if (nextChar == '$') {
// // Skip past $
// cursor++;
// // Throw IAE if this "$" is the last character in replacement
// if (cursor == replacement.length())
// throw new IllegalArgumentException(
// "Illegal group reference: group index is missing");
// nextChar = replacement.charAt(cursor);
// int refNum = -1;
// if (nextChar == '{') {
// cursor++;
// StringBuilder gsb = new StringBuilder();
// while (cursor < replacement.length()) {
// nextChar = replacement.charAt(cursor);
// if (ASCII.isLower(nextChar) ||
// ASCII.isUpper(nextChar) ||
// ASCII.isDigit(nextChar)) {
// gsb.append(nextChar);
// cursor++;
// } else {
// break;
// }
// }
// if (gsb.length() == 0)
// throw new IllegalArgumentException(
// "named capturing group has 0 length name");
// if (nextChar != '}')
// throw new IllegalArgumentException(
// "named capturing group is missing trailing '}'");
// String gname = gsb.toString();
// if (ASCII.isDigit(gname.charAt(0)))
// throw new IllegalArgumentException(
// "capturing group name {" + gname +
// "} starts with digit character");
// if (!parentPattern.namedGroups().containsKey(gname))
// throw new IllegalArgumentException(
// "No group with name {" + gname + "}");
// refNum = parentPattern.namedGroups().get(gname);
// cursor++;
// } else {
// // The first number is always a group
// refNum = (int)nextChar - '0';
// if ((refNum < 0)||(refNum > 9))
// throw new IllegalArgumentException(
// "Illegal group reference");
// cursor++;
// // Capture the largest legal group string
// boolean done = false;
// while (!done) {
// if (cursor >= replacement.length()) {
// break;
// }
// int nextDigit = replacement.charAt(cursor) - '0';
// if ((nextDigit < 0)||(nextDigit > 9)) { // not a number
// break;
// }
// int newRefNum = (refNum * 10) + nextDigit;
// if (groupCount() < newRefNum) {
// done = true;
// } else {
// refNum = newRefNum;
// cursor++;
// }
// }
// }
// // Append group
// if (start(refNum) != -1 && end(refNum) != -1)
// result.append(text, start(refNum), end(refNum));
// } else {
// result.append(nextChar);
// cursor++;
// }
// }
// // Append the intervening text
// sb.append(text, lastAppendPosition, first);
// // Append the match substitution
// sb.append(result);
// lastAppendPosition = last;
// return this;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Implements a terminal append-and-replace step.
*
*
This method reads characters from the input sequence, starting at
* the append position, and appends them to the given string buffer. It is
* intended to be invoked after one or more invocations of the {@link
* #appendReplacement appendReplacement} method in order to copy the
* remainder of the input sequence.
*
* @param sb
* The target string buffer
*
* @return The target string buffer
*
* @diffblue.untested
* @diffblue.noSupport
*/
public StringBuffer appendTail(StringBuffer sb) {
// sb.append(text, lastAppendPosition, getTextLength());
// return sb;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Replaces every subsequence of the input sequence that matches the
* pattern with the given replacement string.
*
*
This method first resets this matcher. It then scans the input
* sequence looking for matches of the pattern. Characters that are not
* part of any match are appended directly to the result string; each match
* is replaced in the result by the replacement string. The replacement
* string may contain references to captured subsequences as in the {@link
* #appendReplacement appendReplacement} method.
*
*
Note that backslashes (\) and dollar signs ($) in
* the replacement string may cause the results to be different than if it
* were being treated as a literal replacement string. Dollar signs may be
* treated as references to captured subsequences as described above, and
* backslashes are used to escape literal characters in the replacement
* string.
*
*
Given the regular expression a*b, the input
* "aabfooaabfooabfoob", and the replacement string
* "-", an invocation of this method on a matcher for that
* expression would yield the string "-foo-foo-foo-".
*
*
Invoking this method changes this matcher's state. If the matcher
* is to be used in further matching operations then it should first be
* reset.
*
* @param replacement
* The replacement string
*
* @return The string constructed by replacing each matching subsequence
* by the replacement string, substituting captured subsequences
* as needed
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String replaceAll(String replacement) {
// reset();
// boolean result = find();
// if (result) {
// StringBuffer sb = new StringBuffer();
// do {
// appendReplacement(sb, replacement);
// result = find();
// } while (result);
// appendTail(sb);
// return sb.toString();
// }
// return text.toString();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Replaces the first subsequence of the input sequence that matches the
* pattern with the given replacement string.
*
*
This method first resets this matcher. It then scans the input
* sequence looking for a match of the pattern. Characters that are not
* part of the match are appended directly to the result string; the match
* is replaced in the result by the replacement string. The replacement
* string may contain references to captured subsequences as in the {@link
* #appendReplacement appendReplacement} method.
*
*
Note that backslashes (\) and dollar signs ($) in
* the replacement string may cause the results to be different than if it
* were being treated as a literal replacement string. Dollar signs may be
* treated as references to captured subsequences as described above, and
* backslashes are used to escape literal characters in the replacement
* string.
*
*
Given the regular expression dog, the input
* "zzzdogzzzdogzzz", and the replacement string
* "cat", an invocation of this method on a matcher for that
* expression would yield the string "zzzcatzzzdogzzz".
*
*
Invoking this method changes this matcher's state. If the matcher
* is to be used in further matching operations then it should first be
* reset.
*
* @param replacement
* The replacement string
* @return The string constructed by replacing the first matching
* subsequence by the replacement string, substituting captured
* subsequences as needed
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String replaceFirst(String replacement) {
// if (replacement == null)
// throw new NullPointerException("replacement");
// reset();
// if (!find())
// return text.toString();
// StringBuffer sb = new StringBuffer();
// appendReplacement(sb, replacement);
// appendTail(sb);
// return sb.toString();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Sets the limits of this matcher's region. The region is the part of the
* input sequence that will be searched to find a match. Invoking this
* method resets the matcher, and then sets the region to start at the
* index specified by the start parameter and end at the
* index specified by the end parameter.
*
*
Depending on the transparency and anchoring being used (see
* {@link #useTransparentBounds useTransparentBounds} and
* {@link #useAnchoringBounds useAnchoringBounds}), certain constructs such
* as anchors may behave differently at or around the boundaries of the
* region.
*
* @param start
* The index to start searching at (inclusive)
* @param end
* The index to end searching at (exclusive)
* @throws IndexOutOfBoundsException
* If start or end is less than zero, if
* start is greater than the length of the input sequence, if
* end is greater than the length of the input sequence, or if
* start is greater than end.
* @return this matcher
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Matcher region(int start, int end) {
// if ((start < 0) || (start > getTextLength()))
// throw new IndexOutOfBoundsException("start");
// if ((end < 0) || (end > getTextLength()))
// throw new IndexOutOfBoundsException("end");
// if (start > end)
// throw new IndexOutOfBoundsException("start > end");
// reset();
// from = start;
// to = end;
// return this;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Reports the start index of this matcher's region. The
* searches this matcher conducts are limited to finding matches
* within {@link #regionStart regionStart} (inclusive) and
* {@link #regionEnd regionEnd} (exclusive).
*
* @return The starting point of this matcher's region
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int regionStart() {
// return from;
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Reports the end index (exclusive) of this matcher's region.
* The searches this matcher conducts are limited to finding matches
* within {@link #regionStart regionStart} (inclusive) and
* {@link #regionEnd regionEnd} (exclusive).
*
* @return the ending point of this matcher's region
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int regionEnd() {
// return to;
CProver.notModelled();
return CProver.nondetInt();
}
/**
* Queries the transparency of region bounds for this matcher.
*
*
This method returns true if this matcher uses
* transparent bounds, false if it uses opaque
* bounds.
*
*
See {@link #useTransparentBounds useTransparentBounds} for a
* description of transparent and opaque bounds.
*
*
By default, a matcher uses opaque region boundaries.
*
* @return true iff this matcher is using transparent bounds,
* false otherwise.
* @see java.util.regex.Matcher#useTransparentBounds(boolean)
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean hasTransparentBounds() {
// return transparentBounds;
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Sets the transparency of region bounds for this matcher.
*
*
Invoking this method with an argument of true will set this
* matcher to use transparent bounds. If the boolean
* argument is false, then opaque bounds will be used.
*
*
Using transparent bounds, the boundaries of this
* matcher's region are transparent to lookahead, lookbehind,
* and boundary matching constructs. Those constructs can see beyond the
* boundaries of the region to see if a match is appropriate.
*
*
Using opaque bounds, the boundaries of this matcher's
* region are opaque to lookahead, lookbehind, and boundary matching
* constructs that may try to see beyond them. Those constructs cannot
* look past the boundaries so they will fail to match anything outside
* of the region.
*
*
By default, a matcher uses opaque bounds.
*
* @param b a boolean indicating whether to use opaque or transparent
* regions
* @return this matcher
* @see java.util.regex.Matcher#hasTransparentBounds
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Matcher useTransparentBounds(boolean b) {
// transparentBounds = b;
// return this;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Queries the anchoring of region bounds for this matcher.
*
*
This method returns true if this matcher uses
* anchoring bounds, false otherwise.
*
*
See {@link #useAnchoringBounds useAnchoringBounds} for a
* description of anchoring bounds.
*
*
By default, a matcher uses anchoring region boundaries.
*
* @return true iff this matcher is using anchoring bounds,
* false otherwise.
* @see java.util.regex.Matcher#useAnchoringBounds(boolean)
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean hasAnchoringBounds() {
// return anchoringBounds;
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Sets the anchoring of region bounds for this matcher.
*
*
Invoking this method with an argument of true will set this
* matcher to use anchoring bounds. If the boolean
* argument is false, then non-anchoring bounds will be
* used.
*
*
Using anchoring bounds, the boundaries of this
* matcher's region match anchors such as ^ and $.
*
*
Without anchoring bounds, the boundaries of this
* matcher's region will not match anchors such as ^ and $.
*
*
By default, a matcher uses anchoring region boundaries.
*
* @param b a boolean indicating whether or not to use anchoring bounds.
* @return this matcher
* @see java.util.regex.Matcher#hasAnchoringBounds
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Matcher useAnchoringBounds(boolean b) {
// anchoringBounds = b;
// return this;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
*
Returns the string representation of this matcher. The
* string representation of a Matcher contains information
* that may be useful for debugging. The exact format is unspecified.
*
* @return The string representation of this matcher
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String toString() {
// StringBuilder sb = new StringBuilder();
// sb.append("java.util.regex.Matcher");
// sb.append("[pattern=" + pattern());
// sb.append(" region=");
// sb.append(regionStart() + "," + regionEnd());
// sb.append(" lastmatch=");
// if ((first >= 0) && (group() != null)) {
// sb.append(group());
// }
// sb.append("]");
// return sb.toString();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
*
Returns true if the end of input was hit by the search engine in
* the last match operation performed by this matcher.
*
*
When this method returns true, then it is possible that more input
* would have changed the result of the last search.
*
* @return true iff the end of input was hit in the last match; false
* otherwise
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean hitEnd() {
// return hitEnd;
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
*
Returns true if more input could change a positive match into a
* negative one.
*
*
If this method returns true, and a match was found, then more
* input could cause the match to be lost. If this method returns false
* and a match was found, then more input might change the match but the
* match won't be lost. If a match was not found, then requireEnd has no
* meaning.
*
* @return true iff more input could change a positive match into a
* negative one.
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public boolean requireEnd() {
// return requireEnd;
CProver.notModelled();
return CProver.nondetBoolean();
}
/**
* Initiates a search to find a Pattern within the given bounds.
* The groups are filled with default values and the match of the root
* of the state machine is called. The state machine will hold the state
* of the match as it proceeds in this matcher.
*
* Matcher.from is not set here, because it is the "hard" boundary
* of the start of the search which anchors will set to. The from param
* is the "soft" boundary of the start of the search, meaning that the
* regex tries to match at that index but ^ won't match there. Subsequent
* calls to the search methods start at a new "soft" boundary which is
* the end of the previous match.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// boolean search(int from) {
// this.hitEnd = false;
// this.requireEnd = false;
// from = from < 0 ? 0 : from;
// this.first = from;
// this.oldLast = oldLast < 0 ? from : oldLast;
// for (int i = 0; i < groups.length; i++)
// groups[i] = -1;
// acceptMode = NOANCHOR;
// boolean result = parentPattern.root.match(this, from, text);
// if (!result)
// this.first = -1;
// this.oldLast = this.last;
// return result;
// }
/**
* Initiates a search for an anchored match to a Pattern within the given
* bounds. The groups are filled with default values and the match of the
* root of the state machine is called. The state machine will hold the
* state of the match as it proceeds in this matcher.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// boolean match(int from, int anchor) {
// this.hitEnd = false;
// this.requireEnd = false;
// from = from < 0 ? 0 : from;
// this.first = from;
// this.oldLast = oldLast < 0 ? from : oldLast;
// for (int i = 0; i < groups.length; i++)
// groups[i] = -1;
// acceptMode = anchor;
// boolean result = parentPattern.matchRoot.match(this, from, text);
// if (!result)
// this.first = -1;
// this.oldLast = this.last;
// return result;
// }
/**
* Returns the end index of the text.
*
* @return the index after the last character in the text
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// int getTextLength() {
// return text.length();
// }
/**
* Generates a String from this Matcher's input in the specified range.
*
* @param beginIndex the beginning index, inclusive
* @param endIndex the ending index, exclusive
* @return A String generated from this Matcher's input
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// CharSequence getSubSequence(int beginIndex, int endIndex) {
// return text.subSequence(beginIndex, endIndex);
// }
/**
* Returns this Matcher's input character at index i.
*
* @return A char from the specified index
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// char charAt(int i) {
// return text.charAt(i);
// }
/**
* Returns the group index of the matched capturing group.
*
* @return the index of the named-capturing group
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// int getMatchedGroupIndex(String name) {
// Objects.requireNonNull(name, "Group name");
// if (first < 0)
// throw new IllegalStateException("No match found");
// if (!parentPattern.namedGroups().containsKey(name))
// throw new IllegalArgumentException("No group with name <" + name + ">");
// return parentPattern.namedGroups().get(name);
// }
}
java-models-library-master/src/main/java/java/util/regex/Pattern.java 0000664 0000000 0000000 00000733606 14323475213 0026162 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 1999, 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.regex;
import org.cprover.CProver;
import org.cprover.CProverString;
import java.text.Normalizer;
import java.util.Locale;
import java.util.Iterator;
import java.util.Map;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
/**
* A compiled representation of a regular expression.
*
*
A regular expression, specified as a string, must first be compiled into
* an instance of this class. The resulting pattern can then be used to create
* a {@link Matcher} object that can match arbitrary {@linkplain
* java.lang.CharSequence character sequences} against the regular
* expression. All of the state involved in performing a match resides in the
* matcher, so many matchers can share the same pattern.
*
*
A typical invocation sequence is thus
*
*
* Pattern p = Pattern.{@link #compile compile}("a*b");
* Matcher m = p.{@link #matcher matcher}("aaaaab");
* boolean b = m.{@link Matcher#matches matches}();
*
*
A {@link #matches matches} method is defined by this class as a
* convenience for when a regular expression is used just once. This method
* compiles an expression and matches an input sequence against it in a single
* invocation. The statement
*
*
* boolean b = Pattern.matches("a*b", "aaaaab");
*
* is equivalent to the three statements above, though for repeated matches it
* is less efficient since it does not allow the compiled pattern to be reused.
*
*
Instances of this class are immutable and are safe for use by multiple
* concurrent threads. Instances of the {@link Matcher} class are not safe for
* such use.
*
*
*
The character with octal value 0mnn
* (0 <=m<= 3,
* 0 <=n<= 7)
*
\xhh
*
The character with hexadecimal value 0xhh
*
\uhhhh
*
The character with hexadecimal value 0xhhhh
*
\x{h...h}
*
The character with hexadecimal value 0xh...h
* ({@link java.lang.Character#MIN_CODE_POINT Character.MIN_CODE_POINT}
* <= 0xh...h <=
* {@link java.lang.Character#MAX_CODE_POINT Character.MAX_CODE_POINT})
*
\t
*
The tab character ('\u0009')
*
\n
*
The newline (line feed) character ('\u000A')
*
\r
*
The carriage-return character ('\u000D')
*
\f
*
The form-feed character ('\u000C')
*
\a
*
The alert (bell) character ('\u0007')
*
\e
*
The escape character ('\u001B')
*
\cx
*
The control character corresponding to x
*
*
*
Character classes
*
*
{@code [abc]}
*
{@code a}, {@code b}, or {@code c} (simple class)
*
{@code [^abc]}
*
Any character except {@code a}, {@code b}, or {@code c} (negation)
*
{@code [a-zA-Z]}
*
{@code a} through {@code z}
* or {@code A} through {@code Z}, inclusive (range)
*
{@code [a-d[m-p]]}
*
{@code a} through {@code d},
* or {@code m} through {@code p}: {@code [a-dm-p]} (union)
*
{@code [a-z&&[def]]}
*
{@code d}, {@code e}, or {@code f} (intersection)
*
{@code [a-z&&[^bc]]}
*
{@code a} through {@code z},
* except for {@code b} and {@code c}: {@code [ad-z]} (subtraction)
*
{@code [a-z&&[^m-p]]}
*
{@code a} through {@code z},
* and not {@code m} through {@code p}: {@code [a-lq-z]}(subtraction)
The backslash character ('\') serves to introduce escaped
* constructs, as defined in the table above, as well as to quote characters
* that otherwise would be interpreted as unescaped constructs. Thus the
* expression \\ matches a single backslash and \{ matches a
* left brace.
*
*
It is an error to use a backslash prior to any alphabetic character that
* does not denote an escaped construct; these are reserved for future
* extensions to the regular-expression language. A backslash may be used
* prior to a non-alphabetic character regardless of whether that character is
* part of an unescaped construct.
*
*
Backslashes within string literals in Java source code are interpreted
* as required by
* The Java™ Language Specification
* as either Unicode escapes (section 3.3) or other character escapes (section 3.10.6)
* It is therefore necessary to double backslashes in string
* literals that represent regular expressions to protect them from
* interpretation by the Java bytecode compiler. The string literal
* "\b", for example, matches a single backspace character when
* interpreted as a regular expression, while "\\b" matches a
* word boundary. The string literal "\(hello\)" is illegal
* and leads to a compile-time error; in order to match the string
* (hello) the string literal "\\(hello\\)"
* must be used.
*
*
Character classes may appear within other character classes, and
* may be composed by the union operator (implicit) and the intersection
* operator (&&).
* The union operator denotes a class that contains every character that is
* in at least one of its operand classes. The intersection operator
* denotes a class that contains every character that is in both of its
* operand classes.
*
*
The precedence of character-class operators is as follows, from
* highest to lowest:
*
*
*
1
*
Literal escape
*
\x
*
2
*
Grouping
*
[...]
*
3
*
Range
*
a-z
*
4
*
Union
*
[a-e][i-u]
*
5
*
Intersection
*
{@code [a-z&&[aeiou]]}
*
*
*
Note that a different set of metacharacters are in effect inside
* a character class than outside a character class. For instance, the
* regular expression . loses its special meaning inside a
* character class, while the expression - becomes a range
* forming metacharacter.
*
*
A line terminator is a one- or two-character sequence that marks
* the end of a line of the input character sequence. The following are
* recognized as line terminators:
*
*
*
*
A newline (line feed) character ('\n'),
*
*
A carriage-return character followed immediately by a newline
* character ("\r\n"),
*
*
A standalone carriage-return character ('\r'),
*
*
A next-line character ('\u0085'),
*
*
A line-separator character ('\u2028'), or
*
*
A paragraph-separator character ('\u2029).
*
*
*
If {@link #UNIX_LINES} mode is activated, then the only line terminators
* recognized are newline characters.
*
*
The regular expression . matches any character except a line
* terminator unless the {@link #DOTALL} flag is specified.
*
*
By default, the regular expressions ^ and $ ignore
* line terminators and only match at the beginning and the end, respectively,
* of the entire input sequence. If {@link #MULTILINE} mode is activated then
* ^ matches at the beginning of input and after any line terminator
* except at the end of input. When in {@link #MULTILINE} mode $
* matches just before a line terminator or the end of the input sequence.
*
*
Capturing groups are numbered by counting their opening parentheses from
* left to right. In the expression ((A)(B(C))), for example, there
* are four such groups:
*
*
*
1
*
((A)(B(C)))
*
2
*
(A)
*
3
*
(B(C))
*
4
*
(C)
*
*
*
Group zero always stands for the entire expression.
*
*
Capturing groups are so named because, during a match, each subsequence
* of the input sequence that matches such a group is saved. The captured
* subsequence may be used later in the expression, via a back reference, and
* may also be retrieved from the matcher once the match operation is complete.
*
*
A capturing group can also be assigned a "name", a named-capturing group,
* and then be back-referenced later by the "name". Group names are composed of
* the following characters. The first character must be a letter.
*
*
*
The uppercase letters 'A' through 'Z'
* ('\u0041' through '\u005a'),
*
The lowercase letters 'a' through 'z'
* ('\u0061' through '\u007a'),
*
The digits '0' through '9'
* ('\u0030' through '\u0039'),
*
*
*
A named-capturing group is still numbered as described in
* Group number.
*
*
The captured input associated with a group is always the subsequence
* that the group most recently matched. If a group is evaluated a second time
* because of quantification then its previously-captured value, if any, will
* be retained if the second evaluation fails. Matching the string
* "aba" against the expression (a(b)?)+, for example, leaves
* group two set to "b". All captured input is discarded at the
* beginning of each match.
*
*
Groups beginning with (? are either pure, non-capturing groups
* that do not capture text and do not count towards the group total, or
* named-capturing group.
*
*
* Unicode escape sequences such as \u2014 in Java source code
* are processed as described in section 3.3 of
* The Java™ Language Specification.
* Such escape sequences are also implemented directly by the regular-expression
* parser so that Unicode escapes can be used in expressions that are read from
* files or from the keyboard. Thus the strings "\u2014" and
* "\\u2014", while not equal, compile into the same pattern, which
* matches the character with hexadecimal value 0x2014.
*
* A Unicode character can also be represented in a regular-expression by
* using its Hex notation(hexadecimal code point value) directly as described in construct
* \x{...}, for example a supplementary character U+2011F
* can be specified as \x{2011F}, instead of two consecutive
* Unicode escape sequences of the surrogate pair
* \uD840\uDD1F.
*
* Unicode scripts, blocks, categories and binary properties are written with
* the \p and \P constructs as in Perl.
* \p{prop} matches if
* the input has the property prop, while \P{prop}
* does not match if the input has that property.
*
* Scripts, blocks, categories and binary properties can be used both inside
* and outside of a character class.
*
*
* Scripts are specified either with the prefix {@code Is}, as in
* {@code IsHiragana}, or by using the {@code script} keyword (or its short
* form {@code sc})as in {@code script=Hiragana} or {@code sc=Hiragana}.
*
* The script names supported by Pattern are the valid script names
* accepted and defined by
* {@link java.lang.Character.UnicodeScript#forName(String) UnicodeScript.forName}.
*
*
* Blocks are specified with the prefix {@code In}, as in
* {@code InMongolian}, or by using the keyword {@code block} (or its short
* form {@code blk}) as in {@code block=Mongolian} or {@code blk=Mongolian}.
*
* The block names supported by Pattern are the valid block names
* accepted and defined by
* {@link java.lang.Character.UnicodeBlock#forName(String) UnicodeBlock.forName}.
*
*
* Categories may be specified with the optional prefix {@code Is}:
* Both {@code \p{L}} and {@code \p{IsL}} denote the category of Unicode
* letters. Same as scripts and blocks, categories can also be specified
* by using the keyword {@code general_category} (or its short form
* {@code gc}) as in {@code general_category=Lu} or {@code gc=Lu}.
*
* The supported categories are those of
*
* The Unicode Standard in the version specified by the
* {@link java.lang.Character Character} class. The category names are those
* defined in the Standard, both normative and informative.
*
*
* Binary properties are specified with the prefix {@code Is}, as in
* {@code IsAlphabetic}. The supported binary properties by Pattern
* are
*
*
Alphabetic
*
Ideographic
*
Letter
*
Lowercase
*
Uppercase
*
Titlecase
*
Punctuation
*
Control
*
White_Space
*
Digit
*
Hex_Digit
*
Join_Control
*
Noncharacter_Code_Point
*
Assigned
*
*
* The following Predefined Character classes and POSIX character classes
* are in conformance with the recommendation of Annex C: Compatibility Properties
* of Unicode Regular Expression
* , when {@link #UNICODE_CHARACTER_CLASS} flag is specified.
*
*
*
*
Classes
*
Matches
*
*
\p{Lower}
*
A lowercase character:\p{IsLowercase}
*
\p{Upper}
*
An uppercase character:\p{IsUppercase}
*
\p{ASCII}
*
All ASCII:[\x00-\x7F]
*
\p{Alpha}
*
An alphabetic character:\p{IsAlphabetic}
*
\p{Digit}
*
A decimal digit character:p{IsDigit}
*
\p{Alnum}
*
An alphanumeric character:[\p{IsAlphabetic}\p{IsDigit}]
*
\p{Punct}
*
A punctuation character:p{IsPunctuation}
*
\p{Graph}
*
A visible character: [^\p{IsWhite_Space}\p{gc=Cc}\p{gc=Cs}\p{gc=Cn}]
*
\p{Print}
*
A printable character: {@code [\p{Graph}\p{Blank}&&[^\p{Cntrl}]]}
*
\p{Blank}
*
A space or a tab: {@code [\p{IsWhite_Space}&&[^\p{gc=Zl}\p{gc=Zp}\x0a\x0b\x0c\x0d\x85]]}
*
\p{Cntrl}
*
A control character: \p{gc=Cc}
*
\p{XDigit}
*
A hexadecimal digit: [\p{gc=Nd}\p{IsHex_Digit}]
*
\p{Space}
*
A whitespace character:\p{IsWhite_Space}
*
\d
*
A digit: \p{IsDigit}
*
\D
*
A non-digit: [^\d]
*
\s
*
A whitespace character: \p{IsWhite_Space}
*
\S
*
A non-whitespace character: [^\s]
*
\w
*
A word character: [\p{Alpha}\p{gc=Mn}\p{gc=Me}\p{gc=Mc}\p{Digit}\p{gc=Pc}\p{IsJoin_Control}]
The named character construct, \N{name}
* for a Unicode character by its name.
*
*
*
The conditional constructs
* (?(condition)X) and
* (?(condition)X|Y),
*
*
*
The embedded code constructs (?{code})
* and (??{code}),
*
*
The embedded comment syntax (?#comment), and
*
*
The preprocessing operations \l\u,
* \L, and \U.
*
*
*
*
Constructs supported by this class but not by Perl:
*
*
*
*
Character-class union and intersection as described
* above.
*
*
*
*
Notable differences from Perl:
*
*
*
*
In Perl, \1 through \9 are always interpreted
* as back references; a backslash-escaped number greater than 9 is
* treated as a back reference if at least that many subexpressions exist,
* otherwise it is interpreted, if possible, as an octal escape. In this
* class octal escapes must always begin with a zero. In this class,
* \1 through \9 are always interpreted as back
* references, and a larger number is accepted as a back reference if at
* least that many subexpressions exist at that point in the regular
* expression, otherwise the parser will drop digits until the number is
* smaller or equal to the existing number of groups or it is one digit.
*
*
*
Perl uses the g flag to request a match that resumes
* where the last match left off. This functionality is provided implicitly
* by the {@link Matcher} class: Repeated invocations of the {@link
* Matcher#find find} method will resume where the last match left off,
* unless the matcher is reset.
*
*
In Perl, embedded flags at the top level of an expression affect
* the whole expression. In this class, embedded flags always take effect
* at the point at which they appear, whether they are at the top level or
* within a group; in the latter case, flags are restored at the end of the
* group just as in Perl.
*
* @see java.lang.String#split(String, int)
* @see java.lang.String#split(String)
*
* @author Mike McCloskey
* @author Mark Reinhold
* @author JSR-51 Expert Group
* @since 1.4
* @spec JSR-51
*
* @diffblue.untested
* @diffblue.noSupport
* This model was automatically generated by the JDK Processor tool.
*/
public final class Pattern
implements java.io.Serializable
{
/**
* Regular expression modifier values. Instead of being passed as
* arguments, they can also be passed as inline modifiers.
* For example, the following statements have the same effect.
*
*
* The flags are duplicated so that the familiar Perl match flag
* names are available.
*/
/**
* Enables Unix lines mode.
*
*
In this mode, only the '\n' line terminator is recognized
* in the behavior of ., ^, and $.
*
*
Unix lines mode can also be enabled via the embedded flag
* expression (?d).
*/
public static final int UNIX_LINES = 0x01;
/**
* Enables case-insensitive matching.
*
*
By default, case-insensitive matching assumes that only characters
* in the US-ASCII charset are being matched. Unicode-aware
* case-insensitive matching can be enabled by specifying the {@link
* #UNICODE_CASE} flag in conjunction with this flag.
*
*
Case-insensitive matching can also be enabled via the embedded flag
* expression (?i).
*
*
Specifying this flag may impose a slight performance penalty.
*/
public static final int CASE_INSENSITIVE = 0x02;
/**
* Permits whitespace and comments in pattern.
*
*
In this mode, whitespace is ignored, and embedded comments starting
* with # are ignored until the end of a line.
*
*
Comments mode can also be enabled via the embedded flag
* expression (?x).
*/
public static final int COMMENTS = 0x04;
/**
* Enables multiline mode.
*
*
In multiline mode the expressions ^ and $ match
* just after or just before, respectively, a line terminator or the end of
* the input sequence. By default these expressions only match at the
* beginning and the end of the entire input sequence.
*
*
Multiline mode can also be enabled via the embedded flag
* expression (?m).
*/
public static final int MULTILINE = 0x08;
/**
* Enables literal parsing of the pattern.
*
*
When this flag is specified then the input string that specifies
* the pattern is treated as a sequence of literal characters.
* Metacharacters or escape sequences in the input sequence will be
* given no special meaning.
*
*
The flags CASE_INSENSITIVE and UNICODE_CASE retain their impact on
* matching when used in conjunction with this flag. The other flags
* become superfluous.
*
*
There is no embedded flag character for enabling literal parsing.
* @since 1.5
*/
public static final int LITERAL = 0x10;
/**
* Enables dotall mode.
*
*
In dotall mode, the expression . matches any character,
* including a line terminator. By default this expression does not match
* line terminators.
*
*
Dotall mode can also be enabled via the embedded flag
* expression (?s). (The s is a mnemonic for
* "single-line" mode, which is what this is called in Perl.)
*/
public static final int DOTALL = 0x20;
/**
* Enables Unicode-aware case folding.
*
*
When this flag is specified then case-insensitive matching, when
* enabled by the {@link #CASE_INSENSITIVE} flag, is done in a manner
* consistent with the Unicode Standard. By default, case-insensitive
* matching assumes that only characters in the US-ASCII charset are being
* matched.
*
*
Unicode-aware case folding can also be enabled via the embedded flag
* expression (?u).
*
*
Specifying this flag may impose a performance penalty.
*/
public static final int UNICODE_CASE = 0x40;
/**
* Enables canonical equivalence.
*
*
When this flag is specified then two characters will be considered
* to match if, and only if, their full canonical decompositions match.
* The expression "a\u030A", for example, will match the
* string "\u00E5" when this flag is specified. By default,
* matching does not take canonical equivalence into account.
*
*
There is no embedded flag character for enabling canonical
* equivalence.
*
*
Specifying this flag may impose a performance penalty.
*/
public static final int CANON_EQ = 0x80;
/**
* Enables the Unicode version of Predefined character classes and
* POSIX character classes.
*
*
* The UNICODE_CHARACTER_CLASS mode can also be enabled via the embedded
* flag expression (?U).
*
* The flag implies UNICODE_CASE, that is, it enables Unicode-aware case
* folding.
*
* Specifying this flag may impose a performance penalty.
* @since 1.7
*/
public static final int UNICODE_CHARACTER_CLASS = 0x100;
/* Pattern has only two serialized components: The pattern string
* and the flags, which are all that is needed to recompile the pattern
* when it is deserialized.
*/
/** use serialVersionUID from Merlin b59 for interoperability */
// DIFFBLUE MODEL LIBRARY - not used in model
// private static final long serialVersionUID = 5073258162644648461L;
/**
* The original regular-expression pattern string.
*
* @serial
*/
private String pattern;
/**
* The original pattern flags.
*
* @serial
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int flags;
/**
* Boolean indicating this Pattern is compiled; this is necessary in order
* to lazily compile deserialized Patterns.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient volatile boolean compiled = false;
/**
* The normalized pattern string.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient String normalizedPattern;
/**
* The starting point of state machine for the find operation. This allows
* a match to start anywhere in the input.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// transient Node root;
/**
* The root of object tree for a match operation. The pattern is matched
* at the beginning. This may include a find that uses BnM or a First
* node.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// transient Node matchRoot;
/**
* Temporary storage used by parsing pattern slice.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// transient int[] buffer;
/**
* Map the "name" of the "named capturing group" to its group id
* node.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// transient volatile Map namedGroups;
/**
* Temporary storage used while parsing group references.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// transient GroupHead[] groupNodes;
/**
* Temporary null terminated code point array used by pattern compiling.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient int[] temp;
/**
* The number of capturing groups in this Pattern. Used by matchers to
* allocate storage needed to perform a match.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// transient int capturingGroupCount;
/**
* The local variable count used by parsing tree. Used by matchers to
* allocate storage needed to perform a match.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// transient int localCount;
/**
* Index into the pattern string that keeps track of how much has been
* parsed.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient int cursor;
/**
* Holds the length of the pattern string.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient int patternLength;
/**
* If the Start node might possibly match supplementary characters.
* It is set to true during compiling if
* (1) There is supplementary char in pattern, or
* (2) There is complement node of Category or Block
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private transient boolean hasSupplementary;
/**
* Compiles the given regular expression into a pattern.
*
* @param regex
* The expression to be compiled
* @return the given regular expression compiled into a pattern
* @throws PatternSyntaxException
* If the expression's syntax is invalid
*
* @diffblue.limitedSupport
* PatternSyntaxException is not thrown by the model, we only assume that
* the first character is not a '?' character. This should be sufficient
* for most cases, as `compile` is often used with String constants.
*/
public static Pattern compile(String regex) {
return new Pattern(regex, 0);
}
/**
* Compiles the given regular expression into a pattern with the given
* flags.
*
* @param regex
* The expression to be compiled
*
* @param flags
* Match flags, a bit mask that may include
* {@link #CASE_INSENSITIVE}, {@link #MULTILINE}, {@link #DOTALL},
* {@link #UNICODE_CASE}, {@link #CANON_EQ}, {@link #UNIX_LINES},
* {@link #LITERAL}, {@link #UNICODE_CHARACTER_CLASS}
* and {@link #COMMENTS}
*
* @return the given regular expression compiled into a pattern with the given flags
* @throws IllegalArgumentException
* If bit values other than those corresponding to the defined
* match flags are set in flags
*
* @throws PatternSyntaxException
* If the expression's syntax is invalid
*
* @diffblue.untested
* @diffblue.limitedSupport
* Argument `flags` is ignored.
* PatternSyntaxException is not thrown by the model, we only assume that
* the first character is not a '?' character. This should be sufficient
* for most cases, as `compile` is often used with String constants.
*/
public static Pattern compile(String regex, int flags) {
return new Pattern(regex, flags);
}
/**
* Returns the regular expression from which this pattern was compiled.
*
* @return The source of this pattern
*
* @diffblue.fullSupport
*/
public String pattern() {
return pattern;
}
/**
*
Returns the string representation of this pattern. This
* is the regular expression from which this pattern was
* compiled.
*
* @return The string representation of this pattern
* @since 1.5
*
* @diffblue.fullSupport
*/
public String toString() {
return pattern;
}
/**
* Creates a matcher that will match the given input against this pattern.
*
* @param input
* The character sequence to be matched
*
* @return A new matcher for this pattern
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Matcher matcher(CharSequence input) {
// if (!compiled) {
// synchronized(this) {
// if (!compiled)
// compile();
// }
// }
// Matcher m = new Matcher(this, input);
// return m;
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns this pattern's match flags.
*
* @return The match flags specified when this pattern was compiled
*
* @diffblue.untested
* @diffblue.noSupport
*/
public int flags() {
// return flags;
return CProver.nondetInt();
}
/**
* DIFFBLUE MODEL LIBRARY
* This method enforces an assumption that its argument contains
* no characters that has special meaning in regular expressions.
* This way we can then match the regex using String.equals().
*/
private static void cproverAssumeIsPlainString(String regex)
{
CProver.assume(
regex.indexOf('[') == -1 &&
regex.indexOf(']') == -1 &&
regex.indexOf('{') == -1 &&
regex.indexOf('}') == -1 &&
regex.indexOf('(') == -1 &&
regex.indexOf(')') == -1 &&
regex.indexOf('?') == -1 &&
regex.indexOf('.') == -1 &&
regex.indexOf('+') == -1 &&
regex.indexOf('\\') == -1 &&
regex.indexOf('*') == -1 &&
regex.indexOf('^') == -1 &&
regex.indexOf('$') == -1 &&
regex.indexOf('|') == -1);
}
/**
* Compiles the given regular expression and attempts to match the given
* input against it.
*
*
An invocation of this convenience method of the form
*
*
* Pattern.matches(regex, input);
*
* behaves in exactly the same way as the expression
*
*
* Pattern.compile(regex).matcher(input).matches()
*
*
If a pattern is to be used multiple times, compiling it once and reusing
* it will be more efficient than invoking this method each time.
*
* @param regex
* The expression to be compiled
*
* @param input
* The character sequence to be matched
* @return whether or not the regular expression matches on the input
* @throws PatternSyntaxException
* If the expression's syntax is invalid
*
* @diffblue.untested
* @diffblue.limitedSupport Regex can only be a plain string.
*/
public static boolean matches(String regex, CharSequence input) {
// Pattern p = Pattern.compile(regex);
// Matcher m = p.matcher(input);
// return m.matches();
// DIFFBLUE MODEL LIBRARY
// We disallow special characters so that we can do matching using equals.
cproverAssumeIsPlainString(regex);
//
if (input == null) {
throw new NullPointerException(); // JDK throws NPE when the 2nd param is null
}
return regex.equals(input);
}
/**
* Splits the given input sequence around matches of this pattern.
*
*
The array returned by this method contains each substring of the
* input sequence that is terminated by another subsequence that matches
* this pattern or is terminated by the end of the input sequence. The
* substrings in the array are in the order in which they occur in the
* input. If this pattern does not match any subsequence of the input then
* the resulting array has just one element, namely the input sequence in
* string form.
*
*
When there is a positive-width match at the beginning of the input
* sequence then an empty leading substring is included at the beginning
* of the resulting array. A zero-width match at the beginning however
* never produces such empty leading substring.
*
*
The limit parameter controls the number of times the
* pattern is applied and therefore affects the length of the resulting
* array. If the limit n is greater than zero then the pattern
* will be applied at most n - 1 times, the array's
* length will be no greater than n, and the array's last entry
* will contain all input beyond the last matched delimiter. If n
* is non-positive then the pattern will be applied as many times as
* possible and the array can have any length. If n is zero then
* the pattern will be applied as many times as possible, the array can
* have any length, and trailing empty strings will be discarded.
*
*
The input "boo:and:foo", for example, yields the following
* results with these parameters:
*
*
*
Regex
*
Limit
*
Result
*
:
*
2
*
{ "boo", "and:foo" }
*
:
*
5
*
{ "boo", "and", "foo" }
*
:
*
-2
*
{ "boo", "and", "foo" }
*
o
*
5
*
{ "b", "", ":and:f", "", "" }
*
o
*
-2
*
{ "b", "", ":and:f", "", "" }
*
o
*
0
*
{ "b", "", ":and:f" }
*
*
* @param input
* The character sequence to be split
*
* @param limit
* The result threshold, as described above
*
* @return The array of strings computed by splitting the input
* around matches of this pattern
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String[] split(CharSequence input, int limit) {
// int index = 0;
// boolean matchLimited = limit > 0;
// ArrayList matchList = new ArrayList<>();
// Matcher m = matcher(input);
// // Add segments before each match found
// while(m.find()) {
// if (!matchLimited || matchList.size() < limit - 1) {
// if (index == 0 && index == m.start() && m.start() == m.end()) {
// // no empty leading substring included for zero-width match
// // at the beginning of the input char sequence.
// continue;
// }
// String match = input.subSequence(index, m.start()).toString();
// matchList.add(match);
// index = m.end();
// } else if (matchList.size() == limit - 1) { // last one
// String match = input.subSequence(index,
// input.length()).toString();
// matchList.add(match);
// index = m.end();
// }
// }
// // If no match was found, return this
// if (index == 0)
// return new String[] {input.toString()};
// // Add remaining segment
// if (!matchLimited || matchList.size() < limit)
// matchList.add(input.subSequence(index, input.length()).toString());
// // Construct result
// int resultSize = matchList.size();
// if (limit == 0)
// while (resultSize > 0 && matchList.get(resultSize-1).equals(""))
// resultSize--;
// String[] result = new String[resultSize];
// return matchList.subList(0, resultSize).toArray(result);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Splits the given input sequence around matches of this pattern.
*
*
This method works as if by invoking the two-argument {@link
* #split(java.lang.CharSequence, int) split} method with the given input
* sequence and a limit argument of zero. Trailing empty strings are
* therefore not included in the resulting array.
*
*
The input "boo:and:foo", for example, yields the following
* results with these expressions:
*
*
*
Regex
*
Result
*
:
*
{ "boo", "and", "foo" }
*
o
*
{ "b", "", ":and:f" }
*
*
*
* @param input
* The character sequence to be split
*
* @return The array of strings computed by splitting the input
* around matches of this pattern
*
* @diffblue.untested
* @diffblue.noSupport
*/
public String[] split(CharSequence input) {
// return split(input, 0);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Returns a literal pattern String for the specified
* String.
*
*
This method produces a String that can be used to
* create a Pattern that would match the string
* s as if it were a literal pattern.
Metacharacters
* or escape sequences in the input sequence will be given no special
* meaning.
*
* @param s The string to be literalized
* @return A literal string replacement
* @since 1.5
*
* @diffblue.untested
* @diffblue.noSupport
*/
public static String quote(String s) {
// int slashEIndex = s.indexOf("\\E");
// if (slashEIndex == -1)
// return "\\Q" + s + "\\E";
// StringBuilder sb = new StringBuilder(s.length() * 2);
// sb.append("\\Q");
// slashEIndex = 0;
// int current = 0;
// while ((slashEIndex = s.indexOf("\\E", current)) != -1) {
// sb.append(s.substring(current, slashEIndex));
// current = slashEIndex + 2;
// sb.append("\\E\\\\E\\Q");
// }
// sb.append(s.substring(current, s.length()));
// sb.append("\\E");
// return sb.toString();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Recompile the Pattern instance from a stream. The original pattern
* string is read in and the object tree is recompiled from it.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private void readObject(java.io.ObjectInputStream s)
// throws java.io.IOException, ClassNotFoundException {
// // Read in all fields
// s.defaultReadObject();
// // Initialize counts
// capturingGroupCount = 1;
// localCount = 0;
// // if length > 0, the Pattern is lazily compiled
// compiled = false;
// if (pattern.length() == 0) {
// root = new Start(lastAccept);
// matchRoot = lastAccept;
// compiled = true;
// }
// }
/**
* This private constructor is used to create all Patterns. The pattern
* string and match flags are all that is needed to completely describe
* a Pattern. An empty pattern string results in an object tree with
* only a Start node and a LastNode node.
*/
// DIFFBLUE MODEL LIBRARY - argument `f` is ignored for now but kept
// to stay closer to the original implementation
private Pattern(String p, int f) {
// DIFFBLUE MODEL LIBRARY
// We disallow special characters so that we can use equals for matching.
cproverAssumeIsPlainString(p);
pattern = p;
// pattern = p;
// flags = f;
// // to use UNICODE_CASE if UNICODE_CHARACTER_CLASS present
// if ((flags & UNICODE_CHARACTER_CLASS) != 0)
// flags |= UNICODE_CASE;
// // Reset group index count
// capturingGroupCount = 1;
// localCount = 0;
// if (pattern.length() > 0) {
// compile();
// } else {
// root = new Start(lastAccept);
// matchRoot = lastAccept;
// }
}
/**
* The pattern is converted to normalizedD form and then a pure group
* is constructed to match canonical equivalences of the characters.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private void normalize() {
// boolean inCharClass = false;
// int lastCodePoint = -1;
// // Convert pattern into normalizedD form
// normalizedPattern = Normalizer.normalize(pattern, Normalizer.Form.NFD);
// patternLength = normalizedPattern.length();
// // Modify pattern to match canonical equivalences
// StringBuilder newPattern = new StringBuilder(patternLength);
// for(int i=0; i= patternLength)
// break;
// c = normalizedPattern.codePointAt(i);
// sequenceBuffer.appendCodePoint(c);
// }
// String ea = produceEquivalentAlternation(
// sequenceBuffer.toString());
// newPattern.setLength(newPattern.length()-Character.charCount(lastCodePoint));
// newPattern.append("(?:").append(ea).append(")");
// } else if (c == '[' && lastCodePoint != '\\') {
// i = normalizeCharClass(newPattern, i);
// } else {
// newPattern.appendCodePoint(c);
// }
// lastCodePoint = c;
// i += Character.charCount(c);
// }
// normalizedPattern = newPattern.toString();
// }
/**
* Complete the character class being parsed and add a set
* of alternations to it that will match the canonical equivalences
* of the characters within the class.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int normalizeCharClass(StringBuilder newPattern, int i) {
// StringBuilder charClass = new StringBuilder();
// StringBuilder eq = null;
// int lastCodePoint = -1;
// String result;
// i++;
// charClass.append("[");
// while(true) {
// int c = normalizedPattern.codePointAt(i);
// StringBuilder sequenceBuffer;
// if (c == ']' && lastCodePoint != '\\') {
// charClass.append((char)c);
// break;
// } else if (Character.getType(c) == Character.NON_SPACING_MARK) {
// sequenceBuffer = new StringBuilder();
// sequenceBuffer.appendCodePoint(lastCodePoint);
// while(Character.getType(c) == Character.NON_SPACING_MARK) {
// sequenceBuffer.appendCodePoint(c);
// i += Character.charCount(c);
// if (i >= normalizedPattern.length())
// break;
// c = normalizedPattern.codePointAt(i);
// }
// String ea = produceEquivalentAlternation(
// sequenceBuffer.toString());
// charClass.setLength(charClass.length()-Character.charCount(lastCodePoint));
// if (eq == null)
// eq = new StringBuilder();
// eq.append('|');
// eq.append(ea);
// } else {
// charClass.appendCodePoint(c);
// i++;
// }
// if (i == normalizedPattern.length())
// throw error("Unclosed character class");
// lastCodePoint = c;
// }
// if (eq != null) {
// result = "(?:"+charClass.toString()+eq.toString()+")";
// } else {
// result = charClass.toString();
// }
// newPattern.append(result);
// return i;
// }
/**
* Given a specific sequence composed of a regular character and
* combining marks that follow it, produce the alternation that will
* match all canonical equivalences of that sequence.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private String produceEquivalentAlternation(String source) {
// int len = countChars(source, 0, 1);
// if (source.length() == len)
// // source has one character.
// return source;
// String base = source.substring(0,len);
// String combiningMarks = source.substring(len);
// String[] perms = producePermutations(combiningMarks);
// StringBuilder result = new StringBuilder(source);
// // Add combined permutations
// for(int x=0; x0)
// result.append("|"+next);
// next = composeOneStep(next);
// if (next != null)
// result.append("|"+produceEquivalentAlternation(next));
// }
// return result.toString();
// }
/**
* Returns an array of strings that have all the possible
* permutations of the characters in the input string.
* This is used to get a list of all possible orderings
* of a set of combining marks. Note that some of the permutations
* are invalid because of combining class collisions, and these
* possibilities must be removed because they are not canonically
* equivalent.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private String[] producePermutations(String input) {
// if (input.length() == countChars(input, 0, 1))
// return new String[] {input};
// if (input.length() == countChars(input, 0, 2)) {
// int c0 = Character.codePointAt(input, 0);
// int c1 = Character.codePointAt(input, Character.charCount(c0));
// if (getClass(c1) == getClass(c0)) {
// return new String[] {input};
// }
// String[] result = new String[2];
// result[0] = input;
// StringBuilder sb = new StringBuilder(2);
// sb.appendCodePoint(c1);
// sb.appendCodePoint(c0);
// result[1] = sb.toString();
// return result;
// }
// int length = 1;
// int nCodePoints = countCodePoints(input);
// for(int x=1; x=0; y--) {
// if (combClass[y] == combClass[x]) {
// continue loop;
// }
// }
// StringBuilder sb = new StringBuilder(input);
// String otherChars = sb.delete(offset, offset+len).toString();
// String[] subResult = producePermutations(otherChars);
// String prefix = input.substring(offset, offset+len);
// for(int y=0; y= pLen - 1) // No \Q sequence found
// return;
// int j = i;
// i += 2;
// int[] newtemp = new int[j + 3*(pLen-i) + 2];
// System.arraycopy(temp, 0, newtemp, 0, j);
// boolean inQuote = true;
// boolean beginQuote = true;
// while (i < pLen) {
// int c = temp[i++];
// if (!ASCII.isAscii(c) || ASCII.isAlpha(c)) {
// newtemp[j++] = c;
// } else if (ASCII.isDigit(c)) {
// if (beginQuote) {
// /*
// * A unicode escape \[0xu] could be before this quote,
// * and we don't want this numeric char to processed as
// * part of the escape.
// */
// newtemp[j++] = '\\';
// newtemp[j++] = 'x';
// newtemp[j++] = '3';
// }
// newtemp[j++] = c;
// } else if (c != '\\') {
// if (inQuote) newtemp[j++] = '\\';
// newtemp[j++] = c;
// } else if (inQuote) {
// if (temp[i] == 'E') {
// i++;
// inQuote = false;
// } else {
// newtemp[j++] = '\\';
// newtemp[j++] = '\\';
// }
// } else {
// if (temp[i] == 'Q') {
// i++;
// inQuote = true;
// beginQuote = true;
// continue;
// } else {
// newtemp[j++] = c;
// if (i != pLen)
// newtemp[j++] = temp[i++];
// }
// }
// beginQuote = false;
// }
// patternLength = j;
// temp = Arrays.copyOf(newtemp, j + 2); // double zero termination
// }
/**
* Copies regular expression to an int array and invokes the parsing
* of the expression which will create the object tree.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private void compile() {
// // Handle canonical equivalences
// if (has(CANON_EQ) && !has(LITERAL)) {
// normalize();
// } else {
// normalizedPattern = pattern;
// }
// patternLength = normalizedPattern.length();
// // Copy pattern to int array for convenience
// // Use double zero to terminate pattern
// temp = new int[patternLength + 2];
// hasSupplementary = false;
// int c, count = 0;
// // Convert all chars into code points
// for (int x = 0; x < patternLength; x += Character.charCount(c)) {
// c = normalizedPattern.codePointAt(x);
// if (isSupplementary(c)) {
// hasSupplementary = true;
// }
// temp[count++] = c;
// }
// patternLength = count; // patternLength now in code points
// if (! has(LITERAL))
// RemoveQEQuoting();
// // Allocate all temporary objects here.
// buffer = new int[32];
// groupNodes = new GroupHead[10];
// namedGroups = null;
// if (has(LITERAL)) {
// // Literal pattern handling
// matchRoot = newSlice(temp, patternLength, hasSupplementary);
// matchRoot.next = lastAccept;
// } else {
// // Start recursive descent parsing
// matchRoot = expr(lastAccept);
// // Check extra pattern characters
// if (patternLength != cursor) {
// if (peek() == ')') {
// throw error("Unmatched closing ')'");
// } else {
// throw error("Unexpected internal error");
// }
// }
// }
// // Peephole optimization
// if (matchRoot instanceof Slice) {
// root = BnM.optimize(matchRoot);
// if (root == matchRoot) {
// root = hasSupplementary ? new StartS(matchRoot) : new Start(matchRoot);
// }
// } else if (matchRoot instanceof Begin || matchRoot instanceof First) {
// root = matchRoot;
// } else {
// root = hasSupplementary ? new StartS(matchRoot) : new Start(matchRoot);
// }
// // Release temporary storage
// temp = null;
// buffer = null;
// groupNodes = null;
// patternLength = 0;
// compiled = true;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// Map namedGroups() {
// if (namedGroups == null)
// namedGroups = new HashMap<>(2);
// return namedGroups;
// }
/**
* Used to print out a subtree of the Pattern to help with debugging.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static void printObjectTree(Node node) {
// while(node != null) {
// if (node instanceof Prolog) {
// System.out.println(node);
// printObjectTree(((Prolog)node).loop);
// System.out.println("**** end contents prolog loop");
// } else if (node instanceof Loop) {
// System.out.println(node);
// printObjectTree(((Loop)node).body);
// System.out.println("**** end contents Loop body");
// } else if (node instanceof Curly) {
// System.out.println(node);
// printObjectTree(((Curly)node).atom);
// System.out.println("**** end contents Curly body");
// } else if (node instanceof GroupCurly) {
// System.out.println(node);
// printObjectTree(((GroupCurly)node).atom);
// System.out.println("**** end contents GroupCurly body");
// } else if (node instanceof GroupTail) {
// System.out.println(node);
// System.out.println("Tail next is "+node.next);
// return;
// } else {
// System.out.println(node);
// }
// node = node.next;
// if (node != null)
// System.out.println("->next:");
// if (node == Pattern.accept) {
// System.out.println("Accept Node");
// node = null;
// }
// }
// }
/**
* Used to accumulate information about a subtree of the object graph
* so that optimizations can be applied to the subtree.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class TreeInfo {
// int minLength;
// int maxLength;
// boolean maxValid;
// boolean deterministic;
// TreeInfo() {
// reset();
// }
// void reset() {
// minLength = 0;
// maxLength = 0;
// maxValid = true;
// deterministic = true;
// }
// }
/*
* The following private methods are mainly used to improve the
* readability of the code. In order to let the Java compiler easily
* inline them, we should not put many assertions or error checks in them.
*/
/**
* Indicates whether a particular flag is set or not.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private boolean has(int f) {
// return (flags & f) != 0;
// }
/**
* Match next character, signal error if failed.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private void accept(int ch, String s) {
// int testChar = temp[cursor++];
// if (has(COMMENTS))
// testChar = parsePastWhitespace(testChar);
// if (ch != testChar) {
// throw error(s);
// }
// }
/**
* Mark the end of pattern with a specific character.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private void mark(int c) {
// temp[patternLength] = c;
// }
/**
* Peek the next character, and do not advance the cursor.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int peek() {
// int ch = temp[cursor];
// if (has(COMMENTS))
// ch = peekPastWhitespace(ch);
// return ch;
// }
/**
* Read the next character, and advance the cursor by one.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int read() {
// int ch = temp[cursor++];
// if (has(COMMENTS))
// ch = parsePastWhitespace(ch);
// return ch;
// }
/**
* Read the next character, and advance the cursor by one,
* ignoring the COMMENTS setting
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int readEscaped() {
// int ch = temp[cursor++];
// return ch;
// }
/**
* Advance the cursor by one, and peek the next character.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int next() {
// int ch = temp[++cursor];
// if (has(COMMENTS))
// ch = peekPastWhitespace(ch);
// return ch;
// }
/**
* Advance the cursor by one, and peek the next character,
* ignoring the COMMENTS setting
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int nextEscaped() {
// int ch = temp[++cursor];
// return ch;
// }
/**
* If in xmode peek past whitespace and comments.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int peekPastWhitespace(int ch) {
// while (ASCII.isSpace(ch) || ch == '#') {
// while (ASCII.isSpace(ch))
// ch = temp[++cursor];
// if (ch == '#') {
// ch = peekPastLine();
// }
// }
// return ch;
// }
/**
* If in xmode parse past whitespace and comments.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int parsePastWhitespace(int ch) {
// while (ASCII.isSpace(ch) || ch == '#') {
// while (ASCII.isSpace(ch))
// ch = temp[cursor++];
// if (ch == '#')
// ch = parsePastLine();
// }
// return ch;
// }
/**
* xmode parse past comment to end of line.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int parsePastLine() {
// int ch = temp[cursor++];
// while (ch != 0 && !isLineSeparator(ch))
// ch = temp[cursor++];
// return ch;
// }
/**
* xmode peek past comment to end of line.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int peekPastLine() {
// int ch = temp[++cursor];
// while (ch != 0 && !isLineSeparator(ch))
// ch = temp[++cursor];
// return ch;
// }
/**
* Determines if character is a line separator in the current mode
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private boolean isLineSeparator(int ch) {
// if (has(UNIX_LINES)) {
// return ch == '\n';
// } else {
// return (ch == '\n' ||
// ch == '\r' ||
// (ch|1) == '\u2029' ||
// ch == '\u0085');
// }
// }
/**
* Read the character after the next one, and advance the cursor by two.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int skip() {
// int i = cursor;
// int ch = temp[i+1];
// cursor = i + 2;
// return ch;
// }
/**
* Unread one next character, and retreat cursor by one.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private void unread() {
// cursor--;
// }
/**
* Internal method used for handling all syntax errors. The pattern is
* displayed with a pointer to aid in locating the syntax error.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private PatternSyntaxException error(String s) {
// return new PatternSyntaxException(s, normalizedPattern, cursor - 1);
// }
/**
* Determines if there is any supplementary character or unpaired
* surrogate in the specified range.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private boolean findSupplementary(int start, int end) {
// for (int i = start; i < end; i++) {
// if (isSupplementary(temp[i]))
// return true;
// }
// return false;
// }
/**
* Determines if the specified code point is a supplementary
* character or unpaired surrogate.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static final boolean isSupplementary(int ch) {
// return ch >= Character.MIN_SUPPLEMENTARY_CODE_POINT ||
// Character.isSurrogate((char)ch);
// }
/**
* The following methods handle the main parsing. They are sorted
* according to their precedence order, the lowest one first.
*/
/**
* The expression is parsed with branch nodes added for alternations.
* This may be called recursively to parse sub expressions that may
* contain alternations.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private Node expr(Node end) {
// Node prev = null;
// Node firstTail = null;
// Branch branch = null;
// Node branchConn = null;
// for (;;) {
// Node node = sequence(end);
// Node nodeTail = root; //double return
// if (prev == null) {
// prev = node;
// firstTail = nodeTail;
// } else {
// // Branch
// if (branchConn == null) {
// branchConn = new BranchConn();
// branchConn.next = end;
// }
// if (node == end) {
// // if the node returned from sequence() is "end"
// // we have an empty expr, set a null atom into
// // the branch to indicate to go "next" directly.
// node = null;
// } else {
// // the "tail.next" of each atom goes to branchConn
// nodeTail.next = branchConn;
// }
// if (prev == branch) {
// branch.add(node);
// } else {
// if (prev == end) {
// prev = null;
// } else {
// // replace the "end" with "branchConn" at its tail.next
// // when put the "prev" into the branch as the first atom.
// firstTail.next = branchConn;
// }
// prev = branch = new Branch(prev, node, branchConn);
// }
// }
// if (peek() != '|') {
// return prev;
// }
// next();
// }
// }
/**
* Parsing of sequences between alternations.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// @SuppressWarnings("fallthrough")
// private Node sequence(Node end) {
// Node head = null;
// Node tail = null;
// Node node = null;
// LOOP:
// for (;;) {
// int ch = peek();
// switch (ch) {
// case '(':
// // Because group handles its own closure,
// // we need to treat it differently
// node = group0();
// // Check for comment or flag group
// if (node == null)
// continue;
// if (head == null)
// head = node;
// else
// tail.next = node;
// // Double return: Tail was returned in root
// tail = root;
// continue;
// case '[':
// node = clazz(true);
// break;
// case '\\':
// ch = nextEscaped();
// if (ch == 'p' || ch == 'P') {
// boolean oneLetter = true;
// boolean comp = (ch == 'P');
// ch = next(); // Consume { if present
// if (ch != '{') {
// unread();
// } else {
// oneLetter = false;
// }
// node = family(oneLetter, comp);
// } else {
// unread();
// node = atom();
// }
// break;
// case '^':
// next();
// if (has(MULTILINE)) {
// if (has(UNIX_LINES))
// node = new UnixCaret();
// else
// node = new Caret();
// } else {
// node = new Begin();
// }
// break;
// case '$':
// next();
// if (has(UNIX_LINES))
// node = new UnixDollar(has(MULTILINE));
// else
// node = new Dollar(has(MULTILINE));
// break;
// case '.':
// next();
// if (has(DOTALL)) {
// node = new All();
// } else {
// if (has(UNIX_LINES))
// node = new UnixDot();
// else {
// node = new Dot();
// }
// }
// break;
// case '|':
// case ')':
// break LOOP;
// case ']': // Now interpreting dangling ] and } as literals
// case '}':
// node = atom();
// break;
// case '?':
// case '*':
// case '+':
// next();
// throw error("Dangling meta character '" + ((char)ch) + "'");
// case 0:
// if (cursor >= patternLength) {
// break LOOP;
// }
// // Fall through
// default:
// node = atom();
// break;
// }
// node = closure(node);
// if (head == null) {
// head = tail = node;
// } else {
// tail.next = node;
// tail = node;
// }
// }
// if (head == null) {
// return end;
// }
// tail.next = end;
// root = tail; //double return
// return head;
// }
/**
* Parse and add a new Single or Slice.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// @SuppressWarnings("fallthrough")
// private Node atom() {
// int first = 0;
// int prev = -1;
// boolean hasSupplementary = false;
// int ch = peek();
// for (;;) {
// switch (ch) {
// case '*':
// case '+':
// case '?':
// case '{':
// if (first > 1) {
// cursor = prev; // Unwind one character
// first--;
// }
// break;
// case '$':
// case '.':
// case '^':
// case '(':
// case '[':
// case '|':
// case ')':
// break;
// case '\\':
// ch = nextEscaped();
// if (ch == 'p' || ch == 'P') { // Property
// if (first > 0) { // Slice is waiting; handle it first
// unread();
// break;
// } else { // No slice; just return the family node
// boolean comp = (ch == 'P');
// boolean oneLetter = true;
// ch = next(); // Consume { if present
// if (ch != '{')
// unread();
// else
// oneLetter = false;
// return family(oneLetter, comp);
// }
// }
// unread();
// prev = cursor;
// ch = escape(false, first == 0, false);
// if (ch >= 0) {
// append(ch, first);
// first++;
// if (isSupplementary(ch)) {
// hasSupplementary = true;
// }
// ch = peek();
// continue;
// } else if (first == 0) {
// return root;
// }
// // Unwind meta escape sequence
// cursor = prev;
// break;
// case 0:
// if (cursor >= patternLength) {
// break;
// }
// // Fall through
// default:
// prev = cursor;
// append(ch, first);
// first++;
// if (isSupplementary(ch)) {
// hasSupplementary = true;
// }
// ch = next();
// continue;
// }
// break;
// }
// if (first == 1) {
// return newSingle(buffer[0]);
// } else {
// return newSlice(buffer, first, hasSupplementary);
// }
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private void append(int ch, int len) {
// if (len >= buffer.length) {
// int[] tmp = new int[len+len];
// System.arraycopy(buffer, 0, tmp, 0, len);
// buffer = tmp;
// }
// buffer[len] = ch;
// }
/**
* Parses a backref greedily, taking as many numbers as it
* can. The first digit is always treated as a backref, but
* multi digit numbers are only treated as a backref if at
* least that many backrefs exist at this point in the regex.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private Node ref(int refNum) {
// boolean done = false;
// while(!done) {
// int ch = peek();
// switch(ch) {
// case '0':
// case '1':
// case '2':
// case '3':
// case '4':
// case '5':
// case '6':
// case '7':
// case '8':
// case '9':
// int newRefNum = (refNum * 10) + (ch - '0');
// // Add another number if it doesn't make a group
// // that doesn't exist
// if (capturingGroupCount - 1 < newRefNum) {
// done = true;
// break;
// }
// refNum = newRefNum;
// read();
// break;
// default:
// done = true;
// break;
// }
// }
// if (has(CASE_INSENSITIVE))
// return new CIBackRef(refNum, has(UNICODE_CASE));
// else
// return new BackRef(refNum);
// }
/**
* Parses an escape sequence to determine the actual value that needs
* to be matched.
* If -1 is returned and create was true a new object was added to the tree
* to handle the escape sequence.
* If the returned value is greater than zero, it is the value that
* matches the escape sequence.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int escape(boolean inclass, boolean create, boolean isrange) {
// int ch = skip();
// switch (ch) {
// case '0':
// return o();
// case '1':
// case '2':
// case '3':
// case '4':
// case '5':
// case '6':
// case '7':
// case '8':
// case '9':
// if (inclass) break;
// if (create) {
// root = ref((ch - '0'));
// }
// return -1;
// case 'A':
// if (inclass) break;
// if (create) root = new Begin();
// return -1;
// case 'B':
// if (inclass) break;
// if (create) root = new Bound(Bound.NONE, has(UNICODE_CHARACTER_CLASS));
// return -1;
// case 'C':
// break;
// case 'D':
// if (create) root = has(UNICODE_CHARACTER_CLASS)
// ? new Utype(UnicodeProp.DIGIT).complement()
// : new Ctype(ASCII.DIGIT).complement();
// return -1;
// case 'E':
// case 'F':
// break;
// case 'G':
// if (inclass) break;
// if (create) root = new LastMatch();
// return -1;
// case 'H':
// if (create) root = new HorizWS().complement();
// return -1;
// case 'I':
// case 'J':
// case 'K':
// case 'L':
// case 'M':
// case 'N':
// case 'O':
// case 'P':
// case 'Q':
// break;
// case 'R':
// if (inclass) break;
// if (create) root = new LineEnding();
// return -1;
// case 'S':
// if (create) root = has(UNICODE_CHARACTER_CLASS)
// ? new Utype(UnicodeProp.WHITE_SPACE).complement()
// : new Ctype(ASCII.SPACE).complement();
// return -1;
// case 'T':
// case 'U':
// break;
// case 'V':
// if (create) root = new VertWS().complement();
// return -1;
// case 'W':
// if (create) root = has(UNICODE_CHARACTER_CLASS)
// ? new Utype(UnicodeProp.WORD).complement()
// : new Ctype(ASCII.WORD).complement();
// return -1;
// case 'X':
// case 'Y':
// break;
// case 'Z':
// if (inclass) break;
// if (create) {
// if (has(UNIX_LINES))
// root = new UnixDollar(false);
// else
// root = new Dollar(false);
// }
// return -1;
// case 'a':
// return '\007';
// case 'b':
// if (inclass) break;
// if (create) root = new Bound(Bound.BOTH, has(UNICODE_CHARACTER_CLASS));
// return -1;
// case 'c':
// return c();
// case 'd':
// if (create) root = has(UNICODE_CHARACTER_CLASS)
// ? new Utype(UnicodeProp.DIGIT)
// : new Ctype(ASCII.DIGIT);
// return -1;
// case 'e':
// return '\033';
// case 'f':
// return '\f';
// case 'g':
// break;
// case 'h':
// if (create) root = new HorizWS();
// return -1;
// case 'i':
// case 'j':
// break;
// case 'k':
// if (inclass)
// break;
// if (read() != '<')
// throw error("\\k is not followed by '<' for named capturing group");
// String name = groupname(read());
// if (!namedGroups().containsKey(name))
// throw error("(named capturing group <"+ name+"> does not exit");
// if (create) {
// if (has(CASE_INSENSITIVE))
// root = new CIBackRef(namedGroups().get(name), has(UNICODE_CASE));
// else
// root = new BackRef(namedGroups().get(name));
// }
// return -1;
// case 'l':
// case 'm':
// break;
// case 'n':
// return '\n';
// case 'o':
// case 'p':
// case 'q':
// break;
// case 'r':
// return '\r';
// case 's':
// if (create) root = has(UNICODE_CHARACTER_CLASS)
// ? new Utype(UnicodeProp.WHITE_SPACE)
// : new Ctype(ASCII.SPACE);
// return -1;
// case 't':
// return '\t';
// case 'u':
// return u();
// case 'v':
// // '\v' was implemented as VT/0x0B in releases < 1.8 (though
// // undocumented). In JDK8 '\v' is specified as a predefined
// // character class for all vertical whitespace characters.
// // So [-1, root=VertWS node] pair is returned (instead of a
// // single 0x0B). This breaks the range if '\v' is used as
// // the start or end value, such as [\v-...] or [...-\v], in
// // which a single definite value (0x0B) is expected. For
// // compatibility concern '\013'/0x0B is returned if isrange.
// if (isrange)
// return '\013';
// if (create) root = new VertWS();
// return -1;
// case 'w':
// if (create) root = has(UNICODE_CHARACTER_CLASS)
// ? new Utype(UnicodeProp.WORD)
// : new Ctype(ASCII.WORD);
// return -1;
// case 'x':
// return x();
// case 'y':
// break;
// case 'z':
// if (inclass) break;
// if (create) root = new End();
// return -1;
// default:
// return ch;
// }
// throw error("Illegal/unsupported escape sequence");
// }
/**
* Parse a character class, and return the node that matches it.
*
* Consumes a ] on the way out if consume is true. Usually consume
* is true except for the case of [abc&&def] where def is a separate
* right hand node with "understood" brackets.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private CharProperty clazz(boolean consume) {
// CharProperty prev = null;
// CharProperty node = null;
// BitClass bits = new BitClass();
// boolean include = true;
// boolean firstInClass = true;
// int ch = next();
// for (;;) {
// switch (ch) {
// case '^':
// // Negates if first char in a class, otherwise literal
// if (firstInClass) {
// if (temp[cursor-1] != '[')
// break;
// ch = next();
// include = !include;
// continue;
// } else {
// // ^ not first in class, treat as literal
// break;
// }
// case '[':
// firstInClass = false;
// node = clazz(true);
// if (prev == null)
// prev = node;
// else
// prev = union(prev, node);
// ch = peek();
// continue;
// case '&':
// firstInClass = false;
// ch = next();
// if (ch == '&') {
// ch = next();
// CharProperty rightNode = null;
// while (ch != ']' && ch != '&') {
// if (ch == '[') {
// if (rightNode == null)
// rightNode = clazz(true);
// else
// rightNode = union(rightNode, clazz(true));
// } else { // abc&&def
// unread();
// rightNode = clazz(false);
// }
// ch = peek();
// }
// if (rightNode != null)
// node = rightNode;
// if (prev == null) {
// if (rightNode == null)
// throw error("Bad class syntax");
// else
// prev = rightNode;
// } else {
// prev = intersection(prev, node);
// }
// } else {
// // treat as a literal &
// unread();
// break;
// }
// continue;
// case 0:
// firstInClass = false;
// if (cursor >= patternLength)
// throw error("Unclosed character class");
// break;
// case ']':
// firstInClass = false;
// if (prev != null) {
// if (consume)
// next();
// return prev;
// }
// break;
// default:
// firstInClass = false;
// break;
// }
// node = range(bits);
// if (include) {
// if (prev == null) {
// prev = node;
// } else {
// if (prev != node)
// prev = union(prev, node);
// }
// } else {
// if (prev == null) {
// prev = node.complement();
// } else {
// if (prev != node)
// prev = setDifference(prev, node);
// }
// }
// ch = peek();
// }
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private CharProperty bitsOrSingle(BitClass bits, int ch) {
// /* Bits can only handle codepoints in [u+0000-u+00ff] range.
// Use "single" node instead of bits when dealing with unicode
// case folding for codepoints listed below.
// (1)Uppercase out of range: u+00ff, u+00b5
// toUpperCase(u+00ff) -> u+0178
// toUpperCase(u+00b5) -> u+039c
// (2)LatinSmallLetterLongS u+17f
// toUpperCase(u+017f) -> u+0053
// (3)LatinSmallLetterDotlessI u+131
// toUpperCase(u+0131) -> u+0049
// (4)LatinCapitalLetterIWithDotAbove u+0130
// toLowerCase(u+0130) -> u+0069
// (5)KelvinSign u+212a
// toLowerCase(u+212a) ==> u+006B
// (6)AngstromSign u+212b
// toLowerCase(u+212b) ==> u+00e5
// */
// int d;
// if (ch < 256 &&
// !(has(CASE_INSENSITIVE) && has(UNICODE_CASE) &&
// (ch == 0xff || ch == 0xb5 ||
// ch == 0x49 || ch == 0x69 || //I and i
// ch == 0x53 || ch == 0x73 || //S and s
// ch == 0x4b || ch == 0x6b || //K and k
// ch == 0xc5 || ch == 0xe5))) //A+ring
// return bits.add(ch, flags());
// return newSingle(ch);
// }
/**
* Parse a single character or a character range in a character class
* and return its representative node.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private CharProperty range(BitClass bits) {
// int ch = peek();
// if (ch == '\\') {
// ch = nextEscaped();
// if (ch == 'p' || ch == 'P') { // A property
// boolean comp = (ch == 'P');
// boolean oneLetter = true;
// // Consume { if present
// ch = next();
// if (ch != '{')
// unread();
// else
// oneLetter = false;
// return family(oneLetter, comp);
// } else { // ordinary escape
// boolean isrange = temp[cursor+1] == '-';
// unread();
// ch = escape(true, true, isrange);
// if (ch == -1)
// return (CharProperty) root;
// }
// } else {
// next();
// }
// if (ch >= 0) {
// if (peek() == '-') {
// int endRange = temp[cursor+1];
// if (endRange == '[') {
// return bitsOrSingle(bits, ch);
// }
// if (endRange != ']') {
// next();
// int m = peek();
// if (m == '\\') {
// m = escape(true, false, true);
// } else {
// next();
// }
// if (m < ch) {
// throw error("Illegal character range");
// }
// if (has(CASE_INSENSITIVE))
// return caseInsensitiveRangeFor(ch, m);
// else
// return rangeFor(ch, m);
// }
// }
// return bitsOrSingle(bits, ch);
// }
// throw error("Unexpected character '"+((char)ch)+"'");
// }
/**
* Parses a Unicode character family and returns its representative node.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private CharProperty family(boolean singleLetter,
// boolean maybeComplement)
// {
// next();
// String name;
// CharProperty node = null;
// if (singleLetter) {
// int c = temp[cursor];
// if (!Character.isSupplementaryCodePoint(c)) {
// name = String.valueOf((char)c);
// } else {
// name = new String(temp, cursor, 1);
// }
// read();
// } else {
// int i = cursor;
// mark('}');
// while(read() != '}') {
// }
// mark('\000');
// int j = cursor;
// if (j > patternLength)
// throw error("Unclosed character family");
// if (i + 1 >= j)
// throw error("Empty character family");
// name = new String(temp, i, j-i-1);
// }
// int i = name.indexOf('=');
// if (i != -1) {
// // property construct \p{name=value}
// String value = name.substring(i + 1);
// name = name.substring(0, i).toLowerCase(Locale.ENGLISH);
// if ("sc".equals(name) || "script".equals(name)) {
// node = unicodeScriptPropertyFor(value);
// } else if ("blk".equals(name) || "block".equals(name)) {
// node = unicodeBlockPropertyFor(value);
// } else if ("gc".equals(name) || "general_category".equals(name)) {
// node = charPropertyNodeFor(value);
// } else {
// throw error("Unknown Unicode property {name=<" + name + ">, "
// + "value=<" + value + ">}");
// }
// } else {
// if (name.startsWith("In")) {
// // \p{inBlockName}
// node = unicodeBlockPropertyFor(name.substring(2));
// } else if (name.startsWith("Is")) {
// // \p{isGeneralCategory} and \p{isScriptName}
// name = name.substring(2);
// UnicodeProp uprop = UnicodeProp.forName(name);
// if (uprop != null)
// node = new Utype(uprop);
// if (node == null)
// node = CharPropertyNames.charPropertyFor(name);
// if (node == null)
// node = unicodeScriptPropertyFor(name);
// } else {
// if (has(UNICODE_CHARACTER_CLASS)) {
// UnicodeProp uprop = UnicodeProp.forPOSIXName(name);
// if (uprop != null)
// node = new Utype(uprop);
// }
// if (node == null)
// node = charPropertyNodeFor(name);
// }
// }
// if (maybeComplement) {
// if (node instanceof Category || node instanceof Block)
// hasSupplementary = true;
// node = node.complement();
// }
// return node;
// }
/**
* Returns a CharProperty matching all characters belong to
* a UnicodeScript.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private CharProperty unicodeScriptPropertyFor(String name) {
// final Character.UnicodeScript script;
// try {
// script = Character.UnicodeScript.forName(name);
// } catch (IllegalArgumentException iae) {
// throw error("Unknown character script name {" + name + "}");
// }
// return new Script(script);
// }
/**
* Returns a CharProperty matching all characters in a UnicodeBlock.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private CharProperty unicodeBlockPropertyFor(String name) {
// final Character.UnicodeBlock block;
// try {
// block = Character.UnicodeBlock.forName(name);
// } catch (IllegalArgumentException iae) {
// throw error("Unknown character block name {" + name + "}");
// }
// return new Block(block);
// }
/**
* Returns a CharProperty matching all characters in a named property.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private CharProperty charPropertyNodeFor(String name) {
// CharProperty p = CharPropertyNames.charPropertyFor(name);
// if (p == null)
// throw error("Unknown character property name {" + name + "}");
// return p;
// }
/**
* Parses and returns the name of a "named capturing group", the trailing
* ">" is consumed after parsing.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private String groupname(int ch) {
// StringBuilder sb = new StringBuilder();
// sb.append(Character.toChars(ch));
// while (ASCII.isLower(ch=read()) || ASCII.isUpper(ch) ||
// ASCII.isDigit(ch)) {
// sb.append(Character.toChars(ch));
// }
// if (sb.length() == 0)
// throw error("named capturing group has 0 length name");
// if (ch != '>')
// throw error("named capturing group is missing trailing '>'");
// return sb.toString();
// }
/**
* Parses a group and returns the head node of a set of nodes that process
* the group. Sometimes a double return system is used where the tail is
* returned in root.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private Node group0() {
// boolean capturingGroup = false;
// Node head = null;
// Node tail = null;
// int save = flags;
// root = null;
// int ch = next();
// if (ch == '?') {
// ch = skip();
// switch (ch) {
// case ':': // (?:xxx) pure group
// head = createGroup(true);
// tail = root;
// head.next = expr(tail);
// break;
// case '=': // (?=xxx) and (?!xxx) lookahead
// case '!':
// head = createGroup(true);
// tail = root;
// head.next = expr(tail);
// if (ch == '=') {
// head = tail = new Pos(head);
// } else {
// head = tail = new Neg(head);
// }
// break;
// case '>': // (?>xxx) independent group
// head = createGroup(true);
// tail = root;
// head.next = expr(tail);
// head = tail = new Ques(head, INDEPENDENT);
// break;
// case '<': // (? is already defined");
// capturingGroup = true;
// head = createGroup(false);
// tail = root;
// namedGroups().put(name, capturingGroupCount-1);
// head.next = expr(tail);
// break;
// }
// int start = cursor;
// head = createGroup(true);
// tail = root;
// head.next = expr(tail);
// tail.next = lookbehindEnd;
// TreeInfo info = new TreeInfo();
// head.study(info);
// if (info.maxValid == false) {
// throw error("Look-behind group does not have "
// + "an obvious maximum length");
// }
// boolean hasSupplementary = findSupplementary(start, patternLength);
// if (ch == '=') {
// head = tail = (hasSupplementary ?
// new BehindS(head, info.maxLength,
// info.minLength) :
// new Behind(head, info.maxLength,
// info.minLength));
// } else if (ch == '!') {
// head = tail = (hasSupplementary ?
// new NotBehindS(head, info.maxLength,
// info.minLength) :
// new NotBehind(head, info.maxLength,
// info.minLength));
// } else {
// throw error("Unknown look-behind group");
// }
// break;
// case '$':
// case '@':
// throw error("Unknown group type");
// default: // (?xxx:) inlined match flags
// unread();
// addFlag();
// ch = read();
// if (ch == ')') {
// return null; // Inline modifier only
// }
// if (ch != ':') {
// throw error("Unknown inline modifier");
// }
// head = createGroup(true);
// tail = root;
// head.next = expr(tail);
// break;
// }
// } else { // (xxx) a regular group
// capturingGroup = true;
// head = createGroup(false);
// tail = root;
// head.next = expr(tail);
// }
// accept(')', "Unclosed group");
// flags = save;
// // Check for quantifiers
// Node node = closure(head);
// if (node == head) { // No closure
// root = tail;
// return node; // Dual return
// }
// if (head == tail) { // Zero length assertion
// root = node;
// return node; // Dual return
// }
// if (node instanceof Ques) {
// Ques ques = (Ques) node;
// if (ques.type == POSSESSIVE) {
// root = node;
// return node;
// }
// tail.next = new BranchConn();
// tail = tail.next;
// if (ques.type == GREEDY) {
// head = new Branch(head, null, tail);
// } else { // Reluctant quantifier
// head = new Branch(null, head, tail);
// }
// root = tail;
// return head;
// } else if (node instanceof Curly) {
// Curly curly = (Curly) node;
// if (curly.type == POSSESSIVE) {
// root = node;
// return node;
// }
// // Discover if the group is deterministic
// TreeInfo info = new TreeInfo();
// if (head.study(info)) { // Deterministic
// GroupTail temp = (GroupTail) tail;
// head = root = new GroupCurly(head.next, curly.cmin,
// curly.cmax, curly.type,
// ((GroupTail)tail).localIndex,
// ((GroupTail)tail).groupIndex,
// capturingGroup);
// return head;
// } else { // Non-deterministic
// int temp = ((GroupHead) head).localIndex;
// Loop loop;
// if (curly.type == GREEDY)
// loop = new Loop(this.localCount, temp);
// else // Reluctant Curly
// loop = new LazyLoop(this.localCount, temp);
// Prolog prolog = new Prolog(loop);
// this.localCount += 1;
// loop.cmin = curly.cmin;
// loop.cmax = curly.cmax;
// loop.body = head;
// tail.next = loop;
// root = loop;
// return prolog; // Dual return
// }
// }
// throw error("Internal logic error");
// }
/**
* Create group head and tail nodes using double return. If the group is
* created with anonymous true then it is a pure group and should not
* affect group counting.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private Node createGroup(boolean anonymous) {
// int localIndex = localCount++;
// int groupIndex = 0;
// if (!anonymous)
// groupIndex = capturingGroupCount++;
// GroupHead head = new GroupHead(localIndex);
// root = new GroupTail(localIndex, groupIndex);
// if (!anonymous && groupIndex < 10)
// groupNodes[groupIndex] = head;
// return head;
// }
/**
* Parses inlined match flags and set them appropriately.
*/
// @SuppressWarnings("fallthrough")
// DIFFBLUE MODEL LIBRARY - not used in model
// private void addFlag() {
// int ch = peek();
// for (;;) {
// switch (ch) {
// case 'i':
// flags |= CASE_INSENSITIVE;
// break;
// case 'm':
// flags |= MULTILINE;
// break;
// case 's':
// flags |= DOTALL;
// break;
// case 'd':
// flags |= UNIX_LINES;
// break;
// case 'u':
// flags |= UNICODE_CASE;
// break;
// case 'c':
// flags |= CANON_EQ;
// break;
// case 'x':
// flags |= COMMENTS;
// break;
// case 'U':
// flags |= (UNICODE_CHARACTER_CLASS | UNICODE_CASE);
// break;
// case '-': // subFlag then fall through
// ch = next();
// subFlag();
// default:
// return;
// }
// ch = next();
// }
// }
@SuppressWarnings("fallthrough")
/**
* Parses the second part of inlined match flags and turns off
* flags appropriately.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private void subFlag() {
// int ch = peek();
// for (;;) {
// switch (ch) {
// case 'i':
// flags &= ~CASE_INSENSITIVE;
// break;
// case 'm':
// flags &= ~MULTILINE;
// break;
// case 's':
// flags &= ~DOTALL;
// break;
// case 'd':
// flags &= ~UNIX_LINES;
// break;
// case 'u':
// flags &= ~UNICODE_CASE;
// break;
// case 'c':
// flags &= ~CANON_EQ;
// break;
// case 'x':
// flags &= ~COMMENTS;
// break;
// case 'U':
// flags &= ~(UNICODE_CHARACTER_CLASS | UNICODE_CASE);
// default:
// return;
// }
// ch = next();
// }
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// static final int MAX_REPS = 0x7FFFFFFF;
// DIFFBLUE MODEL LIBRARY - not used in model
// static final int GREEDY = 0;
// DIFFBLUE MODEL LIBRARY - not used in model
// static final int LAZY = 1;
// DIFFBLUE MODEL LIBRARY - not used in model
// static final int POSSESSIVE = 2;
// DIFFBLUE MODEL LIBRARY - not used in model
// static final int INDEPENDENT = 3;
/**
* Processes repetition. If the next character peeked is a quantifier
* then new nodes must be appended to handle the repetition.
* Prev could be a single or a group, so it could be a chain of nodes.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private Node closure(Node prev) {
// Node atom;
// int ch = peek();
// switch (ch) {
// case '?':
// ch = next();
// if (ch == '?') {
// next();
// return new Ques(prev, LAZY);
// } else if (ch == '+') {
// next();
// return new Ques(prev, POSSESSIVE);
// }
// return new Ques(prev, GREEDY);
// case '*':
// ch = next();
// if (ch == '?') {
// next();
// return new Curly(prev, 0, MAX_REPS, LAZY);
// } else if (ch == '+') {
// next();
// return new Curly(prev, 0, MAX_REPS, POSSESSIVE);
// }
// return new Curly(prev, 0, MAX_REPS, GREEDY);
// case '+':
// ch = next();
// if (ch == '?') {
// next();
// return new Curly(prev, 1, MAX_REPS, LAZY);
// } else if (ch == '+') {
// next();
// return new Curly(prev, 1, MAX_REPS, POSSESSIVE);
// }
// return new Curly(prev, 1, MAX_REPS, GREEDY);
// case '{':
// ch = temp[cursor+1];
// if (ASCII.isDigit(ch)) {
// skip();
// int cmin = 0;
// do {
// cmin = cmin * 10 + (ch - '0');
// } while (ASCII.isDigit(ch = read()));
// int cmax = cmin;
// if (ch == ',') {
// ch = read();
// cmax = MAX_REPS;
// if (ch != '}') {
// cmax = 0;
// while (ASCII.isDigit(ch)) {
// cmax = cmax * 10 + (ch - '0');
// ch = read();
// }
// }
// }
// if (ch != '}')
// throw error("Unclosed counted closure");
// if (((cmin) | (cmax) | (cmax - cmin)) < 0)
// throw error("Illegal repetition range");
// Curly curly;
// ch = peek();
// if (ch == '?') {
// next();
// curly = new Curly(prev, cmin, cmax, LAZY);
// } else if (ch == '+') {
// next();
// curly = new Curly(prev, cmin, cmax, POSSESSIVE);
// } else {
// curly = new Curly(prev, cmin, cmax, GREEDY);
// }
// return curly;
// } else {
// throw error("Illegal repetition");
// }
// default:
// return prev;
// }
// }
/**
* Utility method for parsing control escape sequences.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int c() {
// if (cursor < patternLength) {
// return read() ^ 64;
// }
// throw error("Illegal control escape sequence");
// }
/**
* Utility method for parsing octal escape sequences.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int o() {
// int n = read();
// if (((n-'0')|('7'-n)) >= 0) {
// int m = read();
// if (((m-'0')|('7'-m)) >= 0) {
// int o = read();
// if ((((o-'0')|('7'-o)) >= 0) && (((n-'0')|('3'-n)) >= 0)) {
// return (n - '0') * 64 + (m - '0') * 8 + (o - '0');
// }
// unread();
// return (n - '0') * 8 + (m - '0');
// }
// unread();
// return (n - '0');
// }
// throw error("Illegal octal escape sequence");
// }
/**
* Utility method for parsing hexadecimal escape sequences.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int x() {
// int n = read();
// if (ASCII.isHexDigit(n)) {
// int m = read();
// if (ASCII.isHexDigit(m)) {
// return ASCII.toDigit(n) * 16 + ASCII.toDigit(m);
// }
// } else if (n == '{' && ASCII.isHexDigit(peek())) {
// int ch = 0;
// while (ASCII.isHexDigit(n = read())) {
// ch = (ch << 4) + ASCII.toDigit(n);
// if (ch > Character.MAX_CODE_POINT)
// throw error("Hexadecimal codepoint is too big");
// }
// if (n != '}')
// throw error("Unclosed hexadecimal escape sequence");
// return ch;
// }
// throw error("Illegal hexadecimal escape sequence");
// }
/**
* Utility method for parsing unicode escape sequences.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private int cursor() {
// return cursor;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private void setcursor(int pos) {
// cursor = pos;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private int uxxxx() {
// int n = 0;
// for (int i = 0; i < 4; i++) {
// int ch = read();
// if (!ASCII.isHexDigit(ch)) {
// throw error("Illegal Unicode escape sequence");
// }
// n = n * 16 + ASCII.toDigit(ch);
// }
// return n;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private int u() {
// int n = uxxxx();
// if (Character.isHighSurrogate((char)n)) {
// int cur = cursor();
// if (read() == '\\' && read() == 'u') {
// int n2 = uxxxx();
// if (Character.isLowSurrogate((char)n2))
// return Character.toCodePoint((char)n, (char)n2);
// }
// setcursor(cur);
// }
// return n;
// }
//
// Utility methods for code point support
//
// DIFFBLUE MODEL LIBRARY - not used in model
// private static final int countChars(CharSequence seq, int index,
// int lengthInCodePoints) {
// // optimization
// if (lengthInCodePoints == 1 && !Character.isHighSurrogate(seq.charAt(index))) {
// assert (index >= 0 && index < seq.length());
// return 1;
// }
// int length = seq.length();
// int x = index;
// if (lengthInCodePoints >= 0) {
// assert (index >= 0 && index < length);
// for (int i = 0; x < length && i < lengthInCodePoints; i++) {
// if (Character.isHighSurrogate(seq.charAt(x++))) {
// if (x < length && Character.isLowSurrogate(seq.charAt(x))) {
// x++;
// }
// }
// }
// return x - index;
// }
// assert (index >= 0 && index <= length);
// if (index == 0) {
// return 0;
// }
// int len = -lengthInCodePoints;
// for (int i = 0; x > 0 && i < len; i++) {
// if (Character.isLowSurrogate(seq.charAt(--x))) {
// if (x > 0 && Character.isHighSurrogate(seq.charAt(x-1))) {
// x--;
// }
// }
// }
// return index - x;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private static final int countCodePoints(CharSequence seq) {
// int length = seq.length();
// int n = 0;
// for (int i = 0; i < length; ) {
// n++;
// if (Character.isHighSurrogate(seq.charAt(i++))) {
// if (i < length && Character.isLowSurrogate(seq.charAt(i))) {
// i++;
// }
// }
// }
// return n;
// }
/**
* Creates a bit vector for matching Latin-1 values. A normal BitClass
* never matches values above Latin-1, and a complemented BitClass always
* matches values above Latin-1.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static final class BitClass extends BmpCharProperty {
// final boolean[] bits;
// BitClass() { bits = new boolean[256]; }
// private BitClass(boolean[] bits) { this.bits = bits; }
// BitClass add(int c, int flags) {
// assert c >= 0 && c <= 255;
// if ((flags & CASE_INSENSITIVE) != 0) {
// if (ASCII.isAscii(c)) {
// bits[ASCII.toUpper(c)] = true;
// bits[ASCII.toLower(c)] = true;
// } else if ((flags & UNICODE_CASE) != 0) {
// bits[Character.toLowerCase(c)] = true;
// bits[Character.toUpperCase(c)] = true;
// }
// }
// bits[c] = true;
// return this;
// }
// boolean isSatisfiedBy(int ch) {
// return ch < 256 && bits[ch];
// }
// }
/**
* Returns a suitably optimized, single character matcher.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private CharProperty newSingle(final int ch) {
// if (has(CASE_INSENSITIVE)) {
// int lower, upper;
// if (has(UNICODE_CASE)) {
// upper = Character.toUpperCase(ch);
// lower = Character.toLowerCase(upper);
// if (upper != lower)
// return new SingleU(lower);
// } else if (ASCII.isAscii(ch)) {
// lower = ASCII.toLower(ch);
// upper = ASCII.toUpper(ch);
// if (lower != upper)
// return new SingleI(lower, upper);
// }
// }
// if (isSupplementary(ch))
// return new SingleS(ch); // Match a given Unicode character
// return new Single(ch); // Match a given BMP character
// }
/**
* Utility method for creating a string slice matcher.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private Node newSlice(int[] buf, int count, boolean hasSupplementary) {
// int[] tmp = new int[count];
// if (has(CASE_INSENSITIVE)) {
// if (has(UNICODE_CASE)) {
// for (int i = 0; i < count; i++) {
// tmp[i] = Character.toLowerCase(
// Character.toUpperCase(buf[i]));
// }
// return hasSupplementary? new SliceUS(tmp) : new SliceU(tmp);
// }
// for (int i = 0; i < count; i++) {
// tmp[i] = ASCII.toLower(buf[i]);
// }
// return hasSupplementary? new SliceIS(tmp) : new SliceI(tmp);
// }
// for (int i = 0; i < count; i++) {
// tmp[i] = buf[i];
// }
// return hasSupplementary ? new SliceS(tmp) : new Slice(tmp);
// }
/**
* The following classes are the building components of the object
* tree that represents a compiled regular expression. The object tree
* is made of individual elements that handle constructs in the Pattern.
* Each type of object knows how to match its equivalent construct with
* the match() method.
*/
/**
* Base class for all node classes. Subclasses should override the match()
* method as appropriate. This class is an accepting node, so its match()
* always returns true.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class Node extends Object {
// Node next;
// Node() {
// next = Pattern.accept;
// }
// /**
// * This method implements the classic accept node.
// */
// boolean match(Matcher matcher, int i, CharSequence seq) {
// matcher.last = i;
// matcher.groups[0] = matcher.first;
// matcher.groups[1] = matcher.last;
// return true;
// }
// /**
// * This method is good for all zero length assertions.
// */
// boolean study(TreeInfo info) {
// if (next != null) {
// return next.study(info);
// } else {
// return info.deterministic;
// }
// }
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// static class LastNode extends Node {
// /**
// * This method implements the classic accept node with
// * the addition of a check to see if the match occurred
// * using all of the input.
// */
// boolean match(Matcher matcher, int i, CharSequence seq) {
// if (matcher.acceptMode == Matcher.ENDANCHOR && i != matcher.to)
// return false;
// matcher.last = i;
// matcher.groups[0] = matcher.first;
// matcher.groups[1] = matcher.last;
// return true;
// }
// }
/**
* Used for REs that can start anywhere within the input string.
* This basically tries to match repeatedly at each spot in the
* input string, moving forward after each try. An anchored search
* or a BnM will bypass this node completely.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class Start extends Node {
// int minLength;
// Start(Node node) {
// this.next = node;
// TreeInfo info = new TreeInfo();
// next.study(info);
// minLength = info.minLength;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// if (i > matcher.to - minLength) {
// matcher.hitEnd = true;
// return false;
// }
// int guard = matcher.to - minLength;
// for (; i <= guard; i++) {
// if (next.match(matcher, i, seq)) {
// matcher.first = i;
// matcher.groups[0] = matcher.first;
// matcher.groups[1] = matcher.last;
// return true;
// }
// }
// matcher.hitEnd = true;
// return false;
// }
// boolean study(TreeInfo info) {
// next.study(info);
// info.maxValid = false;
// info.deterministic = false;
// return false;
// }
// }
/*
* StartS supports supplementary characters, including unpaired surrogates.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class StartS extends Start {
// StartS(Node node) {
// super(node);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// if (i > matcher.to - minLength) {
// matcher.hitEnd = true;
// return false;
// }
// int guard = matcher.to - minLength;
// while (i <= guard) {
// //if ((ret = next.match(matcher, i, seq)) || i == guard)
// if (next.match(matcher, i, seq)) {
// matcher.first = i;
// matcher.groups[0] = matcher.first;
// matcher.groups[1] = matcher.last;
// return true;
// }
// if (i == guard)
// break;
// // Optimization to move to the next character. This is
// // faster than countChars(seq, i, 1).
// if (Character.isHighSurrogate(seq.charAt(i++))) {
// if (i < seq.length() &&
// Character.isLowSurrogate(seq.charAt(i))) {
// i++;
// }
// }
// }
// matcher.hitEnd = true;
// return false;
// }
// }
/**
* Node to anchor at the beginning of input. This object implements the
* match for a \A sequence, and the caret anchor will use this if not in
* multiline mode.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Begin extends Node {
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int fromIndex = (matcher.anchoringBounds) ?
// matcher.from : 0;
// if (i == fromIndex && next.match(matcher, i, seq)) {
// matcher.first = i;
// matcher.groups[0] = i;
// matcher.groups[1] = matcher.last;
// return true;
// } else {
// return false;
// }
// }
// }
/**
* Node to anchor at the end of input. This is the absolute end, so this
* should not match at the last newline before the end as $ will.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class End extends Node {
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int endIndex = (matcher.anchoringBounds) ?
// matcher.to : matcher.getTextLength();
// if (i == endIndex) {
// matcher.hitEnd = true;
// return next.match(matcher, i, seq);
// }
// return false;
// }
// }
/**
* Node to anchor at the beginning of a line. This is essentially the
* object to match for the multiline ^.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Caret extends Node {
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int startIndex = matcher.from;
// int endIndex = matcher.to;
// if (!matcher.anchoringBounds) {
// startIndex = 0;
// endIndex = matcher.getTextLength();
// }
// // Perl does not match ^ at end of input even after newline
// if (i == endIndex) {
// matcher.hitEnd = true;
// return false;
// }
// if (i > startIndex) {
// char ch = seq.charAt(i-1);
// if (ch != '\n' && ch != '\r'
// && (ch|1) != '\u2029'
// && ch != '\u0085' ) {
// return false;
// }
// // Should treat /r/n as one newline
// if (ch == '\r' && seq.charAt(i) == '\n')
// return false;
// }
// return next.match(matcher, i, seq);
// }
// }
/**
* Node to anchor at the beginning of a line when in unixdot mode.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class UnixCaret extends Node {
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int startIndex = matcher.from;
// int endIndex = matcher.to;
// if (!matcher.anchoringBounds) {
// startIndex = 0;
// endIndex = matcher.getTextLength();
// }
// // Perl does not match ^ at end of input even after newline
// if (i == endIndex) {
// matcher.hitEnd = true;
// return false;
// }
// if (i > startIndex) {
// char ch = seq.charAt(i-1);
// if (ch != '\n') {
// return false;
// }
// }
// return next.match(matcher, i, seq);
// }
// }
/**
* Node to match the location where the last match ended.
* This is used for the \G construct.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class LastMatch extends Node {
// boolean match(Matcher matcher, int i, CharSequence seq) {
// if (i != matcher.oldLast)
// return false;
// return next.match(matcher, i, seq);
// }
// }
/**
* Node to anchor at the end of a line or the end of input based on the
* multiline mode.
*
* When not in multiline mode, the $ can only match at the very end
* of the input, unless the input ends in a line terminator in which
* it matches right before the last line terminator.
*
* Note that \r\n is considered an atomic line terminator.
*
* Like ^ the $ operator matches at a position, it does not match the
* line terminators themselves.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Dollar extends Node {
// boolean multiline;
// Dollar(boolean mul) {
// multiline = mul;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int endIndex = (matcher.anchoringBounds) ?
// matcher.to : matcher.getTextLength();
// if (!multiline) {
// if (i < endIndex - 2)
// return false;
// if (i == endIndex - 2) {
// char ch = seq.charAt(i);
// if (ch != '\r')
// return false;
// ch = seq.charAt(i + 1);
// if (ch != '\n')
// return false;
// }
// }
// // Matches before any line terminator; also matches at the
// // end of input
// // Before line terminator:
// // If multiline, we match here no matter what
// // If not multiline, fall through so that the end
// // is marked as hit; this must be a /r/n or a /n
// // at the very end so the end was hit; more input
// // could make this not match here
// if (i < endIndex) {
// char ch = seq.charAt(i);
// if (ch == '\n') {
// // No match between \r\n
// if (i > 0 && seq.charAt(i-1) == '\r')
// return false;
// if (multiline)
// return next.match(matcher, i, seq);
// } else if (ch == '\r' || ch == '\u0085' ||
// (ch|1) == '\u2029') {
// if (multiline)
// return next.match(matcher, i, seq);
// } else { // No line terminator, no match
// return false;
// }
// }
// // Matched at current end so hit end
// matcher.hitEnd = true;
// // If a $ matches because of end of input, then more input
// // could cause it to fail!
// matcher.requireEnd = true;
// return next.match(matcher, i, seq);
// }
// boolean study(TreeInfo info) {
// next.study(info);
// return info.deterministic;
// }
// }
/**
* Node to anchor at the end of a line or the end of input based on the
* multiline mode when in unix lines mode.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class UnixDollar extends Node {
// boolean multiline;
// UnixDollar(boolean mul) {
// multiline = mul;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int endIndex = (matcher.anchoringBounds) ?
// matcher.to : matcher.getTextLength();
// if (i < endIndex) {
// char ch = seq.charAt(i);
// if (ch == '\n') {
// // If not multiline, then only possible to
// // match at very end or one before end
// if (multiline == false && i != endIndex - 1)
// return false;
// // If multiline return next.match without setting
// // matcher.hitEnd
// if (multiline)
// return next.match(matcher, i, seq);
// } else {
// return false;
// }
// }
// // Matching because at the end or 1 before the end;
// // more input could change this so set hitEnd
// matcher.hitEnd = true;
// // If a $ matches because of end of input, then more input
// // could cause it to fail!
// matcher.requireEnd = true;
// return next.match(matcher, i, seq);
// }
// boolean study(TreeInfo info) {
// next.study(info);
// return info.deterministic;
// }
// }
/**
* Node class that matches a Unicode line ending '\R'
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class LineEnding extends Node {
// boolean match(Matcher matcher, int i, CharSequence seq) {
// // (u+000Du+000A|[u+000Au+000Bu+000Cu+000Du+0085u+2028u+2029])
// if (i < matcher.to) {
// int ch = seq.charAt(i);
// if (ch == 0x0A || ch == 0x0B || ch == 0x0C ||
// ch == 0x85 || ch == 0x2028 || ch == 0x2029)
// return next.match(matcher, i + 1, seq);
// if (ch == 0x0D) {
// i++;
// if (i < matcher.to && seq.charAt(i) == 0x0A)
// i++;
// return next.match(matcher, i, seq);
// }
// } else {
// matcher.hitEnd = true;
// }
// return false;
// }
// boolean study(TreeInfo info) {
// info.minLength++;
// info.maxLength += 2;
// return next.study(info);
// }
// }
/**
* Abstract node class to match one character satisfying some
* boolean property.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static abstract class CharProperty extends Node {
// abstract boolean isSatisfiedBy(int ch);
// CharProperty complement() {
// return new CharProperty() {
// boolean isSatisfiedBy(int ch) {
// return ! CharProperty.this.isSatisfiedBy(ch);}};
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// if (i < matcher.to) {
// int ch = Character.codePointAt(seq, i);
// return isSatisfiedBy(ch)
// && next.match(matcher, i+Character.charCount(ch), seq);
// } else {
// matcher.hitEnd = true;
// return false;
// }
// }
// boolean study(TreeInfo info) {
// info.minLength++;
// info.maxLength++;
// return next.study(info);
// }
// }
/**
* Optimized version of CharProperty that works only for
* properties never satisfied by Supplementary characters.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static abstract class BmpCharProperty extends CharProperty {
// boolean match(Matcher matcher, int i, CharSequence seq) {
// if (i < matcher.to) {
// return isSatisfiedBy(seq.charAt(i))
// && next.match(matcher, i+1, seq);
// } else {
// matcher.hitEnd = true;
// return false;
// }
// }
// }
/**
* Node class that matches a Supplementary Unicode character
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class SingleS extends CharProperty {
// final int c;
// SingleS(int c) { this.c = c; }
// boolean isSatisfiedBy(int ch) {
// return ch == c;
// }
// }
/**
* Optimization -- matches a given BMP character
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Single extends BmpCharProperty {
// final int c;
// Single(int c) { this.c = c; }
// boolean isSatisfiedBy(int ch) {
// return ch == c;
// }
// }
/**
* Case insensitive matches a given BMP character
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class SingleI extends BmpCharProperty {
// final int lower;
// final int upper;
// SingleI(int lower, int upper) {
// this.lower = lower;
// this.upper = upper;
// }
// boolean isSatisfiedBy(int ch) {
// return ch == lower || ch == upper;
// }
// }
/**
* Unicode case insensitive matches a given Unicode character
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class SingleU extends CharProperty {
// final int lower;
// SingleU(int lower) {
// this.lower = lower;
// }
// boolean isSatisfiedBy(int ch) {
// return lower == ch ||
// lower == Character.toLowerCase(Character.toUpperCase(ch));
// }
// }
/**
* Node class that matches a Unicode block.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Block extends CharProperty {
// final Character.UnicodeBlock block;
// Block(Character.UnicodeBlock block) {
// this.block = block;
// }
// boolean isSatisfiedBy(int ch) {
// return block == Character.UnicodeBlock.of(ch);
// }
// }
/**
* Node class that matches a Unicode script
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Script extends CharProperty {
// final Character.UnicodeScript script;
// Script(Character.UnicodeScript script) {
// this.script = script;
// }
// boolean isSatisfiedBy(int ch) {
// return script == Character.UnicodeScript.of(ch);
// }
// }
/**
* Node class that matches a Unicode category.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Category extends CharProperty {
// final int typeMask;
// Category(int typeMask) { this.typeMask = typeMask; }
// boolean isSatisfiedBy(int ch) {
// return (typeMask & (1 << Character.getType(ch))) != 0;
// }
// }
/**
* Node class that matches a Unicode "type"
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Utype extends CharProperty {
// final UnicodeProp uprop;
// Utype(UnicodeProp uprop) { this.uprop = uprop; }
// boolean isSatisfiedBy(int ch) {
// return uprop.is(ch);
// }
// }
/**
* Node class that matches a POSIX type.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Ctype extends BmpCharProperty {
// final int ctype;
// Ctype(int ctype) { this.ctype = ctype; }
// boolean isSatisfiedBy(int ch) {
// return ch < 128 && ASCII.isType(ch, ctype);
// }
// }
/**
* Node class that matches a Perl vertical whitespace
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class VertWS extends BmpCharProperty {
// boolean isSatisfiedBy(int cp) {
// return (cp >= 0x0A && cp <= 0x0D) ||
// cp == 0x85 || cp == 0x2028 || cp == 0x2029;
// }
// }
/**
* Node class that matches a Perl horizontal whitespace
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class HorizWS extends BmpCharProperty {
// boolean isSatisfiedBy(int cp) {
// return cp == 0x09 || cp == 0x20 || cp == 0xa0 ||
// cp == 0x1680 || cp == 0x180e ||
// cp >= 0x2000 && cp <= 0x200a ||
// cp == 0x202f || cp == 0x205f || cp == 0x3000;
// }
// }
/**
* Base class for all Slice nodes
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class SliceNode extends Node {
// int[] buffer;
// SliceNode(int[] buf) {
// buffer = buf;
// }
// boolean study(TreeInfo info) {
// info.minLength += buffer.length;
// info.maxLength += buffer.length;
// return next.study(info);
// }
// }
/**
* Node class for a case sensitive/BMP-only sequence of literal
* characters.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Slice extends SliceNode {
// Slice(int[] buf) {
// super(buf);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int[] buf = buffer;
// int len = buf.length;
// for (int j=0; j= matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// if (buf[j] != seq.charAt(i+j))
// return false;
// }
// return next.match(matcher, i+len, seq);
// }
// }
/**
* Node class for a case_insensitive/BMP-only sequence of literal
* characters.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class SliceI extends SliceNode {
// SliceI(int[] buf) {
// super(buf);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int[] buf = buffer;
// int len = buf.length;
// for (int j=0; j= matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// int c = seq.charAt(i+j);
// if (buf[j] != c &&
// buf[j] != ASCII.toLower(c))
// return false;
// }
// return next.match(matcher, i+len, seq);
// }
// }
/**
* Node class for a unicode_case_insensitive/BMP-only sequence of
* literal characters. Uses unicode case folding.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class SliceU extends SliceNode {
// SliceU(int[] buf) {
// super(buf);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int[] buf = buffer;
// int len = buf.length;
// for (int j=0; j= matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// int c = seq.charAt(i+j);
// if (buf[j] != c &&
// buf[j] != Character.toLowerCase(Character.toUpperCase(c)))
// return false;
// }
// return next.match(matcher, i+len, seq);
// }
// }
/**
* Node class for a case sensitive sequence of literal characters
* including supplementary characters.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class SliceS extends SliceNode {
// SliceS(int[] buf) {
// super(buf);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int[] buf = buffer;
// int x = i;
// for (int j = 0; j < buf.length; j++) {
// if (x >= matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// int c = Character.codePointAt(seq, x);
// if (buf[j] != c)
// return false;
// x += Character.charCount(c);
// if (x > matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// }
// return next.match(matcher, x, seq);
// }
// }
/**
* Node class for a case insensitive sequence of literal characters
* including supplementary characters.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class SliceIS extends SliceNode {
// SliceIS(int[] buf) {
// super(buf);
// }
// int toLower(int c) {
// return ASCII.toLower(c);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int[] buf = buffer;
// int x = i;
// for (int j = 0; j < buf.length; j++) {
// if (x >= matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// int c = Character.codePointAt(seq, x);
// if (buf[j] != c && buf[j] != toLower(c))
// return false;
// x += Character.charCount(c);
// if (x > matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// }
// return next.match(matcher, x, seq);
// }
// }
/**
* Node class for a case insensitive sequence of literal characters.
* Uses unicode case folding.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class SliceUS extends SliceIS {
// SliceUS(int[] buf) {
// super(buf);
// }
// int toLower(int c) {
// return Character.toLowerCase(Character.toUpperCase(c));
// }
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// private static boolean inRange(int lower, int ch, int upper) {
// return lower <= ch && ch <= upper;
// }
/**
* Returns node for matching characters within an explicit value range.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static CharProperty rangeFor(final int lower,
// final int upper) {
// return new CharProperty() {
// boolean isSatisfiedBy(int ch) {
// return inRange(lower, ch, upper);}};
// }
/**
* Returns node for matching characters within an explicit value
* range in a case insensitive manner.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private CharProperty caseInsensitiveRangeFor(final int lower,
// final int upper) {
// if (has(UNICODE_CASE))
// return new CharProperty() {
// boolean isSatisfiedBy(int ch) {
// if (inRange(lower, ch, upper))
// return true;
// int up = Character.toUpperCase(ch);
// return inRange(lower, up, upper) ||
// inRange(lower, Character.toLowerCase(up), upper);}};
// return new CharProperty() {
// boolean isSatisfiedBy(int ch) {
// return inRange(lower, ch, upper) ||
// ASCII.isAscii(ch) &&
// (inRange(lower, ASCII.toUpper(ch), upper) ||
// inRange(lower, ASCII.toLower(ch), upper));
// }};
// }
/**
* Implements the Unicode category ALL and the dot metacharacter when
* in dotall mode.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class All extends CharProperty {
// boolean isSatisfiedBy(int ch) {
// return true;
// }
// }
/**
* Node class for the dot metacharacter when dotall is not enabled.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Dot extends CharProperty {
// boolean isSatisfiedBy(int ch) {
// return (ch != '\n' && ch != '\r'
// && (ch|1) != '\u2029'
// && ch != '\u0085');
// }
// }
/**
* Node class for the dot metacharacter when dotall is not enabled
* but UNIX_LINES is enabled.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class UnixDot extends CharProperty {
// boolean isSatisfiedBy(int ch) {
// return ch != '\n';
// }
// }
/**
* The 0 or 1 quantifier. This one class implements all three types.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Ques extends Node {
// Node atom;
// int type;
// Ques(Node node, int type) {
// this.atom = node;
// this.type = type;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// switch (type) {
// case GREEDY:
// return (atom.match(matcher, i, seq) && next.match(matcher, matcher.last, seq))
// || next.match(matcher, i, seq);
// case LAZY:
// return next.match(matcher, i, seq)
// || (atom.match(matcher, i, seq) && next.match(matcher, matcher.last, seq));
// case POSSESSIVE:
// if (atom.match(matcher, i, seq)) i = matcher.last;
// return next.match(matcher, i, seq);
// default:
// return atom.match(matcher, i, seq) && next.match(matcher, matcher.last, seq);
// }
// }
// boolean study(TreeInfo info) {
// if (type != INDEPENDENT) {
// int minL = info.minLength;
// atom.study(info);
// info.minLength = minL;
// info.deterministic = false;
// return next.study(info);
// } else {
// atom.study(info);
// return next.study(info);
// }
// }
// }
/**
* Handles the curly-brace style repetition with a specified minimum and
* maximum occurrences. The * quantifier is handled as a special case.
* This class handles the three types.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Curly extends Node {
// Node atom;
// int type;
// int cmin;
// int cmax;
// Curly(Node node, int cmin, int cmax, int type) {
// this.atom = node;
// this.type = type;
// this.cmin = cmin;
// this.cmax = cmax;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int j;
// for (j = 0; j < cmin; j++) {
// if (atom.match(matcher, i, seq)) {
// i = matcher.last;
// continue;
// }
// return false;
// }
// if (type == GREEDY)
// return match0(matcher, i, j, seq);
// else if (type == LAZY)
// return match1(matcher, i, j, seq);
// else
// return match2(matcher, i, j, seq);
// }
// // Greedy match.
// // i is the index to start matching at
// // j is the number of atoms that have matched
// boolean match0(Matcher matcher, int i, int j, CharSequence seq) {
// if (j >= cmax) {
// // We have matched the maximum... continue with the rest of
// // the regular expression
// return next.match(matcher, i, seq);
// }
// int backLimit = j;
// while (atom.match(matcher, i, seq)) {
// // k is the length of this match
// int k = matcher.last - i;
// if (k == 0) // Zero length match
// break;
// // Move up index and number matched
// i = matcher.last;
// j++;
// // We are greedy so match as many as we can
// while (j < cmax) {
// if (!atom.match(matcher, i, seq))
// break;
// if (i + k != matcher.last) {
// if (match0(matcher, matcher.last, j+1, seq))
// return true;
// break;
// }
// i += k;
// j++;
// }
// // Handle backing off if match fails
// while (j >= backLimit) {
// if (next.match(matcher, i, seq))
// return true;
// i -= k;
// j--;
// }
// return false;
// }
// return next.match(matcher, i, seq);
// }
// // Reluctant match. At this point, the minimum has been satisfied.
// // i is the index to start matching at
// // j is the number of atoms that have matched
// boolean match1(Matcher matcher, int i, int j, CharSequence seq) {
// for (;;) {
// // Try finishing match without consuming any more
// if (next.match(matcher, i, seq))
// return true;
// // At the maximum, no match found
// if (j >= cmax)
// return false;
// // Okay, must try one more atom
// if (!atom.match(matcher, i, seq))
// return false;
// // If we haven't moved forward then must break out
// if (i == matcher.last)
// return false;
// // Move up index and number matched
// i = matcher.last;
// j++;
// }
// }
// boolean match2(Matcher matcher, int i, int j, CharSequence seq) {
// for (; j < cmax; j++) {
// if (!atom.match(matcher, i, seq))
// break;
// if (i == matcher.last)
// break;
// i = matcher.last;
// }
// return next.match(matcher, i, seq);
// }
// boolean study(TreeInfo info) {
// // Save original info
// int minL = info.minLength;
// int maxL = info.maxLength;
// boolean maxV = info.maxValid;
// boolean detm = info.deterministic;
// info.reset();
// atom.study(info);
// int temp = info.minLength * cmin + minL;
// if (temp < minL) {
// temp = 0xFFFFFFF; // arbitrary large number
// }
// info.minLength = temp;
// if (maxV & info.maxValid) {
// temp = info.maxLength * cmax + maxL;
// info.maxLength = temp;
// if (temp < maxL) {
// info.maxValid = false;
// }
// } else {
// info.maxValid = false;
// }
// if (info.deterministic && cmin == cmax)
// info.deterministic = detm;
// else
// info.deterministic = false;
// return next.study(info);
// }
// }
/**
* Handles the curly-brace style repetition with a specified minimum and
* maximum occurrences in deterministic cases. This is an iterative
* optimization over the Prolog and Loop system which would handle this
* in a recursive way. The * quantifier is handled as a special case.
* If capture is true then this class saves group settings and ensures
* that groups are unset when backing off of a group match.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class GroupCurly extends Node {
// Node atom;
// int type;
// int cmin;
// int cmax;
// int localIndex;
// int groupIndex;
// boolean capture;
// GroupCurly(Node node, int cmin, int cmax, int type, int local,
// int group, boolean capture) {
// this.atom = node;
// this.type = type;
// this.cmin = cmin;
// this.cmax = cmax;
// this.localIndex = local;
// this.groupIndex = group;
// this.capture = capture;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int[] groups = matcher.groups;
// int[] locals = matcher.locals;
// int save0 = locals[localIndex];
// int save1 = 0;
// int save2 = 0;
// if (capture) {
// save1 = groups[groupIndex];
// save2 = groups[groupIndex+1];
// }
// // Notify GroupTail there is no need to setup group info
// // because it will be set here
// locals[localIndex] = -1;
// boolean ret = true;
// for (int j = 0; j < cmin; j++) {
// if (atom.match(matcher, i, seq)) {
// if (capture) {
// groups[groupIndex] = i;
// groups[groupIndex+1] = matcher.last;
// }
// i = matcher.last;
// } else {
// ret = false;
// break;
// }
// }
// if (ret) {
// if (type == GREEDY) {
// ret = match0(matcher, i, cmin, seq);
// } else if (type == LAZY) {
// ret = match1(matcher, i, cmin, seq);
// } else {
// ret = match2(matcher, i, cmin, seq);
// }
// }
// if (!ret) {
// locals[localIndex] = save0;
// if (capture) {
// groups[groupIndex] = save1;
// groups[groupIndex+1] = save2;
// }
// }
// return ret;
// }
// // Aggressive group match
// boolean match0(Matcher matcher, int i, int j, CharSequence seq) {
// // don't back off passing the starting "j"
// int min = j;
// int[] groups = matcher.groups;
// int save0 = 0;
// int save1 = 0;
// if (capture) {
// save0 = groups[groupIndex];
// save1 = groups[groupIndex+1];
// }
// for (;;) {
// if (j >= cmax)
// break;
// if (!atom.match(matcher, i, seq))
// break;
// int k = matcher.last - i;
// if (k <= 0) {
// if (capture) {
// groups[groupIndex] = i;
// groups[groupIndex+1] = i + k;
// }
// i = i + k;
// break;
// }
// for (;;) {
// if (capture) {
// groups[groupIndex] = i;
// groups[groupIndex+1] = i + k;
// }
// i = i + k;
// if (++j >= cmax)
// break;
// if (!atom.match(matcher, i, seq))
// break;
// if (i + k != matcher.last) {
// if (match0(matcher, i, j, seq))
// return true;
// break;
// }
// }
// while (j > min) {
// if (next.match(matcher, i, seq)) {
// if (capture) {
// groups[groupIndex+1] = i;
// groups[groupIndex] = i - k;
// }
// return true;
// }
// // backing off
// i = i - k;
// if (capture) {
// groups[groupIndex+1] = i;
// groups[groupIndex] = i - k;
// }
// j--;
// }
// break;
// }
// if (capture) {
// groups[groupIndex] = save0;
// groups[groupIndex+1] = save1;
// }
// return next.match(matcher, i, seq);
// }
// // Reluctant matching
// boolean match1(Matcher matcher, int i, int j, CharSequence seq) {
// for (;;) {
// if (next.match(matcher, i, seq))
// return true;
// if (j >= cmax)
// return false;
// if (!atom.match(matcher, i, seq))
// return false;
// if (i == matcher.last)
// return false;
// if (capture) {
// matcher.groups[groupIndex] = i;
// matcher.groups[groupIndex+1] = matcher.last;
// }
// i = matcher.last;
// j++;
// }
// }
// // Possessive matching
// boolean match2(Matcher matcher, int i, int j, CharSequence seq) {
// for (; j < cmax; j++) {
// if (!atom.match(matcher, i, seq)) {
// break;
// }
// if (capture) {
// matcher.groups[groupIndex] = i;
// matcher.groups[groupIndex+1] = matcher.last;
// }
// if (i == matcher.last) {
// break;
// }
// i = matcher.last;
// }
// return next.match(matcher, i, seq);
// }
// boolean study(TreeInfo info) {
// // Save original info
// int minL = info.minLength;
// int maxL = info.maxLength;
// boolean maxV = info.maxValid;
// boolean detm = info.deterministic;
// info.reset();
// atom.study(info);
// int temp = info.minLength * cmin + minL;
// if (temp < minL) {
// temp = 0xFFFFFFF; // Arbitrary large number
// }
// info.minLength = temp;
// if (maxV & info.maxValid) {
// temp = info.maxLength * cmax + maxL;
// info.maxLength = temp;
// if (temp < maxL) {
// info.maxValid = false;
// }
// } else {
// info.maxValid = false;
// }
// if (info.deterministic && cmin == cmax) {
// info.deterministic = detm;
// } else {
// info.deterministic = false;
// }
// return next.study(info);
// }
// }
/**
* A Guard node at the end of each atom node in a Branch. It
* serves the purpose of chaining the "match" operation to
* "next" but not the "study", so we can collect the TreeInfo
* of each atom node without including the TreeInfo of the
* "next".
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class BranchConn extends Node {
// BranchConn() {};
// boolean match(Matcher matcher, int i, CharSequence seq) {
// return next.match(matcher, i, seq);
// }
// boolean study(TreeInfo info) {
// return info.deterministic;
// }
// }
/**
* Handles the branching of alternations. Note this is also used for
* the ? quantifier to branch between the case where it matches once
* and where it does not occur.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Branch extends Node {
// Node[] atoms = new Node[2];
// int size = 2;
// Node conn;
// Branch(Node first, Node second, Node branchConn) {
// conn = branchConn;
// atoms[0] = first;
// atoms[1] = second;
// }
// void add(Node node) {
// if (size >= atoms.length) {
// Node[] tmp = new Node[atoms.length*2];
// System.arraycopy(atoms, 0, tmp, 0, atoms.length);
// atoms = tmp;
// }
// atoms[size++] = node;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// for (int n = 0; n < size; n++) {
// if (atoms[n] == null) {
// if (conn.next.match(matcher, i, seq))
// return true;
// } else if (atoms[n].match(matcher, i, seq)) {
// return true;
// }
// }
// return false;
// }
// boolean study(TreeInfo info) {
// int minL = info.minLength;
// int maxL = info.maxLength;
// boolean maxV = info.maxValid;
// int minL2 = Integer.MAX_VALUE; //arbitrary large enough num
// int maxL2 = -1;
// for (int n = 0; n < size; n++) {
// info.reset();
// if (atoms[n] != null)
// atoms[n].study(info);
// minL2 = Math.min(minL2, info.minLength);
// maxL2 = Math.max(maxL2, info.maxLength);
// maxV = (maxV & info.maxValid);
// }
// minL += minL2;
// maxL += maxL2;
// info.reset();
// conn.next.study(info);
// info.minLength += minL;
// info.maxLength += maxL;
// info.maxValid &= maxV;
// info.deterministic = false;
// return false;
// }
// }
/**
* The GroupHead saves the location where the group begins in the locals
* and restores them when the match is done.
*
* The matchRef is used when a reference to this group is accessed later
* in the expression. The locals will have a negative value in them to
* indicate that we do not want to unset the group if the reference
* doesn't match.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class GroupHead extends Node {
// int localIndex;
// GroupHead(int localCount) {
// localIndex = localCount;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int save = matcher.locals[localIndex];
// matcher.locals[localIndex] = i;
// boolean ret = next.match(matcher, i, seq);
// matcher.locals[localIndex] = save;
// return ret;
// }
// boolean matchRef(Matcher matcher, int i, CharSequence seq) {
// int save = matcher.locals[localIndex];
// matcher.locals[localIndex] = ~i; // HACK
// boolean ret = next.match(matcher, i, seq);
// matcher.locals[localIndex] = save;
// return ret;
// }
// }
/**
* Recursive reference to a group in the regular expression. It calls
* matchRef because if the reference fails to match we would not unset
* the group.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class GroupRef extends Node {
// GroupHead head;
// GroupRef(GroupHead head) {
// this.head = head;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// return head.matchRef(matcher, i, seq)
// && next.match(matcher, matcher.last, seq);
// }
// boolean study(TreeInfo info) {
// info.maxValid = false;
// info.deterministic = false;
// return next.study(info);
// }
// }
/**
* The GroupTail handles the setting of group beginning and ending
* locations when groups are successfully matched. It must also be able to
* unset groups that have to be backed off of.
*
* The GroupTail node is also used when a previous group is referenced,
* and in that case no group information needs to be set.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class GroupTail extends Node {
// int localIndex;
// int groupIndex;
// GroupTail(int localCount, int groupCount) {
// localIndex = localCount;
// groupIndex = groupCount + groupCount;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int tmp = matcher.locals[localIndex];
// if (tmp >= 0) { // This is the normal group case.
// // Save the group so we can unset it if it
// // backs off of a match.
// int groupStart = matcher.groups[groupIndex];
// int groupEnd = matcher.groups[groupIndex+1];
// matcher.groups[groupIndex] = tmp;
// matcher.groups[groupIndex+1] = i;
// if (next.match(matcher, i, seq)) {
// return true;
// }
// matcher.groups[groupIndex] = groupStart;
// matcher.groups[groupIndex+1] = groupEnd;
// return false;
// } else {
// // This is a group reference case. We don't need to save any
// // group info because it isn't really a group.
// matcher.last = i;
// return true;
// }
// }
// }
/**
* This sets up a loop to handle a recursive quantifier structure.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Prolog extends Node {
// Loop loop;
// Prolog(Loop loop) {
// this.loop = loop;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// return loop.matchInit(matcher, i, seq);
// }
// boolean study(TreeInfo info) {
// return loop.study(info);
// }
// }
/**
* Handles the repetition count for a greedy Curly. The matchInit
* is called from the Prolog to save the index of where the group
* beginning is stored. A zero length group check occurs in the
* normal match but is skipped in the matchInit.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class Loop extends Node {
// Node body;
// int countIndex; // local count index in matcher locals
// int beginIndex; // group beginning index
// int cmin, cmax;
// Loop(int countIndex, int beginIndex) {
// this.countIndex = countIndex;
// this.beginIndex = beginIndex;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// // Avoid infinite loop in zero-length case.
// if (i > matcher.locals[beginIndex]) {
// int count = matcher.locals[countIndex];
// // This block is for before we reach the minimum
// // iterations required for the loop to match
// if (count < cmin) {
// matcher.locals[countIndex] = count + 1;
// boolean b = body.match(matcher, i, seq);
// // If match failed we must backtrack, so
// // the loop count should NOT be incremented
// if (!b)
// matcher.locals[countIndex] = count;
// // Return success or failure since we are under
// // minimum
// return b;
// }
// // This block is for after we have the minimum
// // iterations required for the loop to match
// if (count < cmax) {
// matcher.locals[countIndex] = count + 1;
// boolean b = body.match(matcher, i, seq);
// // If match failed we must backtrack, so
// // the loop count should NOT be incremented
// if (!b)
// matcher.locals[countIndex] = count;
// else
// return true;
// }
// }
// return next.match(matcher, i, seq);
// }
// boolean matchInit(Matcher matcher, int i, CharSequence seq) {
// int save = matcher.locals[countIndex];
// boolean ret = false;
// if (0 < cmin) {
// matcher.locals[countIndex] = 1;
// ret = body.match(matcher, i, seq);
// } else if (0 < cmax) {
// matcher.locals[countIndex] = 1;
// ret = body.match(matcher, i, seq);
// if (ret == false)
// ret = next.match(matcher, i, seq);
// } else {
// ret = next.match(matcher, i, seq);
// }
// matcher.locals[countIndex] = save;
// return ret;
// }
// boolean study(TreeInfo info) {
// info.maxValid = false;
// info.deterministic = false;
// return false;
// }
// }
/**
* Handles the repetition count for a reluctant Curly. The matchInit
* is called from the Prolog to save the index of where the group
* beginning is stored. A zero length group check occurs in the
* normal match but is skipped in the matchInit.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class LazyLoop extends Loop {
// LazyLoop(int countIndex, int beginIndex) {
// super(countIndex, beginIndex);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// // Check for zero length group
// if (i > matcher.locals[beginIndex]) {
// int count = matcher.locals[countIndex];
// if (count < cmin) {
// matcher.locals[countIndex] = count + 1;
// boolean result = body.match(matcher, i, seq);
// // If match failed we must backtrack, so
// // the loop count should NOT be incremented
// if (!result)
// matcher.locals[countIndex] = count;
// return result;
// }
// if (next.match(matcher, i, seq))
// return true;
// if (count < cmax) {
// matcher.locals[countIndex] = count + 1;
// boolean result = body.match(matcher, i, seq);
// // If match failed we must backtrack, so
// // the loop count should NOT be incremented
// if (!result)
// matcher.locals[countIndex] = count;
// return result;
// }
// return false;
// }
// return next.match(matcher, i, seq);
// }
// boolean matchInit(Matcher matcher, int i, CharSequence seq) {
// int save = matcher.locals[countIndex];
// boolean ret = false;
// if (0 < cmin) {
// matcher.locals[countIndex] = 1;
// ret = body.match(matcher, i, seq);
// } else if (next.match(matcher, i, seq)) {
// ret = true;
// } else if (0 < cmax) {
// matcher.locals[countIndex] = 1;
// ret = body.match(matcher, i, seq);
// }
// matcher.locals[countIndex] = save;
// return ret;
// }
// boolean study(TreeInfo info) {
// info.maxValid = false;
// info.deterministic = false;
// return false;
// }
// }
/**
* Refers to a group in the regular expression. Attempts to match
* whatever the group referred to last matched.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class BackRef extends Node {
// int groupIndex;
// BackRef(int groupCount) {
// super();
// groupIndex = groupCount + groupCount;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int j = matcher.groups[groupIndex];
// int k = matcher.groups[groupIndex+1];
// int groupSize = k - j;
// // If the referenced group didn't match, neither can this
// if (j < 0)
// return false;
// // If there isn't enough input left no match
// if (i + groupSize > matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// // Check each new char to make sure it matches what the group
// // referenced matched last time around
// for (int index=0; index matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// // Check each new char to make sure it matches what the group
// // referenced matched last time around
// int x = i;
// for (int index=0; index matcher.to) {
// matcher.hitEnd = true;
// return false;
// }
// if (atom.match(matcher, i, seq)) {
// return next.match(matcher, matcher.last, seq);
// }
// i += countChars(seq, i, 1);
// matcher.first++;
// }
// }
// boolean study(TreeInfo info) {
// atom.study(info);
// info.maxValid = false;
// info.deterministic = false;
// return next.study(info);
// }
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Conditional extends Node {
// Node cond, yes, not;
// Conditional(Node cond, Node yes, Node not) {
// this.cond = cond;
// this.yes = yes;
// this.not = not;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// if (cond.match(matcher, i, seq)) {
// return yes.match(matcher, i, seq);
// } else {
// return not.match(matcher, i, seq);
// }
// }
// boolean study(TreeInfo info) {
// int minL = info.minLength;
// int maxL = info.maxLength;
// boolean maxV = info.maxValid;
// info.reset();
// yes.study(info);
// int minL2 = info.minLength;
// int maxL2 = info.maxLength;
// boolean maxV2 = info.maxValid;
// info.reset();
// not.study(info);
// info.minLength = minL + Math.min(minL2, info.minLength);
// info.maxLength = maxL + Math.max(maxL2, info.maxLength);
// info.maxValid = (maxV & maxV2 & info.maxValid);
// info.deterministic = false;
// return next.study(info);
// }
// }
/**
* Zero width positive lookahead.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Pos extends Node {
// Node cond;
// Pos(Node cond) {
// this.cond = cond;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int savedTo = matcher.to;
// boolean conditionMatched = false;
// // Relax transparent region boundaries for lookahead
// if (matcher.transparentBounds)
// matcher.to = matcher.getTextLength();
// try {
// conditionMatched = cond.match(matcher, i, seq);
// } finally {
// // Reinstate region boundaries
// matcher.to = savedTo;
// }
// return conditionMatched && next.match(matcher, i, seq);
// }
// }
/**
* Zero width negative lookahead.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Neg extends Node {
// Node cond;
// Neg(Node cond) {
// this.cond = cond;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int savedTo = matcher.to;
// boolean conditionMatched = false;
// // Relax transparent region boundaries for lookahead
// if (matcher.transparentBounds)
// matcher.to = matcher.getTextLength();
// try {
// if (i < matcher.to) {
// conditionMatched = !cond.match(matcher, i, seq);
// } else {
// // If a negative lookahead succeeds then more input
// // could cause it to fail!
// matcher.requireEnd = true;
// conditionMatched = !cond.match(matcher, i, seq);
// }
// } finally {
// // Reinstate region boundaries
// matcher.to = savedTo;
// }
// return conditionMatched && next.match(matcher, i, seq);
// }
// }
/**
* For use with lookbehinds; matches the position where the lookbehind
* was encountered.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static Node lookbehindEnd = new Node() {
// boolean match(Matcher matcher, int i, CharSequence seq) {
// return i == matcher.lookbehindTo;
// }
// DIFFBLUE MODEL LIBRARY - not used in model
// };
/**
* Zero width positive lookbehind.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class Behind extends Node {
// Node cond;
// int rmax, rmin;
// Behind(Node cond, int rmax, int rmin) {
// this.cond = cond;
// this.rmax = rmax;
// this.rmin = rmin;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int savedFrom = matcher.from;
// boolean conditionMatched = false;
// int startIndex = (!matcher.transparentBounds) ?
// matcher.from : 0;
// int from = Math.max(i - rmax, startIndex);
// // Set end boundary
// int savedLBT = matcher.lookbehindTo;
// matcher.lookbehindTo = i;
// // Relax transparent region boundaries for lookbehind
// if (matcher.transparentBounds)
// matcher.from = 0;
// for (int j = i - rmin; !conditionMatched && j >= from; j--) {
// conditionMatched = cond.match(matcher, j, seq);
// }
// matcher.from = savedFrom;
// matcher.lookbehindTo = savedLBT;
// return conditionMatched && next.match(matcher, i, seq);
// }
// }
/**
* Zero width positive lookbehind, including supplementary
* characters or unpaired surrogates.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class BehindS extends Behind {
// BehindS(Node cond, int rmax, int rmin) {
// super(cond, rmax, rmin);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int rmaxChars = countChars(seq, i, -rmax);
// int rminChars = countChars(seq, i, -rmin);
// int savedFrom = matcher.from;
// int startIndex = (!matcher.transparentBounds) ?
// matcher.from : 0;
// boolean conditionMatched = false;
// int from = Math.max(i - rmaxChars, startIndex);
// // Set end boundary
// int savedLBT = matcher.lookbehindTo;
// matcher.lookbehindTo = i;
// // Relax transparent region boundaries for lookbehind
// if (matcher.transparentBounds)
// matcher.from = 0;
// for (int j = i - rminChars;
// !conditionMatched && j >= from;
// j -= j>from ? countChars(seq, j, -1) : 1) {
// conditionMatched = cond.match(matcher, j, seq);
// }
// matcher.from = savedFrom;
// matcher.lookbehindTo = savedLBT;
// return conditionMatched && next.match(matcher, i, seq);
// }
// }
/**
* Zero width negative lookbehind.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class NotBehind extends Node {
// Node cond;
// int rmax, rmin;
// NotBehind(Node cond, int rmax, int rmin) {
// this.cond = cond;
// this.rmax = rmax;
// this.rmin = rmin;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int savedLBT = matcher.lookbehindTo;
// int savedFrom = matcher.from;
// boolean conditionMatched = false;
// int startIndex = (!matcher.transparentBounds) ?
// matcher.from : 0;
// int from = Math.max(i - rmax, startIndex);
// matcher.lookbehindTo = i;
// // Relax transparent region boundaries for lookbehind
// if (matcher.transparentBounds)
// matcher.from = 0;
// for (int j = i - rmin; !conditionMatched && j >= from; j--) {
// conditionMatched = cond.match(matcher, j, seq);
// }
// // Reinstate region boundaries
// matcher.from = savedFrom;
// matcher.lookbehindTo = savedLBT;
// return !conditionMatched && next.match(matcher, i, seq);
// }
// }
/**
* Zero width negative lookbehind, including supplementary
* characters or unpaired surrogates.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class NotBehindS extends NotBehind {
// NotBehindS(Node cond, int rmax, int rmin) {
// super(cond, rmax, rmin);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int rmaxChars = countChars(seq, i, -rmax);
// int rminChars = countChars(seq, i, -rmin);
// int savedFrom = matcher.from;
// int savedLBT = matcher.lookbehindTo;
// boolean conditionMatched = false;
// int startIndex = (!matcher.transparentBounds) ?
// matcher.from : 0;
// int from = Math.max(i - rmaxChars, startIndex);
// matcher.lookbehindTo = i;
// // Relax transparent region boundaries for lookbehind
// if (matcher.transparentBounds)
// matcher.from = 0;
// for (int j = i - rminChars;
// !conditionMatched && j >= from;
// j -= j>from ? countChars(seq, j, -1) : 1) {
// conditionMatched = cond.match(matcher, j, seq);
// }
// //Reinstate region boundaries
// matcher.from = savedFrom;
// matcher.lookbehindTo = savedLBT;
// return !conditionMatched && next.match(matcher, i, seq);
// }
// }
/**
* Returns the set union of two CharProperty nodes.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static CharProperty union(final CharProperty lhs,
// final CharProperty rhs) {
// return new CharProperty() {
// boolean isSatisfiedBy(int ch) {
// return lhs.isSatisfiedBy(ch) || rhs.isSatisfiedBy(ch);}};
// }
/**
* Returns the set intersection of two CharProperty nodes.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static CharProperty intersection(final CharProperty lhs,
// final CharProperty rhs) {
// return new CharProperty() {
// boolean isSatisfiedBy(int ch) {
// return lhs.isSatisfiedBy(ch) && rhs.isSatisfiedBy(ch);}};
// }
/**
* Returns the set difference of two CharProperty nodes.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static CharProperty setDifference(final CharProperty lhs,
// final CharProperty rhs) {
// return new CharProperty() {
// boolean isSatisfiedBy(int ch) {
// return ! rhs.isSatisfiedBy(ch) && lhs.isSatisfiedBy(ch);}};
// }
/**
* Handles word boundaries. Includes a field to allow this one class to
* deal with the different types of word boundaries we can match. The word
* characters include underscores, letters, and digits. Non spacing marks
* can are also part of a word if they have a base character, otherwise
* they are ignored for purposes of finding word boundaries.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class Bound extends Node {
// static int LEFT = 0x1;
// static int RIGHT= 0x2;
// static int BOTH = 0x3;
// static int NONE = 0x4;
// int type;
// boolean useUWORD;
// Bound(int n, boolean useUWORD) {
// type = n;
// this.useUWORD = useUWORD;
// }
// boolean isWord(int ch) {
// return useUWORD ? UnicodeProp.WORD.is(ch)
// : (ch == '_' || Character.isLetterOrDigit(ch));
// }
// int check(Matcher matcher, int i, CharSequence seq) {
// int ch;
// boolean left = false;
// int startIndex = matcher.from;
// int endIndex = matcher.to;
// if (matcher.transparentBounds) {
// startIndex = 0;
// endIndex = matcher.getTextLength();
// }
// if (i > startIndex) {
// ch = Character.codePointBefore(seq, i);
// left = (isWord(ch) ||
// ((Character.getType(ch) == Character.NON_SPACING_MARK)
// && hasBaseCharacter(matcher, i-1, seq)));
// }
// boolean right = false;
// if (i < endIndex) {
// ch = Character.codePointAt(seq, i);
// right = (isWord(ch) ||
// ((Character.getType(ch) == Character.NON_SPACING_MARK)
// && hasBaseCharacter(matcher, i, seq)));
// } else {
// // Tried to access char past the end
// matcher.hitEnd = true;
// // The addition of another char could wreck a boundary
// matcher.requireEnd = true;
// }
// return ((left ^ right) ? (right ? LEFT : RIGHT) : NONE);
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// return (check(matcher, i, seq) & type) > 0
// && next.match(matcher, i, seq);
// }
// }
/**
* Non spacing marks only count as word characters in bounds calculations
* if they have a base character.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// private static boolean hasBaseCharacter(Matcher matcher, int i,
// CharSequence seq)
// {
// int start = (!matcher.transparentBounds) ?
// matcher.from : 0;
// for (int x=i; x >= start; x--) {
// int ch = Character.codePointAt(seq, x);
// if (Character.isLetterOrDigit(ch))
// return true;
// if (Character.getType(ch) == Character.NON_SPACING_MARK)
// continue;
// return false;
// }
// return false;
// }
/**
* Attempts to match a slice in the input using the Boyer-Moore string
* matching algorithm. The algorithm is based on the idea that the
* pattern can be shifted farther ahead in the search text if it is
* matched right to left.
*
* The pattern is compared to the input one character at a time, from
* the rightmost character in the pattern to the left. If the characters
* all match the pattern has been found. If a character does not match,
* the pattern is shifted right a distance that is the maximum of two
* functions, the bad character shift and the good suffix shift. This
* shift moves the attempted match position through the input more
* quickly than a naive one position at a time check.
*
* The bad character shift is based on the character from the text that
* did not match. If the character does not appear in the pattern, the
* pattern can be shifted completely beyond the bad character. If the
* character does occur in the pattern, the pattern can be shifted to
* line the pattern up with the next occurrence of that character.
*
* The good suffix shift is based on the idea that some subset on the right
* side of the pattern has matched. When a bad character is found, the
* pattern can be shifted right by the pattern length if the subset does
* not occur again in pattern, or by the amount of distance to the
* next occurrence of the subset in the pattern.
*
* Boyer-Moore search methods adapted from code by Amy Yu.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static class BnM extends Node {
// int[] buffer;
// int[] lastOcc;
// int[] optoSft;
// /**
// * Pre calculates arrays needed to generate the bad character
// * shift and the good suffix shift. Only the last seven bits
// * are used to see if chars match; This keeps the tables small
// * and covers the heavily used ASCII range, but occasionally
// * results in an aliased match for the bad character shift.
// */
// static Node optimize(Node node) {
// if (!(node instanceof Slice)) {
// return node;
// }
// int[] src = ((Slice) node).buffer;
// int patternLength = src.length;
// // The BM algorithm requires a bit of overhead;
// // If the pattern is short don't use it, since
// // a shift larger than the pattern length cannot
// // be used anyway.
// if (patternLength < 4) {
// return node;
// }
// int i, j, k;
// int[] lastOcc = new int[128];
// int[] optoSft = new int[patternLength];
// // Precalculate part of the bad character shift
// // It is a table for where in the pattern each
// // lower 7-bit value occurs
// for (i = 0; i < patternLength; i++) {
// lastOcc[src[i]&0x7F] = i + 1;
// }
// // Precalculate the good suffix shift
// // i is the shift amount being considered
// NEXT: for (i = patternLength; i > 0; i--) {
// // j is the beginning index of suffix being considered
// for (j = patternLength - 1; j >= i; j--) {
// // Testing for good suffix
// if (src[j] == src[j-i]) {
// // src[j..len] is a good suffix
// optoSft[j-1] = i;
// } else {
// // No match. The array has already been
// // filled up with correct values before.
// continue NEXT;
// }
// }
// // This fills up the remaining of optoSft
// // any suffix can not have larger shift amount
// // then its sub-suffix. Why???
// while (j > 0) {
// optoSft[--j] = i;
// }
// }
// // Set the guard value because of unicode compression
// optoSft[patternLength-1] = 1;
// if (node instanceof SliceS)
// return new BnMS(src, lastOcc, optoSft, node.next);
// return new BnM(src, lastOcc, optoSft, node.next);
// }
// BnM(int[] src, int[] lastOcc, int[] optoSft, Node next) {
// this.buffer = src;
// this.lastOcc = lastOcc;
// this.optoSft = optoSft;
// this.next = next;
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int[] src = buffer;
// int patternLength = src.length;
// int last = matcher.to - patternLength;
// // Loop over all possible match positions in text
// NEXT: while (i <= last) {
// // Loop over pattern from right to left
// for (int j = patternLength - 1; j >= 0; j--) {
// int ch = seq.charAt(i+j);
// if (ch != src[j]) {
// // Shift search to the right by the maximum of the
// // bad character shift and the good suffix shift
// i += Math.max(j + 1 - lastOcc[ch&0x7F], optoSft[j]);
// continue NEXT;
// }
// }
// // Entire pattern matched starting at i
// matcher.first = i;
// boolean ret = next.match(matcher, i + patternLength, seq);
// if (ret) {
// matcher.first = i;
// matcher.groups[0] = matcher.first;
// matcher.groups[1] = matcher.last;
// return true;
// }
// i++;
// }
// // BnM is only used as the leading node in the unanchored case,
// // and it replaced its Start() which always searches to the end
// // if it doesn't find what it's looking for, so hitEnd is true.
// matcher.hitEnd = true;
// return false;
// }
// boolean study(TreeInfo info) {
// info.minLength += buffer.length;
// info.maxValid = false;
// return next.study(info);
// }
// }
/**
* Supplementary support version of BnM(). Unpaired surrogates are
* also handled by this class.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static final class BnMS extends BnM {
// int lengthInChars;
// BnMS(int[] src, int[] lastOcc, int[] optoSft, Node next) {
// super(src, lastOcc, optoSft, next);
// for (int x = 0; x < buffer.length; x++) {
// lengthInChars += Character.charCount(buffer[x]);
// }
// }
// boolean match(Matcher matcher, int i, CharSequence seq) {
// int[] src = buffer;
// int patternLength = src.length;
// int last = matcher.to - lengthInChars;
// // Loop over all possible match positions in text
// NEXT: while (i <= last) {
// // Loop over pattern from right to left
// int ch;
// for (int j = countChars(seq, i, patternLength), x = patternLength - 1;
// j > 0; j -= Character.charCount(ch), x--) {
// ch = Character.codePointBefore(seq, i+j);
// if (ch != src[x]) {
// // Shift search to the right by the maximum of the
// // bad character shift and the good suffix shift
// int n = Math.max(x + 1 - lastOcc[ch&0x7F], optoSft[x]);
// i += countChars(seq, i, n);
// continue NEXT;
// }
// }
// // Entire pattern matched starting at i
// matcher.first = i;
// boolean ret = next.match(matcher, i + lengthInChars, seq);
// if (ret) {
// matcher.first = i;
// matcher.groups[0] = matcher.first;
// matcher.groups[1] = matcher.last;
// return true;
// }
// i += countChars(seq, i, 1);
// }
// matcher.hitEnd = true;
// return false;
// }
// }
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
/**
* This must be the very first initializer.
*/
// DIFFBLUE MODEL LIBRARY - not used in model
// static Node accept = new Node();
// DIFFBLUE MODEL LIBRARY - not used in model
// static Node lastAccept = new LastNode();
// DIFFBLUE MODEL LIBRARY - not used in model
// private static class CharPropertyNames {
// static CharProperty charPropertyFor(String name) {
// CharPropertyFactory m = map.get(name);
// return m == null ? null : m.make();
// }
// private static abstract class CharPropertyFactory {
// abstract CharProperty make();
// }
// private static void defCategory(String name,
// final int typeMask) {
// map.put(name, new CharPropertyFactory() {
// CharProperty make() { return new Category(typeMask);}});
// }
// private static void defRange(String name,
// final int lower, final int upper) {
// map.put(name, new CharPropertyFactory() {
// CharProperty make() { return rangeFor(lower, upper);}});
// }
// private static void defCtype(String name,
// final int ctype) {
// map.put(name, new CharPropertyFactory() {
// CharProperty make() { return new Ctype(ctype);}});
// }
// private static abstract class CloneableProperty
// extends CharProperty implements Cloneable
// {
// public CloneableProperty clone() {
// try {
// return (CloneableProperty) super.clone();
// } catch (CloneNotSupportedException e) {
// throw new AssertionError(e);
// }
// }
// }
// private static void defClone(String name,
// final CloneableProperty p) {
// map.put(name, new CharPropertyFactory() {
// CharProperty make() { return p.clone();}});
// }
// private static final HashMap map
// = new HashMap<>();
// static {
// // Unicode character property aliases, defined in
// // http://www.unicode.org/Public/UNIDATA/PropertyValueAliases.txt
// defCategory("Cn", 1< asPredicate() {
// return s -> matcher(s).find();
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
/**
* Creates a stream from the given input sequence around matches of this
* pattern.
*
*
The stream returned by this method contains each substring of the
* input sequence that is terminated by another subsequence that matches
* this pattern or is terminated by the end of the input sequence. The
* substrings in the stream are in the order in which they occur in the
* input. Trailing empty strings will be discarded and not encountered in
* the stream.
*
*
If this pattern does not match any subsequence of the input then
* the resulting stream has just one element, namely the input sequence in
* string form.
*
*
When there is a positive-width match at the beginning of the input
* sequence then an empty leading substring is included at the beginning
* of the stream. A zero-width match at the beginning however never produces
* such empty leading substring.
*
*
If the input sequence is mutable, it must remain constant during the
* execution of the terminal stream operation. Otherwise, the result of the
* terminal stream operation is undefined.
*
* @param input
* The character sequence to be split
*
* @return The stream of strings computed by splitting the input
* around matches of this pattern
* @see #split(CharSequence)
* @since 1.8
*
* @diffblue.untested
* @diffblue.noSupport
*/
public Stream splitAsStream(final CharSequence input) {
// class MatcherIterator implements Iterator {
// private final Matcher matcher;
// // The start position of the next sub-sequence of input
// // when current == input.length there are no more elements
// private int current;
// // null if the next element, if any, needs to obtained
// private String nextElement;
// // > 0 if there are N next empty elements
// private int emptyElementCount;
// MatcherIterator() {
// this.matcher = matcher(input);
// }
// public String next() {
// if (!hasNext())
// throw new NoSuchElementException();
// if (emptyElementCount == 0) {
// String n = nextElement;
// nextElement = null;
// return n;
// } else {
// emptyElementCount--;
// return "";
// }
// }
// public boolean hasNext() {
// if (nextElement != null || emptyElementCount > 0)
// return true;
// if (current == input.length())
// return false;
// // Consume the next matching element
// // Count sequence of matching empty elements
// while (matcher.find()) {
// nextElement = input.subSequence(current, matcher.start()).toString();
// current = matcher.end();
// if (!nextElement.isEmpty()) {
// return true;
// } else if (current > 0) { // no empty leading substring for zero-width
// // match at the beginning of the input
// emptyElementCount++;
// }
// }
// // Consume last matching element
// nextElement = input.subSequence(current, input.length()).toString();
// current = input.length();
// if (!nextElement.isEmpty()) {
// return true;
// } else {
// // Ignore a terminal sequence of matching empty elements
// emptyElementCount = 0;
// nextElement = null;
// return false;
// }
// }
// }
// return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
// new MatcherIterator(), Spliterator.ORDERED | Spliterator.NONNULL), false);
CProver.notModelled();
return CProver.nondetWithoutNullForNotModelled();
}
}
java-models-library-master/src/main/java/org/ 0000775 0000000 0000000 00000000000 14323475213 0021442 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/org/sosy_lab/ 0000775 0000000 0000000 00000000000 14323475213 0023255 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/org/sosy_lab/sv_benchmarks/ 0000775 0000000 0000000 00000000000 14323475213 0026102 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/org/sosy_lab/sv_benchmarks/Verifier.java 0000664 0000000 0000000 00000002737 14323475213 0030531 0 ustar 00root root 0000000 0000000 /*
* Contributed by Peter Schrammel
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.sosy_lab.sv_benchmarks;
import org.cprover.CProver;
public final class Verifier
{
public static void assume(boolean condition)
{
CProver.assume(condition);
}
public static boolean nondetBoolean()
{
return CProver.nondetBoolean();
}
public static byte nondetByte()
{
return CProver.nondetByte();
}
public static char nondetChar()
{
return CProver.nondetChar();
}
public static short nondetShort()
{
return CProver.nondetShort();
}
public static int nondetInt()
{
return CProver.nondetInt();
}
public static long nondetLong()
{
return CProver.nondetLong();
}
public static float nondetFloat()
{
return CProver.nondetFloat();
}
public static double nondetDouble()
{
return CProver.nondetDouble();
}
public static String nondetString()
{
return CProver.nondetWithoutNull("");
}
}
java-models-library-master/src/main/java/sun/ 0000775 0000000 0000000 00000000000 14323475213 0021460 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/sun/misc/ 0000775 0000000 0000000 00000000000 14323475213 0022413 5 ustar 00root root 0000000 0000000 java-models-library-master/src/main/java/sun/misc/DoubleConsts.java 0000664 0000000 0000000 00000010261 14323475213 0025662 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 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 sun.misc;
/**
* This class contains additional constants documenting limits of the
* double type.
*
* @author Joseph D. Darcy
*/
public class DoubleConsts {
/**
* Don't let anyone instantiate this class.
*/
private DoubleConsts() {}
public static final double POSITIVE_INFINITY = java.lang.Double.POSITIVE_INFINITY;
public static final double NEGATIVE_INFINITY = java.lang.Double.NEGATIVE_INFINITY;
public static final double NaN = java.lang.Double.NaN;
public static final double MAX_VALUE = java.lang.Double.MAX_VALUE;
public static final double MIN_VALUE = java.lang.Double.MIN_VALUE;
/**
* A constant holding the smallest positive normal value of type
* double, 2-1022. It is equal to the
* value returned by
* Double.longBitsToDouble(0x0010000000000000L).
*
* @since 1.5
*/
public static final double MIN_NORMAL = 2.2250738585072014E-308;
/**
* The number of logical bits in the significand of a
* double number, including the implicit bit.
*/
public static final int SIGNIFICAND_WIDTH = 53;
/**
* Maximum exponent a finite double number may have.
* It is equal to the value returned by
* Math.ilogb(Double.MAX_VALUE).
*/
public static final int MAX_EXPONENT = 1023;
/**
* Minimum exponent a normalized double number may
* have. It is equal to the value returned by
* Math.ilogb(Double.MIN_NORMAL).
*/
public static final int MIN_EXPONENT = -1022;
/**
* The exponent the smallest positive double
* subnormal value would have if it could be normalized. It is
* equal to the value returned by
* FpUtils.ilogb(Double.MIN_VALUE).
*/
public static final int MIN_SUB_EXPONENT = MIN_EXPONENT -
(SIGNIFICAND_WIDTH - 1);
/**
* Bias used in representing a double exponent.
*/
public static final int EXP_BIAS = 1023;
/**
* Bit mask to isolate the sign bit of a double.
*/
public static final long SIGN_BIT_MASK = 0x8000000000000000L;
/**
* Bit mask to isolate the exponent field of a
* double.
*/
public static final long EXP_BIT_MASK = 0x7FF0000000000000L;
/**
* Bit mask to isolate the significand field of a
* double.
*/
public static final long SIGNIF_BIT_MASK = 0x000FFFFFFFFFFFFFL;
static {
// verify bit masks cover all bit positions and that the bit
// masks are non-overlapping
assert(((SIGN_BIT_MASK | EXP_BIT_MASK | SIGNIF_BIT_MASK) == ~0L) &&
(((SIGN_BIT_MASK & EXP_BIT_MASK) == 0L) &&
((SIGN_BIT_MASK & SIGNIF_BIT_MASK) == 0L) &&
((EXP_BIT_MASK & SIGNIF_BIT_MASK) == 0L)));
}
}
java-models-library-master/src/main/java/sun/misc/FloatConsts.java 0000664 0000000 0000000 00000010071 14323475213 0025514 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 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 sun.misc;
/**
* This class contains additional constants documenting limits of the
* float type.
*
* @author Joseph D. Darcy
*/
public class FloatConsts {
/**
* Don't let anyone instantiate this class.
*/
private FloatConsts() {}
public static final float POSITIVE_INFINITY = java.lang.Float.POSITIVE_INFINITY;
public static final float NEGATIVE_INFINITY = java.lang.Float.NEGATIVE_INFINITY;
public static final float NaN = java.lang.Float.NaN;
public static final float MAX_VALUE = java.lang.Float.MAX_VALUE;
public static final float MIN_VALUE = java.lang.Float.MIN_VALUE;
/**
* A constant holding the smallest positive normal value of type
* float, 2-126. It is equal to the value
* returned by Float.intBitsToFloat(0x00800000).
*/
public static final float MIN_NORMAL = 1.17549435E-38f;
/**
* The number of logical bits in the significand of a
* float number, including the implicit bit.
*/
public static final int SIGNIFICAND_WIDTH = 24;
/**
* Maximum exponent a finite float number may have.
* It is equal to the value returned by
* Math.ilogb(Float.MAX_VALUE).
*/
public static final int MAX_EXPONENT = 127;
/**
* Minimum exponent a normalized float number may
* have. It is equal to the value returned by
* Math.ilogb(Float.MIN_NORMAL).
*/
public static final int MIN_EXPONENT = -126;
/**
* The exponent the smallest positive float subnormal
* value would have if it could be normalized. It is equal to the
* value returned by FpUtils.ilogb(Float.MIN_VALUE).
*/
public static final int MIN_SUB_EXPONENT = MIN_EXPONENT -
(SIGNIFICAND_WIDTH - 1);
/**
* Bias used in representing a float exponent.
*/
public static final int EXP_BIAS = 127;
/**
* Bit mask to isolate the sign bit of a float.
*/
public static final int SIGN_BIT_MASK = 0x80000000;
/**
* Bit mask to isolate the exponent field of a
* float.
*/
public static final int EXP_BIT_MASK = 0x7F800000;
/**
* Bit mask to isolate the significand field of a
* float.
*/
public static final int SIGNIF_BIT_MASK = 0x007FFFFF;
static {
// verify bit masks cover all bit positions and that the bit
// masks are non-overlapping
assert(((SIGN_BIT_MASK | EXP_BIT_MASK | SIGNIF_BIT_MASK) == ~0) &&
(((SIGN_BIT_MASK & EXP_BIT_MASK) == 0) &&
((SIGN_BIT_MASK & SIGNIF_BIT_MASK) == 0) &&
((EXP_BIT_MASK & SIGNIF_BIT_MASK) == 0)));
}
}
* 
* 
* 
* 