ligen-csharp

.gitignore

@@ -1,5 +1,6 @@
 # IntelliJ idea auto-generated files
 .idea
+.gradle
 
 # Rust files
 /target

Cargo.toml

@@ -1,14 +1,14 @@
 [workspace]
 members = [
     "ligen",
-    "ligen-c",
-    "ligen-cmake",
-#    "ligen-cpp/crates/core",
-#    "ligen-cpp/crates/macro",
-#    "ligen-cpp/crates/main",
-#    "ligen-cpp/examples/cpp-counter",
-#    "ligen-csharp/crates/core",
-#    "ligen-csharp/crates/macro",
-#    "ligen-csharp/crates/main",
-#    "ligen-csharp/examples/csharp-counter",
-]
+    "ligen/ir",
+    "ligen/utils",
+    "ligen/traits",
+    "generators/ligen-cargo",
+    "generators/ligen-rust",
+    "generators/ligen-cmake",
+    "generators/ligen-c",
+    "generators/ligen-csharp",
+    "examples/example",
+#    "generators/ligen-csharp/tests/rust"
+]

examples/example-c/.gitignore

@@ -0,0 +1 @@
+build

examples/example-c/CMakeLists.txt

@@ -0,0 +1,13 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.0)
+PROJECT("example-c")
+
+IF(TARGET ${PROJECT_NAME})
+RETURN()
+ENDIF()
+
+ADD_SUBDIRECTORY(../../target/ligen/example example)
+
+AUX_SOURCE_DIRECTORY(src SOURCES)
+
+ADD_EXECUTABLE(${PROJECT_NAME} ${SOURCES})
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} PUBLIC example)

examples/example-c/README.md

@@ -0,0 +1,14 @@
+# Counter-c
+
+An example on how to use the c bindings generated by ligen-c.
+
+### Requirements
+1. `cmake`
+
+### Building the project
+1. `$ mkdir build`
+2. `$ cd build`
+3. `$ cmake ..`
+4. `$ cmake --build .`
+
+The compiled executable can be found inside the `build` folder.

examples/example-c/src/main.c

@@ -0,0 +1,44 @@
+//#include <counter/person/sub_counter/Counter.h>
+//#include <counter/ffi/rstring/RString.h>
+//#include <counter/person/Person.h>
+//
+//#include <stdio.h>
+//#include <string.h>
+//
+//#define string_assert_eq(a, b) { printf("assert(\"%s\" == \"%s\")\n", a, b); assert(!strcmp(a, b)); }
+//
+//int main(int argc, char **argv) {
+//    Counter counter = Counter_new(2);
+//    assert_eq(Counter_get_count(counter), 2);
+//    Counter_count(counter, 1);
+//    assert_eq(Counter_get_count(counter), 3);
+//    Counter_count(counter, 3);
+//    assert_eq(Counter_get_count(counter), 6);
+//    Counter_drop(counter);
+//
+//    RString string = RString_new("Hello!");
+//    string_assert_eq("Hello!", RString_as_ptr(string));
+//    RString_drop(string);
+//
+//    Person person = Person_new("Danilo", "Guanabara");
+//
+//    RString fullName = Person_full_name(person);
+//    string_assert_eq("Danilo Guanabara", RString_as_ptr(fullName));
+//    RString_drop(fullName);
+//
+//    Person_drop(person);
+//
+//    return 0;
+//}
+
+#include <stdio.h>
+#include <example.h>
+#include <assert.h>
+
+int main(int argc, char **argv) {
+    Instant* instant = now();
+    Duration* duration = elapsed(instant);
+    print_duration(duration);
+    assert(4 == add(1, 3));
+    return 0;
+}

