From f7cc11d1b4a9852d9b03064238a8f4140b4ed992 Mon Sep 17 00:00:00 2001
From: Andrey Loskutov <loskutov@gmx.de>
Date: Mon, 6 Jun 2016 00:03:00 +0200
Subject: [PATCH] Properly parse Java 9 version, see #105 and #75

FB follows now the new JDK version scheme described in
http://openjdk.java.net/jeps/223.

Java versions before Java 9 will have 1 as major segment, and some
meaningful number as major segment starting with Java 9. This should
work for most cases.
---
 .../java/edu/umd/cs/findbugs/JavaVersion.java | 48 ++++++++++---------
 1 file changed, 25 insertions(+), 23 deletions(-)

diff --git a/findbugs/src/java/edu/umd/cs/findbugs/JavaVersion.java b/findbugs/src/java/edu/umd/cs/findbugs/JavaVersion.java
index 4e2c833a05..536e38f9b5 100644
--- a/findbugs/src/java/edu/umd/cs/findbugs/JavaVersion.java
+++ b/findbugs/src/java/edu/umd/cs/findbugs/JavaVersion.java
@@ -19,14 +19,10 @@
 
 package edu.umd.cs.findbugs;
 
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
 /**
  * Support for finding out what version of Java we're running on.
  */
 public class JavaVersion {
-    private static final Pattern PATTERN = Pattern.compile("^(\\d+)\\.(\\d+)(\\..*)?$");
 
     private final int major;
 
@@ -43,9 +39,8 @@ public class JavaVersion {
         try {
             runtimeVersion = new JavaVersion(SystemProperties.getProperty("java.version"));
         } catch (JavaVersionException e) {
-            System.err.println("Warning: Unknown version of Java");
-            // Assume Java 1.0.
-            runtimeVersion = new JavaVersion(1, 0);
+            // Assume Java 1.8.
+            runtimeVersion = new JavaVersion(1, 8);
             e.printStackTrace();
         }
     }
@@ -63,24 +58,31 @@ public class JavaVersion {
      *            <code>java.version</code> system property: e.g., "1.4.2_04"
      */
     public JavaVersion(String versionString) throws JavaVersionException {
-        Matcher matcher = PATTERN.matcher(versionString);
-        if (!matcher.matches()) {
-            if(versionString.startsWith("9")) {
-                major = 1;
-                minor = 9;
-                rest = "";
-                return;
-            } else {
-                throw new JavaVersionException("Could not parse Java version string: " + versionString);
-            }
-        }
+        // See https://bugs.openjdk.java.net/browse/JDK-8061493 for http://openjdk.java.net/jeps/223
+        // The only common between pre-9 and 9+ are the dots as separators...
+        String[] strings = versionString.split("\\.", 3);
         try {
-            major = Integer.parseInt(matcher.group(1));
-            minor = Integer.parseInt(matcher.group(2));
-            if (matcher.group(3) != null) {
-                rest = matcher.group(3);
+            // We need only care about 9+ early access in first segment
+            int earlyAccess = strings[0].indexOf('-');
+            if(earlyAccess > 0){
+                // 9+ early access versions do not follow common scheme above (it would be too easy)
+                // they look like 9-ea+73 and have only one meaningful (major) part for us.
+                major = Integer.parseInt(strings[0].substring(0, earlyAccess));
+                minor = 0;
+                rest = strings[0].substring(earlyAccess);
             } else {
-                rest = "";
+                major = Integer.parseInt(strings[0]);
+                if(strings.length > 1){
+                    minor = Integer.parseInt(strings[1]);
+                    if (strings.length > 2) {
+                        rest = strings[2];
+                    } else {
+                        rest = "";
+                    }
+                } else {
+                    minor = 0;
+                    rest = "";
+                }
             }
         } catch (NumberFormatException e) {
             throw new JavaVersionException("Could not parse Java Version string: " + versionString, e);