Exécution de commandes Unix

1 Exécution de commandes Unix

Un utilisateur travaille souvent avec les mêmes commandes et sur les mêmes fichiers. Il est donc agréable de pouvoir définir des abréviations pour ces commandes, de pouvoir relancer, éventuellement éditer une commande préalablement lancée. Ces possibilités sont offertes en C shell via les << alias >> et les << history >>. Nous présentons aussi dans cette section les mécanismes permettant l'exécution d'un fichier de commandes, les raccourcis que propose le C shell pour les accès aux fichiers, et les commandes de manipulation de jobs.

1.1 History

Le C shell enregistre chacune des commandes sous un numéro. Il est possible d'afficher ce numéro dans le prompt ; il sera ensuite facile de référencer les commandes par leur numéro :

      % set prompt = '\!% '

Le nouveau prompt est alors (un autre numéro peut apparaître)

2%

La commande

      2% set history = 13

indique au C shell d'enregistrer les commandes. Il alloue alors de la place pour 13 commandes ; les 13 dernières. Entrons les commandes suivantes (seul le résultat de la commande history est affiché) :

      3% ls -a
      4% date
      5% who 
      6% history 
          2  set history = 13 
          3  ls -a
          4  date
          5  who 
          6  history

Le C shell a mémorisé les commandes et leur numéro. Examinons quelques commandes d'history. La plupart d'entre-elles sont invoquées par le caractère ``!''. Par exemple, !! répète la dernière commande

      7%  !!
      history

Remarquons que le C shell affiche la commande avant de l'exécuter. Le !4 répète la commande numéro 4

      8%  !4
      date

Le !w répète la dernière commande commençant par ``w''

      9%  !w
      who

Le !-2 répète l'avant-dernière commande

      10%  !-2
      date

Il est aussi possible de construire une nouvelle commande à partir des précédentes. Par exemple, le !$ remplace la dernière composante de la commande précédente :

      11% ls /usr/include/stdio.h
      12% vi  !$ 
      vi /usr/include/stdio.h

Les autres composantes sont référencées par ``:<digit>'' ou ``:<digit>-<digit>''. Par exemple

      13% spell sujet1.txt sujet2.txt > sujets.erreurs
      14% vi  !!:1-2  
      vi sujet1.txt sujet2.txt

Pour corriger une erreur, il est possible d'utiliser le caractère caret ``^''. Par exemple, si nous tapons, par erreur

      15% ls /user/include
      /user/include not found

nous corrigeons le user en usr par

      16% ^er^r^
      ls /usr/include

Pour éditer une commande plus ancienne, on utilise le ``:s'', par exemple :

      17%  !13:s/spell/ispell/
      ispell sujet1.txt sujet2.txt > sujets.erreurs

Il est possible de visualiser le résultat d'une history sans exécuter la commande en la faisant suivre de ``:p''

      18%  !13:s/spell/ispell/:p
      ispell sujet1.txt sujet2.txt > sujets.erreurs

Si la modification nous satisfait, nous lançons effectivement la commande par ``!!''

      18%  !!
      ispell sujet1.txt sujet2.txt > sujets.erreurs

1.2 Alias

Un alias est une abréviation pour une commande ou une série de commandes fréquemment utilisée. Par exemple, pour abréger la commande history en h, nous utilisons

      % alias h history

De même, après la commande

      % alias ll ls -lag

l'alias ll peut être utilisé avec ou sans paramètre :

      % ll 
      % ll /usr/include

Un alias peut abréger plusieurs commandes et/ou alias

      % alias ah 'h | head -15'

