\chapter{Building NoTA-based software}\label{chap:building}\index{building}

\section{Introduction}

Here, we discuss building software with NoTA. We assume that your using

GNU/Linux or another UNIX-like platform, a C-compiler and the related

development tools (such as {\tt make}\index{make} and {\tt

  pkg-config}\index{\tt pkg-config}) installed. Of course, you'll also need

the NoTA-libraries; for their installation, please refer to

appendix~\ref{chap:installation}.

\section{Building and {\tt pkg-config}}

After you've written your NoTA-based software, you naturally would like to

compile it. Let's assume that we have written an application node in an

implementation file called {\tt an.c}, and the corresponding service node in

{\tt sn.c}. Both live in the same directory.

The easiest way to compile these is to use something like:

\begin{verbatim}

 $ cc -o an an.c `pkg-config --cflags --libs nota-h_in-3.0`

 $ cc -o sn sn.c `pkg-config --cflags --libs nota-h_in-3.0`

\end{verbatim}

After you finished compiling\index{compilation} this (and fixed the almost

unavoidable typing errors in your code), this will generate an executable {\tt

  an}, your application node. Instead of the {\tt nota-h\_in-3.0} above, you

could instead use {\tt nota-h\_in-sp-3.0}, which gives you the {\em single

  process} version.

If you get any errors (from {\tt pkg-config} about not able to find the

libraries, make sure they are listed in the {\tt PKG\_CONFIG\_PATH}. If you

compiled yourself, by default the libraries will go under {\tt /usr/local}. To

use them, you could add {\tt export

PKG\_CONFIG\_PATH="/usr/local/lib/pkgconfig"} to your shell configuration

files. If you install the libraries elsewhere, e.g., under {\tt /opt}, you

will need to update your {\tt PKG\_CONFIG\_PATH}. 

{\tt Important note}: to prevent using the wrong libraries (or wrong library

versions), it's good to run:

\begin{verbatim}

  $ pkg-config  --cflags --libs nota-h_in-3.0 nota-l_in-3.0

\end{verbatim}

The output of that command should tell you where {\tt pkg-config} (and

therefore, the compilation) thinks that your libraries live. It's a common

mistake to use some older version of a library that is still installed.

\textbf{Note:} instead of using \texttt{nota-h\_in-3.0}, you can also use

\texttt{nota-h\_in-sp-3.0}. If you use the latter, your software will be build

with \emph{single-process}\index{single-process}-capabilities, i.e., without

the need for the NoTA-daemon \texttt{nota-ind}. FIXME

\section{Other build options}

How you pass build options to your compilation depends on the details of your

build environment. In general, it should work by putting the compiler flags in

the {\tt CFLAGS} environment variable.

Of course, you can also add other compiler flags; for example, when using the

{\tt gcc}\index{gcc}-compiler, you could set {\tt CFLAGS=''-g -00''} to get a build

with debugging symbols include, and no optimizations. This would be

appropriate for a debug build.

You could also use {\tt CFLAGS=''-g -O2''} to get an optimized build, which is

also a bit harder to debug in a debugger (such as {\tt gdb}), but also

faster. Note that will still include debugging symbols, which makes the

libraries somewhat bigger, but incurs no runtime costs.

\section{Using a Makefile}

Instead of running these compilations 'by hand' all the time, it's a bit more

convenient to use a {\tt Makefile}\index{Makefile}. Again, books have

been written about the wonderful world of {\tt Makefile}s; we do not want to

repeat them here. However, we give a small example, based on the one mentioned

before. Note that lines 4, 7 and 10 should start with a TAB-character.

\begin{lstlisting}[language=make,numbers=none]

all: an sn

an:

        cc -o an an.c `pkg-config --cflags --libs nota-h_in-3.0`   

sn:

        cc -o sn sn.c `pkg-config --cflags --libs nota-h_in-3.0`

clean:

        rm -f an sn *~

\end{lstlisting}

\section{Using autotools, {\tt cmake}, {\tt scons}, {\tt qmake}, ...}

For bigger software project, you probably don't want to use plain Makefiles as

above but instead use a kind of build system. NoTA itself uses {\tt

autotools}, but many other systems exist. We do not go into the details of all

of those, but hope that the instructions in this appendix suffice to make the

build system of your choice, work.