parsing - एन्टल्रेश 3 के साथ तार्किक संयोजन के पेड़ में स्टैक्ड तुलना की अभिव्यक्ति पार्स करें



tree antlr3 (1)

मैं वास्तविक पेड़ इमारत जावा कोड लिखकर इस समस्या का एक गंदा समाधान के साथ आया हूं:

grammar testgrammarforcomparison;

options {
  language = Java;
  output = AST;
}

tokens
{
 CONJUNCTION;
 COMPARISON;
 OPERATOR;
 ADDITION;
}


WS
:
    ('\t' | '\f' | ' ' | '\r' | '\n' )+
    {$channel = HIDDEN;}
;

comparison
@init 
{ 
  List<Object> additions = new ArrayList<Object>();
  List<Object> operators = new ArrayList<Object>();
  boolean secondpart = false;
}
:
(( e=addition {additions.add(e.getTree());} ) ( op=operator k=addition {additions.add(k.getTree()); operators.add(op.getTree()); secondpart = true;} )*) 
{
  if(secondpart)
  {
      root_0 = (Object)adaptor.nil();

            Object root_1 = (Object)adaptor.nil();
            root_1 = (Object)adaptor.becomeRoot(
            (Object)adaptor.create(CONJUNCTION, "CONJUNCTION")
            , root_1); 

      Object lastaddition = additions.get(0);

            for(int i=1;i<additions.size();i++)
      {
        Object root_2 = (Object)adaptor.nil();
        root_2 = (Object)adaptor.becomeRoot(
        (Object)adaptor.create(COMPARISON, "COMPARISON")
        , root_2); 

        adaptor.addChild(root_2, additions.get(i-1)); 
        adaptor.addChild(root_2, operators.get(i-1));
        adaptor.addChild(root_2, additions.get(i)); 

        adaptor.addChild(root_1, root_2);
      }
  adaptor.addChild(root_0, root_1);
  }
  else
  {
   root_0 = (Object)adaptor.nil();
   adaptor.addChild(root_0, e.getTree());
  }
}
;
/** lowercase letters */
fragment LOWCHAR
:   'a'..'z';
/** uppercase letters */
fragment HIGHCHAR
:   'A'..'Z';
/** numbers */
fragment DIGIT
:   '0'..'9';

fragment LETTER
: LOWCHAR
| HIGHCHAR
;

IDENTIFIER
:
 LETTER (LETTER|DIGIT)*
;

addition
:
 IDENTIFIER ->^(ADDITION IDENTIFIER)
;

operator 
:
 ('<'|'>') ->^(OPERATOR '<'* '>'*)
;

parse
:
 comparison EOF
;

इनपुट के लिए

"DATA1 < DATA2 > DATA3" 

यह पेड़ों का उत्पादन करता है जैसे कि:

यदि आप लोग बेहतर समाधान जानते हैं, तो कृपया मुझे उनके बारे में बताएं

मैंने एक समस्या में भाग लिया है, जब मैंने एक स्टैक्ड अंकगणित तुलना अभिव्यक्ति को पार्स करने की कोशिश की:

"1<2<3<4<5" 

संयोजन के एक तार्किक पेड़ में:

CONJUNCTION(COMPARISON(1,2,<) COMPARISON(2,3,<) COMPARISON(3,4,<) COMPARISON(4,5,<))

क्या एंटीआरआर 3 ट्री में कोई तरीका है जो मिलान वाले टोकनों के माध्यम से पुनरावृत्त करने के लिए और लक्ष्य भाषा में उनके परिणाम का पेड़ बनाने के लिए नियम है (मैं जावा का उपयोग कर रहा हूं)? इसलिए मैं मिलान एक्स 'एक्स' की तुलनात्मक नोड्स से मेल खाता 'अतिरिक्त' टोकन बना सकता हूं। मुझे पता है कि मैं नियम के आखिरी परिणाम का संदर्भ दे सकता हूं, लेकिन इस तरह से मैं केवल नेस्टेड नियमों को प्राप्त करता हूं, यही मेरी इच्छा नहीं है।

/This is how i approached the problem, sadly it doesn't do what i would like to do yet of course.

fragment COMPARISON:;

operator
:
('<'|'>'|'<='|'>='|'=='|'!=')
;

comparison
@init{boolean secondpart = false;}
:
e=addition (operator {secondpart=true;} k=addition)* 
-> {secondpart}? ^(COMPARISON ^(VALUES addition*) ^(OPERATORS operator*))
-> $e
;

//Right now what this does is:
tree=(COMPARISON (VALUES (INTEGERVALUE (VALUE 1)) (INTEGERVALUE (VALUE 2)) (INTEGERVALUE (VALUE 3)) (INTEGERVALUE (VALUE 4)) (INTEGERVALUE (VALUE 5))) (OPERATORS < < < <))



//The label for the CONJUNCTION TreeNode that i would like to use:
fragment CONJUNCTION:;  




antlr3