Syntax Analysis

Shift pushes the next input token onto the parse stack; reduce recognises a handle, a complete right-hand side sitting on top, pops those symbols and pushes the rule's left-hand nonterminal. The generated table decides which, per state and lookahead.

Ordered choice commits to the first alternative that succeeds at a position, so each rule yields at most one result there. The grammar defines one recognizer rather than a set of permitted derivations, so a second parse tree cannot exist.

The power handed to the right-operand recursion decides it: recursing with the operator's power plus one makes it left-associative, because an equally binding operator is then refused; recursing with the same power makes it right-associative.

A binding power is a number per operator saying how tightly it grips its neighbours. One loop parses an operand, then keeps absorbing operators whose power clears the caller's minimum, recursing once per right operand.

Each grammar rule becomes one function. The function inspects the next token without consuming it, compares it with the set of tokens each alternative can begin with, and takes the single alternative whose set matches; nested rules become nested calls.

Left recursion: a rule whose first symbol is the rule itself, directly or through a chain. Its function calls itself before consuming anything, so every level re-enters at the same input position and the recursion never terminates.

After a failure the parser's state no longer matches the text, so every following token disagrees and becomes another message. Suppression combines real resynchronisation, a quiet window after each report, deduplication, and a cap.

A shift-reduce conflict means one state can both shift the next token and reduce a completed rule on that same token, so the table is not deterministic. Generators conventionally prefer shift, silently binding the construct to the innermost open one.

The choice lists note before notebook, and the first success wins, so the shorter literal matches and the longer alternative is never tried. A choice that has already succeeded is not retried when the rest of the rule struggles.

From the parser's state at the moment it failed: the tokens that state could legally have accepted next. Tools then rename, group, rank and truncate that raw set, because printing it unedited produces an unreadable message.

An LR parser commits only after the whole right-hand side is already on its stack, plus the lookahead beyond it. An LL parser must choose the rule before reading any of it, from lookahead alone. More evidence, later decision.

It stores the outcome of each rule at each input position: failure, or success with the end position and result. Because every rule-position pair is computed once and then reused, total work is proportional to input length times grammar size.

An alternative that derives nothing begins with no token, so FIRST cannot describe it. The parser takes that empty branch when the next token is one that may legally appear immediately after the rule — that set is FOLLOW.

A reduce-reduce conflict means identical stack contents could become two different nonterminals. The conventional default picks whichever rule was declared first, so the other construct is never built in that context and a whole feature quietly disappears.

Nothing discards whitespace for a scannerless parser: its rules match raw characters, so any space, tab or newline a rule does not consume is still sitting there and makes the next literal fail. Spacing is threaded through the rules by hand.

A prefix operator has no left operand, so it carries a single power of its own, used as the floor when parsing its argument. That number decides how far right the argument reaches, and it is usually higher than the infix power of the same symbol.

That cell says two alternatives of the same rule are predicted by the same lookahead token, so one token cannot choose between them. The rule set is not LL(1), and a purely predictive parser for it cannot be written as written.

Totality: a tree for any input, spanning every byte, with unparsable spans held by explicit error nodes and fabricated tokens marked, plus one flag saying whether any error node exists — so each caller picks its own strictness.

Treat each unread conflict as an undocumented language decision: reproduce what the shipped parser does on inputs that reach it, decide whether that is the intended language, then reshape the rules or record the choice explicitly before adding anything new.

Adopt it when the operator set keeps growing or precedence must be data: each addition becomes one table row instead of a new rule layer and an edit to its neighbour. The cost is that precedence stops being readable from the code and becomes numbers you must document and regression-test.

Phrase-level repair edits the token stream locally: if fabricating the one token the state expected, or dropping the current stray token, lets parsing progress, the parser does that, marks the edit synthetic, and reports once.

SLR and LALR share the LR(0) state set, so their tables are the same size; SLR reduces on global FOLLOW sets, LALR on merged per-state lookaheads, and canonical LR(1) splits states to keep every lookahead exact, at a large size cost.

Brackets cancel the surrounding grip, so the inner parse starts from the loosest possible floor and can absorb every operator up to the closing bracket. Passing the ambient floor instead stops the inner parse early and reports a spurious error at the bracket.

An ordered-choice grammar defines its language operationally: the accepted set is whatever that recognizer accepts, with no independent description to check against. Conformance becomes behavioural agreement, so the specification must ship with a test corpus, not just rules.

Write it by hand when the quality of failure matters most — precise messages, recovery, partial trees for an editor — and when the grammar is small and stable. Generate it when the rule set is large, changes often, and must stay machine-checked.