dmake is a tool for building C++ and C programs using the dcc
compiler driver as the underlying build tool. Because dcc itself does
all dependency analysis dmake simply determines what is being built
and invokes dcc accordingly. Compiling and linking if required.
Despite its name dmake is not a make clone and has no relation to
make or tools of its ilk. The name dmake is used to match dcc.
dmake uses the dcc compiler-driver to build modules of different
types. Modules are either programs, called exes, dynamic libraries
or static libraries. The different module types are distinguished by
requiring different commands to create the module's outputs and the
file names of those outputs.
dmake uses dcc to take care of all compilation and library
construction. dmake determines what and how to build and relies upon
dcc's automatic, dependency-based, compilations and library generation.
So dmake is wrapper but it offers some features to the lazy
programmer to reduce their workload. If not told otherwise dmake will
automatically determine the name and type of thing being built,
whether it is a program or a library, and then invokes dcc with
appropriate options to create the program or library. The program
doesn't need to do anything.
Build options are defined using dcc option files, text files that list build options for the different build steps (these files are named using the conventional make-macro name of the corresponding set of options, e.g C compiler options are read from the CFLAGS file, C++ compiler compiler options from CXXFLAGS and so on).
The dmake user-experience is typically a two step thing. The first step is where we create the options files used by dcc to define the compiler and linker options. We can create a .dcc/CXXFLAGS file for compiler options, .dcc/LDFLAGS for linker options. If we're building a program we may create another file, .dcc/LIBS, to define any required libraries.
Once the options files are in place usage is usually just typing the
single word command dmake. It figures out what to do. If it can't
you can tell it with commands like dmake exe and dmake lib clean.
dmake's actions depends upon how it in invoked. It can either infer the module type, executable or library, or can be told the type.
When invoked without arguments dmake attempts to infer the module type by reading the contents of the source files (in the current directory) and looking for a main() function (dmake is C and C++ specific).
A simple regular expresion is used to locate main() and it will fail for more complex incantations, e.g. using macros to define main(), having weird arguments (Amiga) or other such silliness.
dmake first determines the names of all the source files. By default this is the names of the C++ (.cpp or .cc) or C (.c) files in the current directory.
If a file named 'SRCS' exists in the current directory that file is used instead to obtain source file names. A SRCS file contains filenames and/or glob patterns to define the names of the source files. The file allows filenames and patterns to occur on more than one line and allows #-based line comments.
If dmake was invoked without one of the 'exe', 'lib' or 'dll' arguments, dmake reads the source files looking for a main() function. If dmake finds main() it compiles the source files to an executable. If there is no main() dmake creates a static library.
The output name defaults to the name of the current directory, or if that name is "src", the name of the parent directory. Output files are automatically prefixed and suffixed as required, e.g. on UNIX systems static libraries have a 'lib' prefix and '.a' suffix so a directory called "fred" will produce "libfred.a". If the directory already has a 'lib' prefix no extra prefix is added.
Dmake finally invokes dcc to compile the source files and create the output.
If the 'clean' argument is supplied all output files are removed instead of being built.
dmake can be run in a mode to initialize a project and create the
set of files used to control the build - the dcc options files for
the project, a .dmake file if required, and a Makefile to direct
everything and provide a conventional user-experience.
The initcommand is conversational and accepts numerous keyword
arguments to tell it what to do. With no arguments the standard dmake
rules are used to determine the type of project and thing being
inited and outputs corresponding files for dcc.
The keywords recognized by init are as follows,
- exe | lib | dll
Define the type of thing being built instead of inferring it. - c | c++ | objc | objc++
Define the programming language being used rather than being inferred from the names of any source files. - c99 | c11
Define the C language standard being used. Only valid for C language projects. - c++11 | c++14 | c++17 | c++20
Define the C++ language standard being used. Only valid for C++ language projects - debug | release
Define the type of build to perform, debug or release (optimized).
dmake [<options>] [{exe | lib | dll }] [clean]
dmake dirs <pathname>...
dmake init <options>...
-C dir Change to the named directory
before processing. Useful when
invoking dmake from IDEs.
-o name Use 'name' as the base name for the
build output rather than the default
based off the current directory name.
-k Keep going where possible, don't stop
upon the first error.
-v Be more verbose and issue messages.
-dll When automatically creating a library,
because no main function was found in
the sources, create a dynamic library
rather than a static library.
-quiet Pass dcc its --quiet option.
- .dmake
File defining user variables to define the type of thing being built, its name, sources and other build options. - SRCS
Contains pathnames and glob patterns that expand to pathnames that define the source file names. Format is as per dcc "options" files - values written over multiple lines, #-style line comments and blanks ignored.