I have started something crazy a few weeks ago: porting my app from
C++ to Rust.
I'll talk about it here, in several parts.
This is Part 1.
Context
Once upon a time I started to write a Free Software photography
application for GNOME. That was around 10 years ago.
At the time I chose to use C++ and Gtkmm 2.x. C++ because it provide
unprecedented interoperability with existing C code while offering a
stronger type system, RAII and template which allow safer programing
pattern without a large overhead at runtime. Absolutely no regrets on
that.
Over the years, despite never having been released, the code base was
updated to C++11 and Gtkm 3.x.
Meanwhile Rust was developed at Mozilla. And Rust provide safety and
high performance, but doesn't have the same ease of interoperability
with a C codebase - albeit still make it easy.
Why
Why am I porting to Rust?
- Rust is designed to be a safe language. In this day an age of 0day due to the use of C (and C++) and their unsafe practice, it is something important.
- I want the application to be multi-threaded (it already is in design), which is one of the design goal of Rust.
- I started writing other stand alone components in Rust.
The goal is to progressively rewrite the application in Rust, mostly
translating the logic from C++ to Rust. It is not the first time I do
that across languages. I'll go from the back to the front, the front
being the UI written with Gtkmm.
Several steps.
Build system
There have already been a few posts about integrating Rust into an
automake based build system, by Federico or by me. The gist of it is
to make sure you build your library with Rust and link it to your
application.
Building Rust code is trivial using cargo. There is no point using
anything else.
Interfaces
When doing an ad-hoc conversion, the biggest problem is calling code
write in one language from the other.
You can not call Rust methods or generic functions from C/C++, so
you'll need to have some interface in place. Rust has made it
relatively easy by using C calling convention and making easy to
declare a function with mangling disabled.
Example:
#[no_mangle]
pub extern fn my_function(arg1: &Type1) -> RetType {
}
From C/C++ this would be something like:
extern "C" RetType my_function(const Type1* arg1);
Here we assume that RetType is a POD (Plain Old Datatype, like int,
char, float), not a C++ class, nor a struct in Rust.
There is a tool called
cbindgen that will generate
C/C++ header from the Rust code. You can call it from the Rust build
system to do that automatically. More on that later.
Calling C code from Rust is easy provided you have the proper
interfaces. It is basically the reverse of the above.
But calling C++ methods on the other hand, you have to use bindgen.
Bindgen
Bindgen will generate from C/C++
header Rust modules to call C++ code.
The tool is pretty amazing to not say magical. Albeit there are some
pitfalls.
For example a C++ class with a std::vector<> as a member will a
problem if treated as opaque type. To be honest I am not sure if it
would work as a non opaque type.
The use of boost might actually generate Rust code that doesn't
compile.
Running the Rust test with cargo test will fail. I think it is
Issue 1018.
There are a few things I recommend. Most notably, treat types as
opaque whenever possible ; whitelist types and functions rather than
blacklist. Your mileage may vary but this is what I got to work in my
case.
Using these tools I managed to actually rewrite the large parts of the
backend in Rust with equal functionality. Progressively more C++ code will
be replaced.
I'll get into detail in a future post.
