Rust support

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(".")).

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

@@ -9,6 +9,7 @@ import io.kaitai.struct.translators.TypeProvider
 
 class ClassTypeProvider(classSpecs: ClassSpecs, var topClass: ClassSpec) extends TypeProvider {
   var nowClass = topClass
+  val allClasses: ClassSpecs = classSpecs
 
   var _currentIteratorType: Option[DataType] = None
   var _currentSwitchType: Option[DataType] = None

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

@@ -1,7 +1,8 @@
 package io.kaitai.struct
 
-import io.kaitai.struct.datatype.DataType.{KaitaiStreamType, UserTypeInstream}
-import io.kaitai.struct.datatype.{Endianness, FixedEndian, InheritedEndian}
+import io.kaitai.struct.datatype.DataType._
+import io.kaitai.struct.datatype._
+import io.kaitai.struct.exprlang.Ast
 import io.kaitai.struct.format._
 import io.kaitai.struct.languages.RustCompiler
 import io.kaitai.struct.languages.components.ExtraAttrs
@@ -29,18 +30,19 @@ class RustClassCompiler(
 
     // Basic struct declaration
     lang.classHeader(curClass.name)
-    
+
     compileAttrDeclarations(curClass.seq ++ extraAttrs)
     curClass.instances.foreach { case (instName, instSpec) =>
       compileInstanceDeclaration(instName, instSpec)
     }
-    
+
     // Constructor = Read() function
     compileReadFunction(curClass)
-    
+
     compileInstances(curClass)
 
     compileAttrReaders(curClass.seq ++ extraAttrs)
+    curClass.toStringExpr.foreach(expr => lang.classToString(expr))
     lang.classFooter(curClass.name)
 
     compileEnums(curClass)
@@ -49,7 +51,7 @@ class RustClassCompiler(
     compileSubclasses(curClass)
   }
 
-  def compileReadFunction(curClass: ClassSpec) = {
+  def compileReadFunction(curClass: ClassSpec): Unit = {
     lang.classConstructorHeader(
       curClass.name,
       curClass.parentType,
@@ -58,23 +60,41 @@ class RustClassCompiler(
       curClass.params
     )
 
-    // FIXME
     val defEndian = curClass.meta.endian match {
       case Some(fe: FixedEndian) => Some(fe)
       case _ => None
     }
-
-    lang.readHeader(defEndian, false)
-
+
+    lang.readHeader(defEndian, isEmpty = false)
+
+    curClass.meta.endian match {
+      case Some(ce: CalcEndian) => compileCalcEndian(ce)
+      case Some(_) => // Nothing to generate
+      case None => // Same here
+    }
+
     compileSeq(curClass.seq, defEndian)
     lang.classConstructorFooter
   }
 
-  override def compileInstances(curClass: ClassSpec) = {
+  override def compileCalcEndian(ce: CalcEndian): Unit = {
+    def renderProc(result: FixedEndian): Unit = {
+      val v = result match {
+        case LittleEndian => Ast.expr.IntNum(1)
+        case BigEndian => Ast.expr.IntNum(2)
+      }
+      lang.instanceCalculate(IS_LE_ID, CalcIntType, v)
+    }
+    lang.switchCases[FixedEndian](IS_LE_ID, ce.on, ce.cases, renderProc, renderProc)
+    lang.runReadCalc()
+  }
+
+  override def compileInstances(curClass: ClassSpec): Unit = {
     lang.instanceDeclHeader(curClass.name)
     curClass.instances.foreach { case (instName, instSpec) =>
       compileInstance(curClass.name, instName, instSpec, curClass.meta.endian)
     }
+    lang.instanceFooter
   }
 
   override def compileInstance(className: List[String], instName: InstanceIdentifier, instSpec: InstanceSpec, endian: Option[Endianness]): Unit = {
@@ -88,16 +108,16 @@ class RustClassCompiler(
     lang.instanceHeader(className, instName, dataType, instSpec.isNullable)
     lang.instanceCheckCacheAndReturn(instName, dataType)
 
+    lang.instanceSetCalculated(instName)
     instSpec match {
       case vi: ValueInstanceSpec =>
         lang.attrParseIfHeader(instName, vi.ifExpr)
         lang.instanceCalculate(instName, dataType, vi.value)
         lang.attrParseIfFooter(vi.ifExpr)
-      case i: ParseInstanceSpec =>
-        lang.attrParse(i, instName, None) // FIXME
+      case pi: ParseInstanceSpec =>
+        lang.attrParse(pi, instName, None) // FIXME
     }
 
-    lang.instanceSetCalculated(instName)
     lang.instanceReturn(instName, dataType)
     lang.instanceFooter
   }