Table-Driven Character Classification (Lookup Table/LUT) and Bitmask Accumulation

One of the ways that I'm designing my parsers is using Bitmask Accumulation in combination with a table lookup.

Essentially, I create a table of 256 length and lookup each character in it and use bitwise operator or (|) to accumulate them all into one single uint8_t integer which each bit of that integer can convey information about the types of characters that gave it.

This is a form of classification or categorization.

Then we simply can ask our 8 bit integer if the input for example for the code in the picture:
- Is it possible for it to have IPv4
- Possibility of IPv6
- Contains any specific characters that need special handling like % # ? / \
- Any invalid code points
- Possibility of existence of punycodes
- Existence of Unicode

Of course depending on the table, we can find out other information as well.

This helps the algorithm to completely disable a whole lot of checks.

Instantiating a generator as a template for certain reasons prevents compilers such as GCC and Clang from identifying it as a coroutine, resulting in errors indicating that std::coroutine_traits was not found. Implementing a non-templated override resolves this issue. It is uncertain whether this constitutes a compiler bug or standard behavior.

Setting IDE's line-height to a less than 1.0 value is not visually pleasing, but I must confess that it helps to reduce scrolling.

Did GCC implemented C++26's template for by just copying and pasting the body? 😁

What's the best way to handle errors in consteval functions?

- noexcept + throw std::exception-based
- noexcept + throw "char pointers"
- no noexcept, only throw
- assert
- static_assert (how?)
- return error (std::optional, std::expected, ...)

I wanted to use std::indirect, but I needed something pimpl idiom that:

- consteval constructible-only
- consteval copyable-only

Ended up writing custom nullable_indirect; at least for now.

Called it consteval_copyable and removed a whole bunch of repetitive constructors.

Now I can hold shift, and slow down my mouse and my stylus.

Good for scaling down the drawings and writings.

This simple pipeline pretty much blows up the system by itself.

How? it doesn't grab the keyboard's events, creates a new virtual keyboard, and re-grabs its own virtual keyboard events.

Is it called stack-overflow or kernel-overflow or what? 😅

Added momentum to the scroll wheel.

The scroll itself of course is being converted from pen's events to mouse events, and then we add momentum to it.

My WHATWG URL implementation is now passes WHATWG tests.

Obviously ada wins, but I do win against older ada v2.9.2.

(not reliable benchmark results)

Not creating temporary strings reduces 140ns to 70ns.