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

const size_t StartSize = 15;
const size_t increase = 2;
int F = 0;
/*
 Мирзоева Умджат АПО-12
 ИЗ1
 Составить программу построчной обработки текста. Суть обработки - приведение каждого символа в
 каждой строке к нижнему регистру.
 Программа считывает входные данные со стандартного ввода, и печатает результат в стандартный вывод.
 Процедура приведения к нижнему регистру должна быть оформлена в виде отдельной функции,
 которой на вход подается массив строк (который необходимо обработать),
 количество переданных строк, а также указатель на переменную, в которой необходимо разместить
 результат - массив уже обработанных строк.
 В качестве возвращаемого значения функция должна возвращать количество строк,
 содержащихся в результирующем массиве.
 Программа должна уметь обрабатывать ошибки - такие как неверные входные данные
 (отсутствие входных строк) или ошибки выделения памяти и т.п.
 В случае возникновения ошибки нужно выводить об этом сообщение "[error]" и завершать выполнение
 программы.  */

char* OneString() {
    size_t size = StartSize;
    char* string = (char*)calloc(sizeof(char), size);
    if (string == NULL){
        free(string);
        return NULL;
    }
    fgets(string, size, stdin);
    size_t j = strlen(string);
    if (strlen(string) == 1 && (string[0] = '\n' || string[0] == EOF)){
        free(string);
        return NULL;
    }
    if (string[j-1] != '\n') {
        size *= increase;
        char* res = (char*) realloc(string, sizeof(char) * size);
        if (res == NULL) {
            free(string);
            free(res);
            return 0;
        }
        string = res;
        F = 1;
    } else {
        F = 0;
        string[j-1] = '\0';
    }
    return string;
}


void FreeAll(int size, char **array){
    for (int i = 0; i < size; i++){
        free(array[i]);
    }
    free(array);
}

char** AllStrings(int *StrSize) {
    size_t size = StartSize;
    char** strings = (char**)calloc(sizeof(char*), size);
    if (strings == NULL){
        (*StrSize) = 0;
        return 0;
    }
    int  i;
    char *string = OneString();
    for (i = 0; !feof(stdin) && !ferror(stdin); i++)  {
        if (string == NULL || string[0] == '\0') {
            free(string);
            return strings;
        }
        //увеличиваем размер массива по необходимости
        if (i >= size) {
            size *= increase;
            char** res = (char**) realloc(strings, sizeof(*strings) * size);
            if (res == NULL) {
                FreeAll(size/increase, strings);
                FreeAll(size, res);
                free(string);
                return 0;
            }
            strings = res;
            FreeAll(size, res);
        }
        //добавляем строку
        size_t Size = StartSize;
        while (F == 1){
            char* letter = OneString();
            Size *= increase;
            char * ans = strcat(string, letter);
            char* res = (char*) realloc(ans, sizeof(*strings) * size);
            if (res == NULL) {
                free(string);
                free(res);
                return 0;
            }
            string = res;
        }
        strings[i] = string;
        string = OneString();
        (*StrSize)++;
    }
    //освобождаем память, если вдруг на вход не было подано ничего
    if (ferror(stdin) || (i == 0 && string == NULL) ) {
        FreeAll(i, strings);
        free(string);
        return NULL;
    }
    if (string != NULL) {
        //увеличиваем размер массива по необходимости
        if (i >= size) {
            size += 1;
            char** res = (char**) realloc(strings, sizeof(*strings) * size);
            if (res == NULL) {
                FreeAll(size/increase, strings);
                FreeAll(size, res);
                free(string);
                return 0;
            }
            strings = res;
            FreeAll(size, res);
        }
        //добавляем строку
        strings[i++] = string;
        (*StrSize)++;
    }
    return strings;
}
char** ToLowerCase(const char *const *strings, int *StrSize) {
    if (strings == NULL || * StrSize == 0) {
        return 0;
    }
    char** answer_strings = (char**)malloc(sizeof(char*) * *StrSize);
    if (answer_strings == NULL){
        return 0;
    }
    size_t i;
    for (i = 0; i < *StrSize; ++i) {
        size_t cur_size = strlen(strings[i]);
        answer_strings[i] = (char*)calloc(sizeof(char), cur_size + 1);
        size_t k;
        for (k = 0; k < cur_size + 1; ++k) {
            if (strings[i][k] >= 'A' && strings[i][k] <= 'Z'){
                answer_strings[i][k] = strings[i][k] + 'a' - 'A';
            }
            else {
                answer_strings[i][k] = strings[i][k];
            }
        }
    }
    return answer_strings;
}

int check(int check){
    if (check == 0){
        printf("[error]");
        return 0;
    }
    return 1;
}

int main(){
    //считываем строки
    int StrSize = 0;
    char** incoming = (AllStrings(&StrSize));
    if (check(StrSize) == 0) {
        return 0;
    }
    //приводим к нижнему регистру
    char** answer = ToLowerCase((const char *const *) incoming, &StrSize);
    if (check(StrSize) == 0){
        return 0;
    }
    //выводим на экран
    for (int i = 0; i < StrSize; ++i) {
        printf("%s", answer[i]);
        printf("\n");
    }
    //освобождаем память
    FreeAll(StrSize, incoming);
    FreeAll(StrSize, answer);
    return 0;
}