Julia

shared/src/main/scala/io/kaitai/struct/JuliaClassCompiler.scala

@@ -0,0 +1,110 @@
+package io.kaitai.struct
+
+import io.kaitai.struct.datatype.DataType.{CalcIntType, KaitaiStreamType, UserType, UserTypeInstream}
+import io.kaitai.struct.datatype.{BigEndian, CalcEndian, Endianness, FixedEndian, LittleEndian}
+import io.kaitai.struct.exprlang.Ast
+import io.kaitai.struct.format._
+import io.kaitai.struct.languages.JuliaCompiler
+import io.kaitai.struct.languages.components.ExtraAttrs
+
+class JuliaClassCompiler(
+  classSpecs: ClassSpecs,
+  override val topClass: ClassSpec,
+  config: RuntimeConfig
+) extends ClassCompiler(classSpecs, topClass, config, JuliaCompiler) {
+
+  private val julialang = lang.asInstanceOf[JuliaCompiler]
+
+  override def compileClass(curClass: ClassSpec): Unit = {
+    provider.nowClass = curClass
+
+    val extraAttrs = List(
+      AttrSpec(List(), IoIdentifier, KaitaiStreamType),
+      AttrSpec(List(), RootIdentifier, UserTypeInstream(topClassName, None)),
+      AttrSpec(List(), ParentIdentifier, curClass.parentType)
+    ) ++ ExtraAttrs.forClassSpec(curClass, lang)
+
+    // curClass.types.foreach { case (typeName, _) => lang.classForwardDeclaration(curClass.name ++ List(typeName)) }
+
+    if (!curClass.doc.isEmpty)
+      lang.classDoc(curClass.name, curClass.doc)
+
+    // Enums declaration defines types, so they need to go first
+    compileEnums(curClass)
+
+    if (lang.config.readStoresPos)
+      lang.debugClassSequence(curClass.seq)
+
+    // Basic struct declaration
+    lang.classHeader(curClass.name)
+    compileAttrDeclarations(curClass.seq ++ curClass.params ++ extraAttrs)
+    curClass.instances.foreach { case (instName, instSpec) =>
+      compileInstanceDeclaration(instName, instSpec)
+    }
+    compileConstructor(curClass)
+    lang.classFooter(curClass.name)
+
+    // if (curClass.isTopLevel)
+    //   julialang.fromFile(curClass.name)
+
+    compileEagerRead(curClass.seq, curClass.meta.endian)
+
+    julialang.overrideGetProperty(curClass.name, curClass.instances)
+    compileInstances(curClass)
+
+    compileAttrReaders(curClass.seq ++ extraAttrs)
+
+    curClass.toStringExpr.foreach(expr => lang.classToString(expr))
+    // Recursive types
+    compileSubclasses(curClass)
+  }
+
+  override def compileInstance(className: List[String], instName: InstanceIdentifier, instSpec: InstanceSpec, endian: Option[Endianness]): Unit = {
+    // Determine datatype
+    val dataType = instSpec.dataTypeComposite
+
+    // compileInstanceDeclaration(instName, instSpec)
+
+    if (!lang.innerDocstrings)
+      compileInstanceDoc(instName, instSpec)
+    lang.instanceHeader(className, instName, dataType, instSpec.isNullable)
+    if (lang.innerDocstrings)
+      compileInstanceDoc(instName, instSpec)
+    lang.instanceCheckCacheAndReturn(instName, dataType)
+
+    instSpec match {
+      case vi: ValueInstanceSpec =>
+        lang.attrParseIfHeader(instName, vi.ifExpr)
+        lang.instanceCalculate(instName, dataType, vi.value)
+        lang.attrParseIfFooter(vi.ifExpr)
+        lang.instanceSetCalculated(instName)
+      case pi: ParseInstanceSpec =>
+        lang.attrParse(pi, instName, endian)
+    }
+
+    lang.instanceReturn(instName, dataType)
+    lang.instanceFooter
+  }
+
+  // override def compileCalcEndian(ce: CalcEndian): Unit = {
+  //   def renderProc(result: FixedEndian): Unit = {
+  //     val v = result match {
+  //       case LittleEndian => Ast.expr.Bool(true)
+  //       case BigEndian => Ast.expr.Bool(false)
+  //     }
+  //     lang.instanceCalculate(IS_LE_ID, CalcIntType, v)
+  //   }
+  //   lang.switchCases[FixedEndian](IS_LE_ID, ce.on, ce.cases, renderProc, renderProc)
+  // }
+
+  override def compileAttrDeclarations(attrs: List[MemberSpec]): Unit = {
+    attrs.foreach { (attr) =>
+      val isNullable = if (lang.switchBytesOnlyAsRaw) {
+        attr.isNullableSwitchRaw
+      } else {
+        attr.isNullable || attr.dataType.isInstanceOf[UserType]
+      }
+      lang.attributeDeclaration(attr.id, attr.dataTypeComposite, isNullable)
+    }
+  }
+}

shared/src/main/scala/io/kaitai/struct/Main.scala

@@ -1,7 +1,7 @@
 package io.kaitai.struct
 
 import io.kaitai.struct.format.{ClassSpec, ClassSpecs, MetaSpec}
-import io.kaitai.struct.languages.{GoCompiler, NimCompiler, RustCompiler}
+import io.kaitai.struct.languages.{GoCompiler, NimCompiler, RustCompiler, JuliaCompiler}
 import io.kaitai.struct.languages.components.LanguageCompilerStatic
 import io.kaitai.struct.precompile._
 import io.kaitai.struct.problems.CompilationProblem
@@ -80,6 +80,8 @@ object Main {
         new GraphvizClassCompiler(specs, spec)
       case GoCompiler =>
         new GoClassCompiler(specs, spec, config)
+      case JuliaCompiler =>
+        new JuliaClassCompiler(specs, spec, config)
       case RustCompiler =>
         new RustClassCompiler(specs, spec, config)
       case ConstructClassCompiler =>