numerus_core.c

Go to the documentation of this file.

#include <ctype.h>    /* For `isspace()` */
#include <stdlib.h>   /* For `malloc()` */
#include <string.h>   /* For `strlen()`, `strncasecmp()`, `strcpy()` */
#include <stdbool.h>  /* To use booleans `true` and `false` */
#include "numerus_internal.h"




/*  -+-+-+-+-+-+-+-+-+-+-+-+-+-{   CONSTANTS   }-+-+-+-+-+-+-+-+-+-+-+-+-+-  */


const long NUMERUS_MAX_LONG_NONFLOAT_VALUE = 3999999;


const double NUMERUS_MAX_VALUE = NUMERUS_MAX_LONG_NONFLOAT_VALUE + 11.5 / 12.0;


const long int NUMERUS_MIN_LONG_NONFLOAT_VALUE = -NUMERUS_MAX_LONG_NONFLOAT_VALUE;


const double NUMERUS_MIN_VALUE = -NUMERUS_MAX_VALUE;


const double NUMERUS_MAX_NONLONG_FLOAT_VALUE = 3999 + 11.5 / 12.0;


const double NUMERUS_MIN_NONLONG_FLOAT_VALUE = -NUMERUS_MAX_NONLONG_FLOAT_VALUE;


const char *NUMERUS_ZERO = "NULLA";


const short int NUMERUS_MAX_LENGTH = 37;



/*  -+-+-+-+-+-+-+-+-{   VARIABLES and DATA STRUCTURES   }-+-+-+-+-+-+-+-+-  */


int numerus_error_code = NUMERUS_OK;


struct _num_dictionary_char {
    const int value;
    const char *characters;
    const short max_repetitions;
};


static const struct _num_dictionary_char _NUM_DICTIONARY[] = {
    { 1000, "M" ,  3 }, // index: 0
    {  900, "CM",  1 }, // index: 1
    {  500, "D" ,  1 }, // index: 2
    {  400, "CD",  1 }, // index: 3
    {  100, "C" ,  3 }, // index: 4
    {   90, "XC",  1 }, // index: 5
    {   50, "L" ,  1 }, // index: 6
    {   40, "XL",  1 }, // index: 7
    {   10, "X" ,  3 }, // index: 8
    {    9, "IX",  1 }, // index: 9
    {    5, "V" ,  1 }, // index: 10
    {    4, "IV",  1 }, // index: 11
    {    1, "I" ,  3 }, // index: 12
    {    6, "S" ,  1 }, // index: 13
    {    1, "." ,  5 }, // index: 14
    {    0, NULL,  0 }  // index: 15
};


struct _num_numeral_parser_data {
    char *current_numeral_position;
    const struct _num_dictionary_char *current_dictionary_char;
    bool  numeral_is_long;
    short numeral_sign;
    long  int_part;
    short twelfths;
    short char_repetitions;
};



/*  -+-+-+-+-+-+-+-+-+-{   CONVERSION ROMAN -> VALUE   }-+-+-+-+-+-+-+-+-+-  */


static short _num_string_begins_with(char *to_be_compared,
                                     const char *pattern) {

    size_t pattern_length = strlen(pattern);
    /* Compare the first `pattern_length` characters */
    if (strncasecmp(to_be_compared, pattern, pattern_length) == 0) {
        return (short) pattern_length;
    } else {
        return 0;
    }
}


static void _num_init_parser_data(struct _num_numeral_parser_data *parser_data,
                                  char *roman) {

    parser_data->current_numeral_position = roman;
    parser_data->current_dictionary_char = &_NUM_DICTIONARY[0];
    parser_data->numeral_is_long = false;
    parser_data->numeral_sign = 1;
    parser_data->int_part = 0;
    parser_data->twelfths = 0;
    parser_data->char_repetitions = 0;
}


static bool _num_char_is_in_string(char current, char *terminating_chars) {

    if (current == '\0') {
        return true;
    }
    while (*terminating_chars != '\0') {
        if (current == *terminating_chars) {
            return true;
        } else {
            terminating_chars++;
        }
    }
    return false;
}


