cod | TutPaste - paste bin for text, source codes and links

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

typedef struct page {
    int id;
    char url[50];
    char *description;
} page;

typedef struct stack {
    struct page *top;
} stack;

typedef struct tab {
    int id;
    struct page *currentPage;
    struct stack *backwardStack;
    struct stack *forwardStack;
} tab;

typedef struct List {
    struct tab *data;
    struct List *next;
    struct List *prev;
} List;

typedef struct tabsList {
    struct List *sant;
} tabsList;

typedef struct browser {
    struct tab *current;
    struct tabsList list;
} browser;

void createPage(struct page *p, int id, char *url, char *description) {
    p->id = id;
    strcpy(p->url, url);
    p->description = strdup(description);
}

void initTab(struct tab *t) {
    t->id = 0;
    t->currentPage = (struct page *)malloc(sizeof(struct page));

    createPage(t->currentPage, 0, "https://acs.pub.ro/", "Computer Science");
    t->backwardStack = (struct stack *)malloc(sizeof(struct stack));
    t->backwardStack->top = NULL;

    t->forwardStack = (struct stack *)malloc(sizeof(struct stack));
    t->forwardStack->top = NULL;
}

tab* createTab(struct tab *t, int id_tab, int id, char *url, char *description) {
    t->id = id_tab;
    t->currentPage = (struct page *)malloc(sizeof(struct page));

    createPage(t->currentPage, id, url, description);
    t->backwardStack = (struct stack *)malloc(sizeof(struct stack));
    t->backwardStack->top = NULL;

    t->forwardStack = (struct stack *)malloc(sizeof(struct stack));
    t->forwardStack->top = NULL;
    return t;
}

void freeTab(struct tab *t) {
    if (t->currentPage) {
        free(t->currentPage->description);  // Eliberăm memoria descrierii paginii
        free(t->currentPage);               // Eliberăm memoria paginii
    }
    if (t->backwardStack) free(t->backwardStack);  // Eliberăm stiva backward
    if (t->forwardStack) free(t->forwardStack);    // Eliberăm stiva forward
}

void createBrowser(struct browser *b) {
    // Initialize the sentinel node
    b->list.sant = (struct List *)malloc(sizeof(struct List));
    b->list.sant->data = NULL;
    b->list.sant->next = b->list.sant;
    b->list.sant->prev = b->list.sant;

    // Create the first tab
    struct List *new = (struct List *)malloc(sizeof(struct List));
    new->data = (struct tab *)malloc(sizeof(struct tab));
    createTab(new->data, 0, 0, "https://acs.pub.ro/", "Computer Science");

    // Insert the new tab after the sentinel node
    new->next = b->list.sant->next;
    new->prev = b->list.sant;
    b->list.sant->next->prev = new;
    b->list.sant->next = new;

    // Set the current tab
    b->current = new->data;
}

void freeBrowser(struct browser *b) {
    if (b->list.sant == NULL) return;

    struct List *aux = b->list.sant->next;
    while (aux != b->list.sant) {
        struct List *next = aux->next;
        freeTab(aux->data); // Eliberăm tabul asociat nodului
        free(aux);          // Eliberăm nodul din lista dublu înlănțuită
        aux = next;
    }

    // Eliberăm memoria pentru sentinelă
    free(b->list.sant);  // Eliberăm santinela
    b->list.sant = NULL;
    b->current = NULL;    // Resetăm tabul curent
}

void freePages(struct page pages[51], int n) {
    for (int i = 0; i < n; i++) {
        free(pages[i].description);  // Eliberăm memoria pentru descrierea fiecărei pagini
    }
}

void read(FILE *f, struct page pages[51], char comands[501][51], int *n, int *m) {
    int i;
    fscanf(f, "%d\n", n);
    for (i = 0; i < *n; i++) {
        fscanf(f, "%d\n", &pages[i].id);

        printf("%d\n", pages[i].id);

        fgetc(f);
        fscanf(f, "%s", pages[i].url);
        pages[i].url[strlen(pages[i].url) - 1] = '\0';

        printf("%s\n", pages[i].url);

        char buffer[501];
        fgets(buffer, 501, f);
        pages[i].description = strdup(buffer);

        printf("%s\n", pages[i].description);
    }

    fscanf(f, "%d", m);
    fgetc(f);

    for (i = 0; i < *m; i++) {
        fgets(comands[i], 51, f);
        comands[i][strcspn(comands[i], "\n")] = 0;
    }
}

