exp_ffi.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
use json = "../json"

class val ExpFfi is NodeData
  """
    An FFI call.
  """

  let identifier: (NodeWith[Identifier] | NodeWith[LiteralString])
  let type_args: (NodeWith[TypeArgs] | None)
  let call_args: NodeWith[CallArgs]
  let partial: Bool

  new val create(
    identifier': (NodeWith[Identifier] | NodeWith[LiteralString]),
    type_args': (NodeWith[TypeArgs] | None),
    call_args': NodeWith[CallArgs],
    partial': Bool)
  =>
    identifier = identifier'
    type_args = type_args'
    call_args = call_args'
    partial = partial'

  fun name(): String => "ExpFfi"

  fun val clone(updates: ChildUpdateMap): NodeData =>
    ExpFfi(
      try
        updates(identifier)? as (NodeWith[Identifier] | NodeWith[LiteralString])
      else
        identifier
      end,
      _map_or_none[TypeArgs](type_args, updates),
      _map_with[CallArgs](call_args, updates),
      partial)

  fun add_json_props(node: Node box, props: Array[(String, json.Item)]) =>
    props.push(("identifier", node.child_ref(identifier)))
    match type_args
    | let type_args': NodeWith[TypeArgs] =>
      props.push(("type_args", node.child_ref(type_args')))
    end
    props.push(("call_args", node.child_ref(call_args)))
    if partial then
      props.push(("partial", partial))
    end

primitive ParseExpFfi
  fun help_id(): String => "ExpFfi.identifier must be an Identifier or Literal"

  fun apply(obj: json.Object val, children: NodeSeq): (ExpFfi | String) =>
    let identifier =
      match ParseNode._get_child(obj, children, "identifier", help_id())
      | let node: Node =>
        match node
        | let identifier': NodeWith[Identifier] =>
          identifier'
        | let literal': NodeWith[LiteralString] =>
          literal'
        else
          return help_id()
        end
      | let err: String =>
        return err
      else
        return help_id()
      end
    let type_args =
      match ParseNode._get_child_with[TypeArgs](
        obj,
        children,
        "type_args",
        "ExpFfi.type_args must be a TypeArgs",
        false)
      | let node: NodeWith[TypeArgs] =>
        node
      | let err: String =>
        return err
      end
    let call_args =
      match ParseNode._get_child_with[CallArgs](
        obj,
        children,
        "call_args",
        "ExpFfi.call_args must be a CallArgs")
      | let node: NodeWith[CallArgs] =>
        node
      | let err: String =>
        return err
      else
        return "ExpFfi.call_args must be a CallArgs"
      end
    let partial =
      match try obj("partial")? end
      | let bool: Bool =>
        bool
      | let item: json.Item =>
        return "ExpFfi.partial must be a boolean"
      else
        false
      end
    ExpFfi(identifier, type_args, call_args, partial)