static void _num_skip_to_next_non_unique_dictionary_char(
        struct _num_numeral_parser_data *parser_data) {

    short current_char_is_multiple_of_five =
            strlen(parser_data->current_dictionary_char->characters) == 1;
    while (parser_data->current_dictionary_char->max_repetitions == 1) {
        parser_data->current_dictionary_char++;
        parser_data->char_repetitions = 0;
    }
    if (!current_char_is_multiple_of_five) {
        parser_data->current_dictionary_char++;
    }
}

static int _num_compare_numeral_position_with_dictionary(
        struct _num_numeral_parser_data *parser_data) {

    short num_of_matching_chars = _num_string_begins_with(
            parser_data->current_numeral_position,
            parser_data->current_dictionary_char->characters);

    if (num_of_matching_chars > 0) {
        /* Chars match */
        parser_data->char_repetitions++;
        if (parser_data->char_repetitions >
            parser_data->current_dictionary_char->max_repetitions) {
            return NUMERUS_ERROR_TOO_MANY_REPEATED_CHARS;
        }
        parser_data->current_numeral_position += num_of_matching_chars;
        if (*(parser_data->current_dictionary_char->characters) == 'S'
            || *(parser_data->current_dictionary_char->characters) == '.') {
            /* Add to decimal part value */
            parser_data->twelfths += parser_data->current_dictionary_char->value;
        } else {
            /* Add to integer part value */
            parser_data->int_part += parser_data->current_dictionary_char->value;
        }
        _num_skip_to_next_non_unique_dictionary_char(parser_data);
    } else {
        /* Chars don't match */
        parser_data->char_repetitions = 0;
        parser_data->current_dictionary_char++;
        if (parser_data->current_dictionary_char->max_repetitions == 0) {
            return NUMERUS_ERROR_ILLEGAL_CHAR_SEQUENCE;
        }
    }
    return NUMERUS_OK;
}


static int _num_parse_part_in_underscores(
        struct _num_numeral_parser_data *parser_data) {

    while (!_num_char_is_in_string(*(parser_data->current_numeral_position),
                                   "_Ss.-")) {
        int result_code = _num_compare_numeral_position_with_dictionary(
                parser_data);
        if (result_code != NUMERUS_OK) {
            return result_code;
        }
    }
    if (*(parser_data->current_numeral_position) == '\0') {
        return NUMERUS_ERROR_MISSING_SECOND_UNDERSCORE;
    }
    if (_num_char_is_in_string(*(parser_data->current_numeral_position),
                               "sS.")) {
        return NUMERUS_ERROR_DECIMALS_IN_LONG_PART;
    }
    if (*(parser_data->current_numeral_position) == '-') {
        return NUMERUS_ERROR_ILLEGAL_MINUS;
    }
    return NUMERUS_OK;
}


static int _num_parse_part_after_underscores(
        struct _num_numeral_parser_data *parser_data) {

    char *stop_chars;
    if (parser_data->numeral_is_long) {
        stop_chars = "Ss.M_-";
    } else {
        stop_chars = "Ss._-";
    }
    while (!_num_char_is_in_string(*(parser_data->current_numeral_position),
                                   stop_chars)) {
        int result_code = _num_compare_numeral_position_with_dictionary(
                parser_data);
        if (result_code != NUMERUS_OK) {
            return result_code;
        }
    }
    if (*(parser_data->current_numeral_position) == '_') {
        if (parser_data->numeral_is_long) {
            return NUMERUS_ERROR_UNDERSCORE_AFTER_LONG_PART;
        } else {
            return NUMERUS_ERROR_UNDERSCORE_IN_NON_LONG;
        }
    }
    if (*(parser_data->current_numeral_position) == 'M') {
        return NUMERUS_ERROR_M_IN_SHORT_PART;
    }
    if (*(parser_data->current_numeral_position) == '-') {
        return NUMERUS_ERROR_ILLEGAL_MINUS;
    }
    return NUMERUS_OK;
}


