bison | This package contains the GNU Bison parser generator | Parser library

It's not really an ambiguity. As far as I can see, your language is unambiguous. However, the grammar is not deterministic when restricted to a single lookahead token.

The extremely useful counterexample generator does indeed describe the problem. When the parser sees the ) in let foo = (x) it has to decide whether x is a decl or an expr_primary. The answer will be obvious as soon as the second-next token is seen; if the ) is followed by ->, then the parentheses contain a decl_list; otherwise, the parentheses contain an expr. So there's no ambiguity. But that doesn't necessarily help you :-)

LALR(2) grammars -- which is what you have -- are a perennial problem, and there are three basic strategies to solve them:

1. Use a GLR parser. This is certainly the easiest strategy; all it requires is to add %glr-parser to your parser declarations. (You might also need to update your bison version and possibly specify a different parser skeleton, depending on your bison version, if your semantic type is not compatible with C.) GLR parsers can parse any unambiguous grammar, regardless of how much lookahead might be required. The extra flexibility comes at a cost, but in the case of using GLR to parse an LALR(2) grammar, the cost is almost negligible.

   Note that even if you ask for a GLR parser, Bison will still report the conflict, on the assumption that you wanted to know about it. But it no longer matters, because the GLR parser can handle multiple possible parses at the same time, as long as the grammar is (eventually) unambiguous. Bison pretty well has to report the conflict, because a conflict could be the result of an ambiguity, in which case you'd need to do something. You can suppress the report using an %expect-rr declaration.

   There is no algorithm which can tell whether an arbitrary grammar is ambiguous. Bison does its best with the counterexamples report, but it doesn't always work and it certainly doesn't always indicate an ambiguity. But if the grammar happens to not be ambiguous, a GLR parser will work.

   With GLR parsers, ambiguity is reported as a run-time error. That's maybe not ideal, but since there is no way to tell in advance, that's the best you can do. Other GLR parser generators will return both (or all) possible parses, which you can do with Bison using a custom ambiguity resolver, but in practical applications you generally want the grammar to be unambiguous. If Bison reports a conflict, you should test the parser with relevant inputs and ensure that it doesn't fail with an ambiguity message.

2. Change the grammar so that it's LALR(1). This is always possible because every LR(k) language has an LALR(1) grammar. There's even a (fairly) simple algorithm which can be used to convert an LALR(k) grammar into an LALR(1) grammar provided that k has a known value. Unfortunately, the algorithm produces enormous grammars, which become extremely hard to maintain. (I guess that would be OK if bison came with an automatic rewriter, but it doesn't.) So you'd probably be better off trying to rejig the grammar by hand, which isn't too awful because there's only one conflict which requires two lookahead tokens and you already know what it is.

   The rough outline of a solution goes like this:

   The problem is that the parser can't tell what ( IDENTIFIER ) is until it sees the next token. So all we need to do is make it unnecessary for the parser to perform a unit reduction on that particular IDENTIFIER. To do that, we can create a redundant non-terminal and add productions which use it:

Solution:

The problem was in lines of code not included. llvm::Function::Create requires an llvm::FunctionType which can be provided by filling a vector with llvm::Type* objects. I wrote a function to do this:

That problem is solved by declaring

Besides using id for the IDs, as mentioned in the comments, you can do some refactoring to get SwiftUI to not re-render as much of the view hierarchy and instead reuse components. For example, you have an if condition and in each you have separate Section, ForEach, etc components. Instead, you could render the content of the ForEach based on the state of the search:

I have a two part solution to this problem that seems to do the trick. Please note, I am using re-entrant options for Flex/Bison, so this might not work exactly the same for everyone.

I actually already had code to define YY_FATAL_ERROR so I added the ECHO code to that. I added the following code to the preamble of my .l file:

For more informative error strings you need %error-verbose in yacc file. Perhaps like that in your file:

The basic problem is that you've split digit sequences with gaps and digit sequences without gaps into two independent rules, which means you need to decide which you're going to match first, which requires (possibly unbounded) lookahead to decide which to match.

The solution is generally to match tokens "bottom up" -- single rule for each thing independent of context, and build up lookahead-dependent things from that. In you case, that means building up IntegerToken from DigitStar rather than from DIGIT directly -- an input of digits will be recognized as a DigitStar and only when you get to the end of it (and see the non-digit) do you need to decide what it is.

The problem is that the obvious fix for your grammar (changing IntegerToken: DIGIT | GAP to DigitStar | GAP) doesn't work because it makes IntegerTokenStar (and -Plus) ambigous as any sequence of 2 or more digits might be any number of DigitStar tokens. So you need to rewrite this to make sure you can't have two consecutive DigitStar tokens, which turns out to be quite tricky. Your really need to rethink things "bottom up" -- the input is a sequence of alternating numbers (1+ digits each) and gaps (1+ spaces), with an optional single / that can appear directly between two numbers (no gaps) or a number and a gap (no gap before the /). So you get rules that look more like:

Open the file:

In the last test case you are not sending a second argument to the function, so it is the first part of the if-else that will run - the if part. There is no return -1 in that part.