/* Got it. Thanks Alex */

/*
  Hi Hesam, I noticed you wrote some rules like this

    zero = 'z' 'e' 'r' 'o' -> 0,

  which is perfectly ok, but there is an easier way using the "seq" rule, which makes a sequence of characters:

    zero = seq('zero') -> 0,

  This is almost what

    zero = "zero"

  would do, except the latter would skip whitespace first, since "zero" means token('zero'), and token is defined (in Parser) as

    token :xs = spaces seq(xs) -> xs

  Cheers, Alex
*/

// a simple recognizer, produces no useful value

ometa L {
  number   = digit+,
  addExpr  = addExpr '+' mulExpr
           | addExpr '-' mulExpr
           | mulExpr,
  mulExpr  = mulExpr '*' primExpr
           | mulExpr '/' primExpr
           | primExpr,
  primExpr = '(' expr ')'
           | number,
  expr     = addExpr
}

L.matchAll('6*(4+3)', 'expr') 

// a recognizer that also interprets

ometa Calc {
  digit    = super(#digit):d          -> d.digitValue(),
  number   = number:n digit:d         -> (n * 10 + d)
           | digit
           | engl,
  engl     = zero | one | two | three | four | five,
  zero     = seq('zero') -> 0,
  one      = seq('one') -> 1,   
  two      = seq('two') -> 2,   
  three      = 't' 'h' 'r' 'e' 'e' -> 3,                               
  addExpr  = addExpr:x '+' mulExpr:y  -> (x + y)
           | addExpr:x '-' mulExpr:y  -> (x - y)
           | mulExpr,
  mulExpr  = mulExpr:x '*' primExpr:y -> (x * y)
           | mulExpr:x '/' primExpr:y -> (x / y)
           | primExpr,
  primExpr = '(' expr:x ')'           -> x
           | number,
  expr     = addExpr
}

Calc.matchAll('one+(two+three)', 'expr')

ometa G {
   S = A B,
   A = A 'a'
     | 'a',
   B = B 'b'
     | 'b' -> 3
}

G.matchAll('aab', 'S')

/* 
  Start Sol Project
*/


ometa SolParser <: Parser {
  grammar        = sentences:ss 
                     -> [`Grammar, ss],
  sentences      = sentences:ss spaces sentence:s spaces '.' spaces 
                     -> ss.concat([s])
                 | sentence:s spaces '.' spaces 
                     -> [s], 
  sentence       = startWorld | contWorld | createObj,
  startWorld     = "start-world" name:w                 
                     -> [`startworld, w],
  contWorld      = "continue-world" name:w                 
                     -> [`continueworld, w],
  createObj      = "create" name:n names:props 
                     -> [`create, n, [props]],
  nameFirst      = letter,
  nameRest       = nameFirst | digit,
  tsName         = firstAndRest(#nameFirst,#nameRest):xs   
                     -> xs.join(''),
  name           = spaces tsName,
  names          = names name | name
}

input = "start-world nim.
         create board name number-stones. 
         create player name play-board opponent turn."
SolParser.matchAll(input, 'grammar')   [Grammar, [[startworld, nim]]]