num8_builder.c

#include "num8.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(_WIN32)
#include <windows.h>
#endif

static int trim_eol(char* s)
{
    size_t n = strlen(s);
    while (n > 0 && (s[n - 1] == '\n' || s[n - 1] == '\r'))
    {
        s[n - 1] = '\0';
        n--;
    }
    return (int)n;
}

static void cleanup_temp_output(num8_engine_t* engine, const char* temp_path)
{
    if (engine != NULL)
    {
        (void)num8_close(engine);
    }
    if (temp_path != NULL)
    {
        remove(temp_path);
    }
}

static int install_temp_output(const char* temp_path, const char* output_path)
{
#if defined(_WIN32)
    return MoveFileExA(temp_path, output_path, MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) != 0;
#else
    return rename(temp_path, output_path) == 0;
#endif
}

static int read_builder_line(
    FILE* in,
    char* line,
    size_t cap,
    unsigned long long* line_no,
    int* saw_input,
    int* ended_with_newline,
    num8_status_t* out_status)
{
    size_t len;

    if (fgets(line, (int)cap, in) == NULL)
    {
        if (ferror(in))
        {
            if (out_status != NULL)
            {
                *out_status = NUM8_STATUS_IO_ERROR;
            }
            return -1;
        }
        if (out_status != NULL)
        {
            *out_status = NUM8_STATUS_OK;
        }
        return 0;
    }

    if (saw_input != NULL)
    {
        *saw_input = 1;
    }
    if (line_no != NULL)
    {
        (*line_no)++;
    }

    len = strlen(line);
    if (len == 0u)
    {
        if (out_status != NULL)
        {
            *out_status = NUM8_STATUS_IO_ERROR;
        }
        return -1;
    }

    if (line[len - 1] != '\n')
    {
        if (!feof(in))
        {
            int ch;
            do
            {
                ch = fgetc(in);
            } while (ch != EOF && ch != '\n');
            if (out_status != NULL)
            {
                *out_status = NUM8_STATUS_SIZE_MISMATCH;
            }
            return -1;
        }
        if (ended_with_newline != NULL)
        {
            *ended_with_newline = 0;
        }
        if (out_status != NULL)
        {
            *out_status = NUM8_STATUS_INVALID_FORMAT;
        }
        return -1;
    }

    trim_eol(line);
    if (ended_with_newline != NULL)
    {
        *ended_with_newline = 1;
    }
    if (line[0] == '\0')
    {
        if (out_status != NULL)
        {
            *out_status = NUM8_STATUS_INVALID_FORMAT;
        }
        return -1;
    }

    if (out_status != NULL)
    {
        *out_status = NUM8_STATUS_OK;
    }
    return 1;
}

int main(int argc, char** argv)
{
    FILE* in;
    num8_engine_t engine = {0};
    num8_engine_t verify = {0};
    char temp_out[512];
    char line[256];
    unsigned long long line_no = 0;
    unsigned long long added = 0;
    unsigned long long duplicates = 0;
    int saw_input = 0;
    int ended_with_newline = 1;
    num8_status_t st;

    if (argc != 3)
    {
        fprintf(stderr, "Usage: %s <input.txt> <output.num8>\n", argv[0]);
        return 2;
    }

    in = fopen(argv[1], "rb");
    if (in == NULL)
    {
        fprintf(stderr, "Cannot open input: %s\n", argv[1]);
        return 1;
    }

    if (snprintf(temp_out, sizeof(temp_out), "%s.tmp", argv[2]) < 0)
    {
        fclose(in);
        fprintf(stderr, "Cannot prepare temp output: %s\n", argv[2]);
        return 1;
    }

    remove(temp_out);
    if (num8_create(temp_out, &engine) != NUM8_STATUS_OK)
    {
        fclose(in);
        fprintf(stderr, "Cannot create temp output: %s\n", temp_out);
        return 1;
    }

    for (;;)
    {
        int line_rc = read_builder_line(in, line, sizeof(line), &line_no, &saw_input, &ended_with_newline, &st);
        if (line_rc == 0)
        {
            break;
        }
        if (line_rc < 0 && st == NUM8_STATUS_INVALID_FORMAT && !ended_with_newline)
        {
            fprintf(stderr, "Missing final newline at line %llu\n", line_no);
            cleanup_temp_output(&engine, temp_out);
            fclose(in);
            return 1;
        }
        if (line_rc < 0 && st == NUM8_STATUS_SIZE_MISMATCH)
        {
            fprintf(stderr, "Oversized line at %llu\n", line_no);
            cleanup_temp_output(&engine, temp_out);
            fclose(in);
            return 1;
        }
        if (line_rc < 0 && st == NUM8_STATUS_IO_ERROR)
        {
            fprintf(stderr, "Input read error at %llu\n", line_no + 1u);
            cleanup_temp_output(&engine, temp_out);
            fclose(in);
            return 1;
        }
        if (line[0] == '\0')
        {
            fprintf(stderr, "Invalid empty line at %llu\n", line_no);
            cleanup_temp_output(&engine, temp_out);
            fclose(in);
            return 1;
        }
        st = num8_add_str(&engine, line);
        if (st == NUM8_STATUS_ADDED)
        {
            added++;
            continue;
        }
        if (st == NUM8_STATUS_ALREADY_EXISTS)
        {
            duplicates++;
            continue;
        }

        fprintf(stderr, "Invalid value at line %llu: '%s' (status=%d)\n", line_no, line, (int)st);
        cleanup_temp_output(&engine, temp_out);
        fclose(in);
        return 1;
    }

    fclose(in);

    if (!saw_input)
    {
        fprintf(stderr, "Input is empty\n");
        cleanup_temp_output(&engine, temp_out);
        return 1;
    }

    if (num8_flush(&engine) != NUM8_STATUS_OK)
    {
        cleanup_temp_output(&engine, temp_out);
        fprintf(stderr, "Flush failed\n");
        return 1;
    }

    if (num8_close(&engine) != NUM8_STATUS_OK)
    {
        remove(temp_out);
        fprintf(stderr, "Close failed\n");
        return 1;
    }

    if (num8_open(temp_out, NUM8_OPEN_READ_ONLY, &verify) != NUM8_STATUS_OK)
    {
        remove(temp_out);
        fprintf(stderr, "Validation open failed: %s\n", temp_out);
        return 1;
    }
    if (num8_validate(&verify) != NUM8_STATUS_OK)
    {
        num8_close(&verify);
        remove(temp_out);
        fprintf(stderr, "Validation failed: %s\n", temp_out);
        return 1;
    }
    if (num8_close(&verify) != NUM8_STATUS_OK)
    {
        remove(temp_out);
        fprintf(stderr, "Validation close failed: %s\n", temp_out);
        return 1;
    }

    if (!install_temp_output(temp_out, argv[2]))
    {
        remove(temp_out);
        fprintf(stderr, "Cannot install output: %s\n", argv[2]);
        return 1;
    }
    remove(temp_out);

    fprintf(stdout, "Build done. added=%llu duplicates=%llu\n", added, duplicates);
    return 0;
}