SxsnPC/node_modules/ometa/bs-ometa-compiler.txt

ometa BSOMetaParser <: Parser {
  fromTo :x :y   = seq(x) (~seq(y) char)* seq(y), 
  space          = ^space | fromTo('//', '\n') | fromTo('/*', '*/'),
  nameFirst      = '_' | '$' | letter,
  nameRest       = nameFirst | digit,
  tsName         = firstAndRest(#nameFirst, #nameRest):xs              -> xs.join(''),
  name           = spaces tsName,
  eChar          = '\\' char:c                                         -> unescape('\\' +c)
                 | char,
  tsString       = '\'' (~'\'' eChar)*:xs '\''                         -> xs.join(''),
  characters     = '`' '`' (~('\'' '\'') eChar)*:xs '\'' '\''          -> [#App, #seq,     xs.join('').toProgramString()],
  sCharacters    = '"'     (~'"'         eChar)*:xs '"'                -> [#App, #token,   xs.join('').toProgramString()],
  string         = (('#' | '`') tsName | tsString):xs                  -> [#App, #exactly, xs.toProgramString()],
  number         = ('-' | empty -> ''):sign digit+:ds                  -> [#App, #exactly, sign + ds.join('')],
  keyword :xs    = token(xs) ~letterOrDigit                            -> xs,
  args           = '(' listOf(#hostExpr, ','):xs ")"                   -> xs
                 | empty                                               -> [],
  application    = "^"          name:rule args:as                      -> [#App, "super",        "'" + rule + "'"].concat(as)
                 | name:grm "." name:rule args:as                      -> [#App, "foreign", grm, "'" + rule + "'"].concat(as)
                 |              name:rule args:as                      -> [#App, rule].concat(as),
  hostExpr       = BSSemActionParser.expr:r                               BSJSTranslator.trans(r),
  curlyHostExpr  = BSSemActionParser.curlySemAction:r                     BSJSTranslator.trans(r),
  primHostExpr   = BSSemActionParser.semAction:r                          BSJSTranslator.trans(r),
  atomicHostExpr = curlyHostExpr | primHostExpr,
  semAction      = curlyHostExpr:x                                     -> [#Act, x]
                 | "!"  atomicHostExpr:x                               -> [#Act, x],
  arrSemAction   = "->" atomicHostExpr:x                               -> [#Act, x],
  semPred        = "?"  atomicHostExpr:x                               -> [#Pred, x],
  expr           = expr5(true):x ("|"  expr5(true))+:xs                -> [#Or,  x].concat(xs)
                 | expr5(true):x ("||" expr5(true))+:xs                -> [#XOr, x].concat(xs)
                 | expr5(false),
  expr5 :ne      = interleavePart:x ("&&" interleavePart)+:xs          -> [#Interleave, x].concat(xs)
                 | expr4(ne),
  interleavePart = "(" expr4(true):part ")"                            -> ["1", part]
                 | expr4(true):part modedIPart(part),
  modedIPart     = [#And [#Many  :part]]                               -> ["*", part]
                 | [#And [#Many1 :part]]                               -> ["+", part]
                 | [#And [#Opt   :part]]                               -> ["?", part]
                 | :part                                               -> ["1", part],
  expr4 :ne      =                expr3*:xs arrSemAction:act           -> [#And].concat(xs).concat([act])
                 | ?ne            expr3+:xs                            -> [#And].concat(xs)
                 | ?(ne == false) expr3*:xs                            -> [#And].concat(xs),
  optIter :x     = '*'                                                 -> [#Many,  x]
                 | '+'                                                 -> [#Many1, x]
                 | '?'                                                 -> [#Opt,   x]
                 | empty                                               -> x,
  optBind :x     = ':' name:n                                          -> { this.locals.push(n); [#Set, n, x] }
                 | empty                                               -> x,
  expr3          = ":" name:n                                          -> { this.locals.push(n); [#Set, n, [#App, #anything]] }
                 | (expr2:x optIter(x) | semAction):e optBind(e)
                 | semPred,
  expr2          = "~" expr2:x                                         -> [#Not,       x]
                 | "&" expr1:x                                         -> [#Lookahead, x]
                 | expr1,
  expr1          = application 
                 | ( keyword('undefined') | keyword('nil')
                   | keyword('true')      | keyword('false') ):x       -> [#App, #exactly, x]
                 | spaces (characters | sCharacters | string | number)
                 | "["  expr:x "]"                                     -> [#Form,      x]
                 | "<"  expr:x ">"                                     -> [#ConsBy,    x]
                 | "@<" expr:x ">"                                     -> [#IdxConsBy, x]
                 | "("  expr:x ")"                                     -> x,
  ruleName       = name
                 | spaces tsString,
  rule           = &(ruleName:n) !(this.locals = ['$elf=this', '_fromIdx=this.input.idx'])
                     rulePart(n):x ("," rulePart(n))*:xs               -> [#Rule, n, this.locals, [#Or, x].concat(xs)],
  rulePart :rn   = ruleName:n ?(n == rn) expr4:b1 ( "=" expr:b2        -> [#And, b1, b2]
                                                  | empty              -> b1
                                                  ),
  grammar        = keyword('ometa') name:n
                     ( "<:" name | empty -> 'OMeta' ):sn
                     "{" listOf(#rule, ','):rs "}"                        BSOMetaOptimizer.optimizeGrammar(
                                                                            [#Grammar, n, sn].concat(rs)
                                                                          )
}

// By dispatching on the head of a list, the following idiom allows translators to avoid doing a linear search.
// (Note that the "=" in a rule definition is optional, so you can give your rules an "ML feel".)
ometa BSOMetaTranslator {
  App        'super' anything+:args        -> [this.sName, '._superApplyWithArgs(this,', args.join(','), ')']      .join(''),
  App        :rule   anything+:args        -> ['this._applyWithArgs("', rule, '",',      args.join(','), ')']      .join(''),
  App        :rule                         -> ['this._apply("', rule, '")']                                        .join(''),
  Act        :expr                         -> expr,
  Pred       :expr                         -> ['this._pred(', expr, ')']                                           .join(''),
  Or         transFn*:xs                   -> ['this._or(',  xs.join(','), ')']                                    .join(''),
  XOr        transFn*:xs                       {xs.unshift((this.name + "." + this.rName).toProgramString())}
                                           -> ['this._xor(', xs.join(','), ')']                                    .join(''),
  And        notLast(#trans)*:xs trans:y
             {xs.push('return ' + y)}      -> ['(function(){', xs.join(';'), '}).call(this)']                      .join(''),
  And                                      -> 'undefined',
  Opt        transFn:x                     -> ['this._opt(',           x, ')']                                     .join(''),
  Many       transFn:x                     -> ['this._many(',          x, ')']                                     .join(''),
  Many1      transFn:x                     -> ['this._many1(',         x, ')']                                     .join(''),
  Set        :n trans:v                    -> [n, '=', v]                                                          .join(''),
  Not        transFn:x                     -> ['this._not(',           x, ')']                                     .join(''),
  Lookahead  transFn:x                     -> ['this._lookahead(',     x, ')']                                     .join(''),
  Form       transFn:x                     -> ['this._form(',          x, ')']                                     .join(''),
  ConsBy     transFn:x                     -> ['this._consumedBy(',    x, ')']                                     .join(''),
  IdxConsBy  transFn:x                     -> ['this._idxConsumedBy(', x, ')']                                     .join(''),
  JumpTable  jtCase*:cases                 -> this.jumpTableCode(cases),
  Interleave intPart*:xs                   -> ['this._interleave(', xs.join(','), ')']                             .join(''),
  
  Rule       :name {this.rName = name}
             locals:ls trans:body          -> ['\n"', name, '":function(){', ls, 'return ', body, '}']             .join(''),
  Grammar    :name :sName
             {this.name = name}
             {this.sName = sName}
             trans*:rules                  -> [name, '=objectThatDelegatesTo(', sName, ',{', rules.join(','), '})'].join(''),
  intPart  = [:mode transFn:part]          -> (mode.toProgramString()  + "," + part),
  jtCase   = [:x trans:e]                  -> [x.toProgramString(), e],
  locals   = [string+:vs]                  -> ['var ', vs.join(','), ';']                                          .join('')
           | []                            -> '',
  trans    = [:t apply(t):ans]             -> ans,
  transFn  = trans:x                       -> ['(function(){return ', x, '})']                                     .join('')
}
BSOMetaTranslator.jumpTableCode = function(cases) {
  var buf = new StringBuffer()
  buf.nextPutAll("(function(){switch(this._apply('anything')){")
  for (var i = 0; i < cases.length; i += 1)
    buf.nextPutAll("case " + cases[i][0] + ":return " + cases[i][1] + ";")
  buf.nextPutAll("default: throw fail}}).call(this)")
  return buf.contents()
}