scaffold for server to send and receive messages

.githooks/pre-commit.sh

@@ -2,7 +2,7 @@
 
 everything_staged=$(git diff --name-only)
 
-if [ -z "$everything_staged" ]; then
+if [ -n "$everything_staged" ]; then
   # Don't commit because, after we reformat, the formatting will be unstaged, but it's too hard to determine (and maybe
   # ambiguous) what are the formatting differences and what was originally unstaged.
   mvn spotless:check || {

.gitignore

@@ -1,3 +1,6 @@
+.snapshots/**/*.fail*
+
+### Build ###
 target/
 !.mvn/wrapper/maven-wrapper.jar
 !**/src/main/**/target/

pom.xml

@@ -59,6 +59,16 @@
     </dependency>
   </dependencies>
   <build>
+    <testResources>
+      <!-- Resources including R scripts which are treated as data -->
+      <testResource>
+        <directory>src/test/resources</directory>
+      </testResource>
+      <!-- R scripts which are treated as code -->
+      <testResource>
+        <directory>src/test/R</directory>
+      </testResource>
+    </testResources>
     <plugins>
       <!-- git-build-hook, install git hooks when you run any maven command so you don't forget -->
       <plugin>
@@ -257,6 +267,11 @@
       <plugin>
         <artifactId>maven-surefire-plugin</artifactId>
         <version>3.2.2</version>
+        <!-- Run tests in parallel. You can annotate tests with @NotThreadSafe if necessary -->
+        <configuration>
+          <parallel>all</parallel>
+          <threadCount>8</threadCount>
+        </configuration>
         <!-- automatically runs on `test` (and `verify` because `verify` invokes `test`) -->
       </plugin>
     </plugins>

src/main/java/org/prlprg/RVersion.java

@@ -0,0 +1,52 @@
+package org.prlprg;
+
+import javax.annotation.Nullable;
+
+/**
+ * Major.Minor.Patch version number with an optional suffix for things like "Beta" and "RC".
+ *
+ * <p>This class needs to support whatever format GNU-R versions can have. But it's not a GNU-R
+ * specific
+ */
+public record RVersion(int major, int minor, int patch, @Nullable String suffix) {
+  /** The latest version we handle. */
+  public static final RVersion LATEST_AWARE = new RVersion(4, 3, 2);
+
+  public static RVersion parse(String textual) {
+    var parts = textual.split("\\.");
+
+    int major;
+    int minor;
+    int patch;
+    try {
+      major = Integer.parseInt(parts[0]);
+      minor = Integer.parseInt(parts[1]);
+      patch = Integer.parseInt(parts[2]);
+    } catch (ArrayIndexOutOfBoundsException e) {
+      throw new IllegalArgumentException("Invalid version number: " + textual, e);
+    }
+
+    String suffix;
+    if (parts.length > 3) {
+      if (parts[3].startsWith("-")) {
+        suffix = parts[3].substring(1);
+      } else {
+        throw new IllegalArgumentException(
+            "Invalid version number: " + textual + " (suffix must start with '-')");
+      }
+    } else {
+      suffix = null;
+    }
+
+    return new RVersion(major, minor, patch, suffix);
+  }
+
+  RVersion(int major, int minor, int patch) {
+    this(major, minor, patch, null);
+  }
+
+  @Override
+  public String toString() {
+    return major + "." + minor + "." + patch + (suffix == null ? "" : "-" + suffix);
+  }
+}

src/main/java/org/prlprg/bc/BcCode.java

@@ -32,13 +32,54 @@ protected List<BcInstr> delegate() {
    */
   static BcCode fromRaw(ImmutableIntArray bytecodes, ConstPool.MakeIdx makePoolIdx)
       throws BcFromRawException {
+    if (bytecodes.isEmpty()) {
+      throw new BcFromRawException("Bytecode is empty, needs at least version number");
+    }
+    if (bytecodes.get(0) != Bc.R_BC_VERSION) {
+      throw new BcFromRawException("Unsupported bytecode version: " + bytecodes.get(0));
+    }
+
+    var labelMap = labelFactoryFromRaw(bytecodes);
+
     var builder = new Builder();
-    int i = 0;
+    int i = 1;
+    int sanityCheckJ = 0;
     while (i < bytecodes.length()) {
       try {
-        var instrAndI = BcInstrs.fromRaw(bytecodes, i, makePoolIdx);
-        builder.add(instrAndI.a());
+        var instrAndI = BcInstrs.fromRaw(bytecodes, i, labelMap, makePoolIdx);
+        var instr = instrAndI.a();
         i = instrAndI.b();
+
+        builder.add(instr);
+        sanityCheckJ++;
+
+        try {
+          var sanityCheckJFromI = labelMap.make(i).target;
+          if (sanityCheckJFromI != sanityCheckJ) {
+            throw new AssertionError(
+                "expected target offset " + sanityCheckJ + ", got " + sanityCheckJFromI);
+          }
+        } catch (IllegalArgumentException | AssertionError e) {
+          throw new AssertionError(
+              "BcInstrs.fromRaw and BcInstrs.sizeFromRaw are out of sync, at instruction " + instr,
+              e);
+        }
+      } catch (BcFromRawException e) {
+        throw new BcFromRawException(
+            "malformed bytecode at " + i + "\nBytecode up to this point: " + builder.build(), e);
+      }
+    }
+    return builder.build();
+  }
+
+  static BcLabel.Factory labelFactoryFromRaw(ImmutableIntArray bytecodes) {
+    var builder = new BcLabel.Factory.Builder();
+    int i = 1;
+    while (i < bytecodes.length()) {
+      try {
+        var size = BcInstrs.sizeFromRaw(bytecodes, i);
+        builder.step(size, 1);
+        i += size;
       } catch (BcFromRawException e) {
         throw new BcFromRawException(
             "malformed bytecode at " + i + "\nBytecode up to this point: " + builder.build(), e);