cc-rs
arocc
cc-rs | arocc | |
---|---|---|
8 | 10 | |
1,731 | 765 | |
0.2% | - | |
9.0 | 9.7 | |
8 days ago | 3 days ago | |
Rust | Zig | |
Apache License 2.0 | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
cc-rs
-
RustPython – A Python-3 (CPython >= 3.11.0) Interpreter written in Rust
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
-
Any crates for compiling C ( or other language ) from a rust binary?
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.
-
Calling C code from Rust
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.
- cc-rs is looking for new maintainers
-
Hello, youki! Faster container runtime is written in Rust
https://github.com/alexcrichton/cc-rs This crates lets you shell out to a C compiler when building your Rust project
-
Maintain It with Zig
> 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.
-
Windows can't find link exe
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?
-
Most loved programming language Rust sparks privacy concerns
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
arocc
-
no more bit fiddling (and introducing bilge)
Possible reference as it requires to use the compiler as part of language abi: https://github.com/Vexu/arocc/issues/178 Not sure, where a better thread with explanations of the flaws is.
-
Zig Build System
Zig calls clang to compile C code. This doesn't add a new dependency since Zig already depends on LLVM. In the future when Zig doesn't depend as much on LLVM, there might be a reason to use a C compiler written in Zig (e.g. https://github.com/Vexu/arocc)
-
Embedded C Coding Standard
Bit field rules are underspecified or plain wrongly implemented, because in their edge cases clang and GCC differ in semantics. See https://github.com/Vexu/arocc/issues/178 This should be further restricted with static asserts as compiler semantics even changed with versions and doing this manually/doing code review is error prone.
-
How much better is Zig's "no-FFI" C interop compared to FFIs in other languages?
You might want to contribute or look into https://github.com/Vexu/arocc, which is planned to be eventually an alternative frontend. Is arocc able to handle your use cases?
- Aro: A C compiler written in Zig
-
Zig 0.9.0
> Does this mean that y'all are open to the self-hosted compiler supporting CPU architectures unlikely to ever have LLVM support?
Yes! We won't block 1.0 on the quality of the less mainstream targets, but that's what the tier system is for - to ship a compiler that has varying levels of quality for various targets, while communicating clearly to users what kind of experience they can expect for each one.
SuperH patches are absolutely welcome.
> how is zig cc anticipated to work with a self-hosted Zig? Will there be a dependency on clang [...]?
The main distribution of Zig will be LLVM/Clang-enabled. However it is already possible to build a version of Zig that does not have these features enabled. In such case, compiling C, C++, and Objective-C code will result in an error.
However, the arocc project[1] is emerging, which, depending on a combination of how much funding ZSF gets and how much enthusiasm the unpaid contributors working in their spare time have, is looking like a promising C frontend that would be available even without LLVM/Clang. It is C only, however, with no intention of compiling C++ or Objective-C.
> would zig cc support the planned C backend?
As it is currently implemented: no. Zig invokes clang to turn C source code into object files.
However, with the arocc frontend above, this would be converting the C source code into ZIR (or perhaps AIR), which could then be lowered with any of the backends, including the (partially complete) C backend. In such case, the C output would look drastically different than the input. It would look more like an IR than natural C code that a human would write.
[1]: https://github.com/Vexu/arocc
-
[Rust advocates] demean software that's not memory safe the way that politicians use their words to sow anger. C has won, and Rust blew it's shot aiming at C++ instead.
Implementing only the language part takes like 10k LOC.
- Maintain It with Zig
-
Adding ANSI C11 C compiler to D so it can import and compile C files directly
> 9. Without a C compiler, we're stuck with, wedded to, and beholden to libclang.
> I wouldn't be surprised that the eventual cost of adapting ourselves to
> libclang will exceed the cost of doing our own C compiler.
This is a really insightful point. I had to learn this the hard way :)
We might follow your lead on this, as we have done with so many other great ideas implemented in D.
Ironically, Vexu started from the other side as you, with the preprocessor mostly done, but the backend left to-do: https://github.com/Vexu/arocc
One thing that might make libclang worth the cost, however, is its ability to compile C++ code as well. On Zig's end of things, all we have to do is provide libcxx, libcxxabi, libunwind, compiler-rt, and linking, and then libclang is really pulling a lot of weight by compiling C++ code into object files. Sadly this ability is just too useful in practice to ignore. For example, LLVM itself is C++ so if Zig wants to be able to bootstrap itself, it needs this capability.
Still, I think your maneuver here is the best long-term approach to tackle this problem, and I imagine as time goes on we'll start to migrate towards D's solution here. Maybe someday the Zig distribution that does not have LLVM extensions enabled will be the more popular one!
I'll be watching the evolution of this new feature in D with great interest!
What are some alternatives?
RIIR - why not Rewrite It In Rust
stage0 - A set of minimal dependency bootstrap binaries
mach - zig game engine & graphics toolkit
ohmygentool - LLVM/Clang based bindings generator for D language
zig-riscv-embedded - Experimental Zig-based CoAP node for the HiFive1 RISC-V board
zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.
bzflag - 3D multi-player tank battle game
utfcpp - UTF-8 with C++ in a Portable Way
dstep - A tool for converting C and Objective-C headers to D modules