pax_global_header00006660000000000000000000000064133303653400014512gustar00rootroot0000000000000052 comment=c86885cfd2e8cf98947132de15bcfa3835ae3ebc java-models-library-master/000077500000000000000000000000001333036534000162135ustar00rootroot00000000000000java-models-library-master/.gitignore000066400000000000000000000000441333036534000202010ustar00rootroot00000000000000target *.txt *.d *.o *.a /.project java-models-library-master/.travis.yml000066400000000000000000000002601333036534000203220ustar00rootroot00000000000000language: java script: - mvn package notifications: webhooks: on_success: always on_failure: always on_start: never on_cancel: never on_error: always java-models-library-master/OpenJDK GPLv2 + Classpath Exception.txt000066400000000000000000000406511333036534000250640ustar00rootroot00000000000000GNU 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.md000066400000000000000000000004171333036534000174740ustar00rootroot00000000000000Java 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.xml000066400000000000000000000055611333036534000175370ustar00rootroot00000000000000 4.0.0 org.cprover.models models 1.0-SNAPSHOT jar UTF-8 CProver JDK Models java8-doclint-disabled [1.8,) -Xdoclint:none core-models org.apache.maven.plugins maven-compiler-plugin 3.6.1 ${java.home}/lib/rt.jar 1.8 1.8 org.apache.maven.plugins maven-javadoc-plugin 3.0.0-M1 doc true true src/main/java java src/main/overview.html Diffblue Library of Models Diffblue Library of Models diffblue.fullSupport ptcm DIFFBLUE: Full support diffblue.limitedSupport ptcm DIFFBLUE: Limited support diffblue.noSupport ptcm DIFFBLUE: No support diffblue.untested ptcm DIFFBLUE: Untested diffblue.todo ptcm DIFFBLUE: To do ${javadoc.opts} java-models-library-master/src/000077500000000000000000000000001333036534000170025ustar00rootroot00000000000000java-models-library-master/src/main/000077500000000000000000000000001333036534000177265ustar00rootroot00000000000000java-models-library-master/src/main/java/000077500000000000000000000000001333036534000206475ustar00rootroot00000000000000java-models-library-master/src/main/java/java/000077500000000000000000000000001333036534000215705ustar00rootroot00000000000000java-models-library-master/src/main/java/java/lang/000077500000000000000000000000001333036534000225115ustar00rootroot00000000000000java-models-library-master/src/main/java/java/lang/AbstractMethodError.java000066400000000000000000000047221333036534000272770ustar00rootroot00000000000000/* * 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/ArithmeticException.java000066400000000000000000000035771333036534000273400ustar00rootroot00000000000000/* * 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.java000066400000000000000000000040671333036534000314400ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036001333036534000273250ustar00rootroot00000000000000/* * 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.java000066400000000000000000000147321333036534000263440ustar00rootroot00000000000000/* * 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/BootstrapMethodError.java000066400000000000000000000062131333036534000275060ustar00rootroot00000000000000/* * 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/CharSequence.java000066400000000000000000000214111333036534000257210ustar00rootroot00000000000000/* * 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.java000066400000000000000000010113171333036534000252540ustar00rootroot00000000000000/* * 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 org.cprover.CProver; import java.util.Arrays; import java.util.Map; import java.util.HashMap; import java.util.Locale; /** * The {@code Character} class wraps a value of the primitive * type {@code char} in an object. An object of type * {@code Character} contains a single field whose type is * {@code char}. *

* 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: *

* *

Unicode Character Representations

* *

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: * *

* *

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: *

    *
  1. 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. *
  2. Canonical block names with all spaces removed. For example, "BasicLatin" * is a valid block name for the "Basic Latin" block. *
  3. 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. *

* If the Unicode Standard changes block names, both the previous and * current names will be accepted. * * @param blockName A {@code UnicodeBlock} name. * @return The {@code UnicodeBlock} instance identified * by {@code blockName} * @throws IllegalArgumentException if {@code blockName} is an * invalid name * @throws NullPointerException if {@code blockName} is null * @since 1.5 */ public static final UnicodeBlock forName(String blockName) { UnicodeBlock block = map.get(blockName.toUpperCase(Locale.US)); if (block == null) { throw new IllegalArgumentException(); } return block; } } /** * A family of character subsets representing the character scripts * defined in the * Unicode Standard Annex #24: Script Names. Every Unicode * character is assigned to a single Unicode script, either a specific * script, such as {@link Character.UnicodeScript#LATIN Latin}, or * one of the following three special values, * {@link Character.UnicodeScript#INHERITED Inherited}, * {@link Character.UnicodeScript#COMMON Common} or * {@link Character.UnicodeScript#UNKNOWN Unknown}. * * @since 1.7 */ public static enum UnicodeScript { /** * Unicode script "Common". */ COMMON, /** * Unicode script "Latin". */ LATIN, /** * Unicode script "Greek". */ GREEK, /** * Unicode script "Cyrillic". */ CYRILLIC, /** * Unicode script "Armenian". */ ARMENIAN, /** * Unicode script "Hebrew". */ HEBREW, /** * Unicode script "Arabic". */ ARABIC, /** * Unicode script "Syriac". */ SYRIAC, /** * Unicode script "Thaana". */ THAANA, /** * Unicode script "Devanagari". */ DEVANAGARI, /** * Unicode script "Bengali". */ BENGALI, /** * Unicode script "Gurmukhi". */ GURMUKHI, /** * Unicode script "Gujarati". */ GUJARATI, /** * Unicode script "Oriya". */ ORIYA, /** * Unicode script "Tamil". */ TAMIL, /** * Unicode script "Telugu". */ TELUGU, /** * Unicode script "Kannada". */ KANNADA, /** * Unicode script "Malayalam". */ MALAYALAM, /** * Unicode script "Sinhala". */ SINHALA, /** * Unicode script "Thai". */ THAI, /** * Unicode script "Lao". */ LAO, /** * Unicode script "Tibetan". */ TIBETAN, /** * Unicode script "Myanmar". */ MYANMAR, /** * Unicode script "Georgian". */ GEORGIAN, /** * Unicode script "Hangul". */ HANGUL, /** * Unicode script "Ethiopic". */ ETHIOPIC, /** * Unicode script "Cherokee". */ CHEROKEE, /** * Unicode script "Canadian_Aboriginal". */ CANADIAN_ABORIGINAL, /** * Unicode script "Ogham". */ OGHAM, /** * Unicode script "Runic". */ RUNIC, /** * Unicode script "Khmer". */ KHMER, /** * Unicode script "Mongolian". */ MONGOLIAN, /** * Unicode script "Hiragana". */ HIRAGANA, /** * Unicode script "Katakana". */ KATAKANA, /** * Unicode script "Bopomofo". */ BOPOMOFO, /** * Unicode script "Han". */ HAN, /** * Unicode script "Yi". */ YI, /** * Unicode script "Old_Italic". */ OLD_ITALIC, /** * Unicode script "Gothic". */ GOTHIC, /** * Unicode script "Deseret". */ DESERET, /** * Unicode script "Inherited". */ INHERITED, /** * Unicode script "Tagalog". */ TAGALOG, /** * Unicode script "Hanunoo". */ HANUNOO, /** * Unicode script "Buhid". */ BUHID, /** * Unicode script "Tagbanwa". */ TAGBANWA, /** * Unicode script "Limbu". */ LIMBU, /** * Unicode script "Tai_Le". */ TAI_LE, /** * Unicode script "Linear_B". */ LINEAR_B, /** * Unicode script "Ugaritic". */ UGARITIC, /** * Unicode script "Shavian". */ SHAVIAN, /** * Unicode script "Osmanya". */ OSMANYA, /** * Unicode script "Cypriot". */ CYPRIOT, /** * Unicode script "Braille". */ BRAILLE, /** * Unicode script "Buginese". */ BUGINESE, /** * Unicode script "Coptic". */ COPTIC, /** * Unicode script "New_Tai_Lue". */ NEW_TAI_LUE, /** * Unicode script "Glagolitic". */ GLAGOLITIC, /** * Unicode script "Tifinagh". */ TIFINAGH, /** * Unicode script "Syloti_Nagri". */ SYLOTI_NAGRI, /** * Unicode script "Old_Persian". */ OLD_PERSIAN, /** * Unicode script "Kharoshthi". */ KHAROSHTHI, /** * Unicode script "Balinese". */ BALINESE, /** * Unicode script "Cuneiform". */ CUNEIFORM, /** * Unicode script "Phoenician". */ PHOENICIAN, /** * Unicode script "Phags_Pa". */ PHAGS_PA, /** * Unicode script "Nko". */ NKO, /** * Unicode script "Sundanese". */ SUNDANESE, /** * Unicode script "Batak". */ BATAK, /** * Unicode script "Lepcha". */ LEPCHA, /** * Unicode script "Ol_Chiki". */ OL_CHIKI, /** * Unicode script "Vai". */ VAI, /** * Unicode script "Saurashtra". */ SAURASHTRA, /** * Unicode script "Kayah_Li". */ KAYAH_LI, /** * Unicode script "Rejang". */ REJANG, /** * Unicode script "Lycian". */ LYCIAN, /** * Unicode script "Carian". */ CARIAN, /** * Unicode script "Lydian". */ LYDIAN, /** * Unicode script "Cham". */ CHAM, /** * Unicode script "Tai_Tham". */ TAI_THAM, /** * Unicode script "Tai_Viet". */ TAI_VIET, /** * Unicode script "Avestan". */ AVESTAN, /** * Unicode script "Egyptian_Hieroglyphs". */ EGYPTIAN_HIEROGLYPHS, /** * Unicode script "Samaritan". */ SAMARITAN, /** * Unicode script "Mandaic". */ MANDAIC, /** * Unicode script "Lisu". */ LISU, /** * Unicode script "Bamum". */ BAMUM, /** * Unicode script "Javanese". */ JAVANESE, /** * Unicode script "Meetei_Mayek". */ MEETEI_MAYEK, /** * Unicode script "Imperial_Aramaic". */ IMPERIAL_ARAMAIC, /** * Unicode script "Old_South_Arabian". */ OLD_SOUTH_ARABIAN, /** * Unicode script "Inscriptional_Parthian". */ INSCRIPTIONAL_PARTHIAN, /** * Unicode script "Inscriptional_Pahlavi". */ INSCRIPTIONAL_PAHLAVI, /** * Unicode script "Old_Turkic". */ OLD_TURKIC, /** * Unicode script "Brahmi". */ BRAHMI, /** * Unicode script "Kaithi". */ KAITHI, /** * Unicode script "Meroitic Hieroglyphs". */ MEROITIC_HIEROGLYPHS, /** * Unicode script "Meroitic Cursive". */ MEROITIC_CURSIVE, /** * Unicode script "Sora Sompeng". */ SORA_SOMPENG, /** * Unicode script "Chakma". */ CHAKMA, /** * Unicode script "Sharada". */ SHARADA, /** * Unicode script "Takri". */ TAKRI, /** * Unicode script "Miao". */ MIAO, /** * Unicode script "Unknown". */ UNKNOWN; private static final int[] scriptStarts = { 0x0000, // 0000..0040; COMMON 0x0041, // 0041..005A; LATIN 0x005B, // 005B..0060; COMMON 0x0061, // 0061..007A; LATIN 0x007B, // 007B..00A9; COMMON 0x00AA, // 00AA..00AA; LATIN 0x00AB, // 00AB..00B9; COMMON 0x00BA, // 00BA..00BA; LATIN 0x00BB, // 00BB..00BF; COMMON 0x00C0, // 00C0..00D6; LATIN 0x00D7, // 00D7..00D7; COMMON 0x00D8, // 00D8..00F6; LATIN 0x00F7, // 00F7..00F7; COMMON 0x00F8, // 00F8..02B8; LATIN 0x02B9, // 02B9..02DF; COMMON 0x02E0, // 02E0..02E4; LATIN 0x02E5, // 02E5..02E9; COMMON 0x02EA, // 02EA..02EB; BOPOMOFO 0x02EC, // 02EC..02FF; COMMON 0x0300, // 0300..036F; INHERITED 0x0370, // 0370..0373; GREEK 0x0374, // 0374..0374; COMMON 0x0375, // 0375..037D; GREEK 0x037E, // 037E..0383; COMMON 0x0384, // 0384..0384; GREEK 0x0385, // 0385..0385; COMMON 0x0386, // 0386..0386; GREEK 0x0387, // 0387..0387; COMMON 0x0388, // 0388..03E1; GREEK 0x03E2, // 03E2..03EF; COPTIC 0x03F0, // 03F0..03FF; GREEK 0x0400, // 0400..0484; CYRILLIC 0x0485, // 0485..0486; INHERITED 0x0487, // 0487..0530; CYRILLIC 0x0531, // 0531..0588; ARMENIAN 0x0589, // 0589..0589; COMMON 0x058A, // 058A..0590; ARMENIAN 0x0591, // 0591..05FF; HEBREW 0x0600, // 0600..060B; ARABIC 0x060C, // 060C..060C; COMMON 0x060D, // 060D..061A; ARABIC 0x061B, // 061B..061D; COMMON 0x061E, // 061E..061E; ARABIC 0x061F, // 061F..061F; COMMON 0x0620, // 0620..063F; ARABIC 0x0640, // 0640..0640; COMMON 0x0641, // 0641..064A; ARABIC 0x064B, // 064B..0655; INHERITED 0x0656, // 0656..065F; ARABIC 0x0660, // 0660..0669; COMMON 0x066A, // 066A..066F; ARABIC 0x0670, // 0670..0670; INHERITED 0x0671, // 0671..06DC; ARABIC 0x06DD, // 06DD..06DD; COMMON 0x06DE, // 06DE..06FF; ARABIC 0x0700, // 0700..074F; SYRIAC 0x0750, // 0750..077F; ARABIC 0x0780, // 0780..07BF; THAANA 0x07C0, // 07C0..07FF; NKO 0x0800, // 0800..083F; SAMARITAN 0x0840, // 0840..089F; MANDAIC 0x08A0, // 08A0..08FF; ARABIC 0x0900, // 0900..0950; DEVANAGARI 0x0951, // 0951..0952; INHERITED 0x0953, // 0953..0963; DEVANAGARI 0x0964, // 0964..0965; COMMON 0x0966, // 0966..0980; DEVANAGARI 0x0981, // 0981..0A00; BENGALI 0x0A01, // 0A01..0A80; GURMUKHI 0x0A81, // 0A81..0B00; GUJARATI 0x0B01, // 0B01..0B81; ORIYA 0x0B82, // 0B82..0C00; TAMIL 0x0C01, // 0C01..0C81; TELUGU 0x0C82, // 0C82..0CF0; KANNADA 0x0D02, // 0D02..0D81; MALAYALAM 0x0D82, // 0D82..0E00; SINHALA 0x0E01, // 0E01..0E3E; THAI 0x0E3F, // 0E3F..0E3F; COMMON 0x0E40, // 0E40..0E80; THAI 0x0E81, // 0E81..0EFF; LAO 0x0F00, // 0F00..0FD4; TIBETAN 0x0FD5, // 0FD5..0FD8; COMMON 0x0FD9, // 0FD9..0FFF; TIBETAN 0x1000, // 1000..109F; MYANMAR 0x10A0, // 10A0..10FA; GEORGIAN 0x10FB, // 10FB..10FB; COMMON 0x10FC, // 10FC..10FF; GEORGIAN 0x1100, // 1100..11FF; HANGUL 0x1200, // 1200..139F; ETHIOPIC 0x13A0, // 13A0..13FF; CHEROKEE 0x1400, // 1400..167F; CANADIAN_ABORIGINAL 0x1680, // 1680..169F; OGHAM 0x16A0, // 16A0..16EA; RUNIC 0x16EB, // 16EB..16ED; COMMON 0x16EE, // 16EE..16FF; RUNIC 0x1700, // 1700..171F; TAGALOG 0x1720, // 1720..1734; HANUNOO 0x1735, // 1735..173F; COMMON 0x1740, // 1740..175F; BUHID 0x1760, // 1760..177F; TAGBANWA 0x1780, // 1780..17FF; KHMER 0x1800, // 1800..1801; MONGOLIAN 0x1802, // 1802..1803; COMMON 0x1804, // 1804..1804; MONGOLIAN 0x1805, // 1805..1805; COMMON 0x1806, // 1806..18AF; MONGOLIAN 0x18B0, // 18B0..18FF; CANADIAN_ABORIGINAL 0x1900, // 1900..194F; LIMBU 0x1950, // 1950..197F; TAI_LE 0x1980, // 1980..19DF; NEW_TAI_LUE 0x19E0, // 19E0..19FF; KHMER 0x1A00, // 1A00..1A1F; BUGINESE 0x1A20, // 1A20..1AFF; TAI_THAM 0x1B00, // 1B00..1B7F; BALINESE 0x1B80, // 1B80..1BBF; SUNDANESE 0x1BC0, // 1BC0..1BFF; BATAK 0x1C00, // 1C00..1C4F; LEPCHA 0x1C50, // 1C50..1CBF; OL_CHIKI 0x1CC0, // 1CC0..1CCF; SUNDANESE 0x1CD0, // 1CD0..1CD2; INHERITED 0x1CD3, // 1CD3..1CD3; COMMON 0x1CD4, // 1CD4..1CE0; INHERITED 0x1CE1, // 1CE1..1CE1; COMMON 0x1CE2, // 1CE2..1CE8; INHERITED 0x1CE9, // 1CE9..1CEC; COMMON 0x1CED, // 1CED..1CED; INHERITED 0x1CEE, // 1CEE..1CF3; COMMON 0x1CF4, // 1CF4..1CF4; INHERITED 0x1CF5, // 1CF5..1CFF; COMMON 0x1D00, // 1D00..1D25; LATIN 0x1D26, // 1D26..1D2A; GREEK 0x1D2B, // 1D2B..1D2B; CYRILLIC 0x1D2C, // 1D2C..1D5C; LATIN 0x1D5D, // 1D5D..1D61; GREEK 0x1D62, // 1D62..1D65; LATIN 0x1D66, // 1D66..1D6A; GREEK 0x1D6B, // 1D6B..1D77; LATIN 0x1D78, // 1D78..1D78; CYRILLIC 0x1D79, // 1D79..1DBE; LATIN 0x1DBF, // 1DBF..1DBF; GREEK 0x1DC0, // 1DC0..1DFF; INHERITED 0x1E00, // 1E00..1EFF; LATIN 0x1F00, // 1F00..1FFF; GREEK 0x2000, // 2000..200B; COMMON 0x200C, // 200C..200D; INHERITED 0x200E, // 200E..2070; COMMON 0x2071, // 2071..2073; LATIN 0x2074, // 2074..207E; COMMON 0x207F, // 207F..207F; LATIN 0x2080, // 2080..208F; COMMON 0x2090, // 2090..209F; LATIN 0x20A0, // 20A0..20CF; COMMON 0x20D0, // 20D0..20FF; INHERITED 0x2100, // 2100..2125; COMMON 0x2126, // 2126..2126; GREEK 0x2127, // 2127..2129; COMMON 0x212A, // 212A..212B; LATIN 0x212C, // 212C..2131; COMMON 0x2132, // 2132..2132; LATIN 0x2133, // 2133..214D; COMMON 0x214E, // 214E..214E; LATIN 0x214F, // 214F..215F; COMMON 0x2160, // 2160..2188; LATIN 0x2189, // 2189..27FF; COMMON 0x2800, // 2800..28FF; BRAILLE 0x2900, // 2900..2BFF; COMMON 0x2C00, // 2C00..2C5F; GLAGOLITIC 0x2C60, // 2C60..2C7F; LATIN 0x2C80, // 2C80..2CFF; COPTIC 0x2D00, // 2D00..2D2F; GEORGIAN 0x2D30, // 2D30..2D7F; TIFINAGH 0x2D80, // 2D80..2DDF; ETHIOPIC 0x2DE0, // 2DE0..2DFF; CYRILLIC 0x2E00, // 2E00..2E7F; COMMON 0x2E80, // 2E80..2FEF; HAN 0x2FF0, // 2FF0..3004; COMMON 0x3005, // 3005..3005; HAN 0x3006, // 3006..3006; COMMON 0x3007, // 3007..3007; HAN 0x3008, // 3008..3020; COMMON 0x3021, // 3021..3029; HAN 0x302A, // 302A..302D; INHERITED 0x302E, // 302E..302F; HANGUL 0x3030, // 3030..3037; COMMON 0x3038, // 3038..303B; HAN 0x303C, // 303C..3040; COMMON 0x3041, // 3041..3098; HIRAGANA 0x3099, // 3099..309A; INHERITED 0x309B, // 309B..309C; COMMON 0x309D, // 309D..309F; HIRAGANA 0x30A0, // 30A0..30A0; COMMON 0x30A1, // 30A1..30FA; KATAKANA 0x30FB, // 30FB..30FC; COMMON 0x30FD, // 30FD..3104; KATAKANA 0x3105, // 3105..3130; BOPOMOFO 0x3131, // 3131..318F; HANGUL 0x3190, // 3190..319F; COMMON 0x31A0, // 31A0..31BF; BOPOMOFO 0x31C0, // 31C0..31EF; COMMON 0x31F0, // 31F0..31FF; KATAKANA 0x3200, // 3200..321F; HANGUL 0x3220, // 3220..325F; COMMON 0x3260, // 3260..327E; HANGUL 0x327F, // 327F..32CF; COMMON 0x32D0, // 32D0..3357; KATAKANA 0x3358, // 3358..33FF; COMMON 0x3400, // 3400..4DBF; HAN 0x4DC0, // 4DC0..4DFF; COMMON 0x4E00, // 4E00..9FFF; HAN 0xA000, // A000..A4CF; YI 0xA4D0, // A4D0..A4FF; LISU 0xA500, // A500..A63F; VAI 0xA640, // A640..A69F; CYRILLIC 0xA6A0, // A6A0..A6FF; BAMUM 0xA700, // A700..A721; COMMON 0xA722, // A722..A787; LATIN 0xA788, // A788..A78A; COMMON 0xA78B, // A78B..A7FF; LATIN 0xA800, // A800..A82F; SYLOTI_NAGRI 0xA830, // A830..A83F; COMMON 0xA840, // A840..A87F; PHAGS_PA 0xA880, // A880..A8DF; SAURASHTRA 0xA8E0, // A8E0..A8FF; DEVANAGARI 0xA900, // A900..A92F; KAYAH_LI 0xA930, // A930..A95F; REJANG 0xA960, // A960..A97F; HANGUL 0xA980, // A980..A9FF; JAVANESE 0xAA00, // AA00..AA5F; CHAM 0xAA60, // AA60..AA7F; MYANMAR 0xAA80, // AA80..AADF; TAI_VIET 0xAAE0, // AAE0..AB00; MEETEI_MAYEK 0xAB01, // AB01..ABBF; ETHIOPIC 0xABC0, // ABC0..ABFF; MEETEI_MAYEK 0xAC00, // AC00..D7FB; HANGUL 0xD7FC, // D7FC..F8FF; UNKNOWN 0xF900, // F900..FAFF; HAN 0xFB00, // FB00..FB12; LATIN 0xFB13, // FB13..FB1C; ARMENIAN 0xFB1D, // FB1D..FB4F; HEBREW 0xFB50, // FB50..FD3D; ARABIC 0xFD3E, // FD3E..FD4F; COMMON 0xFD50, // FD50..FDFC; ARABIC 0xFDFD, // FDFD..FDFF; COMMON 0xFE00, // FE00..FE0F; INHERITED 0xFE10, // FE10..FE1F; COMMON 0xFE20, // FE20..FE2F; INHERITED 0xFE30, // FE30..FE6F; COMMON 0xFE70, // FE70..FEFE; ARABIC 0xFEFF, // FEFF..FF20; COMMON 0xFF21, // FF21..FF3A; LATIN 0xFF3B, // FF3B..FF40; COMMON 0xFF41, // FF41..FF5A; LATIN 0xFF5B, // FF5B..FF65; COMMON 0xFF66, // FF66..FF6F; KATAKANA 0xFF70, // FF70..FF70; COMMON 0xFF71, // FF71..FF9D; KATAKANA 0xFF9E, // FF9E..FF9F; COMMON 0xFFA0, // FFA0..FFDF; HANGUL 0xFFE0, // FFE0..FFFF; COMMON 0x10000, // 10000..100FF; LINEAR_B 0x10100, // 10100..1013F; COMMON 0x10140, // 10140..1018F; GREEK 0x10190, // 10190..101FC; COMMON 0x101FD, // 101FD..1027F; INHERITED 0x10280, // 10280..1029F; LYCIAN 0x102A0, // 102A0..102FF; CARIAN 0x10300, // 10300..1032F; OLD_ITALIC 0x10330, // 10330..1037F; GOTHIC 0x10380, // 10380..1039F; UGARITIC 0x103A0, // 103A0..103FF; OLD_PERSIAN 0x10400, // 10400..1044F; DESERET 0x10450, // 10450..1047F; SHAVIAN 0x10480, // 10480..107FF; OSMANYA 0x10800, // 10800..1083F; CYPRIOT 0x10840, // 10840..108FF; IMPERIAL_ARAMAIC 0x10900, // 10900..1091F; PHOENICIAN 0x10920, // 10920..1097F; LYDIAN 0x10980, // 10980..1099F; MEROITIC_HIEROGLYPHS 0x109A0, // 109A0..109FF; MEROITIC_CURSIVE 0x10A00, // 10A00..10A5F; KHAROSHTHI 0x10A60, // 10A60..10AFF; OLD_SOUTH_ARABIAN 0x10B00, // 10B00..10B3F; AVESTAN 0x10B40, // 10B40..10B5F; INSCRIPTIONAL_PARTHIAN 0x10B60, // 10B60..10BFF; INSCRIPTIONAL_PAHLAVI 0x10C00, // 10C00..10E5F; OLD_TURKIC 0x10E60, // 10E60..10FFF; ARABIC 0x11000, // 11000..1107F; BRAHMI 0x11080, // 11080..110CF; KAITHI 0x110D0, // 110D0..110FF; SORA_SOMPENG 0x11100, // 11100..1117F; CHAKMA 0x11180, // 11180..1167F; SHARADA 0x11680, // 11680..116CF; TAKRI 0x12000, // 12000..12FFF; CUNEIFORM 0x13000, // 13000..167FF; EGYPTIAN_HIEROGLYPHS 0x16800, // 16800..16A38; BAMUM 0x16F00, // 16F00..16F9F; MIAO 0x1B000, // 1B000..1B000; KATAKANA 0x1B001, // 1B001..1CFFF; HIRAGANA 0x1D000, // 1D000..1D166; COMMON 0x1D167, // 1D167..1D169; INHERITED 0x1D16A, // 1D16A..1D17A; COMMON 0x1D17B, // 1D17B..1D182; INHERITED 0x1D183, // 1D183..1D184; COMMON 0x1D185, // 1D185..1D18B; INHERITED 0x1D18C, // 1D18C..1D1A9; COMMON 0x1D1AA, // 1D1AA..1D1AD; INHERITED 0x1D1AE, // 1D1AE..1D1FF; COMMON 0x1D200, // 1D200..1D2FF; GREEK 0x1D300, // 1D300..1EDFF; COMMON 0x1EE00, // 1EE00..1EFFF; ARABIC 0x1F000, // 1F000..1F1FF; COMMON 0x1F200, // 1F200..1F200; HIRAGANA 0x1F201, // 1F210..1FFFF; COMMON 0x20000, // 20000..E0000; HAN 0xE0001, // E0001..E00FF; COMMON 0xE0100, // E0100..E01EF; INHERITED 0xE01F0 // E01F0..10FFFF; UNKNOWN }; private static final UnicodeScript[] scripts = { COMMON, LATIN, COMMON, LATIN, COMMON, LATIN, COMMON, LATIN, COMMON, LATIN, COMMON, LATIN, COMMON, LATIN, COMMON, LATIN, COMMON, BOPOMOFO, COMMON, INHERITED, GREEK, COMMON, GREEK, COMMON, GREEK, COMMON, GREEK, COMMON, GREEK, COPTIC, GREEK, CYRILLIC, INHERITED, CYRILLIC, ARMENIAN, COMMON, ARMENIAN, HEBREW, ARABIC, COMMON, ARABIC, COMMON, ARABIC, COMMON, ARABIC, COMMON, ARABIC, INHERITED, ARABIC, COMMON, ARABIC, INHERITED, ARABIC, COMMON, ARABIC, SYRIAC, ARABIC, THAANA, NKO, SAMARITAN, MANDAIC, ARABIC, DEVANAGARI, INHERITED, DEVANAGARI, COMMON, DEVANAGARI, BENGALI, GURMUKHI, GUJARATI, ORIYA, TAMIL, TELUGU, KANNADA, MALAYALAM, SINHALA, THAI, COMMON, THAI, LAO, TIBETAN, COMMON, TIBETAN, MYANMAR, GEORGIAN, COMMON, GEORGIAN, HANGUL, ETHIOPIC, CHEROKEE, CANADIAN_ABORIGINAL, OGHAM, RUNIC, COMMON, RUNIC, TAGALOG, HANUNOO, COMMON, BUHID, TAGBANWA, KHMER, MONGOLIAN, COMMON, MONGOLIAN, COMMON, MONGOLIAN, CANADIAN_ABORIGINAL, LIMBU, TAI_LE, NEW_TAI_LUE, KHMER, BUGINESE, TAI_THAM, BALINESE, SUNDANESE, BATAK, LEPCHA, OL_CHIKI, SUNDANESE, INHERITED, COMMON, INHERITED, COMMON, INHERITED, COMMON, INHERITED, COMMON, INHERITED, COMMON, LATIN, GREEK, CYRILLIC, LATIN, GREEK, LATIN, GREEK, LATIN, CYRILLIC, LATIN, GREEK, INHERITED, LATIN, GREEK, COMMON, INHERITED, COMMON, LATIN, COMMON, LATIN, COMMON, LATIN, COMMON, INHERITED, COMMON, GREEK, COMMON, LATIN, COMMON, LATIN, COMMON, LATIN, COMMON, LATIN, COMMON, BRAILLE, COMMON, GLAGOLITIC, LATIN, COPTIC, GEORGIAN, TIFINAGH, ETHIOPIC, CYRILLIC, COMMON, HAN, COMMON, HAN, COMMON, HAN, COMMON, HAN, INHERITED, HANGUL, COMMON, HAN, COMMON, HIRAGANA, INHERITED, COMMON, HIRAGANA, COMMON, KATAKANA, COMMON, KATAKANA, BOPOMOFO, HANGUL, COMMON, BOPOMOFO, COMMON, KATAKANA, HANGUL, COMMON, HANGUL, COMMON, KATAKANA, COMMON, HAN, COMMON, HAN, YI, LISU, VAI, CYRILLIC, BAMUM, COMMON, LATIN, COMMON, LATIN, SYLOTI_NAGRI, COMMON, PHAGS_PA, SAURASHTRA, DEVANAGARI, KAYAH_LI, REJANG, HANGUL, JAVANESE, CHAM, MYANMAR, TAI_VIET, MEETEI_MAYEK, ETHIOPIC, MEETEI_MAYEK, HANGUL, UNKNOWN , HAN, LATIN, ARMENIAN, HEBREW, ARABIC, COMMON, ARABIC, COMMON, INHERITED, COMMON, INHERITED, COMMON, ARABIC, COMMON, LATIN, COMMON, LATIN, COMMON, KATAKANA, COMMON, KATAKANA, COMMON, HANGUL, COMMON, LINEAR_B, COMMON, GREEK, COMMON, INHERITED, LYCIAN, CARIAN, OLD_ITALIC, GOTHIC, UGARITIC, OLD_PERSIAN, DESERET, SHAVIAN, OSMANYA, CYPRIOT, IMPERIAL_ARAMAIC, PHOENICIAN, LYDIAN, MEROITIC_HIEROGLYPHS, MEROITIC_CURSIVE, KHAROSHTHI, OLD_SOUTH_ARABIAN, AVESTAN, INSCRIPTIONAL_PARTHIAN, INSCRIPTIONAL_PAHLAVI, OLD_TURKIC, ARABIC, BRAHMI, KAITHI, SORA_SOMPENG, CHAKMA, SHARADA, TAKRI, CUNEIFORM, EGYPTIAN_HIEROGLYPHS, BAMUM, MIAO, KATAKANA, HIRAGANA, COMMON, INHERITED, COMMON, INHERITED, COMMON, INHERITED, COMMON, INHERITED, COMMON, GREEK, COMMON, ARABIC, COMMON, HIRAGANA, COMMON, HAN, COMMON, INHERITED, UNKNOWN }; private static HashMap aliases; static { aliases = new HashMap<>(128); aliases.put("ARAB", ARABIC); aliases.put("ARMI", IMPERIAL_ARAMAIC); aliases.put("ARMN", ARMENIAN); aliases.put("AVST", AVESTAN); aliases.put("BALI", BALINESE); aliases.put("BAMU", BAMUM); aliases.put("BATK", BATAK); aliases.put("BENG", BENGALI); aliases.put("BOPO", BOPOMOFO); aliases.put("BRAI", BRAILLE); aliases.put("BRAH", BRAHMI); aliases.put("BUGI", BUGINESE); aliases.put("BUHD", BUHID); aliases.put("CAKM", CHAKMA); aliases.put("CANS", CANADIAN_ABORIGINAL); aliases.put("CARI", CARIAN); aliases.put("CHAM", CHAM); aliases.put("CHER", CHEROKEE); aliases.put("COPT", COPTIC); aliases.put("CPRT", CYPRIOT); aliases.put("CYRL", CYRILLIC); aliases.put("DEVA", DEVANAGARI); aliases.put("DSRT", DESERET); aliases.put("EGYP", EGYPTIAN_HIEROGLYPHS); aliases.put("ETHI", ETHIOPIC); aliases.put("GEOR", GEORGIAN); aliases.put("GLAG", GLAGOLITIC); aliases.put("GOTH", GOTHIC); aliases.put("GREK", GREEK); aliases.put("GUJR", GUJARATI); aliases.put("GURU", GURMUKHI); aliases.put("HANG", HANGUL); aliases.put("HANI", HAN); aliases.put("HANO", HANUNOO); aliases.put("HEBR", HEBREW); aliases.put("HIRA", HIRAGANA); // it appears we don't have the KATAKANA_OR_HIRAGANA //aliases.put("HRKT", KATAKANA_OR_HIRAGANA); aliases.put("ITAL", OLD_ITALIC); aliases.put("JAVA", JAVANESE); aliases.put("KALI", KAYAH_LI); aliases.put("KANA", KATAKANA); aliases.put("KHAR", KHAROSHTHI); aliases.put("KHMR", KHMER); aliases.put("KNDA", KANNADA); aliases.put("KTHI", KAITHI); aliases.put("LANA", TAI_THAM); aliases.put("LAOO", LAO); aliases.put("LATN", LATIN); aliases.put("LEPC", LEPCHA); aliases.put("LIMB", LIMBU); aliases.put("LINB", LINEAR_B); aliases.put("LISU", LISU); aliases.put("LYCI", LYCIAN); aliases.put("LYDI", LYDIAN); aliases.put("MAND", MANDAIC); aliases.put("MERC", MEROITIC_CURSIVE); aliases.put("MERO", MEROITIC_HIEROGLYPHS); aliases.put("MLYM", MALAYALAM); aliases.put("MONG", MONGOLIAN); aliases.put("MTEI", MEETEI_MAYEK); aliases.put("MYMR", MYANMAR); aliases.put("NKOO", NKO); aliases.put("OGAM", OGHAM); aliases.put("OLCK", OL_CHIKI); aliases.put("ORKH", OLD_TURKIC); aliases.put("ORYA", ORIYA); aliases.put("OSMA", OSMANYA); aliases.put("PHAG", PHAGS_PA); aliases.put("PLRD", MIAO); aliases.put("PHLI", INSCRIPTIONAL_PAHLAVI); aliases.put("PHNX", PHOENICIAN); aliases.put("PRTI", INSCRIPTIONAL_PARTHIAN); aliases.put("RJNG", REJANG); aliases.put("RUNR", RUNIC); aliases.put("SAMR", SAMARITAN); aliases.put("SARB", OLD_SOUTH_ARABIAN); aliases.put("SAUR", SAURASHTRA); aliases.put("SHAW", SHAVIAN); aliases.put("SHRD", SHARADA); aliases.put("SINH", SINHALA); aliases.put("SORA", SORA_SOMPENG); aliases.put("SUND", SUNDANESE); aliases.put("SYLO", SYLOTI_NAGRI); aliases.put("SYRC", SYRIAC); aliases.put("TAGB", TAGBANWA); aliases.put("TALE", TAI_LE); aliases.put("TAKR", TAKRI); aliases.put("TALU", NEW_TAI_LUE); aliases.put("TAML", TAMIL); aliases.put("TAVT", TAI_VIET); aliases.put("TELU", TELUGU); aliases.put("TFNG", TIFINAGH); aliases.put("TGLG", TAGALOG); aliases.put("THAA", THAANA); aliases.put("THAI", THAI); aliases.put("TIBT", TIBETAN); aliases.put("UGAR", UGARITIC); aliases.put("VAII", VAI); aliases.put("XPEO", OLD_PERSIAN); aliases.put("XSUX", CUNEIFORM); aliases.put("YIII", YI); aliases.put("ZINH", INHERITED); aliases.put("ZYYY", COMMON); aliases.put("ZZZZ", UNKNOWN); } /** * Returns the enum constant representing the Unicode script of which * the given character (Unicode code point) is assigned to. * * @param codePoint the character (Unicode code point) in question. * @return The {@code UnicodeScript} constant representing the * Unicode script of which this character is assigned to. * * @exception IllegalArgumentException if the specified * {@code codePoint} is an invalid Unicode code point. * @see Character#isValidCodePoint(int) * */ public static UnicodeScript of(int codePoint) { if (!isValidCodePoint(codePoint)) throw new IllegalArgumentException(); int type = getType(codePoint); // leave SURROGATE and PRIVATE_USE for table lookup if (type == UNASSIGNED) return UNKNOWN; int index = Arrays.binarySearch(scriptStarts, codePoint); if (index < 0) index = -index - 2; return scripts[index]; } /** * Returns the UnicodeScript constant with the given Unicode script * name or the script name alias. Script names and their aliases are * determined by The Unicode Standard. The files Scripts<version>.txt * and PropertyValueAliases<version>.txt define script names * and the script name aliases for a particular version of the * standard. The {@link Character} class specifies the version of * the standard that it supports. *

* 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 */ public static String toString(char c) { return String.valueOf(c); } /** * 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. *

This method is equivalent to the expression: * 

{@code
     * isHighSurrogate(high) && isLowSurrogate(low)
     * }
* * @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 || 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 || 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}: *

*

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}: *

*

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: *

* * 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: *

* * 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: *

* *

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: *

* * @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: *

* * 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: *

* * 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: *

* * @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: *

* * @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: *

* 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: *

* *

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: *

* * @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: *

* *

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: *

* * @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: *

* *

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: *

* @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: *

* *

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: *

* * @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: *

* *

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: *

* * @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: *

* *

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: * *

* * @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: * * *

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: *

*

* * @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: * 

     *    Character.valueOf(x).compareTo(Character.valueOf(y))
     *
* * @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. * *

{@code * Character.UnicodeBlock.of(codePoint).toString().replace('_', ' ') * + " " * + Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH); * * }
* * @param codePoint the character (Unicode code point) * * @return the Unicode name of the specified character, or null if * the code point is unassigned. * * @exception IllegalArgumentException if the specified * {@code codePoint} is not a valid Unicode * code point. * * @since 1.7 */ public static String getName(int codePoint) { // if (!isValidCodePoint(codePoint)) { // throw new IllegalArgumentException(); // } // String name = CharacterName.get(codePoint); // if (name != null) // return name; // if (getType(codePoint) == UNASSIGNED) // return null; // UnicodeBlock block = UnicodeBlock.of(codePoint); // if (block != null) // return block.toString().replace('_', ' ') + " " // + Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH); // // should never come here // return Integer.toHexString(codePoint).toUpperCase(Locale.ENGLISH); CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } } java-models-library-master/src/main/java/java/lang/Class.java000066400000000000000000000434521333036534000244310ustar00rootroot00000000000000/* * 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.HashMap; import java.util.Map; // import sun.reflect.CallerSensitive; // import sun.reflect.Reflection; import org.cprover.CProver; import org.cprover.CProverString; 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 isAnnotation; private boolean isArray; private boolean isInterface; private boolean isSynthetic; private boolean isLocalClass; private boolean isMemberClass; private boolean isEnum; 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 isInterface; } public boolean isArray() { return isArray; } 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 isAnnotation; } public boolean isSynthetic() { return isSynthetic; } public boolean isLocalClass() { return isLocalClass; } public boolean isMemberClass() { return isMemberClass; } public boolean isAnonymousClass() { return "".equals(getSimpleName()); } public boolean isEnum() { return isEnum; } 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 */ // @CallerSensitive public ClassLoader getClassLoader() { // ClassLoader cl = getClassLoader0(); // if (cl == null) // return null; // SecurityManager sm = System.getSecurityManager(); // if (sm != null) { // ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass()); // } // return cl; return null; } 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.isAnnotation = isAnnotation; this.isArray = isArray; this.isInterface = isInterface; this.isSynthetic = isSynthetic; this.isLocalClass = isLocalClass; this.isMemberClass = isMemberClass; this.isEnum = isEnum; } } java-models-library-master/src/main/java/java/lang/ClassCastException.java000066400000000000000000000035731333036534000271230ustar00rootroot00000000000000/* * 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.java000066400000000000000000000044661333036534000276600ustar00rootroot00000000000000/* * 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.java000066400000000000000000000045011333036534000266040ustar00rootroot00000000000000/* * 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.java000066400000000000000000000043771333036534000277700ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036331333036534000306670ustar00rootroot00000000000000/* * 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/Enum.java000066400000000000000000000226631333036534000242710ustar00rootroot00000000000000/* * 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.java000066400000000000000000000045221333036534000316760ustar00rootroot00000000000000/* * 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.java000066400000000000000000000126421333036534000244520ustar00rootroot00000000000000/* * 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.java000066400000000000000000000125251333036534000253170ustar00rootroot00000000000000/* * 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.java000066400000000000000000000122231333036534000310170ustar00rootroot00000000000000/* * 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/IllegalAccessError.java000066400000000000000000000047161333036534000270710ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036321333036534000277320ustar00rootroot00000000000000/* * 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.java000066400000000000000000000041321333036534000303070ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036541333036534000311650ustar00rootroot00000000000000/* * 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.java000066400000000000000000000040751333036534000276130ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036601333036534000307420ustar00rootroot00000000000000/* * 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.java000066400000000000000000000046601333036534000310760ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036341333036534000304400ustar00rootroot00000000000000/* * 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.java000066400000000000000000000047331333036534000272210ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036331333036534000300640ustar00rootroot00000000000000/* * 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.java000066400000000000000000001542331333036534000247610ustar00rootroot00000000000000/* * 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 MODEL LIBRARY: Handled internally by CBMC public static String toString(int i, int radix) { return CProver.nondetWithoutNullForNotModelled(); } /** * Returns a string representation of the first argument as an * unsigned integer value in the radix specified by the second * argument. * *

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 MODEL LIBRARY: Handled internally by CBMC public static String toString(int i) { // this function is handled by cbmc internally return CProver.nondetWithoutNullForNotModelled(); } /** * Returns a string representation of the argument as an unsigned * decimal value. * * The argument is converted to unsigned decimal representation * and returned as a string exactly as if the argument and radix * 10 were given as arguments to the {@link #toUnsignedString(int, * int)} method. * * @param i an integer to be converted to an unsigned string. * @return an unsigned string representation of the argument. * @see #toUnsignedString(int, int) * @since 1.8 */ //TODO public static String toUnsignedString(int i) { return Long.toString(toUnsignedLong(i)); } // Requires positive x static int stringSize(int x) { if (x <= 9) return 1; if (x <= 99) return 2; if (x <= 999) return 3; if (x <= 9999) return 4; if (x <= 99999) return 5; if (x <= 999999) return 6; if (x <= 9999999) return 7; if (x <= 99999999) return 8; if (x <= 999999999) return 9; return 10; } /** * Parses the string argument as a signed integer in the radix * specified by the second argument. The characters in the string * must all be digits of the specified radix (as determined by * whether {@link java.lang.Character#digit(char, int)} returns a * nonnegative value), except that the first character may be an * ASCII minus sign {@code '-'} ({@code '\u005Cu002D'}) to * indicate a negative value or an ASCII plus sign {@code '+'} * ({@code '\u005Cu002B'}) to indicate a positive value. The * resulting integer value is returned. * *

An exception of type {@code NumberFormatException} is * thrown if any of the following situations occurs: *

* *

Examples: * 

     * parseInt("0", 10) returns 0
     * parseInt("473", 10) returns 473
     * parseInt("+42", 10) returns 42
     * parseInt("-0", 10) returns 0
     * parseInt("-FF", 16) returns -255
     * parseInt("1100110", 2) returns 102
     * parseInt("2147483647", 10) returns 2147483647
     * parseInt("-2147483648", 10) returns -2147483648
     * parseInt("2147483648", 10) throws a NumberFormatException
     * parseInt("99", 8) throws a NumberFormatException
     * parseInt("Kona", 10) throws a NumberFormatException
     * parseInt("Kona", 27) returns 411787
     *
* * @param s the {@code String} containing the integer * representation to be parsed * @param radix the radix to be used while parsing {@code s}. * @return the integer represented by the string argument in the * specified radix. * @exception NumberFormatException if the {@code String} * does not contain a parsable {@code int}. */ public static int parseInt(String s, int radix) throws NumberFormatException { if (s == null) { throw new NumberFormatException("null"); } if (radix < Character.MIN_RADIX) { throw new NumberFormatException("radix " + radix + " less than Character.MIN_RADIX"); } if (radix > Character.MAX_RADIX) { throw new NumberFormatException("radix " + radix + " greater than Character.MAX_RADIX"); } if (radix == 10) { return parseInt(s); } //TODO from here on int result = 0; boolean negative = false; int i = 0, len = s.length(); int limit = -Integer.MAX_VALUE; int multmin; int digit; if (len > 0) { char firstChar = CProverString.charAt(s, 0); if (firstChar < '0') { // Possible leading "+" or "-" if (firstChar == '-') { negative = true; limit = Integer.MIN_VALUE; } else if (firstChar != '+') throw NumberFormatException.forInputString(s); if (len == 1) // Cannot have lone "+" or "-" throw NumberFormatException.forInputString(s); i++; } multmin = limit / radix; while (i < len) { // Accumulating negatively avoids surprises near MAX_VALUE digit = Character.digit(CProverString.charAt(s, i++), radix); if (digit < 0) { throw NumberFormatException.forInputString(s); } if (result < multmin) { throw NumberFormatException.forInputString(s); } result *= radix; if (result < limit + digit) { throw NumberFormatException.forInputString(s); } result -= digit; } } else { throw NumberFormatException.forInputString(s); } return negative ? result : -result; } /** * Parses the string argument as a signed decimal integer. The * characters in the string must all be decimal digits, except * that the first character may be an ASCII minus sign {@code '-'} * ({@code '\u005Cu002D'}) to indicate a negative value or an * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to * indicate a positive value. The resulting integer value is * returned, exactly as if the argument and the radix 10 were * given as arguments to the {@link #parseInt(java.lang.String, * int)} method. * * @param s a {@code String} containing the {@code int} * representation to be parsed * @return the integer value represented by the argument in decimal. * @exception NumberFormatException if the string does not contain a * parsable integer. */ public static int parseInt(String s) throws NumberFormatException { return CProver.nondetInt(); //The function is handled by cbmc internally } /** * Parses the string argument as an unsigned integer in the radix * specified by the second argument. An unsigned integer maps the * values usually associated with negative numbers to positive * numbers larger than {@code MAX_VALUE}. * * The characters in the string must all be digits of the * specified radix (as determined by whether {@link * java.lang.Character#digit(char, int)} returns a nonnegative * value), except that the first character may be an ASCII plus * sign {@code '+'} ({@code '\u005Cu002B'}). The resulting * integer value is returned. * *

An exception of type {@code NumberFormatException} is * thrown if any of the following situations occurs: *

* * * @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: * * * *

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: * 

     *    Integer.valueOf(x).compareTo(Integer.valueOf(y))
     *
* * @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.java000066400000000000000000000071061333036534000261460ustar00rootroot00000000000000/* * 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.java000066400000000000000000000035751333036534000275520ustar00rootroot00000000000000/* * 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.java000066400000000000000000000051521333036534000257430ustar00rootroot00000000000000/* * 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/Math.java000066400000000000000000003062211333036534000242510ustar00rootroot00000000000000/* * 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: *

* *

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: *

* *

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: *

* *

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: *

* *

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: *

* *

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: *

* *

The computed result must be within 1 ulp of the exact result. * Results must be semi-monotonic. * * @param a the value whose arc tangent is to be returned. * @return the arc tangent of the argument. */ public static double atan(double a) { CProver.notModelled(); return CProver.nondetDouble(); // return StrictMath.atan(a); // default impl. delegates to StrictMath } /** * Converts an angle measured in degrees to an approximately * equivalent angle measured in radians. The conversion from * degrees to radians is generally inexact. * * @param angdeg an angle, in degrees * @return the measurement of the angle {@code angdeg} * in radians. * @since 1.2 */ public static double toRadians(double angdeg) { CProver.notModelled(); return CProver.nondetDouble(); // return angdeg / 180.0 * PI; } /** * Converts an angle measured in radians to an approximately * equivalent angle measured in degrees. The conversion from * radians to degrees is generally inexact; users should * 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: *

* *

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: *

* *

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: * *

* *

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: *

* Otherwise, the result is the {@code double} value closest to * the true mathematical square root of the argument value. * * @param a a value. * @return the positive square root of {@code a}. * If the argument is NaN or less than zero, the result is NaN. */ public static double sqrt(double a) { CProver.notModelled(); return CProver.nondetDouble(); // return StrictMath.sqrt(a); // default impl. delegates to StrictMath // Note that hardware sqrt instructions // frequently can be directly used by JITs // and should be much faster than doing // Math.sqrt in software. } /** * Returns the cube root of a {@code double} value. For * positive finite {@code x}, {@code cbrt(-x) == * -cbrt(x)}; that is, the cube root of a negative value is * the negative of the cube root of that value's magnitude. * * Special cases: * * * *

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: *

* * @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: * 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: * * * @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: * * * @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: * * *

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: * *

* *

(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: *

* * @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: *

* * @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. *

*

* * @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 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. */ public static int abs(int a) { CProver.notModelled(); return CProver.nondetInt(); // return (a < 0) ? -a : a; } /** * Returns the absolute value of a {@code long} value. * If the argument is not negative, the argument is returned. * If the argument is negative, the negation of the argument is returned. * *

Note that if the argument is equal to the value of * {@link Long#MIN_VALUE}, the most negative representable * {@code long} value, the result is that same value, which * is negative. * * @param a the argument whose absolute value is to be determined * @return the absolute value of the argument. */ public static long abs(long a) { CProver.notModelled(); return CProver.nondetLong(); // return (a < 0) ? -a : a; } /** * Returns the absolute value of a {@code float} value. * If the argument is not negative, the argument is returned. * If the argument is negative, the negation of the argument is returned. * Special cases: *

* 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. */ public static float abs(float a) { CProver.notModelled(); return CProver.nondetFloat(); // return (a <= 0.0F) ? 0.0F - a : a; } /** * Returns the absolute value of a {@code double} value. * If the argument is not negative, the argument is returned. * If the argument is negative, the negation of the argument is returned. * Special cases: *

* 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. */ public static double abs(double a) { CProver.notModelled(); return CProver.nondetDouble(); // return (a <= 0.0D) ? 0.0D - a : a; } /** * Returns the greater of two {@code int} values. That is, the * result is the argument closer to the value of * {@link Integer#MAX_VALUE}. If the arguments have the same value, * the result is that same value. * * @param a an argument. * @param b another argument. * @return the larger of {@code a} and {@code b}. */ public static int max(int a, int b) { // return (a >= b) ? a : b; int result = CProver.nondetInt(); CProver.assume((result == a || result == b) && result >= a && result >= b); return result; } /** * Returns the greater of two {@code long} values. That is, the * result is the argument closer to the value of * {@link Long#MAX_VALUE}. If the arguments have the same value, * the result is that same value. * * @param a an argument. * @param b another argument. * @return the larger of {@code a} and {@code b}. */ public static long max(long a, long b) { // return (a >= b) ? a : b; long result = CProver.nondetLong(); CProver.assume((result == a || result == b) && result >= a && result >= b); return result; } // Use raw bit-wise conversions on guaranteed non-NaN arguments. private static long negativeZeroFloatBits = Float.floatToRawIntBits(-0.0f); private static long negativeZeroDoubleBits = Double.doubleToRawLongBits(-0.0d); /** * Returns the greater of two {@code float} values. That is, * the result is the argument closer to positive infinity. If the * arguments have the same value, the result is that same * value. If either value is NaN, then the result is NaN. Unlike * the numerical comparison operators, this method considers * negative zero to be strictly smaller than positive zero. If one * argument is positive zero and the other negative zero, the * result is positive zero. * * @param a an argument. * @param b another argument. * @return the larger of {@code a} and {@code b}. */ public static float max(float a, float b) { // if (a != a) // return a; // a is NaN // if ((a == 0.0f) && // (b == 0.0f) && // (Float.floatToRawIntBits(a) == negativeZeroFloatBits)) { // // Raw conversion ok since NaN can't map to -0.0. // return b; // } // return (a >= b) ? a : b; if (Float.isNaN(a) || Float.isNaN(b)) { return Float.NaN; } else { float result = CProver.nondetFloat(); CProver.assume((result == a || result == b) && result >= a && result >= b); return result; } } /** * Returns the greater of two {@code double} values. That * is, the result is the argument closer to positive infinity. If * the arguments have the same value, the result is that same * value. If either value is NaN, then the result is NaN. Unlike * the numerical comparison operators, this method considers * negative zero to be strictly smaller than positive zero. If one * argument is positive zero and the other negative zero, the * result is positive zero. * * @param a an argument. * @param b another argument. * @return the larger of {@code a} and {@code b}. */ public static double max(double a, double b) { // if (a != a) // return a; // a is NaN // if ((a == 0.0d) && // (b == 0.0d) && // (Double.doubleToRawLongBits(a) == negativeZeroDoubleBits)) { // // Raw conversion ok since NaN can't map to -0.0. // return b; // } // return (a >= b) ? a : b; if (Double.isNaN(a) || Double.isNaN(b)) { return Double.NaN; } else { double result = CProver.nondetDouble(); CProver.assume((result == a || result == b) && result >= a && result >= b); return result; } } /** * Returns the smaller of two {@code int} values. That is, * the result the argument closer to the value of * {@link Integer#MIN_VALUE}. If the arguments have the same * value, the result is that same value. * * @param a an argument. * @param b another argument. * @return the smaller of {@code a} and {@code b}. */ public static int min(int a, int b) { // return (a <= b) ? a : b; int result = CProver.nondetInt(); CProver.assume((result == a || result == b) && result <= a && result <= b); return result; } /** * Returns the smaller of two {@code long} values. That is, * the result is the argument closer to the value of * {@link Long#MIN_VALUE}. If the arguments have the same * value, the result is that same value. * * @param a an argument. * @param b another argument. * @return the smaller of {@code a} and {@code b}. */ public static long min(long a, long b) { // return (a <= b) ? a : b; long result = CProver.nondetLong(); CProver.assume((result == a || result == b) && result <= a && result <= b); return result; } /** * Returns the smaller of two {@code float} values. That is, * the result is the value closer to negative infinity. If the * arguments have the same value, the result is that same * value. If either value is NaN, then the result is NaN. Unlike * the numerical comparison operators, this method considers * negative zero to be strictly smaller than positive zero. If * one argument is positive zero and the other is negative zero, * the result is negative zero. * * @param a an argument. * @param b another argument. * @return the smaller of {@code a} and {@code b}. */ public static float min(float a, float b) { // if (a != a) // return a; // a is NaN // if ((a == 0.0f) && // (b == 0.0f) && // (Float.floatToRawIntBits(b) == negativeZeroFloatBits)) { // // Raw conversion ok since NaN can't map to -0.0. // return b; // } // return (a <= b) ? a : b; if (Float.isNaN(a) || Float.isNaN(b)) { return Float.NaN; } else { float result = CProver.nondetFloat(); CProver.assume((result == a || result == b) && result <= a && result <= b); return result; } } /** * Returns the smaller of two {@code double} values. That * is, the result is the value closer to negative infinity. If the * arguments have the same value, the result is that same * value. If either value is NaN, then the result is NaN. Unlike * the numerical comparison operators, this method considers * negative zero to be strictly smaller than positive zero. If one * argument is positive zero and the other is negative zero, the * result is negative zero. * * @param a an argument. * @param b another argument. * @return the smaller of {@code a} and {@code b}. */ public static double min(double a, double b) { // if (a != a) // return a; // a is NaN // if ((a == 0.0d) && // (b == 0.0d) && // (Double.doubleToRawLongBits(b) == negativeZeroDoubleBits)) { // // Raw conversion ok since NaN can't map to -0.0. // return b; // } // return (a <= b) ? a : b; if (Double.isNaN(a) || Double.isNaN(b)) { return Double.NaN; } else { double result = CProver.nondetDouble(); CProver.assume((result == a || result == b) && result <= a && result <= b); return result; } } /** * Returns the size of an ulp of the argument. An ulp, unit in * the last place, of a {@code double} value is the positive * distance between this floating-point value and the {@code * double} value next larger in magnitude. Note that for non-NaN * x, ulp(-x) == ulp(x). * *

Special Cases: *

* * @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: *

* * @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: *

* * @param d the floating-point value whose signum is to be returned * @return the signum function of the argument * @author Joseph D. Darcy * @since 1.5 */ public static double signum(double d) { CProver.notModelled(); return CProver.nondetDouble(); // return (d == 0.0 || Double.isNaN(d))?d:copySign(1.0, d); } /** * Returns the signum function of the argument; zero if the argument * is zero, 1.0f if the argument is greater than zero, -1.0f if the * argument is less than zero. * *

Special Cases: *

* * @param f the floating-point value whose signum is to be returned * @return the signum function of the argument * @author Joseph D. Darcy * @since 1.5 */ public static float signum(float f) { CProver.notModelled(); return CProver.nondetFloat(); // return (f == 0.0f || Float.isNaN(f))?f:copySign(1.0f, f); } /** * Returns the hyperbolic sine of a {@code double} value. * The hyperbolic sine of x is defined to be * (ex - e-x)/2 * where e is {@linkplain Math#E Euler's number}. * *

Special cases: *

* *

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: *

* *

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: *

* *

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: *

* *

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: *

* *

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: * *

* *

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: * *

* @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: * * * @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: *

* * @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: *

* * @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: *

* * @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: *

* * @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: *

* * @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: *

* * @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: *

* * @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: *

* * @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.java000066400000000000000000000036431333036534000306350ustar00rootroot00000000000000/* * 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.java000066400000000000000000000051461333036534000273510ustar00rootroot00000000000000/* * 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.java000066400000000000000000000047071333036534000265410ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036211333036534000274000ustar00rootroot00000000000000/* * 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.java000066400000000000000000000047601333036534000267350ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036251333036534000276010ustar00rootroot00000000000000/* * 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.java000066400000000000000000000036041333036534000275110ustar00rootroot00000000000000/* * 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/NumberFormatException.java000066400000000000000000000040351333036534000276360ustar00rootroot00000000000000/* * 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.java000066400000000000000000000124221333036534000245630ustar00rootroot00000000000000/* * 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 cbmc // used by monitorenter, monitorexit, wait, and notify // Not present in the original Object class public int cproverMonitorCount; public Object() { cproverMonitorCount = 0; } public final Class getClass() { /* * MODELS LIBRARY { * We make this call to Class.forName to ensure it is loaded * by CBMC even with --lazy-methods on. We have to do this * because the internal support for getClass use the model of * Class.forName. * } */ Class c = Class.forName(""); return CProver.nondetWithoutNullForNotModelled(); } 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() { // FIXME: the thread must own the lock when it calls notify } // See implementation of notify public final void notifyAll() { // FIXME: the thread must own the lock when it calls notifyAll } public final void wait(long timeout) throws InterruptedException { // FIXME: the thread must own the lock when it calls wait // FIXME: 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 Objecct 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) { //FIXME: 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 Objecct 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) { //FIXME: we shoud remove the call to this method from the call // stack appended to the thrown exception // 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.java000066400000000000000000000050501333036534000266130ustar00rootroot00000000000000/* * 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.java000066400000000000000000000041421333036534000312050ustar00rootroot00000000000000/* * 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.java000066400000000000000000000057411333036534000251310ustar00rootroot00000000000000/* * 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.java000066400000000000000000000044431333036534000266630ustar00rootroot00000000000000/* * 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.java000066400000000000000000000040501333036534000270410ustar00rootroot00000000000000/* * 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/StackOverflowError.java000066400000000000000000000044001333036534000271550ustar00rootroot00000000000000/* * 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.java000066400000000000000000004635351333036534000246420ustar00rootroot00000000000000/* * 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: * 

 *     String str = "abc";
 *

* is equivalent to: * 

 *     char data[] = {'a', 'b', 'c'};
 *     String str = new String(data);
 *

* Here are some more examples of how strings can be used: * 

 *     System.out.println("abc");
 *     String cde = "cde";
 *     System.out.println("abc" + cde);
 *     String c = "abc".substring(2,3);
 *     String d = cde.substring(1, 2);
 *
*

* 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 * @diffblue.untested */ 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 * @diffblue.untested */ public String(String original) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC // this.value = original.value; // this.hash = original.hash; } /** * 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.noSupport * @diffblue.todo implement using the version with offset and count arguments */ public String(char value[]) { CProver.notModelled(); // this.value = Arrays.copyOf(value, value.length); } /** * 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 * Does not throw exceptions. * @diffblue.untested */ public String(char value[], int offset, int count) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC // 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); } /** * 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.noSupport * @diffblue.todo Implement assuming ASCII. */ public String(int[] codePoints, int offset, int count) { CProver.notModelled(); // 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; } /** * 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.noSupport */ @Deprecated public String(byte ascii[], int hibyte, int offset, int count) { CProver.notModelled(); // 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; } /** * 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: * * 

     *     c == (char)(((hibyte & 0xff) << 8)
     *                         | (b & 0xff))
     *
* * @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.noSupport */ @Deprecated public String(byte ascii[], int hibyte) { CProver.notModelled(); // 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. */ // DIFFBLUE MODEL LIBRARY Unused private method // 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.noSupport * @diffblue.todo Implement assuming ASCII. */ public String(byte bytes[], int offset, int length, String charsetName) throws UnsupportedEncodingException { CProver.notModelled(); // if (charsetName == null) // throw new NullPointerException("charsetName"); // checkBounds(bytes, offset, length); // this.value = StringCoding.decode(charsetName, bytes, offset, length); } /** * 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.noSupport */ public String(byte bytes[], int offset, int length, Charset charset) { CProver.notModelled(); // if (charset == null) // throw new NullPointerException("charset"); // checkBounds(bytes, offset, length); // this.value = StringCoding.decode(charset, bytes, offset, length); } /** * 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.noSupport */ public String(byte bytes[], String charsetName) throws UnsupportedEncodingException { CProver.notModelled(); // 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. * Generated tests will not pass if the function under test takes a * Charset argument because it is set using reflection. */ 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.noSupport */ public String(byte bytes[], int offset, int length) { CProver.notModelled(); // checkBounds(bytes, offset, length); // this.value = StringCoding.decode(bytes, offset, length); } /** * 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.noSupport */ public String(byte bytes[]) { CProver.notModelled(); // 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.noSupport */ public String(StringBuffer buffer) { CProver.notModelled(); // 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: * * * @diffblue.noSupport */ public void getChars(int srcBegin, int srcEnd, char 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); // } // System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin); } /** * 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: * * * @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: *

* Will enforce the string is composed of ASCII characters when the argument * equals one of the following: * * 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 getBytesEnforceAscii(); CProver.assume(CProverString.equals(charsetName, "UTF-8")); return getBytesEnforceAscii(); // 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: *

* 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: * * Will enforce the string is composed of ASCII characters if the argument * is one of the following: * * * 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 getBytesEnforceAscii(); } // 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[] getBytesEnforceAscii() { 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 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(); } 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(); } CProver.assume(CProverString.equals(charset.name(), "UTF-8") || CProverString.equals(charset.name(), "ISO-8859-1") || CProverString.equals(charset.name(), "US-ASCII")); return getBytesEnforceAscii(); } /** * 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 getBytesEnforceAscii(); } /** * 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 * @diffblue.untested */ public boolean equals(Object anObject) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC return CProver.nondetBoolean(); } /** * 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: *

* * @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: *

* * @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: *

* * @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.limitedSupport * We guarantee that two strings with different hash code have different * content, but the exact value will not correspond to the actual one. */ public int hashCode() { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC return CProver.nondetInt(); // 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; } /** * 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: * 

     * (this.charAt(k) == ch) {@code &&} (k >= fromIndex)
     *
* is true. For other values of {@code ch}, it is the * smallest value k such that: * 
     * (this.codePointAt(k) == ch) {@code &&} (k >= fromIndex)
     *
* 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: * 
     * (this.charAt(k) == ch) {@code &&} (k <= fromIndex)
     *
* is true. For other values of {@code ch}, it is the * largest value k such that: * 
     * (this.codePointAt(k) == ch) {@code &&} (k <= fromIndex)
     *
* 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.

* Examples: * 

     * "unhappy".substring(2) returns "happy"
     * "Harbison".substring(3) returns "bison"
     * "emptiness".substring(9) returns "" (an empty 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}. *

* Examples: * 

     * "hamburger".substring(4, 8) returns "urge"
     * "smiles".substring(1, 5) returns "mile"
     *
* * @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.

* Examples: * 

     * "cares".concat("s") returns "caress"
     * "to".concat("get").concat("her") returns "together"
     *
* * @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 * *

* {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#matches(String,CharSequence) * matches(regex, str)} *
* * @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 * *

* * {@link java.util.regex.Pattern}.{@link * java.util.regex.Pattern#compile compile}(regex).{@link * java.util.regex.Pattern#matcher(java.lang.CharSequence) matcher}(str).{@link * java.util.regex.Matcher#replaceFirst replaceFirst}(repl) * *
* *

* 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 * *

* * {@link java.util.regex.Pattern}.{@link * java.util.regex.Pattern#compile compile}(regex).{@link * java.util.regex.Pattern#matcher(java.lang.CharSequence) matcher}(str).{@link * java.util.regex.Matcher#replaceAll replaceAll}(repl) * *
* *

* 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 tests 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: * *

* * * * * * * * * * * * * * * * * * * * * * * *
RegexLimitResult
:2{@code { "boo", "and:foo" }}
:5{@code { "boo", "and", "foo" }}
:-2{@code { "boo", "and", "foo" }}
o5{@code { "b", "", ":and:f", "", "" }}
o-2{@code { "b", "", ":and:f", "", "" }}
o0{@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 * *

* * {@link java.util.regex.Pattern}.{@link * java.util.regex.Pattern#compile compile}(regex).{@link * java.util.regex.Pattern#split(java.lang.CharSequence,int) split}(str, n) * *
* * * @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.noSupport */ public String[] split(String regex, int limit) { CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); // /* fastpath if the regex is a // (1)one-char String and this character is not one of the // RegEx's meta characters ".$|()[{^?*+\\", or // (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); } /** * 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: * *

* * * * * * * * *
RegexResult
:{@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.noSupport */ public String[] split(String regex) { CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); // return split(regex, 0); } /** * 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 LocaleUpper CaseLower CaseDescription
tr (Turkish)\u0130\u0069capital letter I with dot above -> small letter i
tr (Turkish)\u0049\u0131capital letter I -> small letter dotless i
(all)French Friesfrench frieslowercased all chars in String
(all)capiotacapchi * capthetacapupsil * capsigmaiotachi * thetaupsilon * sigmalowercased 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 LocaleLower CaseUpper CaseDescription
tr (Turkish)\u0069\u0130small letter i -> capital letter I with dot above
tr (Turkish)\u0131\u0049small letter dotless i -> capital letter I
(all)\u00df\u0053 \u0053small letter sharp s -> two letters: SS
(all)FahrvergnügenFAHRVERGNÜ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; } /** * 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: *

* @diffblue.untested */ public static String format(String format, Object... args) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC return CProver.nondetWithoutNullForNotModelled(); // return new Formatter().format(format, args).toString(); } /** * 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(); CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * 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 * @diffblue.untested */ public static String valueOf(boolean b) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC return CProver.nondetWithoutNullForNotModelled(); // 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) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC return CProver.nondetWithNullForNotModelled(); // 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) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC return CProver.nondetWithoutNullForNotModelled(); // 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) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC return CProver.nondetWithoutNullForNotModelled(); // 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) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC return CProver.nondetWithoutNullForNotModelled(); // 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) { // DIFFBLUE MODEL LIBRARY This is treated internally in CBMC return CProver.nondetWithoutNullForNotModelled(); // return Double.toString(d); } /** * 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.noSupport */ // public native String intern(); public String intern() { CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } } java-models-library-master/src/main/java/java/lang/StringBuffer.java000066400000000000000000000777301333036534000257720ustar00rootroot00000000000000/* * 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 * @diffblue.untested */ @Override public synchronized StringBuffer append(int i) { // DIFFBLUE MODEL LIBRARY this is replaced internally // toStringCache = null; // super.append(i); // return this; return CProver.nondetWithoutNullForNotModelled(); } /** * @since 1.5 * * @diffblue.fullSupport * @diffblue.untested */ @Override public synchronized StringBuffer appendCodePoint(int codePoint) { // DIFFBLUE MODEL LIBRARY this is replaced internally // toStringCache = null; // super.appendCodePoint(codePoint); // return this; return CProver.nondetWithoutNullForNotModelled(); } /** * @diffblue.fullSupport * @diffblue.untested */ @Override public synchronized StringBuffer append(long lng) { // DIFFBLUE MODEL LIBRARY this is replaced internally // toStringCache = null; // super.append(lng); // return this; return CProver.nondetWithoutNullForNotModelled(); } /** * @diffblue.fullSupport * @diffblue.untested */ @Override public synchronized StringBuffer append(float f) { // DIFFBLUE MODEL LIBRARY this is replaced internally // toStringCache = null; // super.append(f); // return this; return CProver.nondetWithoutNullForNotModelled(); } /** * @diffblue.fullSupport * @diffblue.untested */ @Override public synchronized StringBuffer append(double d) { // DIFFBLUE MODEL LIBRARY this is replaced internally // toStringCache = null; // super.append(d); // return this; return CProver.nondetWithoutNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * @since 1.2 * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested */ @Override public synchronized StringBuffer delete(int start, int end) { // toStringCache = null; // super.delete(start, end); // return this; if (start < 0) throw new StringIndexOutOfBoundsException(start); if (end > this.length()) end = this.length(); if (start > end) throw new StringIndexOutOfBoundsException(); return CProverString.delete(this, start, end); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * @since 1.2 * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested */ @Override public synchronized StringBuffer deleteCharAt(int index) { // toStringCache = null; // super.deleteCharAt(index); // return this; if ((index < 0) || (index >= this.length())) throw new StringIndexOutOfBoundsException(index); return CProverString.deleteCharAt(this, index); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * @since 1.2 * * @diffblue.noSupport */ @Override public synchronized StringBuffer replace(int start, int end, String str) { // toStringCache = null; // super.replace(start, end, str); // return this; CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * @since 1.2 * * @diffblue.noSupport * Does not throw exceptions. */ @Override public synchronized String substring(int start) { // return substring(start, count); CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @throws IndexOutOfBoundsException {@inheritDoc} * @since 1.4 * * @diffblue.noSupport */ @Override public synchronized CharSequence subSequence(int start, int end) { // return super.substring(start, end); CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * @since 1.2 * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested. */ @Override public synchronized String substring(int start, int end) { // return super.substring(start, end); if (start < 0) throw new StringIndexOutOfBoundsException(start); if (end > this.length()) throw new StringIndexOutOfBoundsException(end); if (start > end) throw new StringIndexOutOfBoundsException(end - start); return CProverString.substring(this, start, end); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * @since 1.2 * * @diffblue.noSupport */ @Override public synchronized StringBuffer insert(int index, char[] str, int offset, int len) { // toStringCache = null; // super.insert(index, str, offset, len); // return this; CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public synchronized StringBuffer insert(int offset, Object obj) { // toStringCache = null; // super.insert(offset, String.valueOf(obj)); // return this; CProver.notModelled(); return this.insert(offset, obj.toString()); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested */ @Override public synchronized StringBuffer insert(int offset, String str) { if ((offset < 0) || (offset > length())) throw new StringIndexOutOfBoundsException(offset); // toStringCache = null; // super.insert(offset, str); // return this; return CProverString.insert(this, offset, str); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public synchronized StringBuffer insert(int offset, char[] str) { // toStringCache = null; // super.insert(offset, str); // return this; CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @throws IndexOutOfBoundsException {@inheritDoc} * @since 1.5 * * @diffblue.noSupport */ @Override public StringBuffer insert(int dstOffset, CharSequence s) { // // Note, synchronization achieved via invocations of other StringBuffer methods // // after narrowing of s to specific type // // Ditto for toStringCache clearing // super.insert(dstOffset, s); // return this; CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @throws IndexOutOfBoundsException {@inheritDoc} * @since 1.5 * * @diffblue.noSupport */ @Override public synchronized StringBuffer insert(int dstOffset, CharSequence s, int start, int end) { // toStringCache = null; // super.insert(dstOffset, s, start, end); // return this; CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested. */ @Override public StringBuffer insert(int offset, boolean b) { // DIFFBLUE MODEL LIBRARY this is replaced internally // // Note, synchronization achieved via invocation of StringBuffer insert(int, String) // // after conversion of b to String by super class method // // Ditto for toStringCache clearing // super.insert(offset, b); // return this; if (offset < 0) throw new StringIndexOutOfBoundsException(offset); if (offset > this.length()) throw new StringIndexOutOfBoundsException(this.length()); return CProverString.insert(this, offset, b); } /** * @throws IndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested. */ @Override public synchronized StringBuffer insert(int offset, char c) { // DIFFBLUE MODEL LIBRARY this is replaced internally // toStringCache = null; // super.insert(offset, c); // return this; if (offset < 0) throw new IndexOutOfBoundsException(); if (offset > this.length()) throw new IndexOutOfBoundsException(); return CProverString.insert(this, offset, c); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested. */ @Override public StringBuffer insert(int offset, int i) { // DIFFBLUE MODEL LIBRARY this is replaced internally // // Note, synchronization achieved via invocation of StringBuffer insert(int, String) // // after conversion of i to String by super class method // // Ditto for toStringCache clearing // super.insert(offset, i); // return this; if (offset < 0) throw new StringIndexOutOfBoundsException(offset); if (offset > this.length()) throw new StringIndexOutOfBoundsException(this.length()); return CProverString.insert(this, offset, i); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested. */ @Override public StringBuffer insert(int offset, long l) { // DIFFBLUE MODEL LIBRARY this is replaced internally // // Note, synchronization achieved via invocation of StringBuffer insert(int, String) // // after conversion of l to String by super class method // // Ditto for toStringCache clearing // super.insert(offset, l); // return this; if (offset < 0) throw new StringIndexOutOfBoundsException(offset); if (offset > this.length()) throw new StringIndexOutOfBoundsException(this.length()); return CProverString.insert(this, offset, l); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public StringBuffer insert(int offset, float f) { // // Note, synchronization achieved via invocation of StringBuffer insert(int, String) // // after conversion of f to String by super class method // // Ditto for toStringCache clearing // super.insert(offset, f); // return this; CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public StringBuffer insert(int offset, double d) { // // Note, synchronization achieved via invocation of StringBuffer insert(int, String) // // after conversion of d to String by super class method // // Ditto for toStringCache clearing // super.insert(offset, d); // return this; CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @since 1.4 * * @diffblue.noSupport */ @Override public int indexOf(String str) { // // Note, synchronization achieved via invocations of other StringBuffer methods // return super.indexOf(str); CProver.notModelled(); return CProver.nondetInt(); } /** * @since 1.4 * * @diffblue.noSupport */ @Override public synchronized int indexOf(String str, int fromIndex) { // return super.indexOf(str, fromIndex); CProver.notModelled(); return CProver.nondetInt(); } /** * @since 1.4 * * @diffblue.noSupport */ @Override public int lastIndexOf(String str) { // // Note, synchronization achieved via invocations of other StringBuffer methods // return lastIndexOf(str, count); CProver.notModelled(); return CProver.nondetInt(); } /** * @since 1.4 * * @diffblue.noSupport */ @Override public synchronized int lastIndexOf(String str, int fromIndex) { // return super.lastIndexOf(str, fromIndex); CProver.notModelled(); return CProver.nondetInt(); } /** * @since JDK1.0.2 * * @diffblue.noSupport */ @Override public synchronized StringBuffer reverse() { // toStringCache = null; // super.reverse(); // return this; CProver.notModelled(); return CProver.nondetWithoutNullForNotModelled(); } /** * @diffblue.fullSupport * @diffblue.untested */ @Override public synchronized String toString() { // DIFFBLUE MODEL LIBRARY this is replaced internally // if (toStringCache == null) { // toStringCache = Arrays.copyOfRange(value, 0, count); // } // return new String(toStringCache, true); return CProver.nondetWithoutNullForNotModelled(); } /** * Serializable fields for StringBuffer. * * @serialField value char[] * The backing character array of this StringBuffer. * @serialField count int * The number of characters in this StringBuffer. * @serialField shared boolean * A flag indicating whether the backing array is shared. * The value is ignored upon deserialization. */ // private static final java.io.ObjectStreamField[] serialPersistentFields = // { // new java.io.ObjectStreamField("value", char[].class), // new java.io.ObjectStreamField("count", Integer.TYPE), // new java.io.ObjectStreamField("shared", Boolean.TYPE), // }; /** * readObject is called to restore the state of the StringBuffer from * a stream. */ // private synchronized void writeObject(java.io.ObjectOutputStream s) // throws java.io.IOException { // java.io.ObjectOutputStream.PutField fields = s.putFields(); // fields.put("value", value); // fields.put("count", count); // fields.put("shared", false); // s.writeFields(); // } /** * readObject is called to restore the state of the StringBuffer from * a stream. */ // private void readObject(java.io.ObjectInputStream s) // throws java.io.IOException, ClassNotFoundException { // java.io.ObjectInputStream.GetField fields = s.readFields(); // value = (char[])fields.get("value", null); // count = fields.get("count", 0); // } } java-models-library-master/src/main/java/java/lang/StringBuilder.java000066400000000000000000000500521333036534000261330ustar00rootroot00000000000000/* * 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: Handled internally by CBMC // super.append(str); // return this; return CProver.nondetWithNullForNotModelled(); } /** * @throws IndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public StringBuilder append(char[] str, int offset, int len) { // super.append(str, offset, len); // return this; CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); } /** * @diffblue.fullSupport * @diffblue.untested */ @Override public StringBuilder append(boolean b) { // super.append(b); // return this; return append(String.valueOf(b)); } /** * @diffblue.fullSupport * @diffblue.untested */ @Override public StringBuilder append(char c) { // super.append(c); // return this; return append(String.valueOf(c)); } /** * @diffblue.fullSupport * @diffblue.untested */ @Override public StringBuilder append(int i) { // super.append(i); // return this; return append(String.valueOf(i)); } /** * @diffblue.fullSupport * @diffblue.untested */ @Override public StringBuilder append(long lng) { // super.append(lng); // return this; return append(String.valueOf(lng)); } /** * @diffblue.limitedSupport * Result string is an approximate the value. * @diffblue.untested */ @Override public StringBuilder append(float f) { // super.append(f); // return this; return append(String.valueOf(f)); } /** * @diffblue.limitedSupport * Result string is an approximate the value. * @diffblue.untested */ @Override public StringBuilder append(double d) { // super.append(d); // return this; return append(String.valueOf(d)); } /** * @since 1.5 * * @diffblue.fullSupport * @diffblue.untested */ @Override public StringBuilder appendCodePoint(int codePoint) { // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC // super.appendCodePoint(codePoint); // return this; return CProver.nondetWithNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested. */ @Override public StringBuilder delete(int start, int end) { // super.delete(start, end); // return this; if (start < 0) throw new StringIndexOutOfBoundsException(start); if (end > this.length()) end = this.length(); if (start > end) throw new StringIndexOutOfBoundsException(); return CProverString.delete(this, start, end); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * @diffblue.fullSupport * @diffblue.untested Only exception support is tested. * */ @Override public StringBuilder deleteCharAt(int index) { // super.deleteCharAt(index); // return this; if ((index < 0) || (index >= this.length())) throw new StringIndexOutOfBoundsException(index); return CProverString.deleteCharAt(this, index); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public StringBuilder replace(int start, int end, String str) { // super.replace(start, end, str); // return this; CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public StringBuilder insert(int index, char[] str, int offset, int len) { // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC // super.insert(index, str, offset, len); // return this; CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public StringBuilder insert(int offset, Object obj) { // super.insert(offset, obj); // return this; CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested */ @Override public StringBuilder insert(int offset, String str) { // super.insert(offset, str); // return this; if ((offset < 0) || (offset > length())) throw new StringIndexOutOfBoundsException(offset); return CProverString.insert(this, offset, str); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public StringBuilder insert(int offset, char[] str) { // super.insert(offset, str); // return this; CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); } /** * @throws IndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public StringBuilder insert(int dstOffset, CharSequence s) { // super.insert(dstOffset, s); // return this; CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); } /** * @throws IndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport */ @Override public StringBuilder insert(int dstOffset, CharSequence s, int start, int end) { // super.insert(dstOffset, s, start, end); // return this; CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested */ @Override public StringBuilder insert(int offset, boolean b) { // super.insert(offset, b); // return this; if ((offset < 0) || (offset > length())) throw new StringIndexOutOfBoundsException(offset); return CProverString.insert(this, offset, b); } /** * @throws IndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested */ @Override public StringBuilder insert(int offset, char c) { // super.insert(offset, c); // return this; if ((offset < 0) || (offset > length())) throw new IndexOutOfBoundsException(); return CProverString.insert(this, offset, c); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested Only exception throwing is tested */ @Override public StringBuilder insert(int offset, int i) { // super.insert(offset, i); // return this; if ((offset < 0) || (offset > length())) throw new StringIndexOutOfBoundsException(offset); return CProverString.insert(this, offset, i); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.fullSupport * @diffblue.untested * @diffblue.untested Only exception throwing is tested */ @Override public StringBuilder insert(int offset, long l) { // super.insert(offset, l); // return this; if ((offset < 0) || (offset > length())) throw new StringIndexOutOfBoundsException(offset); return CProverString.insert(this, offset, l); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.limitedSupport * Value of the floating point is approximated. * @diffblue.untested Only exception throwing is tested */ @Override public StringBuilder insert(int offset, float f) { // super.insert(offset, f); // return this; if ((offset < 0) || (offset > length())) throw new StringIndexOutOfBoundsException(offset); return CProverString.insert(this, offset, f); } /** * @throws StringIndexOutOfBoundsException {@inheritDoc} * * @diffblue.noSupport * Value of the floating point is approximated. * @diffblue.untested Only exception throwing is tested * @diffblue.todo Handle CProverString.insert(StringBuilder, int, double) * in jbmc. */ @Override public StringBuilder insert(int offset, double d) { // super.insert(offset, d); // return this; if ((offset < 0) || (offset > length())) throw new StringIndexOutOfBoundsException(offset); return CProverString.insert(this, offset, d); } /** * @diffblue.noSupport */ @Override public int indexOf(String str) { // return super.indexOf(str); CProver.notModelled(); return CProver.nondetInt(); } /** * @diffblue.noSupport */ @Override public int indexOf(String str, int fromIndex) { // return super.indexOf(str, fromIndex); CProver.notModelled(); return CProver.nondetInt(); } /** * @diffblue.noSupport */ @Override public int lastIndexOf(String str) { // return super.lastIndexOf(str); CProver.notModelled(); return CProver.nondetInt(); } /** * @diffblue.noSupport */ @Override public int lastIndexOf(String str, int fromIndex) { // return super.lastIndexOf(str, fromIndex); CProver.notModelled(); return CProver.nondetInt(); } /** * @diffblue.noSupport */ @Override public StringBuilder reverse() { // super.reverse(); // return this; CProver.notModelled(); return CProver.nondetWithNullForNotModelled(); } /** * @diffblue.fullSupport * @diffblue.untested */ @Override public String toString() { // DIFFBLUE MODEL LIBRARY: Handled internally by CBMC // // Create a copy, don't share the array // return new String(value, 0, count); return CProver.nondetWithNullForNotModelled(); } /** * Save the state of the {@code StringBuilder} instance to a stream * (that is, serialize it). * * @serialData the number of characters currently stored in the string * builder ({@code int}), followed by the characters in the * string builder ({@code char[]}). The length of the * {@code char} array may be greater than the number of * characters currently stored in the string builder, in which * case extra characters are ignored. */ // private void writeObject(java.io.ObjectOutputStream s) // throws java.io.IOException { // s.defaultWriteObject(); // s.writeInt(count); // s.writeObject(value); // } /** * readObject is called to restore the state of the StringBuffer from * a stream. */ // private void readObject(java.io.ObjectInputStream s) // throws java.io.IOException, ClassNotFoundException { // s.defaultReadObject(); // count = s.readInt(); // value = (char[]) s.readObject(); // } } java-models-library-master/src/main/java/java/lang/StringIndexOutOfBoundsException.java000066400000000000000000000040721333036534000316240ustar00rootroot00000000000000/* * 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.java000066400000000000000000002425311333036534000245720ustar00rootroot00000000000000/* * 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: *

*

* 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: * 

 *     class PrimeThread extends Thread {
 *         long minPrime;
 *         PrimeThread(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *              . . .
 *         }
 *     }
 *
*

* 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: * 

 *     class PrimeRun implements Runnable {
 *         long minPrime;
 *         PrimeRun(long minPrime) {
 *             this.minPrime = minPrime;
 *         }
 *
 *         public void run() {
 *             // compute primes larger than minPrime
 *              . . .
 *         }
 *     }
 *
*

* 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 // // * // // *

// // * {@linkplain #join(long) join}{@code (0)} // // *
// // * // // * @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: // // *

// // * // // *

// // * 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: // // *

// // * // // *

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: // // *

// // */ // // 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.java000066400000000000000000001371461333036534000253170ustar00rootroot00000000000000/* * 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(); } /** * 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: * * 

     * try {
     *     lowLevelOp();
     * } catch (LowLevelException le) {
     *     throw (HighLevelException)
     *           new HighLevelException().initCause(le); // Legacy constructor
     * }
     *
* * @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: * * 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: * 
     * public class Junk {
     *     public static void main(String args[]) {
     *         try {
     *             a();
     *         } catch(HighLevelException e) {
     *             e.printStackTrace();
     *         }
     *     }
     *     static void a() throws HighLevelException {
     *         try {
     *             b();
     *         } catch(MidLevelException e) {
     *             throw new HighLevelException(e);
     *         }
     *     }
     *     static void b() throws MidLevelException {
     *         c();
     *     }
     *     static void c() throws MidLevelException {
     *         try {
     *             d();
     *         } catch(LowLevelException e) {
     *             throw new MidLevelException(e);
     *         }
     *     }
     *     static void d() throws LowLevelException {
     *        e();
     *     }
     *     static void e() throws LowLevelException {
     *         throw new LowLevelException();
     *     }
     * }
     *
     * class HighLevelException extends Exception {
     *     HighLevelException(Throwable cause) { super(cause); }
     * }
     *
     * class MidLevelException extends Exception {
     *     MidLevelException(Throwable cause)  { super(cause); }
     * }
     *
     * class LowLevelException extends Exception {
     * }
     *
* 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.java000066400000000000000000000040101333036534000301710ustar00rootroot00000000000000/* * 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.java000066400000000000000000000043371333036534000260340ustar00rootroot00000000000000/* * 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.java000066400000000000000000000045331333036534000274670ustar00rootroot00000000000000/* * 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.java000066400000000000000000000045771333036534000312670ustar00rootroot00000000000000/* * 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.java000066400000000000000000000041601333036534000314450ustar00rootroot00000000000000/* * 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.java000066400000000000000000000044031333036534000256330ustar00rootroot00000000000000/* * 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.java000066400000000000000000000072501333036534000273050ustar00rootroot00000000000000/* * 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/util/000077500000000000000000000000001333036534000225455ustar00rootroot00000000000000java-models-library-master/src/main/java/java/util/Random.java000066400000000000000000001552211333036534000246360ustar00rootroot00000000000000/* * 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.noSupport * Due to TG-2435.
* We currently ignore seeds and make test-generator pick return values * for the methods in this class nondeterministically rather than * calculating them according to a probability distribution. So this * method is simply modelled as a no-op. * * @diffblue.mock */ synchronized public void setSeed(long seed) { // this.seed.set(initialScramble(seed)); // haveNextNextGaussian = false; } /** * Generates the next pseudorandom number. Subclasses should * override this, as this is used by all other methods. * *

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 * 

{@code (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)}
* and returning * 
{@code (int)(seed >>> (48 - bits))}.
* * 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.noSupport * Due to TG-2435.
* This method sets each entry of the argument to a nondeterministic * {@code byte} value. * The nondeterminism is introduced by test-generator itself, and * probability distributions are ignored. * * @diffblue.mock */ public void nextBytes(byte[] bytes) { // for (int i = 0, len = bytes.length; i < len; ) // for (int rnd = nextInt(), // n = Math.min(len - i, Integer.SIZE/Byte.SIZE); // n-- > 0; rnd >>= Byte.SIZE) // bytes[i++] = (byte)rnd; for (int i = 0; i < bytes.length; i++) { byte b = CProver.nondetByte(); bytes[i] = b; } } /** * The form of nextLong used by LongStream Spliterators. If * origin is greater than bound, acts as unbounded form of * nextLong, else as bounded form. * * @param origin the least value, unless greater than bound * @param bound the upper bound (exclusive), must not equal origin * @return a pseudorandom value */ // DIFFBLUE MODEL LIBRARY // This package-private method is not used in the model. // final long internalNextLong(long origin, long bound) { // long r = nextLong(); // if (origin < bound) { // long n = bound - origin, m = n - 1; // if ((n & m) == 0L) // power of two // r = (r & m) + origin; // else if (n > 0L) { // reject over-represented candidates // for (long u = r >>> 1; // ensure nonnegative // u + m - (r = u % n) < 0L; // rejection check // u = nextLong() >>> 1) // retry // ; // r += origin; // } // else { // range not representable as long // while (r < origin || r >= bound) // r = nextLong(); // } // } // return r; // } /** * The form of nextInt used by IntStream Spliterators. * For the unbounded case: uses nextInt(). * For the bounded case with representable range: uses nextInt(int bound) * For the bounded case with unrepresentable range: uses nextInt() * * @param origin the least value, unless greater than bound * @param bound the upper bound (exclusive), must not equal origin * @return a pseudorandom value */ // DIFFBLUE MODEL LIBRARY // This package-private method is not used in the model. // final int internalNextInt(int origin, int bound) { // if (origin < bound) { // int n = bound - origin; // if (n > 0) { // return nextInt(n) + origin; // } // else { // range not representable as int // int r; // do { // r = nextInt(); // } while (r < origin || r >= bound); // return r; // } // } // else { // return nextInt(); // } // } /** * The form of nextDouble used by DoubleStream Spliterators. * * @param origin the least value, unless greater than bound * @param bound the upper bound (exclusive), must not equal origin * @return a pseudorandom value */ // DIFFBLUE MODEL LIBRARY // This package-private method is not used in the model. // final double internalNextDouble(double origin, double bound) { // double r = nextDouble(); // if (origin < bound) { // r = r * (bound - origin) + origin; // if (r >= bound) // correct for rounding // r = Double.longBitsToDouble(Double.doubleToLongBits(bound) - 1); // } // return r; // } /** * Returns the next pseudorandom, uniformly distributed {@code int} * value from this random number generator's sequence. The general * contract of {@code nextInt} is that one {@code int} value is * pseudorandomly generated and returned. All 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: * 

 {@code
     * public boolean nextBoolean() {
     *   return next(1) != 0;
     * }}
* * @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: * 

 {@code
     * public float nextFloat() {
     *   return next(24) / ((float)(1 << 24));
     * }}
* *

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: * 

 {@code
     * public double nextDouble() {
     *   return (((long)next(26) << 27) + next(27))
     *     / (double)(1L << 53);
     * }}
* *

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: * 

 {@code
     *   return (((long)next(27) << 27) + next(27))
     *     / (double)(1L << 54);}
* 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: * 

 {@code
     * private double nextNextGaussian;
     * private boolean haveNextNextGaussian = false;
     *
     * public double nextGaussian() {
     *   if (haveNextNextGaussian) {
     *     haveNextNextGaussian = false;
     *     return nextNextGaussian;
     *   } else {
     *     double v1, v2, s;
     *     do {
     *       v1 = 2 * nextDouble() - 1;   // between -1.0 and 1.0
     *       v2 = 2 * nextDouble() - 1;   // between -1.0 and 1.0
     *       s = v1 * v1 + v2 * v2;
     *     } while (s >= 1 || s == 0);
     *     double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s);
     *     nextNextGaussian = v2 * multiplier;
     *     haveNextNextGaussian = true;
     *     return v1 * multiplier;
     *   }
     * }}
* 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/org/000077500000000000000000000000001333036534000214365ustar00rootroot00000000000000java-models-library-master/src/main/java/org/cprover/000077500000000000000000000000001333036534000231165ustar00rootroot00000000000000java-models-library-master/src/main/java/org/cprover/CProver.java000066400000000000000000000144421333036534000253460ustar00rootroot00000000000000package org.cprover; import java.io.BufferedInputStream; import java.io.PrintStream; public final class CProver { public static final boolean enableAssume=true; public static final boolean enableNondet=true; public static final boolean enableConcurrency=true; public static boolean nondetBoolean() { if (enableNondet) { throw new RuntimeException( "Cannot execute program with CProver.nondetBoolean()"); } return false; } public static byte nondetByte() { if (enableNondet) { throw new RuntimeException( "Cannot execute program with CProver.nondetByte()"); } return 0; } public static char nondetChar() { if (enableNondet) { throw new RuntimeException( "Cannot execute program with CProver.nondetChar()"); } return '\0'; } public static short nondetShort() { if (enableNondet) { throw new RuntimeException( "Cannot execute program with CProver.nondetShort()"); } return 0; } public static int nondetInt() { if (enableNondet) { throw new RuntimeException( "Cannot execute program with CProver.nondetInt()"); } return 0; } public static long nondetLong() { if (enableNondet) { throw new RuntimeException( "Cannot execute program with CProver.nondetLong()"); } return 0; } public static float nondetFloat() { if (enableNondet) { throw new RuntimeException( "Cannot execute program with CProver.nondetFloat()"); } return 0; } public static double nondetDouble() { if (enableNondet) { throw new RuntimeException( "Cannot execute program with CProver.nondetDouble()"); } return 0; } private static T nondetWithNull() { if (enableNondet) { throw new RuntimeException( "Cannot execute program with CProver.nondetWithNull(T)"); } return null; } /** * * @param instance an instance of the type T, this is not used but is there * to make sure the class T is loaded. The parameter should * not be `null`. * @param class of the object to return * @return a non-deterministic object of type T, possibly `null`. */ public static T nondetWithNull(T instance) { return nondetWithNull(); } private static T nondetWithoutNull() { T t = nondetWithNull(); assume(t != null); return t; } /** * * @param instance an instance of the type T, this is not used but is there * to make sure the class T is loaded. The parameter should * not be `null`. * @param class of the object to return * @return a non-deterministic object of type T, assumed to be non-null. */ public static T nondetWithoutNull(T instance) { return nondetWithoutNull(); } public static T nondetWithNullForNotModelled() { return nondetWithNull(); } public static T nondetWithoutNullForNotModelled() { return nondetWithoutNull(); } /** * Return a non-deterministic PrintStream. * It is not recommended to use it, since it will not enforce that PrintStream * is loaded, but is necessary for initializing System.out and System.err. */ public static PrintStream nondetPrintStream() { return nondetWithoutNull(); } /** * Return a non-deterministic BufferedInputStream. * It is not recommended to use it, since it will not enforce that * BufferedInputStream is loaded, but is necessary for initializing System.in. */ public static BufferedInputStream nondetBufferedInputStream() { return nondetWithoutNull(); } public static void assume(boolean condition) { if(enableAssume) { throw new RuntimeException( "Cannot execute program with CProver.assume()"); } } /** * This method is used by JBMC to detect the start of a new thread and * create a multithreaded bmc equation. * Refer to the method `start` in the model for the class `java.lang.Thread` * in the JBMC sources to see an example of usage */ public static void startThread(int id) { if(enableConcurrency) { throw new RuntimeException( "Cannot execute program with CProver.startThread()"); } } /** * This method is used by JBMC to detect the end of a new thread to * manage a multithreaded bmc equation * Refer to the method `start` in the model for the class `java.lang.Thread` * in the JBMC sources to see an example of usage */ public static void endThread(int id) { if(enableConcurrency) { throw new RuntimeException( "Cannot execute program with CProver.endThread()"); } } /** * This method is used by JBMC to return the ID of the executing thread. */ public static int getCurrentThreadID() { if(enableConcurrency) { throw new RuntimeException( "Cannot execute program with CProver.getCurrentThreadID()"); } return 0; } /** * This method is used by jbmc to indicate an atomic section which enforces * the bmc equation to avoid interleavings of the code inside the section */ public static void atomicBegin() { if(enableConcurrency) { throw new RuntimeException( "Cannot execute program with CProver.atomicBegin()"); } } /** * This method is used by jbmc to indicate the end of an atomic section * (see atomicBegin). */ public static void atomicEnd() { if(enableConcurrency) { throw new RuntimeException( "Cannot execute program with CProver.atomicEnd()"); } } /** * If this method is found in the test-gen trace for a particular trace, * that test will be discarded with a message explaining that the test * calls a non-modelled method. * This allows us to copy full classes from the JDK, and insert this function * call into non-modelled methods. We can then model a handful of the * methods on the class, ensuring that tests will only be generated for * 'known-good' models. */ public static void notModelled() { assume(false); } /** * Retrieves the current locking count for 'object'. */ public static int getMonitorCount(Object object) { return object.cproverMonitorCount; } } java-models-library-master/src/main/java/org/cprover/CProverString.java000066400000000000000000000325631333036534000265410ustar00rootroot00000000000000package org.cprover; /// This class provides an interface with string functions modeled internally /// in CProver, for which the CProver model differs from the JDK actual behavior. /// This is in particular the case for functions that throw exceptions. public final class CProverString { /** * Returns the character (Unicode code point) at the specified * index. * * @param instance the String instance * @param index the index to the {@code char} values * @return the code point value of the character at the * {@code index} */ public static int codePointAt(String instance, int index) { return CProver.nondetInt(); } /** * Returns the character (Unicode code point) before the specified * index. * * @param instance the String instance * @param index the index following the code point that should be returned * @return the code point value of the character before the * {@code index} */ public static int codePointBefore(String instance, int index) { return CProver.nondetInt(); } /** * Returns the number of Unicode code points in the specified text * range of this {@code String}. * * @param instance the String instance * @param beginIndex the index to the first {@code char} of * the text range. * @param endIndex the index after the last {@code char} of * the text range. * @return the number of Unicode code points in the specified text * range */ public static int codePointCount( String instance, int beginIndex, int endIndex) { return CProver.nondetInt(); } /** * Returns the index within this {@code String} that is * offset from the given {@code index} by * {@code codePointOffset} code points. * * @param instance the String instance * @param index the index to be offset * @param codePointOffset the offset in code points * @return the index within this {@code String} */ public static int offsetByCodePoints( String instance, int index, int codePointOffset) { return CProver.nondetInt(); } /// Modeled internally in CBMC. /// @return '\u0000' if index is out of bounds and behave as s.charAt(i) /// otherwise. public static char charAt(String s, int i) { return CProver.nondetChar(); } /// Modeled internally in CBMC. /// @return empty string if index is too large, s if index too small and /// behave as s.substring(i) otherwise. public static String substring(String s, int i) { return CProver.nondetWithoutNullForNotModelled(); } /// Modeled internally in CBMC. /// @return empty string if i >= j, s.substring(k, l) where k = max(0, i) /// and l = min(s.length() - 1, j) otherwise. public static String substring(String s, int i, int j) { return CProver.nondetWithoutNullForNotModelled(); } /** * Returns a character sequence that is a subsequence of this sequence. * * @param instance the String instance * @param beginIndex the begin index, inclusive. * @param endIndex the end index, exclusive. * @return the specified subsequence. */ public static CharSequence subSequence( String s, int beginIndex, int endIndex) { return CProver.nondetWithoutNullForNotModelled(); } /** * Appends a subsequence of the specified {@code CharSequence} to this * sequence. * * @param instance the StringBuilder instance * @param s the sequence to append. * @param start the starting index of the subsequence to be appended. * @param end the end index of the subsequence to be appended. * @return the modified StringBuilder. */ public static StringBuilder append( StringBuilder instance, CharSequence cs, int start, int end) { return CProver.nondetWithoutNullForNotModelled(); } /** * Removes the characters in a substring of this sequence. * * @param instance the StringBuilder instance * @param start The beginning index, inclusive. * @param end The ending index, exclusive. * @return the modified StringBuilder. */ public static StringBuilder delete( StringBuilder instance, int start, int end) { return CProver.nondetWithoutNullForNotModelled(); } /** * Removes the {@code char} at the specified position in this * sequence. This sequence is shortened by one {@code char}. * * @param instance the StringBuilder instance * @param index Index of {@code char} to remove * @return the modified StringBuilder. */ public static StringBuilder deleteCharAt( StringBuilder instance, int index) { return CProver.nondetWithoutNullForNotModelled(); } /** * Equality of two strings. Should be much more efficient for * test-genaration than String.equals because the type is known at * compilation time. */ public static boolean equals(String a, String b) { if (a == null) { return b == null; } return a.length() == b.length() && a.startsWith(b); } /** * Inserts the string into this character sequence. * * @param instance the StringBuilder instance * @param offset the offset. * @param str a string. * @return the modified StringBuilder. */ public static StringBuilder insert( StringBuilder instance, int offset, String str) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code boolean} * argument into this sequence. * * @param instance the StringBuilder instance * @param offset the offset. * @param b a {@code boolean}. * @return the modified StringBuilder. */ public static StringBuilder insert( StringBuilder instance, int offset, boolean b) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code char} * argument into this sequence. * * @param instance the StringBuilder instance * @param offset the offset. * @param c a {@code char}. * @return the modified StringBuilder. */ public static StringBuilder insert( StringBuilder instance, int offset, char c) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code int} * argument into this sequence. * * @param instance the StringBuilder instance * @param offset the offset. * @param b a {@code int}. * @return the modified StringBuilder. */ public static StringBuilder insert( StringBuilder instance, int offset, int i) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code long} * argument into this sequence. * * @param instance the StringBuilder instance * @param offset the offset. * @param b a {@code long}. * @return the modified StringBuilder. */ public static StringBuilder insert( StringBuilder instance, int offset, long l) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code float} * argument into this sequence. * * @param instance the StringBuilder instance * @param offset the offset. * @param b a {@code float}. * @return the modified StringBuilder. */ public static StringBuilder insert( StringBuilder instance, int offset, float f) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code double} * argument into this sequence. * * @param instance the StringBuilder instance * @param offset the offset. * @param b a {@code double}. * @return the modified StringBuilder. */ public static StringBuilder insert( StringBuilder instance, int offset, double d) { return CProver.nondetWithoutNullForNotModelled(); } /** * Sets the length of the character sequence. * * @param instance the StringBuffer instance * @param newLength the new length */ public static void setLength(StringBuffer instance, int newLength) { } /** * Returns the {@code char} value in this sequence at the specified index. * * @param instance the StringBuffer instance * @param index the index of the desired {@code char} value. * @return the {@code char} value at the specified index. */ public static char charAt(StringBuffer instance, int index) { return CProver.nondetChar(); } /** * The character at the specified index is set to {@code ch}. * * @param instance the StringBuffer instance * @param index the index of the character to modify. * @param ch the new character. */ public static void setCharAt(StringBuffer instance, int index, char c) { } /** * Removes the characters in a substring of this sequence. * * @param instance the StringBuffer instance * @param start the beginning index, inclusive. * @param end the ending index, exclusive. * @return The modified StringBuffer. */ public static StringBuffer delete( StringBuffer instance, int start, int end) { return CProver.nondetWithoutNullForNotModelled(); } /** * Removes the {@code char} at the specified position in this * sequence. This sequence is shortened by one {@code char}. * *

Note: If the character at the given index is a supplementary * character, this method does not remove the entire character. If * correct handling of supplementary characters is required, * determine the number of {@code char}s to remove by calling * {@code Character.charCount(thisSequence.codePointAt(index))}, * where {@code thisSequence} is this sequence. * * @param instance the StringBuffer instance. * @param index index of {@code char} to remove * @return this object. */ public static StringBuffer deleteCharAt(StringBuffer instance, int index) { return CProver.nondetWithoutNullForNotModelled(); } /** * Returns a new {@code String} that contains a subsequence of * characters currently contained in this sequence. * * @param instance the StringBuffer instance. * @param start the beginning index, inclusive. * @param end the ending index, exclusive. * @return The new string. */ public static String substring(StringBuffer instance, int start, int end) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string into this character sequence. * * @param instance the StringBuffer instance. * @param offset the offset. * @param str a string. * @return The modified StringBuffer. */ public static StringBuffer insert( StringBuffer instance, int offset, String str) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code boolean} * argument into this sequence. * * @param offset the offset. * @param b a {@code boolean}. * @return a reference to this object. */ public static StringBuffer insert( StringBuffer instance, int offset, boolean b) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code char} * argument into this sequence. * * @param offset the offset. * @param c a {@code char}. * @return a reference to this object. */ public static StringBuffer insert( StringBuffer instance, int offset, char c) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code int} * argument into this sequence. * * @param offset the offset. * @param i a {@code int}. * @return a reference to this object. */ public static StringBuffer insert( StringBuffer instance, int offset, int i) { return CProver.nondetWithoutNullForNotModelled(); } /** * Inserts the string representation of the {@code long} * argument into this sequence. * * @param offset the offset. * @param l a {@code long}. * @return a reference to this object. */ public static StringBuffer insert( StringBuffer instance, int offset, long l) { return CProver.nondetWithoutNullForNotModelled(); } } java-models-library-master/src/main/java/org/cprover/MustNotThrow.java000066400000000000000000000004071333036534000264170ustar00rootroot00000000000000package org.cprover; /** * This can be added to methods to indicate they aren't allowed to throw * exceptions. JBMC and related tools will truncate any execution path on which * they do with an ASSUME FALSE instruction. */ public @interface MustNotThrow { }