peg.brat

#* Simple implementation of parsing expression grammar.
  Intended to replace Treetop as the parser for Brat
  but may be used for other purposes, as well.
*#

include 'scanner'

result_match = object.new
result_match.prototype.to_s = {
  name = my.label || my.rule_name || "result"
  "<#{name} text='#{my.text}' start=#{my.start_pos} end=#{my.end_pos}>"
}

peg = object.new

peg.init = { gramma |
  my.named_rules = [:]
  my.rule_names = [:]
  my.first = null
  my.rule_id = 0
  my.memo = [:]

  gramma #Actually set up parser
}

peg.prototype.next_id = {
  my.rule_id = my.rule_id + 1
}

peg.make_memo = { result, pos |
  true? result
    {
      m = object.new
      m.result = result
      m.pos = pos
      m
    }
}

peg.prototype.make_rule = { rule |
  id = next_id
  memo = my.memo
  rules = my.rule_names
  memo[id] = [:]

  real = { x |
    m = memo[id][x.pos]
    null? m
      {
        current = x.pos
        res = rule x
        memo[id][current] = peg.make_memo res, x.pos
        true? res && { null? res.rule_name }
          { res.rule_name = rules[->real] }
        res
      }
      {
        true? m
          {
            x.pos = m.pos
            m.result
          }
      }
  }
}

peg.make_result = { match_pos, end_pos, matched, rule_name = null |
  result = result_match.new
  result.start_pos = match_pos
  result.end_pos = end_pos
  result.matched = matched
  result.label = null
  result.rule_name = rule_name

  when { matched.string? } { result.text = matched }
       { matched.has_method? :full_match } { result.text = matched.full_match }
       { matched.array? } { result.text = { matched.map(:text).join } }
       { matched.has_method? :text } { result.text = matched->text }
       { true } { result.text = "" }

  true? matched.array?
    { result.elements = matched }
    { result.elements = [matched] }

  result
}

#Parse a string
#If no start rule is given, then whichever rule was defined first will be used.
#By default, the entire string does not have to match.
peg.prototype.parse = { str, start_rule = null, fully = false |
  null? start_rule
    { start_rule = my.first }

  my.memo.each_value { v | v.clear }

  s = scanner.new str
  rule = my.named_rules[start_rule]

  null? { ->rule } { throw "No such rule: #{start_rule}" }

  result = rule s

  true? result
    { result.matched_all? = s.pos == str.length }

  true? { result && { fully } }
    { true? result.matched_all?, { result } }
    { result }
}

#Match a sequence of rules
peg.prototype.seq = { rule, *rules |
  true? rules.empty?
    { true? function?(->rule) { rules = [->rule] } { rules = rule } }
    { rules = [->rule] + rules }

  make_rule { x |
    matched = false
    matches = []
    start = x.pos

    rules.each_while { rule |
      matched = rule x
      matches << matched
      matched
    }

    false? matched
      { x.pos = start; false }
      { peg.make_result start, x.pos, matches }
  }
}

peg.prototype.seq_ref = { *rules |
  m = my
  seq rules.map { name | m.ref name }
}

#Match any of a set of rules
peg.prototype.any = { rule, *rules |
  true? rules.empty?
    { true? function?(->rule) { rules = [->rule] } { rules = rule } }
    { rules = [->rule] + rules }

  make_rule { x |
    matched = null
    start = x.pos

    rules.each_until { opt |
      matched = opt x
    }

    matched
  }
}

peg.prototype.any_ref = { *rule_names |
  m = my
  any rule_names.map { name | m.ref name }
}

#Match a rule the specified number of times
peg.prototype.num_of = { rule, min, max |
  make_rule { x |
    matches = []
    start = x.pos

    while {
      matched = rule x
      true? matched
      { matches << matched }
    }

    true? num_matches >= min
      { null? max
        { peg.make_result start, x.pos, matches }
        { true? num_matches <= max
            { peg.make_result start, x.pos, matches }
        }
    }
  }
}

#Match zero or one occurrences of rule
peg.prototype.maybe = { rule |
  make_rule { x |
    start = x.pos

    matched = rule x
    true? matched
      {
        res = peg.make_result start, x.pos, matched
        res.rule_name = "#{matched.rule_name || 'result'}?"
        res
      }
      {
        peg.make_result start, start, ""
      }
  }
}

#Match zero or more occurrences of rule
peg.prototype.kleene = { rule |
  make_rule { x |
    matches = []
    start = x.pos

    while {
      res = rule x

      true? res
        { matches << res }
    }

    res = peg.make_result start, x.pos, matches
    false? matches.empty?
      {
        rule_name = matches.first.rule_name
        res.rule_name = "#{rule_name || 'result'}*"
      }
    res
  }
}

#Match one or more occurrences of rule
peg.prototype.many = { rule |
  make_rule { x |
    start = x.pos
    matches = []

    matched = rule x

    true? matched
      { matches << matched }

    while {
      matched = rule x
      true? matched
        { matches << matched }
    }

    false? matches.empty?
      {
        rule_name = matches.first.rule_name
        res = peg.make_result start, x.pos, matches
        res.rule_name = "#{rule_name}+"
        res
      }
  }
}

#Match a string literally
peg.prototype.str = { literal |
  make_rule { x |
    start = x.pos
    matched = x.scan_string literal
    true? matched
      { peg.make_result start, x.pos, matched }
  }
}

#Match a regular expression
peg.prototype.reg = { reg_literal |
  make_rule { x |
    start = x.pos
    matched = x.scan_regex reg_literal
    true? matched
      { peg.make_result start, x.pos, matched }
  }
}

#Specify that a rule should NOT match
peg.prototype.no = { rule |
  make_rule { x |
    start = x.pos
    res = rule x
    stop = x.pos
    x.pos = start

    true? res
      { false }
      { peg.make_result start, stop, res }
  }
}

#Specific that a rule should match, but do not advance
#position (lookahead)
peg.prototype.and = { rule |
  make_rule { x |
    start = x.pos
    matched = rule x
    stop = x.pos
    x.pos = start
    true? matched
      { peg.make_result start, stop, "" }
  }
}

#Set a named rule
peg.prototype.set = { name, rule |
  null? my.first
    { my.first = name }

  my.rule_names[->rule] = name
  my.named_rules[name] = ->rule
}

#Matches one of anything.
#Shortcut for peg.reg /./m
peg.prototype.anything = {
  reg /./m
}

#Reference a named rule
peg.prototype.ref = { name |
  rules = my.named_rules
  make_rule { x |
    r = rules[name]
    null? { ->r }
      { throw "No such rule: #{name}" }
    r x
  }
}


all_labels = [:]

peg.fetch_labels = { rule |
  labels = []
#*  true? all_labels[rule]
    { p rule }
    { all_labels[rule] = true }
*#
  true? (rule.has_method?(:label) && { rule.label })
    { labels << rule }


  true? rule.has_method?(:elements)
    { labels + rule.elements.map({ r | peg.fetch_labels r }).compact!.flatten }
    { labels }
}

#Execute action upon match
peg.prototype.action = { rule, block |
  make_rule { x |
    res = rule x
    true? res
      {
        peg.add_labels res
        res.with_this ->block
        res
      }
  }
}

peg.add_labels = { res |
  labeled_rules = peg.fetch_labels res

  labeled_rules.each { result |
    false? res.has_method?(result.label)
      { res.add_method result.label, { result } }
  }
}

peg.prototype.label = { label, rule |
  make_rule { x |
    res = rule x
    true? res
      { res.label = label; res }
  }
}

export peg, "peg"