[POLSL][PK][LAB4] XML

/*
Xml basic reader
Dawid Mocek
2014-05

Zadanie 2.
 Napisz program, który umożliwia łączenie wielu plików XML z uwzględnieniem podziału informacji na grupy. W pliku wynikowym grupy o tej samej nazwie nie mogą się powtarzać.


Przykładowy plik wejściowy 1:
<Pogoda>
Niedziela będzie słoneczna.
</Pogoda>
<Wiadomości>
Wybuch na słońcu spowodował awarie w różnych miejscach globu.
</Wiadomości>

Przykładowy plik wejściowy 2:
<Akcje>
Dzisiaj hossa na rynku.
</Akcje>
<Pogoda>
Sobota będzie słoneczna, chyba…
</Pogoda>

Plik wyjściowy:
<Pogoda>
Niedziela będzie słoneczna.
Sobota będzie słoneczna, chyba…
</Pogoda>
<Wiadomości>
Wybuch na słońcu spowodował awarie w różnych miejscach globu.
</Wiadomości>

Przykładowy plik wejściowy 2:
<Akcje>
Dzisiaj hossa na rynku.
</Akcje>

*/


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

struct node // struktura przechowująca tagi i ich treść
{
    char *tag_nazwa;
    char *tresc;
};


FILE * otworz_plik(const char *plik, char *tryb) //otwieranie pliku
{
    FILE *fh = fopen(plik, tryb);
    if (fh == NULL)
    {
        perror(" Blad otwarcia pliku");   //jeśli bląd to komunikat
        exit(EXIT_FAILURE);
    }
    return fh;
}


char *czytaj_do_pamieci(FILE *fh) //funkcja wczytująca dane z pliku do pamięci
{
    char *zawartosc = NULL;
    char  buffer[BUFSIZ]; //512
    size_t buffSize = 0;
    char *tmp = NULL;
    while (fgets(buffer, sizeof(buffer), fh) != NULL)
    {
        tmp = (char*)realloc(zawartosc, (buffSize + strlen(buffer) + 1));
        if (tmp)
        {
            zawartosc = tmp;
        //  printf("zawartosc = %s <=> tmp = %s", zawartosc, tmp);
            zawartosc[buffSize] = '\0';
            strcat(zawartosc, buffer);
            buffSize += strlen(buffer) + 1;
        }
        else
        {
            perror("Blad pamieci\n"); //jeśli bląd to komunikat
            free(zawartosc);
            zawartosc = NULL;
            exit(EXIT_FAILURE);
        }
    }
    return zawartosc;
}

void zapisz_do_pliku(FILE *plik, struct node **wezly, int size)  //funkcja zapisująca do pliku zawartość wezlow
{
    int i;
    for (i = 0; i < 1; ++i)
    {
        fprintf(plik,"Tag: %s, Tresc: %s\n", wezly[i]->tag_nazwa, wezly[i]->tresc);
    }
}


struct node ** analizuj(char *tekst, int *size)  // FUNKCJA ANALIZUJĄCA CIĄG ZNAKÓW I ROZPOZNAJĄCA TAGI
{
    struct node **tablica = NULL;
    int ilosc_nodow = 0;
    *size = 0;
    char *tag_start = tekst;
    while (1) //bedzie ich wiecej
    {
        tag_start = strchr(tag_start, '<'); //tag zaczyna się od tego znaku
        if (tag_start == NULL)
            break;
        char *tag_end = strchr(tag_start, '>');
        int tag_dlugosc = tag_end - tag_start;
        struct node *wezel = (struct node *)malloc(sizeof(struct node)); //tu sie zaczynaja wezly

        wezel->tag_nazwa = (char *)malloc(tag_dlugosc * sizeof(char));
        memset(wezel->tag_nazwa, 0, tag_dlugosc);
        memcpy(wezel->tag_nazwa, tag_start + 1, tag_dlugosc - 1);  //sprytna funkcja do wyłuskania tekstu

        char *ctag_start = strstr(tag_end, "</");  //tak sie ma zaczynać ctag (konczacy)
        int tresc_dlugosc = ctag_start - tag_end;
        wezel->tresc = (char *)malloc(tresc_dlugosc * sizeof(char));
        memset(wezel->tresc, 0, tresc_dlugosc);
        memcpy(wezel->tresc, tag_end + 1, tresc_dlugosc - 1);

        // Szukamy ctag zamykajacego
        char *ctag_end = ctag_start + tag_dlugosc + 1;
        tag_start = ctag_end;
        printf("analyze- tag: %s, tresc: %s\n", wezel->tag_nazwa, wezel->tresc);
        tablica = (struct node **)realloc(tablica, sizeof(struct node *) * ++ilosc_nodow);
        tablica[ilosc_nodow - 1] = wezel;
    }
    *size = ilosc_nodow;
    return tablica;
}



int main(void)
{

    const char *plik1 = "C:\\Users\\Admin\\Documents\\xml1.txt";
    const char *plik2 = "C:\\Users\\Admin\\Documents\\xml2.txt";
    const char *plik3 = "C:\\Users\\Admin\\Documents\\xml3.txt";

    FILE *fh1 = otworz_plik(plik1, "r");
    FILE *fh2 = otworz_plik(plik2, "r");
    FILE *fh3 = otworz_plik(plik3, "w");

    char *zawartosc1 = czytaj_do_pamieci(fh1);
    char *zawartosc2 = czytaj_do_pamieci(fh2);

    int tab_ilosc = 0, tmp;
    struct node **tab = NULL;
    // struct node **tab3 = (struct node **)malloc(4 * sizeof(struct node *));

    tab = analizuj(zawartosc1,  &tmp);
    tab_ilosc += tmp;

    //analizuj(zawartosc2, &tab, &tmp);
    //tab_ilosc += tmp;
    /// for ...
    // tab3[i] = tab1[i];

        printf("Tag: %s, Tresc: %s\n", tab[1]->tag_nazwa, tab[1]->tresc);


    fclose(fh1);
    fclose(fh2);
    fclose(fh3);

    return EXIT_SUCCESS;
}