Module_CUnix_Alex

EX01
#include <stdlib.h>
#include <stdio.h>

unsigned int 	my_strlen(char *str)
{
	int 	counter, i;
	char 	symbol;

	if(str[0] == '\0')
		return 0;

	counter = 0;
	symbol = str[0];
	
	for(i = 0; symbol != '\0';i++)
	{
		symbol = str[i];
		counter++;
	}

	return counter-1;
}

EX02
#include <stdio.h>
#include <stdlib.h>

int 		my_strcmp(char *str1, char *str2)
{
	int 	i;
	int	res;

       	res = 0;
	if(str1[0] == '\0' && str2[0] == '\0')
		return 0;

	for(i = 0; (str1[i] != '\0') && (str2[i] != '\0'); i++)
	{		
		if (str1[i] > str2[i])
		{
			res = 1;
			break;
		}	
		else
			if(str1[i] < str2[i])
			{
				res = -1;
				break;
			}

	}
	return res;	
}
EX03
#include <stdio.h>
#include <stdlib.h>

char 		*my_strcpy(char *dest, const char *src)
{
	char 	*temp = dest;

  	while (*temp++ = *src++);
  		return dest;
}

EX04
#include <stdio.h>
#include <stdlib.h>

int 			my_length(const char *now)
{
  	int 		i;
  	int 		n;

	i = 0;
	n = 1;
  	while((now[i] <= '9') && (now[i] >= '0'))
  	{
    		i = i + 1;
    		n = n * 10;
  	}
  	return n;
}

int 			my_atoi(const char *nptr)
{
  	const char 	now = *nptr;
  	const char 	*next = ++nptr;
  	const char 	cmp = *next;
  	int 		value;
  
 	value = 0;
  	if (now == '-')
    		return (-1) * my_atoi(next);
  	else 
		if ((now <= '9') && (now >= '0'))
  		{
  			value = now - '0';
    			if ((cmp <= '9') && (cmp >= '0'))
  				value = value * my_length(nptr);
    			return value + my_atoi(next);
  		}
  		else
    			return value;
}

int 			power(int a, int b)
{
	int 		i;
	int 		t;

	t = a;
    	if(b == 0)
        	return 1;
    	for(i = 1; i < b; i++)
        	a = a * t;
	return a;
}

int 			length(int n)
{
	int 		l;
	int 		nmb;

	l = 0;
	for( ; nmb != n; )
	{
		nmb = n % power(10, l);
		l++;
    	}
    	return l - 1;
}

char			*my_itoa(int nmb)
{
	char		*n, zero;
	int 		i, c, ntp, t;

	t = length(nmb);
	n = (char*) malloc(sizeof(char) * t);
	c = 0;
	zero = '0';
	
	if(nmb == 0)
	{
		*n = '0';
		return n;
    	}
    	if(nmb < 0)
    	{
		*n = '-';
		c++;
		t++;
		nmb = (-1) * nmb;
    	}
    	for(i=c; i<t; i++)
    	{
        	ntp = nmb % 10;
        	nmb = nmb / 10;
        	*(n + i) = '0' + ntp;
    	}
    
    	for(i = 0; i < t/2; i++)
    	{
        	char b = *(n + i);
        	*(n + i) = *(n + t - i - 1);
        	*(n + t - i - 1) = b;
    	}

    	if(c != 0)
    	{
		char k = *(n + t - 1);
		for(i = 1; i < t; i++)
		{	
			*(n + t - i) = *(n + t - i - 1);
		}
		*n = k;	
    	}
    
    	return n;
}

EX05
#include <stdio.h>
#include <stdlib.h>
#ifndef EOF
# define EOF (-1)
#endif

int 		my_puts(const char *s)
{
    int 	i;

    i = 0;

    while(s[i])
    {
        if(putchar(s[i]) == EOF)
        {
            return EOF;
        }
        i++;
    }

    if( putchar('\n') == EOF)
    {
        return EOF;
    }
    return 1;
}

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