liste les anciennes history. (Nous utilisons des quotes ``''' car la commande comporte un constructeur pipe ``|''.)

La définition d'un alias peut aussi utiliser les caractères ``!*'' pour référencer les paramètres de l'alias ; par exemple

      % alias cd 'cd \!* ; pwd'
      % cd /usr/include
      /usr/include
      % cd 
      /home/enseign/marquet

(Nous utilisons le caractère ``\verb'' devant le ``!'' pour éviter que ce dernier ne soit interprété par le mécanisme d'history.)

Appelée sans paramètre, la commande alias affiche tous les alias définis :

      % alias 
      ah   h | head -15
      cd   cd  !* ; pwd
      h    history
      ll   ls -lag

Utilisation des alias

Nous donnons ici quelques utilisations qui peuvent être faites des alias.

Abréger les commandes souvent utilisées
```
      % alias m more 
```
Attacher systématiquement une option à une commande. Par exemple, pour qui n'a jamais tapé
```
      % rm * .bak 
```
(arghh l'espace !) au lieu de
```
      % rm *.bak 
```
l'alias suivant évite les désagréments
```
      % alias rm 'rm -i' 
```
Créer un environnent particulier pour une commande. Par exemple, il est possible d'interdire aux autres utilisateurs d'écrire sur notre terminal (via les commandes write et talk par exemple) par la commande mesg. Pour éviter d'être perturbé lors de l'édition d'un fichier par vi, nous définissons un alias
```
      % alias vi '(mesg n ; /usr/ucb/vi \!* ; mesg y)' 
```
(Nous utilisons le chemin absolu de vi pour éviter une boucle d'alias.)
Changer l'environnement lors de chaque appel à une commande. Par exemple, pour mettre à jour le prompt avec le répertoire courant
```
      % alias cd 'cd \!* ; set prompt = "`pwd` %"'
      % cd /usr/include
      /usr/include %
```

1.3 Accès aux fichiers

Que faire sous Unix, si ce n'est manipuler des fichiers ! Quelques caractéristiques du C shell facilitent les références aux noms de fichiers.

Le tilde

Le caractère ``~'' référence notre home directorie ; la chaîne ``~user'' celle de l'utilisateur user. Par exemple,

      % diff ~/.login ~toto/.login

compare mon fichier .login et celui de l'utilisateur toto.

La variable `filec`

En positionnant la variable filec,

      % set filec

le C shell étend les noms de fichiers. Par exemple

      % ls 
      abraba       abracadabra  toto

à supposer que nous désirions afficher le contenu du fichier abracadabra ; nous tapons (sans retour chariot)

      % cat a

en appuyant sur la touche d'échappement ESC, le C shell étend le nom a en un nom de fichier possible

      % cat abra

en entrant ^D (control D), le C shell affiche les différentes possibilités d'extension du nom abra formant un nom de fichier valide :

      % cat abra^D
      abraba       abracadabra

pour étendre abra en abracadabra, nous tapons un c et un ESC supplémentaire :

      % cat abracadabra

1.4 Navigation dans les répertoires

Trois commandes du C shell permettent de naviguer dans les répertoires. Il est en effet courant de vouloir se déplacer momentanément dans une directorie pour ensuite revenir dans la directorie courante.

Pour cela le C shell gère une pile de répertoires.

On se déplace dans un répertoire par la commande pushd, par exemple :

      % cd 
      % pushd ~/tmp
      ~/tmp ~

qui affiche la pile des répertoires, le répertoire courant en tête.

La commande dirs affiche également cette pile de répertoires :

      % dirs 
      ~/tmp ~

On dépile un répertoire par la commande popd

      % popd 
      ~

qui affiche le nouvel état de la pile de répertoires.

1.5 Manipulation des jobs

Unix autorise un utilisateur à exécuter simultanément plusieurs processus (à la base un processus est un programme en cours d'exécution). Le C shell propose différentes constructions pour aider le contrôle de ces processus.

Job

Le C shell définit la notion de job. Un job correspond à une ligne de commande. Un job peut correspondre à un processus, par exemple

      % who

Il peut correspondre à plusieurs processus lancés en séquence

      % date ; who

ou correspondre à plusieurs processus dépendant les uns des autres

      % who | wc -l

Foreground

Les jobs peuvent être lancés en foreground (avant-plan). C'est le cas pour les exemples ci-dessus. Les entrées/sorties du job sont alors directement reliées au terminal. L'utilisateur attend la fin de son exécution avant d'avoir le prompt et de pouvoir lancer un nouveau job.

Background

Si l'exécution d'un job est longue (par exemple recompiler une application complète, chercher les erreurs orthographiques dans un gros document...), il est possible de l'exécuter en background (arrière-plan). Pour ce faire, on fait suivre le job du caractère ``&''

      % make all & 
      [1] 1651

Le C shell rend de suite la main, sans attendre la fin de l'exécution du job. Si le job doit produire des sorties, il est préférable de rediriger celles-ci dans un fichier ; par exemple

      % du -s /home/licence/* > du.out & 
      [2] 1659

Lorsque nous lançons un job en background, le C shell répond par un numéro identifiant le job (ici le [2]) et un numéro de processus (1659). (Le numéro de job est unique à un instant donné pour une exécution du C shell ; le numéro de processus est unique pour l'ensemble du système.)

Statut d'un job

Un job peut être actif ou suspendu. Dans ce dernier cas, il sera possible de l'activer à nouveau ; c'est-à-dire qu'il continuera son exécution à partir de l'état dans lequel il a été suspendu.

Gestion des jobs

Diverses commandes de gestion de jobs sont disponibles sous le C shell.

La commande jobs liste les jobs courants

      % jobs
      [1]  - Running      make all
      [2]  + Running      du -s /home/licence/* > du.out

Les autres commandes utilisent en paramètre un numéro de job ; ce numéro est construit sur les schémas suivants :

1659 numéro de processus Unix

%2 numéro de job

% le job courant (paramètre par défaut)

%du job de nom ``du*''

%?home job de nom ``*home*''

Les principales commandes sont

bg re-lance le job en background

fg re-lance le job en foreground

kill tue le job

stop suspend le job

De plus, lors de l'exécution d'un job en foreground, la commande ^Z (control Z) suspend le job. Par exemple, nous lançons l'édition d'un fichier avec vi

      % vi du.out

Sous l'éditeur, nous tapons ^Z, le C shell nous rend alors la main et affiche

      % vi du.out
      Stopped
      %

Le job vi du.out est suspendu :

      % jobs
      [1]  - Running      make all
      [2]  + Stopped      vi du.out

Il est ensuite possible de le relancer pour continuer l'édition :

      % fg %vi

1.6 Exécution d'un shell script

Comme nous l'avons déjà dit, un shell est un véritable langage de programmation et peut être utilisé pour écrire des scripts (un script est un programme écrit en shell). Cependant, il est habituel de choisir un autre shell que le C shell pour interpréter ces fichiers de commandes, typiquement le Bourne shell, sh.

Supposons que nous ayons un fichier monscript contenant des commandes Bourne shell. Il est possible d'exécuter ces commandes en invoquant directement le Bourne shell :

      % sh monscript

Il est aussi possible de d'indiquer que les scripts shells doivent être exécutés par le Bourne shell en positionnant la variable shell :

      % set shell = '/bin/sh'

Le mieux semble d'indiquer dans le fichier script lui-même qu'il doit être exécuté par le Bourne shell en mettant la ligne suivante en tête du fichier :

      #! /bin/sh