`ExprStat.sdf3`

pdmosses/metaborg-poosl/org.metaborg.lang.poosl/syntax/ExprStat.sdf3
module 

imports
    Common

context-free sorts
    
    
    AndStatement
    OrStatement
    
    CaseStatementList
    CaseStatement
    OptDefaultStatement

    
    
    OnSuperClass
    
    OptVariableList
    ExpressionList
    CaseExpressionList
    CaseExpression
    OptDefaultExpression
    
    
    
    
    
    VariableList
    
    OptReceptionCondition

context-free syntax

    // === Statements =======

    .StatementSequence =                   [[{SingleStatement ";\n"}+]]

    .AbortStatement = [
        abort
            [Statement]
        with
            [SingleStatement]
        ]
    .DelayStatement =                [delay [SingleExpression]]
    .GuardedStatement =              <[<Expression>] <SingleStatement>>
    .InterruptStatement = [
        interrupt
            [Statement]
        with
            [SingleStatement]
        ]
    .ParStatement = [
        par
            [Statement]
        [AndStatement+]
        rap
        ]
    .ProcessMethodCallStatement =    ProcessMethodCall
    .SelStatement = [
        sel
            [Statement]
        [OrStatement+]
        les
        ]
    .SkipStatement =                 [skip]
    .SendStatement =                 [[ID]![ID][OptExpressionList] [OptPostExpression]]
    .ReceiveStatement =              [[ID]?[ID][OptVariableList] [OptReceptionCondition] [OptPostExpression]]
    .IfThenStatement = [
        if [Expression] then 
            [Statement]
        fi
        ]
    .IfThenElseStatement = [
        if [Expression] then
            [Statement]
        else
            [Statement]
        fi
        ]
    .RoundBracketStatement = [
        (
            [Statement]
        )
        ]
    .WhileStatement = [
        while [Expression] do
            [Statement]
        od
        ]
    .SwitchStatement = [
        switch [Expression] do
            [CaseStatementList]
            [OptDefaultStatement]
        od
        ]
    .ExpressionStatement =           SingleExpression
    .CurlyExpressionStatement =      [{ [Expression] }]

    .ProcessMethodCall =           [[ID][ExpressionList][VariableList]]

    AndStatement.AndStatement = [
        and
            [Statement]
    ]
    OrStatement.OrStatement = [
        or
            [Statement]
    ]

    CaseStatementList.CaseStatementList =           [[{CaseStatement "\n"}*]]
    CaseStatement.CaseStatement =
        [case [Expression] then
            [Statement]]
    OptDefaultStatement.DefaultStatement =
        [default
            [Statement]]
    OptDefaultStatement.NoDefaultStatement =        []

    .PostExpression =              [{ [Expression] }]
    .NoPostExpression =            []

    OptReceptionCondition.ReceptionCondition =      [| [Expression] |]
    OptReceptionCondition.NoReceptionCondition =    []

    OptVariableList.Variables =                     [([{ID ", "}*])]
    OptVariableList.NoVariables =                   []

    VariableList.VariableList =                     [([{ID ", "}*])]


    // === Expressions =======

    .ExpressionSequence =                 [[{SingleExpression ";\n"}+]]

    // --- Level 1 -------
    .AssignmentExpression =         [[ID] := [SingleExpression]]
    .ReturnExpression =             [return [SingleExpression]]
    // --- Level 2-4  -------   
    .BinaryOperatorExpression2 =    [[SingleExpression] [BinaryOperatorLevel2] [SingleExpression]]  {left}
    .BinaryOperatorExpression3 =    [[SingleExpression] [BinaryOperatorLevel3] [SingleExpression]]  {left}
    .BinaryOperatorExpression4 =    [[SingleExpression] [BinaryOperatorLevel4] [SingleExpression]]  {left}
    // --- Level 5 -------
    .DataMethodCallExpression =     [[SingleExpression][OnSuperClass] [ID][OptExpressionList]]
    // --- Level 6 -------
    .UnaryOperatorExpression =      [[UnaryOperator][SingleExpression]]
    .IfThenExpression = [
        if [Expression] then
            [Expression]
        fi
        ]
    .IfThenElseExpression = [
        if [Expression] then
            [Expression]
        else
            [Expression]
        fi
        ]
    .WhileExpression = [
        while [Expression] do
            [Expression]
        od
        ]
    .SwitchExpression = [
        switch [Expression] do
            [CaseExpressionList]
            [OptDefaultExpression]
        od
        ]
    // --- Level 7 -------
    .CurrentTimeExpression =        [currentTime]
    .SelfExpression =               [self]
    .ConstantExpression =           ExpressionConstant
    .NewExpression =                [new ([ID])]
    .VariableExpression =           ID
    .RoundBracketExpression =       [([Expression])]

    .BooleanConstant =            BOOL
    .CharacterConstant =          CHARACTER
    .FloatConstant =              FLOAT
    .IntegerConstant =            INT
    .NilConstant =                [nil]
    .RealConstant =               REAL
    .StringConstant =             STRING
    .EnvironmentConstant =        ENV

    OnSuperClass.OnSuperClass =                     [^]
    OnSuperClass.NotOnSuperClass =                  []

    .Expressions =                 [([{Expression ", "}*])]
    .NoExpressions =               []

    ExpressionList.ExpressionList =                 [([{Expression ", "}*])]

    CaseExpressionList.CaseExpressionList =         [[{CaseExpression "\n"}*]]
    CaseExpression.CaseExpression =
        [case [Expression] then
            [Expression]]
    OptDefaultExpression.DefaultExpression =
        [default
            [Expression]]
    OptDefaultExpression.NoDefaultExpression =      []

    // --- Operators -------
    .Minus =                           [-]
    .Not =                             [!]

    .Equal =                    [=]
    .Unequal =                  [!=]
    .Identical =                [==]
    .NotIdentical =             [!==]
    .LessThan =                 [<]
    .AtMost =                   [<=]
    .GreaterThan =              [>]
    .AtLeast =                  [>=]

    .Add =                      [+]
    .Subtract =                 [-]
    .And =                      [&]
    .Or =                       [|]

    .Multiply =                 [*]
    .Divide =                   [/]