static int _num_parse_decimal_part(
        struct _num_numeral_parser_data *parser_data) {

    while (!_num_char_is_in_string(*(parser_data->current_numeral_position),
                                   "_-")) {
        int result_code = _num_compare_numeral_position_with_dictionary(
                parser_data);
        if (result_code != NUMERUS_OK) {
            return result_code;
        }
    }
    if (*(parser_data->current_numeral_position) == '_') {
        if (parser_data->numeral_is_long) {
            return NUMERUS_ERROR_UNDERSCORE_AFTER_LONG_PART;
        } else {
            return NUMERUS_ERROR_UNDERSCORE_IN_NON_LONG;
        }
    }
    if (*(parser_data->current_numeral_position) == '-') {
        return NUMERUS_ERROR_ILLEGAL_MINUS;
    }
    return NUMERUS_OK;
}





double numerus_roman_to_double(char *roman, int *errcode) {
    long int_part;
    short twelfths;
    int_part = numerus_roman_to_int_part_and_twelfths(roman, &twelfths, errcode);
    return numerus_parts_to_double(int_part, twelfths);
}


long numerus_roman_to_int(char *roman, int *errcode) {
    return numerus_roman_to_int_part_and_twelfths(roman, 0, errcode);
}


long numerus_roman_to_int_part_and_twelfths(char *roman, short *twelfths,
                                            int *errcode) {
    /* Prepare variables */
    long int_part;
    int response_code;
    short zero_twelfths = 0;
    if (twelfths == NULL) {
        twelfths = &zero_twelfths;
    }
    if (errcode == NULL) {
        errcode = &numerus_error_code;
    }
    struct _num_numeral_parser_data parser_data;
    _num_init_parser_data(&parser_data, roman);

    /* Check for illegal symbols or length */
    numerus_count_roman_chars(roman, &response_code);
    if (response_code != NUMERUS_OK) {
        numerus_error_code = response_code;
        *errcode = response_code;
        return NUMERUS_MAX_LONG_NONFLOAT_VALUE + 10;
    }

    /* Skip initial whitespace */
    while (isspace(*roman)) {
        roman++;
    }

    /* Conversion if NUMERUS_NULLA */
    if (_num_is_zero(roman)) {
        int_part = 0;
        *twelfths = 0;
        numerus_error_code = NUMERUS_OK;
        *errcode = NUMERUS_OK;
        return int_part;
    }

    /* Conversion of other cases */
    if (*parser_data.current_numeral_position == '-') {
        parser_data.numeral_sign = -1;
        parser_data.current_numeral_position++;
    }
    if (*parser_data.current_numeral_position == '_') {
        parser_data.current_numeral_position++;
        parser_data.numeral_is_long = 1;
    }
    if (parser_data.numeral_is_long) {
        response_code = _num_parse_part_in_underscores(&parser_data);
        if (response_code != NUMERUS_OK) {
            numerus_error_code = response_code;
            *errcode = response_code;
            return NUMERUS_MAX_LONG_NONFLOAT_VALUE + 10;
        }
        parser_data.current_numeral_position++; /* Skip second underscore */
        parser_data.int_part *= 1000;
        parser_data.current_dictionary_char = &_NUM_DICTIONARY[1];
        parser_data.char_repetitions = 0;
    }
    response_code = _num_parse_part_after_underscores(&parser_data);
    if (response_code != NUMERUS_OK) {
        numerus_error_code = response_code;
        *errcode = response_code;
        return NUMERUS_MAX_LONG_NONFLOAT_VALUE + 10;
    }
    response_code = _num_parse_decimal_part(&parser_data);
    if (response_code != NUMERUS_OK) {
        numerus_error_code = response_code;
        *errcode = response_code;
        return NUMERUS_MAX_LONG_NONFLOAT_VALUE + 10;
    }
    int_part = parser_data.numeral_sign * parser_data.int_part;
    *twelfths = parser_data.numeral_sign * parser_data.twelfths;
    numerus_error_code = NUMERUS_OK;
    *errcode = NUMERUS_OK;
    return int_part;
}



/*  -+-+-+-+-+-+-+-+-+-{   CONVERSION VALUE -> ROMAN   }-+-+-+-+-+-+-+-+-+-  */


static char *_num_copy_char_from_dictionary(const char *source,
                                            char *destination) {
    
    *destination = *(source++);
    if (*source != '\0') {
        *(++destination) = *source;
    }
    return ++destination;
}


