Added switch support. Updated README in preparation for 0.1

Author: FractalFir

README.md

@@ -1,5 +1,7 @@
 # What is `jtcpp`
-`jtcpp` is a versatile, highly experimental JVM bytecode to C++ converter. It generates C++ code which an exact, JVM op into C++ statement, translation of the input bytecode. This approach has some limitations, which may reduce performance of generated C++ code. This makes general comparisons between speed original Java code and translated C++ very hard, because it varies so much(From 3x speedup to 50x slowdown).
+Disclaimer:
+*`jtcpp` was created as a learning exercise, and a way to better understand both JVM bytcode and Java class format. It is a proof of concept, and not meant to be used for anything besides exploring the idea of compiling languages using JVM to native code.*
+`jtcpp` is a versatile, highly experimental JVM bytecode to C++ transpiler. It generates C++ code which an exact, JVM op into C++ statement, translation of the input bytecode. This approach has some limitations, which may reduce performance of generated C++ code. This makes general comparisons between speed original Java code and translated C++ very hard, because it varies so much(From 3x speedup to 50x slowdown).
 # Compatibility.
 Building `jtcpp` is supported only on Linux. `make`,`cmake`,`git` and either `g++` or `clang` is required.
 Translated `C++` code should work with almost any compiler. It was tested with both `g++` and `clang`, and minimal supported C++ version is C++ 11. 
@@ -20,7 +22,22 @@ NOTE:All translated dependencies should have the same target directory
 `jtcpp` ships with a minimal, bare-bones implementation of java standard library. The shipped version of the standard library is meant only for testing, and contains only support for classes such as `String`, `Object`, `System` and `PrintStream`, required for outputting to console. Those classes contain only implementations of strictly necessary methods.
 # Java features
 `jtcpp` supports object creation, 1D arrays, inheritance, static and virtual methods. Support for generics is partial and they may not always work.
-`jtcpp` does not support multi dimensional arrays, interfaces, switch statements, exception handling.
+`jtcpp` does not support multi dimensional arrays, interfaces, exception handling.
 # JVM bytcode Ops 
-`jtcpp` currently supports almost all JVM opcodes, besides: `tableswitch`, `lookupswitch` `dup2_x2`, `multanewarray`, `invokedynamic`.
+`jtcpp` currently supports almost all JVM opcodes, besides: `dup2_x2`, `multanewarray`, and `invokedynamic`.
+# Building some examples
+In order to test out some examples(they are in `test` directory), compile them using `javac`.  Then, invoke jtcpp with resulting `.class` files as source files for transpilation. Go to the resulting target directory, and run `make`.
+After that, you should have a naively compiled version of input program. 
+
+Beware! Some of examples do not work on purpose, to show what is currently missing. Examples which do not work have a comment at their top, explaing exactly why they do not work yet.
+Example of building an example:
+`cd test/nbody`
+`javac NBody`
+`cd ../..`
+`jtcpp --out target/nbody -s test/nbody/Planet.class -s test/nbody/Vector3.class -s test/nbody/NBody.class -s test/nbody/Rand.class`
+`cd target/nbody`
+`make`
+`cd build`
+`./translated.out`
+And you should see positions and velocities of simulated bodies being printed.
 

src/cpp_codegen/method.rs

@@ -1049,7 +1049,21 @@ fn write_op(op: &FatOp, mw: &mut MethodWriter) {
                 _=>panic!("Invoke Dynamic requires runtime codegen, which is not supported!"),
             }
         }
-        FatOp::Dup2X2 | &FatOp::MultiANewArray(_, _) | &FatOp::LookupSwitch { .. } => todo!(),
+        FatOp::LookupSwitch{default_op,pairs}=>{
+            let (key_type,key) = mw.vstack_pop().unwrap();
+            assert!(VariableType::Int.assignable(&key_type));
+            mw.write_raw(&format!("switch ({key})"));
+            mw.begin_scope();
+            for (key,target) in pairs.iter(){
+                mw.write_raw(&format!("case {key}:"));
+                mw.write_raw(&format!("\tgoto bb{target};"));
+            }
+            mw.write_raw("default:");
+            mw.write_raw(&format!("\tgoto bb{default_op};"));
+            mw.end_scope();
+            "".into()
+        },
+        FatOp::Dup2X2 | &FatOp::MultiANewArray(_, _) => todo!(),
         //_ => todo!("Unsuported op:\"{op:?}\""),
     };
     mw.write_op(op, &code);

src/cpp_codegen/method_writer.rs

@@ -93,15 +93,18 @@ impl MethodWriter {
     pub(crate) fn set_sig(&mut self, sig: &str) {
         self.sig = sig.into();
     }
+    pub(crate) fn write_raw(&mut self, code: &str){
+        self.write_ident();
+        self.code.push_str(code);
+        self.code.push('\n');
+    }
     pub(crate) fn write_op(&mut self, curr_op: &FatOp, code: &str) {
         if self.use_debuginfo() {
             self.write_ident();
             self.code.push_str(&format!("//{curr_op:?}\n"));
         }
         if code != ""{
-            self.write_ident();
-            self.code.push_str(code);
-            self.code.push('\n');
+            self.write_raw(code);
         }
     }
     pub(crate) fn vstack_push(&mut self, vvar: &str, vtype: VariableType) {

src/importer/opcodes.rs

@@ -442,10 +442,30 @@ pub(crate) fn load_ops<R: std::io::Read>(
                 }))
             }
             0xaa => {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    "Table switch op not supported!",
-                ));
+                let to_next = ((4 - curr_offset % 4) % 4) as usize;
+                // skip to_next
+                let mut out = [0; 4];
+                src.read_exact(&mut out[..to_next])?;
+                curr_offset += to_next as u16;
+                assert_eq!(curr_offset % 4, 0);
+                let default_offset = load_i32(src)?;
+                curr_offset += 4 as u16;
+                let low = load_i32(src)?;
+                curr_offset += 4 as u16;
+                let high = load_i32(src)?;
+                curr_offset += 4 as u16;
+                let count = (high - low + 1);
+                let mut pairs = Vec::with_capacity(count as usize);
+                for key in 0..count{
+                    let curr_key:i32 = key - low;
+                    let offset = load_i32(src)?;
+                    curr_offset += 4 as u16;
+                    pairs.push((curr_key,offset));
+                }
+                OpCode::LookupSwitch(Box::new(LookupSwitch {
+                    default_offset,
+                    pairs: pairs.into(),
+                }))
             }
             0xac => OpCode::IReturn,
             0xad => OpCode::LReturn,

test/BasicArthm.java

@@ -1,3 +1,4 @@
+//This example can be transpiled, but produced C++ does not yet compile, since the C++ implementation of the stdlib does not support Charsets.
 import java.net.Socket;
 import java.net.ServerSocket;
 import java.io.OutputStream;

test/Calls.java

@@ -1,3 +1,4 @@
+// Interfaces don't yet work!
 interface Animal{
   public void Sound();
 }

test/Extends.java

@@ -1,3 +1,4 @@
+// This example uses lambdas, which use `InvokeDynamic` op under the hood.
 import java.util.List;
 class InvokeDynamic { 
     public static void main(String[] args) {