Pour ceux qui ne connaissent pas ce merveilleux langage de programmation, il y a dans la note précédente, quelques exemples de code brainfuck. Le brainfuck, conceptuellement, c'est trop cool. Un seul registre, un jeu d'instruction tres réduite, et une utilisation tres proche des systèmes logiques. Et bien, en attendant d'avoir le courage de bidouiller un ordinateur brainfuck, j'ai décidé de coder ma propre version de ce langage!

Voilà, donc j'ai commencé par programmer un interpréteur simple, qui supportait toutes les instructions du brainfuck, pour ensuite le modifier. J'ai déjà implémenté deux ou trois fonctionnalités tres pratiques qui rendent bien service, comme le support des boucles imbriquées, et un incrément numérique des valeur du registres. Prochain étape, l'adressage "direct" du registre. Finalement, ça va s'apparenter à ce que je voulais faire (voir le billet sur mes projets en cours). Le brainfuck est vraiment tout indiqué, et est bien plus facile à interpréter que le BASIC (la conversion "langage->code" c'est trop la merde, et ca dépends trop de la finalité.).

Là, je pense être sur la bonne voie pour créer un langage pratique, rétro-compatible (il peut interpréter un code brainfuck), et léger (moins de répétitions, interpréteur simple=bug--). Je vais poster le code source de l'interpréteur, sous licence GPL (of course) et le langage lui même aussi j'espère.

Grace à TimGau, qui a posté une de ses sources BrainFuck sur le réseau social totalitaire et bleu, j'ai eu le plaisir de re-goûter à ce merveilleux langage qu'est le BrainFuck. J'ai alors demandé à mon entité cérébrale nerd de me remettre en RAM les vicissitudes de ce dernier. Quel miracle, un langage si simple, et si poétique à la fois! Il regorge de concepts tout à fait intéressants d'ailleurs.

Pour rappel, le brainfuck permet de manipuler UN registre, d'afficher la valeur d'une cellule de ce registre, et de demander la saisie d'une valeur de cellule. Il dispose aussi de la formidable "[]" qui est une boucle conditionnelle.

Quelque petits codes BrainFuck

+++++ +++++ +++++ ++++
[>+++++<-]
+++[>----<-]>+.
<+++[>+++++++<-]>.     
<+++[>+++++<-]>.
<+++[>----<-]>.
<++[>---<-]>-.
++.
--..
<++[>+++<-]>.

>+++++ +++
[<+++++ ++>-]<+
>>+++
[<+++>-]<+
>++++++++++.<
[<.->->.<]

>+++++ +++
[<+++++ +>-]<
>>+++
[<+++>-]<+
>++++++++++.<
[<.+>->.<]

>++++++++++
[>+++++++<-]>+++.
<++[>-----<-]>---.
<++[>-----<-]>+.
<++++[>++++++++<-]>++.

Hm... Et c'est tout pour le moment. Je vais avoir le temps de brainfucker, je vous tiens au courant!

Souvent, quand on est amené à manipuler de la mémoire en C, par exemple, lors que l'on a des chaines de caractères, ou que l'on doit analyser une structure "complexe" de données (images, etc...), on aimerait pouvoir résoudre de petits problèmes simples avec élégance... Si les librairies standard offrent de bons moyens de ne pas avoir à savoir coder, il est en revanche un constat accablant à faire: apprendre à bien coder éviteraient parfois de belles bourdes.

Je n'ai pas la prétention d'avoir des leçons a donner. Mais finalement, pourquoi ne pas diffuser un peut ce qui me semble utile?

Je propose donc de donner quelques exemples commentés de fonctions usuelles codées dans un style élégant, qui pourraient vous permettre d'enfin apprécier de faire un code découlant d'une logique implacable. Et le code logique et pur, c'est beau.

Strlen

strlen (string lenght) est une fonction définie dans le header de la librairie standard string.h, et ayant pour prototype "size_t strlen(const char *s);". Son role est de renvoyer la taille d'une chaine de caractères (nombres de caractères contenus dans la chaine). Une chaine correspond en réalité à un pointeur, donnant accès à une plage de caractères, et dont la fin est déterminée par un \0 (valeur à 0). Le pointeur donne l'emplacement mémoire du premier caractère de la chaine.

Comme je le disait plus haut, le C permet une manipulation de la mémoire très propre, et bien intégrée. On pourra donc coder notre fonction de strlen en utilisant les pointeurs et leur syntaxe:

/* (c)Tixlegeek 2010 - GPLv3  */
int strlen(char *str)
{
   int i=0;
   while(*(str+i)){i++;}
   return i;
}

Malgré qu'il puisse etre un peut intimidant pour les débutants (et c'est normal, ya des pointeurs ) on peut aisément l'expliquer et le comprendre:

