libsemver/semver.c

#include "semver.h"
#include "epoch.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

u128 u128FromVersion(Version *self) {
    u128         out = 0;
    uint16_t     pre = 0, mask = 03777;
    uint64_t     major, minor, patch, build;
    int64_t      ts;

    switch (self->vk_tag) {
        case Simple:
            out |= ((u128)self->vk_data.simple.major << (64 + 52));
            break;
        case Rapid:
            major = (uint64_t)self->vk_data.rapid.major << 52;
            minor = (uint64_t)self->vk_data.rapid.minor << 40;
            out = (u128)(major | minor) << 64;
            break;
        case SemVer:
            major = (uint64_t)self->vk_data.semver.major << 52;
            minor = (uint64_t)self->vk_data.semver.minor << 40;
            patch = (uint64_t)self->vk_data.semver.patch << 28;
            out = (u128)(major | minor | patch) << 64;
            break;
        case Extended:
            major = (uint64_t)self->vk_data.extended.major << 52;
            minor = (uint64_t)self->vk_data.extended.minor << 40;
            patch = (uint64_t)self->vk_data.extended.patch << 28;
            build = (uint64_t)self->vk_data.extended.build << 16;
            out = (u128)(major | minor | patch | build) << 64;
            break;
    }
    switch (self->pr_tag) {
        case Alpha:
            out |= ((u128)010000 << 64);
            pre = self->pr_data.alpha & mask;
            out |= ((u128)pre << 64);
            break;
        case Beta:
            out |= ((u128)020000 << 64);
            pre = self->pr_data.beta & mask;
            out |= ((u128)pre << 64);
            break;
        case ReleaseCandidate:
            out |= ((u128)040000 << 64);
            pre = self->pr_data.rc & mask;
            out |= ((u128)pre << 64);
            break;
        case GitRev:
            out |= ((u128)01000 << 64);
            ts = dateTimeGetTimestamp(&self->pr_data.git->dt);
            out |= (u128)ts;
            break;
        case PRNone:
            out |= ((u128)0100000 << 64);
            break;
    }
    return out;
}

Comparison compareVersion(Version *self, Version *other) {
    u128 a, b;

    if (self->arch != other->arch)
        return CompNone;
    a = u128FromVersion(self);
    b = u128FromVersion(other);
    if (a < b)
        return CompLess;
    else if (a == b)
        return CompEqual;
    else if (a > b)
        return CompGreater;
    else
        return CompNone;
}

char *archToString(Arch self) {
    switch (self) {
        case any:       return "any";
        case arm:       return "arm";
        case arm64:     return "aarch64";
        case loongson:  return "loongson";
        case mips32:    return "mips32";
        case mips64:    return "mips64";
        case powerepc:  return "ppc";
        case powerpc64: return "ppc64";
        case riscv64:   return "riscv64";
        case s390x:     return "s390x";
        case sparc:     return "sparc";
        case sparc64:   return "sparc64";
        case x86:       return "x86";
        case x86_64:    return "x86_64";
    }
    return NULL;
}

char *versionToString(Version *self) {
    char *buf, *temp;

    buf = calloc(100, sizeof(char));
    if (buf == NULL) return NULL;
    temp = calloc(50, sizeof(char));
    if (temp == NULL) {
        free(buf);
        return NULL;
    }
    switch (self->vk_tag) {
        case Simple:
            snprintf(buf, 6, "%d", self->vk_data.simple.major);
            break;
        case Rapid:
            snprintf(buf, 13, "%d.%d", self->vk_data.rapid.major, self->vk_data.rapid.minor);
            break;
        case SemVer:
            snprintf(
                buf, 20, "%d.%d.%d",
                self->vk_data.semver.major,
                self->vk_data.semver.minor,
                self->vk_data.semver.patch
            );
            break;
        case Extended:
            snprintf(
                buf, 27, "%d.%d.%d.%d",
                self->vk_data.extended.major,
                self->vk_data.extended.minor,
                self->vk_data.extended.patch,
                self->vk_data.extended.build
            );
            break;
    }
    switch (self->pr_tag) {
        case PRNone:
            snprintf(temp, 9, "-%s", archToString(self->arch));
            break;
        case Alpha:
            snprintf(temp, 25, "_alpha%d-%s", self->pr_data.alpha, archToString(self->arch));
            break;
        case Beta:
            snprintf(temp, 25, "_beta%d-%s", self->pr_data.beta, archToString(self->arch));
            break;
        case ReleaseCandidate:
            snprintf(temp, 25, "_rc%d-%s", self->pr_data.rc, archToString(self->arch));
            break;
        case GitRev:
            snprintf(
                temp, 50, "_git_%c%c%c%c%c%c%c.%li-%s",
                self->pr_data.git->hash[0],
                self->pr_data.git->hash[1],
                self->pr_data.git->hash[2],
                self->pr_data.git->hash[3],
                self->pr_data.git->hash[4],
                self->pr_data.git->hash[5],
                self->pr_data.git->hash[6],
                dateTimeGetTimestamp(&self->pr_data.git->dt),
                archToString(self->arch)
            );
    }
    strncat(buf, temp, 50);
    free(temp);
    return buf;
}