Woap a écrit 9 commentaires

Je dois rendre le travail demain donc si vous pourriez me guider un peu plus, ça fait deux jours que je suis dessus

#!/bin/sh

# $1 c'est la cible donc A
B=`grep '$1:' | sed 's/$1://g;s/\t//g'`
# J'ai "greper" le motif A: et j'en recupere la valeur B

for k in $B
do
    $0 $B
done

# Je relance le script avec la récursivité pour qu'il cherche le motif B et récupère C ( etc ... )

C'est avec cette base que je dois faire mon script ? C'est bon pour la récursivité la ?

J'ai refait le script ( j'ai modifié le makefile car je ne sais pas distinguer le cas du toto.o et totooo) :
http://img4.hostingpics.net/pics/798206popo.jpg

#!/bin/sh

ligne=`sed -n "/$1:/=" makefile`
texte=`sed -n "$ligne p" makefile`

while [ ! -z "$texte" ]
do
    ligne=`expr $ligne + 1`
    texte=`sed -n "$ligne p" makefile`
    echo "$texte"
done >> CMD

COMMANDE=`sed 's/ /:/g' CMD`
DEPENDANCES=`grep "$1:" makefile | cut -d ':' -f2`

if [ ! -e $1 ] || [ $1 -ot $DEPENDANCES ]
then
    if [ -z $DEPENDANCES ]
    then
        for k in $COMMANDE
        do
            var=`echo $k | sed 's/:/ /g'`
            sh -c "$var"
        done
        rm CMD
        exit 0

    else
        if [ ! -e $DEPENDANCES ]
        then
            TEST=`grep "$DEPENDANCES:" makefile`
            if [ -z $TEST ]
            then
                touch impossible
                $0 impossible
            else
                $0 $DEPENDANCES
            fi
        else
            for k in $COMMANDE
            do
            var=`echo $k | sed 's/:/ /g'`
            sh -c "$var"
            done
            $0 toto
        fi
    fi
else
    rm CMD
    exit 0

fi

Le script fonctionne pour le cas ou il prend comme argument clean.
Si tota existe, toto est bien crée
Sinon je tombe toujours dans le cas impossible

Par contre si toto.c existe, le script ne construit pas tota puis toto mais tombe dans le cas impossible aussi ..

Donc ce script ne fait pas ce que tu demande ? :

if [ ! -e A ]
then
    if [ ! -e B ]
    then
        $0 $B
    else
        for k in $COMMANDE
        do
            var=`echo $k | sed 's/:/ /g'`
            echo $var
            sh -c "$var"
        done
        $0 A
    fi
else
echo "$1 existe déjà"

En fait j'ai écrit le script avec la récursivité mais je ne sais pas s'il fonctionne et pour vérifier je dois récupérer correctement $DEPENDANCES / $COMMANDE :

#!/bin/sh

FAUX -> DEPENDANCES=` grep -v '^#' makefile | grep "$1:" | sed 's/\t//g' | cut -d ':' -f2 | head -1 `
FAUX -> COMMANDE=`grep -v '^#' makefile | head -4 | tail -2 | sed 's/\t//g;s/ /:/g'`

#echo $DEPENDANCES
#echo $COMMANDE

if [ ! -e $1 ]
then
    if [ ! -e $DEPENDANCES ]
    then
        $0 $DEPENDANCES
    else
        for k in $COMMANDE
        do
            var=`echo $k | sed 's/:/ /g'`
            echo $var
            sh -c "$var"
        done
        $0 toto
    fi
else
echo "$1 existe déjà"

Donc je cherche toujours le moyen de trouver pour "greper" correctement ce qu'il me faut :

• $DEPENDANCES : grep 'toto:' makefile | cut -d ':' -f2 | sed 's/\t//g'

Ça marche mais pour
grep 'toto.o:' makefile | cut -d ':' -f2 | sed 's/\t//g'
J'obtiens les résultats pour deux cibles ( toto.o et totooo )
Comment je désactive le . en tant que caractère générique

• $COMMANDE : Ici j'essaye de récupérer les lignes après le $DEPENDANCES jusqu’à qu'il y ai une ligne vide

LIGNE=`sed -n "/$1:/=" makefile`
TEXTE=`sed -n "$LIGNE p" makefile`

    while [ -z $TEXTE ]
    do
        LIGNE=`expr $LIGNE + 1`
        TEXTE=`sed -n "$LIGNE p" makefile`
        echo $TEXTE
    done

