serenity - The Serenity Operating System 🐞

Age	Commit message (Collapse)	Author
2022-07-20	LibRegex: Partially implement the ECMAScript unicodeSets proposal	Ali Mohammad Pur
	This skips the new string unicode properties additions, along with \q{}.
2022-07-10	LibRegex: Correctly track current inversion state in the optimizer	Ali Mohammad Pur
	This is currently not important as we do not nest TemporaryInverse.
2022-07-10	LibRegex: Flush compare tables before entering a permanent inverse state	Ali Mohammad Pur

2022-07-05	LibRegex: Use proper CharRange constructor instead of bit_casting	Ali Mohammad Pur
	Otherwise the range order would be inverted.
2022-07-04	LibRegex: Fully interpret the Compare Op when looking for overlaps	Ali Mohammad Pur
	We had a really naive and simplistic implementation, which lead to various issues where the optimiser incorrectly rewrote the regex to use atomic groups; this commit fixes that.
2022-02-20	LibRegex: Make codegen+optimisation for alternatives much faster	Ali Mohammad Pur
	Just a little thinking outside the box, and we can now parse and optimise a million copies of "a\|" chained together in just a second :^)
2022-02-14	LibRegex: Correct the alternative matching order when one is empty	Ali Mohammad Pur
	Previously we were compiling `/a\|/` into what effectively would be `/\|a`, which is clearly incorrect.
2022-02-09	LibRegex: Only skip full instructions when optimizing alternations	Ali Mohammad Pur
	It makes no sense to skip half of an instruction, so make sure to skip only full instructions!
2022-01-22	LibRegex: Preserve capture groups and matches across ForkReplace	Ali Mohammad Pur
	This makes the (flawed) ForkStay inserted as a loop header unnecessary, and finally fixes LibRegex rewriting weird loops in weird ways.
2022-01-21	LibRegex: Correct jump offset to the start of the loop block	Ali Mohammad Pur
	Previously we were jumping to the new end of the previous block (created by the newly inserted ForkStay), correct the offset to jump to the correct block as shown in the comments. Fixes #12033.
2021-12-21	LibRegex: Add some implied auto qualifiers	Hendiadyoin1

2021-12-21	LibRegex: Make append_alternation() significantly faster	Ali Mohammad Pur
	...by flattening the underlying bytecode chunks first. Also avoid calling DisjointChunks::size() inside a loop. This is a very significant improvement in performance, making the compilation of a large regex with lots of alternatives take only ~100ms instead of many minutes (I ran out of patience waiting for it) :^)
2021-12-15	LibRegex: Merge alternations based on blocks and not instructions	Ali Mohammad Pur
	The instructions can have dependencies (e.g. Repeat), so only unify equal blocks instead of consecutive instructions. Fixes #11247. Also adds the minimal test case(s) from that issue.
2021-11-18	LibRegex: Avoid rewriting `a+` as `a*` as part of atomic rewriting	Ali Mohammad Pur
	The initial `ForkStay` is only needed if the looping block has a following block, if there's no following block or the following block does not attempt to match anything, we should not insert the ForkStay, otherwise we would be rewriting `a+` as `a*` by allowing the 'end' to be executed. Fixes #10952.
2021-10-29	LibRegex: Don't ignore empty alternatives in append_alternation()	Ali Mohammad Pur
	Doing so would cause patterns like `(a\|)` to not match the empty string.
2021-10-03	LibRegex: Use a match table for character classes	Ali Mohammad Pur
	Generate a sorted, compressed series of ranges in a match table for character classes, and use a binary search to find the matches. This is about a 3-4x speedup for character class match performance. :^)
2021-09-29	LibRegex: Flatten bytecode before performing optimizations	Andreas Kling
	This avoids doing DisjointChunks traversal for every bytecode access, significantly reducing startup time for large regular expressions.
2021-09-15	LibRegex: Make the optimizer understand references and capture groups	Ali Mohammad Pur
	Otherwise the fork in patterns like `(1+)\1` would be (incorrectly) optimized away.
2021-09-14	LibRegex: Avoid excessive Vector copy when compiling regexps	Ali Mohammad Pur
	Previously we would've copied the bytecode instead of moving the chunks around, use the fancy new DisjointChunks<T> abstraction to make that happen automagically. This decreases vector copies and uses of memmove() by nearly 10x :^)
2021-09-13	LibRegex: Add a basic optimization pass	Ali Mohammad Pur
	This currently tries to convert forking loops to atomic groups, and unify the left side of alternations.