#peg.mbt

• At runtime: @peg.generate(grammar) returns a parser that interprets the compiled bytecode. Code blocks are implemented by MoonBit closures.
• As generated source: pegmbt (or @peg.generate_source) emits a standalone MoonBit parser whose { ... } code blocks are MoonBit code.

#Fidelity

#Runtime parsers

///|
test "runtime parser with actions" {
  let grammar =
    #|start = head:number tail:("+" @number)* { sum }
    #|number = [0-9]+ { toNumber }
  let parser : @peg.Parser[Unit] = @peg.generate(
    grammar,
    options=@peg.Options::new(actions={
      "toNumber": ctx => {
        let mut n = 0.0
        for c in ctx.text() {
          n = n * 10.0 + (c.to_int() - '0'.to_int()).to_double()
        }
        Num(n)
      },
      "sum": ctx => {
        let mut total = ctx.label("head")
        for x in ctx.label("tail").as_arr().unwrap() {
          guard (total, x) is (Num(a), Num(b)) else { fail("not numbers") }
          total = Num(a + b)
        }
        total
      },
    }),
  )
  debug_inspect(parser.parse("1+20+300"), content="Num(321)")
}

///|
test "default values and errors" {
  let parser : @peg.Parser[Unit] = @peg.generate("start = 'a' [0-9]? $('b'+)")
  debug_inspect(
    parser.parse("abbb"),
    content=(
      #|Arr([Str("a"), Null, Str("bbb")])
    ),
  )
  let message = try parser.parse("ac") catch {
    @runtime.SyntaxError(message~, ..) => message
    _ => "other error"
  } noraise {
    _ => "parsed"
  }
  inspect(
    message,
    content=(
      #|Expected "b" or [0-9] but "c" found.
    ),
  )
}

• ActionContext (ctx) gives the labels in scope (ctx.label("x")) and the PEG.js helpers: text(), offset(), range(), location(), expected(description, location?), error(message, location?), options().
• A binding is looked up by "#<index>", then by exact code, then by trimmed code. Identical code blocks with different labels share a text key, so read labels by name.
• Predicates return a Value, judged by JavaScript truthiness.
• A grammar initializer needs Options::initializer: it runs once per parse and returns bindings, so actions can share per-parse state.
• Options: allowed_start_rules, cache, trace, optimize, features, parser (reserved words, comments) and plugins, as in PEG.js. parse accepts start_rule, filename, tracer and options.

#Generated parsers

{
  // The initializer runs once per parse; its definitions are visible to all
  // code blocks.
  fn num(v : PegValue) -> Double {
    match v {
      Num(n) => n
      _ => 0.0
    }
  }
}

Sum
  = head:Integer tail:(_ "+" _ @Integer)* {
      let mut total = num(head)
      for x in tail.as_arr().unwrap() {
        total = total + num(x)
      }
      Num(total)
    }

Integer "integer"
  = [0-9]+ &{ ctx.text().length() < 10 } { Num(@string.parse_double(ctx.text())) }

_ = " "*

moon run --target native cmd/pegmbt -- sum.pegjs        # writes sum.mbt

• Actions are function bodies returning PegValue (@runtime.Value[T]), with the labels in scope as PegValue parameters, so labels must be MoonBit identifiers (lowercase, not keywords).
• Predicates (&{ }, !{ }) return a Bool or a PegValue (truthiness).
• ctx : @runtime.ActionContext[T] provides text(), location(), error(), the other helpers, and ctx.label(name).
• The initializer is pasted into a per-parse function. It must fall through (no return), and generated names start with peg_ / Peg.
• As in PEG.js, code blocks end at the first unbalanced }, even when that brace is inside a string or comment.

#Differences from PEG.js

• The JavaScript output formats (format, dependencies, exportVar) are dropped. pegmbt cannot load JavaScript plugins (-p); library plugins are MoonBit functions receiving the Session (grammar parser, passes, opcodes, reporters, backend) and the options.
• Code blocks are MoonBit: bound closures at runtime, source text in generated parsers. When source is generated, labels must be valid MoonBit identifiers, and MoonBit keywords are the default reserved words.
• An action referring to an out-of-scope label raises ReferenceError at runtime; in generated source it is a compile error.
• A class whose line continuations produce an out-of-order regexp range (e.g. [z\<newline>-a]) makes PEG.js' generate fail on the invalid regexp; here that range matches nothing.

#Packages

#Development

• tools/harvest.js: a mocha hook that records every grammar parse, pass invocation, generate and parse of the upstream test suite into tools/corpus.jsonl.
• tools/gen-fixtures.js: turns the corpus into the MoonBit differential tests.
• tools/gen-codegen-corpus.js: generates internal/codegen_corpus with pegmbt, using the MoonBit versions of the upstream test code blocks from tools/mbt-code-blocks.js.
• tools/gen-program.js, tools/gen-self-host.js, tools/gen-unicode.js: produce the frozen meta-grammar program, the self-hosted grammar and the case tables.

• tools/regenerate.sh: rebuilds every generated file from the pinned reference; CI checks that the result matches the repository.

moon test --target all