Le SHELL.
On a coutume de représenter UNIX sous forme de 4 couches concentriques avec, au plus bas niveau la couche matériel comprenant le bus, le processeur et tous les dispositifs d'entrées/sorties.
La couche noyau comprenant tout le code résident qui assure la gestion correcte des processus et qui contrôle l'accès aux ressources du système.
La couche utilisateur inclut toutes les commandes fournies avec le système et s'interface directement avec le kernel (noyau).
Et enfin le niveau application peut soit accéder directement aux services du noyau par le biais des librairies, soit profiter des utilitaires déjà existants.

 
Rôle et fonction du Shell.
Le shell est l'interface entre l'utilisateur et le système
Le shell est un interpréteur de commandes qui est doté :
       - de son propre langage de programmation
       - de sa propre syntaxe.
Le langage du SHELL est interprété.
Il existe plusieurs shell : KORN SHELL, Bourne Shell, C-SHELL .
Le langage du shell
Le shell possède les mêmes caractéristiques que les langages de troisième génération interprétés :
       - une grammaire,
       - un vocabulaire (mots-clefs réservés),
       - des variables non typées définies (et redéfinies) dynamiquement,
       - des structures de contrôle,
       - des fonctions,
       - la possibilité d'intervenir dynamiquement sur l'interpréteur.
Suivant les options choisies par l'utilisateur le programme SHELL peut être entré de manière interactive par l'utilisateur ou en "batch", c'est à dire regroupées dans un fichier soumis à l'interpréteur.
La fin de la lecture d'une commande est provoquée par la rencontre de :
                        ;      le caractère point-virgule,
                        &    le caractère de lancement de commande à l’arrière plan,
                        \n    le saut de ligne (line feed, ASCII (10)).
La fin de lecture d'une ligne entraîne son analyse par l'interpréteur.

 
Les variables et l'environnement
Chaque processus est créé à partir d'un autre processus.
Le processus père donne naissance à un processus fils grâce à un mécanisme de duplication (fork).
Un mécanisme de recouvrement permet de substituer à l'image du père une nouvelle image mémoire (exec).
Un dispositif de synchronisation permet au processus père d'attendre la fin d'exécution de son fils (wait).
Exemple :
prenons le cas simple de la commande "ls" lancée à partir d'un terminal quelconque.
1)    Le shell est en attente d'une commande. C'est le père.
2)    L'utilisateur tape la commande 'ls'. Le shell crée un processus fils identique à lui-même (fork) et se met en attente de la fin d'exécution de son fils (wait).
3)    Un ‘exec’ remplace le shell par 'ls' dans la mémoire du fils et s'exécute.
Le langage SHELL manipule des variables dynamiquement. Il alloue ses variables au fur et à mesure des besoins du script qu'il interprète. Ces variables sont dites locales.
Le processus père ne transmet au processus fils que deux zones:
                   - la ligne de commande
                   - l'environnement
Les variables locales ne sont pas transmises.
Les variables exportées ne sont que des copies des variables locales.
Si une variable locale exportée est changée, elle doit être de nouveau exportée afin que l'environnement reflète le changement.
              $ TERM= ibm3151
              $ export TERM
              $ TERM= ibm3151
              $ export TERM

Le fils peut changer les variables mais ces changements n'affectent que son environnement et celui de ses prochains processus fils.
Les modifications apportées par le fils sur son propre environnement ne peuvent pas affecter celui du père.
Liste des variables pré-définies du Shell.
D'entrée, toute session shell dispose d'un environnement bien défini. Au niveau des variables, il existe des variables pré-définies du shell.

  VARIABLE              OBJET REPRESENTE


  $#                           Nombre d'arguments

  $*                           Tous les arguments

  $-                            Les options

  $?                           Valeur de retour de la dernière commande

  $$                           Numéro de processus du shell

  $!                            N° de processus de la dernière commande avec &

  $HOME                  Argument par défaut de la commande cd

  $PATH                   Liste des répertoires pour rechercher les
                                 commandes

  $PS1                       Caractère d'appel (prompt), par défaut $

  $PS2                       Caractère d'appel des lignes suivantes, par défaut >

Utilisation d'une variable d'environnement.
Pour assigner une valeur à une variable, on écrit simplement :
                                  variable=valeur
Attention :
Il ne doit pas y avoir d'espace de part et d'autre du signe "=".
Exemple :
                                  ux=s.unix
L'exemple précédent assigne à "ux" la valeur "s.unix" en utilisant le signe d'égalité.
La valeur d'une variable est obtenue en faisant précéder le nom de cette variable du caractère "$".
                                  # echo $ux
                                   s.unix
                                  #
La variable "$ux" peut être modifiée :
Exemple :
            # echo $ux
             s.unix
            #
            #ux=aix
            # echo $ux
             aix
            #
Exemple :
            # a=bonjour
            # b=ami
            # echo $a cher $b
            bonjour cher ami
            #

Dans l'exemple précédent deux variables "a" et "b" sont définies. La commande "echo" interprète ces deux variables et effectue le remplacement dans la chaîne de caractère.
Attention :
Une seule évaluation est effectuée, le shell n'examine pas ensuite la chaîne de remplacement pour effectuer d'autres remplacements. Par exemple:
            # y=ami
            # x=\$y
            # echo $x
            $y
            #
Chaque fois que l'on désire effectuer plusieurs niveaux d'évaluation, il faut utiliser la commande eval . Dans l'exemple précèdent :
            # eval echo $x
            ami
            #
icon phone
Téléphone/Whatsapp : +33 (0)6 83 84 85 74
icon phone