xtext生成器表达式getLeft和getRight

Question

I'm trying to write a DSL via Xtext with which I can customize SQL. First I want to have a string representation of my query. There I got stuck on the expressions. I created them after this example: https://typefox.io/parsing-expressions-with-xtext .

Expression returns Expression: 
OrExpression;

OrExpression returns Expression:
AndExpression ({OrExpression.left=current} name="OR" right=AndExpression)*;

AndExpression returns Expression:
 NotExpression({AndExpression.left=current} name="AND" right=NotExpression)*;

NotExpression returns Expression:
 ComparisonExpression({NotExpression.left=current} name='NOT' right=ComparisonExpression)*;

ComparisonExpression returns Expression:
BitwiseOR({ComparisonExpression.left=current} name=cmpop right=BitwiseOR)*;

BitwiseOR returns Expression:
BitwiseAND ({BitwiseOR.left=current} name='|' right=BitwiseAND)*;

BitwiseAND returns Expression:
BitwiseXOR ({BitwiseAND.left=current} name='&' right=BitwiseXOR)*;

BitwiseXOR returns Expression:
Addition ({BitwiseXOR.left=current} name='^' right=Addition)*;

Addition returns Expression:
Substraction ({Addition.left=current} name='+' right=Substraction)*;

Substraction returns Expression:
Multiplication ({Substraction.left=current} name='-' right=Multiplication)*;

Multiplication returns Expression:
Division ({Multiplication.left=current} name='*' right=Division)*;

Division returns Expression:
Modulo ({Division.left=current} name='/' right=Modulo)*;

Modulo returns Expression:
Primary ({Modulo.left=current} name='%' right=Primary)*;

Primary returns Expression:
=> count=count
| => func=funccall
| {Bracket} '(' inner=Expression ')'
| (name=unop) expr=Expression
| (name=unop)? ID=Literal ('IS' 'NOT'? 'NULL')?;

/*Values that a Expression can have */
Literal returns Expression: 
value=values;

I can manage to get to get a single value but im unable to get the left or the right side of a expression.

My Generator (unfinished and with my testings looks like this)

class TsqlGenerator extends AbstractGenerator {
StringBuilder st = new StringBuilder();
TimeConditionHandler tch = new TimeConditionHandler
ExpressionHandler exprH = new ExpressionHandler
String expression = ""
int fromIndex = 0;
int whereIndex


def clear() {
    st.delete(0, st.length);
    fromIndex = 0;
    whereIndex =0;

}

override beforeGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { clear() }

override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) {

    for (e : resource.allContents.toIterable.filter(ComplexSelect)) {

        /*SELECT */
        // TODO: String Value ohne Anführungszeichen?
        st.append("SELECT ");
        for (selectArgument : e.left.selectArguments.arguments) {
            if (selectArgument.expr.name == null) {
                //hier später in eine Liste speichern?
                    st.append(" " + selectArgument.expr.ID.value.name);
            }else {
                // TODO: Generate a Sting of the Expression!

            }
        }

        /*FROM */
        st.append(" FROM ")
        //Hier ebenso in eine Liste speichern?
        for (fromSource : e.left.from.sources) {
                st.append(e.left.from.sources.get(fromIndex).name);
        }

        /*WHERE */
        if (e.left.where !== null || e.left.timedef !== null) {
            st.append(" WHERE");

            if (e.left.where !== null) {
                for (whereArgument : e.left.where.predicates.expr) {
                    if (whereIndex == 0) {
                        st.append(" " + whereArgument.ID.value.name);
                    } else {
                        st.append("AND " + whereArgument.ID.value.name);
                    }
                    whereIndex++;
                }
            }
            /*TIMEINTERVALL 
             *TODO: timestamp as columname hardcoded*/
            if (e.left.timedef !== null) {
                if (whereIndex > 0) {
                    st.append(" AND")
                }
                st.append(tch.toIso8601(e.left.timedef))
                //if (e.left.timedef.name != null) {
                //st.append(" ").append(e.left.where.name);
            }
            }



        fsa.generateFile("query.txt", st.toString());

    }

}

Answer 1

Given the following simplified grammar

grammar org.xtext.example.mydsl1.MyDsl with org.eclipse.xtext.common.Terminals

generate myDsl "http://www.xtext.org/example/mydsl1/MyDsl"

Model:
    (expressions+=Expression ";")*;

Expression returns Expression:
    OrExpression;

OrExpression returns Expression:
    PrimaryExpression ({OrExpression.left=current} name="OR" right=PrimaryExpression)*;

PrimaryExpression returns Expression:
     '(' Expression ')'
    | {Negation} "NOT" expr=Expression 
    | {IntLiteral} value=INT
    | {StringLiteral} value=STRING
    | {Variable} name=ID;

the input NOT x or y can be parsed in two ways: Either as

Or(Negation(Variable("x")), Variable("y"))

or as

Negation(Or(Variable("x"), Variable("y")))

When compiling the Xtext grammer it tells you so (somewhat vaguely) with warnings likes this:

warning(200): ../org.xtext.example.mydsl1/src-gen/org/xtext/example/mydsl1/parser/antlr/internal/InternalMyDsl.g:195:3: Decision can match input such as "'OR'" using multiple alternatives: 1, 2
As a result, alternative(s) 2 were disabled for that input

The important part here is: [...]alternative(s) 2 were disabled for that input . So parts of your grammar are dead code and effectively ignored.

Solution: Put all operators into the precedence hierarchy properly. Do not put anything complex into PrimaryExpression . In fact ( Expression ) should be the only place which calls a rule higher in the hierarchy. The result is a conflict-free grammar like this:

OrExpression returns Expression:
    IsNullExpression ({OrExpression.left=current} name="OR" right=IsNullExpression)*;

IsNullExpression returns Expression:
    CompareExpression ({IsNullExpression.expr=current} 'IS' not?='NOT'? 'NULL')?;

CompareExpression returns Expression:
    NegationExpression ({CompareExpression.left=current} name=("NOT"| "=" | "!=") right=NegationExpression)*;

NegationExpression returns Expression:
    {NegationExpression} name=("NOT" | "-") expr=PrimaryExpression
    | PrimaryExpression;

PrimaryExpression returns Expression:
     '(' Expression ')'
    | {IntLiteral} name=INT
    | {StringLiteral} name=STRING
    | {Variable} name=ID;

Note that this grammar is conflict free despite several keywords are used multiple times in distinct places (eg NOT , - ).