Preprocessor
View SourceFile Inclusion
A file can be included as follows:
-include(File).
-include_lib(File).File, a string, is to point out a file. The contents of this file are included
as is, at the position of the directive.
Include files are typically used for record and macro definitions that are
shared by several modules. It is recommended to use the file name extension
.hrl for include files.
File can start with a path component $VAR, for some string VAR. If that is
the case, the value of the environment variable VAR as returned by
os:getenv(VAR) is substituted for $VAR. If os:getenv(VAR) returns false,
$VAR is left as is.
If the filename File is absolute (possibly after variable substitution), the
include file with that name is included. Otherwise, the specified file is
searched for in the following directories, and in this order:
- The current working directory
- The directory where the module is being compiled
- The directories given by the
includeoption
For details, see erlc in ERTS and
compile in Compiler.
Examples:
-include("my_records.hrl").
-include("incdir/my_records.hrl").
-include("/home/user/proj/my_records.hrl").
-include("$PROJ_ROOT/my_records.hrl").include_lib is similar to include, but is not to point out an absolute file.
Instead, the first path component (possibly after variable substitution) is
assumed to be the name of an application.
Example:
-include_lib("kernel/include/file.hrl").The code server uses code:lib_dir(kernel) to find the directory of the current
(latest) version of Kernel, and then the subdirectory include is searched for
the file file.hrl.
Defining and Using Macros
A macro is defined as follows:
-define(Const, Replacement).
-define(Func(Var1,...,VarN), Replacement).A macro definition can be placed anywhere among the attributes and function declarations of a module, but the definition must come before any usage of the macro.
If a macro is used in several modules, it is recommended that the macro definition is placed in an include file.
A macro is used as follows:
?Const
?Func(Arg1,...,ArgN)Macros are expanded during compilation. A simple macro ?Const is replaced with
Replacement.
Example:
-define(TIMEOUT, 200).
...
call(Request) ->
server:call(refserver, Request, ?TIMEOUT).This is expanded to:
call(Request) ->
server:call(refserver, Request, 200).A macro ?Func(Arg1,...,ArgN) is replaced with Replacement, where all
occurrences of a variable Var from the macro definition are replaced with the
corresponding argument Arg.
Example:
-define(MACRO1(X, Y), {a, X, b, Y}).
...
bar(X) ->
?MACRO1(a, b),
?MACRO1(X, 123)This is expanded to:
bar(X) ->
{a,a,b,b},
{a,X,b,123}.It is good programming practice, but not mandatory, to ensure that a macro definition is a valid Erlang syntactic form.
To view the result of macro expansion, a module can be compiled with the 'P'
option. compile:file(File, ['P']). This produces a listing of the parsed code
after preprocessing and parse transforms, in the file File.P.
Predefined Macros
The following macros are predefined:
?MODULE- The name of the current module, as an atom.?MODULE_STRING- The name of the current module, as a string.?FILE- The file name of the current module, as a string.?LINE- The current line number, as an integer.?MACHINE- The machine name,'BEAM'.?FUNCTION_NAME- The name of the current function, as an atom.?FUNCTION_ARITY- The arity (number of arguments) for the current function, as an integer.?OTP_RELEASE- The OTP release for the runtime system that is running the compiler, as an integer. For example, when compiling using Erlang/OTP 27, the macro returns27.Note
To find out the release at run-time, call
erlang:system_info(otp_release). Note that it returns the release as a string. For example, when the release is Erlang/OTP 27, the string"27"will be returned.Change
The
?OTP_RELEASEmacro was introduced in Erlang/OTP 21.?FEATURE_AVAILABLE(Feature)- Expands totrueif the featureFeatureis available. The feature might or might not be enabled.Change
The
?FEATURE_AVAILABLE()macro was introduced in Erlang/OTP 25.?FEATURE_ENABLED(Feature)- Expands totrueif the featureFeatureis enabled.Change
The
?FEATURE_ENABLED()macro was introduced in Erlang/OTP 25.
Macros Overloading
It is possible to overload macros, except for predefined macros. An overloaded macro has more than one definition, each with a different number of arguments.
Change
Support for overloading of macros was added in Erlang 5.7.5/OTP R13B04.
A macro ?Func(Arg1,...,ArgN) with a (possibly empty) list of arguments results
in an error message if there is at least one definition of Func with
arguments, but none with N arguments.
Assuming these definitions:
-define(F0(), c).
-define(F1(A), A).
-define(C, m:f).the following does not work:
f0() ->
?F0. % No, an empty list of arguments expected.
f1(A) ->
?F1(A, A). % No, exactly one argument expected.On the other hand,
f() ->
?C().is expanded to
f() ->
m:f().Removing a macro definition
A definition of macro can be removed as follows:
-undef(Macro).Conditional Compilation
The following macro directives support conditional compilation:
-ifdef(Macro).- Evaluate the following lines only ifMacrois defined.-ifndef(Macro).- Evaluate the following lines only ifMacrois not defined.-else.- Only allowed after theifdef,ifndef,if, andelifdirectives. The lines followingelseare evaluated if the preceding directive evaluated to false.-if(Condition).- Evaluates the following lines only ifConditionevaluates to true.-elif(Condition).- Only allowed after anifor anotherelifdirective. If the precedingiforelifdirective does not evaluate to true, and theConditionevaluates to true, the lines following theelifare evaluated instead.-endif.- Specifies the end of a series of control flow directives.
Note
Macro directives cannot be used inside functions.
Syntactically, the Condition in if and elif must be a
guard expression. Other constructs (such as
a case expression) result in a compilation error.
As opposed to the standard guard expressions, an expression in an if and
elif also supports calling the psuedo-function defined(Name), which tests
whether the Name argument is the name of a previously defined macro.
defined(Name) evaluates to true if the macro is defined and false
otherwise. An attempt to call other functions results in a compilation error.
Example:
-module(m).
...
-ifdef(debug).
-define(LOG(X), io:format("{~p,~p}: ~p~n", [?MODULE,?LINE,X])).
-else.
-define(LOG(X), true).
-endif.
...When trace output is desired, debug is to be defined when the module m is
compiled:
% erlc -Ddebug m.erl
or
1> c(m, {d, debug}).
{ok,m}?LOG(Arg) is then expanded to a call to io:format/2 and provide the user
with some simple trace output.
Example:
-module(m)
...
-if(?OTP_RELEASE >= 25).
%% Code that will work in OTP 25 or higher
-elif(?OTP_RELEASE >= 26).
%% Code that will work in OTP 26 or higher
-else.
%% Code that will work in OTP 24 or lower.
-endif.
...This code uses the OTP_RELEASE macro to conditionally select code depending on
release.
Example:
-module(m)
...
-if(?OTP_RELEASE >= 26 andalso defined(debug)).
%% Debugging code that requires OTP 26 or later.
-else.
%% Non-debug code that works in any release.
-endif.
...This code uses the OTP_RELEASE macro and defined(debug) to compile debug
code only for OTP 26 or later.
The -feature() directive
The directive -feature(FeatureName, enable | disable) can be used to enable or
disable the feature FeatureName. This is
the preferred way of enabling (disabling) features, although it is possible to
do it with options to the compiler as well.
Note that the -feature(..) directive may only appear before any syntax is
used. In practice this means it should appear before any -export(..) or record
definitions.
-error() and -warning() directives
The directive -error(Term) causes a compilation error.
Example:
-module(t).
-export([version/0]).
-ifdef(VERSION).
version() -> ?VERSION.
-else.
-error("Macro VERSION must be defined.").
version() -> "".
-endif.The error message will look like this:
% erlc t.erl
t.erl:7: -error("Macro VERSION must be defined.").The directive -warning(Term) causes a compilation warning.
Example:
-module(t).
-export([version/0]).
-ifndef(VERSION).
-warning("Macro VERSION not defined -- using default version.").
-define(VERSION, "0").
-endif.
version() -> ?VERSION.The warning message will look like this:
% erlc t.erl
t.erl:5: Warning: -warning("Macro VERSION not defined -- using default version.").Change
The -error() and -warning() directives were added in Erlang/OTP 19.
Stringifying Macro Arguments
The construction ??Arg, where Arg is a macro argument, is expanded to a
string containing the tokens of the argument. This is similar to the #arg
stringifying construction in C.
Example:
-define(TESTCALL(Call), io:format("Call ~s: ~w~n", [??Call, Call])).
?TESTCALL(myfunction(1,2)),
?TESTCALL(you:function(2,1)).results in
io:format("Call ~s: ~w~n",["myfunction ( 1 , 2 )",myfunction(1,2)]),
io:format("Call ~s: ~w~n",["you : function ( 2 , 1 )",you:function(2,1)]).That is, a trace output, with both the function called and the resulting value.