<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>

  <meta http-equiv="CONTENT-TYPE" content="text/html; charset=windows-1252">
  <title>Dmake</title>


</head>


<body style="direction: ltr;" lang="en-US">

<h2>Dmake</h2>

<p>Dmake is a make utility similar to <tt>GNU make</tt>
or the Workshop <tt>dmake</tt>.
This utility has an irregular syntax but is available for Linux,
Solaris, Win32 and other platforms. It&nbsp;is&nbsp;used by the
OpenOffice.org build system.</p>

<p>This version of <tt>dmake</tt>
is a modified version of Dennis Vadura's GPL'ed <tt>dmake</tt>.
The original sources were available on
	<a href="http://dmake.wticorp.com/">http://dmake.wticorp.com</a>.
As this site has not been reachable for some time the OpenOffice.org
team adopted this utility but all development on it has been abandoned.</p>

The sources can still be found on GitHub and it can be downloaded
the stand-alone
<a href="https://github.com/jimjag/dmake">Dmake Repository</a>.

	
<p>Added features in dmake (outdated):</p>

<ul>

  <li>
smaller/greater arithmetic like: <br>

    <code>.IF 400&lt;=200</code>
  </li>

  <li>Boolean expressions "or", "and" and nesting thereof:<br>

    <code>.IF
(("$(OS)"=="MACOSX"&amp;&amp;"$(COM)"=="GCC")||"$(OS)"=="LINUX"||"$(OS)"=="SOLARIS")
&amp;&amp; "$(GUIBASE)"=="unx"</code></li>

</ul>

Those are only two examples, read the NEWS file (find links below) for more
features and changes.

<p><b>Note: Beside fixed bugs the dmake versions are downward compatible.</b>
</p>

<h3>Previous version (4.3)</h3>

The OpenOffice.org sources up to version 2.0.2 ship with dmake version 4.3,
the dmake sources can be found in the dmake directory.
See the
 <a href="http://tools.openoffice.org/source/browse/tools/dmake/NEWS?rev=OpenOffice_2_0_2">NEWS</a>
file for a summary of the changes in this version.

<h4>Documentation</h4>
The documentation for the dmake 4.3 version can be found in the
<a href="dmake_4.3.html">dmake 4.3 man</a> page.

<h3>Previous version (4.4)</h3>

OpenOffice.org 2.0.3 ships with the sources of dmake version 4.4.

More information can be found in the
<a href="http://tools.openoffice.org/source/browse/tools/dmake/NEWS?rev=OpenOffice_2_0_3">NEWS</a> and
<a href="http://tools.openoffice.org/source/browse/tools/dmake/ChangeLog?rev=OpenOffice_2_0_3">ChangeLog</a>
files.

<h4>Documentation</h4>
The documentation for the dmake 4.4 version can be found in the
<a href="dmake_4.4.html">dmake 4.4 man</a> page.

<h3>Previous version (4.5)</h3>

Starting from milestone m174 and in the OpenOffice.org 2.0.4
release dmake version 4.5 is included in the OpenOffice.org sources.

More information can be found in the
<a href="http://tools.openoffice.org/source/browse/tools/dmake/NEWS?rev=SRC680_m174">NEWS</a>
and
<a href="http://tools.openoffice.org/source/browse/tools/dmake/ChangeLog?rev=SRC680_m174">ChangeLog</a>
files.

<h4>Documentation</h4>
The documentation for the dmake 4.5 version can be found in the
<a href="dmake_4.5.html">dmake 4.5 man</a> page.

<h3>Stable version (4.6)</h3>

Starting from milestone m186 and in the OpenOffice.org 2.1
release dmake version 4.6 is included in the OpenOffice.org sources.

More information can be found in the
<a href="http://tools.openoffice.org/source/browse/tools/dmake/NEWS?rev=SRC680_m186">NEWS</a>
and
<a href="http://tools.openoffice.org/source/browse/tools/dmake/ChangeLog?rev=SRC680_m186">ChangeLog</a>
files.

