Source-to-Source JavaScript Compiler in OMeta/JS

This page "autoexecs" the example from the OMeta/JS demo page that adds support for method declarations to the SqueakParser, then defines a multi-stage OMeta/JS compiler. To make it go, select all of the code below and press the "do it" button, then try the examples at the end of the page.

Object isString [^false].
String isString [^true].

ometa JSParser : Parser {
  fromTo :x :y ::= <seq x> (~<seq y> <char>)* <seq y>. 
  space        ::= <super #space> | <fromTo '//' '\n'> | <fromTo '/*' '*/'>.
  nameFirst    ::= <letter>        | '$' | '_'.
  nameRest     ::= <letterOrDigit> | '$' | '_'.
  iName        ::= <firstAndRest #nameFirst #nameRest>:r                                           => [r join: ''].
  name         ::= <iName>:n ?[(self isKeyword: n) not]                                            => [{#name. n}].
  keyword      ::= <iName>:k ?[self isKeyword: k]                                                  => [{k. k}].
  number       ::= <digit>+:ws ('.' <digit>* | <empty> => [{''}]):fs                               => [{#number. parseFloat value:
                                                                                                         (ws join: ''), '.',
                                                                                                         (fs join: '')}].
  escapeChar   ::= '\\' <char>:c                                                                   => ['\\', c].
  str          ::= "'" (<escapeChar> | ~"'" <char>)*:cs "'"                                        => [{#string. cs join: ''}]
                 | '"' (<escapeChar> | ~'"' <char>)*:cs '"'                                        => [{#string. cs join: ''}].
  special      ::= ( "("   | ")"   | "{"   | "}"   | "["  | "]"  | "," | ";"  | "?" | ":"
                   | "!==" | "!="  | "===" | "=="  | "="  | ">=" | ">" | "<=" | "<" | "++"
                   | "+="  | "+"   | "--"  | "-="  | "-"  | "*=" | "*" | "/=" | "/" | "%="
                   | "%"   | "&&=" | "&&"  | "||=" | "||" | "."  | "!"                    ):s      => [{s. s}].
  tok          ::= <spaces> (<name> | <keyword> | <number> | <str> | <special>).
  toks         ::= <token>*:ts <spaces> <end>                                                      => [ts].
  token :tt    ::= <tok>:t ?[(t at: 0) = tt]                                                       => [t at: 1].
  spacesNoNl   ::= (~'\n' <space>)*.

expr         ::= <orExpr>:e ( <token '?'>   <expr>:t <token ':'> <expr>:f                        => [{#condExpr. e. t. f}]
                              | <token '='>   <expr>:rhs                                           => [{#set.  e. rhs}]
                              | <token '+='>  <expr>:rhs                                           => [{#mset. e. #+.    rhs}]
                              | <token '-='>  <expr>:rhs                                           => [{#mset. e. #-.    rhs}]
                              | <token '*='>  <expr>:rhs                                           => [{#mset. e. #*.    rhs}]
                              | <token '/='>  <expr>:rhs                                           => [{#mset. e. #/.    rhs}]
                              | <token '%='>  <expr>:rhs                                           => [{#mset. e. #%.    rhs}]
                              | <token '&&='> <expr>:rhs                                           => [{#mset. e. #&&.   rhs}]
                              | <token '||='> <expr>:rhs                                           => [{#mset. e. #'||'. rhs}]
                              | <empty>                                                            => [e]
                              ).
  orExpr       ::= <orExpr>:x <token '||'> <andExpr>:y                                             => [{#binop. #'||'. x. y}]
                 | <andExpr>.
  andExpr      ::= <andExpr>:x <token '&&'> <eqExpr>:y                                             => [{#binop. #&&. x. y}]
                 | <eqExpr>.
  eqExpr       ::= <eqExpr>:x ( <token '=='>  <relExpr>:y                                          => [{#binop. #==.  x. y}]
                              | <token '!='>  <relExpr>:y                                          => [{#binop. #!=.  x. y}]
                              | <token '==='> <relExpr>:y                                          => [{#binop. #===. x. y}]
                              | <token '!=='> <relExpr>:y                                          => [{#binop. #!==. x. y}]
                              )
                 | <relExpr>.
  relExpr      ::= <relExpr>:x ( <token '>'>          <addExpr>:y                                  => [{#binop. #>.  x. y}]
                               | <token '>='>         <addExpr>:y                                  => [{#binop. #>=. x. y}]
                               | <token '<'>          <addExpr>:y                                  => [{#binop. #<.  x. y}]
                               | <token '<='>         <addExpr>:y                                  => [{#binop. #>=. x. y}]
                               | <token 'instanceof'> <addExpr>:y                                  => [{#binop. #instanceof. x. y}]
                               )
                 | <addExpr>.
  addExpr      ::= <addExpr>:x <token '+'> <mulExpr>:y                                             => [{#binop. #+. x. y}]
                 | <addExpr>:x <token '-'> <mulExpr>:y                                             => [{#binop. #-. x. y}]
                 | <mulExpr>.
  mulExpr      ::= <mulExpr>:x <token '*'> <mulExpr>:y                                             => [{#binop. #*. x. y}]
                 | <mulExpr>:x <token '/'> <mulExpr>:y                                             => [{#binop. #/. x. y}]
                 | <mulExpr>:x <token '%'> <mulExpr>:y                                             => [{#binop. #%. x. y}]
                 | <unary>.
  unary        ::= <token '-'>  <postfix>:p                                                        => [{#unop.  #-.   p}]
                 | <token '+'>  <postfix>:p                                                        => [p]
                 | <token '++'> <postfix>:p                                                        => [{#preop. #++.  p}]
                 | <token '--'> <postfix>:p                                                        => [{#preop. #--.  p}]
                 | <token '!'>  <postfix>:p                                                        => [{#unop.  #!.   p}]
                 | <postfix>.
  postfix      ::= <primExpr>:p ( <spacesNoNl> <token '++'>                                        => [{#postop. #++. p}]
                                | <spacesNoNl> <token '--'>                                        => [{#postop. #--. p}]
                                | <empty>                                                          => [p]
                                ).
  primExpr     ::= <primExpr>:p
                     ( <token '['> <expr>:i <token ']'>                                            => [{#get.  i. p}]
                     | <token '.'> <token #name>:m <token '('> <listOf #expr ','>:as <token ')'>   => [{#send. m. p} concat: as]
                     | <token '.'> <token #name>:f                                                 => [{#get.  {#string. f}. p}]
                     | <token '('> <listOf #expr ','>:as <token ')'>                               => [{#call. p} concat: as]
                     )
                 | <primExprHd>.
  primExprHd   ::= <token '('> <expr>:e <token ')'>                                                => [e]
                 | <token 'this'>                                                                  => [{#this}]
                 | <token #name>:n                                                                 => [{#get. n}]
                 | <token #number>:n                                                               => [{#number. n}]
                 | <token #string>:s                                                               => [{#string. s}]
                 | <token 'function'> <funcRest>
                 | <token 'new'> <token #name>:n <token '('> <listOf #expr ','>:as <token ')'>     => [{#new. n} concat: as]
                 | <token '['> <listOf #expr ','>:es <token ']'>                                   => [{#arr} concat: es]
                 | <json>.
  json         ::= <token '{'> <listOf #jsonBinding ','>:bs <token '}'>                            => [{#json} concat: bs].
  jsonBinding  ::= <jsonPropName>:n <token ':'> <expr>:v                                           => [{#binding. n. v}].
  jsonPropName ::= <token #name> | <token #number> | <token #string>.
  formal       ::= <spaces> <token #name>.
  funcRest     ::= <token '('> <listOf #formal ','>:fs <token ')'>
                     <token '{'> <srcElems>:body <token '}'>                                       => [{#func. fs. body}].
  sc           ::= <spacesNoNl> ('\n' | &'}' | <end>)
                 | <token ';'>.
  binding      ::= <token #name>:n ( <token '='> <expr>
                                    | <empty> => [{#get. 'undefined'}] ):v                         => [{#var. n. v}].
  block        ::= <token '{'> <srcElems>:ss <token '}'>                                           => [ss].
  stmt         ::= <block>
                 | <token 'var'> <listOf #binding ','>:bs <sc>                                     => [{#begin} concat: bs]
                 | <token 'if'> <token '('> <expr>:c <token ')'> <stmt>:t
                     ( <token 'else'> <stmt>
                     | <empty> => [{#get. 'undefined'}] ):f                                        => [{#if. c. t. f}]
                 | <token 'while'> <token '('> <expr>:c <token ')'> <stmt>:s                       => [{#while.   c. s}]
                 | <token 'do'> <stmt>:s <token 'while'> <token '('> <expr>:c <token ')'> <sc>     => [{#doWhile. s. c}]
                 | <token 'for'> <token '('> ( <token 'var'> <binding>
                                             | <expr>
                                             | <empty> => [{#get. 'undefined'}] ):i
                                 <token ';'> ( <expr>
                                             | <empty> => [{#get. 'true'}]      ):c
                                 <token ';'> ( <expr>
                                             | <empty> => [{#get. 'undefined'}] ):u
                                 <token ')'>
                       <stmt>:s                                                                    => [{#for. i. c. u. s}]
                 | <token 'for'> <token '('> ( <token 'var'> <token #name>:n
                                                            => [{#var. n. {#get. 'undefined'}}]
                                            | <expr>                                            ):v
                                <token 'in'> <expr>:e
                                <token ')'>
                       <stmt>:s                                                                    => [{#forIn. v. e. s}]
                 | <token 'switch'> <token '('> <expr>:e <token ')'> <token '{'>
                     ( <token 'case'> <expr>:c <token ':'> <srcElems>:cs => [{#case. c. cs}]
                     | <token 'default'> <token ':'> <srcElems>:cs       => [{#default. cs}] )*:cs
                     <token '}'>                                                                   => [{#switch. e} concat: cs]
                 | <token 'break'> <sc>                                                            => [{#break}]
                 | <token 'continue'> <sc>                                                         => [{#continue}]
                 | <token 'throw'> <spacesNoNl> <expr>:e <sc>                                      => [{#throw. e}]
                 | <token 'try'> <block>:t
                     <token 'catch'> <token '('> <token #name>:e <token ')'> <block>:c
                     ( <token 'finally'> <block>
                     | <empty> => [{#get. 'undefined'}] ):f                                        => [{#try. t. e. c. f}]
                 | <token 'return'> ( <expr>
                                    | <empty> => [{#get. 'undefined'}] ):e <sc>                    => [{#return. e}]
                 | <expr>:e <sc>                                                                   => [e].
  srcElem      ::= <token 'function'> <token 'name'>:n <funcRest>:f                                => [{#var. n. f}]
                 | <stmt>.
  srcElems     ::= <srcElem>*:ss                                                                   => [{#begin} concat: ss].
  iParse       ::= <srcElems>:r <spaces> <end>                                                     => [r].
}.
JSParser at: #keywords put: Object new.
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).
keywords do: [:k |
  (JSParser at: #keywords) at: k put: true
].
JSParser isKeyword: k [^ (self at: #keywords) hasProperty: k].
JSParser parse: aString [
  ^ [self matchAll: aString with: #iParse] on: Fail do: [:f | f realPos]
].

ometa Translator {
  trans    {:t ?[self hasProperty: t] <apply t>:ans} => [ans].
}.

ometa JSTranslator : Translator {
  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 printString].
  arr      <trans>*:xs                                        => ['[', (xs join: ','), ']'].
  unop     :op <trans>:x                                      => ['(', op, x, ')'].
  get      <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].
  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 at: x size - 1) = '}']
                | <end>)                      => [x]
              |                               => [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 printString, ': ', val].
  switch   <trans>:x <trans>*:cases                           => ['switch (', x, ') {', (cases join: '; '), '}'].
  case     <trans>:x <trans>:y                                => ['case ', x, ': ', y].
}.

input := '1 + 2 3'.
[JSParser parse: input with: #iParse] on: Fail do: [:f |
  (input substring: 0 : f.failPos), ' Parse error ->', (input substring: f.failPos)
].

ometa SpecialTranslator : Translator {
  trans ::= :x ?[x isArray not]                             => [x]
          | <super #trans>
          | {:x <trans>*:xs}                                => [xs addFirst: x; yourself].
}.

Object isArray [^false].
Array  isArray [^true].
Array  includes: x [
  self do: [:y | x = y ifTrue: [^true]].
  ^false
].
ometa LocalFinder : SpecialTranslator {
  go    ::= ![self at: #locals put: {}] <start> => [self.locals].
  start ::= {#func :fs <trans>}
          | <trans>.

var  :name :val                                           => [(self.locals includes: name) ifFalse: [self.locals add: name]].
  func :fs :b.
}.

ast := JSParser matchAll: 'function() { if (foo > bar) { var x, y; } else { var w } return function() { var z } }' with: #iParse.
ast := ast at: 1.
LocalFinder match: ast with: #go.

gensym := [
  | n |
  n := 0.
  ['$$gensym$$', (n := n + 1) asString]
] value.

ometa LocalRenamer : SpecialTranslator {
  init :m        ::= &<foreign LocalFinder #go>:locals
                       ![self at: #locals put: locals;
                              at: #map    put: m]
                       ![locals do: [:l |
                           self.map at: l
                                    put: gensym value]].
  go :m <init m> ::= {#func :fs <trans>:body}            => [{#func. fs. body}]
                   | <trans>.
  transName :n   ::= ?[self.map hasOwnProperty: n]       => [self.map at: n]
                   |                                     => [n].

var  <transName>:n <trans>:v                           => [{#var. n. v}].
  get  <trans>:fd <trans>:obj                            => [{#get. fd. obj}];
  get  <transName>:n                                     => [n isString
                                                               ifTrue:  [{#get. n}]
                                                               ifFalse: [n]].
  func :fs :b
    <foreign LocalFinder #go b>:ls
    ![self newStateWithLocals: ls fields: fs]:old
    <trans b>:b
    ![self at: #locals put: (old at: 0);
           at: #map    put: (old at: 1)]                 => [{#func. fs. b}].
}.
LocalRenamer newStateWithLocals: ls fields: fs [
  | old |
  old := {self.locals. self.map}.
  self at: #locals put: {};
       at: #map    put: Object new.
  (old at: 0) do: [:l |
    ((ls includes: l) or: [fs includes: l])
      ifFalse: [
        self.map at: l put: ((old at: 1) at: l).
        self.locals add: l.
      ]
  ].
  ^old
].

ast := JSParser parse: 'function(x, y) { var z; return function(y) { y+z} }' with: #iParse.
LocalRenamer match: (ast at: 1) with: #go : Object new.

ometa MJSParser : JSParser {
  name     ::= '@' <iName>:n                                                    => [{#mname. n}]
             | <super #name>.
  sc       ::= <spacesNoNl> &(')' | ',')
             | <super #sc>.
  primExpr ::= <token #mname>:n <token '('> <listOf #stmt ','>:args <token ')'> => [{#expand. n} concat: args]
             | <super #primExpr>.
  topLevel ::= <srcElem>
             | <token 'macro'> <token #mname>:n
                 <token '('> <listOf #formal ','>:fs <token ')'> <block>:body   => [macros at:  n
                                                                                           put: (Object new
                                                                                                   at: #formals put: fs;
                                                                                                   at: #body    put: body;
                                                                                                   yourself).
                                                                                    {#macro. n. fs. body}].
  iParse   ::= <topLevel>:t   <spaces> <end>                                    => [t]
             | <topLevel>*:ts <spaces> <end>                                    => [{#begin} concat: ts].
}.
MJSParser at: #keywords put: JSParser.keywords delegated.
MJSParser.keywords at: #macro put: true.
macros := Object new.

ometa MacroExpander : SpecialTranslator {
  expand :n <trans>*:args
    ![macros at: n]:m
    <foreign LocalRenamer #go (Object new) m.body>:r
    <foreign LocalRenamer #go (self mapForFormals: m.formals actuals: args) r>.
}.
MacroExpander mapForFormals: fs actuals: as [
  | m |
  m := Object new.
  0 to: fs size - 1 do: [:idx | m at: (fs at: idx) put: (as at: idx)].
  ^ m
].

ometa MJSTranslator : JSTranslator {
  transWithoutMacros ::= ![self at:  #delMacros
                                put: true]
                         <trans>.

macro :n :fs ( ?[self.delMacros] :body => ['']
               | <trans>:body            => ['macro @', n, '(', (fs join: ','), '){', body, '}']
               ).
  expand :n <trans>*:args   => ['@', n, '(', (args join: ','), ')'].
}.
MJSTranslator at: #delMacros put: false.

mjsEval := [:code |
  | tmp |
  tmp := MJSParser parse: code with: #iParse.
  tmp := MacroExpander match: tmp with: #trans.
  tmp := MJSTranslator match: tmp with: #transWithoutMacros.
  eval value: tmp
].

mjsEval value: '
  macro @repeat(k, s) {
    var n = k
    while (n--)
      s
  }

var x = 0
  @repeat(5, x++)
  alert(x)
'

Translation
Transcript