examples/example/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name    = "example"
+version = "0.1.0"
+authors = ["Danilo Guanabara <danilo@sensorial.systems>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+bindings = ["ligen", "ligen-cargo", "ligen-rust", "ligen-csharp"]
+
+[lib]
+crate-type = ["lib", "staticlib"]
+
+[dependencies]
+ligen-macro = { path = "../../ligen/macro" }
+
+[build-dependencies]
+ligen        = { path = "../../ligen", optional = true }
+ligen-cargo  = { path = "../../generators/ligen-cargo", optional = true }
+ligen-rust   = { path = "../../generators/ligen-rust", optional = true }
+ligen-csharp = { path = "../../generators/ligen-csharp", optional = true }

examples/example/README.md

@@ -0,0 +1,7 @@
+# Counter
+
+An example on how to use ligen.
+
+# Using
+
+`cargo build --features=bindings`

examples/example/build.rs

@@ -0,0 +1,24 @@
+fn main() {
+    #[cfg(feature = "bindings")]
+        {
+            use ligen::prelude::*;
+            use ligen::traits::build::{BuildSystem, BuildProfile};
+            use ligen_csharp::CSharpGenerator;
+            use ligen_cargo::{CargoProject, CargoGenerator, CargoBuilder};
+            use ligen_rust::RustGenerator;
+
+            match CargoProject::current().and_then(Project::try_from) {
+                Ok(project) => {
+                    println!("Generating C# bindings...");
+                    let rust_generator = RustGenerator::default();
+                    let csharp_generator = CSharpGenerator::default();
+                    let cargo_generator = CargoGenerator::default();
+                    cargo_generator.generate(&project).expect("Failed to generate Cargo interface.");
+                    rust_generator.generate(&project).expect("Failed to generate Rust interface.");
+                    csharp_generator.generate(&project).expect("Failed to generate C# interface.");
+                    CargoBuilder.build(&project, BuildProfile::Release).expect("Failed to build Cargo project.");
+                },
+                Err(_) => ()
+            }
+        }
+}

examples/example/src/ffi.rs

@@ -0,0 +1,13 @@
+use std::ffi::CStr;
+use std::os::raw::c_char;
+
+pub mod rstring;
+
+#[repr(C)]
+pub struct CChar(*const c_char);
+
+impl From<CChar> for String {
+    fn from(cchar: CChar) -> Self {
+        unsafe { CStr::from_ptr(cchar.0).to_str().unwrap().to_string() }
+    }
+}

examples/example/src/ffi/rstring/mod.rs

@@ -0,0 +1,44 @@
+use ligen_macro::ligen;
+
+// inner_ligen!(MarshalTo(String, *mut RString));
+// inner_ligen!(MarshalFrom(String, CChar));
+
+use std::os::raw::c_char;
+
+pub struct RString(std::ffi::CString);
+
+impl RString {
+    pub fn new(string: *const c_char) -> Self {
+        string.into()
+    }
+
+    pub fn as_ptr(&self) -> *const c_char {
+        self.0.as_ptr()
+    }
+}
+
+impl From<String> for RString {
+    fn from(string: String) -> Self {
+        let string = std::ffi::CString::new(string).expect("Couldn't create CString.");
+        Self(string)
+    }
+}
+
+impl From<RString> for String {
+    fn from(string: RString) -> Self {
+        string.0.to_string_lossy().to_string()
+    }
+}
+
+impl From<*const c_char> for RString {
+    fn from(c_char: *const c_char) -> Self {
+        unsafe {
+            let string = std::ffi::CString::new(
+                std::ffi::CStr::from_ptr(c_char)
+                    .to_string_lossy()
+                    .to_string(),
+            ).expect("Failed to create RString.");
+            Self(string)
+        }
+    }
+}

examples/example/src/ignored.rs

@@ -0,0 +1,7 @@
+ligen_macro::inner_ligen!(ignore);
+
+pub struct Ignored;
+
+impl Ignored {
+    pub fn ignored() -> Self { Self }
+}

examples/example/src/lib.rs

@@ -0,0 +1,25 @@
+
+pub mod time;
+pub use time::Instant;
+pub use time::instant::Instant as RenamedInstant;
+pub use time::duration::*;
+
+pub fn add(a: u32, b: u32) -> u32 {
+    a + b
+}
+
+pub fn now() -> Instant {
+    Instant::now()
+}
+
+pub fn elapsed(instant: *mut Instant) -> *mut Duration {
+    unsafe {
+        Box::into_raw(Box::new((*instant).elapsed()))
+    }
+}
+
+pub fn print_duration(duration: *mut Duration) {
+    unsafe {
+        println!("{:#?}", (*duration).0);
+    }
+}

examples/example/src/person/mod.rs

@@ -0,0 +1,16 @@
+pub mod sub_counter;
+
+pub struct Person {
+    pub first_name: String,
+    pub last_name: String
+}
+
+impl Person {
+    pub fn new(first_name: String, last_name: String) -> Self {
+        Self { first_name, last_name }
+    }
+
+    pub fn full_name(&self) -> String {
+        format!("{} {}", self.first_name, self.last_name)
+    }
+}

examples/example/src/person/sub_counter.rs

@@ -0,0 +1,17 @@
+pub struct Counter {
+    count: u32
+}
+
+impl Counter {
+    pub fn new(count: u32) -> Self {
+        Self { count }
+    }
+
+    pub fn count(&mut self, counts: u32) {
+        self.count += counts;
+    }
+
+    pub fn get_count(&self) -> u32 {
+        self.count
+    }
+}

examples/example/src/time/duration.rs

@@ -0,0 +1 @@
+pub struct Duration(pub(crate) std::time::Duration);

examples/example/src/time/instant.rs

@@ -0,0 +1,16 @@
+use ligen_macro::ligen;
+
+use crate::time::duration::Duration;
+
+#[ligen(opaque)]
+pub struct Instant(std::time::Instant);
+
+impl Instant {
+    pub(crate) fn now() -> Self {
+        Self(std::time::Instant::now())
+    }
+
+    pub(crate) fn elapsed(&self) -> Duration {
+        Duration(self.0.elapsed())
+    }
+}

examples/example/src/time/mod.rs

@@ -0,0 +1,5 @@
+pub mod instant;
+pub mod duration;
+
+pub use instant::Instant;
+pub use duration::Duration;

ligen-c/Cargo.toml → generators/ligen-c/Cargo.toml

@@ -11,4 +11,4 @@ readme        = "../../README.md"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-ligen = { path = "../ligen" }
+ligen = { path = "../../ligen" }

ligen-c/src/ast/type_.rs → generators/ligen-c/src/ast/type_.rs

@@ -105,15 +105,15 @@ impl From<ir::Atomic> for Atomic {
                 ir::Integer::I32 => Atomic::Int,
                 ir::Integer::I64 => Atomic::LongLongInt,
                 ir::Integer::U128 | ir::Integer::USize | ir::Integer::I128 | ir::Integer::ISize => {
-                    panic!("Atomic types u128, usize, i128 and isize not implemented")
+                    todo!("Atomic types u128, usize, i128 and isize not implemented")
                 }
             },
             ir::Atomic::Float(float) => match float {
                 ir::Float::F32 => Atomic::Float,
                 ir::Float::F64 => Atomic::Double,
             },
-            ir::Atomic::Boolean => panic!("Boolean not implemented"),
-            ir::Atomic::Character => panic!("16bit char not implemented"),
+            ir::Atomic::Boolean => todo!("Boolean not implemented"),
+            ir::Atomic::Character => todo!("16bit char not implemented"),
         }
     }
 }