context-free restrictions
    UnaryOperator -/- [0-9]                         // Parse -42 as Integer instead of UnaryOperation (but 42-0 should be allowed)

context-free priorities
    // If A > B, then all trees are removed that have a B node as a direct child of an A node.
    SingleStatement.ExpressionStatement <0> >
        { SingleExpression.RoundBracketExpression
          SingleExpression.IfThenExpression
          SingleExpression.IfThenElseExpression
          SingleExpression.WhileExpression
          SingleExpression.SwitchExpression},

    SingleExpression.UnaryOperatorExpression >
        SingleExpression.DataMethodCallExpression >
        SingleExpression.BinaryOperatorExpression4 >
        SingleExpression.BinaryOperatorExpression3 >
        SingleExpression.BinaryOperatorExpression2 >
        { SingleExpression.AssignmentExpression SingleExpression.ReturnExpression }

lexical syntax      // keywords
     = "if"           {reject}
     = "then"         {reject}
     = "else"         {reject}
     = "fi"           {reject}

     = "while"        {reject}
     = "do"           {reject}
     = "od"           {reject}

     = "switch"       {reject}
     = "case"         {reject}
     = "default"      {reject}

     = "par"          {reject}
     = "and"          {reject}
     = "rap"          {reject}

     = "sel"          {reject}
     = "or"           {reject}
     = "les"          {reject}

     = "abort"        {reject}
     = "interrupt"    {reject}
     = "with"         {reject}

     = "delay"        {reject}
     = "skip"         {reject}

     = "currentTime"  {reject}
     = "new"          {reject}
     = "nil"          {reject}
     = "self"         {reject}
     = "return"       {reject}