ACDK Make features


An overview to the features of acdkmake.

Content of this chapter:

   Overall purpose
     Construction of acdkmake
       acdmake notation
   Feature Table

 Overall purpose

acdkmake was developed on the background of ACDK, a portable C++ library, which provides an higher level object model and connects several middle ware and scripting technologies.

Building ACDK has several challenges:
  • Supporting multiple platforms.
  • Supporting multiple compilers.
  • Supporting multiple compile modes (debug/release, dynamic/static)
  • Instrumenting sources with meta compiler
  • Automatic self tests
  • Compile again several interpreter (Java, perl, tcl, python)



ACDK uses still a set of lisp files which are interpreted by the  acdk_lisp Man interpreter and generates make files for several platforms.

As long acdkmake cannot create platform make files the acdk_lisp make framework will supported for ACDK.


automake is limited traditional unix environments and not useable for other platforms.


Ant was developed for compiling Java projects and becomes a de facto standard.
Unfortunately Ant has no support for C++.

acdkmake uses some ideas from ant, but differs also in some aspects.

 Construction of acdkmake


The base construct in acdkmake is a Task.
See:  acdk::make::Task.
A Task is simply a class which has an execute method.

An build process is build as an tree of Tasks, starting with the the Task named "default". This Task has children task, which may build executable, and so on.

 acdk.make.ProjectTask ("default").
 -> (depends on) acdk.make.AcdkLibTask("acdk_make").
    ->  acdk.make.LookupFileTask (find matching sources, compiler, etc. ).
    ->  acdk.make.CompileTask ( .cpp -> .o ).
      ->  acdk.make.FileDependTask (check if .c is newer then .o).
      ->  acdk.make.CppSourceDependTask (check .cpp #include).
        ->  acdk.make.FileDependTask (check if .h is newer then .o).
      ->  acdk.make.JobExecuterTask (starts multiple compile tasks parallel).
        ->  acdk.make.ShellExecuteTask ( starts compiler ).
    ->  acdk.make.ShellExecuteTask ( starts linker ).

An important difference to traditional make's the task dependencies are not static, but can be created dynamically by a task. Actually it is up to an Task, which sub-Task it starts.

See on  Tasks for more information about Tasks.

 acdmake notation

Traditional make uses declarative statments with very limited evaluation possibilities. In the execution part of a traditional normally a shell interpreter is used.
Ant uses XML as notation. This has the advantage that it is more general, but XML is not the easiest way to read and write by humans.

acdkmake uses a very simple scripting language, which mainly just invokes ACDK C++ classes (or other DMI server).
 CfgScript is also used by  man acdkmc to code class attributes (see  Meta Attributes).

The main purpose of CfgScript to call ACDK classes via DMI.


If an project needs external ressources, like shared libries, headers, compilers, etc. the build system has to know where to find these files.
In traditional make files the locations of these ressources are often defined as variables at the top of the Makefile or the Makefile asumes that the variables are defined in the environment. The user of the project has to ajust these values fitting to his platform.

Autoconf/automake is a generator, which looks and tests if all prerequistist can be located.
acdkmake merged the configuration step into the build process.

 Feature Table

  • Configuration
    • check environment (ACDKHOME) (done)
    • Check platform and compiler compatibility (done for NT and Linux)
    • find needed tools (done for NT and Linux)
    • find needed header
    • find needed libs
    • setup environment (done for NT and Linux)
    • Conditions (uses scripting engine)
  • Grouping Sources
    • Make list after pattern (done)
  • Variables
    • Overwritable Variables (make cannot overwrite Variables) (done)
    • Evaluation $(VAR) (done)
    • Concenation (done)
    • String Replacement (done)
  • Dependencies Rules
    • Execute Task if file does not exist, is newer. (done)
  • Targets
    • Execute Targets, common in makes. (done)
  • platform abstract standard tasks
    • Compiling (done)
    • Linking (done)
    • support for modification like DEBUG, RELEASE, SHARED, STATIC etc. (done)
    • compile with multiple threads.

  • Generate Sources
    • Start acdkmc depending to change of .h (done)
  • Compile Sources
    • C-header include dependencies (done)
    • Compile java
  • Installing
    • install to directory, generate needed dirs, only write file if newer. (done)
    • chmod to files.
  • Testing
    • setting environment before testing (see also configuration)
    • execute tests and make reports.
  • General purpose Scripting
    • File manipulation
    • statement based scripts
    • contitional and iteration statements
  • Generating Project files
    • generate standard make files (corresponding to current solution)
    • generate Project files for IDEs
  • Generic Targets
    • For common tasks, like Project settings (done for acdk projects)
    • Metatargets with abstract rules

  • Template support for generating files
    • For example for project files (like realized to generate make and project files in current solution).

  • Script integration (done for lisp)
    • Integrate Script elements (list, perl, etc).