RELEASE_NOTES.md

@@ -71,7 +71,7 @@
   * Implement parsed data validations using `valid` key ([#435](https://github.com/kaitai-io/kaitai_struct/issues/435))
   * Implement compile-time `sizeof` and `bitsizeof` operators ([#84](https://github.com/kaitai-io/kaitai_struct/issues/84))
     * Type-based: `sizeof<u4>`, `bitsizeof<b13>`, `sizeof<user_type>`
-    * Value-based: `file_header._sizeof`, `flags._bitsizeof` (`file_header`, `flags` are fields defined in the current type)
+    * Value-based: `file_header._sizeof` (`file_header` is a field defined in the current type)
   * Implement little-endian bit-sized integers ([docs](https://doc.kaitai.io/user_guide.html#bit-ints-le))
     * Support choosing endianness using `le` / `be` suffix: `type: b12le`, `type: b1be`
     * Add `meta/bit-endian` key for selecting default bit endianness (`le` / `be`)

build.sbt

@@ -8,7 +8,7 @@ resolvers ++= Resolver.sonatypeOssRepos("public")
 
 val NAME = "kaitai-struct-compiler"
 val VERSION = "0.11-SNAPSHOT"
-val TARGET_LANGS = "C++/STL, C#, Go, Java, JavaScript, Lua, Nim, Perl, PHP, Python, Ruby"
+val TARGET_LANGS = "C++/STL, C#, Go, Java, JavaScript, Lua, Nim, Perl, PHP, Python, Ruby, Rust"
 val UTF8 = Charset.forName("UTF-8")
 
 lazy val root = project.in(file(".")).

jvm/src/main/scala/io/kaitai/struct/JavaMain.scala

@@ -210,35 +210,71 @@ object JavaMain {
     // Windows, custom install path with spaces and non-latin chars:
     // /G:/%d0%b3%d0%b4%d0%b5-%d1%82%d0%be%20%d1%82%d0%b0%d0%bc/lib/io.kaitai.kaitai-struct-compiler-0.10-SNAPSHOT.jar
 
-    val fStr = classOf[JavaMain].getProtectionDomain.getCodeSource.getLocation.getPath
-    Log.importOps.info(() => s"home path: location = $fStr")
-
-    if (fStr.endsWith(".jar")) {
-      val fDec = URLDecoder.decode(fStr, "UTF-8")
-      Log.importOps.info(() => s"... URL-decoded = $fDec")
-
-      val homeFile = new File(fDec).getParentFile.getParentFile
-      Log.importOps.info(() => s"... home = $homeFile")
-
-      if (homeFile.exists) {
-        val homeFormat = new File(homeFile, "formats")
-        Log.importOps.info(() => s"... formats = $homeFormat")
-        if (homeFormat.exists) {
-          Some(homeFormat.toString)
+    try {
+      optionOrLog(
+        classOf[JavaMain].getProtectionDomain.getCodeSource,
+        "home path: unable to run getCodeSource(), got null"
+      ).flatMap(sourceCode => optionOrLog(
+        sourceCode.getLocation,
+        "home path: unable to run getLocation(), got null"
+      )).flatMap(location => optionOrLog(
+        location.getPath,
+        "home path: unable to run getPath(), got null"
+      )).flatMap(fStr => {
+        Log.importOps.info(() => s"home path: location = $fStr")
+
+        if (fStr.endsWith(".jar")) {
+          val fDec = URLDecoder.decode(fStr, "UTF-8")
+          Log.importOps.info(() => s"... URL-decoded = $fDec")
+
+          val homeFile = new File(fDec).getParentFile.getParentFile
+          Log.importOps.info(() => s"... home = $homeFile")
+
+          if (homeFile.exists) {
+            val homeFormat = new File(homeFile, "formats")
+            Log.importOps.info(() => s"... formats = $homeFormat")
+            if (homeFormat.exists) {
+              Some(homeFormat.toString)
+            } else {
+              Log.importOps.info(() => "... home formats dir doesn't exist => fail")
+              None
+            }
+          } else {
+            Log.importOps.info(() => s"... home doesn't exist => no home import paths")
+            None
+          }
         } else {
-          Log.importOps.info(() => "... home formats dir doesn't exist => fail")
+          Log.importOps.info(() => s"... not a jar, we're not running a packaged app => no home")
           None
         }
-      } else {
-        Log.importOps.info(() => s"... home doesn't exist => no home import paths")
+      })
+    } catch {
+      case se: SecurityException =>
+        Log.importOps.info(() => s"home path: unable to run getProtectionDomain(), got SecurityException $se")
         None
-      }
-    } else {
-      Log.importOps.info(() => s"... not a jar, we're not running a packaged app => no home")
-      None
     }
   }
 
+  /**
+   * Helper method to wrap nullable value (coming from Java API) into Option.
+   * If it's null, we will bail out and won't process any longer due to a chain
+   * of flatMap(), but if we use this method, we'll also note in our logging which
+   * step failed, making it easier to diagnose.
+   * @param nullableValue value which is potentially null
+   * @param errMsg error message to show in case if it's null
+   * @tparam T type of potentially nullable value
+   * @return option-wrapped value
+   * @see [[scala.Option.apply()]]
+   */
+  private def optionOrLog[T](nullableValue: T, errMsg: String): Option[T] =
+    Option(nullableValue) match {
+      case None =>
+        Log.importOps.info(() => errMsg)
+        None
+      case someValue =>
+        someValue
+    }
+
   private def envPaths: List[String] =
     sys.env.get("KSPATH").toList.flatMap((x) => x.split(File.pathSeparatorChar))
 

jvm/src/test/scala/io/kaitai/struct/exprlang/ExpressionsSpec.scala

@@ -404,6 +404,21 @@ class ExpressionsSpec extends AnyFunSpec {
       Expressions.parse("foo.bar") should be (Attribute(Name(identifier("foo")),identifier("bar")))
     }
 
+    describe("strings") {
+      it("single-quoted") {
+        // \" -> \"
+        // \\ -> \\
+        Expressions.parse(""" ' \" \\ ' """) should be(Str(" \\\" \\\\ "))
+        Expressions.parse(""" 'ASCII\\x' """) should be(Str("ASCII\\\\x"))
+      }
+      it("double-quoted") {
+        // \" -> "
+        // \\ -> \
+        Expressions.parse(""" " \" \\ " """) should be(Str(" \" \\ "))
+        Expressions.parse(""" "ASCII\\'x" """) should be(Str("ASCII\\'x"))
+      }
+    }
+
     describe("f-strings") {
       it("parses f-string with just a string") {
         Expressions.parse("f\"abc\"") should be(InterpolatedStr(Seq(