void NEW_TAB(struct browser *b) {
    struct List *new = (struct List *)malloc(sizeof(struct List));
    new->data = (struct tab *)malloc(sizeof(struct tab));

    // Generate a new ID
    int new_id = b->current->id + 1;

    // Initialize the new tab
    new->data = createTab(new->data, new_id, 0, "https://acs.pub.ro/", "Computer Science");

    if (b->list.sant) {
        if (b->current) {
            // Insert the new tab after the current tab
            struct List *aux = b->list.sant->next;
            while (aux->data != b->current) {
                aux = aux->next;
            }

            new->next = aux->next;
            new->prev = aux;
            aux->next->prev = new;
            aux->next = new;
        } else {
            // If no current tab, insert after the sentinel node
            new->next = b->list.sant->next;
            new->prev = b->list.sant;
            b->list.sant->next->prev = new;
            b->list.sant->next = new;
        }
    } else {
        // If the list is empty, initialize the sentinel node
        new->next = new->prev = new;
        b->list.sant = new;
    }

    // Set the new tab as the current tab
    b->current = new->data;

}

void CLOSE(struct browser *b, FILE *g) {
    struct List *aux = b->list.sant->next;
    while (aux->data != b->current) {
        aux = aux->next;
    }

    if(aux->data->id == 0) {
        fprintf(g, "403 Forbidden\n");
    } else {
        // Remove the current tab from the list
        aux->prev->next = aux->next;
        aux->next->prev = aux->prev;

        // Set the current tab to the previous one, if it exists
        if (aux->prev != b->list.sant) {
            b->current = aux->prev->data;
        } else {
            b->current = NULL; // No tabs left
        }

        // Free the current tab
        freeTab(aux->data);
        free(aux);
    }
}

void OPEN(struct browser *b, int id_specif, FILE *g) {
    struct List *aux = b->list.sant->next;

    // Traverse the list to find the tab with the specified ID
    do {
        if (aux->data->id == id_specif) {
            b->current = aux->data; // Set the current tab to the one with the specified ID
            return;
        }
        aux = aux->next;
    } while (aux != b->list.sant);

    // If the tab with the specified ID was not found
    fprintf(g, "403 Forbidden\n");
}

void PRINT(struct browser *b, FILE *g) {
    struct List *temp = b->list.sant->next;
    while (temp->data != b->current) {
         temp = temp->next;
    }

    // Print all tabs in the circular doubly linked list
    do {
        fprintf(g, "%d", temp->data->id);
        temp = temp->next;
        if(temp == b->list.sant)
            temp = temp->next;
        if (temp->data->id != b->current->id)
            fprintf(g, " ");
    } while (temp->data->id != b->current->id);

    fprintf(g, "\n");

    // Print the current tab's page description if it exists
    if (b->current && b->current->currentPage) {
        fprintf(g, "%s\n", b->current->currentPage->description);
    }

}

int main() {
    FILE *f = fopen("tema1.in", "r");
    FILE *g = fopen("tema1.out", "w");

    struct page pages[51];
    char comands[501][51];
    struct browser b; // Declare the browser
    int i, n, m;

    // Initialize the browser directly in main
    b.list.sant = (struct List *)malloc(sizeof(struct List));
    b.list.sant->data = NULL;
    b.list.sant->next = b.list.sant;
    b.list.sant->prev = b.list.sant;
    b.current = NULL;
    createBrowser(&b);

    read(f, pages, comands, &n, &m);

    for (i = 0; i < m; i++) {
        if (strcmp(comands[i], "NEW_TAB") == 0)
            NEW_TAB(&b);
        else if (strcmp(comands[i], "PRINT") == 0)
            PRINT(&b, g);
        else if (strcmp(comands[i], "CLOSE") == 0)
            CLOSE(&b, g);
        else if (strstr(comands[i], "OPEN") != NULL) {
            int id_specif;
            sscanf(comands[i], "OPEN %d", &id_specif);
            OPEN(&b, id_specif, g);
        }
    }

    freePages(pages, n);
    freeBrowser(&b);
    fclose(f);
    fclose(g);
    return 0;
}