Building C/C++

🚧No port compiler

In rebar3 it is required to have a Makefile or other instructions for building your C/C++ code outside of rebar itself.

Using the Makefile Template

We’ll start by making a new lib named test_nif and then using the cmake template from the root of the test_nif project.

  1. $ rebar3 new lib test_nif
  2. ===> Writing test_nif/src/test_nif.erl
  3. ===> Writing test_nif/src/test_nif.app.src
  4. ===> Writing test_nif/rebar.config
  5. ===> Writing test_nif/.gitignore
  6. ===> Writing test_nif/LICENSE
  7. ===> Writing test_nif/README.md
  8. $ cd test_nif
  9. $ rebar3 new cmake
  10. ===> Writing c_src/Makefile

In test_nif's rebar.config, add the pre_hooks line so that make is called when compile is run. Furthermore, add the post_hooks entry for cleaning up the built C object files.

The Makefile written by rebar3 new cmake is a GNU Makefile, which means you will need to have GNU Make installed on the system. In the example, we provide a handler for the FreeBSD operating system, which assumes GNU Make is called gmake.

  1. {pre_hooks,
  2.   [{"(linux|darwin|solaris)", compile, "make -C c_src"},
  3.    {"(freebsd)", compile, "gmake -C c_src"}]}.
  4. {post_hooks,
  5.   [{"(linux|darwin|solaris)", clean, "make -C c_src clean"},
  6.    {"(freebsd)", clean, "gmake -C c_src clean"}]}.

Below is a NIF which has a function repeat that will take a pid and an Erlang term to send to that pid.

  1. #include "erl_nif.h"
  3. ERL_NIF_TERM
  4. mk_atom(ErlNifEnv* env, const char* atom)
  5. {
  6.     ERL_NIF_TERM ret;
  8.     if(!enif_make_existing_atom(env, atom, &ret, ERL_NIF_LATIN1))
  9.     {
  10.         return enif_make_atom(env, atom);
  11.     }
  13.     return ret;
  14. }
  16. ERL_NIF_TERM
  17. mk_error(ErlNifEnv* env, const char* mesg)
  18. {
  19.     return enif_make_tuple2(env, mk_atom(env, "error"), mk_atom(env, mesg));
  20. }
  22. static ERL_NIF_TERM
  23. repeat(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
  24. {
  25.     ErlNifEnv* msg_env;
  26.     ErlNifPid pid;
  27.     ERL_NIF_TERM copy;
  29.     if(argc != 2)
  30.     {
  31.         return enif_make_badarg(env);
  32.     }
  34.     if(!enif_is_pid(env, argv[0]))
  35.     {
  36.         return mk_error(env, "not_a_pid");
  37.     }
  39.     if(!enif_get_local_pid(env, argv[0], &pid))
  40.     {
  41.         return mk_error(env, "not_a_local_pid");
  42.     }
  44.     msg_env = enif_alloc_env();
  45.     if(msg_env == NULL)
  46.     {
  47.         return mk_error(env, "environ_alloc_error");
  48.     }
  50.     copy = enif_make_copy(msg_env, argv[1]);
  52.     if(!enif_send(env, &pid, msg_env, copy))
  53.     {
  54.         enif_free(msg_env);
  55.         return mk_error(env, "error_sending_term");
  56.     }
  58.     enif_free_env(msg_env);
  59.     return mk_atom(env, "ok");
  60. }
  62. static ErlNifFunc nif_funcs[] = {
  63.     {"repeat", 2, repeat}
  64. };
  66. ERL_NIF_INIT(test_nif, nif_funcs, NULL, NULL, NULL, NULL);

Modify test_nif.erl to load the test_nif shared library from priv and export repeat/2.

  1. -module(test_nif).
  2. -export([repeat/2]).
  3. -on_load(init/0).
  5. -define(APPNAME, test_nif).
  6. -define(LIBNAME, test_nif).
  8. repeat(_, _) ->
  9.     not_loaded(?LINE).
  11. init() ->
  12.     SoName = case code:priv_dir(?APPNAME) of
  13.         {error, bad_name} ->
  14.             case filelib:is_dir(filename:join(["..", priv])) of
  15.                 true ->
  16.                     filename:join(["..", priv, ?LIBNAME]);
  17.                 _ ->
  18.                     filename:join([priv, ?LIBNAME])
  19.             end;
  20.         Dir ->
  21.             filename:join(Dir, ?LIBNAME)
  22.     end,
  23.     erlang:load_nif(SoName, 0).
  25. not_loaded(Line) ->
  26.     erlang:nif_error({not_loaded, [{module, ?MODULE}, {line, Line}]}).

Note that the error() function will cause Dializer errors. Using erlang:nif_error/1 will not, and is preferred here.

Run rebar3 shell and give the NIF a try.

  1. $ rebar3 shell
  2. ===> Verifying dependencies...
  3. ===> Compiling test_nif
  4. Erlang/OTP 17 [erts-6.3] [source] [64-bit] [smp:4:4] [async-threads:0] [kernel-poll:false]
  6. Eshell V6.3  (abort with ^G)
  7. 1> test_nif:repeat(self(), hello).
  8. ok
  9. 2> receive X -> X end.
  10. hello

References