ometa OMetaParser <: Parser {
  nameFirst      = '_' | '$' | letter,
  nameRest       = nameFirst | digit,
  tsName         = firstAndRest(#nameFirst, #nameRest):xs              -> joinStr(xs),
  name           = spaces tsName,
  eChar          = '\\' char:c                                         -> escapeChrToStr(c)
                 | char,
  tsString       = '\'' (~'\'' eChar)*:xs '\''                         -> joinStr(xs),
  characters     = '`' '`' (~('\'' '\'') eChar)*:xs '\'' '\''          -> [`App, `seq,     ident(xs)],
  sCharacters    = '"'     (~'"'         eChar)*:xs '"'                -> [`App, `token,   ident(xs)],
  string         = (('#' | '`') tsName | tsString):xs                  -> [`App, `exactly, ident(xs)],
  number         = ('-' | empty -> ''):sign digit+:ds                  -> [`App, `exactly, sign + joinStr(ds)],
  keyword :xs    = token(xs) ~letterOrDigit                            -> xs,
  hostExpr       = foreign(BSJSParser, `expr):r                           foreign(BSJSTranslator, `trans, r),
  atomicHostExpr = foreign(BSJSParser, `semAction):r                      foreign(BSJSTranslator, `trans, r),
  args           = "(" listOf(`hostExpr, ','):xs ")"                   -> xs
                 | empty                                               -> [],
  application    = name:rule args:as                                   -> joinList([`App, rule], as),
  semAction      = ("!" | "->") atomicHostExpr:x                       -> [`Act,  evalItem(x)],
  semPred        = "?"          atomicHostExpr:x                       -> [`Pred, evalItem(x)],
  expr           = listOf(#expr4, '|'):xs                              -> joinList([`Or], xs),
  expr4          = expr3*:xs                                           -> joinList([`And], xs),
  optIter :x     = "*"                                                 -> [`Many,  x]
                 | "+"                                                 -> [`Many1, x]
                 | empty                                               -> x,
  expr3          = expr2:x optIter(x):x ( ':' name:n                   -> [`Set, n, x]
                                        | empty                        -> x
                                        )
                 | ":" name:n                                          -> [`Set, n, [`App, `anything]],
  expr2          = "~" expr2:x                                         -> [`Not,       x]
                 | "&" expr1:x                                         -> [`Lookahead, x]
                 | expr1,
  expr1          = application | semAction | semPred
                 | ( keyword('undefined') | keyword('nil')
                   | keyword('true')      | keyword('false') ):x       -> [`App, #exactly, x]
                 | spaces (characters | sCharacters | string | number)
                 | "[" expr:x "]"                                      -> [`Form, x]
                 | "(" expr:x ")"                                      -> x,
  ruleName       = name
                 | spaces tsString,
  rule           = &(ruleName:name) 
                     rulePart(name):x ("," rulePart(name))*:xs         -> joinList([`Rule, name], joinList([`Or, x], 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 "}"                     -> joinList([`Grammar, n, sn], rs)
}
///END///

escapeCharToStr = function(c) { return unescape("\\"+c); }
joinStr = function(xs) { return xs.join(""); } 
joinList = function(l0, l1) { return l0.concat(l1); }
ident = function(xs) { return joinStr(xs); }
evalItem = function(s) { return (s[0] == '"') ? s : '"""'+s+'"""'; }

thisFile     = readFile("OMeta-as-SExpr")
ometaGrammar = thisFile.substring(0, thisFile.indexOf("///END///"))

loadOMetaFile = function(fn) { return BSOMetaTranslator.match(BSOMetaParser.matchAll(readFile(fn), "grammar"), "trans"); }
OmetaOptimizer = loadOMetaFile("OMeta_Optimizer")

r = BSOMetaParser.matchAll(thisFile, "grammar")
for (ri=0;ri<r.length;ri++) {
    Transcript.show(r[ri])
}

r = OmetaOptimizer.match(r, "optimizeGrammar")
for (ri=0;ri<r.length;ri++) {
    Transcript.show(r[ri])
}

r = OMetaParser.matchAll(ometaGrammar, "grammar")
for (ri=0;ri<r.length;ri++) {
    Transcript.show(r[ri])
}