diff options
author | Martin Odersky <odersky@gmail.com> | 2013-04-30 18:02:30 +0200 |
---|---|---|
committer | Martin Odersky <odersky@gmail.com> | 2013-04-30 18:02:30 +0200 |
commit | ab39cb9f4d6451dd6e2a45e73f08db31a3cea5b3 (patch) | |
tree | f5431eac437f835020c4345abd9d187af3ac5b62 /docs/SyntaxSummary.txt | |
parent | ad80e82469b6fe298a5cbdb0beac736fc01ec5fb (diff) | |
download | dotty-ab39cb9f4d6451dd6e2a45e73f08db31a3cea5b3.tar.gz dotty-ab39cb9f4d6451dd6e2a45e73f08db31a3cea5b3.tar.bz2 dotty-ab39cb9f4d6451dd6e2a45e73f08db31a3cea5b3.zip |
Syntax summary for dotty, with indications what trees get generated.
Diffstat (limited to 'docs/SyntaxSummary.txt')
-rw-r--r-- | docs/SyntaxSummary.txt | 295 |
1 files changed, 295 insertions, 0 deletions
diff --git a/docs/SyntaxSummary.txt b/docs/SyntaxSummary.txt new file mode 100644 index 000000000..ba26e1750 --- /dev/null +++ b/docs/SyntaxSummary.txt @@ -0,0 +1,295 @@ +% $Id: SyntaxSummary.tex 21104 2010-03-08 13:49:27Z odersky $ + +\chapter{Scala Syntax Summary}\label{sec:syntax} +\todo{introduce SeqPattern syntax} + +The lexical syntax of Scala is given by the following grammar in EBNF +form. + +{\small +\begin{lstlisting} + upper ::= `A' | $\cdots$ | `Z' | `$\Dollar$' | `_' $\mbox{\rm\em and Unicode category Lu}$ + lower ::= `a' | $\cdots$ | `z' $\mbox{\rm\em and Unicode category Ll}$ + letter ::= upper | lower $\mbox{\rm\em and Unicode categories Lo, Lt, Nl}$ + digit ::= `0' | $\cdots$ | `9' + opchar ::= $\mbox{\rm\em ``all other characters in \U{0020-007F} and Unicode}$ + $\mbox{\rm\em categories Sm, So except parentheses ([{}]) and periods''}$ + + op ::= opchar {opchar} + varid ::= lower idrest + alphaid ::= upper idrest + | varid + plainid ::= alphaid + | op + id ::= plainid + | `\`' stringLit `\`' + idrest ::= {letter | digit} [`_' op] + + integerLiteral ::= (decimalNumeral | hexNumera) [`L' | `l'] + decimalNumeral ::= `0' | nonZeroDigit {digit} + hexNumeral ::= `0' `x' hexDigit {hexDigit} + digit ::= `0' | nonZeroDigit + nonZeroDigit ::= `1' | $\cdots$ | `9' + octalDigit ::= `0' | $\cdots$ | `7' + + floatingPointLiteral + ::= digit {digit} `.' {digit} [exponentPart] [floatType] + | `.' digit {digit} [exponentPart] [floatType] + | digit {digit} exponentPart [floatType] + | digit {digit} [exponentPart] floatType + exponentPart ::= (`E' | `e') [`+' | `-'] digit {digit} + floatType ::= `F' | `f' | `D' | `d' + + booleanLiteral ::= `true' | `false' + + characterLiteral ::= `\'' printableChar `\'' + | `\'' charEscapeSeq `\'' + + stringLiteral ::= `"' {stringElement} `"' + | `"""' {[`"'] [`"'] char \ `"'} {`"'} `"""' + stringElement ::= printableChar \ (`"' | `\') + | charEscapeSeq + charEscapeSeq ::= `\b' | `\n' | `\t' | `\f' | `\r' | `"' | `'' | `\\' + + processedStringLiteral + ::= alphaid`"' {printableChar \ (`"' | `$') | escape} `"' + | alphaid `"""' {[`"'] [`"'] char \ (`"' | `$') | escape} {`"'} `"""' + escape ::= `$$' \comment{$} + | `$' letter { letter | digit } + | `{' Block [`;' whiteSpace stringFormat whiteSpace] `}' + stringFormat ::= {printableChar \ (`"' | `}' | ` ' | `\t' | `\n')} + whiteSpace ::= {` ' | `\t'} + + symbolLiteral ::= `'' plainid + + comment ::= `/*' $\mbox{\rm\em ``any sequence of characters''}$ `*/' + | `//' $\mbox{\rm\em ``any sequence of characters up to end of line''}$ + + nl ::= $\mbox{\rm\em ``new line character''}$ + semi ::= `;' | nl {nl} +\end{lstlisting}} + +The context-free syntax of Scala is given by the following EBNF +grammar. + +{\small +\begin{lstlisting} + Literal ::= [`-'] integerLiteral + | [`-'] floatingPointLiteral + | booleanLiteral + | characterLiteral + | stringLiteral + | processedStringLiteral + | symbolLiteral + | `null' + + QualId ::= id {`.' id} + ids ::= id {`,' id} + + Path ::= StableId + | [id `.'] `this' + StableId ::= id + | Path `.' id + | [id '.'] `super' [ClassQualifier] `.' id + ClassQualifier ::= `[' id `]' + + Type ::= FunctionArgTypes `=>' Type Function(ts, t) + | InfixType + FunctionArgTypes ::= InfixType + | `(' [ FunArgType {`,' FunArgType } ] `)' + InfixType ::= RefinedType {id [nl] RefinedType} InfixOp(t1, op, t2) + RefinedType ::= SimpleType {Annotation | Refinement} Annotated(t, annot), RefinedTypeTree(t, ds) + SimpleType ::= SimpleType TypeArgs AppliedTypeTree(t, args) + | SimpleType `#' id SelectFromTypeTree(t, name) + | StableId + | Path `.' `type' SingletonTypeTree(p) + | `(' Types ')' Parens(ts) + TypeArgs ::= `[' Types `]' ts + Types ::= Type {`,' Type} + Refinement ::= [nl] `{' Dcl {semi Dcl} `}' ds + | + Ascription ::= `:' OrType Typed(expr, tp) + | `:' Annotation {Annotation} Typed(expr, Annotated(EmptyTree, annot)*) + FunArgType ::= Type + | `=>' Type Function(EmptyTree, t) + ParamType ::= FunArgType + | Type `*' PostfixOp(t, "*") + + Expr ::= (Bindings | [`implicit'] id | `_') `=>' Expr Function(args, expr), Function(ValDef([implicit], id, TypeTree(), EmptyTree), expr) + | Expr1 + Expr1 ::= `if' `(' Expr `)' {nl} Expr [[semi] else Expr] If(Parens(cond), thenp, elsep?) + | `if' Expr `then' Expr [[semi] else Expr] If(cond, thenp, elsep?) + | `while' `(' Expr `)' {nl} Expr WhileDo(Parens(cond), body) + | `while' Expr `do' Expr WhileDo(cond, body) + | `try' Expr Catches [`finally' Expr] Try(expr, catches, expr?) + | `try' Expr [`finally' Expr] Try(expr, Nil, expr?) + | `do' Expr [semi] `while' `(' Expr ')' DoWhile(expr, Parens(cond)) + | `do' Expr [semi] `while' Expr DoWhile(expr, cond) + | `for' (`(' Enumerators `)' | `{' Enumerators `}') ForYield(enums, expr) + {nl} [`yield'] Expr ForDo(enums, expr) + | `for' Enumerators (`do' Expr | `yield' Expr) + | `throw' Expr Throw(expr) + | `return' [Expr] Return(expr?) + | [SimpleExpr `.'] id `=' Expr Assign(expr, expr) + | SimpleExpr1 ArgumentExprs `=' Expr Assign(expr, expr) + | PostfixExpr [Ascription] + | PostfixExpr `match' `{' CaseClauses `}' Match(expr, cases) -- point on match + Catches ::= `catch' `{' CaseClauses `}' cases + PostfixExpr ::= InfixExpr [id] PostfixOp(expr, op) + InfixExpr ::= PrefixExpr + | InfixExpr id [nl] InfixExpr InfixOp(expr, op, expr) + PrefixExpr ::= [`-' | `+' | `~' | `!'] SimpleExpr PrefixOp(expr, op) + SimpleExpr ::= `new' Template New(templ) + | BlockExpr + | SimpleExpr1 [`_'] PostfixOp(expr, _) + SimpleExpr1 ::= Literal + | Path + | `_' + | `(' [Exprs] `)' Parens(exprs) + | SimpleExpr `.' id Select(expr, id) + | SimpleExpr TypeArgs TypeApply(expr, args) + | SimpleExpr1 ArgumentExprs Apply(expr, args) + | XmlExpr + Exprs ::= Expr {`,' Expr} + ArgumentExprs ::= `(' [Exprs] `)' exprs + | `(' [Exprs `,'] PostfixExpr `:' `_' `*' ')' exprs :+ Typed(expr, Ident(wildcardStar)) + | [nl] BlockExpr + BlockExpr ::= `{' CaseClauses `}' cases + | `{' Block `}' block // starts at { + Block ::= {BlockStat semi} [ResultExpr] Block(stats, expr?) + BlockStat ::= Import + | {Annotation} [`implicit' | `lazy'] Def + | {Annotation} {LocalModifier} TmplDef + | Expr1 + | + ResultExpr ::= Expr1 + | (Bindings | ([`implicit'] id | `_') `:' ) `=>' Block + Function(args, block) // block starts at => + Enumerators ::= Generator {semi Enumerator | Guard} + Enumerator ::= Generator + | Guard + | Pattern1 `=' Expr GenAlias(pat, expr) + Generator ::= Pattern1 `<-' Expr GenFrom(pat, expr) + + CaseClauses ::= CaseClause { CaseClause } + CaseClause ::= `case' Pattern [Guard] `=>' Block CaseDef(pat, guard?, block) // block starts at => + Guard ::= `if' PostfixExpr + + Pattern ::= Pattern1 { `|' Pattern1 } Alternative(pats) + Pattern1 ::= varid `:' Type Bind(name, Typed(Ident(wildcard), tpe)) + | `_' `:' Type Typed(Ident(wildcard), tpe) + | Pattern2 + Pattern2 ::= [varid `@'] InfixPattern Bind(name, pat) + InfixPattern ::= SimplePattern + | SimplePattern { id [nl] SimplePattern } InfixOp(pat, op, pat) + SimplePattern ::= `_' Ident(wildcard) + | varid Bind(name, Ident(wildcard)) + | Literal + | StableId + | StableId `(' [Patterns] `)' Apply(fn, pats) + | StableId `(' [Patterns `,'] Pattern2 `:' `_' `*' ') + | `(' [Patterns] `)' Parens(pats) + | XmlPattern + Patterns ::= Pattern [`,' Patterns] + + VarTypeParamClause::= `[' VariantTypeParam {`,' VariantTypeParam} `]' + FunTypeParamClause::= `[' TypeParam {`,' TypeParam} `]' + VariantTypeParam ::= {Annotation} [`+' | `-'] TypeParam TypeDef(Modifiers, name, tparams, bounds) + FunTypeParam ::= {Annotation} TypeParam + TypeParam ::= (id | `_') [TypeParamClause] [`>:' Type] [`<:' Type] Bound(below, above, context) + {`<%' Type} {`:' Type} + ParamClauses ::= {ParamClause} [[nl] `(' `implicit' Params `)'] + ParamClause ::= [nl] `(' [Params] ')' + Params ::= Param {`,' Param} + Param ::= {Annotation} id `:' ParamType [`=' Expr] ValDef(mods, id, tpe, expr) -- point of mods at id. + + ClassParamClauses ::= {ClassParamClause} + [[nl] `(' `implicit' ClassParams `)'] + ClassParamClause ::= [nl] `(' [ClassParams] ')' + ClassParams ::= ClassParam {`' ClassParam} + ClassParam ::= {Annotation} [{Modifier} (`val' | `var')] ValDef(mods, id, tpe, expr) -- point of mods on val/var + id `:' ParamType [`=' Expr] + Bindings ::= `(' Binding {`,' Binding `)' bindings + Binding ::= (id | `_') [`:' Type] ValDef(_, id, tpe, EmptyTree) + + Modifier ::= LocalModifier + | AccessModifier + | `override' + LocalModifier ::= `abstract' + | `final' + | `sealed' + | `implicit' + | `lazy' + AccessModifier ::= (`private' | `protected') [AccessQualifier] + AccessQualifier ::= `[' (id | `this') `]' + + Annotation ::= `@' SimpleType {ArgumentExprs} + ConstrAnnotation ::= `@' SimpleType ArgumentExprs Apply(tpe, args) + + TemplateBody ::= [nl] `{' [SelfType] TemplateStat {semi TemplateStat} `} (self, stats) + TemplateStat ::= Import + | {Annotation [nl]} {Modifier} Def + | {Annotation [nl]} {Modifier} Dcl + | Expr + | + SelfType ::= id [`:' Type] `=>' ValDef(_, name, tpt, _) + | `this' `:' Type `=>' + + Import ::= `import' ImportExpr {`,' ImportExpr} + ImportExpr ::= StableId `.' (id | `_' | ImportSelectors) Import(expr, sels) + ImportSelectors ::= `{' {ImportSelector `,'} (ImportSelector | `_') `}' + ImportSelector ::= id [`=>' id | `=>' `_'] Ident(name), Pair(id, id) + + Dcl ::= `val' ValDcl + | `var' VarDcl + | `def' FunDcl + | `type' {nl} TypeDcl + + ValDcl ::= ids `:' Type PatDef(_, ids, tpe, EmptyTree) + VarDcl ::= ids `:' Type PatDef(_, ids, tpe, EmptyTree) + FunDcl ::= FunSig [`:' Type] DefDef(_, name, tparams, vparamss, tpe, EmptyTree) + FunSig ::= id [FunTypeParamClause] ParamClauses + TypeDcl ::= id [TypeParamClause] ['=' Type] TypeDefTree(_, name, tparams, tpt) + ([`>:' Type] [`<:' Type] | ['=' Type]) TypeDefTree(_, name, tparams, bounds) + + Def ::= `val' PatDef + | `var' VarDef + | `def' FunDef + | `type' {nl} TypeDef + | TmplDef + PatDef ::= Pattern2 {`,' Pattern2} [`:' Type] `=' Expr PatDef(_, pats, tpe?, expr) + VarDef ::= PatDef + | ids `:' Type `=' `_' + FunDef ::= FunSig [`:' Type] `=' Expr DefDef(_, name, tparams, vparamss, tpe, expr) + | FunSig [nl] `{' Block `}' DefDef(_, name, tparams, vparamss, tpe, Block) + | `this' ParamClause ParamClauses DefDef(_, <init>, Nil, vparamss, EmptyTree, expr | Block) + (`=' ConstrExpr | [nl] ConstrBlock) + + TmplDef ::= ([`case'] `class' | `trait') ClassDef + | [`case'] `object' ObjectDef + ClassDef ::= id [TypeParamClause] ClassDef(mods, name, tparams, templ) // + with DefDef(_, <init>, Nil, vparamss, EmptyTree, EmptyTree) as first stat + {ConstrAnnotation} [AccessModifier] + ClassParamClauses [`extends' Template] + ObjectDef ::= id [`extends' Template] ModuleDef(mods, name, template) // no constructor + Template ::= ConstrApps [TemplateBody] | TemplateBody Template(constrs, self, stats) + ConstrApps ::= ConstrApp {`with' ConstrApp} + ConstrApp ::= RefinedType {ArgumentExprs} Apply(tp, args) + + ConstrExpr ::= SelfInvocation + | ConstrBlock + ConstrBlock ::= `{' SelfInvocation {semi BlockStat} `}' + SelfInvocation ::= `this' ArgumentExprs {ArgumentExprs} + + TopStatSeq ::= TopStat {semi TopStat} + TopStat ::= {Annotation [nl]} {Modifier} TmplDef + | Import + | Packaging + | PackageObject + | + Packaging ::= `package' QualId [nl] `{' TopStatSeq `}' Package(qid, stats) + PackageObject ::= `package' `object' ObjectDef object with package in mods. + + CompilationUnit ::= {`package' QualId semi} TopStatSeq Package(qid, stats) +\end{lstlisting} +} |