On Thursday, 26 April 2018 at 09:24:19 UTC, A. Nicholi wrote:
So in a way, the D runtime is similar to libstdc++, providing
implementations of runtime language features.
I would argue that Phobos is more analogous to libstc++, but
there are some language features in C++ that are implemented in
libstc++. For example, if you try to compile the following code.
---main.cpp
int main()
{
throw 1;
return 0;
}
$g++ -c main.cpp
$ld main.o
ld: warning: cannot find entry symbol _start; defaulting to
00000000004000e8
main.o: In function `main':
main.cpp:(.text+0xa): undefined reference to
`__cxa_allocate_exception'
main.cpp:(.text+0x1c): undefined reference to `typeinfo for int'
main.cpp:(.text+0x24): undefined reference to `__cxa_throw'
So, yeah those "__cxa_..." functions are very similar to what
you'll find in Druntim. D calls them runtime hooks, and you can
find an unmaintained list of them here:
https://wiki.dlang.org/Runtime_Hooks
Here's similar experiment in D. IMO D is actually better than
C++ in this regard because it emits a compile-time error, instead
of a linker error, when it can't find something in the runtime
that it needs.
---object.d
module object;
// this useless object.d file is currently required, though I'm
trying to
// find a way to get rid of such nonsense.
// See https://github.com/dlang/dmd/pull/7825
---main.d
void main()
{
throw new Exception("whatever");
}
$dmd -conf= -defaultlib= main.d
main.d(3): Error: Cannot use throw statements because
object.Throwable was not declared
But it is also like C++ in that those language features can be
avoided, correct?
That was the goal with the "minimal runtime" features released in
v2.079. It's still a work in progress though. See
https://github.com/dlang/dmd/pull/8204
But, yes, as long as you avoid certain features that require
runtime implementations in your code, you should still be able to
write software in D. And, if I am allowed to have may way, it
should get even better.
At least with the use of minimal D, I mean. This means that as
a language, there is enough granularity to theoretically
provide as few or as many features as one desires for their use
case, making the penning of new C and C++ code redundant? Do I
get this right?
Not sure if I totally understand that, but it sounds right on.
The goal with the minimal runtime features is to allow one use D
on any platform in a pay-as-you-go fashion. That is, you only
need to implement what you intend to use. The primary use case I
have in mind is using D for resource-constrained
microcontrollers, though it would also be useful for libraries
written in D, but intended to be linked in by applications
written in other languages. I'm there are also use cases that I
haven't even thought of.
Mike
