decimal_to_any_base.c File Reference

Decimal to any-base is a C function wich convert positive decimal integer to any positive ascii base with the base's alphabet given in input and return it in a dynamically allocated string(recursive way) More...

#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include <assert.h>
#include <stdlib.h>

Include dependency graph for decimal_to_any_base.c:

Functions
bool	isbad_alphabet (const char *alphabet)
	for IO operations
uint64_t	converted_len (uint64_t nb, short base)
	Calculate the final length of the converted number.
void	convertion (uint64_t nb, const char *alphabet, short base, char *converted)
	Convert positive decimal integer into anybase recursively.
char *	decimal_to_anybase (uint64_t nb, const char *alphabet)
	decimal_to_anybase ensure the validity of the parameters and convert any unsigned integers into any ascii positive base
static void	test ()
	Self-test implementations.
int	main ()
	Main function.

Detailed Description

Decimal to any-base is a C function wich convert positive decimal integer to any positive ascii base with the base's alphabet given in input and return it in a dynamically allocated string(recursive way)

Author

jucollet972

Function Documentation

converted_len()

uint64_t converted_len	(	uint64_t	nb,
		short	base
	)

Calculate the final length of the converted number.

Parameters

nb	to convert
base	calculated from alphabet

Returns

Converted nb string length

                                                {
    /* Counting the number of characters translated to the base*/
    if (nb > base - 1) {
        return (converted_len(nb/base, base) + 1);
    }
    return 1;
}

Here is the call graph for this function:

convertion()

void convertion	(	uint64_t	nb,
		const char *	alphabet,
		short	base,
		char *	converted
	)

Convert positive decimal integer into anybase recursively.

Parameters

nb	to convert
alphabet	inputed by user used for base convertion
base	calculated from alphabet
converted	string filled with the convertion's result

Returns

void

                                                                                {
    /* Recursive convertion */
    *(converted) = *(alphabet + nb%base);
    if (nb > base - 1) {
        convertion(nb/base, alphabet, base, --converted);
    }
}

Here is the call graph for this function:

decimal_to_anybase()

char * decimal_to_anybase	(	uint64_t	nb,
		const char *	alphabet
	)

decimal_to_anybase ensure the validity of the parameters and convert any unsigned integers into any ascii positive base

Parameters

nb	to convert
base's	alphabet

Returns

nb converted on success

NULL on error

                                                            {
    char* converted;
 
    /* Verify that alphabet is valid */
    if (isbad_alphabet(alphabet)) {
        return NULL;
    }
    /* Convertion */
    uint64_t base = strlen(alphabet);
    uint64_t final_len = converted_len(nb, base);
    converted = malloc(sizeof(char) * (final_len + 1));
    converted[final_len] = 0;
    convertion(nb, alphabet, base, converted + final_len - 1);
    return converted;
}

Here is the call graph for this function:

isbad_alphabet()

bool isbad_alphabet

(

const char *

alphabet

)

for IO operations

for strchr and strlen for CPU arch's optimized int types for boolean types for assert for malloc and free

Checking if alphabet is valid

Parameters

base	alphabet inputed by user

Returns

int64_t as success or not

                                          {
    uint64_t len = strlen(alphabet);
    
    /* Checking th lenght */    
    if (len < 2) {
        return true;
    }
    /* Browse the alphabet */
    for (int i = 0; i < len ; i++) {
        /* Searching for duplicates */ 
        if (strchr(alphabet + i + 1, alphabet[i]))
            return true;
    }
    return false;
}

main()

int main

(

void

)

Main function.

Returns

0 on exit

{
    test(); // run self-test implementations
    return 0;
}

Here is the call graph for this function:

test()

static void test ( void  )

static

Self-test implementations.

Returns

void

{
    char* ret = NULL;
    char* reference = NULL;
 
    /* min dec*/
    reference = "0";
    ret = decimal_to_anybase(0, "0123456789");
    for (int i = 0; i < strlen(reference) && i < strlen(ret); i++) {
        assert(ret[i] == reference[i]);
    }
    if (ret != NULL) {
        free(ret);
    }
    
    /* max dec*/
    reference = "18446744073709551615";
    ret = decimal_to_anybase(18446744073709551615, "0123456789");
    for (int i = 0; i < strlen(reference) && i < strlen(ret); i++) {
        assert(ret[i] == reference[i]);
    }
    if (ret != NULL) {
        free(ret);
    }
    
    /* negative dec*/
    reference = "18446744073709551615";
    ret = decimal_to_anybase(-1, "0123456789");
    for (int i = 0; i < strlen(reference) && i < strlen(ret); i++) {
        assert(ret[i] == reference[i]);
    }
    if (ret != NULL) {
        free(ret);
    }
 
    /* bin */
    reference = "101010";
    ret = decimal_to_anybase(42, "01");
    for (int i = 0; i < strlen(reference) && i < strlen(ret); i++) {
        assert(ret[i] == reference[i]);
    }
    if (ret != NULL) {
        free(ret);
    }
    
    /* octal */
    reference = "52";
    ret = decimal_to_anybase(42, "01234567");
    for (int i = 0; i < strlen(reference) && i < strlen(ret); i++) {
        assert(ret[i] == reference[i]);
    }
    if (ret != NULL) {
        free(ret);
    }
    
    /* hexa */
    reference = "2A";
    ret = decimal_to_anybase(42, "0123456789ABCDEF");
    for (int i = 0; i < strlen(reference) && i < strlen(ret); i++) {
        assert(ret[i] == reference[i]);
    }
    if (ret != NULL) {
        free(ret);
    }
    printf("[+] All tests have successfully passed!\n");
}

Here is the call graph for this function: