Finding counterexamples from parsing conflicts

Abstract

Writing a parser remains remarkably painful. Automatic parser generators offer a powerful and systematic way to parse complex grammars, but debugging conflicts in grammars can be time-consuming even for experienced language designers. Better tools for diagnosing parsing conflicts will alleviate this difficulty. This paper proposes a practical algorithm that generates compact, helpful counterexamples for LALR grammars. For each parsing conflict in a grammar, a counterexample demonstrating the conflict is constructed. When the grammar in question is ambiguous, the algorithm usually generates a compact counterexample illustrating the ambiguity. This algorithm has been implemented as an extension to the CUP parser generator. The results from applying this implementation to a diverse collection of faulty grammars show that the algorithm is practical, effective, and suitable for inclusion in other LALR parser generators.

Solidity Parsing Using SmaCC

“…Creating a parser can be a difficult and time-consuming endeavor. Parser generators provide an easier way to tackle this problem [IM15]. Basically, we write the syntax specification using a formal grammar and the generator automatically builds the parser.…”

“…Shift-reduce is a process to handle input on bottom-up parsers, used by LR and LALR methods. However, there are context-free grammars where the shift-reduce process cannot decide if it should employ shift or reduce, thus creating a shift-reduce conflict [IM15,ALSU06]. SmaCC uses this process, and one of its error messages is a shift-reduce conflict [BLGD17].…”

“…Isradisaikul and Myers [IM15] describe the difficulty in solving grammar conflicts with LALR parser generators. They propose an algorithm that generates better counterexamples for LALR parsers.…”

Parse Condition: Symbolic Encoding of LL(1) Parsing

“…As writing parsers is a complex activity, Isradisaikul et al [21] attempt to assist in debugging conflicts by counterexamples from a parser run. As a parse conditions encodes the parser runs on all possible strings, they can also assist in such debugging activities by extracting the smallest counterexample and localizing a conflict to a smaller set of the grammar rules that are inconsistent (by extracting entities like unsat cores).…”

“…Writing and debugging parsers is remarkably painful-debugging conflicts in grammars remains an arduous activity even for experienced language designers [21]. The difficulty stems from the fact that all efficiently parsable languages, like LL(1), lack a simple syntactic identity-given a context-free grammar, it is not possible to deduce it to be LL(1) simply by examining its structure; successful construction of an LL(1) parse table is the test that a grammar needs to pass to qualify as LL (1).…”