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 : "("
;
