An overview to the features of acdkmake.
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.
The base construct in acdkmake is a 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.
-> (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.
Traditional make uses declarative statments with
very limited evaluation possibilities. In the execution
part of a traditional normally a shell interpreter is
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
user of the project has to ajust these values fitting to his
Autoconf/automake is a generator, which looks and tests if all
prerequistist can be located.
acdkmake merged the configuration step into the build process.
- 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)
- 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)
- 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
- install to directory, generate needed dirs, only write file if newer. (done)
- chmod to files.
- 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).