Decision can match input such as "{'A'..'Z', '_', 'a'..'z'}" using multiple alternatives: 1, 3

Question

I am a startbie for this antlr 3.5. I understood that left recursion is accepted in ant;r 4.0 and not in 3.5, I am getting ambigious error warning for my grammar . I am just verifying my email using this grammar, can some one fix this grammar

        grammar HelloWorld;

        options
        {
          // antlr will generate java lexer and parser
          language = Java;
          // generated parser should create abstract syntax tree
          output = AST;
          backtrack = true;
        }

        //as the generated lexer will reside in com.nuwaza.aqua.antlr
        //package, we have to add package declaration on top of it
        @lexer::header {
          package com.nuwaza.aqua.antlr;
        }

        //as the generated parser will reside in org.meri.antlr_step_by_step.parsers 
        //package, we have to add package declaration on top of it
        @parser::header {
          package com.nuwaza.aqua.antlr;
        }



        // ***************** parser rules:
        //our grammar accepts only salutation followed by an end symbol
        expression : EmailId At Domain Dot Web EOF;


        // ***************** lexer rules:
        //the grammar must contain at least one lexer rule
        EmailId: (Domain)+;   
        At : '@';
        Domain:(Identifier)+;
        Dot: DotOperator;
        Web:(Identifier)+|(DotOperator)+|(Identifier)+;
        /*Space
          :
          (
            ' '
            | '\t'
            | '\r'
            | '\n'
            | '\u000C'
          )

           {
            skip();
           }
          ;*/
        Identifier
          :
          (
            'a'..'z'
            | 'A'..'Z'
            | '_'
          )
          (
            'a'..'z'
            | 'A'..'Z'
            | '_'
            | Digit
          )*
          ; 
          fragment
        Digit
          :
          '0'..'9'
          ;

          fragment DotOperator:'.';

Answer 1

I am having two different grammar file and i am trying to use combined grammar for different abstraction. My code is as follows HelloWorldParser.g parser grammar HelloWorldParser;

                options
                {
                  // antlr will generate java lexer and parser
                  language = Java;
                  // generated parser should create abstract syntax tree
                  output = AST;
                }




                //as the generated parser will reside in org.meri.antlr_step_by_step.parsers 
                //package, we have to add package declaration on top of it



                // ***************** parser rules:
                //our grammar accepts only salutation followed by an end symbol
                expression1
                :
                Hello World EOF;

and HelloWorldLexer.g

        lexer grammar HelloWorldLexer;



        //as the generated lexer will reside in com.nuwaza.aqua.antlr
        //package, we have to add package declaration on top of it

        //as the generated parser will reside in org.meri.antlr_step_by_step.parsers 
        //package, we have to add package declaration on top of it




        // ***************** lexer rules:

        Hello: 'Hello';
        World: 'World';

My combined grammar is Test.g

                grammar Test;



                options
                {
                  // antlr will generate java lexer and parser
                  language = Java;
                  // generated parser should create abstract syntax tree
                  output = AST;
                }

                import HelloWorldLexer, HelloWorldParser;


                @lexer::header {
                  package com.nuwaza.aqua.antlr;
                }
                @parser::header {
                  package com.nuwaza.aqua.antlr;
                }


                // ***************** parser rules:
                //our grammar accepts only salutation followed by an end symbol
                expression:expression1;

My LexerParserGenerator is :

package com.nuwaza.aqua.antlr.generator;

            import org.antlr.Tool;


            public class LexerParserGenerator {



                private static final String OUTPUT_DIRECTORY_KEY = "-o";

                public static void main(String[] args) {

                        //provide the grammar ( .g file) residing path
                        String grammarPath = "./src/main/resources/grammar/Test.g";
                        //Specify the path with which grammar has to be generated.
                        String outputPath = "./src/main/java/com/nuwaza/aqua/antlr/";
                        Tool tool = new Tool(new String[] { grammarPath, OUTPUT_DIRECTORY_KEY,
                                outputPath });
                        tool.process();

                }

            }

Answer 2

I assume that your problem is in your rule: Identifier. If I were you, I would do something like:

Identifier : ID (ID |Digit)*; 

fragment ID : ('a'..'z' | 'A'..'Z' | '_');

I hope this would help you. ;)