@@ -122,7 +122,7 @@ impl From<ir::Type> for Types {
     fn from(type_: ir::Type) -> Self {
         match type_ {
             ir::Type::Atomic(atomic) => Self::Atomic(Atomic::from(atomic)),
-            ir::Type::Compound(compound) => {
+            ir::Type::Compound(compound, _generics) => {
                 Self::Compound(compound.segments.last().unwrap().clone())
             }
             ir::Type::Reference(_reference) => {
@@ -134,7 +134,10 @@ impl From<ir::Type> for Types {
 
 impl From<ir::Reference> for Type {
     fn from(type_: ir::Reference) -> Self {
-        let constness = if type_.is_constant { Some(Const) } else { None };
+        let constness = match type_.mutability {
+            ir::Mutability::Constant => Some(Const),
+            ir::Mutability::Mutable => None
+        };
         let type_ = Types::from(*type_.type_.clone());
         let pointer = Some(Pointer);
         Self {
@@ -153,7 +156,7 @@ impl From<ir::Type> for Type {
                 type_: Types::Atomic(type_.into()),
                 pointer: None,
             },
-            ir::Type::Compound(path) => Self {
+            ir::Type::Compound(path, _) => Self {
                 constness: None,
                 type_: Types::Compound(path.segments.last().unwrap().clone()),
                 pointer: None,
@@ -164,6 +167,7 @@ impl From<ir::Type> for Type {
 }
 
 use std::fmt;
+
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(_) = self.constness {
@@ -174,7 +178,7 @@ impl fmt::Display for Type {
             Types::Atomic(atomic) => write!(f, "{}", atomic.as_ref())?,
             Types::Compound(identifier) => match identifier.name.as_str() {
                 "String" => write!(f, "const char*")?,
-                _ => write!(f, "C{}", identifier.name)?,
+                _ => write!(f, "{}", identifier.name)?,
             },
         }