unsigned int 		my_length_char(char *str)
{
	int 		counter, i;
	char 		symbol;

        if(str[0] == '\0')
                return 0;

        counter = 0;
        symbol = str[0];

        for(i = 0; symbol != '\0'; i++)
        {
                symbol = str[i];
                counter++;
        }
        return counter - 1;
}


int 			my_length(const char *now)
{
	int		i;
	int 		n;

	i = 0;
	n = 1;

  	while((now[i] <= '9') && (now[i] >= '0'))
  	{
    		i = i + 1;
    		n = n * 10;
  	}

  	return n;
}

int			my_atoi(const char *nptr)
{
	const char 	now = *nptr, *next = ++ nptr, compare = *next;
  	int 		value;

  	value = 0;

 	if (now == '-')
    		return (-1) * my_atoi(next);
  	else
        	if ((now <= '9') && (now >= '0'))
        	{
                	value = now - '0';
                	if ((compare <= '9') && (compare >= '0'))
                        	value = value * my_length(nptr);
                	return value + my_atoi(next);
        	}
        	else
                	return value;
}


int 			power(int a, int b)
{
	int 		i, t;

	if(b == 0)
        	return 1;

    	t = a;

    	for(i = 1; i < b; i++)
        	a = a * t;
    	
	return a;
}

int 			length(int n)
{
	int 		l;
	int 		nmb;
	
	l = 0;	
    	
	for( ; nmb != n; )
    	{
        	nmb = n % power(10, l);
        	l++;
    	}
    	return l - 1;
}

char* 			my_itoa(int nmb)
{
    int 		t = length(nmb);
    char 		*n;
    int 		i;
    int 		ntp;

    n = (char*)malloc(sizeof(char) * t);

    for(i=0; i<t; i++)
    {
        ntp = nmb % 10;
        nmb = nmb / 10;
        *(n + i) = '0' + ntp;
    }

    for(i = 0; i < t/2; i++)
    {
        char b = *(n + i);
        *(n + i) = *(n + t - i - 1);
        *(n + t - i - 1) = b;
    }
    return n;
}


void 			my_printf(char *str,...)
{
    int 		arg1, len, i, counter, flag, padding;
    char 		token, tok, *arg2, *temp, *tmp, ch1, ch2;
    va_list 		ap;

    ch1 = ' ';
    ch2 = '0';
    padding = 0;
    flag = 0;
    counter = 0;

    va_start(ap,str);

    while(*str != '\0')
    {
        if(*str == '%')
        {
            if(*(++str) == '0')
                flag = 1;
            else
            {
                --str;
                flag = 0;
            }
            
            if(*(str+1) >= '1' && *(str+1) <='9')
            {
                while((tok = *(++str)) >='0' && tok <='9')
                {
                    counter++;
                }
                tmp = (char*) malloc(counter*sizeof(char));
                for(i = 0; i < counter; i++)
                    --str;
                for(i = 0; i < counter; i++)
                {
                    *(tmp+i) = *(str++);
                }
                for(i = 0; i <= counter; i++)
                    --str;
                padding = my_atoi(tmp);
                str += counter;
                counter = 0;
            }
            
            token = *(++str);
            
	    switch(token)
            {
                case 'd':
                    arg1 = va_arg(ap, int);
                    len = length(arg1);
                    if (flag == 0)
                        for(int i = 0; i < padding - len; i++)
                            write(1, &ch1, sizeof(ch1));
                    else
                        if(flag == 1)
                            for(int i = 0; i < padding - len; i++)
                                write(1, &ch2, sizeof(ch1));
                    char ch_write;
                    for (int i = len; i > 0 ; i--)
                    {
                        ch_write = arg1 / power(10, i-1) + 48;
                        write(1, &ch_write, 1);
                        arg1 = arg1 % power(10, i-1);
                    }
                break;
                
                case '%':
                    len = 1 ;
                    if (flag == 0)
                        for(int i = 0; i < padding - len; i++)
                            write(1, &ch1, sizeof(ch1));
                    else
                        if(flag == 1)
                            for(int i = 0; i < padding - len; i++)
                                write(1, &ch2, sizeof(ch1));
                    write(1, &token, sizeof(token));
                break;
                
                case 's':
                    arg2 = va_arg(ap, char *);
                    len = my_length_char(arg3);
                    
                    if (flag == 0)
                            for(int i = 0; i < padding - len; i++)
                                write(1, &ch1, 1);
                    else
                        if(flag == 1)
                            for(int i = 0; i < padding - len; i++)
                                write(1, &ch2, 1);
                    
                    for(arg2; *arg2; arg2++)
                         write(1, arg3, 1);
                            
                break;
            }
        
        }
        else
            write(1, &(*str), sizeof(*str));
            
        str++;
    }
}

