== NIFs and port drivers
Erlang.mk can not only build Erlang projects, but also the C code
that some projects come with, like NIFs and port drivers.
There are two ways to build the C code: using a custom Makefile,
or making Erlang.mk do it directly. The C code will be built
as needed when you run `make`.
// @todo something for easier bootstrapping
=== C source code location and Erlang environment
The C source code should be located in the '$(C_SRC_DIR)' directory.
It defaults to 'c_src/'. Should you need to modify it, all you
need to do is to set the variable in your Makefile before including
Erlang.mk:
[source,make]
C_SRC_DIR = $(CURDIR)/my_nif_source
When this directory exists, Erlang.mk will automatically create a
file named '$(C_SRC_ENV)'. This file defaults to '$(C_SRC_DIR)/env.mk'.
This can also be changed:
[source,make]
C_SRC_ENV = $(C_SRC_DIR)/erlang_env.mk
It contains a few variable definitions for the environment used for the build:
`ERTS_INCLUDE_DIR`::
Path to the ERTS include files ('erl_driver.h', 'erl_nif.h' and more).
`ERL_INTERFACE_INCLUDE_DIR`::
Path to the Erl_Interface include files ('ei.h' and related).
`ERL_INTERFACE_LIB_DIR`::
Path to the Erl_Interface static libraries.
// @todo We should remove this file on clean, not distclean.
=== Using a custom Makefile
Erlang.mk will automatically run `make` if it detects a Makefile
in '$(C_SRC_DIR)/Makefile'.
The Makefile should have at least two targets: a default target
(which can be anything, for example `all`) which is invoked when
building the C code, and a `clean` target invoked when cleaning
it.
You can include the 'env.mk' file to benefit from the Erlang
environment detection:
[source,make]
include env.mk
=== Using Erlang.mk directly
You don't need to write a Makefile to build C source code, however.
Erlang.mk comes with rules to build both shared libraries and
executables, using the source files it finds in '$(C_SRC_DIR)'.
By default, Erlang.mk will create a shared library. To change
this and create an executable instead, put this in your Makefile
before including Erlang.mk:
[source,make]
C_SRC_TYPE = executable
The generated file will be saved to '$(C_SRC_OUTPUT)'. It
defaults to '$(CURDIR)/priv/$(PROJECT).so', the filename
adequately fitting a Unix shared library.
Erlang.mk sets appropriate compile and linker flags by default.
These flags vary depending on the platform, and can of course
be overriden.
`CC`::
The compiler to be used.
`CFLAGS`::
C compiler flags.
`CXXFLAGS`::
C++ compiler flags.
`LDFLAGS`::
Linker flags.
`LDLIBS`::
Libraries to link against.
The source files are automatically gathered from the contents
of '$(C_SRC_DIR)'. Erlang.mk looks for '.c', '.C', '.cc' and '.cpp'
source files. You can define the variable `SOURCES` to manually
list the files to compile.
