| Geth | rakudo: ugexe++ created pull request #6652: Measure a case-folded interpolation match against the target |
00:52 | |
| rakudo: ugexe++ created pull request #6653: Throw for a hash used as a regex assertion |
00:53 | ||
|
01:54
kurahaupo left
02:11
coleman left,
summerisle left,
ugexe left
02:27
coleman joined,
summerisle joined,
ugexe joined
|
|||
| Geth | rakudo: ugexe++ created pull request #6654: Match the lookahead greedily in the LTM before-assertion test |
03:31 | |
| rakudo/main: f4f55b2775 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files Match the initializer symbol before rejecting a signature declaration (#6651) Previously initializer:sym<=> checked for a signature declaration before matching its symbol, so that group led the candidate and set its declarative prefix. Once a sequential alternation ends the prefix, that candidate has an empty prefix and gets tried on any input. A my :(...) declaration with no initializer at all then died with the assignment error instead of the missing initializer one. This matches the symbol first, so the candidate is only tried when an assignment is actually there. |
03:34 | ||
| nqp/main: 8172e76567 | (Nick Logan)++ | 2 files Stop the declarative prefix at a sequential alternation Previously the NFA for a sequential alternation covered its first branch and an empty path, then kept going with whatever followed the group. That made the declarative prefix of `[ x || y ] z` behave like `x? z`, so a branch of a longest token alternation containing that group was never tried on input such as `yz` even though `y` matches ... (6 more lines) |
04:01 | ||
| nqp/main: 26181555c8 | (Nick Logan)++ | src/QRegex/NFA.nqp Stop building a repetition after the declarative prefix has ended Previously the counted repetition loop kept calling the builder with whatever state the previous repetition returned, and a repetition that ended the declarative prefix returns no state. The loop then pushed edges onto the fate list, and a sequential alternation under a counted quantifier is a common way to end the prefix. This leaves the loop once a repetition ends the prefix. Only the paths that skipped the remaining repetitions carry on. |
04:02 | ||
| nqp/main: f639323a13 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files Merge pull request #871 from ugexe/ugexe/altseq-terminates-ltm Stop the declarative prefix at a sequential alternation |
|||
| rakudo: ugexe++ created pull request #6655: Bump NQP to stop the declarative prefix at a sequential alternation |
04:04 | ||
| rakudo/main: ab802d1eef | (Nick Logan)++ (committed using GitHub Web editor) | t/02-rakudo/ltm-before-assertion.t Match the lookahead greedily in the LTM before-assertion test (#6654) Previously the test grammar looked ahead with `.+?`, which only contributed to the declarative prefix because the NFA treated a frugal quantifier like a greedy one. S05 ends the longest token at a frugal quantifier, so the test would then assert nothing about the lookahead being inlined, which is what it was written for. This looks ahead with `.+` instead. Inside a lookahead nothing is consumed, so the assertion succeeds on the same input either way. |
04:46 | ||
| rakudo/main: 6b984fe73f | (Nick Logan)++ (committed using GitHub Web editor) | tools/templates/NQP_REVISION Bump NQP to stop the declarative prefix at a sequential alternation (#6655) |
05:16 | ||
|
05:20
kurahaupo joined
|
|||
| Geth | rakudo/main: 2d14ad281b | (Nick Logan)++ (committed using GitHub Web editor) | 2 files RakuAST: split long decimal numbers before converting them to Int (#6647) Previously the literal builder handed a whole decimal digit string to the VM bigint parser, which is quadratic in the digit count. A capture variable, integer literal, or regex quantifier bound with a million digits took around a minute to compile, while the legacy frontend parsed the same capture index into a native int in under a second. ... (7 more lines) |
05:23 | |
| rakudo/main: d6ada9bd14 | (Nick Logan)++ (committed using GitHub Web editor) | 2 files Backtrack into interpolated regex alternatives (#6650) Previously an array (or list, or any junction) interpolated into a regex was tried once: INTERPOLATE walked every candidate the NFA passed and returned the longest match as a plain cursor. When the rest of the regex failed after it there was nothing to backtrack into, so `'abc' ~~ / @(< a ab >) b /` was Nil where the literal `< a ab >` form ... (17 more lines) |
05:26 | ||
|
06:17
kurahaupo left
|
|||