Package cminor; Helpers all = [0 .. 0xffff]; digit = ['0' .. '9']; alpha = (['A'..'Z']|['a'..'z']); tab = 9; cr = 13; lf = 10; eol = cr lf | cr | lf; opsymbol = ('.'|'+'|'-'|'*'|'/'|'%'|'='|'!'|'<'|'>'|':'|'?'|'$'|'&'|'^'); escape_sequence = '\b' | '\t' | '\n' | '\f' | '\r' | '\"' | '\' ''' | '\\' ; string_character = [all - ['"' + '\']] | escape_sequence; not_cr_lf = [all - [10 + 13]]; not_star = [all - '*']; not_star_slash = [not_star - '/']; line_comment = '//' not_cr_lf*; long_comment = '/*' not_star* '*'+ (not_star_slash not_star* '*'+)* '/'; blank = (';'|' ' | tab | cr | lf)+; ignored_helper = (blank | line_comment | long_comment)+; Tokens ignored = ignored_helper; underscore='_'; colon = ':'; lpar= '('; rpar = ')'; lbrace = '{'; rbrace = '}'; llbrack = '[['; rrbrack = ']]'; lbrack = '['; rbrack = ']'; semi = ';'; comma = ','; blank = blank; number = digit+; operator = opsymbol+; while_t = 'while'; if_t = 'if'; else_t = 'else'; switch_t = 'switch'; case_t = 'case'; module_t = 'module'; class_t = 'class'; function = 'function'; return = 'return'; extends = 'extends'; val = 'val'; var = 'var'; ident = alpha (digit|alpha|'_')*; stringliteral = '"' string_character* '"'; Ignored Tokens ignored; Productions grammar{->module} = module_t ident lbrace topleveldefs rbrace {-> New module(ident,[topleveldefs.def])} ; topleveldefs{-> def*} = {list} topleveldefs def {-> [topleveldefs.def, def.def] } |{single} def {-> [def.def] } ; def{-> def} = {class} classdef {-> classdef.def} |{function}fundef {-> fundef.def} |{val}valdef {-> valdef.def} |{var}vardef {-> vardef.def} ; classdef{-> def} = class_t ident formaltypeparams? constructorparams? extendsclause? lbrace topleveldefs? rbrace {-> New def.class(ident,[formaltypeparams.ident] ,[constructorparams.paramdef] ,extendsclause.constrcall ,[topleveldefs.def]) } ; constructorparams {-> paramdef*} = lpar formalparams rpar {-> [formalparams.paramdef]} ; extendsclause {-> constrcall}= extends type params? {-> New constrcall(type,params)} ; fundef{-> def} = function ident lpar formalparams? rpar colon type functionbody? {-> New def.function (ident,[formalparams.paramdef],type,functionbody.exprlist) } ; functionbody {-> exprlist}= lbrace exprs rbrace {-> exprs.exprlist} ; valdef{->def} = val ident colon type {-> New def.val(ident,type)} ; vardef{->def} = var ident colon type {-> New def.var(ident,type)} ; typeparams {-> type*} = lbrack typeparams2 rbrack {-> [typeparams2.type]} ; typeparams2 {-> type*} = {list} typeparams2 comma type {->[typeparams2.type,type.type]} |{single} type {->[type.type]} ; formalparams {-> paramdef*} = {list} formalparams comma paramdef {->[formalparams.paramdef,paramdef.paramdef]} |{single} paramdef {->[paramdef.paramdef]} ; paramdef {-> paramdef} = ident colon type {-> New paramdef(ident,type)} ; formaltypeparams {-> ident*} = lbrack formaltypeparams2 rbrack {-> [formaltypeparams2.ident]} ; formaltypeparams2 {-> ident*} = {list} formaltypeparams2 comma ident {->[formaltypeparams2.ident,ident]} |{single} ident {->[ident]} ; type {-> type} = {type} ident typeparams? {-> New type(ident,[typeparams.type])} ; exprs {-> exprlist}= exprsaslist {->New exprlist([exprsaslist.expr])} ; exprsaslist {-> expr*}= {list} exprsaslist expr {->[exprsaslist.expr,expr.expr]} |{single} expr {->[expr.expr]} ; expr {-> expr}= {funcall} funcall {-> funcall.expr} |{localdef} def {-> New expr.localdef(def)} |{operator} operator expr {-> New expr.operator(operator,expr)} |{intliteral} number {-> New expr.intliteral(number)} |{stringliteral} stringliteral {-> New expr.stringliteral(stringliteral)} |{whileex} whileex {-> whileex.expr} |{ifex} ifex {-> ifex.expr} |{switch} switch {-> switch.expr} |{vardef} localvardef {-> localvardef.expr} |{listliteral}listliteral {-> listliteral.expr} ; localvardef {-> expr}= var ident {-> New expr.vardef(Null,ident)} ; funcall {-> expr} = ident params? {-> New expr.funcall(ident,params)} ; params {-> params} = lpar params2? rpar {-> New params([params2.param]) } ; params2 {-> param*} = {list} params2 comma param {->[params2.param,param.param]} |{single} param {->[param.param]} ; param {->param}= exprs {-> New param(exprs.exprlist)} ; ifex {->expr}= if_t lpar exprs rpar alt_tr alt_fa {->New expr.ifex(exprs.exprlist,alt_tr.exprlist,alt_fa.exprlist)} ; whileex {->expr}= while_t lpar exprs rpar alt_tr {->New expr.whileex(exprs.exprlist,alt_tr.exprlist)} ; alt_tr {->exprlist}= lbrace exprs rbrace {->exprs.exprlist} ; alt_fa {->exprlist}= else_t lbrace exprs rbrace {->exprs.exprlist} ; switch {->expr}= switch_t lpar exprs rpar lbrace cases rbrace {->New expr.switch(exprs.exprlist,[cases.casealt])} ; cases {-> casealt*}= {list} cases case {->[cases.casealt,case.casealt]} |{single} case {->[case.casealt]} ; case {-> casealt}= case_t pattern colon exprs {-> New casealt(pattern,exprs.exprlist)} ; pattern{-> pattern}= {widecard} underscore {->New pattern.widecard()} |{constructorpattern}ident patternargs? {->New pattern.constructorpattern(ident,patternargs)} ; patternargs{->patternargs}= lpar patargs? rpar {-> New patternargs([patargs.pattern])}; patargs{->pattern*}= {list} patargs comma pattern {->[patargs.pattern,pattern.pattern]} |{single} pattern {->[pattern.pattern]} ; listliteral{->expr}= llbrack elements rrbrack {->New expr.listliteral([elements.exprlist])}; elements {->exprlist*}= {xs} elements comma exprs {->[elements.exprlist,exprs.exprlist]} |{x} exprs {->[exprs.exprlist]} ; ///////////////////////////////////////////////////////////////// Abstract Syntax Tree module = [name]:ident [definitions]: def+ ; def = {class} [name]:ident [tps]:ident* [params]:paramdef* [super]:constrcall? [defs]:def* |{function} [name]:ident [params]:paramdef* [result]:type [body]:exprlist? |{val} [name]:ident [type]:type |{var} [name]:ident [type]:type ; paramdef = [name]:ident [type]:type; type = [name]:ident [params]:type+; exprlist = expr*; expr = {funcall} [name]:ident [params]:params? |{assignment} [lhs]:expr [rhs]:expr |{oofeature} [lhs]:expr [inclass]:type? [rhs]:expr |{localdef} [def]:def |{operator} [op]:operator[rhs]:expr |{binoperator}[lhs]:expr [op]:operator[rhs]:expr |{intliteral} [value]:number |{stringliteral} [value]:stringliteral |{listliteral} [elements]:exprlist* |{ifex} [cond]:exprlist [alttrue]:exprlist [altfalse]:exprlist |{whileex} [cond]:exprlist [body]:exprlist |{switch} [expr]:exprlist [alts]:casealt* |{vardef} [typ]:type?[name]:ident |{label} ident |{jump} ident |{condjump} [var]:ident [label]: ident ; constrcall =[name]:type [params]:params? ; param = [expr]:exprlist; params = [params]:param*; casealt = [pat]:pattern [rhs]:exprlist; pattern= {widecard} |{constructorpattern} [name]:ident [args]:patternargs? ; patternargs= [args]:pattern*;