POCO C++ Libraries GNU Make Build System
AAAIntroduction

!!!Introduction

The POCO C++ Libraries use a built system based on
[[http://www.gnu.org/software/make/ GNU Make]] on every platform
capable of running it. This includes Linux, Mac OS X, virtually
every other Unix platform, as well as Cygwin and MinGW on Windows.

Why GNU Make? Well, GNU Make is available virtually everywhere
and it's usually readily available, such as on Linux and Mac OS X.
Sure, there are more advanced build systems out there, but the
philosophy for POCO is download -- compile -- go. Requiring the user
to download and install another build tool just for getting
POCO to work is unacceptable.

The build system consists of a number of make files, as well as a few
supporting shell scripts. All core files are located within the <*build*>
directory in the POCO distribution. For every library and executable,
there is a small make file describing the kind of project,
its input files, and the output.

The POCO build system automatically determines the dependencies
between source and header files. This is done when a source file is
compiled for the first time, or after a source file has been changed.
This relieves the developer from the tedious task of maintining file
dependencies manually - one of the biggest drawbacks of GNU Make.


!!Build System Features

The POCO build system supports the following features:

  * building libraries, applications and plugins
  * debug and release builds
  * dynamic and static linking
  * 32-bit and 64-bit builds
  * automatic dependency detection
  * easy to use
  * support for cross-compiling for embedded platforms
    such as Embedded Linux or iOS


!!Build System Overview

The core of the build system consists of three different kinds of files --
platform configuration files, make rules and shell scripts. All are located
in the <*build*> directory within the POCO C++ Libraries root directory.

  build/
    config/
      Darwin
      Linux
      HP-UX
      ...

    rules/
      compile
      dylib
      exec
      global
      lib

    script/
      makedepend.gcc
      makedepend.cxx
      makedepend.SunCC
      makeldpath
      projname
      shlibln
      ...
----


!Configuration Files

Configuration files contain all the knowledge how the toolchain (compiler and linker)
must be invoked for a given platform. Configuration files for the most common
Unix platforms and their toolchains, as well as for Cygwin and MinGW are already
part of POCO.
Support for an additional platform (or a variation of a platform) can be added
by creating a new (or copying and modifying) an existing build configuration file.

Configuration files are located in the <*build/config*> directory.


!Rule Files

Rule files contain platform independent make rules for compiling and
linking executables or (static and shared) libraries from source files,
using the tools defined in a configuration file. Rule files are located
in the <*build/rules*> directory.


!Script Files

Script files are called by the build system's make files to do things that
cannot be expressed in make files. For example, there are scripts for
invoking a particular C++ compiler in such a way that it produces a list of
dependencies for later inclusion by the build system. Script files are
located in the <*build/script*> directory.



!!Filesystem Layout

!Sources

The build system expects a project's files (header files, source files, Makefiles)
to be in a certain directory layout.
First, all project directories must be located in or under the same directory where the
<*build*> directory is located, or in a directory below.
All header files must be in the <*include*> directory (or a subdirectory of it).
All source files must be in the <*src*> directory.
Finally, there must be a Makefile (named <*Makefile*>) located in the project directory.

Below is a sample for a POCO source directory hierarchy:

  poco/
    build/
    Foundation/
    Net/
    Util/
    XML/
    ...

    MyLib/
      include/
        MyLib.h
        MyClass.h

      src/
        MyClass.cpp

      Makefile
----


!Build Products

The POCO build system puts final build products (executables and libraries)
and intermediate products (object files, dependency files) into certain directories.
Unless specified otherwise (by setting the environment variable
POCO_BUILD accordingly -- see below), these directories are located within
the source directory tree. All libraries are put into a
directory with the path <*lib/<OSNAME>/<OSARCH>*>, within the POCO base directory.
Executables are put into a directory with the path <*bin/<OSNAME>/<OSARCH>*>,
within the project directory. Object files are put into a directory with the
path <*obj/<OSNAME>/<OSARCH>*>, within the project directory.
Dependency files are put into <*.dep/<OSNAME>/<OSARCH>*>,
also within the project directory.

Unless specified otherwise (by setting the Makefile variables
<[$(POCO_TARGET_OSNAME)]> and <[$(POCO_TARGET_OSARCH)]>, <*<OSNAME>*> is the
name of the host's operating system, as obtained by a call to
<*uname*> (or something equivalent), and <*<OSARCH>*> is the name of the
host's hardware architecture, as obtained by a call to <*uname -m*>
(or something equivalent).

Taking into account the build products, a typical project hierarchy looks like this:


  poco/
    build/
    lib/
      Linux/
        i686/
          libCppUnit.so.1
          libCppUnitd.so.1
          libCppUnit.so
          libCppUnitd.so
          libPocoFouncation.so.1
          ...

    Foundation/
      ...
      testsuite/
        ...
        bin/
          Linux/
            i686/
              testrunner
              testrunnerd
              ...

    Net/
    Util/
    XML/
    ...

    MyLib/
      .dep/
        Linux/
          i686/
            MyClass.d

      obj/
        Linux/
          i686/
            MyClass.o

      include/
        MyLib.h
        MyClass.h

      src/
        MyClass.cpp

      Makefile
----


!!Project Makefiles

Depending on the kind of project, a project Makefile comes in one of three variants.


!Library Makefiles

The Makefile for a library always looks like this:

  #
  # Makefile for a library
  #

  include $(POCO_BASE)/build/rules/global

  objects = MyClass ...

  target = MyLib
  target_version = 1
  target_libs = PocoFoundation ...

  include $(POCO_BASE)/build/rules/lib
----


Every Makefile always has to include <*$(POCO_BASE)/build/rules/global*> first.
In the <*objects*> section, the source files (located in the <*src*> directory)
must be specified. The file extension must not be included; the build system
will find files ending in .cpp (C++ sources) and .c (C sources).
<*target*> specifies the name of the library, <*target_version*> specifies the
version number for the shared library. <*target_libs*> specifies the
libraries required for linking the library.

Last in the Makefile is the inclusion of <*$(POCO_BASE)/build/rules/lib*>,
which includes the rules for building a shared or static library.


!Executable Makefiles

Makefiles for executables look similar to the ones for libraries.


  #
  # Makefile for a library
  #

  include $(POCO_BASE)/build/rules/global

  objects = MyClass ...

  target = MyLib
  target_libs = PocoFoundation ...

  include $(POCO_BASE)/build/rules/exec
----



The only differences are the missing <*target_version*> entry, and the
<*$(POCO_BASE)/build/rules/exec*> file, which is included instead of
<*$(POCO_BASE)/build/rules/lib*> at the end of the Makefile.



!Plugin Makefiles



Makefiles for plugins - shared libraries that are loadable dynamically at runtime - again look almost the same as Makefiles for ordinary libraries or executables.

  #
  # Makefile for a library
  #

  include $(POCO_BASE)/build/rules/global

  objects = MyClass ...

  target = MyPlugin
  target_libs = PocoFoundation ...

  include $(POCO_BASE)/build/rules/dylib
----


The difference is the file that is included at the end of the Makefile:
<*$(POCO_BASE)/build/rules/dylib*>.


!!!Build System Reference

!!Postbuild Command

A Makefile can contain a so-called postbuild command -- a shell command
that will be executed when the target has been built successfully.
To specify a postbuild command, define the variable <*postbuild*>
in your Makefile, e.g.

  #
  # Makefile for a library
  #

  include $(POCO_BASE)/build/rules/global

  objects = MyClass ...

  target = MyLib
  target_libs = PocoFoundation ...

  postbuild = echo "The build is done."

  include $(POCO_BASE)/build/rules/exec
----


!!Make Targets

Independently of which kind of product (library, executable, plugin) is
being built, there are always five make targets available:
Note that these targets are only available in project-level Makefiles, not
the global Makefile.

!clean

The <*clean*> target will remove all executable and intermediate object files,
forcing a full rebuild with the next make.


!all

<*all*> is the default target, used if no other target is specified.
Depending on the current configuration, it will either build a statically linked or
dynamically linked library/executable, or both.


!static_debug

The <*static_debug*> target will build a statically linked debug version of
the library or executable. Statically linked executables will be linked
in the <*static*> subdirectory within the <*bin/<OSNAME>/<OSARCH>*> directory.
Debug libraries and executables have a 'd' appended to their basename
(e.g., MyLibd.so).


!static_release

The <*static_release*> target will build a statically linked release
version of the library or executable.


!shared_debug

The <*shared_debug*> target will build a dynamically linked debug version
of the library or executable. The library or executable will
have the suffix <*d*> appended to its name (e.g., if target is MyExec,
the actual name of the executable will be MyExecd).


!shared_release

The <*shared_release*> target will build a dynamically linked release
version of the library or executable.


!!Environment Variables

The POCO build system requires or uses certain environment variables to work properly.

!POCO_BASE

<*POCO_BASE*> is required and specifies the directory where the POCO
source tree is located.


!POCO_BUILD

<*POCO_BUILD*> specifies the directory where the build system puts all
intermediate build files (object files, dependency files) and build
products (libraries and executables). Normally, these files are located
within the POCO source tree. Setting POCO_BUILD allows to keep the POCO
source tree clean and free of binaries.


!POCO_CONFIG

<*POCO_CONFIG*> specifies the build configuration file (located in build/config)
to use. Defaults to the output of <*uname*> if not specified.


!POCO_TARGET_OSNAME and POCO_TARGET_OSARCH

<*POCO_TARGET_OSNAME*> and >*POCO_TARGET_OSARCH*> are used in
cross builds, to specify the operating system name and hardware
architecture of the target. These names is used to find the directory
where intermediate object files and final build products are put.
Intermediate files are always put into <*obj/<OSNAME>/<OSARCH>*>
and final build products are put into <*lib/<OSNAME>/<OSARCH>*>, or
<*bin/<OSNAME>/<OSARCH>*>, respectively.
If <*POCO_TARGET_OSNAME*> is specified, its value becomes the
value for <*<OSNAME>*>. If <*POCO_TARGET_OSARCH*> is specified, its value
likewise becomes the value for <*<OSARCH>*>

The default value for <*<OSNAME>*> is the output of <*uname*> or a
similar command.
The default value for <*<OSARCH>*> is the output of <*uname -m*> or a
similar command.


!OSARCH_64BITS

If defined to 1, will force a 64 bit build on platforms that support 64 bit builds.


!PROJECT_BASE


Setting this environment variable allows you to use the build system to
build POCO-based libraries and executables outside the POCO_BASE directory
hierarchy. Given a directory <*/projects*> containing a project directory
<*MyProject*> (that is, <*/projects/MyProject*>), <*PROJECT_BASE*>
must be set to <*/projects*>. Assuming <*/projects/MyProject/Makefile*>
is available, you can change to the <*/projects/MyProject*> directory and
invoke <*gmake*> to build your project. <*POCO_BASE*> must still be set
and point to the POCO source tree, as usual.


!!Special Files

!components

The build system requires a file named <*components*> being located in
<*$(POCO_BASE)*>. This file contains a list of project names, one per line.
The contents of this file are used by the build system to automatically
build include search paths. For example, if <*components*> has the following content:

  Foundation
  XML
  Util
  Net
----

the following include search path options will be used for compiling:

  -I$(POCO_BASE)/Foundation/include -I$(POCO_BASE)/XML/include -I$(POCO_BASE)/Util/include -I$(POCO_BASE)/Net/include
----


If a new library is being added to POCO, a corresponding entry should be made in the <*components*> file, so that the compiler can find its header files.


!libversion

The content of the file <*libversion*>, located in <*$(POCO_BASE)*>,
will be stored in the variable <*$(LIBVERSION)*>. This variable can be used
in a Makefile as the value for the <*target_version*> variable.


!Configuring the Build Process

The build process is configured by build configuration files,
located in the <*build/config*> directory.
Unless specified otherwise, by setting the <*POCO_CONFIG*>
environment variable accordingly, the build system selects the
build configuration file with the same name as the host's
operating system (output of <*uname*>). If you need support for a
new operating system, or just need to customize an existing configuration,
you'll usually create a new build configuration file (by copying an existing one).

    A typical build configuration file looks like this:

    #
    # Linux
    #
    # Make settings for Linux 2.6/gcc 3.3
    #
    #

    #
    # General Settings
    #
    LINKMODE = SHARED

    #
    # Define Tools
    #
    CC      = gcc
    CXX     = g++
    LINK    = $(CXX)
    LIB     = ar -cr
    RANLIB  = ranlib
    SHLIB   = $(CXX) -shared -Wl,-soname,$(notdir $@) -o $@
    SHLIBLN = $(POCO_BASE)/build/script/shlibln
    STRIP   = strip
    DEP     = $(POCO_BASE)/build/script/makedepend.gcc
    SHELL   = sh
    RM      = rm -rf
    CP      = cp
    MKDIR   = mkdir -p

    #
    # Extension for Shared Libraries
    #
    SHAREDLIBEXT     = .so.$(target_version)
    SHAREDLIBLINKEXT = .so

    #
    # Compiler and Linker Flags
    #
    CFLAGS          =
    CFLAGS32        =
    CFLAGS64        =
    CXXFLAGS        = -Wall -Wno-sign-compare
    CXXFLAGS32      =
    CXXFLAGS64      =
    LINKFLAGS       =
    LINKFLAGS32     =
    LINKFLAGS64     =
    STATICOPT_CC    =
    STATICOPT_CXX   =
    STATICOPT_LINK  = -static
    SHAREDOPT_CC    = -fPIC
    SHAREDOPT_CXX   = -fPIC
    SHAREDOPT_LINK  = -Wl,-rpath,$(LIBPATH)
    DEBUGOPT_CC     = -g -D_DEBUG
    DEBUGOPT_CXX    = -g -D_DEBUG
    DEBUGOPT_LINK   = -g
    RELEASEOPT_CC   = -O2 -DNDEBUG
    RELEASEOPT_CXX  = -O2 -DNDEBUG
    RELEASEOPT_LINK = -O2

    #
    # System Specific Flags
    #
    SYSFLAGS = -D_XOPEN_SOURCE=500 -D_REENTRANT -D_THREAD_SAFE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -DPOCO_HAVE_FD_EPOLL

    #
    # System Specific Libraries
    #
    SYSLIBS  = -lpthread -ldl -lrt
----

The various settings in the build configuration file are described below.

!!General Settings

!LINKMODE

This specifies the default link mode, which can have the values
<*STATIC*>, <*SHARED*> or <*BOTH*>.


!TOOL

For cross builds, <*TOOL*> specifies the prefix for the toolchain executables, e.g.

  TOOL = arm-unknown-linux-gnu
----

<*TOOL*> can later be used in the tool section, as in:

  CC  = $(TOOL)-gcc
  CXX = $(TOOL)-g++
  ...
----


!POCO_TARGET_OSNAME and POCO_TARGET_OSARCH

The general settings section is also the right place to define
<*POCO_TARGET_OSNAME*> and <*POCO_TARGET_OSARCH*> for cross builds.


!!Tool Definition

!CC

<*CC*> specifies the command for invoking the C compiler.


!CXX

<*CXX*> specifies the command for invoking the C++ compiler.


!LINK

<*LINK*> specifies the command for invoking the link editor.


!STRIP

<*STRIP*> specifies the command for invoking the strip utility.


!LIB

<*LIB*> specifies the command for invoking the library archiver utility.


!RANLIB

<*RANLIB*> specifies the command for invoking the library table of contents updater
utility.


!SHLIB

<*SHLIB*> specifies the command for creating shared libraries.


!SHLIBLN

<*SHLIBLN*> specifies the command for creating shared library
symbolic links (e.g. <*libPocoFoundation.so*> -> <*libPocoFoundation.so.1*>)


!DEP

<*DEP*> specifies the command for creating or updating the dependencies. This
is usually a shell script invoking the C/C++ compiler in a special way to generate
a list of dependencies.


!SHELL

<*SHELL*> specifies the command for invoking the POSIX shell.


!RM

<*RM*> specifies the command for deleting files and directories.


!CP

<*CP*> specifies the command for copying files.


!MKDIR

<*MKDIR*> specifies the command for creating directories.


!!Shared Library Extensions

!SHAREDLIBEXT

<*SHAREDLIBEXT*> specifies the extension for shared libraries.
This usually includes a version number (e.g. <*.so.1*>).


!SHAREDLIBLINKEXT

<*SHAREDLIBLINKEXT*> specifies the extension for shared library
symbolic links. (e.g., <*.so*>)


!!Compiler and Linker Flags

!CFLAGS

<*CFLAGS*> specifies additional flags passed to the C compiler.


!CFLAGS32

<*CFLAGS32*> specifies additional flags passed to the C compiler
if compiling in 32 bit mode.


!CFLAGS64

<*CFLAGS64*> specifies additional flags passed to the C compiler
if compiling in 64 bit mode.


!CXXFLAGS

<*CXXFLAGS*> specifies additional flags passed to the C++ compiler.


!CXXFLAGS32

<*CXXFLAGS32*> specifies additional flags passed to the C++ compiler if
compiling in 32 bit mode.


!CXXFLAGS64

<*CXXFLAGS64*> specifies additional flags passed to the C++ compiler if
compiling in 64 bit mode.


!LIBFLAGS

<*LIBFLAGS*> specifies additional flags passed to the linker when building
a static library.


!LIBFLAGS32

<*LIBFLAGS32*> specifies additional flags passed to the linker when building
a static library if compiling in 32 bit mode.


!LIBFLAGS64

<*LIBFLAGS64*> specifies additional flags passed to the linker when building
a static library if compiling in 64 bit mode.


!SHLIBFLAGS

<*SHLIBFLAGS*> specifies additional flags passed to the linker when building
a shared library.


!SHLIBFLAGS32

<*SHLIBFLAGS32*> specifies additional flags passed to the linker when building
a shared library if compiling in 32 bit mode.


!SHLIBFLAGS64

<*SHLIBFLAGS64*> specifies additional flags passed to the linker when building
a shared library if compiling in 64 bit mode.


!DYLIBFLAGS

<*DYLIBFLAGS*> specifies additional flags passed to the linker when building
a dynamically loadable shared library.


!DYLIBFLAGS32

<*DYLIBFLAGS32*> specifies additional flags passed to the linker when building
a dynamically loadable shared library if compiling in 32 bit mode.


!DYLIBFLAGS64

<*DYLIBFLAGS64*> specifies additional flags passed to the linker when building
a dynamically loadable shared library if compiling in 64 bit mode.


!LINKFLAGS

<*LINKFLAGS*> specifies additional flags passed to the linker when building
an executable.


!LINKFLAGS32

<*LINKFLAGS32*> specifies additional flags passed to the linker when building
an executable if compiling in 32 bit mode.


!LINKFLAGS64

<*LINKFLAGS64*> specifies additional flags passed to the linker when building
an executable if compiling in 64 bit mode.


!STATICOPT_CC

<*STATICOPT_CC*> specifies additional flags passed to the C compiler
if compiling for static linking.


!STATICOPT_CXX

<*STATICOPT_CXX*> specifies additional flags passed to the C++ compiler if
compiling for static linking.


!STATICOPT_LINK

<*STATICOPT_LINK*> specifies additional flags passed to the linker for
static linking.


!SHAREDOPT_CC

<*SHAREDOPT_CC*> specifies additional flags passed to the C compiler
for dynamic linking.


!SHAREDOPT_CXX

<*SHAREDOPT_CXX*> specifies additional flags passed to the C++ compiler if
compiling for dynamic linking.


!SHAREDOPT_LINK

<*SHAREDOPT_LINK*> specifies additional flags passed to the linker for dynamic linking.


!DEBUGOPT_CC

<*DEBUGOPT_CC*> specifies additional flags passed to the C compiler if compiling in debug mode.


!DEBUGOPT_CXX

<*DEBUGOPT_CXX*> specifies additional flags passed to the C++ compiler if compiling in debug mode.


!DEBUGOPT_LINK

<*DEBUGOPT_LINK*> specifies additional flags passed to the linker if linking in debug mode.


!RELEASEOPT_CC

<*RELEASEOPT_CC*> specifies additional flags passed to the C compiler if compiling in release mode.


!RELEASEOPT_CXX

<*RELEASEOPT_CXX*> specifies additional flags passed to the C++ compiler if compiling in release mode.


!RELEASEOPT_LINK

<*RELEASEOPT_LINK*> specifies additional flags passed to the linker if linking in release mode.


!!System Specific Flags

!SYSFLAGS

<*SYSFLAGS*> specifies flags passed to both the C and C++ compiler. This usually contains system-specific include paths and settings such as -D_XOPEN_SOURCE=500 or -D_THREAD_SAFE.


!SYSLIBS

<*SYSLIBS*> specifies flags passed to the linker. Usually, this flags specify system-specific libraries, such as -lpthread or -ldl.