Je ne sais pas pourquoi mais ça ne fonctionne pas lorsque je lance ce petit script ( message d'erreur -> [: 13: toto:: unexpected operator )

Voila merci d'avance

J'ai compris cela mais disons par exemple :

./mon_script toto

D'après mon script plus haut :

Dans $DEPENDANCES -> je veux avoir 'toto.o'
Dans $COMMANDE -> je veux 'touch toto echo toto est touche'

Après je vérifie les dépendances :

Si toto.o existe
J’exécute tout ce qu'on trouve dans $COMMANDE
Sinon ( récursivité ) je relance mon script avec comme argument toto.o ( ce qu'on trouve dans $DEPENDANCES )

==========================================================================================================================================================================================================================================================================================================================================================================

Donc le script aura maintenant
$DEPENDANCES -> toto.c
$COMMANDE -> touch toto.o echo toto.o est touche

Et on refait les tests .. et ainsi de suite

Mon problème ici est que je n'arrive pas à stocker dans COMMANDE ET DEPENDANCES les lignes nécessaires.

Oui je n'ai pas encore mis en place la récursivité car j'ai déjà un problème avant voir 1) 3) de mon message précédent

Et j'ai enlever les "cat" dans la correction de mon code voir aussi dans le commentaire précédent sinon pour le "cut" je ne vois pas comment faire autrement c'est pour cela que je l'ai mis.

Nous avons fait beaucoup de script utilisant la récursivité sans l'utilisation des fonctions, donc est-ce indispensable dans mon cas ?

• Oui nous avons vu la notion de fonction shell

• head permet d'afficher le début d'un fichier, dans mon code head -1 la première ligne

Et la correction :

#!/bin/sh
if [ ! -e $1 ]
then
    DEPENDANCES=` grep -v '^#' makefiletest | grep "$1" | sed 's/\t//g' | cut -d ':' -f2 | head -1`
    COMMANDE=`grep -v '^#' makefiletest | grep -v ':' | sed 's/\t//g;s/ /:/g'`

    for i in $DEPENDANCES
    do
        if [ -e $i ]
        then for k in $COMMANDE
        do
            var=`echo $k | sed 's/:/ /g'`
            sh -c "$var"
        done
        else
            grep $i makefiletest 2>&1 /dev/null
            if [ $? -ne 0 ]
            then
                echo "prérequis $i inexistant"
                exit 1
            else
                echo "STOP"
                exit 0
            fi
        fi
    done
else
echo "La cible $1 existe deja"
exit 0
fi

J'en suis au même stade pour mes questions précédentes

J'ai modifié le script en prenant en considération tout les commentaires :

#!/bin/sh
if [ ! -e $1 ]
then
    DEPENDANCES=`cat makefiletest | grep -v '^#' | grep '$1' | sed 's/\t//g' | c                        ut -d ':' -f2 | head -1`
    COMMANDE=`cat makefiletest | grep -v '^#' | grep -v ':' | sed 's/\t//g'| sed                         's/ /:/g'`

    for i in $DEPENDANCES
    do
        if [ -e $i ]
        then for k in $COMMANDE
        do
            var=`echo $k | sed 's/:/ /g'`
            echo $var
            #sh -c "$var"
        done
        else
            cat makefiletest | grep $i 2>&1 /dev/null
            if [ $? -ne 0 ]
            then
                echo "prérequis $i inexistant"
                exit 1
            else
                echo "STOP" <- Récursivité ici ?
                exit 0
            fi
        fi
    done
else
echo "La cible $1 existe deja"
exit 0
fi

1) Comment je fait pour tester si $i se trouve en tant que cible ? ( Par exemple tester si toto.o se trouve en tant que cible )

cat makefiletest | grep $i 2>&1 /dev/null
if [ $? -ne 0 ]

Avec grep j'ai toutes lignes contenant le mot or il faut que la ligne commence par ce mot

2) Pour la récursivité c'est bien ici que je dois le faire avec : $0 $i ?

echo "STOP"

3) Après j'ai toujours le problème pour récupérer $DEPENDANCES et $COMMANDE selon la cible :
Si la cible est toto je dois pouvoir mettre dans

$DEPENDANCES= toto.o

$COMMANDE= touch toto
echo toto est touche

Dans ce script cela fonctionne que quand il n'y a qu'un seul bloc dans le makefile :

toto: toto.o
touch toto
echo toto est touche

Quand il y a plusieurs blocs je n'arrive pas a récupérer juste le bloc correspondant le nom de la cible

Voila merci d'avance