La programmation des scripts ( C-shell)

 

 

Qu'est-ce qu'un script?

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

 

Redirection de flots :

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.

 

Commandes Utiles :

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.   

 

Exemple d'application

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

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 :

Les variables sont des données internes qui servent au programmeur dans son programme. En C-Shell voici comment on utilise les variables:

 

Les expressions

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érateurs booléens :

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

 

Algorithmique: quelques structures de contrôle

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.

1.      if...then...else...endif :

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
 
 
 
 
 
 
 

2.      foreach...end

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
 
  1. repeat

La syntaxe est la suivante :

repeat count command
Exemple:  repeat 10 echo "allo"

Affiche allo 10 fois.

 

Exercices 

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