La
programmation des scripts ( C-shell)
Un script est une suite de commandes qui se trouver dans un
fichier exécutable. Ils permettent d'automatiser des opérations répétitives.
·
La première ligne du script indique le
shell utilisé pour interpréter le contenu du fichier.
o #! suivi du shell (ex: #!/bin/tcsh) Indique que le shell tcsh interprètera le fichier.
o # avec rien sur la ligne. Indique que le c-shell interprètera le fichier.
o Sinon, le Bourne shell interprétera le fichier.
· Les autres lignes du fichier contiennent des commandes.
· Le fichier doit posséder la permission "execute". Utiliser la commande "chmod".
· Le caractère "#" délimite les commentaires dans un script shell. Tout ce qui suit le "#" sur une ligne est considéré comme un commentaire.
On écrit #!/bin/csh en début de fichier pour que
l'interpréteur de commandes lance un C-Shell pour exécuter le programme en
question.
Pour exécuter un script il faut rendre son fichier
exécutable avec la commande chmod et après l’exécuter avec la commande
./NomFichier .
Les différents shells :
Le shell est un interprèteur de commande.
Comment changer de shell.
bash% tcsh
tcsh% cd ~bergeret
tcsh% exit
bash%
SHELL=csh
Pour chaque commande ayant un input et un output on peut
redirige les flots vers des fichiers.
Voici les différents opérateurs de redirection :
Opérateur |
Fonction |
Cmd1 | Cmd2 |
Dirige
l'output de Cmd1 sur l'input de Cmd2. |
Cmd1 >
fichier1 |
Dirige
l'output de Cmd1 dans le fichier fich1 en écrasant son contenu. |
Cmd1 >>
fichier1 |
Dirige
l'output de Cmd1 dans le fichier fich1 et le place à la suite du texte
existant. |
Cmd1<
fichier1 |
Dirige le
fichier fich1 dans l'input de la Cmd1. |
Pour utiliser au mieux ces redirections il faut être capable de traiter les flots de données, voici donc quelques commandes et quelques indications pour les utiliser:
Commande |
Fonction |
grep expr |
Ne garde que les lignes qui marchent avec expr |
sed expr |
Identique mais peut aussi effectuer des remplacements. |
find dir –name expr –print –exec com \ |
Trouve dans l’arborescence en dessous de dir les fichiers dans le nom
matche avec expr et exécute comm. |
Comment faire pour éliminer tous les fichiers portant les
noms passés en argument ? Appelons cette commande rmmax et développons-la.
Pour chaque nom passé en argument il faudra appliquer la même suite de
commandes: nous utiliserons une boucle foreach. Pour chacun de ces noms
il faudra alors trouver toutes les occurences du nom dans l'arborescence et
leur appliquer un taitement simple (rm) nous pouvons donc utiliser find
pour cela.
On obtient donc le programme suivant:
#
set i
foreach i ($argv)
find . -name $i -print -exec rm {} \;
end
Les arguments sont la suite de caractères qui suivent la commande quand vous l'exécuté, ils sont séparés par un espace et voici comment les utiliser:
exemple: ls -al a un seul argument: -al
pour le récupérer, on utilise $argv[1] ou $1
Les variables sont des données internes qui servent au programmeur dans son programme. En C-Shell voici comment on utilise les variables:
Une expression peut être par les opérateurs classiques suivants:
Opérateur |
Fonction |
Expr1 + Expr2 |
Fait le somme. |
Expr1 – Expr2 |
Fait la différence. |
Expr1 * Expr2 |
Fait le produit. |
Expr1 / Expr2 |
Fait le quotient. |
Pour forcer l'évaluation on inclut l'expression dans des
parenthèses ().
Exemple: le programme suivant calcule le produit de 2
valeurs entrées en argument
#
set prod=0
@ prod = $argv[1] * $argv[2]
echo ``le resultat est ''$prod
Opérateur
|
Fonction
|
Expr1 > Expr2
|
Supérieur.
|
Expr1 < Expr2
|
Inférieur.
|
Expr1 >= Expr2
|
Supérieur ou égal.
|
Expr1 <= Expr2
|
Inférieur ou égal.
|
Expr1 == Expr2
|
Egal.
|
Expr1 != Expr2
|
Différent.
|
Expr1 && Expr2
|
ET logique.
|
Expr1 || Expr2
|
OU logique.
|
·
L'expression
Expr1 > Expr2 a alors la valeur 1 (vrai) si la valeur de Expr1 est
supérieure à celle de Expr2 et elle prend la valeur 0 (faux)
sinon. Et de même pour chacun des opérateurs du premier groupe.
·
Le
ET logique de Expr1 et Expr2 a pour valeur 1 si Expr1 et Expr1
ont pour valeur 1. Il a pour valeur 0 sinon.
·
Le
OU logique de Expr1 et Expr2 a pour valeur 1 si Expr1 ou Expr2
ont pour valeur 1. Il a pour valeur 0 sinon (c'est-à-dire s'ils ont tous
les deux pour valeur 0).
Test sur les fichiers
Les structures de contrôle sont des structures qui
permettent de contrôler le déroulement d'un programme et de lui faire subir des
modifications par rapport à une exécution linéaire.
La structure if va permettre de vérifier une condition et d'avoir deux traitements possibles suivant la véracité de cette condition. La syntaxe est la suivante:
if (expr_Bool)
then
Exécuter si vrais
else
Exécuter si faux
endif
Exemple d'application: ce programme vérifie un mot de
passe (ici en clair 12345678)
#
set passwd=12345678
if ( $1 == $passwd ) then
echo "ok"
else echo "refuse"
endif
La structure de contrôle foreach permet d'appliquer un même traitement à
une liste de valeurs. En voici la syntaxe:
foreach variable (Liste-des-valeurs)
Suite des
commandes.
end
Le shell va exécuter la suite des commandes pour chaque valeur de la liste
« liste-des-valeurs » en affectant la valeur courante de la liste à
variable.
Exemple d'application: ce programme liste tous les
répertoires passés en arguments.
#
set i
foreach i ($argv)
echo "----------------------------------------------------------"
echo $i
echo "----------------------------------------------------------"
ls $i
end
3. while...end
Cette
structure permet de faire une suite d'opération tant qu'une expression est
vraie. La syntaxe est la suivante:
while
(expression)
suite de commandes
end
Exemple d'utilisation:
#
while (1)
wait
echo ``penser au cadeau de Melanie''
end
Ce programme ne s'arrête jamais... comment l'arrêter? Avec kill ou en faisant ctrl+C dans la fenêtre qui exécute le programme.
4. switch :
Cette
structure joue le rôle de plusieurs if suivi.
La syntaxe est la suivante :
switch ( chaîne )
case val1 :
liste
de commandes
breaksw
…………
default :
liste de commandes
breaksw
endsw
Exemple
d'utilisation:
#
set date = (`date`)
switch ($date[1])
case Fri:
echo Thank goodness it\'s Friday!
Breaksw
case Thu:
echo It\'s Friday tomorrow!
Breaksw
default:
echo It\'s still a long time until Friday.
Breaksw
endsw
La syntaxe est la
suivante :
repeat count command
Exemple: repeat 10 echo "allo"
Affiche allo 10 fois.
Lisez le manuel sur ces commandes et pour chacune essayez de savoir ce qu'elles fait.
Exercice
1.
Ecrire un
script qui demande à l’utilisateur de rentrer deux nombres et qui retourne la
somme et le produit de ces deux nombres.
Solution :
#
echo -n "Entrez un nombre:"
set a = $<
echo -n "Entrez un nombre:"
set b = $<
@ s = $a + $b
@ m = $a * $b
echo "La somme est " $s
echo "Le produit est " $m
Exemple 2.
Ecrire un script qui
affiche tous les répertoires et les sous fichiers du répertoire courant. Et
s’il y autre chose qu’un fichier ou un répertoire il l’affiche aussi.
#
foreach file ( * )
if( -f $file ) then
echo "Fichier:" $file
else if( -d $file ) then
echo "Repertoire: " $file
else
echo "Autre:" $file
endif
end
Exemple 3.
Ecrire un script qui demande à l’utilisateur s’il veut quitter. Si la réponse
est oui ou o alors on quitte, si la réponse est non ou n alors le programme
boucle, si la réponse est différente des deux alors on demande de reposer la
question.
#
while( ! $?quit )
echo -n "Voulez-vous quitter? (oui/non)"
set reponse = $<
switch ( $reponse )
case oui:
echo "Vous avez
répondu oui\n"
set quit
breaksw
case non:
echo "Vous avez
répondu non\n"
breaksw
case o*:
echo "Je suppose
que vous voulez répondre oui\n"
set quit
breaksw
case n*:
echo "Je suppose
que vous voulez répondre non\n"
breaksw
default:
echo "Je ne
comprends pas votre réponse\n"
breaksw
endsw
end #while