EDG C++ front-end goes public

edgcpp.org

97 pointsiandinwoodie36 comments

Wow. This is big news for C++.

For background -- and I am not an expert here -- their C++ frontend is widely known. I first heard of it because Visual C++'s Intellisense uses it, which was notable because VC does not use the msvc frontend for its own completion. I understand it's been either used or evaluated for other frontends in the past too. I worked as PM for one C++ product, and was fortunate to be able to learn a lot from our engineers; we didn't use it, but they thought highly of EDG.

It has a very strong reputation for being correct. And as such, I think open sourcing it will be a very beneficial thing for the C++ community.

i dont even use cpp and my immediate response was oh shit this is a big deal

Announcement: https://edgcpp.org/#transition

The source code itself: https://github.com/edgcpp/compiler

Documentation: https://edgcpp.org/doc/

And for those curious the license SPDX is: Apache-2.0 WITH LLVM-exception

i.e.

- https://spdx.org/licenses/Apache-2.0.html

- https://spdx.org/licenses/LLVM-exception.html

It's got history! That's really unusual for moves to open-source; the dates on the earliest commits are in 1990 and they do go forward in time so that's really unusual to have that much history. I bet there's some fun stuff in there.

If I remember correctly, EDG was the only C++ implementation that actually attempted to implement the export keyword for templates in old C++. It was this implementation experience that informed the deprecation of export. EDG is a major influence in the development of C++.

Yes, it was also where C++26 static reflection was prototyped, as another example of its influence.

One of EDG developers prototyped his idea, and brought it to WG21 when it seemed reflection as originally thought for C++17 was never happening.

Ah, I used EDG for static analysis, but joined when we were switching over to using Clang for the frontend. I can't say for sure, but part of it was definitely just to save money using open source. The code that was hacked on top of EDG was also ridiculous, so there was a lot of accumulated tech debt there.

Looking back at that code definitely brings back memories. As a consumer of both frontends, I will say I much preferred working with Clang's. Both needed extra work on top to support everything we needed. Maybe I'm just not as acquainted with C as I would like to be. It's cool to look at this again, though.

Ooh, fond (and some not so fond) memories of when Silicon Graphics' (MIPS) C and C++ compilers were based on EDG's frontend, with a custom ucode-generating backend, and integrated into CASEVision. Early 1990s.

EDG was just 3 guys back then.

Wikipedia claims they have 6 employees, so they didn't exactly enjoy exponential growth over the years ;)

Despite using C++ for a few years now, the EDG source code is still mostly C code (and in fact, the C++ code is still using the old .c file names). In particular, there's no usage of the C++ standard library.

Where other languages might use inheritance, EDG still uses the C-style `union { ... } variant;`.

On a related note, compiling EDG is extremely fast: on my machine, the EDG frontend compiles in <10s; whereas clang takes >10min (caution unfair comparison: clang includes much more than just a frontend).

I think this is fairly common practice when writing compilers. You ideally want to be able to bootstrap from other languages, and C is a much simpler starting point.

"Three tracks, one codebase" this is such an LLM written sentence.

EDIT: But in this case it seems something significant is being released, it would be better with less writing and more human if possible.

What is this?

https://en.wikipedia.org/wiki/Edison_Design_Group

TLDR EDG C++ is a compiler frontend developed by EDG since the 80s which has been used under the hood for a whole bunch of commercial C and C++ compilers, static analyzers, linters, and IDE code completion tools.

Odds are if you are familiar with a closed source tool in one of those categories above, there's a decent chance it uses EDG's frontend somewhere in it under the hood.

It's one of the 4 big remaining C++ compiler frontends: gcc, clang, MSVC, EDG. Most other C++ compilers are based on either EDG or clang. (e.g. the Intel C++ compiler used to be based on the EDG frontend, though modern versions are based on clang instead)

The "frontend" is the part of the compiler that understands the input language: lexer, parser, template instantiation, constexpr evaluation, ... The EDG frontend produces an intermediate representation (IL) that is then used by the different compiler vendors to generate machine code. Or do code analysis.

EDG can also be used as a C++-to-C compiler.

> EDG can also be used as a C++-to-C compiler.

Nice to see this still exists!

After all, this is how it all started back in the days of - what was it called again ? - yeah, cfront

https://en.wikipedia.org/wiki/Cfront

It has an interesting code style, the comments go _after_ the function definition but before the opening bracket.

It looks weird, but it actually makes sense! The flow is more natural - first the function definition, and then the explanation of what it does. It also avoids repeating the function name.

This is also where conditions go in languages with contracts, I like it

This is common in Lisps.

never occurred to me to write a comment there, but it actually looks kind of clean imho. Really old C code looked like

void func(var1, var2) int var1, char* var2. { ... }

perhaps some legacy from that? Probably not, but just first thing that popped into my head since it feels similar :shrug:

I write comments about what a function does and it's interface before, but comments about the implementation after. Also my pre- and post-conditions go there of course. (I'm mostly writing in C.)

Reply on news.ycombinator.com