Nuit Du Hack
Creative Commons License
.

Aller au contenu | Aller au menu | Aller à la recherche | Voir les modalités d'utilisation des travaux de l'auteur

Page d'accueil rss Sélection Geekstories.fr La Boite à Vomi

dimanche 28 décembre 2008

La Quadrature.net : Nouveau scandale muet...

[ Partager : Partager sur Digg ]
citation directe de La Quadrature.net :

Paris, le 17 Décembre 2008. L'amendement n°125 à la loi sur l'audiovisuel public, déposé par le rapporteur Christian Kert et Françoise de Panafieu vient d'être voté. Il vise à soumettre au contrôle du Conseil Supérieur de l'Audiovisuel les publicités sur Internet. Au nom de la protection de l'enfance, cet amendement absurde crée un dangereux précédent visant à imposer l'idée de régulation des contenus sur Internet.

« S’agissant des services consistant à éditer du contenu créé par des utilisateurs privés à des fins de partage et d’échanges au sein de communautés d’intérêt, le Conseil supérieur de l’audiovisuel veille à ce que la publicité placée par l’éditeur du site ne puisse nuire à l’épanouissement physique, mental ou moral des mineurs. »

« Protégeons les enfants ! » Qui pourrait s'opposer à ce noble objectif ? Il est pourtant indispensable de s'interroger sur la légitimité de mesures visant, sous ce prétexte, à imposer plus de contrôle1 et à contourner l'autorité judiciaire. L'amendement n° 125 est de ceux là : cette proposition réactionnaire et inapplicable constitue une atteinte grave à la libre concurrence et à la liberté d'expression.

D'ailleurs cet amendement ne décrit aucunement ses conditions d'applications. De même, la définition floue des « services consistant à éditer du contenu créé par des utilisateurs privés à des fins de partage et d’échanges au sein de communautés d’intérêt » pourrait très bien englober la quasi-totalité de l'Internet non-marchand, soit la vaste majorité des contenus publiés sur le réseau.

« Assimiler le réseau Internet aux médias télévisuels est au mieux une escroquerie intellectuelle (et technique), au pire une grave menace pour la liberté d'expression. » affirme Jérémie Zimmermann, co-fondateur de La Quadrature du Net, «  Cette mesure est un pied dans la porte, un pas de plus vers un contrôle administratif du réseau, une mise en coupe réglée par le pouvoir politique. Et le tout au nom de la protection de l'enfance, bien sûr ! »

Je n'ai rien à dire de plus, cependant, comme on pourrais s'autoriser à le préconiser, faites tourner, faites tourner ! . enfin, là, je ne le dis pas hein, je vous le suggère ;) plusplus, Tix.

samedi 20 décembre 2008

Phrase à la con n°2

[ Partager : Partager sur Digg ]
Il a parlé
"Hâtons nous de succomber à la tentation avant qu'elle ne s'éloigne." (Épicure)

le nouvel AspirAtor

[ Partager : Partager sur Digg ]

Ouiouioui, ce matin, en faisant les courses avec le pere, on est tombé né à né avec un engin assez spéciale dans le rayon informatique de l'échoppe visitée : le nouvel Acer Aspire Predator.



Réplique du pere : "Ho regarde, un aspirateur !"

Petit clin d'œil en passant, au vieil Alex.com qui, fût un temps, m'avais parlé du très fameux "Gringo del validator"

mercredi 17 décembre 2008

Phrase à la con n°1

[ Partager : Partager sur Digg ]
Le saviez vous ?
Un homme marche à une vitesse moyenne de 8,6x1012 Angström/semaine.

jeudi 11 décembre 2008

Developpement -> LowBrainBasicInterpreter [0.0.2]

[ Partager : Partager sur Digg ]

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.

mercredi 10 décembre 2008

Au passage ...

[ Partager : Partager sur Digg ]
salutations

Au passage, comme je le disait, souhaitons la bienvenue à Lara, la dernière release stable petite fille de Ornella et Alex, devenus heureux parents en ce 6 décembre 2008! Beaucoup de bonheur à eux deux et à leur petit bou d'chou!

++ Tix.

Developpement -> LowBrainBasicInterpreter

[ Partager : Partager sur Digg ]
Salutations

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.

Creative Commons License
Les travaux signés "Tixlegeek" by DUBIEF Gery sont mis à disposition selon les termes de la licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Partage des Conditions Initiales à l'Identique 2.0 France.

Pour toute modifications apportées, ou diffusion, merci de mentionner l'auteur d'origine, et l'adresse de ce blog.