lab3 main.c

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

#include "states.h"
#include "buffer.h"

//tablica na wskazniki do funkcji obslugujacych stany maszyny
int(*states[])(void) = {
    open_connection_state,
    wait_for_request_state,
    get_request_state,
    find_handler_state,
    send_response_state,
    send_error_state,
};

//wskaznik na bufor cykliczny przechowujacy stany i informacje o tym co zwrocily funkcje obslugujace stany
cyclic_buffer* buffer;

//funkcja ktora na podstawie parametrow 'current_state' i 'return_code' dobiera odpowiedni stan,
//do ktorego powinna przejsc maszyna
int handle_transition(codes current_state, return_codes return_code) {
    //zapisanie aktualnego stanu i sygnalu do bufora cyklicznego
    write_to_buffer(buffer, create_transition(current_state, return_code));
    if (current_state == open) {
        static int time = 0;
        time++;
        //jesli za dlugo czekanie na polaczenie to timeout
        if (time == 30) {
            time = 0;
            return send_error;
        }

        if (return_code == error) return open;
        else if (return_code == done) return wait_for_request;
    }
    else if (current_state == wait_for_request) {
        //zmienna liczaca jak dlugo maszyna stanow jest w stanie czekania na zadanie
        static int time = 0;
        time++;
        //jesli za dlugo czekanie na rzadanie to timeout
        if (time == 10) {
            time = 0;
            return send_error;
        }
        else if (return_code == request_available) return get_request;
        else if (return_code == no_request) return wait_for_request;
    }
    else if (current_state == get_request) {
        if (return_code == done) return find_handler;
        else if (return_code == error) return send_error;
    }
    else if (current_state == find_handler) {
        if (return_code == handler_available) return send_response;
        else if (return_code == no_handler) return send_error;
    }
    else if (current_state == send_response) {
        return close;
    }
    else if (current_state == send_error) {
        return close;
    }
    return 0;
}

int main(void) {

    //zmienna przechowujaca numer aktualnego stanu
    codes current_state = open;
    //zmienna przechowujaca numer sygnalu zwroconego przez stan
    return_codes return_code;
    //wskaznik na funkcje zwracajaca wartosc 'int' i nie przyjmujaca argumentow
    int(*state_handler)(void);
    //incjalizacja bufora cyklicznego
    buffer = init_buffer();

    //glowna petla programu
    while (1) {
        //jesli aktualny stan to stan wyjsciowy to koniec programu
        if (current_state == close) {
            //niezapisane wartosci z bufora zapisywane do pliku
            clean_buffer(buffer);
            break;
        }
        //dobieranie odpowiedniej funkcji obslugujacej stan na podstawie kodu aktualnego stanu
        state_handler = states[current_state];
        //sygnal zwrocony przez funkcje
        return_code = (return_codes)state_handler();
        //dobranie odpowiedniego stanu na podstawie kodu stanu aktualnego i kodu zwroconego sygnalu
        current_state = handle_transition(current_state, return_code);
    }

    return 0;
}