You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
211 lines
16 KiB
211 lines
16 KiB
ometa BSJSParser <: Parser { |
|
fromTo :x :y = seq(x) (~seq(y) char)* seq(y), |
|
space = ^space | fromTo('//', '\n') | fromTo('/*', '*/'), |
|
nameFirst = letter | '$' | '_', |
|
nameRest = nameFirst | digit, |
|
iName = firstAndRest(#nameFirst, #nameRest):r -> r.join(''), |
|
isKeyword :x = ?BSJSParser._isKeyword(x), |
|
name = iName:n ~isKeyword(n) -> [#name, n=='self' ? '$elf' : n], |
|
keyword = iName:k isKeyword(k) -> [k, k], |
|
hexDigit = char:x {this.hexDigits.indexOf(x.toLowerCase())}:v ?(v >= 0) -> v, |
|
hexLit = hexLit:n hexDigit:d -> (n * 16 + d) |
|
| hexDigit, |
|
number = ``0x'' hexLit:n -> [#number, n] |
|
| digit+:ws ('.' digit+ | empty -> []):fs -> [#number, parseFloat(ws.join('') + '.' + |
|
fs.join(''))], |
|
escapeChar = '\\' char:c -> unescape('\\' + c), |
|
str = seq('"""') (escapeChar | ~seq('"""') char)*:cs seq('"""') -> [#string, cs.join('')] |
|
| '\'' (escapeChar | ~'\'' char)*:cs '\'' -> [#string, cs.join('')] |
|
| '"' (escapeChar | ~'"' char)*:cs '"' -> [#string, cs.join('')] |
|
| ('#' | '`') iName:n -> [#string, n], |
|
special = ( '(' | ')' | '{' | '}' | '[' | ']' | ',' |
|
| ';' | '?' | ':' | ``!=='' | ``!='' | ``==='' | ``=='' |
|
| ``='' | ``>='' | '>' | ``<='' | '<' | ``++'' | ``+='' |
|
| '+' | ``--'' | ``-='' | '-' | ``*='' | '*' | ``/='' |
|
| '/' | ``%='' | '%' | ``&&='' | ``&&'' | ``||='' | ``||'' |
|
| '.' | '!' ):s -> [s, s], |
|
tok = spaces (name | keyword | number | str | special), |
|
toks = token*:ts spaces end -> ts, |
|
token :tt = tok:t ?(t[0] == tt) -> t[1], |
|
spacesNoNl = (~'\n' space)*, |
|
|
|
expr = orExpr:e ( "?" expr:t ":" expr:f -> [#condExpr, e, t, f] |
|
| "=" expr:rhs -> [#set, e, rhs] |
|
| "+=" expr:rhs -> [#mset, e, "+", rhs] |
|
| "-=" expr:rhs -> [#mset, e, "-", rhs] |
|
| "*=" expr:rhs -> [#mset, e, "*", rhs] |
|
| "/=" expr:rhs -> [#mset, e, "/", rhs] |
|
| "%=" expr:rhs -> [#mset, e, "%", rhs] |
|
| "&&=" expr:rhs -> [#mset, e, "&&", rhs] |
|
| "||=" expr:rhs -> [#mset, e, "||", rhs] |
|
| empty -> e |
|
), |
|
orExpr = orExpr:x "||" andExpr:y -> [#binop, "||", x, y] |
|
| andExpr, |
|
andExpr = andExpr:x "&&" eqExpr:y -> [#binop, "&&", x, y] |
|
| eqExpr, |
|
eqExpr = eqExpr:x ( "==" relExpr:y -> [#binop, "==", x, y] |
|
| "!=" relExpr:y -> [#binop, "!=", x, y] |
|
| "===" relExpr:y -> [#binop, "===", x, y] |
|
| "!==" relExpr:y -> [#binop, "!==", x, y] |
|
) |
|
| relExpr, |
|
relExpr = relExpr:x ( ">" addExpr:y -> [#binop, ">", x, y] |
|
| ">=" addExpr:y -> [#binop, ">=", x, y] |
|
| "<" addExpr:y -> [#binop, "<", x, y] |
|
| "<=" addExpr:y -> [#binop, "<=", x, y] |
|
| "instanceof" addExpr:y -> [#binop, "instanceof", x, y] |
|
) |
|
| addExpr, |
|
addExpr = addExpr:x "+" mulExpr:y -> [#binop, "+", x, y] |
|
| addExpr:x "-" mulExpr:y -> [#binop, "-", x, y] |
|
| mulExpr, |
|
mulExpr = mulExpr:x "*" unary:y -> [#binop, "*", x, y] |
|
| mulExpr:x "/" unary:y -> [#binop, "/", x, y] |
|
| mulExpr:x "%" unary:y -> [#binop, "%", x, y] |
|
| unary, |
|
unary = "-" postfix:p -> [#unop, "-", p] |
|
| "+" postfix:p -> [#unop, "+", p] |
|
| "++" postfix:p -> [#preop, "++", p] |
|
| "--" postfix:p -> [#preop, "--", p] |
|
| "!" unary:p -> [#unop, "!", p] |
|
| "void" unary:p -> [#unop, "void", p] |
|
| "delete" unary:p -> [#unop, "delete", p] |
|
| "typeof" unary:p -> [#unop, "typeof", p] |
|
| postfix, |
|
postfix = primExpr:p ( spacesNoNl "++" -> [#postop, "++", p] |
|
| spacesNoNl "--" -> [#postop, "--", p] |
|
| empty -> p |
|
), |
|
primExpr = primExpr:p ( "[" expr:i "]" -> [#getp, i, p] |
|
| "." "name":m "(" listOf(#expr, ','):as ")" -> [#send, m, p].concat(as) |
|
| "." "name":f -> [#getp, [#string, f], p] |
|
| "(" listOf(#expr, ','):as ")" -> [#call, p].concat(as) |
|
) |
|
| primExprHd, |
|
primExprHd = "(" expr:e ")" -> e |
|
| "this" -> [#this] |
|
| "name":n -> [#get, n] |
|
| "number":n -> [#number, n] |
|
| "string":s -> [#string, s] |
|
| "function" funcRest |
|
| "new" "name":n "(" listOf(#expr, ','):as ")" -> [#new, n].concat(as) |
|
| "[" listOf(#expr, ','):es "]" -> [#arr].concat(es) |
|
| json, |
|
json = "{" listOf(#jsonBinding, ','):bs "}" -> [#json].concat(bs), |
|
jsonBinding = jsonPropName:n ":" expr:v -> [#binding, n, v], |
|
jsonPropName = "name" | "number" | "string", |
|
formal = spaces "name", |
|
funcRest = "(" listOf(#formal, ','):fs ")" "{" srcElems:body "}" -> [#func, fs, body], |
|
sc = spacesNoNl ('\n' | &'}' | end) |
|
| ";", |
|
binding = "name":n ( "=" expr |
|
| empty -> [#get, 'undefined'] ):v -> [#var, n, v], |
|
block = "{" srcElems:ss "}" -> ss, |
|
stmt = block |
|
| "var" listOf(#binding, ','):bs sc -> [#begin].concat(bs) |
|
| "if" "(" expr:c ")" stmt:t ( "else" stmt |
|
| empty -> [#get, 'undefined'] ):f -> [#if, c, t, f] |
|
| "while" "(" expr:c ")" stmt:s -> [#while, c, s] |
|
| "do" stmt:s "while" "(" expr:c ")" sc -> [#doWhile, s, c] |
|
| "for" "(" ( "var" binding |
|
| expr |
|
| empty -> [#get, 'undefined'] ):i |
|
";" ( expr |
|
| empty -> [#get, 'true'] ):c |
|
";" ( expr |
|
| empty -> [#get, 'undefined'] ):u |
|
")" stmt:s -> [#for, i, c, u, s] |
|
| "for" "(" ( "var" "name":n -> [#var, n, [#get, 'undefined']] |
|
| expr ):v |
|
"in" expr:e |
|
")" stmt:s -> [#forIn, v, e, s] |
|
| "switch" "(" expr:e ")" "{" |
|
( "case" expr:c ":" srcElems:cs -> [#case, c, cs] |
|
| "default" ":" srcElems:cs -> [#default, cs] )*:cs |
|
"}" -> [#switch, e].concat(cs) |
|
| "break" sc -> [#break] |
|
| "continue" sc -> [#continue] |
|
| "throw" spacesNoNl expr:e sc -> [#throw, e] |
|
| "try" block:t "catch" "(" "name":e ")" block:c |
|
( "finally" block |
|
| empty -> [#get, 'undefined'] ):f -> [#try, t, e, c, f] |
|
| "return" ( expr |
|
| empty -> [#get, 'undefined'] ):e sc -> [#return, e] |
|
| "with" "(" expr:x ")" stmt:s -> [#with, x, s] |
|
| expr:e sc -> e |
|
| ";" -> [#get, "undefined"], |
|
srcElem = "function" "name":n funcRest:f -> [#var, n, f] |
|
| stmt, |
|
srcElems = srcElem*:ss -> [#begin].concat(ss), |
|
|
|
topLevel = srcElems:r spaces end -> r |
|
} |
|
BSJSParser.hexDigits = "0123456789abcdef" |
|
BSJSParser.keywords = { } |
|
keywords = ["break", "case", "catch", "continue", "default", "delete", "do", "else", "finally", "for", "function", "if", "in", |
|
"instanceof", "new", "return", "switch", "this", "throw", "try", "typeof", "var", "void", "while", "with", "ometa"] |
|
for (var idx = 0; idx < keywords.length; idx++) |
|
BSJSParser.keywords[keywords[idx]] = true |
|
BSJSParser._isKeyword = function(k) { return this.keywords.hasOwnProperty(k) } |
|
|
|
|
|
ometa BSSemActionParser <: BSJSParser { |
|
curlySemAction = "{" expr:r sc "}" spaces -> r |
|
| "{" (srcElem:s &srcElem -> s)*:ss |
|
( expr:r sc -> [#return, r] | srcElem):s {ss.push(s)} |
|
"}" spaces -> [#send, #call, |
|
[#func, [], [#begin].concat(ss)], |
|
[#this]], |
|
semAction = curlySemAction |
|
| primExpr:r spaces -> r |
|
} |
|
|
|
ometa BSJSTranslator { |
|
trans = [:t apply(t):ans] -> ans, |
|
curlyTrans = [#begin curlyTrans:r] -> r |
|
| [#begin trans*:rs] -> ('{' + rs.join(';') + '}') |
|
| trans:r -> ('{' + r + '}'), |
|
|
|
this -> 'this', |
|
break -> 'break', |
|
continue -> 'continue', |
|
number :n -> ('(' + n + ')'), |
|
string :s -> s.toProgramString(), |
|
arr trans*:xs -> ('[' + xs.join(',') + ']'), |
|
unop :op trans:x -> ('(' + op + ' ' + x + ')'), |
|
getp trans:fd trans:x -> (x + '[' + fd + ']'), |
|
get :x -> x, |
|
set trans:lhs trans:rhs -> ('(' + lhs + '=' + rhs + ')'), |
|
mset trans:lhs :op trans:rhs -> ('(' + lhs + op + '=' + rhs + ')'), |
|
binop :op trans:x trans:y -> ('(' + x + ' ' + op + ' ' + y + ')'), |
|
preop :op trans:x -> (op + x), |
|
postop :op trans:x -> (x + op), |
|
return trans:x -> ('return ' + x), |
|
with trans:x curlyTrans:s -> ('with(' + x + ')' + s), |
|
if trans:cond curlyTrans:t curlyTrans:e -> ('if(' + cond + ')' + t + 'else' + e), |
|
condExpr trans:cond trans:t trans:e -> ('(' + cond + '?' + t + ':' + e + ')'), |
|
while trans:cond curlyTrans:body -> ('while(' + cond + ')' + body), |
|
doWhile curlyTrans:body trans:cond -> ('do' + body + 'while(' + cond + ')'), |
|
for trans:init trans:cond trans:upd |
|
curlyTrans:body -> ('for(' + init + ';' + cond + ';' + upd + ')' + body), |
|
forIn trans:x trans:arr curlyTrans:body -> ('for(' + x + ' in ' + arr + ')' + body), |
|
begin trans:x end -> x, |
|
begin (trans:x |
|
( (?(x[x.length - 1] == '}') | end) -> x |
|
| empty -> (x + ';') |
|
) |
|
)*:xs -> ('{' + xs.join('') + '}'), |
|
func :args curlyTrans:body -> ('(function (' + args.join(',') + ')' + body + ')'), |
|
call trans:fn trans*:args -> (fn + '(' + args.join(',') + ')'), |
|
send :msg trans:recv trans*:args -> (recv + '.' + msg + '(' + args.join(',') + ')'), |
|
new :cls trans*:args -> ('new ' + cls + '(' + args.join(',') + ')'), |
|
var :name trans:val -> ('var ' + name + '=' + val), |
|
throw trans:x -> ('throw ' + x), |
|
try curlyTrans:x :name curlyTrans:c curlyTrans:f -> ('try ' + x + 'catch(' + name + ')' + c + 'finally' + f), |
|
json trans*:props -> ('({' + props.join(',') + '})'), |
|
binding :name trans:val -> (name.toProgramString() + ': ' + val), |
|
switch trans:x trans*:cases -> ('switch(' + x + '){' + cases.join(';') + '}'), |
|
case trans:x trans:y -> ('case ' + x + ': '+ y), |
|
default trans:y -> ('default: ' + y) |
|
}
|
|
|