min_printf.h

Go to the documentation of this file.

/**
 * @file
 * @brief Implementation of a [function](https://www.geeksforgeeks.org/variable-length-argument-c) similar to `printf`
 * @details
 * `printf` statement rewritten (as `min_printf`) in C without using the `stdio.h` library 
 * Syntax of `min_printf` is same as `printf`
 * Currently min_printf handles:
 *  Integers, Doubles, floats, characters and strings
 * The format specifiers and escape sequence is the same as for `printf`
 * User can also specify the width and precision if required, just like in the case of `printf`
 * How to use it:
 *  - First include min_printf.h in your code
 *  - Then type `min_printf()`, and pass required parameters to it
 *  - As already specified, it's syntax is same as printf 
 * @author [Jaskarn Singh](https://github.com/Jaskarn7)
*/
 
#ifndef MIN_PRINTF_H
#define MIN_PRINTF_H
 
#include <stdlib.h> /// for `malloc` and `free` functions
#include <unistd.h> /// for `write` function
#include <stdarg.h> /// for `va_start` and `va_arg` functions
 
#define INT_MAX_LENGTH 10       /// used as standard length of string to store integers
#define PRECISION_FOR_FLOAT 8   /// default precision for float or double if not specified
 
/**
 * @brief struct used to store character in certain times
*/
typedef struct buffer {
    char buffr_char; // Character will be stored in this variable
    int buf_size; // Checks if character is present in buffr_char or not, 0 if no and 1 if yes
} Buffer;
 
/**
 * @details 
 * This function return ten to the power a(The parameter specified to it) like:
 *      if the parameter specified is 4 i.e. -> power_of_ten(4) is called then
 *      this function will return ten to the power four (10000);
 * @param a The power of ten which is to be returned
 * @return Ten to the power a
 */
int power_of_ten(int a)
{
    int n = 1; ///< This number will be returned as ten to power of a
    for (int i = 1; i <= a; ++i)
        n *= 10 ;
    return n;
}
 
/**
 * @brief Checks if a character is a number
 * @param c character to be checked if it's a number or not
 * @return `true`(1) if the character is a number 
 * @return `false`(0) if the character is NOT a number
*/
int is_number(char *c)
{
    return (*c >= '0' && *c <= '9') ? 1 : 0;
}
 
/**
 * @brief Returns specific required next character
 * @param p pointer to a format string of `min_printf()`
 * @param buffer struct for checking if buffr_char character is present or not
 * @return character inside `buffer->buffr_char`, if `buffer->buf_size` is one
 * @return character at which p is pointing, if `buffer->buf_size` is zero
 */
char get_ch(char *p, Buffer *buffer)
{
    if (buffer->buf_size) {
        buffer->buf_size = 0; ///< Since character is used, this sets `buffer->buf_size` to zero
        return buffer->buffr_char; // Returns character inside buffer->buffr_char
    }
    return *p++;
}
 
/**
 * @brief Stores character to the `buffer->buffr_char`
 * @param c character to be stored in the `buffer->buffr_char`
 * @param buffer struct where character will be stored
*/
void unget_ch(char *c, Buffer *buffer)
{
    buffer->buffr_char = *c;    // Character initializes inside buffer->buffr_char
    buffer->buf_size = 1; // Sets bufsize to one as new character is stored in buffr_char
}
 
 
/**
 * @brief Calculates the number of digits in a number
 * @param n number whose digits are to be counted
 * @return number of digits in n
*/
int get_number_of_digits(int n)
{
    int digits = 0; // Stores encountered number of digits
    while (n > 0) {
        ++digits; // Since number still contains a digit, so increment digit variable
        n /= 10; // Removes last digit from number
    }
    return digits;
}
 
/**
 * @brief Prints one character on screen
 * @param s character to be printed on the screen
*/
void put_char(char s)
{
    /* buf used for storing character to be printed in an array (+1 for '\0')*/
    char *buf = (char *) malloc(sizeof(char) + 1); 
    *buf = s;
    *(buf + 1) = '\0';
    write(1, buf, 1);
    free(buf);
}
 
/**
 * @brief Reverses a string using [two pointer algorithm](https://www.geeksforgeeks.org/program-reverse-array-using-pointers/?ref=rp)
 * @param p pointer to the string which is to be reversed
*/
void reverse_str(char *p)
{
    char *l = p; // Points to first character of p
    char *h = p; // Will be used to point to last character of p
    char temp; // Temporarily stores a character, Used in swapping
 
    while (*h != '\0') 
        ++h;
    --h; // Now h point to last valid character of string 
 
    /* Swap character which lower and higher are pointing until lower < higher. At that point string will be reversed.*/
    while (l < h) {
        temp = *l;
        *l = *h;
        *h = temp;
        ++l; // Increment lower to next character
        --h; // Decrement higher to previous character from current character
    }
}
 
/**
 * @details
 * The algorithm here is to first convert the number into 
 * string and then reverse it be passing it to reverse_str function
 * and then printing on the screen
 * @param n Number to be printed
 * @param width Total characters to be printed (Prints ' ' if (size < width)
 * @param precision Total character of number to be printed (prints 0 before number if size of number < precision)
 * 
*/
void print_int_value(int n, int width, int precision)
{
    char *p = (char *) malloc(INT_MAX_LENGTH * sizeof(char) + 1); /* +1 for '\0' */
    char *s = p; // Temporary pointer
    int size = 0; //!< Used to store number of digits in number
 
    while (n > 0) {
        *s++ = n % 10 + '0'; // Converts last digit of number to character and store it in p
        ++size; // Increment size variable as one more digit is occurred
        n /= 10; // Removes the last digit from the number n as we have successfully stored it in p
    }
    *s = '\0';
 
    s = p; // Again point back s to starting of p
 
    reverse_str(p);
 
    /*!
     * The next two conditions check weather it is required to 
     * add blanks before printing the number (ie: width)and is it specified how many
     * zeros to be printed before the number is printed (ie: precision)
    */
    if (width > 0 && size < width)
        for (int i = 0; i < (width - precision); ++i) 
            put_char(' ');
 
    if (precision > 0 && precision > size)
        for (int i = 0; i < (precision - size); ++i)
            put_char('0');
 
    /* Prints the number.*/
    while (*s != '\0')
        put_char(*s++);
 
    free(p);
}
 
