defprotocol Zig.Type do
alias Zig.Type.Array
alias Zig.Type.Bool
alias Zig.Type.Cpointer
alias Zig.Type.Error
alias Zig.Type.Float
alias Zig.Type.Integer
alias Zig.Type.Manypointer
alias Zig.Type.Optional
alias Zig.Type.Slice
alias Zig.Type.Struct
alias Zig.Type.Resource
@type t ::
Bool.t() | Enum.t() | Float.t() | Integer.t() | Struct.t() | :env | :pid | :port | :term
@spec marshals_param?(t) :: boolean
@doc "beam-side type conversions that might be necessary to get an elixir parameter into a zig parameter"
def marshals_param?(type)
@spec marshal_param(t, Macro.t(), non_neg_integer, :elixir | :erlang) :: Macro.t()
def marshal_param(type, variable, index, platform)
@spec marshals_return?(t) :: boolean
@doc "beam-side type conversions that might be necessary to get a zig return into an elixir return"
def marshals_return?(type)
@spec marshal_return(t, Macro.t(), :elixir | :erlang) :: Macro.t()
def marshal_return(type, variable, platform)
@doc "catch prongs to correctly perform error handling, atom is a reference to function in `Zig.ErrorProng`"
@spec error_prongs(t, :argument | :return) :: [{atom, [atom]}]
def error_prongs(type, context)
@doc "generates make clauses in zig"
@spec get_result(t, keyword) :: String.t()
def get_result(type, opts)
@spec needs_make?(t) :: boolean
def needs_make?(type)
@spec missing_size?(t) :: boolean
def missing_size?(type)
@spec to_call(t) :: String.t()
def to_call(type)
@spec return_allowed?(t) :: boolean
def return_allowed?(type)
@typep spec_context :: :param | :return
@spec spec(t, spec_context, keyword) :: Macro.t()
def spec(type, context, opts)
import Protocol, only: []
import Kernel
defmacro sigil_t({:<<>>, _, [string]}, _) do
string
|> parse
|> Macro.escape()
end
def parse(string) do
case string do
"u" <> _ ->
Integer.parse(string)
"i" <> _ ->
Integer.parse(string)
"f" <> _ ->
Float.parse(string)
"c_uint" <> _ ->
Integer.parse(string)
"[]" <> rest ->
Slice.of(parse(rest))
"[:0]" <> rest ->
Slice.of(parse(rest), has_sentinel?: true)
"[*]" <> rest ->
Manypointer.of(parse(rest))
"[*:0]" <> rest ->
Manypointer.of(parse(rest), has_sentinel?: true)
"[*c]" <> rest ->
Cpointer.of(parse(rest))
"?" <> rest ->
Optional.of(parse(rest))
"[" <> maybe_array ->
case Elixir.Integer.parse(maybe_array) do
{count, "]" <> rest} ->
Array.of(parse(rest), count)
{count, ":0]" <> rest} ->
Array.of(parse(rest), count, has_sentinel?: true)
_ ->
raise "unknown type #{string}"
end
"?*.cimport" <> rest ->
if String.ends_with?(rest, "struct_enif_environment_t") do
Env
else
unknown =
rest
|> String.split(".")
|> List.last()
raise "unknown type #{unknown}"
end
end
end
@pointer_types ~w(array struct)
def from_json(json, module) do
case json do
nil ->
# only allow during documentation sema passes
if module do
raise CompileError, description: "zigler encountered anytype"
else
:anytype
end
%{"type" => "unusable:" <> typename} ->
# only allow during documentation sema passes
if module do
raise CompileError, description: "zigler encountered the unusable type #{typename}"
else
String.to_atom(typename)
end
%{"type" => "bool"} ->
Bool.from_json(json)
%{"type" => "void"} ->
:void
%{"type" => "integer"} ->
Integer.from_json(json)
%{"type" => "enum"} ->
Zig.Type.Enum.from_json(json, module)
%{"type" => "float"} ->
Float.from_json(json)
%{
"type" => "struct",
"fields" => [%{"name" => "__payload"}, %{"name" => "__should_release"}]
} ->
Resource.from_json(json, module)
%{"type" => "struct"} ->
Struct.from_json(json, module)
%{"type" => "array"} ->
Array.from_json(json, module)
%{"type" => "slice"} ->
Slice.from_json(json, module)
%{"type" => "pointer", "child" => child = %{"type" => type}} when type in @pointer_types ->
child
|> __MODULE__.from_json(module)
|> Map.replace!(:mutable, true)
%{"type" => "pointer", "child" => %{"type" => "unusable:anyopaque"}} ->
:anyopaque_pointer
%{"type" => "manypointer"} ->
Manypointer.from_json(json, module)
%{"type" => "cpointer"} ->
Cpointer.from_json(json, module)
%{"type" => "optional"} ->
Optional.from_json(json, module)
%{"type" => "error"} ->
Error.from_json(json, module)
%{"type" => "env"} ->
:env
%{"type" => "erl_nif_term"} ->
:erl_nif_term
%{"type" => "struct", "name" => "beam.term"} ->
:term
%{"type" => "pid"} ->
:pid
%{"type" => "port"} ->
:port
%{"type" => "term"} ->
:term
%{"type" => "e.ErlNifBinary"} ->
:erl_nif_binary
%{"type" => "e.ErlNifEvent"} ->
:erl_nif_event
%{"type" => "pointer", "child" => %{"type" => "e.ErlNifBinary"}} ->
:erl_nif_binary_pointer
%{"type" => "pointer", "child" => %{"type" => "builtin.StackTrace"}} ->
:stacktrace
end
end
# convenienece function
def spec(atom) when is_atom(atom) do
quote context: Elixir do
unquote(atom)()
end
end
defmacro __using__(opts) do
module = __CALLER__.module
inspect? = Keyword.get(opts, :inspect?, false)
quote bind_quoted: [inspect?: inspect?, module: module] do
import Kernel, except: [to_string: 1]
def marshals_param?(_), do: false
def marshals_return?(_), do: false
def marshal_param(_, _, _, _), do: raise("unreachable")
def marshal_return(_, _, _), do: raise("unreachable")
def error_prongs(_, :argument), do: [:argument_error_prong]
def error_prongs(_, :return), do: []
def get_result(type, opts) do
return_type = Keyword.fetch!(opts, :type)
"break :get_result beam.make(env, result, .{.output_type = .#{return_type}}).v;"
end
def needs_make?(_), do: true
def missing_size?(_), do: false
defoverridable get_result: 2,
marshals_param?: 1,
marshal_param: 4,
marshals_return?: 1,
marshal_return: 3,
error_prongs: 2,
needs_make?: 1,
missing_size?: 1
defimpl String.Chars do
defdelegate to_string(type), to: module
end
if inspect? do
defimpl Inspect do
defdelegate inspect(type, opts), to: module
end
else
defimpl Inspect do
defdelegate inspect(type, opts), to: Inspect.Any
end
end
defimpl Zig.Type do
defdelegate marshals_param?(type), to: module
defdelegate marshal_param(type, variable, index, platform), to: module
defdelegate marshals_return?(type), to: module
defdelegate marshal_return(type, variable, platform), to: module
defdelegate error_prongs(type, context), to: module
defdelegate to_call(type), to: module
defdelegate return_allowed?(type), to: module
defdelegate get_result(type, opts), to: module
defdelegate needs_make?(type), to: module
defdelegate missing_size?(type), to: module
defdelegate spec(type, context, opts), to: module
end
end
end
end
defimpl Zig.Type, for: Atom do
def marshals_param?(_), do: false
def marshals_return?(_), do: false
def marshal_param(_, _, _, _), do: raise("unreachable")
def marshal_return(_, _, _), do: raise("unreachable")
def error_prongs(type, :argument),
do: List.wrap(if type in ~w(pid port)a, do: :argument_error_prong)
def error_prongs(_, _), do: []
def to_call(:erl_nif_term), do: "e.ErlNifTerm"
def to_call(:term), do: "beam.term"
def to_call(:pid), do: "beam.pid"
def to_call(:port), do: "beam.port"
def to_call(:void), do: "void"
def to_call(type), do: to_string(type)
def return_allowed?(type), do: type in ~w(term erl_nif_term pid void)a
def get_result(:erl_nif_term, _), do: "break :get_result result;"
def get_result(:pid, _), do: "break :get_result beam.make(env, result, .{}).v;"
def get_result(:term, _), do: "break :get_result result.v;"
def get_result(:void, opts) do
# TODO: move this out of void, and make it general?
return_type = Keyword.get(opts, :type, :default)
case {opts[:arg], opts[:length]} do
{nil, _} ->
"break :get_result beam.make(env, result, .{}).v;"
{arg, nil} ->
"""
_ = result;
break :get_result beam.make(env, payload[#{arg}], .{.output_type = .#{return_type}}).v;
"""
{arg, {:arg, length_arg}} ->
"""
_ = result;
break :get_result beam.make(env, payload[#{arg}][0..@intCast(payload[#{length_arg}])], .{.output_type = .#{return_type}}).v;
"""
{arg, length} when is_integer(length) ->
"""
_ = result;
break :get_result beam.make(env, payload[#{arg}][0..#{length})], .{.output_type = .#{return_type}}).v;
"""
end
end
def spec(:void, :return, _), do: :ok
def spec(:pid, _, _), do: Zig.Type.spec(:pid)
def spec(term, _, _) when term in ~w(term erl_nif_term)a, do: Zig.Type.spec(:term)
def needs_make?(_), do: false
def missing_size?(_), do: false
end
