antlr3 | antlr v3 repository (pulled from p4 with history from //depot/code/antlr/antlr3-main

Try adding Trusted_Connection=True; to your connection string

to me you missed Syntax error, '>' expected for img tag in file Tools/Index.cshtml

It is impossible. And there is no parameter for ProjectUrl under Get-Package | select xxx command. And that is a feature request.

So if you want that, you should request a feature to the Team and when you finish that, you could share the link here and anyone who is interested in it including us will vote it. And those will help get more attention from Microsoft.

To specify the number of digits for a data type, use MaxLength().
Note that you cannot specify the number of digits by writing it in Column(TypeName := "").

This exact example (character-by-character) is found on page 277 of the ANTLR3 version of The Definitive ANTLR Reference, which is available on-line (at least for limited previewing as well as paid download). It's used as an explanation of one of the aspects of the LL(*) algorithm used in ANTLR3, so the explanation on the following pages is probably the best detailed answer to your question. In addition, various possible solutions are discussed.

So let me focus on just one of your questions, which I think will also answer the question in the post title.

1. What is * in LL(*) if not backtracking after an unsuccessful, arbitrarily long lookahead?

LL(*) is a heuristic algorithm and not a formal language category; Terence Parr (the author of ANTLR) uses the term to label a particular parsing algorithm used in ANTLR3. (ANTLR4 uses a different algorithm, which Parr calls Adaptive LL(*). I'm not goint to get into that.)

LL parsing, in general terms, decides which production to use before starting to parse the production. LL(k) parsing makes that decision based on the following k tokens, where k is some fixed (and usually small) integer. That was basically the algorithm used in ANTLR2, and it's not really good enough to handle many grammars.

To make the algorithm more general, you can add backtracking (which ANTLR does); if after examining k tokens, the parser still can't decide which production to use, it tries them in order until it finds one which works. If an attempted production fails, the parser returns to the decision point and tries the next production. If a production succeeds, the parser accepts it and continues, even if that might lead to a parsing failure later on. (So the order of productions in the grammar is important in a backtracking parser.)

LL(*) does not involve backtracking. Rather, it constructs a finite-automaton-based forward scan which matches an arbitrarily long lookahead sequence against a regular expression (of tokens, not characters, but the principle is the same). If it can construct (while compiling the grammar) regular expressions for each candidate production which unambiguously distinguish between the alternatives, then it can rapidly run the finite automatons in parallel at a decision point and make a decision. The * in LL(*) makes reference to the fact that there is no arbitrary length limit on the lookahead; it is only necessary that the regular expressions diverge at some point in the future.

As a practical example, in the grammar you present the alternative

Your rule:

The v3 grammar:

Solved. Google Api works with IIS > 7 and stucks with IIS 7.

Simply upgrading the operating system solve the problem

The part after -> is not rule rewiring but tree rewriting. ANTLR3 produced an AST which you could manually change using this tree rewriting syntax. ANTLR4 no longer produces ASTs but parse trees, which you cannot change (as they represent the path taken through the grammar).

So the simple solution is to remove everything on a line starting with ->, example: