aoc-2021/src/puzzle_input.c

#include "day.h"
#include <limits.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "puzzle_input.h"

#define BUFFER_SIZE 256

parse_ret_t parse_long(char * buffer, int64_t *val, int16_t base) {
    if (buffer == NULL) {
        return PARSE_NULL;
    }

    *val = strtol(buffer, NULL, base);

    if (*val == LONG_MIN || *val == LONG_MAX) {
        return PARSER_INVALID;
    }

    return PARSER_OK;

}

static parse_ret_t parse_long_base_from_buff(char * buffer, void * data, uint16_t index, uint16_t base) {
    uint64_t * int_data = (uint64_t *)data;
    uint64_t val;
    int ret;

    ret = parse_long(buffer, (int64_t *)&val, (int16_t)base);

    if (ret != PARSER_OK) {
        return ret;
    }

    int_data[index] = val;

    return PARSER_OK;
}

parse_ret_t parse_long_from_buff(char * buffer, void * data, uint16_t index) {
    return parse_long_base_from_buff(buffer, data, index, 10);
}

parse_ret_t parse_long_base_2_from_buff(char * buffer, void * data, uint16_t index) {
    return parse_long_base_from_buff(buffer, data, index, 2);
}

parse_ret_t read_input_split_on(const char * file_path, void * data, uint16_t max_len, input_parser_t parser, uint16_t * len, char sep) {
    char buffer[BUFFER_SIZE];
    int c;
    int ret = 0;
    FILE * file = fopen(file_path, "r");
    uint16_t data_ndx = 0;

    if (file != NULL) {
        int buffer_ndx = 0;
        while ((c = fgetc(file)) != EOF) {
            if (c == sep) {
                buffer[buffer_ndx] = 0;

                ret = parser(buffer, data, data_ndx);

                if (ret != PARSER_OK) {
                    break;
                }

                data_ndx++;

                if (data_ndx >= max_len) {
                    ret = PARSER_RANGE_OVERFLOW;
                    break;
                }

                buffer_ndx = 0;

                memset(buffer, 0, BUFFER_SIZE);
            }
            else {
                buffer[buffer_ndx] = (char)c;
                buffer_ndx++;
            }
        }

        if (buffer_ndx > 0) {
            ret = parser(buffer, data, data_ndx);

            if (ret == PARSER_OK) {
                data_ndx++;
            }
        }
    }
    else {
        ret = PARSE_FILE_ERR;
    }

    if (file != NULL) {
        fclose(file);
    }

    *len = data_ndx;

    return ret;
}

char buffer_g[BUFFER_SIZE];
char line_buffer_g[BUFFER_SIZE];

parse_ret_t read_input_multi_line(const char * file_path, void * data, uint16_t max_len, char * line_sep, input_parser_t parser, uint16_t * len) {
    int c;
    int ret = 0;
    FILE * file = fopen(file_path, "r");
    uint16_t data_ndx = 0;

    if (file != NULL) {
        int buffer_ndx = 0;
        int line_buffer_ndx = 0;
        while ((c = fgetc(file)) != EOF) {
            if (c == '\n') {
                line_buffer_g[line_buffer_ndx] = 0;

                if (strcmp(line_buffer_g, line_sep) == 0) {
                    ret = parser(buffer_g, data, data_ndx);

                    if (ret != PARSER_OK) {
                        break;
                    }

                    data_ndx++;
                    buffer_ndx = 0;

                    if (data_ndx >= max_len) {
                        ret = PARSER_RANGE_OVERFLOW;
                        break;
                    }
                }
                else {
                    strncpy(&buffer_g[buffer_ndx], line_buffer_g, line_buffer_ndx);
                    buffer_ndx += line_buffer_ndx;
                    buffer_g[buffer_ndx++] = ' ';
                }

                line_buffer_ndx = 0;
            }
            else {
                line_buffer_g[line_buffer_ndx] = (char)c;
                line_buffer_ndx++;
            }
        }

        if (buffer_ndx > 0) {
            strncpy(&buffer_g[buffer_ndx], line_buffer_g, line_buffer_ndx);
            buffer_ndx += line_buffer_ndx;
            buffer_g[buffer_ndx++] = ' ';
            ret = parser(buffer_g, data, data_ndx);

            if (ret != PARSER_OK) {
                return ret;
            }

            data_ndx++;

            if (data_ndx >= max_len) {
                return PARSER_RANGE_OVERFLOW;
            }
        }
    }
    else {
        ret = PARSE_FILE_ERR;
    }

    if (file != NULL) {
        fclose(file);
    }

    *len = data_ndx;

    return ret;
}

parse_ret_t read_input_single_line(const char * file_path, void * data, uint16_t max_len, input_parser_t parser, uint16_t * len) {
    read_input_split_on(file_path, data, max_len, parser, len, '\n');
}

parse_ret_t parse_byte_from_buff(char * buffer, void * data, uint16_t index) {
    uint8_t * initial_states = (uint8_t *)data;
    int64_t val;
    parse_ret_t res;

    res = parse_long(buffer, &val, 10);

    if (res != PARSER_OK) {
        return res;
    }

    initial_states[index] = (uint8_t)val;

    return PARSER_OK;
}