Fuzion Logo
flang.dev — The Fuzion Language Portal
JavaScript seems to be disabled. Functionality is limited.

fuzion.ebnf


unit        : feature semi EOF
            ;
stmntsEof   : stmnts EOF
            ;
semiOrFlatLF: semi
            | LF
            ;
semi        : SEMI semi
            |
            ;
feature     : routine
            | field
            ;
routine     : visibility
              modifiers
              featNames
              formGens
              formArgs
              returnType
              inherits
              contract
              implRout
            ;
field       : visibility
              modifiers
              featNames
              returnType
              contract
              implFldOrRout
            ;
visibility  : visiFlag
            |
            ;
visiFlag    : "export" visiList
            | "private"
            | "protected"
            | "public"
            ;
visiList    : e=visi ( COMMA visiList
                     |
                     )
            ;
qual        : name ( dot qual
                   |
                   )
            ;
name        : IDENT
            | opName
            | "ternary" QUESTION COLON
            | "index" LBRACKET ( ".." RBRACKET
                               | RBRACKET
                               )
            | "set" ( LBRACKET RBRACKET
                    | IDENT
                    )
            ;
opName      : "infix"   op
            | "prefix"  op
            | "postfix" op
            ;
modifiers   : modifier modifiers
            |
            ;
modifier    : "lazy"
            | "synchronized"
            | "redef"
            | "redefine"
            | "const"
            | "leaf"
            ;
featNames   : qual (COMMA featNames
                   |
                   )
            ;
formGens    : "<" formGensBody ">"
            | "<" ">"
            |
            ;
formGensBody: l=genericList ( "..."
                            |
                            )
            |
            ;
genericList : e=generic  ( COMMA genericList
                         |
                         )
            ;
generic     : IDENT
              ( COLON type
              |
              )
            ;
formArgs    : LPAREN argLst RPAREN
            |
            ;
argLst      : argList
            |
            ;
argList     : argument ( COMMA argList
                       |
                       )
            ;
argument    : visibility
              modifiers
              argNames
              type
              contract
            ;
argNames    : name ( COMMA argNames
                   |
                   )
            ;
returnType  : type
            | "value"
            | "ref"
            |
            ;
inherits    : inherit
            |
            ;
inherit     : COLON callList
            ;
callList    : call ( COMMA callList
                   |
                   )
            ;