/**
* @brief The algorithm here is also the same as the `print_int_value` function
 *
 * @details
 * First, the digits before decimal is printed by converting the double 
 * to int. Then after printed a `.`, the double number is subtracted with
 * the integer value of the number, leaving us with 0 before the decimal.
 * Then, we multiply the number with 10 raised to the power precision (
 * precision means how many digits to be printed after the decimal.)
 * By default, the precision is 8 if it is not specified.
 * Then, the remaining number is printed on the screen.
 * @param dval double number to be printed
 * @param width similar to width parameter of print_int_value()
 * @param precision tells the number of digits to be printed after the decimal (By default it is 8)
 */
void print_double_value(double dval, int width, int precision)
{
    int ndigits = get_number_of_digits((int) dval); // Store number of digits before decimal in dval
    int reqd_blanks = width - (precision + 1) - ndigits; // Blanks to be printed before printing dval, just to cover the width
    
    print_int_value((int) dval, reqd_blanks, 0); // Prints the part before decimal
 
    put_char('.'); // Print decimal
 
    /*Deletes digits before decimal and makes them zero. For example:
        if dval = 1923.79022, them this will make dval = 0.79022
    */
    dval = dval - (int) dval;
 
    dval *= power_of_ten(precision); // Brings precision number of digits after decimal to before decimal
    
    print_int_value((int) dval, 0, precision); // Prints the remaining number
}
 
/**
 * @details
* First size of the string is calculated to check whether
* width and precision are to be taken into account or not.
* Then, the string is printed in accordingly.
* @param p pointer to string to be printed
* @param width if (width > sizeof string) then, blanks will be printed before sting to cover up the width
* @param precision total characters of the string to be printed (prints the whole string if 0 or greater than size of string)
*/
void print_string(char *p, int width, int precision)
{
    int size = 0; // Stores number of character in string
    char *s = p; // Temporary pointer
 
    /* Calculates size of string p*/
    while (*s != '\0') { 
        ++size;
        ++s;
    }
 
    s = p; // Point s to starting of p
 
    /* Checks how many characters to be printed.
        if precision is defined then size variable is changed to precision so that only precision
        number of characters were printed.
    */
    if (precision != 0 && precision < size)
        size = precision;
 
    /* Prints blanks to cover the width if required*/
    for (int i = 0; i < (width - size); ++i)
        put_char(' ');
 
    /* Print the string.*/
    for (int i = 0; i < size; ++i)
        put_char(*s++);
 
}
 
/**
* @brief Takes width and precision specified from the format of the string
* @param p pointer of the format string
* @param width variable in which width will be stored
* @param precision variable in which precision will be stored
* @return character pointer to the current pointer of string p (used to update value of p)
*/
char *get_width_and_precision(char *p, Buffer *buffer, int *width, int *precision)
{
    /* Skip % if p is pointing to it.*/
    if (*p == '%')
        ++p;
    
    /* Calculates the width specified. */
    while (*p != '.' && is_number(p)) 
        *width = *width * 10 + (*p++ - '0');
 
    /* Calculates the precision specified.*/
    if (*p == '.' /* Since a precision is always specified after a '.'. */) { 
        while (is_number(++p))
            *precision = *precision * 10 + (*p - '0'); 
        unget_ch(p, buffer); // The non number will be stored in `buffer->buffr`
    }
    return p;
}
 
/**
 * min_printf is the function same as printf
 * @param fmt format of string
 * @param ... arguments passed according to the format
*/
void min_printf(char *fmt, ...)
{
    va_list ap; // Points to each unnamed arg in turn
    char *p, *sval; // p will be used to point to fmt and sval will store string value
    char cval; // Stores character value
    int ival; // For integer values
    double dval; // For double or float values
    va_start(ap, fmt); // Makes ap points to first unnames argument
 
    /* Initializing the buffer for storing character. */
    Buffer *buffer = (Buffer *) malloc(sizeof(Buffer));
    buffer->buf_size = 0; // Initially set buffer size to zero as no character is inserted
 
    for (p = fmt; *p != '\0'; ++p) {
        
        /* If p != '%' then the character is printed to screen. */
        if (*p != '%') {
            put_char(*p);
            continue;
        }
        
        int width = 0; // Stores width specified
        int precision = 0; // Stores precision specified
 
        /* Updates values of width, precision and p. */
        p = get_width_and_precision(p, buffer, &width, &precision); 
        
        /* Checks format of next argument.*/
        switch (get_ch(p, buffer)) {
            case 'd': // Integer
                ival = va_arg(ap, int);
                print_int_value(ival, width, precision);
                break;
            case 'c': // Character
                cval = va_arg(ap, int);
                put_char(cval);
                break;
            case 'f': // Float or Double
                dval = va_arg(ap, double);
 
                // If precision is not specified then default value is applied
                if (precision == 0)
                    precision = PRECISION_FOR_FLOAT;
                print_double_value(dval, width, precision);
                break;
            case 's': // String pointer
                sval = va_arg(ap, char *);
                print_string(sval, width, precision);
                break;
            default:
                put_char(*p);
                break;
        }
    }
    va_end(ap);
}
 
#endif /* MIN_PRINTF_H */