This Weekend in Meson++ (October 3rd Edition)

 I thought I might try to write a series of light blog posts on the ongoing status of Meson++, and since I'm mostly working on it in my weekend free time, It's called "This Weekend in Meson++" (I stole this name from Emma Anholt, who called their series on VC4 "This Week in VC4", so thanks Emma).

Target Linking

Since I've already gotten basic targets working, I've started pushing toward getting linking between targets working, which is more difficult than it sounds. Meson++ uses a flat IR, and relies on IR optimizations to reduce the instruction stream from the Meson DSL into a vector of Targets (and eventually tests), then the backend has the responsibility to convert that stream of Targets into a file that can be consumed by the runner tool (ninja, make, msbuild, etc). This means to take something very simple like:

project('foo', 'cpp')

lib = static_library('lib, 'lib.cpp')

executable('main.cpp', link_with : lib)  

We need to be able to link the `lib` identifiers together. To do this we need value numbering, and from an implementation point of view, constant folding. Essentially what internally this ends up looking like, is an `Executable` Object with a reference to the `StaticLibrary` object, which seems like overkill, since ninja really just needs the output name. However, as recent work in Meson itself has demonstrated, Visual Studio doesn't work that way. I'm still working on this, so I don't have much more on this yet.

Parser Improvements

After hearing that Muon could parse all of the test cases in the upstream meson repo, I had to be able to do that as well, I found some pretty interesting bugs, and some annoying cases in Meson's grammar

A number of the problems, thankfully, were rather trivial to fix. Among the simpler fixes was:

  • Implementing f-strings, which are interpolated
  • Implement foreach loops over dictionaries, which do automatic unpacking
  • Implement binary literals 0b101
  • Fixed ambiguity of the `not in` operator

Numeric Literals are also interesting, as I had a bug where 0xFF would work, but 0XFF would not, it's not documented that you can capitalize the second character of the literal, but there are tests for it.

 Most annoying, and time-consuming, was newline management. Meson uses newlines as statement terminators, but they're not significant anywhere else. That means that, for example, you don't want the lexer to tell the parser about a newline following a comment, unless it's an inline comment. They also don't matter inside braces, since statements can't appear in braces, only expressions can. It's the inline comment business that makes this awful:

if x == 2  # this newline is significant
  # this one is not
endif

Clean Patches

Up until this point I've been just running fast and dirty with commits, pushing directly to the main branch as I write patches. Now that there is something working I've added CI, and I'm using Pull requests, even for my own patches. In addition, I've wired up some github CI, so things hopefully keep working.

First External Contribution

I got my first external contribution this weekend, from the author of Muon. Nothing makes yuou feel like your project is taking off like getting a Pull Request from someone other than yourself.

Comments

Post a Comment

Popular posts from this blog

This Weekend in Meson++ (February 6th)

 Meson++ is 1 year old! It's strange to think that February 9th, 2021, was the first commit to meson++, and a year later, we have a working flex+bison C++ frontend, an optimizing mid level IR, a file based backend IR, and the ability to generate simple ninja programs! It's a strange and proud feeling.  Anyway, I haven't implemented any sweepingly huge features this week, but we have landed support for `declare_dependency`, an important first step toward real dependencies (like those found by pkg-config). I also implemented a simple optimization for finding unreachable code. In this case, we look for the `error` function, and mark any instructions after that as dead, as well as removing any next block. Currently, there are no other non-returning functions implemented, but eventually `subdir_done()` will also need to be handled (though `subdir_done()` may present other problems for me). I also started implementing some neat argument pack based variant argument extractors. The
Read more

Introducing Meson++

I've been semi-quietly working on a new project for the last few months on and off, and today I've gotten far enough that I want to talk about it more widely: Meson++ . Meson++ is now capable of compiling very simply projects, if they meet the following criteria:  they use only C++ they don't have any external dependencies they only build executables they don't do any code generation you're okay using ninja you're using clang or gcc This may seem like a lot of restrictions, and it is, but there's a lot of code that has gone into getting to this point. I'd like to thank stackoverflow for answering a lot of questions. Motivation My primary motivation is to solve bootstrapping issues, imagine if python wanted to use Meson, currently that would create a bootstrap loop, where you need an old version of python to run an old version of Meson, etc. Or, imagine you want to build something like your compiler with Meson, now you need to build python bef
Read more

Rust in Meson — 0.57 Edition

Rust in Meson 0.57 Most people by now have heard of the meson build system I hope (at least anyone who would bother to read this blog post), and Rust is the cool new language everyone wants to use because it guards against specific kinds of memory bugs and has some neat features. The question of course is how to add rust to your existing project using C, C++ or another language. The answer of course, should be build your project with meson. I’m not going to go into whether using Rust is a good idea, whether it’s going to solve all of your problems, eat your puppy, or any of that. Rust, like everything else we do in programming comes with a set of trade-offs. I’ll say though, for the record, that I like Rust as a programming language form the relatively small amount of it I’ve done. So here’s a run down of what’s coming in the meson 0.57.0 release for Rust. Meson level handling for rust editions. Rust editions, for the uninitiated, are roughly equivalent to standards in C and C++.
Read more