gunsailor a écrit 24 commentaires

Bonsoir Tonton Th,
je vais prendre cette habitude désormais…
Merci!

merci dalfab,
ton commentaire m'a permis de résoudre mon problème!
En effet, je ne vois pas pourquoi j'allouais de la mémoire…
J'ai pris en compte aussi ta réflexion à propos des fonctions en ligne.
Je vous remercie tous chaleureusement !!
bonne soirée!

ouai!! merci les gars.
à+

oui j'utilise la version de ma distribution.
J'ai utilisé valgrind -v sans plus de résultats.
Quant à gdb, maintenant il m'indique pour SDL_Init:

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff781536c in ?? () from /usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0

Je n'ai plus la même erreur sans rien avoir touché.
ET POURTANT, lorsque je vire la quasi totalité de mon code pour nelaisser que ma fonction d'initialisation, SDL_Init se comporte à ravir…
Je vous refile la totalité de mon code, je n'arrive pas à le formater pour qu'il rende dans les balises:

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>
#include <stdio.h>
#include<stdlib.h>
const int SCREEN_WIDTH = 640;
const int SCREEN_HEIGHT = 480;
SDL_Window* gWindow = NULL;
SDL_Renderer* gRenderer = NULL;
TTF_Font *gFont = NULL;
void free1(SDL_Texture *mTexture)
{
    //Free texture if it exists
    if( mTexture != NULL )
    {
        SDL_DestroyTexture( mTexture );
        mTexture = NULL;
    }
}
int loadFromRenderedText(SDL_Texture *mTexture, char textureText[200], SDL_Color textColor, SDL_Rect *position )
{
    //Get rid of preexisting texture
    free1(mTexture);
    //Render text surface
    SDL_Surface* textSurface = TTF_RenderText_Solid( gFont, textureText, textColor );
    if( textSurface == NULL )
    {
        printf( "Unable to render text surface! SDL_ttf Error: %s\n", TTF_GetError() );
    }
    else
    {
        //Create texture from surface pixels
        mTexture = SDL_CreateTextureFromSurface( gRenderer, textSurface );
        if( mTexture == NULL )
        {
            printf( "Unable to create texture from rendered text! SDL Error: %s\n", SDL_GetError() );
        }
        else
        {
            //Get image dimensions
            position->w = textSurface->w;
            position->h = textSurface->h;
        }
        //Get rid of old surface
        SDL_FreeSurface( textSurface );
    }
    //Return success
    return mTexture != NULL;
}
void render(SDL_Texture *mTexture, SDL_Rect* clip)
{
    SDL_RenderCopy( gRenderer, mTexture, clip, clip);
}
int init()
{
    //Initialization flag
    int success = 1;
    //Initialize SDL
    if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "SDL could not initialize! SDL Error: %s\n", SDL_GetError() );
        success = 0;
    }
    else
    {
        //Set texture filtering to linear
        if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
        {
            printf( "Warning: Linear texture filtering not enabled!" );
        }
        //Create window
        gWindow = SDL_CreateWindow( "SDL Test", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );
        if( gWindow == NULL )
        {
            printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
            success = 0;
        }
        else
        {
            //Create vsynced renderer for window
            gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
            if( gRenderer == NULL )
            {
                printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
                success = 0;
            }
            else
            {
                //Initialize renderer color
                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                //Initialize PNG loading
                int imgFlags = IMG_INIT_PNG;
                if( !( IMG_Init( imgFlags ) & imgFlags ) )
                {
                    printf( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
                    success = 0;
                }
                 //Initialize SDL_ttf
                if( TTF_Init() == -1 )
                {
                    printf( "SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError() );
                    success = 0;
                }
            }
        }
    }
    return success;
}
int loadMedia(SDL_Texture *mTexture, SDL_Rect *position)
{
    //Loading success flag
    int success = 1;
    //Open the font
    gFont = TTF_OpenFont( "lazy.ttf", 28 );
    if( gFont == NULL )
    {
        printf( "Failed to load lazy font! SDL_ttf Error: %s\n", TTF_GetError() );
        success = 0;
    }
    else
    {
        //Render text
        SDL_Color textColor = { 0, 0, 0, 255};
        char text[200];
        sprintf(text, "The quick brown fox jumps over the lazy dog");
        if( !loadFromRenderedText(mTexture, text, textColor, position ) )
        {
            printf( "Failed to render text texture!\n" );
            success = 0;
        }
    }
    return success;
}
void close(SDL_Texture *mTexture)
{
    SDL_DestroyTexture( mTexture );
    mTexture = NULL;
    //Free global font
    TTF_CloseFont( gFont );
    gFont = NULL;
    //Destroy window    
    SDL_DestroyRenderer( gRenderer );
    SDL_DestroyWindow( gWindow );
    gWindow = NULL;
    gRenderer = NULL;
    //Quit SDL subsystems
    TTF_Quit();
    IMG_Quit();
    SDL_Quit();
}
int main( int argc, char* args[] )
{
    SDL_Texture* mTexture = NULL;
    SDL_Rect position;
    position.x = 100;
    position.y = 100;
    position.w = 0;
    position.h = 0;
    //Start up SDL and create window
    if( !init() )
    {
        printf( "Failed to initialize!\n" );
    }
    else
    {
        //Load media
        if( !loadMedia(mTexture, &position) )
        {
            printf( "Failed to load media!\n" );
        }
        else
        {   
            //Main loop flag
            int quit = 0;
            //Event handler
            SDL_Event e;
            //While application is running
            while( !quit )
            {
                //Handle events on queue
                while( SDL_PollEvent( &e ) != 0 )
                {
                    //User requests quit
                    if( e.type == SDL_QUIT )
                    {
                        quit = 1;
                    }
                }
                //Clear screen
                //SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                //SDL_RenderClear( gRenderer );
                ////Render current frame
                //render(mTexture, &position );
                ////Update screen
                //SDL_RenderPresent( gRenderer );
            }
        }
    }
    //Free resources and close SDL
    close(mTexture);
    return 0;
}

meric pour votre retour. à bientôt!

Et non, j'aurais dû le préciser par ailleurs.
J'appelle mon SDL_Init en tout début de code.
J'ai juste déclaré quelques variables avant en les initialisant soit à NULL soit à 0.
Je ne vois vraiment pas d'où vient le problème!
Surtout que, comme je le répète, j'ai seulement modifié un code c++ en code c sans toucher à l'organisation des fonctions…
C'est à n'y rien comprendre.

Oui je sais bien, mais je ne fais pas jouer la machine en premier dans l'algorithme;
je m'explique: Je fais jouer la machine sur un coup, puis c'est le joueur que j'évalue…
Je fais ça pour les 7 coups possibles.
Du coup, ma profondeur est de depth + 1.
Je ne sais pas si je formule bien.
En gros j'appelle negamax ( ou bien minmax et là pour le coup ça marche ) 7 fois et je prends la position correspondant au maximum des scores que j'obtiens.
Mais negamax, comme son nom l'indique est un Maximizer pour la racine.
J'essaie de trouver le pendant de negamax: negamin.

Je vous livre ici le code de mon application.
Faites en bon usage.
Merci encore

Merci NeoX,
je viens enfin d'aboutir.
Le sujet est maintenant résolu.
Sur mon prochain post, je vous livrerai la page github de mon projet.
Merci encore

Merci gUI,
Je suis arrivé à faire en partie ce que je voulais grâce à toi.
Maintenant j'ai un problème de guillemets non-appairés.
Les fichiers contenant des guillemets ne sont pas traités.
Verrais tu une solution à mon problème ?

Merci, je ne connaissais pas cette fonctionnalité de realloc.
Aussitôt dit aussitôt fait.
Je suis en train d'éditer un programme exemple assez conséquent histoire de montrer les possibilité du module.
Je reviens pour poster le lien github.

c'est entendu.
Mon problème n'est toujours pas résolu.
Je vais être plus précis.
Je dispose de fichiers mp3 avec un surplus de caractères.
J'enlève ce surplus de caractères et range l'ensemble des noms de mes fichiers tronqués dans MON_FICHIER.
C'est à partir de là que je bug.
comment faire pour passer au premier paramètre du mv de mon xargs les nom des fichiers dont je ne dispose que d'une partie tronquée.
d'où le:

{}*

qui ne fonctionne pas.
pourriez vous me venir en aide?

Je tiens juste à préciser que la formule:

< MON FICHIER >

signifiait n'importe quel fichier de mon hdd.

Bon alors là j'ai dû mal me faire comprendre. size est la taille de result. Si size vaut 0 alors result est égal à null. Mais je veut bien concevoir votre aspect de la réalité:

if(*size < len){
    if(*result == NULL)
        *result = calloc(len +1,  sizeof(char));
    else
        *result = realloc(*result, (len + 1) * sizeof(char));
    *size = len;
}

et le calloc reste essentiel !

merci pour ces précisions.
Un peu de lecture ne me fera pas de mal.

Merci pour votre patience.
Le code rectifié est le suivant:

        if(*size < len){
            if(!*size)
                *result = calloc(len + 1, sizeof(char));
            else
                *result = realloc(*result, (len + 1) * sizeof(char));
            *size = len;
        }

avec size affecté en dernier.

J'espère que c'est plus clair.

Le programme est maintenant fonctionnel et sans leak.

Je vais poster, dès la création de la page, le lien github de ce petit bout de code à destination de ceux qui haïssent le bash.

Bonjour Mr Marec,
je vais tenter d'expliquer cette partie du code:
1. result: résultat en chaîne de caractères des opérations précédentes de l'exécution de la chaîne de modules courante - je nommerai ces dernières "listing". Il est censé être ré-allouer dès que nécessaire et libéré après conservation dans le tableau process_datas->result de ma structure process_datas, ce à la fin de l'exécution de chaque listing.
2. size: taille du string result nécessaire à la fonction fd_readn pour le calcul d'un espace supplémentaire éventuel - le but étant de limiter les libérations.
1. len: somme des longueurs des strings à concaténer ( ne peut pas être égal à 0 ):
- code de la fonction interne concat revisité:

        int len = 0;
        for(int l = 1; l < p->args[*i][1] - 1; l++)
            len += strlen(p->commands[*i][l]);
        if(*size < len){
            *size = len;
            if(!*size)
                *result = calloc(len + 1, sizeof(char));
            else
                *result = realloc(*result, (len + 1) * sizeof(char));
        }
        strncpy(*result, p->commands[*i][1], strlen(p->commands[*i][1]));
        for(int l = 2; l < p->args[*i][1] - 1; l++)
        {
            strncat(*result, p->commands[*i][l], strlen(p->commands[*i][l]));
        }
        ++(*i);
        return 256;

remarquez l'incrémentation du i de la boucle de process_exec et dont je vérifie la validité dans cette même dernière fonction ( améliorée ), afin d'éviter de passer par le pipe si jamais le listing courant se terminait par une commande internal:

        if((ret = process_datas_internal(p, &result, &size, &i)) == EXIT_FAILURE)
        {
            free(result);
            perror("Bad internal process");
            return EXIT_FAILURE;
        }else if(i == p->size)
            break;

Mon programme se comporte mieux ( il fonctionne ). Par contre, je vais devoir m'arracher les cheveux pour trouver le pointeur non libéré que m'indique valgrind:

==26878== LEAK SUMMARY:
==26878==    definitely lost: 128 bytes in 1 blocks

merci encore une fois de votre attention. Si vous souhaitez collaborer à la conception de ce module destiné à la création de nouveaux modules… n'hésitez pas à m'en faire part.

Merci David pour toutes ces suggestions.
```

Je suis tombé sur un truc intéressant intitulé "Communication classique entre processus"
concernant une "possibilité rarement proposée par les shell".

Il s'agit tout simplement de l'emploi du pipe, ce afin de rediriger l'entrée ET la sortie ( c'est là la nouveauté ) d'une sous routine de mon programme père. Ce système permet l'exécution de sous-routines à la chaîne, et donc de créer un programme composé uniquement de sous-routines - que j'appellerais modules du programme. En concaténant plusieurs modules, on peut arriver à créer un nouveau programme basé sur ces mêmes modules.
Mon programme n'est qu'un utilisateur de sous programmes/routines/modules.
Il est destiné à l'édition ( via un utilitaire d'édition en ncurses ) de nouveaux programmes dont les paramètres ( aide, modules au format json avec messages d'erreur pour chacun d'entre eux etc... ) seront classés au sein d'une base de donnée.
Chaque sous routine devra dès lors être imbriquée dans une liste doublement chaînée afin de faciliter la correction des erreurs, l'éditeur permettant à tout instant de lancer un programme partiel ( ou pas ) afin d'en vérifier les résultats intermédiaires.
J'ai même envie de donner à mon module le nom "concat", la fonctionnalité qui m'a amené à rédiger ce topic.


Alors je sais que c'est un peu imbuvable question longueur,

```J'essaierai de faire mieux la prochaine fois, en me rappelant du conseil donné plus haut par j_m et en gardant un formatage décent.

    Préférez strncat et strncpy qui vous éviterons des ennuis, d'autant que vous recalculez la longueur juste avant.

J'ai fait comme vous me l'avez préconisé.

Vous aviez raison pour le calloc… En effet, result peut avoir été alloué au préalable.
voici le code spécifique à concat dans internal:

            int len = 0;
    for(int l = 1; l < p->args[i][1] - 1; l++)
        len += strlen(p->commands[i][l]);
    if(*size < len){
        *size = len;
        if(!*size)
            *result = calloc(len + 1, sizeof(char));
        else
            *result = realloc(*result, (len + 1) * sizeof(char));
    }
    strncpy(*result, p->commands[i][1], strlen(p->commands[i][1]));
    for(int l = 2; l < p->args[i][1] - 1; l++)
    {
        strncat(*result, p->commands[i][l], strlen(p->commands[i][l]));
    }
    return 256;

En ce qui concerne size, j'avais oublié de lui affecter len. size est un marqueur qui me permet de savoir si result mérite d'être ré-alloué dans fd_readn. Dans ce cas, il est incrémenté en conséquence dans cette dernière fonction avant la prochaine itération de la boucle de process_exec.

Merci de votre attention.

Le problème n'est toujours pas résolu.

merci je m'en étais aperçu.
En plus de cela je m'étais mélangé les pinceaux avec la variable "size" pour effectuer l'agrandissement de ma variable "content". sujet résolu.

il m'a juste paru un peu bizarre que parallèlement à l'ouverture de ce fichier par le biais de la visionneuse debian stretch, il y ait eu à la fois un avertissement de format non reconnu et un crash du noyau.
Mis de côté ces quelques remarques, peut-être, en effet, que j'ai parlé trop vite.
Je m'en excuse.

C'est en téléchargeant le pdf situé dans l'onglet "complete-book-pdf" qu'un script semble s'être exécuté.
Toute modification sur mon noyau étant inefficace, je me suis attelé ( en fin de journée ) à tout réinstaller de a-z.
Après ça, mes scripts fonctionnant comme prévu, j'en ai déduit que cela venait de ce pdf,
qui n'avait pas été reconnu en tant que tel lors du lancement,
et qui avait fait mouliner mon pc jusqu'au reboot.

Je relance le topic car j'ai voulu éditer un message le lendemain du premier, mais le site devait être en chantier car je n'ai pas pu le poster.
Du coup, j'ai planché le sujet des iptables plus en profondeur, ai compris qu'il n'y avait pas que la table filter et ai étudié les correspondances.
J'en suis arrivé à un script qui fonctionne et me protège bien d'avantage que le pare-feu de ma box ( débogage grâce au journal ).
J'ai bien accès à tous les logiciels que j'utilise et me suis rendu compte au passage que keepass2 provoquait une boucle locale …
J'ai accès par internet aux sites d'actualité et aux sites en streaming… mais pas aux sites de vente ni à ceux concernant l'informatique.
Je n'ai même pas accès à linuxfr en fait, et j'ai dû flusher mon pare-feu pour envoyer ce message.
Y aurait-il une quelconque explication rationnelle?

merci d'avoir pris le temps d'examiner cela avec moi et de décortiquer pour moi ces commandes.
Je vais me méfier de tout ce qu'il y a marqué dans ce bouquin désormais.

voici la sortie du programme répertorié dans le livre de christophe blaess:

echo $SHLVL
1
./exemple-execve
2
sh
./exemple-execve
3
exit
./exemple-execve
2

avec pour fichier c:

extern char ** environ;
int main(int argc, char ** argv)
{
char* args[]= {"bash", "-c", "echo $SHLVL", (char*) NULL};
execve("/bin/bash", args, environ);
return EXIT_SUCCESS;
}

et ceci seulement après avoir changé les "sh" en "bash".
l'appel à un autre shell par "sh", ne modifie pas le nombre contenu dans la variable $SHLVL.

gunsailor@soulfly:~$ echo $SHLVL
1
gunsailor@soulfly:~$ ./exemple-execve
2
gunsailor@soulfly:~$ sh
$ ./exemple-execve

2

je n'avait pas bien compris l'allusion de Benoît. désolé.
mais cela ne fonctionne toujours pas!
avez-vous des retours sur ce bouquin ?
merci d'avance

ce commentaire est inutile.
j'ai quand même essayé de renommer mon exécutable, rien n'y fait.
la variable $SHLVL devrait être incrémentée au fur et à mesure des appels.
que se passe-t-il?