<h4>Documentation</h4>
The documentation for the dmake 4.6 version can be found in the
<a href="dmake_4.6.html">dmake 4.6 man</a> page.

<h3>Stable version (4.7)</h3>

Starting from milestone m200 up to m215
dmake version 4.7 is included in the OpenOffice.org sources.
.
More information can be found in the
<a href="http://tools.openoffice.org/source/browse/tools/dmake/NEWS?rev=SRC680_m200">NEWS</a>
and
<a href="http://tools.openoffice.org/source/browse/tools/dmake/ChangeLog?rev=SRC680_m200">ChangeLog</a>
files.

<h4>Documentation</h4>
The documentation for the dmake 4.7 version can be found in the
<a href="dmake_4.7.html">dmake 4.7 man</a> page.

<h3>Stable version (4.8)</h3>

From milestone m216 to m218 dmake version 4.8 is included in the
OpenOffice.org sources.

More information can be found in the
<a href="http://tools.openoffice.org/source/browse/tools/dmake/NEWS?rev=SRC680_m216">NEWS</a>
and
<a href="http://tools.openoffice.org/source/browse/tools/dmake/ChangeLog?rev=SRC680_m216">ChangeLog</a>
files.

<h4>Documentation</h4>
The documentation for the dmake 4.8 version can be found in the
<a href="dmake_4.8.html">dmake 4.8 man</a> page.

<h3>Stable version (4.9)</h3>

From milestone m219 to m233 and in the OpenOffice.org 2.3 and 2.3.1 release
dmake version 4.9 is included in the
OpenOffice.org sources.

More information can be found in the
<a href="http://tools.openoffice.org/source/browse/tools/dmake/NEWS?rev=SRC680_m219">NEWS</a>
and
<a href="http://tools.openoffice.org/source/browse/tools/dmake/ChangeLog?rev=SRC680_m219">ChangeLog</a>
files.

<h4>Documentation</h4>
The documentation for the dmake 4.9 version can be found in the
<a href="dmake_4.9.html">dmake 4.9 man</a> page.

<h3>Version (4.10) was skipped</h3>

This dmake version was skipped to avoid confusion with Version 4.1,
patch level 0 which identified itself as "Version 4.10, PL 0".

<h3>Stable version (4.11)</h3>

From milestone m234 on dmake version 4.11 is included in the
OpenOffice.org sources.

More information can be found in the
<a href="http://tools.openoffice.org/source/browse/tools/dmake/NEWS?rev=1.10">NEWS</a>
and
<a href="http://tools.openoffice.org/source/browse/tools/dmake/ChangeLog?rev=1.9">ChangeLog</a>
files.

<h4>Documentation</h4>
The documentation for the dmake 4.11 version can be found in the
<a href="dmake_4.11.html">dmake 4.11 man</a> page.


<!--
<h3>Development version (4.7-cvs)</h3>
The current development version can be obtained by using the OpenOffice.org
version control system. The development takes place on the <code>dmake47</code>
CWS and can be checked out from the <code>cws_src680_dmake47</code> cvs branch.
Read the
<a href="http://tools.openoffice.org/source/browse/tools/dmake/NEWS?rev=1.6.2.4">NEWS</a>
file of the development version or see the
<a href="http://tools.openoffice.org/source/browse/tools/dmake/ChangeLog?only_with_tag=cws_src680_dmake47">ChangeLog</a>
(click on the latest revision number) file for more in depth information.

<h4>Documentation</h4>
The current documentation for the dmake 4.7 version is available in CVS:
<br>
&nbsp;&nbsp;&nbsp;
<a href="http://tools.openoffice.org/source/browse/*checkout*/tools/dmake/man/dmake.nc?content-type=text%2Fplain&rev=1.6.2.5">man page (ascii)</a>
&nbsp;&nbsp;&nbsp;
<a href="http://tools.openoffice.org/source/browse/*checkout*/tools/dmake/man/dmake.tf?rev=1.8.2.5">man page (troff)</a>.
-->

</body>
</html>
