Question

I am using ANTLR to create an and/or parser+evaluator. Expressions will have the format like:

• x eq 1 && y eq 10
• (x lt 10 && x gt 1) OR x eq -1

I was reading this post on logic expressions in ANTLR Looking for advice on project. Parsing logical expression and I found the grammar posted there a good start:

grammar Logic;

parse
  :  expression EOF
  ;

expression
  :  implication
  ;

implication
  :  or ('->' or)*
  ;

or
  :  and ('&&' and)*
  ;

and
  :  not ('||' not)*
  ;

not
  :  '~' atom
  |  atom
  ;

atom
  :  ID
  |  '(' expression ')'
  ;

ID    : ('a'..'z' | 'A'..'Z')+;
Space : (' ' | '\t' | '\r' | '\n')+ {$channel=HIDDEN;};

However, while getting a tree from the parser works for expressions where the variables are just one character (ie, "(A || B) AND C", I am having a hard time adapting this to my case (in the example "x eq 1 && y eq 10" I’d expect one "AND" parent and two children, "x eq 1" and "y eq 10", see the test case below).

@Test
public void simpleAndEvaluation() throws RecognitionException{
    String src = "1 eq 1 && B";

    LogicLexer lexer = new LogicLexer(new ANTLRStringStream(src));
    LogicParser parser = new LogicParser(new CommonTokenStream(lexer));


    CommonTree tree = (CommonTree)parser.parse().getTree();

    assertEquals("&&",tree.getText());
    assertEquals("1 eq 1",tree.getChild(0).getText());
    assertEquals("a neq a",tree.getChild(1).getText());
}

I believe this is related with the "ID". What would the correct syntax be?

Answer 1

For those interested, I made some improvements in my grammar file (see bellow)

Current limitations:

• only works with &&/||, not AND/OR (not very problematic)

• you can’t have spaces between the parenthesis and the &&/|| (I solve that by replacing ” (” with “)” and “) ” with “)” in the source String before feeding the lexer)

  grammar Logic;

  options {
    output = AST;
  }
  
  tokens {
    AND = '&&';
    OR  = '||';
    NOT = '~';
  }
  
  // parser/production rules start with a lower case letter
  parse
    :  expression EOF!    // omit the EOF token
    ;
  
  expression
    :  or
    ;
  
  or
    :  and (OR^ and)*    // make `||` the root
    ;
  
  and
    :  not (AND^ not)*      // make `&&` the root
    ;
  
  not
    :  NOT^ atom    // make `~` the root
    |  atom
    ;
  
  atom
    :  ID
    |  '('! expression ')'!    // omit both `(` and `)`
    ;
  
  // lexer/terminal rules start with an upper case letter
  ID
    :
      (
      'a'..'z'
      | 'A'..'Z'
      | '0'..'9' | ' '
      | SYMBOL
    )+ 
    ;
  
  SYMBOL
    :
      ('+'|'-'|'*'|'/'|'_')
   ;