Recortador Multilineas Masivo

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <stdio.h>
#include <Clipbrd.hpp>

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

TForm1 *Form1;

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button_ComenzarClick(TObject *Sender)
{
        AnsiString salida,Aux;
        char caracter;
        FILE *origen;
        AnsiString ultimo, Cadena, Path_Inicial="", Path_Final="", Directorio="", Control="", NombreArchivo;
        int posicionCadena, largo, largoCadena, error = 0, modificados = 0;
        BOOL encontrado;
        HANDLE hFind;
        WIN32_FIND_DATA busqueda;

        if(Edit_Cadena->Text != "")
        {
                //Deshabilitamos todos los botones o elementos del form que pueda influir
                //en el correcto funcionamiento su manipulacion durante la ejecucion
                Edit_Cadena->Enabled = false;
                GroupBox_Opciones->Enabled = false;
                Button_Comenzar->Enabled = false;
                Button_Exportar_Log->Enabled = false;
                Button_Ver_Log_Modificados->Enabled = false;
                Button_Ver_Log_No_Encontrados->Enabled = false;
                Button_Ver_Todo_Log->Enabled = false;
                Button_Salir->Enabled = false;
                DirectoryListBoxOrigen->Enabled = false;
                DriveComboBox1->Enabled = false;

                //Si pusimos alguna extension la concatena detras del asterisco para
                //asi solo trabajar con los archivos que tengan esa extension y si no
                //ponemos ninguna trabajaremos con todos los archivos
                if(EditExtension->Text == "")
                {
                        Path_Inicial = DirectoryListBoxOrigen->Directory + "\\*.*";
                }
                else
                {
                        Path_Inicial = DirectoryListBoxOrigen->Directory + "\\*." + EditExtension->Text;
                }

                //Obtenemos el nombre del primer archivo del directorio elegido
                Path_Final = Path_Inicial;
                hFind = FindFirstFile((char*)Path_Final.c_str(),&busqueda);
                Path_Final = busqueda.cFileName;

                ListBox_LogAll->Clear(); //Borramos el log
                ListBox_LogFounds->Clear(); //Borramos el log
                ListBox_LogNotFounds->Clear(); //Borramos el log

                while(Path_Final != "") // Si no existen archivos con la extension deseada
                {
                        //Solo queremos trabajar con archivos que no sean de sistema u ocultos
                        if(busqueda.dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE &&
                        busqueda.dwFileAttributes != FILE_ATTRIBUTE_SYSTEM &&
                        busqueda.dwFileAttributes != FILE_ATTRIBUTE_HIDDEN)
                        {
                                //Abrimos el archivo para su lectura
                                origen=fopen(busqueda.cFileName, "r");

                                //Si se pudo abrir...
                                if(origen)
                                {
                                        int tmp, x=0, contador=0;
                                        char *mRet=NULL, *buffer=NULL, *salidaRealojada=NULL;
                                        long pos=0, mSize;

                                        // Pedimos cuanto pesa el fichero ..
                                        fseek(origen,0,SEEK_END); // Vamos al final
                                        mSize = ftell(origen); // pedimos la posicion
                                        fseek(origen,0,SEEK_SET); // vamos al comienzo
                                        // En mSize tenemos el tamaño del archivo y lo
                                        //podemos usar para crear un buffer para manipularlo

                                        //Obtenemos memoria dinamicamente para nuestro buffer
                                        //con el tamaño obtenido en la operacion anterior
                                        buffer = (char*)malloc(mSize);
                                        memset( buffer, 0, mSize );

                                        //Copiamos todo el contenido del archivo al buffer
                                        while( !feof(origen) )
                                        {
                                                buffer[pos]=fgetc(origen);
                                                pos++;
                                        }

                                        //Sustituimos el caracter del EOF por el de fin de cadena
                                        if(buffer[pos-1] == EOF)
                                                buffer[pos-1] = '\0';

                                        //Cerramos la cadena del buffer con el fin de cadena
                                        //buffer[pos]='\0';

                                        //Metemos el tamaño de la cadena alojada en el buffer en mSize
                                        mSize = strlen(buffer);

                                        //Metemos la cadena a buscar en Cadena para mayor comodidad
                                        Cadena = Edit_Cadena->Text;

                                        //Ponemos a false encontrado para que a la salida si no fue
                                        //modificado sabremos que no se encontró la cadena en el archivo
                                        encontrado = false;

                                        //Entramos siempre que haya una cadena a buscar y que el buffer
                                        //esté lleno
                                        if(Cadena != "" && mSize > 0)
                                        {
                                                //Recorremos todo el buffer
                                                for(long i = 0; i < mSize; i++)
                                                {
                                                        caracter = buffer[i];

                                                        //Esta variable la usaré para saber si se encontró la cadena completa
                                                        tmp = 0;

                                                        //Si el caracter obtenido del buffer coincide con el primer caracter de
                                                        //la cadena a buscar...
                                                        if(caracter == Cadena[1])
                                                        {
                                                                //Guardamos la posicion actual del caracter por si tenemos que volver a el
                                        pos = i;

                                                                //Comprobamos si coincide la cadena al completo
                                                                for(tmp=1;tmp<=Cadena.Length() && i < mSize; tmp++)
                                                                {
                                                                        if (caracter==Cadena[tmp])
                                                                        {
                                                                                i++;
                                                                                caracter = buffer[i];
                                                                        }
                                                                        else
                                                                        {
                                                                                break;
                                                                        }
                                                                }
                                                                tmp--; //Ajustamos la variable

                                                                if(tmp==Cadena.Length()) //Si coinciden es porque la cadena se ha encontrado
                                                                {
                                                                        i--; //Ajustamos la posicion para poder continuar leyendo el buffer
                                                                        contador++; //Incrementamos el contador de veces encontrada
                                                                        encontrado = true; //Indicamos que ha sido encontrada
                                                                }
                                                                else  //Si no coinciden es porque no se encontró la cadena completa
                                                                {
                                                                        i = pos; //Vamos al sitio donde se encontró el primer caracter
                                                                        caracter = buffer[i]; //Cogemos el caracter

                                                                        //Pedimos mas memoria
                                                                        salidaRealojada = (char*) realloc (mRet, (x+1) * sizeof(char));

                                                                        //Si no pudimos obtener mas memoria liberamos la memoria ocupada,
                                                                        //habilitamos todos los elementos de form y salimos del proceso
                                                                        if (salidaRealojada==NULL)
                                                                        {
                                                                                free (buffer);
                                                                                free(mRet);
                                                                                ShowMessage(" Error (re)allocating memory");
                                                                                Edit_Cadena->Enabled = true;
                                                                                GroupBox_Opciones->Enabled = true;
                                                                                Button_Comenzar->Enabled = true;
                                                                                Button_Exportar_Log->Enabled = true;
                                                                                Button_Ver_Log_Modificados->Enabled = true;
                                                                                Button_Ver_Log_No_Encontrados->Enabled = true;
                                                                                Button_Ver_Todo_Log->Enabled = true;
                                                                                Button_Salir->Enabled = true;
                                                                                DirectoryListBoxOrigen->Enabled = true;
                                                                                DriveComboBox1->Enabled = true;
                                                                                fclose(origen);
                                                                                return;
                                                                        }

                                                                        //Si pudimos obtener mas memoria guardamos el caracter
                                                                        mRet=salidaRealojada;
                                                                        mRet[x]=caracter;
                                                                        x++;
                                                                }
                                                        }
                                                        else if(i < mSize) //Y si el primer caracter no coincide...
                                                        {
                                                                //Pedimos mas memoria
                                                                salidaRealojada = (char*) realloc (mRet, (x+1) * sizeof(char));

                                                                //Si no pudimos obtener mas memoria liberamos la memoria ocupada,
                                                                //habilitamos todos los elementos de form y salimos del proceso
                                                                if (salidaRealojada==NULL)
                                                                {
                                                                        free (buffer);
                                                                        free(mRet);
                                                                        ShowMessage(" Error (re)allocating memory");
                                                                        Edit_Cadena->Enabled = true;
                                                                        GroupBox_Opciones->Enabled = true;
                                                                        Button_Comenzar->Enabled = true;
                                                                        Button_Exportar_Log->Enabled = true;
                                                                        Button_Ver_Log_Modificados->Enabled = true;
                                                                        Button_Ver_Log_No_Encontrados->Enabled = true;
                                                                        Button_Ver_Todo_Log->Enabled = true;
                                                                        Button_Salir->Enabled = true;
                                                                        DirectoryListBoxOrigen->Enabled = true;
                                                                        DriveComboBox1->Enabled = true;
                                                                        fclose(origen);
                                                                        return;
                                                                }

                                                                //Si pudimos obtener mas memoria guardamos el caracter
                                                                mRet=salidaRealojada;
                                                                mRet[x]=caracter;
                                                                x++;
                                                        }
                                                }

                                                //Pedimos mas memoria
                                                salidaRealojada = (char*) realloc (mRet, (x+1) * sizeof(char));

                                                //Si no pudimos obtener mas memoria liberamos la memoria ocupada,
                                                //habilitamos todos los elementos de form y salimos del proceso
                                                if (salidaRealojada==NULL)
                                                {
                                                        free (buffer);
                                                        free(mRet);
                                                        ShowMessage(" Error (re)allocating memory");
                                                        Edit_Cadena->Enabled = true;
                                                        GroupBox_Opciones->Enabled = true;
                                                        Button_Comenzar->Enabled = true;
                                                        Button_Exportar_Log->Enabled = true;
                                                        Button_Ver_Log_Modificados->Enabled = true;
                                                        Button_Ver_Log_No_Encontrados->Enabled = true;
                                                        Button_Ver_Todo_Log->Enabled = true;
                                                        Button_Salir->Enabled = true;
                                                        DirectoryListBoxOrigen->Enabled = true;
                                                        DriveComboBox1->Enabled = true;
                                                        fclose(origen);
                                                        return;
                                                }

                                                //Si pudimos obtener mas memoria guardamos el caracter
                                                mRet=salidaRealojada;
                                                mRet[x]='\0';
                                        }

                                        if(encontrado == true) //Si la cadena fue encontrada...
                                        {
                                                ListBox_LogFounds->Items->Add("Encontrado y eliminado " + AnsiString(contador) + " veces en \"" + Path_Final + "\".");
                                                ListBox_LogAll->Items->Add("Encontrado y eliminado " + AnsiString(contador) + " veces en \"" + Path_Final + "\".");
                                                modificados++;
                                                Application->ProcessMessages();
                                        }
                                        else  //Y si no fue encontrada...
                                        {
                                                ListBox_LogNotFounds->Items->Add("No pudo ser encontrado en \"" + Path_Final + "\".");
                                                ListBox_LogAll->Items->Add("No pudo ser encontrado en \"" + Path_Final + "\".");
                                                error++;
                                        }

                                        fclose(origen); //Cerramos el archivo

                                        //Si se encontró la cadena procedemos a guardar los cambios
                                        if(encontrado == true)
                                        {
                                                origen = fopen(busqueda.cFileName,"w");
                                                fwrite(mRet, sizeof(char), strlen(mRet), origen);
                                                fclose(origen);
                                        }

                                        //Liberamos la memoria obtenida dinamicamente
                                        free(mRet);
                                        free(buffer);
                                }
                        }

                        //Buscamos el siguiente archivo
                        FindNextFile(hFind,&busqueda);

                        //Esto es una forma de controlar cuando llegamos al ultimo archivo del directorio
                        Control = Path_Final;
                        Path_Final=busqueda.cFileName; // Asignamos a Path_Final el nombre del siguiente archivo a mostrar

                        if(Control == Path_Final) // Si son iguales es porque ya llegamos al ultimo archivo del directorio
                        {
                                if(error == 0 && modificados == 0)
                                {
                                        ListBox_LogAll->Items->Add("No se encontraron archivos con la extension indicada.");
                                        ListBox_LogFounds->Items->Add("No se encontraron archivos con la extension indicada.");
                                        ListBox_LogNotFounds->Items->Add("No se encontraron archivos con la extension indicada.");
                                }

                                //Escribimos las incidencias en los Logs
                                ListBox_LogAll->Items->Add("");
                                ListBox_LogAll->Items->Add("------------------------------------------------------------");
                                ListBox_LogAll->Items->Add("Se encontraron y modificaron " + AnsiString(modificados) + " archivos.");
                                ListBox_LogAll->Items->Add("No se encontró en " + AnsiString(error) + " archivos.");
                                ListBox_LogAll->Items->Add("------------------------------------------------------------");

                                ListBox_LogFounds->Items->Add("");
                                ListBox_LogFounds->Items->Add("------------------------------------------------------------");
                                ListBox_LogFounds->Items->Add("Se encontraron y modificaron " + AnsiString(modificados) + " archivos.");
                                ListBox_LogFounds->Items->Add("------------------------------------------------------------");

                                ListBox_LogNotFounds->Items->Add("");
                                ListBox_LogNotFounds->Items->Add("------------------------------------------------------------");
                                ListBox_LogNotFounds->Items->Add("No se encontró en " + AnsiString(error) + " archivos.");
                                ListBox_LogNotFounds->Items->Add("------------------------------------------------------------");

                                //Mostramos el mensaje adecuado para cada caso
                                if(error == 0 && modificados == 0)
                                {
                                        ShowMessage("No hubo ninguna coincidencia");
                                }
                                else if(error > 0 && modificados >= 0)
                                {
                                        ShowMessage("La operacion finalizó con errores");
                                }
                                else if(error == 0 && modificados > 0)
                                {
                                        ShowMessage("La operacion finalizó satisfactoriamente");
                                }

                                //Dejamos a Path_Final vacia para indicar que ya leimos todos los archivos
                                Path_Final = "";
                        }
                }

                //Habilitamos todos los elementos del Form
                Edit_Cadena->Enabled = true;
                GroupBox_Opciones->Enabled = true;
                Button_Comenzar->Enabled = true;
                Button_Exportar_Log->Enabled = true;
                Button_Ver_Log_Modificados->Enabled = true;
                Button_Ver_Log_No_Encontrados->Enabled = true;
                Button_Ver_Todo_Log->Enabled = true;
                Button_Salir->Enabled = true;
                DirectoryListBoxOrigen->Enabled = true;
                DriveComboBox1->Enabled = true;
        }
        else
        {
                ShowMessage("No se introdujo ninguna cadena a buscar. Introduzca una cadena e intentelo de nuevo.");
        }
}