static char *_num_value_part_to_roman(long value, char *roman,
                                      int dictionary_start_char) {

    const struct _num_dictionary_char *current_dictionary_char
            = &_NUM_DICTIONARY[dictionary_start_char];
    while (value > 0) {
        while (value >= current_dictionary_char->value) {
            roman = _num_copy_char_from_dictionary(
                    current_dictionary_char->characters, roman);
            value -= current_dictionary_char->value;
        }
        current_dictionary_char++;
    }
    return roman;
}


char *numerus_int_to_roman(long int_value, int *errcode) {
    return numerus_int_with_twelfth_to_roman(int_value, 0, errcode);
}


char *numerus_double_to_roman(double double_value, int *errcode) {
    short twelfths;
    long int_part = numerus_double_to_parts(double_value, &twelfths);
    return numerus_int_with_twelfth_to_roman(int_part, twelfths, errcode);
}


char *numerus_int_with_twelfth_to_roman(long int_part, short twelfths,
                                        int *errcode) {

    /* Prepare variables */
    numerus_shorten_and_same_sign_to_parts(&int_part, &twelfths);
    double double_value = numerus_parts_to_double(int_part, twelfths);
    if (errcode == NULL) {
        errcode = &numerus_error_code;
    }

    /* Out of range check */
    if (double_value < NUMERUS_MIN_VALUE || double_value > NUMERUS_MAX_VALUE) {
        numerus_error_code = NUMERUS_ERROR_VALUE_OUT_OF_RANGE;
        *errcode = NUMERUS_ERROR_VALUE_OUT_OF_RANGE;
        return NULL;
    }

    /* Create pointer to the building buffer */
    char building_buffer[NUMERUS_MAX_LENGTH];
    char *roman_numeral = building_buffer;

    /* Save sign or return NUMERUS_ZERO for 0 */
    if (int_part == 0 && twelfths == 0) {
        /* Return writable copy of NUMERUS_ZERO on the heap */
        char *zero_string = malloc(strlen(NUMERUS_ZERO) + 1);
        if (zero_string == NULL) {
            numerus_error_code = NUMERUS_ERROR_MALLOC_FAIL;
            *errcode = NUMERUS_ERROR_MALLOC_FAIL;
            return NULL;
        }
        strcpy(zero_string, NUMERUS_ZERO);
        return zero_string;
    } else if (int_part < 0 || (int_part == 0 && twelfths < 0)) {
        int_part = ABS(int_part);
        twelfths = ABS(twelfths);
        double_value = ABS(double_value);
        *(roman_numeral++) = '-';
    }

    /* Create part between underscores */
    if (double_value > NUMERUS_MAX_NONLONG_FLOAT_VALUE) {
        /* Underscores are needed */
        *(roman_numeral++) = '_';
        roman_numeral = _num_value_part_to_roman(int_part / 1000,
                                                 roman_numeral, 0);
        int_part -= (int_part / 1000) * 1000; /* Remove 3 left-most digits */
        *(roman_numeral++) = '_';
        /* Part after underscores without "M" char, start with "CM" */
        roman_numeral = _num_value_part_to_roman(int_part, roman_numeral, 1);
    } else {
        /* No underscores needed, so starting with "M" char */
        roman_numeral = _num_value_part_to_roman(int_part, roman_numeral, 0);
    }
    /* Decimal part, starting with "S" char */
    roman_numeral = _num_value_part_to_roman(twelfths, roman_numeral, 13);
    *(roman_numeral++) = '\0';

    /* Copy out of the buffer and return it on the heap */
    char *returnable_roman_string =
            malloc(roman_numeral - building_buffer);
    if (returnable_roman_string == NULL) {
        numerus_error_code = NUMERUS_ERROR_MALLOC_FAIL;
        *errcode = NUMERUS_ERROR_MALLOC_FAIL;
        return NULL;
    }
    strcpy(returnable_roman_string, building_buffer);
    numerus_error_code = NUMERUS_OK;
    *errcode = NUMERUS_OK;
    return returnable_roman_string;
}