Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
make(3)			   Erlang Module Definition		       make(3)

       make - A	Make Utility for Erlang

       The  module  make  provides a set of functions similar to the UNIX type
       Make functions.

       all() ->	up_to_date | error
       all(Options) -> up_to_date | error


		 Options = [Option]
		  Option = noexec | load | netload | {emake,  Emake}  |	 <com-
		 piler option>

	      This  function  determines the set of modules to compile and the
	      compile options to use, by first looking for the emake make  op-
	      tion,  if	 not present reads the configuration from a file named
	      Emakefile	(see below). If	no such	file is	found, the set of mod-
	      ules  to	compile	defaults to all	modules	in the current working

	      Traversing the set of modules, it	then recompiles	 every	module
	      for which	at least one of	the following conditions apply:

		* there	is no object file, or

		* the  source  file  has  been modified	since it was last com-
		  piled, or,

		* an include file has been modified since the source file  was
		  last compiled.

	      As a side	effect,	the function prints the	name of	each module it
	      tries to compile.	If compilation fails for a  module,  the  make
	      procedure	stops and error	is returned.

	      Options  is  a list of make- and compiler	options. The following
	      make options exist:

		* noexec
		   No execution	mode. Just prints the name of each module that
		  needs	to be compiled.

		* load
		   Load	mode. Loads all	recompiled modules.

		* netload
		   Net	load  mode.  Loads all recompiled modules on all known

		* {emake, Emake}
		   Rather than reading the Emakefile specify configuration ex-

	      All items	in Options that	are not	make options are assumed to be
	      compiler options and are passed as-is to compile:file/2. Options
	      defaults to [].

       files(ModFiles) -> up_to_date | error
       files(ModFiles, Options)	-> up_to_date |	error


		 ModFiles = [Module | File]
		  Module = atom()
		  File = string()
		 Options = [Option]
		  Option = noexec | load | netload | <compiler option>

	      files/1,2	 does  exactly	the  same thing	as all/0,1 but for the
	      specified	ModFiles, which	is a list of module or file names. The
	      file extension .erl may be omitted.

	      The  Emakefile  (if  it  exists)	in  the	 current  directory is
	      searched for compiler options for	each module. If	a given	module
	      does  not	exist in Emakefile or if Emakefile does	not exist, the
	      module is	still compiled.

       make:all/0,1 and	make:files/1,2 first looks for {emake, Emake}  in  op-
       tions,  then  in	 the current working directory for a file named	Emake-
       file. If	present	Emake should contain elements like this:


       Modules is an atom or a list of atoms. It can be

	 * a module name, e.g. file1

	 * a module name in another directory, e.g. ../foo/file3

	 * a set of modules specified with a wildcards,	e.g. 'file*'

	 * a wildcard indicating all modules in	current	directory, i.e.	'*'

	 * a list of any of the	above, e.g. ['file*','../foo/file3','File4']

       Options is a list of compiler options.

       Emakefile is read from top to bottom. If	a module matches more than one
       entry,  the  first match	is valid. For example, the following Emakefile
       means  that  file1  shall   be	compiled   with	  the	options	  [de-
       bug_info,{i,"../foo"}],	while all other	files in the current directory
       shall be	compiled with only the debug_info flag.


Ericsson AB			   tools 3.1			       make(3)


Want to link to this manual page? Use this URL:

home | help