named_rule.pony

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
use "collections"

class NamedRule[
  S: (Any #read & Equatable[S]),
  D: Any #share = None,
  V: Any #share = None]
  is RuleNodeWithBody[S, D, V]
  """
  Represents a named grammar rule.  Memoization and left-recursion handling happens per named `Rule`.
  """

  let name: String
  let memoize: Bool
  var _body: (RuleNode[S, D, V] | None)
  var _action: (Action[S, D, V] | None)

  var left_recursive: Bool = false

  new create(
    name': String,
    body': (RuleNode[S, D, V] | None) = None,
    action': (Action[S, D, V] | None) = None,
    memoize': Bool = false)
  =>
    name = name'
    memoize = memoize'
    _body = body'
    _action = action'
    set_left_recursive()

  fun action(): (Action[S, D, V] | None) =>
    _action

  fun body(): (this->(RuleNode[S, D, V]) | None) =>
    _body

  fun has_body(): Bool =>
    _body isnt None

  fun ref set_body(
    body': RuleNode[S, D, V],
    action': (Action[S, D, V] | None) = None)
  =>
    _body = body'
    if action' isnt None then
      _action = action'
    end
    set_left_recursive()

  fun ref set_left_recursive() =>
    let named_rules = SetIs[NamedRule[S, D, V]]
    _collect(this, named_rules)
    for nr in named_rules.values() do
      _set_lr(nr, SetIs[NamedRule[S, D, V]])
    end

  fun tag _collect(node: RuleNode[S, D, V], seen: SetIs[NamedRule[S, D, V]]) =>
    match node
    | let named_rule: NamedRule[S, D, V] =>
      if not seen.contains(named_rule) then
        seen.set(named_rule)
        match named_rule.body()
        | let body': RuleNode[S, D, V] =>
          _collect(body', seen)
        end
      end
    | let with_children: RuleNodeWithChildren[S, D, V] =>
      for child in with_children.children().values() do
        _collect(child, seen)
      end
    | let with_body: RuleNodeWithBody[S, D, V] =>
      match with_body.body()
      | let body': RuleNode[S, D, V] =>
        _collect(body', seen)
      end
    end

  fun tag _set_lr(node: RuleNode[S, D, V], seen: SetIs[NamedRule[S, D, V]]) =>
    match node
    | let named_rule: NamedRule[S, D, V] =>
      if seen.contains(named_rule) then
        named_rule.left_recursive = true
      else
        seen.set(named_rule)
        match named_rule.body()
        | let body': RuleNode[S, D, V] =>
          _set_lr(body', seen)
        end
      end
    | let conj: Conj[S, D, V] =>
      try
        _set_lr(conj.children()(0)?, seen)
      end
    | let disj: Disj[S, D, V] =>
      for child in disj.children().values() do
        _set_lr(child, seen)
      end
    | let with_body: RuleNodeWithBody[S, D, V] =>
      match with_body.body()
      | let body': RuleNode[S, D, V] =>
        _set_lr(body', seen)
      end
    end

  fun call(depth: USize, loc: Loc[S]): _RuleFrame[S, D, V] =>
    _NamedRuleFrame[S, D, V](this, depth, loc, _body)

class _NamedRuleFrame[
  S: (Any #read & Equatable[S]),
  D: Any #share,
  V: Any #share]
  is _Frame[S, D, V]

  let rule: NamedRule[S, D, V] box
  let depth: USize
  let loc: Loc[S]
  let body: (RuleNode[S, D, V] box | None)

  new create(
    rule': NamedRule[S, D, V] box,
    depth': USize,
    loc': Loc[S],
    body': (RuleNode[S, D, V] box | None))
  =>
    rule = rule'
    depth = depth'
    loc = loc'
    body = body'

  fun ref run(child_result: (Result[S, D, V] | None)): _FrameResult[S, D, V] =>
    // can't happen; parser should not call this
    Failure[S, D, V](rule, loc, "NamedRuleFrame.run() should not be called")