EX07
#include "linked_list.h"

node_t 		*list_create(void *data)
{
	node_t 	*cur;

       	cur = (node_t *) malloc(sizeof(node_t));
	
	cur->data = data;
	cur->next = NULL;
	return cur;
}

void 		list_destroy(node_t **head, void(*fp)(void *))
{
	if((*head) == NULL)
		return;
	fp((*head)->data);
	list_destroy(&(*head)->next, fp);
	free(*head);
}

void 		list_push(node_t *head, void *data)
{
	node_t 	*temp = head;
	node_t 	*cur;

       	cur = (node_t*) malloc(sizeof(node_t));

	while(temp->next != NULL)
		temp = temp->next;
	cur->data = data;
	cur->next = NULL;
	temp->next = cur;
}

void 		list_unshift(node_t **head, void *data)
{
	node_t 	*cur;
       	
	cur = (node_t*) malloc(sizeof(node_t));
	
	cur->data = data;
	cur->next = *head;
	*head = cur;
}

void 		*list_pop(node_t **head)
{
	node_t 	*temp = *head;
	node_t 	*cur = *head;

	if((*head)->next == NULL)
	{
		free(*head);
		*head = NULL;
		return NULL;
	}

	cur = cur->next;
	
	while(cur->next != NULL)
	{
		cur = cur->next;
		temp = temp->next;
	}
	
	void *data = cur->data;
	free(temp->next);
	temp->next = NULL;
	return data;
}

void 		*list_shift(node_t **head)
{
	node_t 	*cur = *head;
	
	*head = cur->next;
	void *data = cur->data;
	free(cur);
}

void 		*list_remove(node_t **head, int pos)
{
	int 	i;
	node_t 	*cur = *head;
	node_t 	*temp = *head;

	i = 0;
	cur = cur->next;

	while(i < pos-1)
	{
		cur = cur->next;
		temp = temp->next;
		i++;
	}
	
	void *data = cur->data;
	temp->next = cur->next;
	free(cur);
	return data;
}

void 		list_print(node_t *head)
{
	node_t 	*cur = head;
	
	while(cur)
	{
		printf("%s", cur->data);
		cur = cur->next;
	}
}

void 		list_visitor(node_t *head, void(*fp)(void *data))
{
	if(head->next != NULL)
		list_visitor(head->next, fp);
	fp(head->data);
}

EX08
#include "binary_tree.h"

node_t  	*allocnode()
{
    	node_t 	*new;

       	new = (node_t *) malloc(sizeof(node_t));
    	
	new->left = NULL;
    	new->right = NULL;
    	return new;
}


node_t  	*insert(node_t *root, char *key, void *data)
{
    	if(root == NULL)
    	{
		root = allocnode();
		root->key = key;
		root->data = data;
   	}
    	else if(root->key >= key)
		root->right = insert(root->right, key, data);
    	else
		root->left = insert(root->left, key, data);
    	return root;
}

void 		print_node(node_t *node)
{
	if (node != NULL)
		printf("%s\n", node->data);
 	else
	 	return;
}