call        : name ( actualGens actualArgs callTail
                   | dot ( NUM_LITERAL callTail
                         | call
                   )
            ;
indexCall   : ( LBRACKET exprList RBRACKET
                ( ":=" exprInLine
                |
                )
              )+
            ;
callTail    : ( indexCall
              |
              )
              ( dot call
              |
              )
            ;
actualGens  : "<" typeList ">"
            | "<" ">"
            |
            ;
typeList    : type ( COMMA typeList
                   |
                   )
            ;
actualArgs  : actualsList
            | LPAREN exprLst RPAREN
            | LPAREN RPAREN
            ;
exprList    : expr ( COMMA exprList
                   |
                   )
            ;
actualsList : exprUntilSp actualsLst
            | exprUntilSp actualsLstC
            |
            ;
actualsLst  : exprUntilSp actualsLst
            |
            ;
actualsLstC : COMMA expr actualsLstC
            |
            ;
bracketTerm : block
            | klammer
            | initArray
            ;
exprUntilSp : expr         # no white space except enclosed in { }, [ ], or ( ).
            ;
exprInLine  : expr             # within one line
            | bracketTerm      # stretching over one or several lines
            ;
expr        : opExpr
              ( QUESTION expr  COLON expr
              | QUESTION cases
              |
              )
            ;
opExpr      : ( op
              )*
              opTail
            ;
opTail      : term
              ( ( op )+
                ( opTail
                |
                )
              |
              )
            ;
klammer     : klammerexpr
            | tuple
            ;
klammerexpr : LPAREN expr RPAREN
            ;
tuple       : LPAREN RPAREN
            | LPAREN expr (COMMA expr)+ RPAREN
            ;
initArray   : LBRACKET expr (COMMA expr)+ RBRACKET
            | LBRACKET expr (SEMI  expr)+ RBRACKET
            ;
term        : simpleterm ( indexCall
                         |
                         )           ( dot call
                                     |
                                     )
            ;
simpleterm  : bracketTerm
            | fun
            | string
            | NUM_LITERAL
            | "old" term
            | match
            | loop
            | ifstmnt
            | callOrFeatOrThis
            ;
stringTerm  : STRING
            | STRING$ ident stringTerm
            | STRING{ expr  stringTerm
            ;
op          : OPERATOR
            ;
fun         : "fun" function
            | "fun" c=call
            ;
function    : formArgs
              ( type | )
              inherits
              contract
              ( block
              | "is" block
              | ARROW e=block
              )
            ;
match       : "match" exprInLine BRACEL cases BRACER
            ;
cases       : caze maybecomma ( '|' casesBars   // NYI: grammar not correct yet.
                              |     casesNoBars
                              )
            ;
casesBars   : caze maybecomma ( '|' casesBars
                              |
                              )
            ;
caseNoBars  : caze maybecomma ( casesNoBars
                              |
                              )
            ;
maybecomma  : comma
            |
            ;
caze        : ( caseFldDcl
              | caseTypes
              | caseStar
              )
            ;
caseFldDcl  : IDENT type caseBlock
            ;
caseTypes   : typeList   caseBlock
            ;
caseStar    : STAR       caseBlock
            ;
caseBlock   : ARROW          -- if followed by '|'
            | ARROW block    -- if block does not start with '|'
            ;
block       : BRACEL stmnts BRACER
            ;
stmnts      :
            | s=stmnt semiOrFlatLF l=stmnts (semiOrFlatLF | )
            ;
stmnt       : feature
            | assign
            | destructure
            | exprInLine
            | checkstmt
            ;
loop        : loopProlog loopBody loopEpilog
            |            loopBody loopEpilog
            | loopProlog loopBody
            |            loopBody
            | loopProlog          loopEpilog
            ;
loopProlog  : "for" indexVars "variant" exprInLine
            | "for" indexVars
            |                 "variant" exprInLine
            ;
loopBody    : "while" exprAtMinIndent      block
            | "while" exprAtMinIndent "do" block
            |                         "do" block
            ;
loopEpilog  : "until" exprAtMinIndent thenPart elseBlockOpt
            |                                  elseBlock
            ;
indexVars   : indexVar (semi indexVars)
            |
            ;
indexVar    : visibility
              modifiers
              name
              ( type contract implFldInit nextValue
              |      contract implFldInit nextValue
              | type contract implFldIter
              |      contract implFldIter
              )
            ;
implFldIter : "in" exprInLine
nextValue   : COMMA exprAtMinIndent
            |
            ;
cond        : exprInLine
            ;
ifstmt      : "if" exprInLine thenPart elseBlockOpt
            ;
thenPart    : "then" block
            |        block
            ;
elseBlockOpt: elseBLock
            |
            ;
elseBlock   : "else" ( ifstmt
                     | block
                     )
            ;
checkstmt   : "check" cond
            ;
assign      : "set" name ":=" exprInLine
            ;
destructure : destructr
            | destructrDcl
            | destructrSet
            | destructrOld
            | destructrDclOld
            ;
destructr   : "(" argNames ")"       ":=" exprInLine
destructrDcl: formArgs               ":=" exprInLine
destructrSet: "set" "(" argNames ")" ":=" exprInLine
            ;
anonymous   : returnType
              inherit
              contract
              block
            ;
qualThis    : name ( dot name )* dot "this"
            ;
contract    : require
              ensure
              invariant
            ;
require     : "pre" condList
            |
            ;
ensure      : "post" condList
            |
            ;
invariant   : "inv" condList
            |
            ;
condList    : cond ( COMMA condList
                   |
                   )
              semi
            ;
implRout    : block
            | "is" "abstract"
            | "is" "intrinsic"
            | "is" block
            | ARROW e=block
            ;
impl        : implRout
            | implFldInit
            | implFldUndef
            |
            ;
implFldInit : ":=" exprAtMinIndent
            ;
implFldUndef: ":=" "?"
            ;
type        : onetype ( PIPE onetype ) *
            ;
onetype     : "ref" simpletype
            | "fun" funTypeArgs ( type
                                |
                                )
            | t=simpletype
            ;
funTypeArgs : LPAREN a=typeList RPAREN
            |
            ;
simpletype  : name actualGens
              ( dot simpletype
              |
              )
            ;
comma       : COMMA
            ;
colon       : ":"
            ;
dot         : "."
            ;
LPAREN      : "("
            ;