cc-rs VS wtfiles

It does support calling into other compilers and toolchains through build scripts and such. Take cc-rs[0] for example: this allows building C and C++ files natively without even calling an executable yourself.

In practice, I'd expect libraries to just call make/cmake/ninja for you, or (like openssl-sys) ask you to install the necessary libraries using your favourite package manager.

[0]: https://github.com/rust-lang/cc-rs

The cc crate (https://github.com/rust-lang/cc-rs) is widely used for compiling C code from Rust (often in a build.rs file for the purpose of wrapping a C library so that it can be used from Rust). However, I believe it generally does expect a C compiler to be present.

It might be quite tedious to compile static library manually every time we make changes in C code. The better solution is to instead utilize the cc crate, which provides an idiomatic Rust interface to the compiler provided by the host.

https://github.com/alexcrichton/cc-rs This crates lets you shell out to a C compiler when building your Rust project

> You're splitting hairs in a weird way. rustc cannot compile C code. zig can.

But why do I care? I don't use rustc directly, the build system of choice does. And very few of the major build systems have an issue handling multiple languages.

Cargo (rust's build system) supports build scripts and the community has already created C/C++ compiler hooks such as https://github.com/alexcrichton/cc-rs

rustup and cargo also provide easy cross-compilation support, too.

I think it's getting confused because link.exe is in your PATH. But it's not the link.exe it expects. Link tools are detected using the cc crate so it would need to be fixed there. Would you be willing to open an issue about this?

It’s not super well-documented, but there is an option to change this. --remap-path-prefix $(pwd)= in your RUSTFLAGS will usually do the trick. If you have any C dependencies you’ll also need similar things in CFLAGS, see https://github.com/alexcrichton/cc-rs/issues/593

Keep in mind that filesystem paths aren't strings. On Linux, they are raw bytes without any fixed encoding (but usually UTF-8 on UTF-8-based locales), and on Windows, they are sequences of 16-bit codepoints which are expected to be UTF-16 but not validated.

Rust's OsStr is my favorite approach so far. It stores Linux's raw bytes as-is, and stores Windows's possibly-valid UTF-16 as WTF-8. This makes path management "just work", with the ability to operate normally on invalid UTF-8 or UTF-16 paths, and zero-copy conversion from UTF-8/ASCII strings to OsStr (though converting OsStr into UTF-16 requires parsing). (Qt's QString-based file dialogs on Linux fail to convert invalid UTF-8 paths like those in https://github.com/petrosagg/wtfiles into QString, causing Qt-based apps to open/save the wrong paths.)

However there are difficulties in printing an OsStr. For example, a file dialog that shows filenames as raw bytes can't show non-Latin/Unicode characters in a human-readable form, and a file dialog that shows filenames as Unicode strings can't handle invalid Unicode filenames. GTK3 file dialogs show filenames as Unicode strings, and when encountering files with invalid Unicode names, instead displays "file�name.txt (invalid encoding)".

Worse yet, how should a file dialog allow users to rename files? If it's based around byte arrays, the user can't enter Unicode characters directly, and if it's based around Unicode (or a locale-specific text encoding), it can't display existing files with invalid Unicode/etc. in the name (probably not an issue if it allows the user to rename to a valid name), nor allow users to enter invalid Unicode (which is not an issue IMO).