possiblePathsFrom and recursion + missing grammar validation

[cdietrich]

hi, first gratulations and thank you for this great project.
while exploring i found some problems i want you to know

trying to sketch a recursive expression grammar it looks like possiblePathsFrom might run into an infinite loop. do i overlook sth?

interface Expression {}

interface Add extends Expression {
    Left *Expression // stupid me
    Right *Expression
}

interface Mult extends Expression {
    Left *Expression
    Right *Expression
}

interface Literal extends Expression {
    value string
}

Addition returns Expression:
    Multiplication ({Add.Left=current} '+' Right=Multiplication)*
;

Multiplication returns Expression:
    Primary ({Mult.Left=current} '*' Right=Primary)*
;

Primary returns Expression:
    '(' Addition ')' | Literal
;

Literal returns Literal:
    value=INT
;

then i guess for the naming convention of Uppercase=Rule we need a validation.

[msujew]

hi, first gratulations and thank you for this great project.

Thanks!

trying to sketch a recursive expression grammar it looks like possiblePathsFrom might run into an infinite loop. do i overlook sth?

As long as the grammar doesn't feature any left recursion, this shouldn't be an issue. However, possiblePathFrom will currently stop after three tokens - which should be enough for the grammar in question.

then i guess for the naming convention of Uppercase=Rule we need a validation.

We still need quite a few validations - currently almost nothing in the grammar is being validated. I've opened #46 just now for the type related validations.

[cdietrich]

hmmm,

i added it to sm language and generation hangs

interface Transition {
    Event *Event
    State *State
    Condition Expression
}

Transition returns Transition:
    Event=[Event:ID] "=>"
    State=[State:ID]
    ("if" Condition=Expression)?
;

[msujew]

Interesting, I'll take a look on monday :)

[msujew]

@cdietrich It is indeed an infinite recursion, but mostly due to errors in the input document. This works for me:

interface Transition {
    Event *Event
    State *State
    Condition Expression
}

interface Expression {}

interface Add extends Expression {
    Left Expression
    Right Expression
}

interface Mult extends Expression {
    Left Expression
    Right Expression
}

interface Literal extends Expression {
    Value string
}

Addition returns Expression:
    Multiplication ({Add.Left=current} "+" Right=Multiplication)*
;

Multiplication returns Expression:
    Primary ({Mult.Left=current} "*" Right=Primary)*
;

Primary returns Expression:
    "(" Addition ")" | Literal
;

Literal returns Literal:
    Value=ID
;

Transition returns Transition:
    Event=[Event:ID] "=>"
    State=[State:ID]
    ("if" Condition=Addition)?;

#47 will help to find those errors :D

[cdietrich]

Thx I got it already Running on the Weekend. Just Wanted to Report it anyway so we can prevent it for other Users Like me that do stupid grammar mistakes like me