wash/ropkg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

meta: replace bluelib with fx

Browse Source
This commit is contained in:
max 🍓
2026-06-22 17:45:54 +01:00
parent 4190a5c54a
commit c6c4b0c1f9
81 changed files with 3933 additions and 1349 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libropkg/version.c
+95 -85
View File
@@ -1,7 +1,7 @@
#include "version.h"
#include <blue/core/stringstream.h>
#include <ctype.h>
#include <fx/stringstream.h>
#include <stdlib.h>
#include <string.h>
@@ -14,10 +14,10 @@ enum ropkg_status ropkg_version_create(struct ropkg_version **out)
memset(version, 0x0, sizeof *version);
version->v_release_phase = ROPKG_VERSION_RELEASE_PHASE_RELEASE;
version->v_unref_phase = ROPKG_VERSION_RELEASE_PHASE_RELEASE;
version->v_upstream_version[0] = 1;
version->v_version_release_phase = ROPKG_VERSION_RELEASE_PHASE_RELEASE;
version->v_version_release_phase_revision = 1;
version->v_version_unref_phase = ROPKG_VERSION_RELEASE_PHASE_RELEASE;
version->v_version_unref_phase_revision = 1;
version->v_package_revision = 1;
*out = version;
@@ -29,9 +29,9 @@ void ropkg_version_destroy(struct ropkg_version *version)
free(version);
}
static b_result parse_release_phase(
static fx_result parse_unref_phase(
const char *s,
enum ropkg_version_release_phase *out)
enum ropkg_version_unref_phase *out)
{
if (s[0] == 0) {
*out = ROPKG_VERSION_RELEASE_PHASE_RELEASE;
@@ -40,24 +40,24 @@ static b_result parse_release_phase(
} else if (!strcmp(s, "beta")) {
*out = ROPKG_VERSION_RELEASE_PHASE_BETA;
} else {
b_result result = b_error_with_msg_template(
fx_result result = fx_error_with_msg_template(
ROPKG_ERROR_VENDOR,
ROPKG_ERR_INVALID_VERSION_FORMAT,
ROPKG_EMSG_INVALID_RELEASE_PHASE,
B_ERROR_PARAM("phase", s));
b_error_add_submsg(
FX_ERROR_PARAM("phase", s));
fx_error_add_submsg(
result,
B_ERROR_SUBMSG_INFO,
FX_ERROR_SUBMSG_INFO,
ROPKG_EMSG_AVAILABLE_RELEASE_PHASES);
return result;
}
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
static b_result parse_version_release_phase(
static fx_result parse_version_unref_phase(
const char *s,
enum ropkg_version_release_phase *out_phase,
enum ropkg_version_unref_phase *out_phase,
unsigned int *out_revision,
size_t *nr_read)
{
@@ -67,14 +67,14 @@ static b_result parse_version_release_phase(
*out_phase = ROPKG_VERSION_RELEASE_PHASE_RELEASE;
*out_revision = 1;
*nr_read = i;
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
if (*s == '~') {
i++;
s++;
} else {
return b_error_with_msg(
return fx_error_with_msg(
ROPKG_ERROR_VENDOR,
ROPKG_ERR_INVALID_VERSION_FORMAT,
ROPKG_EMSG_INVALID_VERSION_RELEASE_PHASE_UNKNOWN_START);
@@ -97,14 +97,14 @@ static b_result parse_version_release_phase(
} else if (!strcmp(temp, "rc")) {
*out_phase = ROPKG_VERSION_RELEASE_PHASE_RC;
} else {
b_result result = b_error_with_msg_template(
fx_result result = fx_error_with_msg_template(
ROPKG_ERROR_VENDOR,
ROPKG_ERR_INVALID_VERSION_FORMAT,
ROPKG_EMSG_INVALID_VERSION_RELEASE_PHASE,
B_ERROR_PARAM("phase", temp));
b_error_add_submsg(
FX_ERROR_PARAM("phase", temp));
fx_error_add_submsg(
result,
B_ERROR_SUBMSG_INFO,
FX_ERROR_SUBMSG_INFO,
ROPKG_EMSG_AVAILABLE_VERSION_RELEASE_PHASES);
return result;
}
@@ -123,10 +123,10 @@ static b_result parse_version_release_phase(
}
*nr_read = i;
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
static b_result parse_package_revision(
static fx_result parse_package_revision(
const char *s,
unsigned int *out_revision,
size_t *nr_read)
@@ -136,14 +136,14 @@ static b_result parse_package_revision(
if (*s == '\0') {
*out_revision = 1;
*nr_read = i;
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
if (*s == '-') {
i++;
s++;
} else {
return b_error_with_msg(
return fx_error_with_msg(
ROPKG_ERROR_VENDOR,
ROPKG_ERR_INVALID_VERSION_FORMAT,
ROPKG_EMSG_INVALID_PACKAGE_REVISION_UNKNOWN_START);
@@ -163,16 +163,16 @@ static b_result parse_package_revision(
*out_revision = strtoul(temp, &ep, 10);
*nr_read = i;
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
static b_result parse_upstream_version(
static fx_result parse_upstream_version(
const char *s,
unsigned int out[ROPKG_VERSION_UPSTREAM_DIGIT_MAX],
size_t *nr_read)
{
if (!isdigit(*s)) {
return b_error_with_msg(
return fx_error_with_msg(
ROPKG_ERROR_VENDOR,
ROPKG_ERR_INVALID_VERSION_FORMAT,
ROPKG_EMSG_INVALID_UPSTREAM_VERSION_UNKNOWN_START);
@@ -197,14 +197,14 @@ static b_result parse_upstream_version(
if (s[i] == '.') {
if (nr_temp == 0) {
return b_error_with_msg(
return fx_error_with_msg(
ROPKG_ERROR_VENDOR,
ROPKG_ERR_INVALID_VERSION_FORMAT,
ROPKG_EMSG_INVALID_UPSTREAM_VERSION_TWO_DOTS);
}
if (nr_digits >= ROPKG_VERSION_UPSTREAM_DIGIT_MAX - 1) {
return b_error_with_msg(
return fx_error_with_msg(
ROPKG_ERROR_VENDOR,
ROPKG_ERR_INVALID_VERSION_FORMAT,
ROPKG_EMSG_INVALID_UPSTREAM_VERSION_TOO_MANY_NUMBERS);
@@ -218,7 +218,7 @@ static b_result parse_upstream_version(
}
if (nr_temp == 0) {
return b_error_with_msg(
return fx_error_with_msg(
ROPKG_ERROR_VENDOR,
ROPKG_ERR_INVALID_VERSION_FORMAT,
ROPKG_EMSG_INVALID_UPSTREAM_VERSION_END_DOT);
@@ -231,21 +231,21 @@ static b_result parse_upstream_version(
}
*nr_read = i;
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
b_result ropkg_version_parse(struct ropkg_version *version, const char *s)
fx_result ropkg_version_parse(struct ropkg_version *version, const char *s)
{
enum ropkg_version_release_phase release_phase
enum ropkg_version_unref_phase release_phase
= ROPKG_VERSION_RELEASE_PHASE_RELEASE;
unsigned int upstream_version[ROPKG_VERSION_UPSTREAM_DIGIT_MAX]
= {0, 0, 0, 0, 0};
enum ropkg_version_release_phase version_release_phase
enum ropkg_version_unref_phase version_unref_phase
= ROPKG_VERSION_RELEASE_PHASE_RELEASE;
unsigned int version_release_phase_revision = 1;
unsigned int version_unref_phase_revision = 1;
unsigned int package_revision = 1;
b_result result = B_RESULT_SUCCESS;
fx_result result = FX_RESULT_SUCCESS;
char temp[64] = {0};
size_t z = 0;
@@ -256,28 +256,28 @@ b_result ropkg_version_parse(struct ropkg_version *version, const char *s)
s++;
}
result = parse_release_phase(temp, &release_phase);
if (b_result_is_error(result)) {
return b_result_propagate(result);
result = parse_unref_phase(temp, &release_phase);
if (fx_result_is_error(result)) {
return fx_result_propagate(result);
}
size_t nr_read = 0;
result = parse_upstream_version(s, upstream_version, &nr_read);
if (b_result_is_error(result)) {
return b_result_propagate(result);
if (fx_result_is_error(result)) {
return fx_result_propagate(result);
}
s += nr_read;
if (*s == '~' || *s == 0) {
result = parse_version_release_phase(
result = parse_version_unref_phase(
s,
&version_release_phase,
&version_release_phase_revision,
&version_unref_phase,
&version_unref_phase_revision,
&nr_read);
s += nr_read;
if (b_result_is_error(result)) {
return b_result_propagate(result);
if (fx_result_is_error(result)) {
return fx_result_propagate(result);
}
}
@@ -285,39 +285,38 @@ b_result ropkg_version_parse(struct ropkg_version *version, const char *s)
result = parse_package_revision(s, &package_revision, &nr_read);
s += nr_read;
if (b_result_is_error(result)) {
return b_result_propagate(result);
if (fx_result_is_error(result)) {
return fx_result_propagate(result);
}
}
if (*s != 0) {
return b_error_with_msg(
return fx_error_with_msg(
ROPKG_ERROR_VENDOR,
ROPKG_ERR_INVALID_VERSION_FORMAT,
ROPKG_EMSG_INVALID_VERSION_UNKNOWN_END);
}
version->v_release_phase = release_phase;
version->v_unref_phase = release_phase;
memcpy(version->v_upstream_version,
upstream_version,
sizeof upstream_version);
version->v_version_release_phase = version_release_phase;
version->v_version_release_phase_revision
= version_release_phase_revision;
version->v_version_unref_phase = version_unref_phase;
version->v_version_unref_phase_revision = version_unref_phase_revision;
version->v_package_revision = package_revision;
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
void ropkg_version_set_release_phase(
void ropkg_version_set_unref_phase(
struct ropkg_version *version,
enum ropkg_version_release_phase phase)
enum ropkg_version_unref_phase phase)
{
if (phase == ROPKG_VERSION_RELEASE_PHASE_RC) {
return;
}
version->v_release_phase = phase;
version->v_unref_phase = phase;
}
void ropkg_version_set_upstream_version(
@@ -329,17 +328,17 @@ void ropkg_version_set_upstream_version(
sizeof version->v_upstream_version);
}
void ropkg_version_set_version_release_phase(
void ropkg_version_set_version_unref_phase(
struct ropkg_version *version,
enum ropkg_version_release_phase phase,
enum ropkg_version_unref_phase phase,
unsigned int revision)
{
version->v_version_release_phase = phase;
version->v_version_unref_phase = phase;
if (phase == ROPKG_VERSION_RELEASE_PHASE_RELEASE) {
version->v_version_release_phase_revision = 1;
version->v_version_unref_phase_revision = 1;
} else {
version->v_version_release_phase_revision = revision;
version->v_version_unref_phase_revision = revision;
}
}
@@ -350,8 +349,7 @@ void ropkg_version_set_package_revision(
version->v_package_revision = revision;
}
static const char *release_phase_to_string(
enum ropkg_version_release_phase phase)
static const char *release_phase_to_string(enum ropkg_version_unref_phase phase)
{
switch (phase) {
case ROPKG_VERSION_RELEASE_PHASE_ALPHA:
@@ -387,48 +385,60 @@ size_t ropkg_version_to_string(
char *out,
size_t max)
{
b_stringstream str;
b_stringstream_begin(&str, out, max);
fx_stringstream *str = fx_stringstream_create_with_buffer(out, max);
b_stringstream_add(
&str,
release_phase_to_string(version->v_release_phase));
fx_stream_write_cstr(
str,
release_phase_to_string(version->v_unref_phase),
NULL);
unsigned int version_length
= upstream_version_length(version->v_upstream_version);
for (unsigned int i = 0; i < version_length; i++) {
if (i > 0) {
b_stringstream_add(&str, ".");
fx_stream_write_char(str, '.');
}
b_stringstream_addf(&str, "%u", version->v_upstream_version[i]);
fx_stream_write_fmt(
str,
NULL,
"%u",
version->v_upstream_version[i]);
}
if (version->v_version_release_phase
if (version->v_version_unref_phase
!= ROPKG_VERSION_RELEASE_PHASE_RELEASE) {
b_stringstream_addf(
&str,
fx_stream_write_fmt(
str,
NULL,
"~%s",
release_phase_to_string(
version->v_version_release_phase));
version->v_version_unref_phase));
if (version->v_version_release_phase_revision > 1
|| version->v_version_release_phase
if (version->v_version_unref_phase_revision > 1
|| version->v_version_unref_phase
== ROPKG_VERSION_RELEASE_PHASE_RC) {
b_stringstream_addf(
&str,
fx_stream_write_fmt(
str,
NULL,
"%u",
version->v_version_release_phase_revision);
version->v_version_unref_phase_revision);
}
}
if (version->v_package_revision > 1) {
b_stringstream_addf(&str, "-%u", version->v_package_revision);
fx_stream_write_fmt(
str,
NULL,
"-%u",
version->v_package_revision);
}
b_stringstream_end(&str);
return b_stringstream_get_length(&str);
size_t written = fx_stringstream_get_length(str);
fx_stringstream_unref(str);
return written;
}
static int version_compare(
@@ -443,14 +453,14 @@ static int version_compare(
return 1; \
} while (0)
COMPARE(left, right, v_release_phase);
COMPARE(left, right, v_unref_phase);
for (int i = 0; i < ROPKG_VERSION_UPSTREAM_DIGIT_MAX; i++) {
COMPARE(left, right, v_upstream_version[i]);
}
COMPARE(left, right, v_version_release_phase);
COMPARE(left, right, v_version_release_phase_revision);
COMPARE(left, right, v_version_unref_phase);
COMPARE(left, right, v_version_unref_phase_revision);
COMPARE(left, right, v_package_revision);
#undef COMPARE