void 		visit_tree(node_t *node, void (*fp)(node_t *root))
{
  	if(node->right != NULL)
  	{
    		if(node->left != NULL)
    		{
      			visit_tree(node->left, fp);
      			visit_tree(node->right, fp);
    		}
    		else
    		{
        		visit_tree(node->right, fp);
    		}
  	}
  	else
  	{
    		if(node->left != NULL)
    		{
      			visit_tree(node->left, fp);
    		}
  	}
  	fp(node);
}


void 		destroy_tree(node_t *node, void (*fdestroy)(node_t *root))
{
  	if(node->right != NULL)
  	{
    		if(node->left != NULL)
    		{
      			destroy_tree(node->left, fdestroy);
      			destroy_tree(node->right, fdestroy);
    		}
    		else
    		{
        		destroy_tree(node->right, fdestroy);
    		}	
  	}
  	else
  	{
    		if(node->left != NULL)
    		{
      			destroy_tree(node->left, fdestroy);
    		}
  	}

	fdestroy(node);
	free(node);
}

EX09
#include "hash.h"
#include "linked_list.h"

hashtable_t 		*hash_create(unsigned int size)
{
	hashtable_t 	*new;
	
	if(size > 0)
	{
		new = (hashtable_t*) malloc(sizeof(hashtable_t));	
		new->size = size;
		new->table = (void **) malloc(size*sizeof(void*));
		int i;
		for(i = 0; i < size; i++)
		{
			new->table[i] = NULL;
		}
		return new;
	}
	return NULL;
}

void 			hash_destroy(hashtable_t *ht, void (*fp)(void *data))
{
	int 		i;
	node_t		*cur;
	
	for(i = 0; i < ht->size; i++)
	{
		if(ht->table[i] != NULL)
		{
			cur = ht->table[i];
			list_destroy(&cur, fp);
		}
	}
	free(ht->table);
	ht->table = NULL;
	free(ht);
}

unsigned int 		hash_func(char *key)
{
	int 		sum, i;
	
	if(key == NULL)
		return 0;
	
	sum = 0;
	
	for(int i = 0; *key != '\0'; i++)
	{
		sum += *(key);
		key = key + 1;
	
	}
	return sum;
}

void 			hash_set(hashtable_t *ht, char *key, void *ptr, void (*fp)(void *data))
{
	unsigned int 	k; 
		
	k = hash_func(key) % ht->size;

	if(ht->table[k] == NULL)
	{
		ht->table[k] = list_create(ptr);	
	}
	else
	{
		list_push(ht->table[k], ptr);
	}
	fp(key);
}

void 			*hash_get(hashtable_t *ht, char *key)
{
	int 		k; 
	node_t 		*cur;
		
	k = hash_func(key) % ht->size;
	
	if(ht->table[k] == NULL)
		return NULL;

	cur = ht->table[k];
	
	return cur->data;
}

EX10
filler.c
#include "../include/filler.h"
#include <stdio.h>
#include <stdlib.h>

int 					main()
{
	filler_t 		new_filler;

	create_filler(&new_filler);
	start_game(&new_filler);
	destroy_filler(&new_filler);

	return 0;
}

game.c
#include <stdio.h>
#include <stdlib.h>
#include "../include/filler.h"

void timeout_reset(struct timeval *timer)
{
	timer->tv_sec = 1;
	timer->tv_usec = 0;
}

