aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/CmakeModule.cpp1
-rw-r--r--src/Conf.cpp23
-rw-r--r--src/FileUtil.cpp27
-rw-r--r--src/GlobalLib.cpp40
-rw-r--r--src/Package.cpp65
-rw-r--r--src/PkgConfig.cpp48
-rw-r--r--src/Version.cpp86
-rw-r--r--src/VersionParser.cpp362
-rw-r--r--src/main.cpp2
9 files changed, 588 insertions, 66 deletions
diff --git a/src/CmakeModule.cpp b/src/CmakeModule.cpp
index 1e873cd..91c572d 100644
--- a/src/CmakeModule.cpp
+++ b/src/CmakeModule.cpp
@@ -239,6 +239,7 @@ namespace sibs
}
}
}
+ return true;
});
// TODO: Clean this up. The below code is indentical to code in Ninja.cpp.......
diff --git a/src/Conf.cpp b/src/Conf.cpp
index a204f13..7ae589e 100644
--- a/src/Conf.cpp
+++ b/src/Conf.cpp
@@ -1,5 +1,6 @@
#include "../include/Conf.hpp"
#include "../include/types.hpp"
+#include "../include/VersionParser.hpp"
#include "../external/utf8/unchecked.h"
#include <iostream>
@@ -482,7 +483,7 @@ namespace sibs
return Result<bool>::Err(errMsg);
}
- if(config.version.empty())
+ if(config.versionStr.empty())
{
string errMsg = "The project ";
errMsg += config.getPackageName();
@@ -670,6 +671,7 @@ namespace sibs
{
if(_tinydir_strcmp(file->extension, CONFIG_STATIC_LIB_FILE_EXTENSION) == 0)
outputFiles.push_back(toUtf8(file->path));
+ return true;
});
}
@@ -747,12 +749,17 @@ namespace sibs
else if(name.equals("version"))
{
if (value.isSingle())
- version = string(value.asSingle().data, value.asSingle().size);
+ versionStr = string(value.asSingle().data, value.asSingle().size);
else
throw ParserException("Expected package.version to be a single value, was a list");
- if(!isVersionStringValid(version))
- throw ParserException("package.version is in invalid format. Version string can only contain numbers and dots");
+ int versionSize = 0;
+ Result<PackageVersion> versionResult = parsePackageVersion(value.asSingle(), &versionSize);
+ if(!versionResult)
+ throw ParserException("package.version is in invalid format, error: " + versionResult.getErrMsg());
+ if(versionSize != (int)versionStr.size())
+ throw ParserException("package.version is in invalid format, expected to only contain numbers and dots");
+ version = versionResult.unwrap();
}
else if(name.equals("authors"))
{
@@ -1025,10 +1032,14 @@ namespace sibs
{
if(value.isSingle())
{
- // TODO: Validate version is number in correct format
+ VersionParser versionParser;
+ Result<PackageVersionRange> dependencyVersionResult = versionParser.parse(value.asSingle().data, value.asSingle().size);
+ if(!dependencyVersionResult)
+ throw ParserException("Dependency " + string(name.data, name.size) + " version is in invalid format, error: " + dependencyVersionResult.getErrMsg());
+
PackageListDependency *dependency = new PackageListDependency();
dependency->name = string(name.data, name.size);
- dependency->version = string(value.asSingle().data, value.asSingle().size);
+ dependency->version = dependencyVersionResult.unwrap();
packageListDependencies.emplace_back(dependency);
}
else if(value.isObject())
diff --git a/src/FileUtil.cpp b/src/FileUtil.cpp
index b41808b..d33c94d 100644
--- a/src/FileUtil.cpp
+++ b/src/FileUtil.cpp
@@ -175,7 +175,11 @@ namespace sibs
tinydir_file file;
tinydir_readfile(&dir, &file);
if(_tinydir_strncmp(file.name, TINYDIR_STRING("."), 1) != 0)
- callbackFunc(&file);
+ {
+ bool doContinue = callbackFunc(&file);
+ if(!doContinue)
+ break;
+ }
tinydir_next(&dir);
}
@@ -193,7 +197,11 @@ namespace sibs
tinydir_file file;
tinydir_readfile(&dir, &file);
if(file.is_reg)
- callbackFunc(&file);
+ {
+ bool doContinue = callbackFunc(&file);
+ if(!doContinue)
+ break;
+ }
tinydir_next(&dir);
}
@@ -201,7 +209,7 @@ namespace sibs
}
// TODO: Handle failure (directory doesn't exist, no permission etc)
- void walkDirFilesRecursive(const _tinydir_char_t *directory, FileWalkCallbackFunc callbackFunc)
+ bool walkDirFilesRecursive(const _tinydir_char_t *directory, FileWalkCallbackFunc callbackFunc)
{
tinydir_dir dir;
tinydir_open(&dir, directory);
@@ -211,13 +219,22 @@ namespace sibs
tinydir_file file;
tinydir_readfile(&dir, &file);
if(file.is_reg)
- callbackFunc(&file);
+ {
+ bool doContinue = callbackFunc(&file);
+ if(!doContinue)
+ return false;
+ }
else if(_tinydir_strncmp(file.name, TINYDIR_STRING("."), 1) != 0)
- walkDirFilesRecursive(file.path, callbackFunc);
+ {
+ bool doContinue = walkDirFilesRecursive(file.path, callbackFunc);
+ if(!doContinue)
+ return false;
+ }
tinydir_next(&dir);
}
tinydir_close(&dir);
+ return true;
}
Result<StringView> getFileContent(const _tinydir_char_t *filepath)
diff --git a/src/GlobalLib.cpp b/src/GlobalLib.cpp
index 242e621..61e6648 100644
--- a/src/GlobalLib.cpp
+++ b/src/GlobalLib.cpp
@@ -8,6 +8,7 @@
#include "../include/CmakeModule.hpp"
#include "../include/Dependency.hpp"
#include "../include/GitRepository.hpp"
+#include "../include/VersionParser.hpp"
using namespace std;
@@ -69,7 +70,7 @@ namespace sibs
// TODO: If return error is invalid url, then the message should be converted to
// invalid package name/version. A check should be done if it is the name or version
// that is invalid.
- Result<bool> downloadDependencyResult = GlobalLib::downloadDependency(globalLibDependency);
+ Result<bool> downloadDependencyResult = GlobalLib::downloadDependency(globalLibDependency, parentConfig.platform);
if(!downloadDependencyResult)
return downloadDependencyResult;
@@ -118,7 +119,7 @@ namespace sibs
return Result<bool>::Ok(true);
}
- Result<bool> GlobalLib::getLibsLinkerFlags(const SibsConfig &parentConfig, const FileString &globalLibRootDir, const std::string &name, const std::string &version, LinkerFlagCallbackFunc staticLinkerFlagCallbackFunc, LinkerFlagCallbackFunc dynamicLinkerFlagCallbackFunc, GlobalIncludeDirCallbackFunc globalIncludeDirCallback)
+ Result<bool> GlobalLib::getLibsLinkerFlags(const SibsConfig &parentConfig, const FileString &globalLibRootDir, const std::string &name, const PackageVersionRange &versionRange, LinkerFlagCallbackFunc staticLinkerFlagCallbackFunc, LinkerFlagCallbackFunc dynamicLinkerFlagCallbackFunc, GlobalIncludeDirCallbackFunc globalIncludeDirCallback)
{
Result<bool> packageExistsResult = validatePackageExists(globalLibRootDir, name);
if (packageExistsResult.isErr())
@@ -126,33 +127,34 @@ namespace sibs
#if OS_FAMILY == OS_FAMILY_POSIX
FileString namePlatformNative = name;
- FileString versionPlatformNative = version;
#else
FileString namePlatformNative = utf8To16(name);
- FileString versionPlatformNative = utf8To16(version);
#endif
FileString packageDir = globalLibRootDir + TINYDIR_STRING("/");
packageDir += namePlatformNative;
- // TODO: Instead of checking if version is exact match, check if package has same major version
- // and same or newer minor version
FileString foundVersion;
- walkDir(packageDir.c_str(), [&foundVersion, &versionPlatformNative](tinydir_file *file)
+ walkDir(packageDir.c_str(), [&foundVersion, &versionRange](tinydir_file *file)
{
if(file->is_dir)
{
- //printf("version: %s\n", file->name);
- if(_tinydir_strcmp(versionPlatformNative.c_str(), file->name) == 0)
+ string versionUtf8 = toUtf8(file->name);
+ Result<PackageVersion> versionResult = parsePackageVersion({ versionUtf8.data(), versionUtf8.size() }, nullptr);
+ if(versionResult && versionRange.isInRange(versionResult.unwrap()))
+ {
foundVersion = file->name;
+ return false;
+ }
}
+ return true;
});
if(foundVersion.empty())
- return Result<bool>::Err("Global lib dependency found, but version doesn't match dependency version", DependencyError::DEPENDENCY_VERSION_NO_MATCH);
+ return Result<bool>::Err("Global lib dependency found, but version isn't in range of version", DependencyError::DEPENDENCY_VERSION_NO_MATCH);
packageDir += TINYDIR_STRING("/");
- packageDir += versionPlatformNative;
+ packageDir += foundVersion;
return GlobalLib::getLibsLinkerFlagsCommon(parentConfig, packageDir, name, staticLinkerFlagCallbackFunc, dynamicLinkerFlagCallbackFunc, globalIncludeDirCallback);
}
@@ -261,13 +263,13 @@ namespace sibs
}
}
- Result<bool> GlobalLib::downloadDependency(PackageListDependency *dependency)
+ Result<bool> GlobalLib::downloadDependency(PackageListDependency *dependency, Platform platform)
{
- Result<string> packageUrlResult = Package::getPackageUrl(dependency->name.c_str(), dependency->version.c_str(), SYSTEM_PLATFORM);
- if(!packageUrlResult)
- return Result<bool>::Err(packageUrlResult);
+ Result<PackageMetadata> packageResult = Package::getPackage(dependency->name.c_str(), dependency->version, platform);
+ if(!packageResult)
+ return Result<bool>::Err(packageResult);
- const string &url = packageUrlResult.unwrap();
+ const PackageMetadata &package = packageResult.unwrap();
Result<FileString> libPathResult = getHomeDir();
if (!libPathResult)
@@ -276,7 +278,7 @@ namespace sibs
libPath += TINYDIR_STRING("/.cache/sibs/lib/");
libPath += toFileString(dependency->name);
libPath += TINYDIR_STRING("/");
- libPath += toFileString(dependency->version);
+ libPath += package.version.toString();
FileString libArchivedFilePath = libPathResult.unwrap();
libArchivedFilePath += TINYDIR_STRING("/.cache/sibs/archive/");
@@ -286,8 +288,8 @@ namespace sibs
return createArchiveDirResult;
libArchivedFilePath += TINYDIR_STRING("/");
- libArchivedFilePath += toFileString(dependency->version);
- Result<bool> downloadResult = curl::downloadFile(url.c_str(), libArchivedFilePath.c_str());
+ libArchivedFilePath += package.version.toString();
+ Result<bool> downloadResult = curl::downloadFile(package.urls[0].c_str(), libArchivedFilePath.c_str());
if(!downloadResult)
return downloadResult;
diff --git a/src/Package.cpp b/src/Package.cpp
index eab0680..925de82 100644
--- a/src/Package.cpp
+++ b/src/Package.cpp
@@ -1,5 +1,6 @@
#include "../include/Package.hpp"
#include "../include/curl.hpp"
+#include "../include/VersionParser.hpp"
#include "../external/rapidjson/error/en.h"
#ifdef GetObject
@@ -37,7 +38,15 @@ namespace sibs
PackageMetadata packageMetadata;
packageMetadata.description.assign(description->value.GetString(), description->value.GetStringLength());
- packageMetadata.version.assign(version->value.GetString(), version->value.GetStringLength());
+
+ int versionStrSize = 0;
+ Result<PackageVersion> versionResult = parsePackageVersion({ version->value.GetString(), version->value.GetStringLength() }, &versionStrSize);
+ if(!versionResult)
+ return Result<PackageMetadata>::Err("package version is in wrong fromat, error: " + versionResult.getErrMsg());
+ if(versionStrSize != (int)version->value.GetStringLength())
+ return Result<PackageMetadata>::Err("package version is in wrong format, expected only numbers and dots (version: " + string(version->value.GetString(), version->value.GetStringLength()) + ")");
+
+ packageMetadata.version = versionResult.unwrap();
const auto &platformsArray = platforms->value.GetArray();
packageMetadata.platforms.reserve(platformsArray.Size());
@@ -50,6 +59,9 @@ namespace sibs
}
const auto &urlsArray = urls->value.GetArray();
+ if(urlsArray.Empty())
+ return Result<PackageMetadata>::Err("Expected url list to not be empty");
+
packageMetadata.urls.reserve(urlsArray.Size());
for(int i = 0; i < urlsArray.Size(); ++i)
{
@@ -62,16 +74,16 @@ namespace sibs
return Result<PackageMetadata>::Ok(packageMetadata);
}
- static Result<string> getPackageUrl(const PackageMetadata &packageMetadata, const char *packageName, const char *packageVersion, Platform platform)
+ static Result<bool> isPackageUsableForPlatform(const PackageMetadata &packageMetadata, const char *packageName, const PackageVersionRange &versionRange, Platform platform)
{
- if(strcmp(packageMetadata.version.c_str(), packageVersion) != 0)
+ if(!versionRange.isInRange(packageMetadata.version))
{
string errMsg = "Package \"";
errMsg += packageName;
- errMsg += "\" does not exist for version \"";
- errMsg += packageVersion;
+ errMsg += "\" does not exist for version range \"";
+ errMsg += versionRange.toString();
errMsg += "\"";
- return Result<string>::Err(errMsg);
+ return Result<bool>::Err(errMsg);
}
if(!containsPlatform(getPlatformsByNames(packageMetadata.platforms), platform))
@@ -79,14 +91,14 @@ namespace sibs
string errMsg = "Package \"";
errMsg += packageName;
errMsg += "\" with version \"";
- errMsg += packageVersion;
+ errMsg += packageMetadata.version.toString();
errMsg += "\" does not support platform \"";
errMsg += platform;
errMsg += "\"";
- return Result<string>::Err(errMsg);
+ return Result<bool>::Err(errMsg);
}
-
- return Result<string>::Ok(packageMetadata.urls[0]);
+
+ return Result<bool>::Ok(true);
}
// TODO: Always downloading is fine right now because the package list is small. This should later be modified to use local cache.
@@ -120,11 +132,11 @@ namespace sibs
return Result<Document*>::Ok(packageList);
}
- Result<string> Package::getPackageUrl(const char *packageName, const char *packageVersion, Platform platform)
+ Result<PackageMetadata> Package::getPackage(const char *packageName, const PackageVersionRange &versionRange, Platform platform)
{
Result<Document*> packageList = Package::getPackageList("https://gitlab.com/DEC05EBA/sibs_packages/raw/master/packages.json");
if(!packageList)
- return Result<string>::Err(packageList);
+ return Result<PackageMetadata>::Err(packageList);
const Document &packageDoc = *packageList.unwrap();
@@ -134,14 +146,18 @@ namespace sibs
string errMsg = "No package with the name \"";
errMsg += packageName;
errMsg += "\" was found";
- return Result<string>::Err(errMsg);
+ return Result<PackageMetadata>::Err(errMsg);
}
if(packageMetaDataJsonIt->value.IsObject())
{
Result<PackageMetadata> packageMetadataResult = getPackageMetadata(packageMetaDataJsonIt->value.GetObject());
- if(!packageMetadataResult) return Result<string>::Err(packageMetadataResult);
- return ::sibs::getPackageUrl(packageMetadataResult.unwrap(), packageName, packageVersion, platform);
+ if(!packageMetadataResult) return packageMetadataResult;
+ Result<bool> packageUsableResult = isPackageUsableForPlatform(packageMetadataResult.unwrap(), packageName, versionRange, platform);
+ if(packageUsableResult)
+ return Result<PackageMetadata>::Ok(packageMetadataResult.unwrap());
+ else
+ return Result<PackageMetadata>::Err(packageUsableResult);
}
else if(packageMetaDataJsonIt->value.IsArray())
{
@@ -155,35 +171,32 @@ namespace sibs
errMsg += "[";
errMsg += to_string(i);
errMsg += "] is not an object";
- return Result<string>::Err(errMsg);
+ return Result<PackageMetadata>::Err(errMsg);
}
Result<PackageMetadata> packageMetadataResult = getPackageMetadata(packageData.GetObject());
- if(packageMetadataResult)
- {
- Result<string> packageUrlResult = ::sibs::getPackageUrl(packageMetadataResult.unwrap(), packageName, packageVersion, platform);
- if(packageUrlResult)
- return packageUrlResult;
- }
+ if(!packageMetadataResult) return packageMetadataResult;
+ if(isPackageUsableForPlatform(packageMetadataResult.unwrap(), packageName, versionRange, platform))
+ return Result<PackageMetadata>::Ok(packageMetadataResult.unwrap());
++i;
}
string errMsg = "Package \"";
errMsg += packageName;
- errMsg += "\" with version \"";
- errMsg += packageVersion;
+ errMsg += "\" in version range \"";
+ errMsg += versionRange.toString();
errMsg += "\" does not exist or does not exist for platform \"";
errMsg += asString(platform);
errMsg += "\"";
- return Result<string>::Err(errMsg);
+ return Result<PackageMetadata>::Err(errMsg);
}
else
{
string errMsg = "No package with the name \"";
errMsg += packageName;
errMsg += "\" was found";
- return Result<string>::Err(errMsg);
+ return Result<PackageMetadata>::Err(errMsg);
}
}
}
diff --git a/src/PkgConfig.cpp b/src/PkgConfig.cpp
index e8f742c..89d3a44 100644
--- a/src/PkgConfig.cpp
+++ b/src/PkgConfig.cpp
@@ -1,6 +1,7 @@
#include "../include/PkgConfig.hpp"
#include "../include/Exec.hpp"
#include "../include/Dependency.hpp"
+#include "../include/VersionParser.hpp"
using namespace std;
@@ -32,9 +33,12 @@ namespace sibs
if(dependencyValidationResult.isErr())
return Result<bool>::Err(dependencyValidationResult.getErrMsg());
- Result<bool> dependencyVersionValidationResult = PkgConfig::validatePackageVersionAtLeast(dependency->name, dependency->version);
- if(dependencyVersionValidationResult.isErr())
- return Result<bool>::Err(dependencyVersionValidationResult.getErrMsg());
+ Result<PackageVersion> dependencyVersionResult = PkgConfig::getPackageVersion(dependency->name);
+ if(!dependencyVersionResult)
+ return Result<bool>::Err(dependencyVersionResult);
+
+ if(!dependency->version.isInRange(dependencyVersionResult.unwrap()))
+ return Result<bool>::Err("pkg-config package " + dependency->name + " exists but the version does not match our expected version range");
return Result<bool>::Ok(true);
}
@@ -70,11 +74,6 @@ namespace sibs
Result<bool> PkgConfig::validatePackageVersionAtLeast(const string &name, const string &version)
{
- // TODO: Instead of checking if package version is same or newer, check if package is same major version
- // and same or newer minor version
-
- // Use --modversion instead and check if the version returned is newer or equal to dependency version.
- // This way we can output installed version vs expected dependency version
FileString command = pkgConfigPath + TINYDIR_STRING(" '--atleast-version=");
command += toFileString(version);
command += TINYDIR_STRING("' '");
@@ -98,7 +97,7 @@ namespace sibs
}
else if(execResult.unwrap().exitCode != 0)
{
- string errMsg = "Failed to check dependency version, Unknown error, exit code: ";
+ string errMsg = "Failed to check pkg-config package version, Unknown error, exit code: ";
errMsg += to_string(execResult.unwrap().exitCode);
return Result<bool>::Err(errMsg);
}
@@ -106,6 +105,37 @@ namespace sibs
return Result<bool>::Ok(true);
}
+ Result<PackageVersion> PkgConfig::getPackageVersion(const std::string &name)
+ {
+ FileString command = pkgConfigPath + TINYDIR_STRING(" --modversion '");
+ command += toFileString(name);
+ command += TINYDIR_STRING("'");
+ Result<ExecResult> execResult = exec(command.c_str());
+ if(!execResult)
+ return Result<PackageVersion>::Err(execResult.getErrMsg());
+
+ if(execResult.unwrap().exitCode == 1)
+ {
+ string errMsg = "Dependency ";
+ errMsg += name;
+ errMsg += " not found in pkg-config";
+ return Result<PackageVersion>::Err(errMsg);
+ }
+ else if(execResult.unwrap().exitCode == 127)
+ {
+ return Result<PackageVersion>::Err("pkg-config is not installed");
+ }
+ else if(execResult.unwrap().exitCode != 0)
+ {
+ string errMsg = "Failed to get pkg-config package version, Unknown error, exit code: ";
+ errMsg += to_string(execResult.unwrap().exitCode);
+ return Result<PackageVersion>::Err(errMsg);
+ }
+
+ // Intentionally allow packages which have a version that contains more data after patch number, since some pkg-config packages are not in semver format
+ return parsePackageVersion({ execResult.unwrap().execStdout.data(), execResult.unwrap().execStdout.size() }, nullptr);
+ }
+
Result<string> PkgConfig::getDynamicLibsLinkerFlags(const vector<PackageListDependency*> &libs)
{
if(libs.empty()) return Result<string>::Ok("");
diff --git a/src/Version.cpp b/src/Version.cpp
new file mode 100644
index 0000000..26e5dbd
--- /dev/null
+++ b/src/Version.cpp
@@ -0,0 +1,86 @@
+#include "../include/Version.hpp"
+#include <cassert>
+
+namespace sibs
+{
+ const char* asString(VersionOperation operation)
+ {
+ switch(operation)
+ {
+ case VersionOperation::LESS: return "<";
+ case VersionOperation::LESS_EQUAL: return "<=";
+ case VersionOperation::EQUAL: return "=";
+ case VersionOperation::GREATER: return ">";
+ case VersionOperation::GREATER_EQUAL: return ">=";
+ default: return "";
+ }
+ }
+
+ std::string PackageVersion::toString() const
+ {
+ std::string result;
+ result += std::to_string(major);
+ result += ".";
+ result += std::to_string(minor);
+ result += ".";
+ result += std::to_string(patch);
+ return result;
+ }
+
+ std::string PackageVersionRange::toString() const
+ {
+ std::string result;
+ result += asString(startOperation);
+ result += start.toString();
+ if(endDefined)
+ {
+ result += " and ";
+ result += asString(endOperation);
+ result += end.toString();
+ }
+ return result;
+ }
+
+ static bool isInRangeOfEnd(const PackageVersionRange &versionRange, const PackageVersion &version)
+ {
+ if(!versionRange.endDefined)
+ return true;
+
+ switch(versionRange.endOperation)
+ {
+ case VersionOperation::LESS:
+ return version < versionRange.end;
+ case VersionOperation::LESS_EQUAL:
+ return version <= versionRange.end;
+ default:
+ assert(false);
+ return true;
+ }
+ }
+
+ bool PackageVersionRange::isInRange(const PackageVersion &version) const
+ {
+ switch(startOperation)
+ {
+ case VersionOperation::LESS:
+ return version < start;
+ case VersionOperation::LESS_EQUAL:
+ return version <= start;
+ case VersionOperation::EQUAL:
+ return version == start;
+ case VersionOperation::GREATER:
+ {
+ if(version <= start)
+ return false;
+ return isInRangeOfEnd(*this, version);
+ }
+ case VersionOperation::GREATER_EQUAL:
+ {
+ if(version < start)
+ return false;
+ return isInRangeOfEnd(*this, version);
+ }
+ }
+ return true;
+ }
+} \ No newline at end of file
diff --git a/src/VersionParser.cpp b/src/VersionParser.cpp
new file mode 100644
index 0000000..7b28cef
--- /dev/null
+++ b/src/VersionParser.cpp
@@ -0,0 +1,362 @@
+#include "../include/VersionParser.hpp"
+#include "../include/StringView.hpp"
+
+namespace sibs
+{
+ static int stringToIntNoVerify(const StringView &str)
+ {
+ int result = 0;
+ if(str.size > 0)
+ result += (str[0] - '0');
+
+ for(int i = 1; i < (int)str.size; ++i)
+ {
+ int num = str[i] - '0';
+ result += (10 * ((int)str.size - i) * num);
+ }
+ return result;
+ }
+
+ static bool isNum(char c)
+ {
+ return c >= '0' && c <= '9';
+ }
+
+ static bool isAlpha(char c)
+ {
+ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+ }
+
+ Result<PackageVersion> parsePackageVersion(const StringView &versionStr, int *size)
+ {
+ PackageVersion result = { 0, 0, 0 };
+ int *versionPtr = &result.major;
+ int digitStart = 0;
+ int i = 0;
+
+ for(; i < (int)versionStr.size; ++i)
+ {
+ char c = versionStr[i];
+ if(isNum(c))
+ {
+ if(digitStart == -1)
+ digitStart = i;
+ }
+ else
+ {
+ int length = i - digitStart;
+ if(digitStart == -1 || length == 0)
+ return Result<PackageVersion>::Err("Package version string is in invalid format. Expected to be in format xxx.xxx.xxx where x is a number");
+
+ *versionPtr = stringToIntNoVerify({ versionStr.data + digitStart, (usize)(i - digitStart) });
+ bool endOfVersions = versionPtr == &result.patch;
+ ++versionPtr;
+ digitStart = -1;
+
+ if(c != '.' || endOfVersions)
+ break;
+ }
+ }
+
+ if(i == 0)
+ return Result<PackageVersion>::Err("version can't be empty");
+
+ if(digitStart != -1)
+ {
+ *versionPtr = stringToIntNoVerify({ versionStr.data + digitStart, (usize)(i - digitStart) });
+ ++versionPtr;
+ }
+
+ if(size)
+ *size = i;
+
+ if(versionPtr == &result.major)
+ return Result<PackageVersion>::Err("version can't be empty");
+
+ return Result<PackageVersion>::Ok(result);
+ }
+
+ VersionTokenizer::VersionTokenizer() :
+ start(nullptr),
+ code(nullptr),
+ size(0),
+ index(0)
+ {
+
+ }
+
+ VersionTokenizer::VersionTokenizer(const char *_start, const usize _size) :
+ start(_start),
+ code(_start),
+ size(_size),
+ index(0)
+ {
+
+ }
+
+ VersionTokenizer::VersionTokenizer(const VersionTokenizer &other)
+ {
+ start = other.start;
+ code = other.code;
+ size = other.size;
+ index = other.index;
+ }
+
+ VersionToken VersionTokenizer::next()
+ {
+ while(index < size)
+ {
+ char c = code[index];
+ if(c == ' ' || c == '\t' || c == '\n' || c == '\r')
+ ++index;
+ else
+ break;
+ }
+
+ if(index >= size)
+ return VersionToken::END_OF_FILE;
+
+ char c = code[index];
+ if(isNum(c))
+ {
+ int versionStrSize = 0;
+ identifier.data = code + index;
+ Result<PackageVersion> packageVersion = parsePackageVersion({ code + index, (usize)(size - index) }, &versionStrSize);
+ identifier.size = versionStrSize;
+ index += versionStrSize;
+ if(!packageVersion)
+ {
+ errMsg = packageVersion.getErrMsg();
+ return VersionToken::INVALID;
+ }
+ version = packageVersion.unwrap();
+ return VersionToken::VERSION_NUMBER;
+ }
+ else if(isAlpha(c))
+ {
+ usize identifierStart = index;
+ ++index;
+ while(index < size && isAlpha(code[index]))
+ {
+ ++index;
+ }
+ usize identifierEnd = index;
+ usize identifierLength = identifierEnd - identifierStart;
+
+ if(identifierLength == 3 && strncmp(code + identifierStart, "and", 3) == 0)
+ {
+ return VersionToken::AND;
+ }
+ else
+ {
+ errMsg = "Invalid identifier ";
+ errMsg += std::string(code + identifierStart, identifierLength);
+ return VersionToken::INVALID;
+ }
+ }
+ else if(c == '<')
+ {
+ ++index;
+ if(index < size && code[index] == '=')
+ {
+ ++index;
+ operation = VersionOperation::LESS_EQUAL;
+ return VersionToken::OPERATION;
+ }
+ operation = VersionOperation::LESS;
+ return VersionToken::OPERATION;
+ }
+ else if(c == '=')
+ {
+ ++index;
+ operation = VersionOperation::EQUAL;
+ return VersionToken::OPERATION;
+ }
+ else if(c == '>')
+ {
+ ++index;
+ if(index < size && code[index] == '=')
+ {
+ ++index;
+ operation = VersionOperation::GREATER_EQUAL;
+ return VersionToken::OPERATION;
+ }
+ operation = VersionOperation::GREATER;
+ return VersionToken::OPERATION;
+ }
+ else
+ {
+ errMsg = "Unexpected character ";
+ errMsg += c;
+ return VersionToken::INVALID;
+ }
+ }
+
+ Result<PackageVersionRange> VersionParser::parse(const char *code, const usize size)
+ {
+ versionRange = PackageVersionRange();
+ tokenizer = VersionTokenizer(code, size);
+ VersionToken token = parseStart();
+
+ if(token == VersionToken::END_OF_FILE)
+ {
+ if(!versionRange.startDefined)
+ return Result<PackageVersionRange>::Err("version can't be empty");
+ return Result<PackageVersionRange>::Ok(versionRange);
+ }
+ else if(token == VersionToken::INVALID)
+ return Result<PackageVersionRange>::Err(tokenizer.errMsg);
+ else
+ {
+ std::string errMsg = "Unexpected token '";
+ switch(token)
+ {
+ case VersionToken::NONE:
+ {
+ errMsg += "<none>";
+ break;
+ }
+ case VersionToken::OPERATION:
+ {
+ errMsg += "operation ";
+ errMsg += asString(tokenizer.operation);
+ break;
+ }
+ case VersionToken::AND:
+ {
+ errMsg += "and";
+ break;
+ }
+ case VersionToken::VERSION_NUMBER:
+ {
+ errMsg += "version ";
+ errMsg += std::string(tokenizer.identifier.data, tokenizer.identifier.size);
+ break;
+ }
+ default:
+ break;
+ }
+ errMsg += "'";
+ return Result<PackageVersionRange>::Err(errMsg);
+ }
+ }
+
+ VersionToken VersionParser::parseStart()
+ {
+ VersionToken token = tokenizer.next();
+ if(token == VersionToken::VERSION_NUMBER)
+ {
+ versionRange.startOperation = VersionOperation::GREATER_EQUAL;
+ versionRange.start = tokenizer.version;
+ versionRange.startDefined = true;
+ token = tokenizer.next();
+ if(token == VersionToken::AND)
+ {
+ token = VersionToken::INVALID;
+ tokenizer.errMsg = "Unexpected end version when start version does not have operation defined";
+ }
+ }
+ else if(token == VersionToken::OPERATION)
+ {
+ versionRange.startOperation = tokenizer.operation;
+ token = tokenizer.next();
+ if(token == VersionToken::VERSION_NUMBER)
+ {
+ versionRange.start = tokenizer.version;
+ versionRange.startDefined = true;
+ switch(versionRange.startOperation)
+ {
+ case VersionOperation::LESS:
+ {
+ token = VersionToken::INVALID;
+ tokenizer.errMsg = "Unexpected version end when start version is expected to less than ";
+ tokenizer.errMsg += versionRange.start.toString();
+ return token;
+ }
+ case VersionOperation::LESS_EQUAL:
+ {
+ token = VersionToken::INVALID;
+ tokenizer.errMsg = "Unexpected version end when start version is expected to be less or equal to ";
+ tokenizer.errMsg += versionRange.start.toString();
+ return token;
+ }
+ case VersionOperation::EQUAL:
+ {
+ token = VersionToken::INVALID;
+ tokenizer.errMsg = "Unexpected version end when start version is expected to be exactly ";
+ tokenizer.errMsg += versionRange.start.toString();
+ return token;
+ }
+ default:
+ break;
+ }
+
+ token = tokenizer.next();
+ if(token == VersionToken::AND)
+ {
+ return parseEnd();
+ }
+ }
+ else if(token == VersionToken::INVALID)
+ return token;
+ else
+ {
+ token = VersionToken::INVALID;
+ tokenizer.errMsg = "Expected version after operation";
+ }
+ }
+ return token;
+ }
+
+ VersionToken VersionParser::parseEnd()
+ {
+ VersionToken token = tokenizer.next();
+ if(token == VersionToken::OPERATION)
+ {
+ versionRange.endOperation = tokenizer.operation;
+ switch(versionRange.endOperation)
+ {
+ case VersionOperation::EQUAL:
+ case VersionOperation::GREATER:
+ case VersionOperation::GREATER_EQUAL:
+ {
+ token = VersionToken::INVALID;
+ tokenizer.errMsg = "End version can only have operations < and <=";
+ return token;
+ }
+ default:
+ break;
+ }
+
+ token = tokenizer.next();
+ if(token == VersionToken::VERSION_NUMBER)
+ {
+ versionRange.end = tokenizer.version;
+ versionRange.endDefined = true;
+ if(versionRange.end <= versionRange.start)
+ {
+ token = VersionToken::INVALID;
+ tokenizer.errMsg = "Expected version end to be greater than ";
+ tokenizer.errMsg += versionRange.start.toString();
+ tokenizer.errMsg += ", was ";
+ tokenizer.errMsg += versionRange.end.toString();
+ return token;
+ }
+ token = tokenizer.next();
+ }
+ else if(token == VersionToken::INVALID)
+ return token;
+ else
+ {
+ token = VersionToken::INVALID;
+ tokenizer.errMsg = "Expected version after operation";
+ }
+ }
+ else
+ {
+ token = VersionToken::INVALID;
+ tokenizer.errMsg = "Expected end version to have operation defined";
+ }
+ return token;
+ }
+}
diff --git a/src/main.cpp b/src/main.cpp
index 4bf840a..5d43679 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1173,7 +1173,7 @@ static int packageProject(int argc, const _tinydir_char_t **argv)
TINYDIR_STRING("\" \"") +
executablePath +
TINYDIR_STRING("\" \"") +
- toFileString(sibsConfig.version) +
+ toFileString(sibsConfig.version.toString()) +
TINYDIR_STRING("\" \"") +
packagePath +
TINYDIR_STRING("\" ") +