Can you generate code with your debugger?

Here's the story, I have a struct with 12 boolean options in it; those options are used in many `if constexpr`s in the code.

But, I have test cases that I read from a txt file, which when I see a that a test should fail in the txt file, I disable the corresponding option and run the tests.

But, there's a problem. The txt file is read at runtime, but the options are at compile time.

My first solution to bring runtime choices to compile time:

I created a table with size of`1 << 11` (2048) that contains all the possible combinations of that the function I was supposed to call with the option given to it at compile time.

Problem? compile time went up to minutes.

My second solution:
Instead of creating a table full of the combinations, I now will create one (or rather a switch-statement like the code in the picture) for only the cases that is being tests.

But how do we get those flags? I did this:

I set a Logpoint on the debugger printing the flags.

I'm gonna call this Log Driven Development. 😁

I'm in process of re-writing GoogleTest library for a custom one for Web++.

I've already made GTest optional in the library, and implemented a bare minimum clone of it.

I've also added some hardware stats (from perf stats in Linux) for each unit tests, and have some minimal anomaly detection in there; which sees for example if we have too much cache misses, it'll tell us.

I'm keeping the compatibility with GTest for now because IDEs have some special features for them that it might be useful for us later on.

I'm kinda excited about this; I have some ideas, but I don't want to over-engineer it since one of the reasons I did this was to reduce compile times and remove a dependency from Web++.

I made it a bit more useful and pretty when tests fail, with a bit more colors.

First we demangle the type name, then we replace common patterns (for example std::__cxx11::basic_string<char, char_traits<char>, allocator<char> > becomes string.

Do you think it's too colorful?

Well it took me a while to get another compiler to crash; I was getting worried I'm not using new stuff anymore.

This error means nothing.

I know I have fixed this before, I just don't remember how; but at least I know it's totally irrelevant.

In foresight, now we can detect what the user is typing.

Now let's see if we can also type things as well or not.

After that, I'm planning to put them all together with a bash script runner, and let us do crazy stuff like:

- Auto-complete things
- Replace texts
- Do things on shortcuts or random texts
- Run custom shortcuts anywhere
- ...

The search engine is using Aho-Corasick algorithm which creates a "trie" of patterns we want to search, but it's not that easy; we get events (like the ones in the image above) from Linux kernel, but we have texts to match them to it.

But we also support things like <Ctrl-r>. So how do we do both of them in the Aho-Corasick trie?

We convert <Ctrl-r> strings into 32bit integers, and we convert the rest of the text into UTF-32. And we convert events into Unicode code point, if it fails, we encode it into a 32bit integers.

Now that everything is in a 32-bit integer, we can match and see in which state of the trie we're in.

This is what I have to do just to get a boolean out of the kernel.

Am I doing it wrong?

The modified version of this code stopped working, so now I'm wondering if I was debugging the Linux kernel past few hours or my own code!

Well, something went wrong, and I don't know if it's me, my kernel, or my hardware. 😐🤦‍♂️

A simple member function call on each of the elements in C++ ranges should not be like this.

Seriously, I've yet to use ranges in a way that has not turned simple problems into impossible ones.

If you ever needed to check if type T is "default constructible at compile time", meaning the default construct of T is marked as constexpr or consteval, this little utility is for you.

Even if you don't need it, it's very interesting how it works.

Thanks to Vittorio Romeo for coming up with the idea.

I also made it support arguments as well, but for some reason I can't use std::declval, and even a custom declval implementation, so the only restriction is that the arguments have to be default constructible but not T itself.


[]<T=Args{}...}>{}() looks like gibberish to be honest; I wouldn't explain the syntax to a C++ newbie. 😁

These are just some of the URL-related issues open/closed so far.

I finally was able to make the ToASCII algorithm pass all the tests.

You ask why not just replace bad inputs with the replacement character (U+FFFD)?

Because of these two tests in the picture.
They're from IdnaTestV2.txt from Unicode tests, that even though they are failures, but if you disable the Validity Criteria options, you should end up with the results.

If we during Normalization process, replace bad code points with the replacement character, then the punycode encoded output would be different because we'd be converting the replacement character instead of the bad code point.

Even though, a compliant standard, does not need to have options to disable the features of IDNA Validity Criteria, I provide those options.

Even though I don't know how my mind end up deciding to support disabling those options, I ended up with that.

So, now you have options, that you can disable.

Optimize for "happy path" or the "failure path"?

I wrote my first blog post on substack. Let's see if I'm gonna give up writing blog posts in a few months or not!

https://moisrex.substack.com/p/optimize-for-happy-path-or-the-failure

Unicode Code Point "﷼" (U+FDFC) was a mistake.

Here's a vibe coded script that with it you can hide any message in a valid URL using forward and backward slashes.

Just to show you how poorly WHATWG URL Specs really are written.

The script

Locally Bound Globals

I'm not sure if there's a another name for it or not, but it's essentially a "global pointer" that acts like a reference, and can be made to point to local variables, so you don't have to keep passing it as args to funcs you call.

Using lbg_scope, we can assign the global pointer to point to local variable, and when it goes out of scope, it'll point to whatever was pointer before this scope.

Thus creating a very easy transition.

The global pointer's type itself can easily be implemented by just using "self" to point to the local instance of itself.

This is good for when you don't want to keep passing arguments 5 layers deep into your call chain, and just want to have access to it.

The Code