void 			start_game(filler_t *filler)
{
	struct timeval 	timeout;
	req_t 		*req;
	fd_set 		rfds;
	fd_set 		wfds;
	pos_t 		p;
	FILE 		*logger;
	int 		ret;
	logger = fopen("filler.log", "w");
	fprintf(logger, "start game\n");
	fclose(logger);

	create_req(req);
	set_nonblocking(0);

	while(42)
	{
		FD_ZERO(&rfds);
		FD_ZERO(&wfds);

		switch(filler->status)
		{
			case 1:
				FD_SET(1, &wfds);
				break;
			case 0:
				FD_SET(0, &rfds);
				break;
		}
		timeout_reset(&timeout);

		ret = select(2, &rfds, &wfds, NULL, &timeout);

		if(ret < 0){
		}

		if(FD_ISSET(0, &rfds))
		{
			req = read_request(filler);

			logger = fopen("filler.log", "a");
			fprintf(logger, "\nRead complete\n");
			fclose(logger);
				

			if(req != NULL)
			{
				logger=fopen("filler.log", "a");
				fprintf(logger, "Req != NULL\n");
				fclose(logger);

				p = play(req, filler);
			
				logger=fopen("filler.log", "a");
				fprintf(logger, "Play position complete\n");
				fclose(logger);

				filler->status = 1;	
			}
		}

		if(FD_ISSET(1, &wfds))
		{
			print_pos(p);

			logger=fopen("filler.log", "a");
			fprintf(logger, "Return position\n");
			fclose(logger);

			filler->status = 0;
			string_destroy(filler->current_stream);
			filler->current_stream = NULL;
		}
	}
}

game_logic.c
#include <stdio.h>
#include <stdlib.h>
#include "../include/filler.h"

pos_t 		play(req_t *core, filler_t *filler)
{
	pos_t 	res;
	FILE 	  *logger;
	int 	  h;
	int 	  w;
	int 	  flag;
	
	flag = 1;
	h = core->map.h;
	w = core->map.w;

	logger = fopen("filler.log", "a");
	fprintf(logger, "Play\n");
	fprintf(logger, "core->map.h = %d, core->map.w = %d/n", core->map.h, core->map.w);
	fclose(logger);	

	for(int i = h-1; i>=0; i--)
		for(int j = 0; j < w; j++)
		{
			logger = fopen("filler.log", "a");
			fprintf(logger, "Play circle\n");
			fclose(logger);

			res.x = j;
			res.y = i;

			pos_t temp;
			temp.x = res.x;
			temp.y = res.y;

			for(int m = 0; m < w; m++)
				if(core->map.array[h-1][m] == core->symbol)
				{
					res.x = -100;
					res.y = -100;
					flag = 0;
					break;

				}

			for(int m = 0; m < h; m++)
				if(core->map.array[m][0] == core->symbol)
				{
					res.x = -100;
					res.y = -100;
					flag = 0;
					break;
				}

			if(!check_free_space(&(core->map), &(core->elem), res) && !check_connection(&(core->map), &(core->elem), res, core->symbol))
			{
				logger = fopen("filler.log", "a");
				fprintf(logger, "RES POS = %d %d\n", res.x, res.y);
				fclose(logger);
				return res;
			}
			else
			{
				logger = fopen("filler.log", "a");
				fprintf(logger, "%d and %d don't fit\n", i, j);
				fclose(logger);
			}
		}

	if(flag == 0)
		for(int i = 0; i < h; i++)	
			for(int j = w - 1; j >= 0; j--)
			{
				res.x = j;
				res.y = i;

				for(int m = 0; m < w; m++)
					if(core->map.array[0][m] == core->symbol)
					{
						res.x = -100;
						res.y = -100;
						flag = 2;
						break;
					}
	
				for(int m = 0; m < h; m++)
					if(core->map.array[m][w-1] == core->symbol)
					{
						res.x = -100;
						res.y = -100;
						flag = 2;
						break;
					}

				if(!check_free_space(&(core->map), &(core->elem), res) && !check_connection(&(core->map), &(core->elem), res, core->symbol))
				{
					logger = fopen("filler.log", "a");
					fprintf(logger, "RES POS = %d %d\n", res.x, res.y);
					fclose(logger);
					return res;
				}
			}

	if(flag == 2)
	{
		logger = fopen("filler.log", "a");
		fprintf(logger, "Flag 2 \n");
		fclose(logger);

		for(int i = 0; i < (w+h)/2; i++)
		{
			res.x = i;
			res.y = i;
			for(int m = 0; m < w/8 * 1; m++)
				if(core->map.array[0][m] == core->symbol)
				{
					res.x = -100;
					res.y = -100;
					break;
				}
			for(int m = 0; m < h/8 * 1; m++)
				if(core->map.array[m][0] == core->symbol)
				{
					res.x = -100;
					res.y = -100;
					flag = 4;
					break;
				}

			if(!check_free_space(&(core->map), &(core->elem), res) && !check_connection(&(core->map), &(core->elem), res, core->symbol))
			{
				logger = fopen("filler.log", "a");
				fprintf(logger, "RES POS = %d %d\n", res.x, res.y);
				fclose(logger);
				return res;
			}
		
		}
	
	}

	for(int j = w - 1; j >= 0; j--)
		for(int i = h - 1; i >= 0; i--)
		{
			res.x = j;
			res.y = i;
		
			if(!check_free_space(&(core->map), &(core->elem), res) && !check_connection(&(core->map), &(core->elem), res, core->symbol))
			{
				logger = fopen("filler.log", "a");
				fprintf(logger, "RES POS = %d %d\n", res.x, res.y);
				fclose(logger);
				return res;
			}
			else
			{
				logger = fopen("filler.log", "a");
				fprintf(logger, "%d and %d not mine point \n", i, j);
				fclose(logger);
			}
		}

	return res;
}

