plntowords.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <math.h>
#include "plntowords.h"
/*----------------------------------------------------------------------------*/
static const char
*hundreds[] = {
    "", "sto ", "dwieście ", "trzysta ", "czterysta ", "pięćset ",
    "sześćset ", "siedemset ", "osiemset ", "dziewięćset "};
static const char
*teens[] = {
    "dziesięć ", "jedenaście ", "dwanaście ", "trzynaście ",
    "czternaście ", "piętnaście ", "szesnaście ", "siedemnaście ",
    "osiemnaście ", "dziewiętnaście "};
static const char
*tens[] = {
    "", "", "dwadzieścia ", "trzydzieści ", "czterdzieści ",
    "pięćdziesiąt ", "sześćdziesiąt ", "siedemdziesiąt ",
    "osiemdziesiąt ", "dziewięćdziesiąt "};
static const char
*ones[] = {
    "", "jeden ", "dwa ", "trzy ", "cztery ", "pięć ",
    "sześć ", "siedem ", "osiem ", "dziewięć "};
static const char
*ends[11][3] = {
    {"złoty ",     "złote ",      "złotych "},
    {"tysiąc ",    "tysiące ",    "tysięcy "},
    {"milion ",    "miliony ",    "milionów "},
    {"miliard ",   "miliardy ",   "miliardów "},
    {"bilion ",    "biliony ",    "bilionów "},
    {"biliard",    "biliardy",    "biliardów"},
    {"trylion",    "tryliony",    "trylionów"},
    {"tryliard",   "tryliardy",   "tryliardów"},
    {"kwadrylion", "kwadryliony", "kwadrylionów"},
    {"kwintylion", "kwintyliony", "kwintylionów"},
    {"sekstylion", "sekstyliony", "sekstylionów"}};
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
static uint64_t power        (uint64_t       x,
                              int            n)   __attribute__ ((const));
 
static uint8_t  get_digit    (uint64_t       x,
                              uint8_t        pos) __attribute__ ((const));
 
static void     divide_split (uint64_t      *x,
                              uint8_t       *y);
 
static void     check_resize (char         **buff,
                              const size_t   ui_len);
 
static int      prestr       (uint8_t        n,
                                             ...);
/*----------------------------------------------------------------------------*/
static uint64_t
power (uint64_t x,
       int      n)
{
    if (n == 0)
        return 1;
    else
        return x * power (x, n - 1);
}
/*----------------------------------------------------------------------------*/
static uint8_t
get_digit (uint64_t x,
           uint8_t  pos)
{
    return (uint8_t) ((x - x / power (10, pos + 1) * power (10, pos + 1)) / 
            power (10, pos));
}
/*----------------------------------------------------------------------------*/
static void
divide_split (uint64_t *x,
              uint8_t  *y)
{
    y[2] = get_digit (*x, 0);
    y[1] = get_digit (*x, 1);
    y[0] = get_digit (*x, 2);
    *x /= 1000;
}
/*----------------------------------------------------------------------------*/
static void
check_resize (char         **buff,
              const size_t   ui_len)
{
    if (*buff == NULL) {
        *buff = malloc (ui_len * sizeof (char));
    }
    else {
        *buff = realloc (*buff, ui_len * sizeof (char));
    }
    if (*buff == NULL) {
        puts ("Error (re)allocating memory");
        exit (1);
    }
}
/*----------------------------------------------------------------------------*/
static int
prestr (uint8_t n, ...)
{
    char    **dst    = NULL; /* Pointer to destination string */
    char     *src    = NULL; /* Source strings to prepend */
    uint8_t   i      = 0;    /* i */
    size_t    ui_srl = 0;    /* Length of source string */
    size_t    ui_dsl = 0;    /* Length of destination string */
    va_list   vl;            /* Information about variable arguments */
 
    va_start (vl, n);
    dst = va_arg (vl, char**);
    for (i = 1; i < n; ++i) {
        src = va_arg (vl, char*);
        ui_srl = strlen (src);
        ui_dsl = strlen (*dst);
        check_resize (dst, ui_srl + ui_dsl + 1);
        memmove ((*dst) + ui_srl, *dst, ui_dsl + 1);
        memmove (*dst, src, ui_srl);
    }
    return 0;
}
/*----------------------------------------------------------------------------*/
char *
pln_amount_txt_double (double d_price)
{
    double d_val = 0;
 
    d_val = d_price * 100.0;
    d_val = round (d_val);
 
    return pln_amount_txt ((uint64_t) d_val );
}
/*----------------------------------------------------------------------------*/
char *
pln_amount_txt (uint64_t ui_inprice)
{
    char     *s_price  = NULL;      /* Result string with price */
    uint64_t  ui_price = 0;         /* Price without "gr" after comma */
    uint64_t  ui_gr    = 0;         /* After comma "gr" rest */
    uint64_t  ui_prtmp = 0;         /* Temp price to count length */
    uint8_t   ui_prlen = 0;         /* Length of price in 3 char portions */
    uint8_t   p [3]    = {0, 0, 0}; /* 3 chars of a price portion */
    uint8_t   i        = 0;         /* i */
 
    ui_price = ui_inprice / 100;
    ui_prtmp = ui_price;
    ui_gr    = ui_inprice - (ui_inprice / 100 * 100);
 
    while (ui_prtmp || ui_prlen % 3) {
        ++ui_prlen;
        ui_prtmp /= 10;
    }
    check_resize (&s_price, 10);
    sprintf (s_price, "%" PRIu64 "/100", ui_gr);
    for (i = 0; i < ui_prlen / 3; ++i) {
        divide_split (&ui_price, p);
        if (p[1] == 1) prestr (3, &s_price, ends[i][2], teens[p[2]]);
        else {
            if (p[2] == 0) {
                if (i == 0) {
                    prestr (2, &s_price, ends[i][2]);
                    if (p[0] == 0 && p[1] == 0 && ui_prlen == 3)
                        prestr (2, &s_price, "zero ");
                }
                else if (! (p[0] == 0 && p[1] == 0 && ui_prlen > ((i + 1) * 3)))
                    prestr (2, &s_price, ends[i][2]);
            }
            else if (p[2] == 1) {
                if (p[0] == 0 && p[1] == 0)
                    prestr (3, &s_price, ends[i][0], ones[p[2]]);
                else prestr (3, &s_price, ends[i][2], ones[p[2]]);
            }
            else if (p[2] > 1 && p[2] < 5)
                prestr (3, &s_price, ends[i][1], ones[p[2]]);
            else prestr (3, &s_price, ends[i][2], ones[p[2]]);
            prestr (2, &s_price, tens[p[1]]);
        }
        prestr (2, &s_price, hundreds[p[0]]);
    }
    return s_price;
}
/*----------------------------------------------------------------------------*/