Gnat 2021 GPL Community Edition Ada 202x compiler released

As a simple example you can lookup what the compiler generates as a low-level binding [0] that is wrapped in a higher level API [1].

BTW you can also bind Ada to Java (although support is a bit limited I know places where it's in prod). Don't remember if it's a commercial product or oss.

And for the python people, my company financed a first version of ada-py-bind, inspired by the great pybind11. Still a lot of code to write (or generate) but it works fine.

Thanks onox for those two links!

[0] https://github.com/persan/zeromq-Ada/blob/651ca44cce831c2d71...

[1] https://github.com/persan/zeromq-Ada/blob/651ca44cce831c2d71...

Is the implementation of a Convention isolated enough that it would make sense to be extensible?

One thing I had in mind is something like Postgres. Some functions in Postgres are called in a specific way that converts arguments into an array first, and handles SQL NULL values. If I were to define this as a new Convention, it would inherit a lot from the "C" Convention, but would do some transformations first.

If it could handle a longjmp() as well, then the new Convention would also do whatever setup (manipulate some global variables and call setjmp()) so that the caller doesn't have to worry about the longjmp().

The challenge with handling longjmp() in rust is that you can't call setjmp() as a normal FFI function (because it can return twice, like fork(), which is not a normal control flow). Also, longjmp()ing into rust code is just not defined behavior, even if it "works" for now. I assume there are similar challenges in Ada.

Here is the Ada 2012 standard: http://www.ada-auth.org/standards/rm12_w_tc1/html/RM-TOC.htm...

If you create a programming language that meets all of the Ada standard requirements, you will have your own Ada implementation.

You could use whatever backend suits your needs (or write your own) and license it accordingly.

If it is an Ada implementation, why wouldn't they call it Ada rather than alang?

If the language implements the Ada standard (http://www.ada-auth.org/standards/rm12_w_tc1/html/RM-TOC.htm...), it is Ada, regardless of how the particular implementation is licensed.

[0] https://blog.adacore.com/combining-gnat-with-llvm [1] https://blog.adacore.com/use-of-gnat-llvm-to-translate-ada-a... [2] https://blog.adacore.com/android-application-with-ada-and-we...

The fun part is that dragonegg became an important part of clang/llvm for years (before it was phased out) to compile fortran (before flang) and to compare clang results and gcc's. I seem to remember other interesting uses but my memory is failing me.

Duncan Sands (the original author I think?) is an outstanding engineer and very fun person to talk to.

I still have fond memories of (the sadly late) Robert Dewar answering a ticket of mine 'this is so slow, whyyyyyyy?' with a 'we have implemented a change that should improve the performance of your code' so fast I hadn't had the time to go talk to our local Ada guy for an alternative idea.

They also have world experts in formal methods like Yannick Moy and Claire Dross who will help you prove you jump-start a Spark project and are pushing the state of the art every year (proof of floating point code, pointer/ownership...).

Money well spent.

And to be clear: not from AdaCore, just a customer.

I mentioned it precisely because people get it wrong so often.

> But breaking GNAT's license doesn't make the software created GPL

If you do not comply with the terms of the GPL license you're no longer allowed to use the code/software licensed under GPL. Under GPL 2, you can continue to use the code/software after the license violation is removed. Under GPL 3 the copyright holder might terminate your license (see section 8 of GPL 3).

This is an important distinction.

But it's still true, that using the Ada core GPL Ada compiler, which does not come with lgpl/run-time exception - you can only legally distribute binaries under the GPL (or commercial license).

This does not matter much if you don't distribute code to others (eg: break system of a car - gpl/commercial; build a web server to sell/stream movies - gpl/internal use).

I still think it's probably a mistake to have the fsf and Ada core version be so similar, yet differently licensed (because it is confusing - most are used to gpl compilers comming with lgpl/runtime exception, like gcc).

I am not wrong. The runtime of the Adacore Community edition is under GPL, as are many libraries included in the Adacore edition that are not included in the FSF edition. Your binaries will be under the GPL. (Technically speaking, you could compile executables with this version of GNAT that are not under GPL by writing your own runtime. Practically, this is pretty much impossible and nobody has ever done it.)

The FSF edition allows you to compile executables without license encumbering, because it is licensed under the mGPL.

"If the resulting software were GPL, all those nasty contradictions would go away. Let's assign GPL to the software and the problem is solved."

Unfortunately, the law doesn't work that way.

If you want mGPL (with the runtime exception) you need to wait for the FSF version.

This is well-known in the Ada community, but I thought I'd mention it because occasionally people don't know the license conditions of various GNAT versions very well. Such as you.

You'll be violating the terms that allow you to use the compiler if your source code isn't GPL licensed. That doesn't mean your source code is automatically converted to GPL. It just means you don't have a right to use the compiler or to distribute the binaries you've produced with it.

> Unlike other parts of GCC, GNAT copyright is held by AdaCore due to some special arrangement with the FSF.

Adacore holds at least the copyright of their own contributions and therefore can decide whether they want to release their version of GNAT with or without the runtime library exception; the FSF version eventually inherits also the contributions of Adacore, but the Adacore version is more current.

> So yes, binaries compiled with that particular compiler are de-facto under GPLv3, and you have to abide by its terms

This doesn't have anything to do with source or binary version. The reason is that the binaries provided by Adacore are compiled from their (most recent) source version which they publish under GPL without the runtime library exception. For this (and only this) reason you create a "combined work" when you link your code with the Adacore version of the runtime library. This doesn't change in any way if you compile the GNAT version of Adacore by yourself; you still don't have the runtime libary exception which only Adacore can give for their contributions.