Convert DIFFPY_VERSION macro back to integer.

C preprocessor cannot compare floating point values,
DIFFPY_VERSION as a float would cause compilation failures.

- multiply DIFFPY_VERSION by 1000 so it is now integer
- add macro DIFFPY_VERSION_PATCH
- change type of libdiffpy_version_info::version back to long long.
  Ensure it can fit full version even for date-based scheme.
- check DIFFPY_VERSION formulas described in version.tpl.

Author: pavoljuhas

site_scons/libdiffpybuildutils.py

@@ -30,7 +30,7 @@ def gitinfo():
     rv['minor'] = int(mx.group(2))
     rv['micro'] = int(mx.group(3) or 0)
     rv['prerelease'] = mx.group(4)
-    rv['number'] = vnum
+    rv['patchnumber'] = vnum
     rv['version'] = vtag
     if vnum:
         rv['version'] += '.post' + str(vnum)

src/diffpy/SConscript.version

@@ -16,19 +16,25 @@ def parsemajorminor(hcode):
 
 def build_VersionCode(target, source, env):
     tplcode = source[0].get_contents()
-    numversion = (1000000 * ginfo['major'] +
-            1000 * ginfo['minor'] + ginfo['micro'] +
-            0.0001 * ginfo['number'])
-    libversion = "%.0f" % numversion
-    if ginfo['number']:
-        libversion = "%.4f" % numversion
+    numversion = ginfo['major']
+    numversion = 1000 * numversion + ginfo['minor']
+    numversion = 1000 * numversion + ginfo['micro']
+    numversion = 1000 * numversion + ginfo['patchnumber']
+    # verify that formulas in version.tpl work as advertised
+    emsg = "Inconsistent value of DIFFPY_VERSION = %i" % numversion
+    assert numversion // 1000000000 == ginfo['major'], emsg
+    assert numversion // 1000000 % 1000 == ginfo['minor'], emsg
+    assert numversion // 1000 % 1000 == ginfo['micro'], emsg
+    assert numversion % 500 == ginfo['patchnumber'], emsg
+    libversion = str(numversion)
     if ginfo['prerelease']:
-        libversion = "(-0.5 + %s)" % libversion
+        libversion = "(-500 + %s)" % libversion
     flds = {
         'DIFFPY_VERSION' : libversion,
         'DIFFPY_VERSION_MAJOR' : ginfo['major'],
         'DIFFPY_VERSION_MINOR' : ginfo['minor'],
         'DIFFPY_VERSION_MICRO' : ginfo['micro'],
+        'DIFFPY_VERSION_PATCH' : ginfo['patchnumber'],
         'DIFFPY_VERSION_STR' : ginfo['version'],
         'DIFFPY_VERSION_DATE' : ginfo['date'],
         'DIFFPY_GIT_SHA' : ginfo['commit'],

src/diffpy/version.cpp

@@ -18,11 +18,16 @@
 
 #include <diffpy/version.hpp>
 
-const double libdiffpy_version_info::version = DIFFPY_VERSION;
+// Append LL suffix to the DIFFPY_VERSION number.
+#define APPEND(x, y) x ## y
+#define LL(x) APPEND(x, LL)
+
+const long long libdiffpy_version_info::version = LL(DIFFPY_VERSION);
 const char* libdiffpy_version_info::version_str = DIFFPY_VERSION_STR;
 const int libdiffpy_version_info::major = DIFFPY_VERSION_MAJOR;
 const int libdiffpy_version_info::minor = DIFFPY_VERSION_MINOR;
 const int libdiffpy_version_info::micro = DIFFPY_VERSION_MICRO;
+const int libdiffpy_version_info::patch = DIFFPY_VERSION_PATCH;
 const char* libdiffpy_version_info::date = DIFFPY_VERSION_DATE;
 const char* libdiffpy_version_info::git_sha = DIFFPY_GIT_SHA;
 

src/diffpy/version.tpl

@@ -17,6 +17,7 @@
 *   DIFFPY_VERSION_MAJOR,
 *   DIFFPY_VERSION_MINOR,
 *   DIFFPY_VERSION_MICRO,
+*   DIFFPY_VERSION_PATCH,
 *   DIFFPY_VERSION_STR,
 *   DIFFPY_VERSION_DATE
 *   DIFFPY_GIT_SHA
@@ -32,15 +33,18 @@
 #define DIFFPY_VERSION_MAJOR ${DIFFPY_VERSION_MAJOR}
 #define DIFFPY_VERSION_MINOR ${DIFFPY_VERSION_MINOR}
 #define DIFFPY_VERSION_MICRO ${DIFFPY_VERSION_MICRO}
+// number of git commits since the last release tag
+#define DIFFPY_VERSION_PATCH ${DIFFPY_VERSION_PATCH}
 
-// round(DIFFPY_VERSION) / 1000000 is the major version
-// round(DIFFPY_VERSION) / 1000 % 1000 is the minor version
-// round(DIFFPY_VERSION) % 1000 is the micro version
-// round(DIFFPY_VERSION * 10000) % 1000
-//      is number of git commits since the last tag
+// DIFFPY_VERSION is an integer representation of a full version:
+//
+// DIFFPY_VERSION / 1000000000 is the major version number
+// DIFFPY_VERSION / 1000000 % 1000 is the minor version number
+// DIFFPY_VERSION / 1000 % 1000 is the micro version number
+// DIFFPY_VERSION % 500 is the patch number
 //
 // alpha and beta releases have smaller DIFFPY_VERSION than
-// a completed release.  Numerical comparison of DIFFPY_VERSION
+// a finalized release.  Numerical comparisons of DIFFPY_VERSION
 // values from two pre-releases may be inaccurate.
 
 #define DIFFPY_VERSION ${DIFFPY_VERSION}
@@ -62,11 +66,12 @@
 
 struct libdiffpy_version_info {
 
-    static const double version;
+    static const long long version;
     static const char* version_str;
     static const int major;
     static const int minor;
     static const int micro;
+    static const int patch;
     static const char* date;
     static const char* git_sha;