DynComp fixes

Makefile

@@ -10,9 +10,13 @@ CHECKLINK ?= ${DAIKONDIR}/.utils/checklink
 PLUME_SCRIPTS ?= ${DAIKONDIR}/.utils/plume-scripts
 
 ifeq (,$(wildcard ${PLUME_SCRIPTS}))
-  dummy := $(shell mkdir ${DAIKONDIR}/.utils && git clone --depth=1 -q https://github.com/plume-lib/plume-scripts.git ${PLUME_SCRIPTS})
+  dummy := $(shell mkdir -p ${DAIKONDIR}/.utils && git clone --depth=1 -q https://github.com/plume-lib/plume-scripts.git ${PLUME_SCRIPTS})
 endif
 SORT_DIRECTORY_ORDER := ${PLUME_SCRIPTS}/sort-directory-order
+ifneq "$(wildcard ${SORT_DIRECTORY_ORDER})" "${SORT_DIRECTORY_ORDER}"
+  # The clone above did not happen or did not succeed, so sort-directory-order is not available.
+  SORT_DIRECTORY_ORDER := sort
+endif
 
 JAVA_RELEASE_NUMBER := $(shell java -version 2>&1 | head -1 | cut -d'"' -f2 | sed '/^1\./s///' | cut -d'.' -f1 | sed 's/-ea//')
 

java/daikon/chicory/Runtime.java

@@ -939,9 +939,11 @@ public Class<?> primitiveClass() {
     }
   }
 
+  /** The major version of the running JVM: 8 for Java 8, 24 for Java 24, and so on. */
+  private static final int javaMajorVersion = javaMajorVersion(System.getProperty("java.version"));
+
   /** True if the running JVM is for Java 9 or later. */
-  private static final boolean isJava9orLater =
-      !System.getProperty("java.version").startsWith("1.");
+  private static final boolean isJava9orLater = javaMajorVersion >= 9;
 
   /**
    * Returns true if the running JVM is for Java 9 or later.
@@ -953,10 +955,7 @@ public static boolean isJava9orLater() {
   }
 
   /** True if the running JVM is for Java 24 or later. */
-  private static final boolean isJava24orLater =
-      !System.getProperty("java.version").startsWith("1.")
-          && !System.getProperty("java.version").startsWith("9.")
-          && Integer.parseInt(System.getProperty("java.version").substring(0, 2)) >= 24;
+  private static final boolean isJava24orLater = javaMajorVersion >= 24;
 
   /**
    * Returns true if the running JVM is for Java 24 or later.
@@ -967,6 +966,43 @@ public static boolean isJava24orLater() {
     return isJava24orLater;
   }
 
+  /**
+   * Returns the major version encoded in a {@code java.version} property value: 8 for Java 8, 24
+   * for Java 24, and so on.
+   *
+   * <p>Both version schemes are accepted: the pre-Java-9 {@code "1.8.0_432"} form, whose major
+   * version is its second component, and the Java 9 and later {@code "24"}, {@code "24.0.1"}, and
+   * {@code "24-ea"} forms, whose major version is the first. In the latter scheme the major version
+   * may stand alone with no separator at all, as it does for a GA release such as {@code "9"}.
+   *
+   * <p>Only the leading digits are examined; anything after them is ignored rather than rejected,
+   * so {@code "9foo"} yields 9. That is deliberate. This runs from a static initializer, so
+   * throwing on an unrecognized suffix would turn an unanticipated vendor version string into an
+   * ExceptionInInitializerError inside an instrumented program, which is the failure this method
+   * exists to prevent. Ignoring the suffix instead yields the right major version for any string
+   * that begins with one. A value with no leading digits at all is still rejected.
+   *
+   * @param version the value of the {@code java.version} system property
+   * @return the major version it encodes
+   */
+  // Package-private rather than private so that RuntimeTest can exercise it directly; the value
+  // derived from the running JVM is fixed at class-initialization time and cannot be varied.
+  static int javaMajorVersion(String version) {
+    // Java 8 and earlier report "1.N..."; the major version is the second component.
+    String rest = version.startsWith("1.") ? version.substring(2) : version;
+    // The major version is the leading run of digits.  What follows it is "." for a release with
+    // minor components, "-" or "+" for a pre-release or build identifier, and nothing at all for a
+    // bare GA release such as "9".
+    int end = 0;
+    while (end < rest.length() && Character.isDigit(rest.charAt(end))) {
+      end++;
+    }
+    if (end == 0) {
+      throw new IllegalArgumentException("Cannot parse java.version: " + version);
+    }
+    return Integer.parseInt(rest.substring(0, end));
+  }
+
   // ///////////////////////////////////////////////////////////////////////////
   // Copied code
   //

java/daikon/chicory/RuntimeTest.java

@@ -0,0 +1,50 @@
+package daikon.chicory;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link daikon.chicory.Runtime}. */
+@RunWith(JUnit4.class)
+public class RuntimeTest {
+
+  /**
+   * Tests {@link Runtime#javaMajorVersion}. The values are real {@code java.version} strings; the
+   * bare "9" is the one that matters most, because Java 9 GA reported its version with no separator
+   * after the major number.
+   */
+  @Test
+  public void testJavaMajorVersion() {
+    // Java 8 and earlier: the major version is the second component.
+    assertEquals(8, Runtime.javaMajorVersion("1.8.0_432"));
+    assertEquals(7, Runtime.javaMajorVersion("1.7.0_80"));
+    // Java 9 and later, with minor components.
+    assertEquals(9, Runtime.javaMajorVersion("9.0.4"));
+    assertEquals(11, Runtime.javaMajorVersion("11.0.28"));
+    assertEquals(24, Runtime.javaMajorVersion("24.0.1"));
+    assertEquals(25, Runtime.javaMajorVersion("25.0.2"));
+    // Java 9 and later, major version alone.
+    assertEquals(9, Runtime.javaMajorVersion("9"));
+    assertEquals(24, Runtime.javaMajorVersion("24"));
+    // Pre-release and build identifiers.
+    assertEquals(9, Runtime.javaMajorVersion("9-ea"));
+    assertEquals(26, Runtime.javaMajorVersion("26-ea"));
+    assertEquals(26, Runtime.javaMajorVersion("26+11"));
+
+    // Trailing junk after the major version is ignored rather than rejected; this is deliberate,
+    // and javaMajorVersion's javadoc says why.  A value with no leading digits still throws.
+    assertEquals(9, Runtime.javaMajorVersion("9foo"));
+    assertThrows(IllegalArgumentException.class, () -> Runtime.javaMajorVersion("bogus"));
+  }
+
+  /** Tests that {@link Runtime#isJava24orLater} agrees with the JVM running the test. */
+  @Test
+  public void testIsJava24orLater() {
+    int major = Runtime.javaMajorVersion(System.getProperty("java.version"));
+    assertEquals(major >= 24, Runtime.isJava24orLater());
+    assertEquals(major >= 9, Runtime.isJava9orLater());
+  }
+}

java/daikon/dcomp/ClassGen24.java

@@ -64,9 +64,6 @@ public class ClassGen24 {
   /** True if this class is an interface. */
   private final boolean isInterface;
 
-  /** True if this class is static. */
-  private final boolean isStatic;
-
   /**
    * Creates a ClassGen24 object.
    *
@@ -85,7 +82,6 @@ public ClassGen24(
 
     accessFlags = classModel.flags();
     isInterface = accessFlags.has(AccessFlag.INTERFACE);
-    isStatic = accessFlags.has(AccessFlag.STATIC);
 
     superclassName = getSuperclassName(classModel);
 
@@ -147,15 +143,6 @@ public final boolean isInterface() {
     return isInterface;
   }
 
-  /**
-   * Returns true if this class is static.
-   *
-   * @return true if this class is static
-   */
-  public final boolean isStatic() {
-    return isStatic;
-  }
-
   /**
    * Returns this class's name, in binary format.
    *