Les shells

Ce sont des programmes ayant plusieurs fonctions:

dialogue avec les utilisateurs : lancement des commandes, arrêt et redémarrage, gestion d'un historique, d'éditions de commandes, de synonymes, de fonctions.
programmation de séquence de commandes. On dispose de variables, de structures de contrôle, et de toutes les commandes standard Unix (expr, test, sort, grep, awk, sed, tr, diff, comm, cmp, wc, head, tail, cut, paste, ...)

Il y a 2 familles:

les shells de type Bourne (sh, zsh, bash)
et les shells de type C-shell (csh, lcsh, tcsh). La syntaxe de ces derniers est inspirée de la syntaxe du C.

Lancement

En interactif, le comportement est différent selon que c'est un shell de login (= de démarrage) ou non.

sh lit .profile quand il est shell de login, rien sinon
csh lit le fichier .cshrc puis, s'il est de login, le fichier .login. csh sait s'il est interactif ou non à la présence de variables $term et $prompt:
```
	if ( $?prompt != 0 && $?term != 0 ) then
		echo je suis interactif...
	endif
```

Appel

Ce peut être un appel:

à la main:

	$ sh mon/fichier.csh
	$ tcsh -x mon/fichier.tcsh

implicite:
- le texte est mis dans un fichier
- que l'on rend exécutable: chmod +x ...
- dont la première ligne référence le bon interpréteur:
```
		#!/bin/sh
		#!/usr/local/bin/bash
```
- et on appelle alors le fichier par son nom. La variable d'environnement PATH permet de le retrouver, si l'on n'a pas indiqué le chemin complet:
```
		~/bin/mon.fichier
		mon.fichier # sous-entendu via le PATH
```

Syntaxe

Le format n'est pas du tout libre, mais par ligne.
Les commentaires sont introduits par un '#'.
Les identificateurs sont une lettre, suivi de lettres ou chiffres. Il y a des mots réservés.

Caractères spéciaux

Règle : chaque ligne subit des substitutions puis est interprété conformément à la syntaxe du shell.

Classe 1

On se base ici sur la liste des noms de fichiers (résultat de la commande ls):

? : ce caractère peut remplacer un seul caractère. Exemples:
```
	echo a.?ex
	for i in a.???
```
* : toute suite de caractères ne commençant pas par un . (lire : un point). Exemple:
```
	echo *
	echo .*
	echo .??*
	echo *.*
	echo *.???
```
[a-z] ou [st] : un caractère de la liste. Exemple:
```
	echo *.[st]*
	grep mot *.[ch]
```

Classe 2 : le $

On se base ici sur des variables internes au shell, distinctes des variables d'environnement.

$var est remplacé, en termes de texte par la valeur de la variable var. On regarde dans les variables internes au shell puis dans les variables d'environnement.
(csh) $var[index] accède le i-ème élément du tableau.
$0, $1, etc. sont les paramètres d'appel du shell. shift permet de jeter le premier argument.
$? (sh) ou $status (csh) est le code de retour de la dernière commande exécutée.
$# est le nombre d'arguments.
$$ est le numéro de process du shell.
$! est le numéro de process de la dernière commande lancé en background.
(csh) $#var donne le nombre d'éléments de la variable qui est un tableau
(sh) read var lit une variable sur l'entrée standard.
(csh) $< est lue sur l'entrée standard.

Classe 3: les protections

': ce qui est entre apostrophes n'est pas interprété. Exemple: echo '*'

" : ce qui est entre guillemets est interprété mais reste un seul mot. Exemple:

	showargs "*"	# un seul argument : la liste des fichiers
	showargs *	# n arguments si n fichiers

` : ce qui est entre apostrophes inverses est remplacé par le résultat de la commande:
```
	echo `date`
	echo `ls`
	a=`wc -l fichier`
```

Les redirections

Pour un shell, tout process a

une entrée standard (stdin de numéro 0),
une sortie standard (stdout de numéro 1),
une sortie d'erreur (stderr de numéro 2).

Par défaut, l'entrée standard est le clavier, la sortie standard et la sortie d'erreur sont l'écran.
Mais on peut rediriger:

process < file: lance un process avec en entrée standard le contenu du fichier.
process > file : lance le process avec en sortie standard le fichier. Ce fichier est détruit au lancement.
process >> file : lance le process avec en sortie standard le fichier mais on concatène au fichier s'il existe déjà.
p1 | p2 : la sortie de p1 devient l'entrée de p2.
p1 <<MotADefinir : met sur l'entrée standard ce qui vient dans le shell jusqu'à la ligne MotADefinir.
```
	cat <<FinDuMessage
	Ceci est le message.
	La suite.
	FinDuMessage
	date	# commande executee
	
```

En sh:

process 2>file redirige la sortie d'erreur
process 2>&1 concatène la sortie d'erreur à la sortie standard. Exemple:
```
	commande >file 2>&1	# bon
	commande 2>&1 >file	# mauvais
		
```

En csh:

process >& file concatène les 2 sorties dans le fichier.
(process > out) >& err pour les séparer.

Constantes, types de données

Il n'y a pas de constante, tout en shell est chaîne de caractères.

(csh) Les tableaux

Indicé à partir de 1.
Exemples:

	foreach i (*)
	ls = (*)
	set compte = ( un deux trois )

Les affectations en sh

var = valeur Si on a des calculs à faire, on se sert du programme expr(1).
Si on a des tests à faire, on se sert du programme test(1) appelé aussi '['.
Exemple:

	i = `expr $i + $j`
	i = `expr $i '*' 2`
	if [ $a = test ]
	if test $a = test
	if [ -f .profile ]

Les affectations en csh

@ var = expression

	@i = $i + $j
	@i = $i * 2
	if ($a == test) ...
	if (-f .cshrc) ...

Les instructions en sh

les affectations
les groupements ( cmd1; cmd2 )

les tests

	if condition
	then
		....
	elsif condition
		....
	else
		:
	fi

les boucles
```
	while condition
	do
		....
	done
```

les cas

	case expression in
	v1|v2) ....;;
	v3) ....;;
	*)	....;;
	esac

la sortie exit N

Les instructions en csh

les affectations
les groupements ( cmd1; cmd2 )

les tests

	if (condition) commande
	if (condition) then
		....
	else if (condition) then
		...
	else
		...
	endif

les boucles
```
	while (condition)
		....
	end
```

les cas

	switch (string)
	case v1:
		....
		breaksw
	default:
		....
	endsw

la sortie exit N

Quelques programmes

iter exécuter toutes les ARG[1] secondes la commande "ARG[2] ARG[3]...". Un argument optionnel supprime l'affichage du temps écoulé.
getftp aller chercher le fichier ARG[2] sur le serveur ARG[1] par ftp anonyme. Vérifier si sa longueur est bien ARG[3].
NB: la commande ncftp de certains systèmes fait cela en bien mieux.
multi pour imprimer un fichier Postscript par pages de 2, 4, 8, etc. Il faut analyser des options et utiliser des fichiers temporaires.