int strlen(char *str)
{
   int i=0;   Déclaration de la variable i et initialisation à 0
   while(*(str+i)){i++}  Tant que la valeur *(str+i) (=valeur à l'adresse str+i) est supérieure à 0, on incrémente i.
   return i;   On est arrivé à un 0, on retourne donc la valeur de i, qui correspond au nombre de caracteres parcouru dans la boucle précédente.
}

ltrim

OOPS! L'ami Mathedit m'a fait remarqué à juste titre que ma fonction ne marchait pas! (je flagellerai ma chaire impure avec une courge molle ce soir, c'est promis) Et m'en a fait la démonstration. Je ne suis pas encore certain des circonstances du bug, mais à l'évidence, ca plante. Ce n'est que partie remise! Et merci à mathedit

Voilà. Ces deux fonctions permettent de comprendre un peut mieux l'utilité des pointeurs, et en quoi ils peuvent nous changer la vie. Ce ne sont que des exemples, mais le haut niveau n'empêche pas d'avoir à savoir programmer un minimum!

Il ya quelques temps, j'aivais réalisé en une matinée, un petit programme qui utilisait la wiimote et OpenGL pour faire bouger des mobiles en 3D avec l'accéléromètre de la wiimote. J'avais fait ça juste avant mon exposé sur "la contre culture du détournement logiciel et matériel" (Les Hackers en réalité)

J'ai enfin pris le temps de réaliser une petite vidéo pour vous montrer mon petit bricolage !

Voilà! J'utilise donc les librairies OpenGL, SDL, Et LibcWiid, et compile mon code sous GCC. Je le posterai bientot je pense.

Suite au commentaire de Gaspard sur l'article dédié précédent, voilà l'archive contenant le code source et le projet CodeBlocks. Il est distribué sous licence GPL, ne contient qu'un seul fichier source, et, je le rappel, utilise les librairies GTK+ et Libcurl.

++ Tix.

Voilà mon dernier programme : "La citation du jour". Il s'agit d'une application, pour le momment uniquement disponible pour GNU/linux, qui, à chaque lancement, se connecte à mon serveur de citations aléatoires (écrit en PHP dans la foulée) et l'affiche.

J'ai utilisé la librairie Libcurl, une librairie réseau tres sympathique, et un interfacage graphique GTK+. Le code, lui, à été compilé avec GCC, sous Code::blocks IDE, et sera bientot publié. Je n'ai aucune envie de faire une version Windows, mais, qui sait !

++ Tix. !

Voilà le dernier sample de mon interpréteur basic. Ajout d'une fonction Ltrim, et d'une fonction d'analyse plus poussée du code. Optimisation des fonctions précédentes. J'ai aussi revu un peu ma syntaxe, et j'ai décidé de m'orienter un peu plus vers un basic qui tourne un peu comme celui des TI. En effet, il permet de bien gérer les imbrications de boucles, et de ne pas s'embêter avec de drôles de choses qui consomment de la mémoire ! Vous constaterez aussi que par le fait, le codage est bien plus libre espaces superflus gérés etc...)
TODO: le reste u___u

/*****************************************************************************************


                                  BASIC interpreter
                                (PIC2PC - simulateur)
                                        0.0.2


          By Gery DUBIEF, www.tixlegeek.com, tixlegee AT gmail DOT com

          Code à compiler exclusivement avec GCC. Non compatible WINDOWS

*****************************************************************************************

            -> L'intégralité de ce code est sous license GPL. Rapportez vous au
            site ci dessous pour connaître les conditions exactes de la license.

                            http://www.gnu.org/copyleft/

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

/*****************************************************************************************
                            Reperes de lignes
*****************************************************************************************/
#define LBB_RCCHAR 59
#define LBB_STOPCHAR 0

//Domaine de définition ASCII des variables
#define LBB_SVDEF 65
#define LBB_EVDEF 90

/*****************************************************************************************
                            Index d'instruction
*****************************************************************************************/
#define LBBI_IF 100
#define LBBI_FOR 101

#define LBBI_ELSE 110
#define LBBI_GOTO 111
/*****************************************************************************************
                            Macros du simulateur
*****************************************************************************************/

// Affiche un retour chariot
#define LBB_NRC()   printf("\033[30m"); \

                    printf("\033[43m"); \
                    printf("[RC]"); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche un début de conditionnelle IF
#define LBB_NCIS(stackind)   printf("\033[34m"); \

                    printf("\033[40m"); \
                    printf("{%d\t[Debut de conditionelle IF]", stackind); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche un début de conditionnelle FOR
#define LBB_NCFS(stackind)   printf("\033[31m"); \

                    printf("\033[40m"); \
                    printf("{%d\t[Debut de conditionelle FOR]", stackind); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche une fin de conditionelle
#define LBB_NCE(stackind)   printf("\033[35m"); \

                    printf("\033[40m"); \
                    printf("}%d\t[Fin de conditionelle END]", stackind); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche un goto
#define LBB_NCG()   printf("\033[36m"); \

                    printf("\033[40m"); \
                    printf("--> \t<GO TO>"); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche un titre
#define LBB_NTI(titre)   printf("\033[30m"); \

                    printf("\033[47m"); \
                    printf("-------------------- [ %s ] --------------------", titre); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");

// Affiche un texte
#define LBB_CTS(txt,b,f)   printf("\033[3%dm",f); \

                    printf("\033[4%dm",b); \
                    printf("%s", txt); \

                    printf("\033[37m"); \
                    printf("\033[40m");

// Affiche un caractere
#define LBB_CTC(txt,b,f)   printf("\033[3%dm",f); \

                    printf("\033[4%dm",b); \
                    printf("%c", txt); \

                    printf("\033[37m"); \
                    printf("\033[40m");

// Affiche une erreur
#define LBB_NERR(errtxt)   printf("\033[31m"); \

                    printf("\033[40m"); \
                    printf("[ERROR] : %s ", errtxt); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");

/*****************************************************************************************
                            Typedefs
*****************************************************************************************/
typedef struct

{
	int index;  // Adresse ligne
	int argstart;

	int ctype;  // Type
	int branch; // Accord de goto

} LBB_CodeLine;

/*****************************************************************************************
                    Contenu de l'eeprom, normalement externe au programme.

                    Toutes les instructions de lectures de cette varibale devront
                    interragir avec le périphérique de support dirrectement.
*****************************************************************************************/
char ProgBuffer[] = "A=0 ; for B, 1, 10;A=A+1 ;if A<=10 ;  goto 3;end ; A=A - 1; if A>=1;goto 7; end ;end ;B=78; C=D ;";

int             LBB_LineCursor = 0;             // Curseur de lecture
int             LBB_LineUltimate = 0;           // Nombre de lignes

LBB_CodeLine    LBB_LineIndex[1024];            // Index des Lignes
int             LBB_ConditionalStack[10];       // Pile de repérage des branchements

/*****************************************************************************************
                            Déclaration des fonctions
*****************************************************************************************/
int LBB_strlen(char *str);
int LBB_strstr(char *str1, char *str2);

int LBB_InitConditionnal();
int LBB_Init();
int LBB_Execut(int LBB_LineToEx);

int LBB_Ltrim(char *str, int offset);
/*****************************************************************************************
                            Fonctions
*****************************************************************************************/

/*****************************************************************************************
                        Découpe et cartographie les lignes de script

                        les ";" actuels seront transcrit comme caracteres
                        spéciaux (habituellement \n, codé 15) dans l'eeprom.
*****************************************************************************************/
int LBB_Init()
{
    LBB_NTI("Initialisation de la trame de code");

    int i=0, j=1;
    while(ProgBuffer[i] != LBB_STOPCHAR)

    {
        if(ProgBuffer[i] == LBB_RCCHAR)

        {
            j++;
            LBB_Ltrim(ProgBuffer, i+1);

            LBB_LineIndex[j].index = i+1;
            LBB_NRC();

        }
        else
        {
            printf("%c", ProgBuffer[i]);

        }
        i++;
    }
    LBB_LineUltimate = j;

    printf("\nNombre de lignes : %d \n", LBB_LineUltimate);
    return(0);

}

/*****************************************************************************************
                            Cartographie de l'arbre conditionel
*****************************************************************************************/
int LBB_InitConditionnal()
{
    LBB_NTI("Analyse des conditionelles");

    int i=0, j=1, charindex = 1, LBB_ConditionalStackIndex = 0;

    char LBB_InstructionBuffer[30];
    for(i = 1 ; i <= LBB_LineUltimate-1 ; i++)

    {
        charindex = 0;
        printf("Ligne n° %d : instruction ", i);

        for(j=LBB_LineIndex[i].index; j<=LBB_LineIndex[i+1].index; j++)

        {

            if(ProgBuffer[j] == 32 || ProgBuffer[j] == 59 || ProgBuffer[j] == 61)

            {
                LBB_InstructionBuffer[charindex] = 0;
                LBB_LineIndex[i].argstart = LBB_strlen(LBB_InstructionBuffer);                // Inscription de l'offset de lecture pour

                break;
            }
            else
            {
            LBB_InstructionBuffer[charindex] = ProgBuffer[j];

            charindex++;
            }
        }



                                                 // les arguments

        printf("%s \t\t(offset de lecture : %d) \n",LBB_InstructionBuffer, LBB_LineIndex[i].argstart);

        if(LBB_strstr(LBB_InstructionBuffer, "if")==1)

        {
            LBB_ConditionalStackIndex ++;                                               // Ajout d'une adresse au STACK conditionel
            LBB_ConditionalStack[LBB_ConditionalStackIndex] = i;                        // pour les retours

            LBB_LineIndex[i].ctype = LBBI_IF;
            LBB_NCIS(LBB_ConditionalStackIndex);

        }
        if(LBB_strstr(LBB_InstructionBuffer, "end")==1)

        {
            LBB_LineIndex[LBB_ConditionalStack[LBB_ConditionalStackIndex]].branch = i;  // Attribution de l'index actuel

            LBB_NCE(LBB_ConditionalStackIndex);                                         // au STACK précedent
            LBB_ConditionalStackIndex --;                                               //

            LBB_LineIndex[i].ctype = LBBI_ELSE;

        }

        if(LBB_strstr(LBB_InstructionBuffer, "for")==1)

        {
            LBB_ConditionalStackIndex ++;                           // Ajout d'une adresse au STACK conditionel
            LBB_ConditionalStack[LBB_ConditionalStackIndex] = i;    // pour les retours

            LBB_LineIndex[i].ctype = LBBI_FOR;
            LBB_NCFS(LBB_ConditionalStackIndex);

        }
/*
        if(LBB_strstr(LBB_InstructionBuffer, "next")==1)
        {
            LBB_LineIndex[LBB_ConditionalStack[LBB_ConditionalStackIndex]].branch = i;  // Attribution de l'index actuel
            LBB_NCE(LBB_ConditionalStackIndex);                                         // au STACK précedent
            LBB_ConditionalStackIndex --;                                               //
            LBB_LineIndex[i].ctype = LBBI_ELSE;

        }
*/

        if(LBB_strstr(LBB_InstructionBuffer, "goto")==1)

        {
            LBB_LineIndex[i].ctype = LBBI_GOTO;
            LBB_NCG();

        }

    }
    if(LBB_ConditionalStackIndex > 0)
    {

        LBB_NERR("Arbre de branchement déséquilibré");
    }
    return(0);

}

/*****************************************************************************************
                                Analyse d'une ligne en vue de l'exécuter
*****************************************************************************************/
int LBB_Execut(int LBB_LineToEx)
{

    // 101 132
    int j=1, charindex;
    char LBB_InstructionBuffer[5],LBB_ArgumentBuffer[30];

        //printf(" >> ligne %d --> argstart: %d, index: %d \n",LBB_LineToEx, LBB_LineIndex[LBB_LineToEx].argstart, LBB_LineIndex[LBB_LineToEx].index);
        /////////////////////////////////////////////////////////////////////////////////////////////
        charindex = 0;

        for(j=LBB_LineIndex[LBB_LineToEx].index; j<= LBB_LineIndex[LBB_LineToEx].index + LBB_LineIndex[LBB_LineToEx].argstart-1; j++)    // Parcour de l'instruction

        {

            LBB_InstructionBuffer[charindex] = ProgBuffer[j];               // Copie dans le Buffer

            charindex++;
        }
        LBB_InstructionBuffer[charindex] = 0;

        /////////////////////////////////////////////////////////////////////////////////////////////
        charindex = 0;
        for(j=LBB_LineIndex[LBB_LineToEx].index + LBB_LineIndex[LBB_LineToEx].argstart; j<= LBB_LineIndex[LBB_LineToEx+1].index-2; j++)    // Parcour des arguments

        {

            LBB_ArgumentBuffer[charindex] = ProgBuffer[j];               // Copie dans le Buffer

            charindex++;
        }
        LBB_ArgumentBuffer[charindex] = 0;

        /////////////////////////////////////////////////////////////////////////////////////////////
        printf("%d#\t",LBB_LineToEx);
        LBB_Ltrim(LBB_ArgumentBuffer, 0);

        //printf("[");
        LBB_CTS(LBB_InstructionBuffer,0,4);
        //printf("][");

        LBB_CTS(LBB_ArgumentBuffer,0,5);

        if(LBB_InstructionBuffer[0] >= LBB_SVDEF && LBB_InstructionBuffer[0] <= LBB_EVDEF)

        {
           printf ("\t\t[Modification du registre ");
           LBB_CTC(LBB_InstructionBuffer[0],0,3);

           printf ("]");
        }
        printf(" \n");

       /* if(LBB_strstr(LBB_InstructionBuffer, "goto")==1)
        {
            LBB_LineIndex[i].ctype = LBBI_GOTO;
            LBB_NCG();
        }*/
    return(0);
}

/*****************************************************************************************
                            Renvoie la taille d'un tableau
*****************************************************************************************/
int LBB_strlen(char *str)
{
    int i=0,  strlen_buffer = 0;

    while(str[i] != 0)
    {

        strlen_buffer++;
        i++;
    }
    return strlen_buffer;

}

/*****************************************************************************************
                            Supprimme les espaces à gauche
                         d'une chaine et renvoie leur nombre
*****************************************************************************************/
int LBB_Ltrim(char *str, int offset)

{
    int i=0, decreased = 0, b;

    while(str[offset] == 32)
    {

        for(i=offset; i<=LBB_strlen(str); i++)

        {
        b = str[i+1];
        str[i] = b;

        }
        decreased++;
    }
    return(decreased);

}

/*****************************************************************************************
                            Compare deux chaines
*****************************************************************************************/
int LBB_strstr(char *str1, char *str2)

{
    int i = 0, strlen_str = LBB_strlen(str1), returned = 1;

    if(strlen_str==LBB_strlen(str2))
    {
        while(i < strlen_str)

        {

            if(str1[i]!=str2[i])

            {
                returned = 0;
            }
            i++;

        }

    }
    else
    {
        returned = 0;

    }
    return returned;

}
/*****************************************************************************************
                            Fonction principale
*****************************************************************************************/
int main()

{
    int i;
    LBB_Init();
    LBB_InitConditionnal();

        LBB_NTI("Exécution");
    for(i=1; i<=LBB_LineUltimate; i++)

    {
        LBB_Execut(i);
    }
    return 0;

}

Et, une fois compilé, ce gros tas de bug donne ca :

++ Tix.

Cette semaine, j'ai entrepris le développement d'un petit interpréteur BASIC simple. Le but à terme est de pouvoir l'utiliser dans des systemes embarqués, genre PIC, AVR... pour traiter de petits scripts "clairs", et ce, sans avoir à gérer l'EMI, qui permet d'étendre la mémoire RAM du micro, sur des systèmes amovibles par exemple.

Le la syntaxe du BASIC que j'entreprends de décoder est un genre d'hybride entre le BASIC des micro d'antan, et un assembleur émulé. J'ai choisi cette voie pour des raisons pratique. En effet, si cette solution est plus stricte au niveau du script, elle est bien plus simple à décoder tout en permettant l'interprétation d'instructions très "bas niveau" (gestion de la mémoire plus poussée, registres, pile, etc...)

voilà un exemple de script :

va =0
vb=0
va = va + 1
if va <= 10
goto 3
else
va= va - 1
if va >= 1
goto 7
else
vb = vb + 1
if vb <= 10
goto 4
else

Ce petit morceau de code fait varier la valeur de va une dizaine de fois, de 1 à 10, puis de 10 à 1.

Actuellement, l'interpréteur n'en est qu'à ses balbutiement. Il découpe d'ors et déjà le script en lignes puis dresse une carte du programme et des branchements conditionnels. En effet, tout l'intéret de cet interpréteur est que le code n'est pas copié dans la RAM dans son intégralité, mais uniquement par ligne. Ensuite, en fonction de la carte dressée au préalable, il pourra exécuter telle ou telle ligne. Pour le développement, j'utilise un code qui n'ets pas le code définitif, mais une émulation de ce qui se passerait dans le PIC. Par exemple, le script ne sera pas stocké dans une variable (ca serait en contradiction avec les principes cités plus haut) mais dans un périphérique externe (genre mémoire EEPROM ou FLASH). Deplus, aucun dispositif de monitoring, tout ce qui est en rapport avec l'affichage sera viré au moment opportun.

Voilà le code actuel :

/*****************************************************************************************


                                  BASIC interpreter
                                (PIC2PC - simulateur)
                                        0.0.1


          By Gery DUBIEF, www.tixlegeek.com, tixlegee AT gmail DOT com

          Code à compiler exclusivement avec GCC. Non compatible WINDOWS

*****************************************************************************************

            -> L'intégralité de ce code est sous license GPL. Rapportez vous au
            site ci dessous pour connaître les conditions exactes de la license.

                            http://www.gnu.org/copyleft/

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

/*****************************************************************************************
                            Reperes de lignes
*****************************************************************************************/
#define LBB_RCCHAR 59
#define LBB_STOPCHAR 0

/*****************************************************************************************
                            Index d'instruction
*****************************************************************************************/
#define LBBI_IF 100
#define LBBI_ELSE 101

#define LBBI_GOTO 102
/*****************************************************************************************
                            Macros du simulateur
*****************************************************************************************/
// Affiche un retour chariot
#define LBB_NRC()   printf("\033[30m"); \

                    printf("\033[43m"); \
                    printf("[RC]"); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche un début de conditionnelle
#define LBB_NCS(stackind)   printf("\033[33m"); \

                    printf("\033[40m"); \
                    printf("{%d\t[Debut de conditionelle IF]", stackind); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche une fin de conditionelle
#define LBB_NCE(stackind)   printf("\033[33m"); \

                    printf("\033[40m"); \
                    printf("}%d\t[Fin de conditionelle IF]", stackind); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche un goto
#define LBB_NCG()   printf("\033[36m"); \

                    printf("\033[40m"); \
                    printf("--> \t<GO TO>"); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche un titre
#define LBB_NTI(titre)   printf("\033[30m"); \

                    printf("\033[47m"); \
                    printf("-------------------- [ %s ] --------------------", titre); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");
// Affiche une erreur
#define LBB_NERR(errtxt)   printf("\033[31m"); \

                    printf("\033[40m"); \
                    printf("[ERROR] : %s ", errtxt); \

                    printf("\033[37m"); \
                    printf("\033[40m"); \

                    printf("\n");

/*****************************************************************************************
                            Typedefs
*****************************************************************************************/
typedef struct

{
	int index;  // Adresse ligne
	int argstart;

	int ctype;  // Type
	int branch; // Accord de goto

} LBB_CodeLine;

/*****************************************************************************************
                    Contenu de l'eeprom, normalement externe au programme.

                    Toutes les instructions de lectures de cette varibale devront
                    interragir avec le périphérique de support dirrectement.
*****************************************************************************************/
unsigned char ProgBuffer[] = "va =0;vb = 0;va = va + 1;if va <= 10;goto 3;else ;va = va - 1;if va >= 1;goto 7;else ;vb = vb + 1;if vb <= 10;goto 4;else ; ;";

int             LBB_LineCursor = 0;             // Curseur de lecture
int             LBB_LineUltimate = 0;           // Nombre de lignes

LBB_CodeLine    LBB_LineIndex[1024];            // Index des Lignes
int             LBB_ConditionalStack[10];       // Pile de repérage des branchements

/*****************************************************************************************
                            Déclaration des fonctions
*****************************************************************************************/
int LBB_strlen(char *str);
int LBB_strstr(char *str1, char *str2);

int LBB_InitConditionnal();
int LBB_Init();
/*****************************************************************************************
                            Fonctions
*****************************************************************************************/

/*****************************************************************************************
                        Découpe et cartographie les lignes de script

                        les ";" actuels seront transcrit comme caracteres
                        spéciaux (habituellement \n, codé 15) dans l'eeprom.
*****************************************************************************************/
int LBB_Init()
{
    LBB_NTI("Initialisation de la trame de code");

    int i=0, j=1;
    while(ProgBuffer[i] != LBB_STOPCHAR)

    {
        if(ProgBuffer[i] == LBB_RCCHAR)

        {
            j++;
            LBB_LineIndex[j].index = i+1;

            LBB_NRC();
        }
        else
        {
            printf("%c", ProgBuffer[i]);

        }
        i++;
    }
    LBB_LineUltimate = j;

    printf("\nNombre de lignes : %d \n", LBB_LineUltimate);
    return(0);

}

/*****************************************************************************************
                            Cartographie de l'arbre conditionel
*****************************************************************************************/
int LBB_InitConditionnal()
{
    LBB_NTI("Analyse des conditionelles");

    int i=0, j=1, charindex = 1, LBB_ConditionalStackIndex = 0;

    char LBB_InstructionBuffer[30];
    for(i = 1 ; i <= LBB_LineUltimate-1 ; i++)

    {
        charindex = 0;
        printf("Ligne n° %d : instruction ", i);

        for(j=LBB_LineIndex[i].index; j<=LBB_LineIndex[i+1].index; j++)

        {
            if(ProgBuffer[j] == 32)

            {
                LBB_InstructionBuffer[charindex] = 0;
                break;

            }
            LBB_InstructionBuffer[charindex] = ProgBuffer[j];

            charindex++;

        }

        LBB_LineIndex[i].argstart = LBB_strlen(LBB_InstructionBuffer)+1;  // Inscription de l'offset de lecture poue

                                                                        // les arguments
        printf("%s \t\t(offset de lecture : %d) \n",LBB_InstructionBuffer, LBB_LineIndex[i].argstart);

        if(LBB_strstr(LBB_InstructionBuffer, "if")==1)

        {
            LBB_ConditionalStackIndex ++;                           // Ajout d'une adresse au STACK conditionel
            LBB_ConditionalStack[LBB_ConditionalStackIndex] = i;    // pour les retours

            LBB_LineIndex[i].ctype = LBBI_IF;
            LBB_NCS(LBB_ConditionalStackIndex);

        }
        if(LBB_strstr(LBB_InstructionBuffer, "else")==1)

        {
            LBB_LineIndex[LBB_ConditionalStack[LBB_ConditionalStackIndex]].branch = i;  // Attribution de l'index actuel

            LBB_NCE(LBB_ConditionalStackIndex);                                         // au STACK précedent
            LBB_ConditionalStackIndex --;                                               //

            LBB_LineIndex[i].ctype = LBBI_ELSE;

        }

        if(LBB_strstr(LBB_InstructionBuffer, "goto")==1)

        {
            LBB_LineIndex[i].ctype = LBBI_GOTO;
            LBB_NCG();

        }

    }
    if(LBB_ConditionalStackIndex > 0)
    {

        LBB_NERR("Arbre de branchement déséquilibré");
    }
    return(0);

}
/*****************************************************************************************
                            Renvoie la taille d'un tableau
*****************************************************************************************/
int LBB_strlen(char *str)
{

    int i=0,  strlen_buffer = 0;
    while(str[i] != 0)

    {
        strlen_buffer++;
        i++;
    }

    return strlen_buffer;
}
/*****************************************************************************************
                            Compare deux chaines
*****************************************************************************************/
int LBB_strstr(char *str1, char *str2)

{
    int i = 0, strlen_str = LBB_strlen(str1), returned = 1;

    if(strlen_str==LBB_strlen(str2))
    {
        while(i < strlen_str)

        {

            if(str1[i]!=str2[i])

            {
                returned = 0;
            }
            i++;

        }

    }
    else
    {
        returned = 0;

    }
    return returned;

}
/*****************************************************************************************
                            Fonction principale
*****************************************************************************************/
int main()

{
    LBB_Init();
    LBB_InitConditionnal();
    return 0;

}

Et, une fois compilé, ce gros sac de noeud donne ca :

Plus d'infos dans les semaines à venir.

Salutations !!

Apres ce long silence, dû à trop et trop peu à la foi, je reviens avec un ptit programme qui date d'il ya tout-juste quelques heures. Un effet matrix en C.

Le code source :

Aujourd'hui, grace a un fil tres intéressant sur le SDZ, j'ai repris le codage d'effest graphiques en programmation ! Je commence avec OpenGL en C (je faisait ca en Qbasic avant ^^) La migration du 16bit vers le 32 bit s'est bien passée. voilà mes réalisations pour le momment :

Comme vous pouvez le constater, j'ai tester plusieurs interpolations, avec un résultat plus ou moins esthétique... mais ça reste sympa ^^

Code source non disponible depuis changement de serveur, désolé :/

Qu'en pensez vous ? c jouli, non ?^^

Aujourd'huit, je vous montre ma réalisation d'hier soir : Tyni Pong...
J'ai en effet donné pour suite a une question sur un forum, un petit programme illustrant un systeme simple rebond. Rien de compliqué en fait, mais j'ai dû apprendre à utiliser une lib graphique sur le tas en une soirée pour bricoller ca :o

Ce programme a été codé en C, avec la SDL (lib Graphique). Le but du jeu est simple : manquer moin de fois la balle que l'adversaire. Les illustrations ont été réalisées sous Photoshop, et tout a été horriblement codé par un incompétant que je suis, c'est pourquoi la source n'est pas encore transmise ^^

Vous en pensez quoi de mon petit jeu ?, mis a part ses 100% de ressources CPU bouffées ? :] Vous avez des idées pour l'amélioration ?