teclado.c

/*
  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
    Blog:       https://parzibyte.me/blog
    Ayuda:      https://parzibyte.me/blog/contrataciones-ayuda/
    Contacto:   https://parzibyte.me/blog/contacto/
    
    Copyright (c) 2020 Luis Cabrera Benito
    Licenciado bajo la licencia MIT
    
    El texto de arriba debe ser incluido en cualquier redistribución
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXIMA_LONGITUD_LINEA 100000

char *nombreArchivoOriginal = "teclado-entrada.txt";
char *nombreArchivoSalida = "teclado-salida.txt";
char INICIO = '[';
char FIN = ']';

// Nodo que tiene la línea
struct nodo {
    char linea[MAXIMA_LONGITUD_LINEA];
    struct nodo *siguiente;
};
// La parte superior de la lista; es decir, por donde comenzamos
struct nodo *superior = NULL;


void agregarLineaALista(char *linea) {
    // El que se agregará; reservamos memoria
    struct nodo *nuevoNodo = malloc(sizeof(struct nodo));

    // Le ponemos el dato
    strcpy(nuevoNodo->linea, linea);

    // Si es el primer elemento que se agrega...
    if (superior == NULL) {
        superior = nuevoNodo;
        return;
    }

    // Si no, buscamos el último elemento y le asignamos el valor al mismo
    struct nodo *temporal = superior;
    while (temporal->siguiente != NULL) {
        temporal = temporal->siguiente;
    }
    temporal->siguiente = nuevoNodo;
}


void insertarSubcadena(char *original, char *subcadena, int indice) {
    // El inicio es copiar la original N caracteres definidos por posición
    char inicio[MAXIMA_LONGITUD_LINEA] = "";
    strncpy(inicio, original, indice);
    // El final es copiar desde la posición N caracteres definidos por los sobrantes
    char fin[MAXIMA_LONGITUD_LINEA] = "";
    strncpy(fin, original + indice, strlen(original) - indice);
    // Agregar la subcadena al inicio
    strcat(inicio, subcadena);
    // Y agregar el fin a la anterior cadena, es decir, al inicio
    strcat(inicio, fin);
    // Copiarla dentro de la cadena recibida
    strcpy(original, inicio);
}


void arreglarTexto(char *linea, char destino[MAXIMA_LONGITUD_LINEA]) {
    // Bandera para saber si el teclado presionó [ o ]
    int deberiaEscribirAlInicio = 0;
    // Si se escribe al inicio se debe llevar un contador para evitar
    // colocar el texto al revés
    int contador = 0;

    /*
     * Recorrer la línea letra por letra...
     * */
    for (size_t x = 0; x < strlen(linea); x++) {

        char caracterActual = linea[x];
        // Una cadena de un único carácter, útil para convertir char a char*
        char cadenaTemporal[2] = "\0";
        cadenaTemporal[0] = caracterActual;

        // Si se detecta un [ o ] entonces se reinicia el contador
        if ((caracterActual == FIN || caracterActual == INICIO) && deberiaEscribirAlInicio) {
            contador = 0;
        }

        // Si se encuentra un [ o ] entonces solo se cambia la bandera y se salta en el ciclo
        if (caracterActual == INICIO) deberiaEscribirAlInicio = 1;
        else if (caracterActual == FIN) deberiaEscribirAlInicio = 0;
        if (caracterActual == INICIO || caracterActual == FIN) continue;

        // Arreglar la línea. Si es al inicio inserta la letra en la cadena según el contador
        if (deberiaEscribirAlInicio) {
            insertarSubcadena(destino, cadenaTemporal, contador);
            contador++;
        } else {
            // Si no, la agrega al final, usando strcat
            strcat(destino, cadenaTemporal);
        }
    }
}

void cargarArchivoEnMemoria() {
    FILE *archivoOriginal;
    int tamanioBuffer = MAXIMA_LONGITUD_LINEA;
    char linea[tamanioBuffer];


    archivoOriginal = fopen(nombreArchivoOriginal, "r");
    if (archivoOriginal == NULL) {
        printf("Imposible leer el archivo %s", nombreArchivoOriginal);
        exit(EXIT_FAILURE);
    }
    while (fgets(linea, tamanioBuffer, archivoOriginal)) {
        size_t longitudLinea = strlen(linea);
        // Checar si la línea no es un salto de línea vacío
        if (longitudLinea > 1) {
            // De la línea, removemos el salto de línea
            strtok(linea, "\n");
            agregarLineaALista(linea);
        }
    }
    fclose(archivoOriginal);
}

void escribirListaEnArchivo() {
    FILE *archivoSalida;
    archivoSalida = fopen(nombreArchivoSalida, "w");
    if (archivoSalida == NULL) {
        printf("El archivo %s no existe", nombreArchivoSalida);
        return;
    }

    // Recorrer la lista...
    struct nodo *temporal = superior;
    while (temporal != NULL) {
        char miCadena[MAXIMA_LONGITUD_LINEA] = "";
        // Arreglar el teclado descompuesto
        arreglarTexto(temporal->linea, miCadena);

        // Y escribir en el otro archivo
        printf("Escribiendo la cadena %s\n", miCadena);
        fprintf(archivoSalida, "%s\n", miCadena);
        // Avanzamos en la lista
        temporal = temporal->siguiente;
    }
    fclose(archivoSalida);
}


int main(void) {
    cargarArchivoEnMemoria();
    escribirListaEnArchivo();
    return EXIT_SUCCESS;
}