min_printf.h File Reference

Implementation of a function similar to printf More...

#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>

Include dependency graph for min_printf.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	buffer
	struct used to store character in certain times More...

Macros
#define	INT_MAX_LENGTH   10
	for malloc and free functions for write function for va_start and va_arg functions
#define	PRECISION_FOR_FLOAT   8

Typedefs
typedef struct buffer	Buffer
	struct used to store character in certain times

Functions
int	power_of_ten (int a)
int	is_number (char *c)
	Checks if a character is a number. More...
char	get_ch (char *p, Buffer *buffer)
	Returns specific required next character. More...
void	unget_ch (char *c, Buffer *buffer)
	Stores character to the buffer->buffr_char More...
int	get_number_of_digits (int n)
	Calculates the number of digits in a number. More...
void	put_char (char s)
	Prints one character on screen. More...
void	reverse_str (char *p)
	Reverses a string using two pointer algorithm More...
void	print_int_value (int n, int width, int precision)
void	print_double_value (double dval, int width, int precision)
	The algorithm here is also the same as the print_int_value function. More...
void	print_string (char *p, int width, int precision)
char *	get_width_and_precision (char *p, Buffer *buffer, int *width, int *precision)
	Takes width and precision specified from the format of the string. More...
void	min_printf (char *fmt,...)
	min_printf is the function same as printf More...

Detailed Description

Implementation of a function similar to printf

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

Function Documentation

get_ch()

char get_ch	(	char *	p,
		Buffer *	buffer
	)

Returns specific required next character.

Parameters

p	pointer to a format string of min_printf()
buffer	struct for checking if buffr_char character is present or not

Returns

character inside buffer->buffr_char, if buffer->buf_size is one

character at which p is pointing, if buffer->buf_size is zero

< Since character is used, this sets buffer->buf_size to zero

{
    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++;
}

get_number_of_digits()

int get_number_of_digits

(

int

n

)

Calculates the number of digits in a number.

Parameters

n	number whose digits are to be counted

Returns

number of digits in 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;
}

get_width_and_precision()

char * get_width_and_precision	(	char *	p,
		Buffer *	buffer,
		int *	width,
		int *	precision
	)

Takes width and precision specified from the format of the string.

Parameters

p	pointer of the format string
width	variable in which width will be stored
precision	variable in which precision will be stored

Returns

character pointer to the current pointer of string p (used to update value of p)

{
    /* 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;
}

Here is the call graph for this function:

is_number()

int is_number

(

char *

c

)

Checks if a character is a number.

Parameters

c	character to be checked if it's a number or not

Returns

true(1) if the character is a number

false(0) if the character is NOT a number

{
    return (*c >= '0' && *c <= '9') ? 1 : 0;
}

min_printf()

void min_printf	(	char *	fmt,
			...
	)

min_printf is the function same as printf

Parameters

fmt	format of string
...	arguments passed according to the format

{
    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);
}

Here is the call graph for this function:

power_of_ten()

int power_of_ten

(

int

a

)

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);

Parameters

a	The power of ten which is to be returned

Returns

Ten to the power a

< This number will be returned as ten to power of 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;
}

print_double_value()

void print_double_value	(	double	dval,
		int	width,
		int	precision
	)

The algorithm here is also the same as the print_int_value function.

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.

Parameters

dval	double number to be printed
width	similar to width parameter of print_int_value()
precision	tells the number of digits to be printed after the decimal (By default it is 8)

{
    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
}

Here is the call graph for this function:

print_int_value()

void print_int_value	(	int	n,
		int	width,
		int	precision
	)

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

Parameters

n	Number to be printed
width	Total characters to be printed (Prints ' ' if (size < width)
precision	Total character of number to be printed (prints 0 before number if size of number < precision)

< Used to store number of digits in number

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)

{
    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 occured
        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);
}

Here is the call graph for this function:

print_string()

void print_string	(	char *	p,
		int	width,
		int	precision
	)

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.

Parameters

p	pointer to string to be printed
width	if (width > sizeof string) then, blanks will be printed before sting to cover up the width
precision	total characters of the string to be printed (prints the whole string if 0 or greater than size of string)

{
    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++);
 
}

Here is the call graph for this function:

put_char()

void put_char

(

char

s

)

Prints one character on screen.

Parameters

s	character to be printed on the screen

{
    /* 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);
}

reverse_str()

void reverse_str

(

char *

p

)

Reverses a string using two pointer algorithm

Parameters

p	pointer to the string which is to be reversed

{
    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
    }
}

unget_ch()

void unget_ch	(	char *	c,
		Buffer *	buffer
	)

Stores character to the buffer->buffr_char

Parameters

c	character to be stored in the buffer->buffr_char
buffer	struct where character will be stored

{
    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
}