Jison not assuming correct grammar

[8150133]

I'm creating a grammar in jison

This is my jison file:

sgr.jison

    /*
    AUX VARIABLES
    */
    %{
    var contratos = "(E1:ENTIDADE)-[C:CONTRATO] -> (E2:ENTIDADE)";
    var dataArray = {};

    function
    translateQuery(dataArray) 
    {
        var finalQuery = dataArray["Listar"] + " "
                         + dataArray["Contratos"] + "\n"
                         + dataArray["Onde"] + " "
                         + dataArray["condition"] + "\n"
                         + dataArray["Retornar"] + " "
                         + dataArray["returnAttributes"]
        console.log("\n" + finalQuery)
    }

    %}

    /* description: Parses end executes mathematical expressions. */

    /* lexical grammar */
    %lex

    %%
    \s+                     /* skip whitespace */
    Listar                  return 'MATCH'
    Contratos               return 'CONTRACTS'
    Onde                    return 'WHERE'
    Retornar                return 'RETURN'
    e                       return 'AND'
    ou                      return 'OR'

    ","                     return 'DELIMITER'
    ";"                     return 'END'

    [><>=<==]               return 'MATH_SYMBOL'
    [0-9]+\b                return 'VALUE'
    [A-Za-z0-9.]+\b         return 'ENTITY_ATTRIBUTE'
    ["]                     return 'QUOTATION_MARK'

    /lex

    %start expressions

    %% /* language grammar */

    expressions :
        regra               
            {
                /*
                ADD SOMETHING 
                ONLY IF NEEDED
                */
            }
        | /* | significa um OU o que quer dizer que isto aqui pode ter mais do que uma regra ISTO E FEITO PELA RECURSIVIDADE*/
        expressions regra
            {
                /*
                ADD SOMETHING 
                ONLY IF NEEDED
                */
            }
    ;

     regra: 
        MATCH CONTRACTS
        WHERE condition
        RETURN returnAttributes END
            {
                $$ = $1 + " "
                    + $2 + " "
                    + $3 + " "
                    + $4 + " "
                    + $5 + " "
                    + $6 + " "
                    dataArray[$1] = "MATCH"
                    dataArray[$2] = contratos
                    dataArray[$3] = "WHERE"
                    dataArray["condition"] = $4
                    dataArray[$5] = "RETURN"
                    dataArray["returnAttributes"] = $6
                    /*ESTA FUNCAO TRATA DE TRADUZIR A QUERY QUE E INTERPRETADA*/
                    translateQuery(dataArray)
            }
     ;

     condition:
        ENTITY_ATTRIBUTE MATH_SYMBOL
            {
                $$ = $1 +  " "
                    + $2
            }
        |
        condition VALUE
            {
                $$ = $1 +  " "
                    + $2
            }
        |
        condition QUOTATION_MARK ENTITY_ATTRIBUTE QUOTATION_MARK
            {
                    $$ = $1 +  " "
                    + $2 + " "
                    + $3 + " "
                    + $4
            }
        |
        condition AND ENTITY_ATTRIBUTE MATH_SYMBOL VALUE
            {
                $$ = $1 +  " "
                    + $2 + " "
                    + $3 + " "
                    + $4 + " "
                    + $5
            }
        |
        condition OR ENTITY_ATTRIBUTE MATH_SYMBOL VALUE
            {
                $$ = $1 +  " "
                    + $2 + " "
                    + $3 + " "
                    + $4 + " "
                    + $5
            }
        |
        condition AND ENTITY_ATTRIBUTE MATH_SYMBOL QUOTATION_MARK ENTITY_ATTRIBUTE QUOTATION_MARK
            {
                $$ = $1 +  " "
                    + $2 + " "
                    + $3 + " "
                    + $4 + " "
                    + $5 + " "
                    + $6 + " "
                    + $7
            }
        |
        condition OR ENTITY_ATTRIBUTE MATH_SYMBOL QUOTATION_MARK ENTITY_ATTRIBUTE QUOTATION_MARK
            {
                $$ = $1 +  " "
                    + $2 + " "
                    + $3 + " "
                    + $4 + " "
                    + $5 + " "
                    + $6 + " "
                    + $7
            }
     ;

     returnAttributes:
        ENTITY_ATTRIBUTE
            {
                $$ = $1
            }
        |
        returnAttributes DELIMITER ENTITY_ATTRIBUTE
            {
                $$ = $1 + ""
                    + $2 + " "
                    + $3
            }
     ;

In my lexical grammar definition i have:

e      return 'AND'
ou    return 'OR'

so, whenever in my testfile "e" or "ou" were found they should return "AND" and "OR" respectively.

The problem is, when i test it, instead of returning me "AND" and "OR" it is returning me "e" and "ou".

Take a look:

This is my testfile:

test.sgr

 Listar Contratos
    Onde C.preco=1000
    Retornar C.Preco, C.NifAdjudicante,C.NifAdjudicataria;

    Listar Contratos
    Onde C.preco=1000 e E1.name="ESTG"
    Retornar C.Preco, C.NifAdjudicante,C.NifAdjudicataria;

    Listar Contratos
    Onde C.preco=1000 e E1.name="ESTG" e C.TipoProcedimento="ADS"
    Retornar C.Preco, C.NifAdjudicante,C.NifAdjudicataria;

    Listar Contratos
    Onde E1.name="ESTG"
    Retornar E1.name,C.Preco,C.NifAdjudicante,C.NifAdjudicataria;

    Listar Contratos
    Onde E1.name="ESTG" e C.preco=1000 ou C.preco>1000 
    Retornar E1.name,C.Preco,C.NifAdjudicante,C.NifAdjudicataria;

The outputs should be:

MATCH (E1:ENTIDADE)-[C:CONTRATO] -> (E2:ENTIDADE)
    WHERE C.preco = 1000
    RETURN C.Preco, C.NifAdjudicante, C.NifAdjudicataria

    MATCH (E1:ENTIDADE)-[C:CONTRATO] -> (E2:ENTIDADE)
    WHERE C.preco = 1000 AND E1.name = " ESTG "
    RETURN C.Preco, C.NifAdjudicante, C.NifAdjudicataria

    MATCH (E1:ENTIDADE)-[C:CONTRATO] -> (E2:ENTIDADE)
    WHERE C.preco = 1000 AND E1.name = " ESTG " AND C.TipoProcedimento = " ADS "
    RETURN C.Preco, C.NifAdjudicante, C.NifAdjudicataria

    MATCH (E1:ENTIDADE)-[C:CONTRATO] -> (E2:ENTIDADE)
    WHERE E1.name = " ESTG "
    RETURN E1.name, C.Preco, C.NifAdjudicante, C.NifAdjudicataria

    MATCH (E1:ENTIDADE)-[C:CONTRATO] -> (E2:ENTIDADE)
    WHERE E1.name = " ESTG " AND C.preco = 1000 OR C.preco > 1000
    RETURN E1.name, C.Preco, C.NifAdjudicante, C.NifAdjudicataria

However the outputs are:

What i've done wrong?

[GerHobbelt]

For the AND and OR tokens in your grammar rules, your rules' action code takes their value (condition rule: $$ = ... + $2 + ...; where $2 references the AND (or OR) token in that subrule. The value for the lexed token is its lexed string ('e' or 'ou' in your case) unless you specifically set it to something else.

Two ways about it (not tested; YMMV as this should work for the jison-gho fork at least, but not sure about jison itself):

1:

$$ = ... + 'AND' + ...; i.e. hardcoding the AND and OR strings in the grammar rules' action blocks.

2:

augment the lexer to return different token values (which will then be used by the $2 references):

e      yytext = "AND";
        return 'AND'
ou    yytext = "OR";
        return 'OR'

Second approach is cleaner IMO (and more akin to what you'ld do when doing this in classic lex / flex)