Qualité webcam

++ Tix.

Soyez nombreux à venir signer la pétition contre le brevet logiciel en Europe ! Pour rappel, un brevet logiciel est une technique d'accaparement judiciaire de lignes de code... En d'autre terme, la légalisation de la proprietarisation d'une forme d'accès à la culture et à l'expression ! On ne peu plus être plus liberticide que ce genre de chose... Plus d'information sur le site de la pétition :

++ Tix.

Salutations

Voilà maintenant un bon moment que je tourne presque essentiellement sous GNU/Linux, et, jusqu'à il ya peu, je n'avais encore jamais trouvé d'équivalent viable à M$ Visio (c'est sans doute leur meilleur programme, il faut bien l'avouer). C'est d'autant plus grave qu'aucune machine virtuelle gratuite ne permet de le virtualiser !!!

Puis, j'ai découvert le fabuleux Inkscape !

Car, en effet, comme en témoigne mes Tuxs, et autres illustrations ( qui étaient devenues récurrentes, du temps ou j'utilisait visio ...), je me servait de Visio (propriétaire, berk), qui est en théorie fait pour dessiner des diagrammes et des schémas, pour dessiner des trucs un peu moins techniques. Mais l'utilisation de Inkscape, elle est bien dédiée au dessin! Résultat ? Un programme génial, tres complet, tres performant, et super bien foutu pour dessiner plus que jamais !

Je vous présente donc ma toute première illustration, réalisée entièrement avec ce petit bijou :

Il sagit d'une interprétation toute personnelle de Cernunnos, une divinité gauloise, allégorie de l'abondance... Pour la petite histoire, il fait partie de ceux, parait-il, que les cathos, dans leur quête effrénée de pouvoir, auraient assimilés par la suite au diable, à satan, etc...
Bref, voilà =) c'est pas parfait, mais, en étant raisonnable, je n'aurais sû en espérer plus !

++ Tix.

Il y a à peine quelques mois, la hausse du prix du pétrole était due aux chinois, qui consommaient... Plus tard, il y à environ deux mois, c'était la crise, qui apres avoir fait descendre "momentanément" son cour, allait sans doute le fair eremonter. Mais comme ça ne tiens plus, on à enfin trouvé une solution pour que ces connards de francais ces chers consommateurs francophones, gobent une hausse du prix du pétrole sans trop gueuler : la guerre en palestine...

C'est pas miraculeux la com en france ? en moins de six mois : trois bonnes raison d'expliquer qu'on nous prends pas assez, et qu'il faut participer aux commissions des actionnaires du gouvernement... u_u"

encore une fois : Affligeant ... totalement affligeant ...

++ Tix.

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.

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.

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"

Salutations

Salutations.
C'est un peu révolté que je prends la plume ce matin, en lisant les nouvelles politiques sur le blog de RMS. Il y cite notamment cet article publié sur sfgate.com.

Il y dit, en gros, être la victime des services de renseignements, qui l'auraient trompé, et que l'inexactitude des données à propos de la présence d'armes de destruction massive avait été prouvée. Il se défends, et tente de se défaire de ses responsabilités avant de léguer le pouvoir au prochain président des États-Unis. Il aurait usé, selon l'article sus-cité, de "l'incertitude et de l'effet de panique" pour vendre aux américains, qui selon les mêmes sources aurait coûté la vie de quelques 4200 vies américaines (sans compter les victimes, les vraies, de cette espèce de guerre), plus de cent milliard de dollars par ans, et porté des dommages important à l'image des états unis.

Bon, si on entends parler de ca ce soir au JT de TF1, j'en serait bien étonné en tous les cas, tout le monde sait bien que la seule chose qui intéresse les français, c'est la star'ac et les ébats sexuels des sexagénaires reconvertis... Rappelons aussi que Bush est également le genre de gars à affirmer dans les interview qu'il fait de la politique pour les croyants, et que les athées ne sont pas son principal centre d'intérêt. Une personne bien intentionnée comme dirait Brassens...

++ 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.

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.

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.

Salutations!

Aujourd'hui, je prends la plume (et oui, mon clavier à de drôles d'airs parfois) pour causer pub ! En effet, ce cher Alex.com, qui, comme s'il fallait que je le rapelle u___u', un genre de collègue spirituel, un mentor, doté d'un niveau de geekerie tres élevé. S'il ne fallait citer que son simili-ambilight multizone, son détecteur d'éclaire pour appareil photo, son fusible électronique, ses diverses réalisations à led, son horloge Cmos, son vaisseau, on passerait à coté de bien des réalisations intéressantes. Il fait, de plus, de tres sympathiques photographies (reflex man, comme Giles, le japonais), et cause toujours avec une grande précision sur bien des sujets. Guy (mon pere) dit souvent, (et amicalement) de lui qu'il fait partie des gens avec qui, quand on à fini de discuter, on ne se souviens plus du sujet de départ. C'est un compliment bien entendu, de nos jours, trouver des gens intéressant, c'est coton.

Bref, après cette présentation un peu vaseuse, le vif du sujet: L'amis Alex.com à changé de Blog! En ce qui me concerne, je trouve le changement approprié, étant donné la grande médiocrité des services proposés par NRJ. Bref, un blog intéressant au contenu prenant en règle générale !

voilà le lien : http://le-zgeg25.over-blog.fr/

++ Tix.

Salutations !

Toujours en physique, mais cette fois, d'inspiration tout à fait neutre, un petit diable, méphistophélique diabolique .

++ Tix.

Salutations !

Pour couper court avec la note précédente, voilà un petit dessin fait en cour de physique, une petite gribouille lointaine ment inspirée de du (mauvais) film "Silent Hill". Ce n'est pas mon premier gaillard mutan en masque à oxygene, mais celui ci me plaisait bien.

Voilà donc l'engin si j'ose dire

voilà, z'en pensez quoi ?

++ Tix.