1 /* 2 * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package java.lang; 27 28 import java.io.PrintStream; 29 import java.util.ArrayList; 30 import java.util.List; 31 import java.util.Optional; 32 33 class VersionProps { 34 35 36 private static final String launcher_name = 37 "@@LAUNCHER_NAME@@"; 38 39 private static final String java_version = 40 "@@VERSION_SHORT@@"; 41 42 private static final String java_runtime_name = 43 "@@RUNTIME_NAME@@"; 44 45 private static final String java_runtime_version = 46 "@@VERSION_STRING@@"; 47 48 private static final String VERSION_NUMBER = 49 "@@VERSION_NUMBER@@"; 50 51 private static final String VERSION_BUILD = 52 "@@VERSION_BUILD@@"; 53 54 private static final String VERSION_PRE = 55 "@@VERSION_PRE@@"; 56 57 private static final String VERSION_OPT = 58 "@@VERSION_OPT@@"; 59 60 static { 61 init(); 62 } 63 64 public static void init() { 65 System.setProperty("java.version", java_version); 66 System.setProperty("java.runtime.version", java_runtime_version); 67 System.setProperty("java.runtime.name", java_runtime_name); 68 } 69 70 static List<Integer> versionNumbers() { 71 List<Integer> versionNumbers = new ArrayList<>(4); 72 int prevIndex = 0; 73 int index = VERSION_NUMBER.indexOf('.'); 74 while (index > 0) { 75 versionNumbers.add( 76 Integer.parseInt(VERSION_NUMBER, prevIndex, index, 10)); 77 prevIndex = index + 1; // Skip the period 78 index = VERSION_NUMBER.indexOf('.', prevIndex); 79 } 80 versionNumbers.add(Integer.parseInt(VERSION_NUMBER, 81 prevIndex, VERSION_NUMBER.length(), 10)); 82 return versionNumbers; 83 } 84 85 static Optional<String> pre() { 86 return optionalOf(VERSION_PRE); 87 } 88 89 static Optional<Integer> build() { 90 return VERSION_BUILD.isEmpty() ? 91 Optional.empty() : 92 Optional.of(Integer.parseInt(VERSION_BUILD)); 93 } 94 95 static Optional<String> optional() { 96 return optionalOf(VERSION_OPT); 97 } 98 99 // Treat empty strings as value not being present 100 private static Optional<String> optionalOf(String value) { 101 if (!value.isEmpty()) { 102 return Optional.of(value); 103 } else { 104 return Optional.empty(); 105 } 106 } 107 108 /** 109 * In case you were wondering this method is called by java -version. 110 * Sad that it prints to stderr; would be nicer if default printed on 111 * stdout. 112 */ 113 public static void print() { 114 print(System.err); 115 } 116 117 /** 118 * This is the same as print except that it adds an extra line-feed 119 * at the end, typically used by the -showversion in the launcher 120 */ 121 public static void println() { 122 print(System.err); 123 System.err.println(); 124 } 125 126 /** 127 * Give a stream, it will print version info on it. 128 */ 129 public static void print(PrintStream ps) { 130 boolean isHeadless = false; 131 132 /* Report that we're running headless if the property is true */ 133 String headless = System.getProperty("java.awt.headless"); 134 if ( (headless != null) && (headless.equalsIgnoreCase("true")) ) { 135 isHeadless = true; 136 } 137 138 /* First line: platform version. */ 139 ps.println(launcher_name + " version \"" + java_version + "\""); 140 141 /* Second line: runtime version (ie, libraries). */ 142 143 String jdk_debug_level = System.getProperty("jdk.debug", "release"); 144 /* Debug level is not printed for "release" builds */ 145 if ("release".equals(jdk_debug_level)) { 146 jdk_debug_level = ""; 147 } else { 148 jdk_debug_level = jdk_debug_level + " "; 149 } 150 151 ps.print(java_runtime_name + " (" + jdk_debug_level + "build " + java_runtime_version); 152 153 if (java_runtime_name.indexOf("Embedded") != -1 && isHeadless) { 154 // embedded builds report headless state 155 ps.print(", headless"); 156 } 157 ps.println(')'); 158 159 /* Third line: JVM information. */ 160 String java_vm_name = System.getProperty("java.vm.name"); 161 String java_vm_version = System.getProperty("java.vm.version"); 162 String java_vm_info = System.getProperty("java.vm.info"); 163 ps.println(java_vm_name + " (" + jdk_debug_level + "build " + java_vm_version + ", " + 164 java_vm_info + ")"); 165 } 166 167 }