liblog/liblog.c

#include <gint/exc.h>
#include <gint/keyboard.h>
#include <gint/display.h>
#include <gint/std/stdlib.h>
#include <gint/std/stdio.h>
#include <gint/defs/attributes.h>
#include <liblog.h>
#include <stdint.h>
#include <gint/timer.h>

#ifdef FX9860G
static int number_max_messages=4096; // Ram 4Ko
#define MAX_LENGHT 22
#define WIDTH 8
#endif

#ifdef FXCG50
static int number_max_messages=10000; // Ram 10 Ko
#define MAX_LENGHT 132
#define WIDTH 17
#endif

typedef struct log_line log_line;
typedef struct log_line
{
    void* previous;
    char text[MAX_LENGHT];
    void* next;
    int cursor;
} log_line;


static log_line first_line=
{
    0,
    "Log beginning:",
    0,
    0
};

static log_line* current_line=&first_line;

static int number_messages=0;

static log_level_t priority=LOG_INFO;

static log_line* cut_line()
{
	log_line* maillon = first_line.next;
	log_line* maillon_suivant = maillon->next;

	first_line.next=maillon_suivant;
	if (maillon_suivant)
		maillon_suivant->previous=&first_line;
    number_messages--;
	return maillon;
}

static void optimize()
{
	while (number_messages*sizeof(log_line)>=number_max_messages)
	{
		log_line* line = cut_line();
		free(line);
		number_messages--;
	}
}


void ll_set_size(int s)
{
	number_max_messages=s;
	optimize();
}


int ll_get_size();


void ll_set_state(log_state_t s)
{
    if (s==LOG_DISABLE)
    	priority=LOG_QUIET;
    if (s==LOG_ENABLE)
    	priority=LOG_INFO;
}

int ll_get_state()
{
    if (priority=LOG_QUIET)
    	return 0;
    else
    	return 1;
}



static void link_line(log_line* line)
{
	current_line->next=line;
	line->previous=current_line;
	current_line=line;
}

static void clear_line(log_line* line)
{
	line->next=0;
	line->cursor=0;
    for (int i=0; i<MAX_LENGHT; i++)
        current_line->text[i]='\0';
}

static log_line* add_line()
{
    int malloc_fail=0;

    log_line* line;

    int test=(number_messages*sizeof(log_line)>=number_max_messages);
    if (!test)
    {
        line = malloc(sizeof(log_line));
        if (0==line)
            malloc_fail=1;
        else
        	number_messages++;
    }

    if (test || malloc_fail) // fail du malloc ou dépassement de la limite de ram imposée lors du build
        line=cut_line();

    link_line(line);
    clear_line(line);
    optimize();
    return current_line;

}

void ll_clear()
{
    number_messages=0;
    while (current_line->previous)
    {
        log_line* next=current_line->previous;
        free(current_line);
        current_line=next;
    }
    current_line->next=0;
    current_line->cursor=0;
    for (int i=0; i<MAX_LENGHT; i++)
        current_line->text[i]='\0';
}



static void append_character(char c)
{
    if (current_line==&first_line)
        add_line();
    if (c=='\n')
    {
        current_line->text[current_line->cursor] = '\0';
        add_line();
        return;
    }
    current_line->text[current_line->cursor] = c;
    if (c!='\0')
    {
        current_line->cursor ++;


    if (current_line->cursor == MAX_LENGHT-1)
        add_line();
    //current_line->text[current_line->cursor] = '\0';
#ifdef FXCG50
    else if (dsize(&current_line->text[0])>396-7)
    {
        add_line();
    }
#endif
    }
}

// log something
void ll_send(const char * txt)
{
    if (priority!=LOG_QUIET)
    {
        char c=1;
        int i=0;
        while (c!='\0')
        {
            c=txt[i];
            append_character(c);
            i++;
        }
    }
}

void ll_sendp(char const *s , log_level_t l)
{
	if (l>=priority)
		ll_send(s);
}

static void show_line(const log_line* l, int y)
{
    dtext(1, y, &l->text[0], C_BLACK, C_NONE);
}

void ll_display_custom(log_line* line)
{
    dfont(NULL);
    dclear(C_WHITE);
    for (int i=0; i<8; i++)
    {
#ifdef FX9860G
        show_line(line, 63 - 8*(i+1));
#endif
#ifdef FXCG50
        show_line(line, 224 - 13*(i+1));
#endif
        line=line->previous;
        if (!line)
            break;
    }
    dupdate_noint();
}




void ll_display()
{
    ll_display_custom(current_line);
}
 
void ll_pause()
{
    //for (int i=0; i<timer_count(); i++)
    //    if (i!=3) // keyboard timer
    //        timer_pause(i);
    dclear(C_WHITE);
    log_line* line=current_line;
    while (1)
    {
        ll_display_custom(line);
        int key = getkey().key;
        if (key==KEY_UP)
        {
            log_line* linet=line->previous;
            if (linet)
                line=linet;
        }
        if (key==KEY_DOWN)
        {
            log_line* linet=line->next;
            if (linet)
                line=linet;
        }
        if (key==KEY_EXIT)
            break;
    }
    //for (int i=0; i<timer_count(); i++)
    //    if (i!=3)
    //        timer_start(i);
}

GNORETURN void ll_panic(uint32_t code)
{
    char str[10];
    sprintf(str, "\nException !\n>> LogState=%d\n>> ErrCode=%d", state, code);
    ll_set_state(1);
    ll_send(str);
    while (1)
        ll_pause();
}

void ll_set_panic()
{
    gint_panic_set(ll_panic);
}