alschwalm

Nice writeup! I've done some work with libdwarf and I agree that it isn't very pleasant. Do you have any suggestions for better interfaces that support writing?

For those (like me) wondering what became of that P != NP proof. It seems to have generally been discredited (though not yet retracted). Note that I'm just reporting what I found here: http://www.scottaaronson.com/blog/?p=458

But I don't keep up with this area, so maybe the status of that work is more contentious than Scott Aaronson makes it appear.

Awesome work! I've actually been making something in a similar vein myself, but it's not nearly this polished.

One issue (I'm not sure how it could be fixed) is that sections of code that were disabled by the preprocessor are not highlighted at all. For example, the compiler (or flags) used when parsing the boost code did not support move semantics, so "BOOST_NO_CXX11_RVALUE_REFERENCES" was defined, which means this line is not parsed:

https://code.woboq.org/boost/boost/boost/any.hpp.html#69

But this is a minor thing, and I'm not sure there's really a solution.

Just to note, the proposal the author lists as "so complicated" is actually just fixing an inconsistency in the grammar where "class" and "typename" are not always synonymous in the context of template declarations. Specifically:

    template<class T> class Foo;
    template<typename T> class Foo;
     

Are the same. But, not when declaring a template with a parameter that is itself a template:

    template<template<typename> class T> struct Foo;    // Compiles
    template<template<typename> typename T> struct Foo; // Does not compile

The proposal allows the second form to compile, fixing this inconsistency.

Somewhat related, C++14 gets 'auto' for function return types, which really makes me nervous (C++11 has a form of this, but not as powerful).The D programming language uses 'auto' as the return type for many of the functions in the standard library and this makes it, IMO, somewhat cumbersome to use.

In general, I don't think C++ (or D) devs should be using deduced return types in the public interface, if at all possible.