input.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>

#include "filler.h"
#include "my_string.h"

#define BUF_SIZE 64

req_t 		*parse_all(char *all)
{
	int 	i;
	map_t 	map;
	elem_t 	elem;
	req_t 	*request;
	pos_t 	position;
	int 	flag;
	int 	n;
	int 	m;
	char 	*pos1;
	char 	*pos2;
	FILE 	*logger;

	i = 0;
	flag = 0;
	n = 0;
	m = 0;
	request = (req_t *) malloc(sizeof(req_t));
	pos1 = (char *) malloc(BUF_SIZE * sizeof(char));
	pos2 = (char *) malloc(BUF_SIZE * sizeof(char));

	memset(pos1, '\0', BUF_SIZE);
	memset(pos1, '\0', BUF_SIZE);

	logger = fopen("filler.log", "a");
	fprintf(logger, "parse\n");
	fclose(logger);

	request->symbol = *all;
	m += 2;

	do
	{
		*(pos1 + n) = *(all + m);
		m++;
		n++;
	}while(*(all + m - 1) != '\n');
	
	position = parse_size(pos1);
	request->map.h = position.x;
	request->map.w = position.y;

	request->map.array = (char **) malloc(request->map.h * sizeof(char*));
	
	logger=fopen("filler.log", "a");
	fprintf(logger, "first size: %d %d\n", request->map.h, request->map.w);
	fclose(logger);
	
	for(int i = 0; i < request->map.h; i++)
		request->map.array[i] = (char *) malloc((request->map.w + 1) * sizeof(char));

	for(int i = 0; i < request->map.h; i++)
		for(int j = 0; j < request->map.w + 1; j++)
		{
			*(*(request->map.array + i) + j) = *(all + m);
			logger = fopen("filler.log", "a");
			fprintf(logger, "%c", *(*(request->map.array + i)+j));
			fclose(logger);
			m++;
		}
	
	n = 0;

	do
	{
		*(pos2 + n) = *(all + m);
		m++;
		n++;
	}while(*(all + m - 1) != '\n');

	position = parse_size(pos2);
	request->elem.h = position.x;
	request->elem.w = position.y;

	request->elem.array = (char **) malloc(request->elem.h * sizeof(char*));

	logger = fopen("filler.log", "a");
	fprintf(logger, "second size: %d %d\n", request->elem.h, request->elem.w);
	fclose(logger);

	for(int i = 0; i < request->elem.h; i++)
		request->elem.array[i] = (char *)malloc((request->elem.w+1) * sizeof(char));

	for(int i = 0; i < request->elem.h; i++)
		for(int j = 0; j < request->elem.w +1; j++)
		{
			*(*(request->elem.array + i) + j) = *(all + m);
			logger = fopen("filler.log", "a");
			fprintf(logger, "%c", *(*(request->elem.array + i) + j));
			fclose(logger);
			m++;
		}
	
	logger = fopen("filler.log", "a");
	fprintf(logger, "end of parsing");
	fclose(logger);
	free(pos1);
	free(pos2);
	return request;	
}

