ccbuild

Build everything or the given source.

Collect all objects into an archive. If a version is given, using --pversion, then a shared library is also build and symbolic links will be created. This currently forces the -fPIC argument addition.

Clean everything or the given source.

Recursively remove all "o" directories after removing all .md5 and .o files therein. And removes all .gch files.

List all files this source depends on. It lists three lines seperated by empty lines. The first contains the local dependencies, the second the ignored headers (for the file) and the last contains all global includes needed.

Generate dot graph files for sources on the stdout. If no source filename is given, then for all binary targets in the local directory a .dot file will be created. If the --verbose flag is used the dot graph will also contain all object filenames and their dependencies and lists of ignored headers. Objects will be coloured lightgrey, binary targets lightblue, ignored headers by a red line.

Generate a Makefile on stdout. If no filename is given, an all rule will be generated. Otherwise only the rules for the given file are generated.

Generate an A-A-P file on stdout. If the filename is not given, an "all" rule will be added and all local binary targets will be listed.

EXPERIMENTAL: output will probably change in the future. Generate an ascii art tree of your project files.

Desplay source status and filename on the stdout. Status and source path are seperated with a tab character. Status is either "old" or "ok". When the --verbose flag is used, another tab seperated collumn will be inserted containing a two letter filetype ccbuild identifies it as. This filetype is "bt", "ot", "ih" or "hh" for binary target, object target, internal header and header respectively.

icmake slave mode. This will output used directories, this can be used as a directory or class list within the icmake build script.

Print all unresoved globals onto the stdout followed by a tab character. These can be appended to the ccResolutions file.

MD5 sum all sources needed to compile all binary targets, or the given source on stdout.

Update everything by labeling everything as old.

Get a list of options and commands.

Touch files part of the GNU software standard. They will be touched in ../ except when there is a directory called src in the current directory, then the current directory will be used. This will touch AUTHORS, NEWS, README, INSTALL, COPYING, TODO and ChangeLog.

Simulate, don't really execute any writing commands.

Set the compiler command. The default is "g++".

Set these default compiler arguments, removing the standard default arguments ("-Wall -g"). Mulitple uses of this option are concatenated with spaces.

Change directory before anything else.

Precompile only internal headers. This requires g++ version 3.4 up.

Precompile both internal headers and normal headers. This requires g++ version 3.4 up. When you use internal headers, this will only slow you down. However, when you don't use internal headers, this precompilation is all you've got.

Continue on compiler errors.

Use MD5 hashes to check for file changes. The hashes are store in "o/filename.md5" for every file. These sums are only stored after a clean exit from ccbuild (last line showing "[WR] MD5 data") or a succesfull compilation.

Show command return values per file on stdout. Combine this with "2>/dev/null" appended to the command an you'll have something for real men. This is a total rip-off from Real Man's Compiler Collection http://freshmeat.net/projects/rmcc/

Add this path to the local include search path of ccbuild and the compiler (which will receive the same argument).

This is just like -I, but for the given path and every non-empty directory with a name other then "o".

Set terminal colour to red before executing the command, then reset to normal at the end of it.

Execute this command when the command (pre)compilation returns anything but 0. The first argument given to the command will be relative path to the file the command was executed on (which is either a C++ source or header). If you don't want to use the filename, you can append an echo command like "sleep 2; echo".

This is the same as --exec-on-fail, except it only works when the command returns 0. The first argument given to the command will be the relative path to the file the command was executed on.

Clear the screen just before executing the command (clear per command).

Append this to every command. This can be used to redirect output or set up pipes for compiler output.

Loop the system with one second intervals. This only works for the build command at the moment. All sources who are touched will be reloaded. If a file is removed, the whole source tree is reloaded.

Do not read the first line of ./ccResolutions for extra arguments.

Do not load any ccResolutions files outside of ./ccResolutions. This can be used to create a monolithic ccResolutions file or discover your project's dependencies with the resolve command.

Load the given resolution file before any other.

Set the program version you are working on to version. This is currently only used for the library command. When defined, the library command can make a shared object (.so) and symbolic links by using the version number. It should not contain any filesystem special characters like slashes.

Archive the objects before linking. This should reduce the binary size because it leaves out unused objects.

Show commands and produce more output for dot and check commands.

Output version number on stdout and copyright/license on stderr.

Output in XML where supported. Currently this is only the check command.

Get back to development after a distclean. This will update as much objects as will compile. Which will allow you to focus on the errors in the next ccbuild call.

Precompile internal headers using g++-3.4 and highlight all compiler output. Also give all compiler commands the parameters "-Wall -Wextra -ansi".

Recompiling your project for benchmarking tests.

Graph the dependencies for all programs with colours. Then view these using dotty. This can help you to discover irregular dependencies and what test programs use.

Open all error producing sources in gedit. Very usefull for when you change the interface of a class.

Combine ccbuild with distcc using make. This is a work-around because ccbuild doesn't support multiprocessing.

If all the sources are buildable without any warnings, commit everything to the repository using subversion.

Local configuration which is project specific.

Global configuration file.

The resolution configuration directory. All files in this directory are considered configuration files.