aboutsummaryrefslogtreecommitdiff
path: root/butl/standard-version.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'butl/standard-version.cxx')
-rw-r--r--butl/standard-version.cxx161
1 files changed, 97 insertions, 64 deletions
diff --git a/butl/standard-version.cxx b/butl/standard-version.cxx
index 1952653..74a5848 100644
--- a/butl/standard-version.cxx
+++ b/butl/standard-version.cxx
@@ -38,32 +38,32 @@ namespace butl
}
static void
- check_version (uint64_t version, bool snapshot, bool allow_earliest)
+ check_version (uint64_t vr, bool sn, standard_version::flags fl)
{
// Check that the version isn't too large.
//
- // AAABBBCCCDDDE
- bool r (version < 10000000000000ULL);
+ // AAABBBCCCDDDE
+ bool r (vr < 10000000000000ULL);
// Check that E version component is consistent with the snapshot flag.
- // Note that if the allow_earliest flag is true, then E can be 1 for the
+ // Note that if the allow_earliest flag is set, then E can be 1 for the
// snapshot flag being false, denoting the earliest pre-release of the
// version.
//
if (r)
{
- uint64_t e (version % 10);
- if (!allow_earliest)
- r = e == (snapshot ? 1 : 0);
+ uint64_t e (vr % 10);
+ if ((fl & standard_version::allow_earliest) == 0)
+ r = e == (sn ? 1 : 0);
else
- r = e == 1 || (e == 0 && !snapshot);
+ r = e == 1 || (e == 0 && !sn);
}
// Check that pre-release number is consistent with the snapshot flag.
//
if (r)
{
- uint64_t ab (version / 10 % 1000);
+ uint64_t ab (vr / 10 % 1000);
// Note that if ab is 0, it can either mean non-pre-release version in
// the absence of snapshot number, or 'a.0' pre-release otherwise. If ab
@@ -71,14 +71,16 @@ namespace butl
// number.
//
if (ab != 0)
- r = ab != 500 || snapshot;
+ r = ab != 500 || sn;
}
- // Check that the major, the minor and the bugfix versions are not
- // simultaneously zeros.
+ // Check that the major, the minor and the patch versions are not
+ // simultaneously zeros, unless stub is allowed, in which case the snapshot
+ // flag must be false.
//
if (r)
- r = (version / 10000) != 0;
+ r = (vr / 10000) != 0 ||
+ ((fl & standard_version::allow_stub) != 0 && !sn);
if (!r)
throw invalid_argument ("invalid project version");
@@ -87,7 +89,7 @@ namespace butl
// standard_version
//
standard_version::
- standard_version (const std::string& s, bool allow_earliest)
+ standard_version (const std::string& s, flags f)
{
auto bail = [] (const char* m) {throw invalid_argument (m);};
@@ -101,7 +103,10 @@ namespace butl
ep = *e == '~';
}
- size_t p (0);
+ // Note that here and below p is less or equal n, and so s[p] is always
+ // valid.
+ //
+ size_t p (0), n (s.size ());
if (ep)
{
@@ -110,59 +115,70 @@ namespace butl
}
uint16_t ma, mi, bf, ab (0);
+ bool earliest (false);
ma = parse_num (s, p, "invalid major version");
- // Note that here and below p is less or equal n, and so s[p] is always
- // valid.
+ // The only valid version that has no epoch, contains only the major
+ // version being equal to zero, that is optionally followed by the plus
+ // character, is the stub version, unless forbidden. For such a version
+ // we go straight to the package revision parsing.
//
- if (s[p] != '.')
- bail ("'.' expected after major version");
+ bool stub ((f & allow_stub) != 0 && !ep && ma == 0 &&
+ (p == n || s[p] == '+'));
- mi = parse_num (s, ++p, "invalid minor version");
+ if (!stub)
+ {
+ if (s[p] != '.')
+ bail ("'.' expected after major version");
- if (s[p] != '.')
- bail ("'.' expected after minor version");
+ mi = parse_num (s, ++p, "invalid minor version");
- bf = parse_num (s, ++p, "invalid bugfix version");
+ if (s[p] != '.')
+ bail ("'.' expected after minor version");
- // AAABBBCCCDDDE
- version = ma * 10000000000ULL +
- mi * 10000000ULL +
- bf * 10000ULL;
+ bf = parse_num (s, ++p, "invalid patch version");
- if (version == 0)
- bail ("0.0.0 version");
+ // AAABBBCCCDDDE
+ version = ma * 10000000000ULL +
+ mi * 10000000ULL +
+ bf * 10000ULL;
- // Parse the pre-release component if present.
- //
- bool earliest (false);
- if (s[p] == '-')
- {
- char k (s[++p]);
+ if (version == 0)
+ bail ("0.0.0 version");
- if (k == '\0' && allow_earliest) // Dash is the last string character.
- earliest = true;
- else
+ // Parse the pre-release component if present.
+ //
+ if (s[p] == '-')
{
- if (k != 'a' && k != 'b')
- bail ("'a' or 'b' expected in pre-release");
-
- if (s[++p] != '.')
- bail ("'.' expected after pre-release letter");
-
- ab = parse_num (s, ++p, "invalid pre-release", 0, 499);
-
- if (k == 'b')
- ab += 500;
+ char k (s[++p]);
- // Parse the snapshot components if present. Note that pre-release number
- // can't be zero for the final pre-release.
+ // If the last character in the string is dash, then this is the
+ // earliest version pre-release, unless forbidden.
//
- if (s[p] == '.')
- parse_snapshot (s, ++p);
- else if (ab == 0 || ab == 500)
- bail ("invalid final pre-release");
+ if (k == '\0' && (f & allow_earliest) != 0)
+ earliest = true;
+ else
+ {
+ if (k != 'a' && k != 'b')
+ bail ("'a' or 'b' expected in pre-release");
+
+ if (s[++p] != '.')
+ bail ("'.' expected after pre-release letter");
+
+ ab = parse_num (s, ++p, "invalid pre-release", 0, 499);
+
+ if (k == 'b')
+ ab += 500;
+
+ // Parse the snapshot components if present. Note that pre-release
+ // number can't be zero for the final pre-release.
+ //
+ if (s[p] == '.')
+ parse_snapshot (s, ++p);
+ else if (ab == 0 || ab == 500)
+ bail ("invalid final pre-release");
+ }
}
}
@@ -173,7 +189,7 @@ namespace butl
revision = parse_num (s, ++p, "invalid revision", 1, uint16_t (~0));
}
- if (p != s.size ())
+ if (p != n)
bail ("junk after version");
if (ab != 0 || snapshot_sn != 0 || earliest)
@@ -184,18 +200,18 @@ namespace butl
}
standard_version::
- standard_version (uint64_t v, bool allow_earliest)
+ standard_version (uint64_t v, flags f)
: version (v)
{
- check_version (v, false, allow_earliest);
+ check_version (v, false, f);
}
standard_version::
- standard_version (uint64_t v, const std::string& s, bool allow_earliest)
+ standard_version (uint64_t v, const std::string& s, flags f)
: version (v)
{
bool snapshot (!s.empty ());
- check_version (version, snapshot, allow_earliest);
+ check_version (version, snapshot, f);
if (snapshot)
{
@@ -213,14 +229,23 @@ namespace butl
uint64_t sn,
std::string si,
uint16_t rv,
- bool allow_earliest)
+ flags fl)
: epoch (ep),
version (vr),
snapshot_sn (sn),
snapshot_id (move (si)),
revision (rv)
{
- check_version (vr, true, allow_earliest);
+ check_version (vr, true, fl);
+
+ if (stub ())
+ {
+ if (ep != 0)
+ throw invalid_argument ("epoch for stub");
+
+ if (sn != 0)
+ throw invalid_argument ("snapshot for stub");
+ }
if (!snapshot_id.empty () && (snapshot_id.size () > 16 ||
snapshot_sn == 0 ||
@@ -286,6 +311,9 @@ namespace butl
string standard_version::
string_version () const
{
+ if (stub ())
+ return "0";
+
std::string r (to_string (major ()) + '.' + to_string (minor ()) + '.' +
to_string (patch ()));
@@ -395,7 +423,8 @@ namespace butl
try
{
- min_version = standard_version (s.substr (p, e - p), true);
+ min_version = standard_version (s.substr (p, e - p),
+ standard_version::allow_earliest);
}
catch (const invalid_argument& e)
{
@@ -412,7 +441,8 @@ namespace butl
try
{
- max_version = standard_version (s.substr (p, e - p), true);
+ max_version = standard_version (s.substr (p, e - p),
+ standard_version::allow_earliest);
}
catch (const invalid_argument& e)
{
@@ -460,7 +490,10 @@ namespace butl
try
{
- v = standard_version (s.substr (p), operation != comparison::eq);
+ v = standard_version (s.substr (p),
+ operation != comparison::eq
+ ? standard_version::allow_earliest
+ : standard_version::none);
}
catch (const invalid_argument& e)
{