pos_t 		parse_size(char *answer)
{
	pos_t 	cur;
	int 	flag;
	char 	*c1 = NULL;
	char 	*c2 = NULL;
	int 	t1;
	int 	t2;
	FILE 	*logger;

	flag = 0;
	t1 = 0;
	t2 = 0;
	c1 = (char*) malloc(strlen(answer) * sizeof(char));
	c2 = (char*) malloc(strlen(answer) * sizeof(char));

	memset(c1, '\0', strlen(answer));
	memset(c2, '\0', strlen(answer));

	for(int i = 0; *(answer+i) != '\n'; i++)
	{
		if(*(answer+i) == ' ')
		{
			flag = 1;
			continue;
		}

		if(flag == 0)
		{
			*(c1 + t1) = *(answer+i);
			t1++;
		}

		if(flag == 1)
		{
			*(c2 + t2) = *(answer+i);
			t2++;
		}
		
	}
	
	cur.x = atoi(c1);
	cur.y = atoi(c2);

	logger = fopen("filler.log", "a");
	fprintf(logger, "c1 = %s, c2 = %s\n", c1, c2);
	fclose(logger);

	free(c1);
	free(c2);

	return cur;
}

int		find_size(char res[32], char *buf, int start_pos)
{
	int 	i;

	i = 0;

	do
	{
    		res[i] = buf[start_pos];
    		start_pos++;
    		i++;
  	}
  	while (buf[start_pos-1] != '\n');
  	
	res[i] = '\0';
  	start_pos++;

  	return i-1;
}

int         	read_is_finished(stream_t* buf)
{
	int 	pos;
  	bool 	first_size;
  	int 	elem_pos;
  	char 	arr_elem_size[32];
  	pos_t 	el_size;

	pos = 0;
	first_size = true;
	elem_pos = 0;
	
  	while(pos <= buf->size)
  	{
    		if(buf->str[pos] > '9' || buf->str[pos] < '0')
      			pos++;
    		else if (first_size)
    		{
      			while(pos <= buf->size && buf->str[pos] != '\n')
        			pos++;
      			pos++;
      			first_size = false;
    		}
    		else
    		{
      			elem_pos = pos;
      			while(pos <= buf->size && buf->str[pos] != '\n')
        			pos++;
      			if(buf->str[pos] != '\n')
        			return -1;
      			else
      			{
        			find_size(arr_elem_size, buf->str, elem_pos);
        			el_size = parse_size(arr_elem_size);
        			if(buf->size <= pos + el_size.x*(el_size.y + 1))
          				return -1;
        			else return 0;
      			}
    		}
  	}

  	return -1;
}

void            read_input(filler_t* filler)
{
  	char    buffer[BUF_SIZE];
  	int     res;
	FILE 	*logger;

  	while(42)
  	{
      		memset(buffer, '\0', BUF_SIZE);
      		res = read(0, buffer, BUF_SIZE - 1);

      		if(!strlen(buffer))
		{
			logger = fopen("filler_new.log", "a");
      			fprintf(logger,"buffer: empty", buffer);
      			fclose(logger);	
			break;
		}
      	
		if(filler->current_stream == NULL)
       			filler->current_stream = string_create(buffer);
      		else
	      		string_append(filler->current_stream, buffer);
	}

	logger = fopen("filler_new.log", "a");
	fprintf(logger,"all buffer: %s\n", filler->current_stream->str);
	fclose(logger);
}

req_t       	*read_request(filler_t *filler)
{
	req_t   *req = NULL;

	read_input(filler);

	if(read_is_finished(filler->current_stream) == 0)
		req = parse_all(filler->current_stream->str);

	return req;
}

my_string.c
#include "filler.h"
#include "my_string.h"                                                                                                                                  
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define COEF 2

stream_t		*string_init()
{
	stream_t 	*str;

	str = (stream_t *) malloc(sizeof(stream_t));
  	str->str = NULL;
  	str->size = 0;
  	str->limit = 0;
  	return str;
}

void 			string_add(stream_t *s, char* str)
{
	int 		len;

	len = strlen(str);
  	for(int i = 0; i < len; i++)
    		s->str[s->size + i] = str[i];
  	s->size += len;
  	s->str[s->size + len] = 0;
}

stream_t 		*string_create(char* str)
{
	stream_t	*s;
  	int 		size;

	s = string_init();
	size = strlen(str);
  	s->limit = size * COEF + size;
  	s->str = (char*)malloc(s->limit * sizeof(char));
  	string_add(s, str);
  	return s;
}

void 			string_append(stream_t *s, char *str)
{
  	int 		len;

	len = strlen(str);
  	if(s->size + len > s->limit)
	{
    		s->limit = s->limit * COEF + len;
    		s->str = realloc( s->str, s->limit * sizeof(char));
    		s->str[s->size + len] = 0;
  	}
  	string_add(s, str);
}

void 			string_destroy(stream_t *s)
{
  	free(s->str);
  	free(s);
}

print.c
#include <stdio.h>
#include <stdlib.h>
#include "../include/filler.h"

void 		print_pos(pos_t p)
{
	FILE 	*logger;

	dprintf(1, "%d %d", p.x, p.y);

	logger = fopen("filler.log" , "a");
	fprintf(logger, "Print pos: %d %d\n", p.x, p.y);
	fclose(logger);
}

tools.c
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include "../include/filler.h"

int set_nonblocking(int fd)
{
	int flags = fcntl(fd, F_GETFL, 0);
	return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

void fatal(char *msg)
{
	dprintf(2, msg);
	exit(1);
}

void create_filler(filler_t *filler)
{
	filler->current_stream = NULL;
	filler->status = 0;
}

void destroy_filler(filler_t *filler)
{
	string_destroy(filler->current_stream);
}

void create_req(req_t *req)
{
	req = (req_t*) malloc(sizeof(req_t));
}


void destroy_req(req_t *req)
{
	free(req);
	req = NULL;
}

int check_free_space(map_t *map, elem_t *new_elem, pos_t p)
{
  for(int i = 0; i < new_elem->h; i++)
    for(int j = 0; j < new_elem->w; j++)
      if(new_elem->array[i][j] == '*')
      {
        if(i + p.y < map->h && j + p.x < map->w && i + p.y >= 0 && j + p.x >= 0)
        {
          if(map->array[i + p.y][j + p.x] != '.')
            return -1;
        }
        else
         return -1;
      }
  return 0;
}

int check_connection(map_t *map, elem_t *new_elem, pos_t p, char symbol)
{
  int i_max = map->w - p.y;
  int j_max = map->h - p.x;

  for(int i = 0; i < new_elem->h; i++)
    for(int j = 0; j < new_elem->w; j++)
      if(new_elem->array[i][j] != '.')
      {
        if(i + p.y + 1 < map->h && map->array[i + p.y + 1][j + p.x] == symbol)
            return 0;
        if (i + p.y - 1 >= 0 && map->array[i + p.y - 1][j + p.x] == symbol)
            return 0;
        if (j + p.x + 1 < map->w && map->array[i + p.y][j + p.x + 1] == symbol)
            return 0;
        if (j + p.x - 1 >= 0 && map->array[i + p.y][j + p.x - 1] == symbol)
            return 0;
      }
  return -1;
}