Année 2001-2002









Pense-bête

Systèmes Informatiques

1ère année Matméca

Université de Bordeaux1



mis en page par Philippe Depouilly du MPB (http://www.math.u-bordeaux.fr/Math_Pures), d'après les documents électroniques de :

J.D. Durou et Ph. Joly de l'IRIT (http://www.irit.fr),

Philippe Dax de l'ENST (http://www-inf.enst.fr) et

Christian Labesse de l'A2X (http://www.math.u-bordeaux.fr/A2X)



Sommaire :

Les commandes UNIX : page 2

Emacs : page 38

Make et Makefile : page 43

Rappels des commandes UNIX

Introduction
Les métacaractères du shell
Les expressions régulières
Redirections de l'entrée standard et de la sortie standard
Redirections de la sortie standard des erreurs
Les "scripts"
Les paramètres positionnels
Les opérateurs && et ||
La structure de contrôle de condition
La structure de contrôle d'aiguillage à choix multiple
La structure de contrôle "boucle For"
La structure de contrôle "boucle While"
La structure de contrôle "boucle Until"
Les variables du shell
Lancement d'un "shell fils"
Les fonctions en shell
Les principales commandes sous UNIX


Introduction

Un "shell" est un interpréteur de commandes du système UNIX. Il existe plusieurs versions de cet interpréteur : le "shell de Bourne" (ou "Bourne shell"), le "Korn shell", le "C_shell",...
On se placera dans le cadre du shell de Bourne.
Le format d'une commande sous UNIX suit le modèle suivant :

nom_de_la_commande -options arguments

Les options et arguments forment ce que l'on appelle les "paramètres" de la commande.


Les métacaractères du shell

Les métacaractères du shell permettent :
 


Les expressions régulières

On appelle "expression régulière" une chaîne de caractères composée de caractères normaux et de caractères spéciaux, appelés "métacaractères des expressions régulières" (à ne pas confondre avec les métacaractères du shell décrits plus haut !). Comme toutes les chaînes de caractères, on peut écrire une expression régulière entre apostrophes, entre guillemets ou seule, mais on évitera cette dernière possibilité, et on conseille même d'utiliser la notation entre apostrophes. Les principaux métacaractères des expressions régulières sont les suivants :

Exemples :
 


Redirections de l'entrée standard et de la sortie standard

Il est possible, sous UNIX, de rediriger l'entrée standard ou la sortie standard d'une commande :

Remarque :

Une redirection en entrée est toujours suivie d'un nom de fichier, mais jamais du résultat d'une commande.


Redirections de la sortie standard des erreurs

Il est possible de rediriger la sortie standard des erreurs sur un fichier, de l'une des deux manières suivantes :

[commande] 2> [nom_fichier]

ou :

[commande] 2>> [nom_fichier]


Les "scripts"

Un "script" est un ensemble de commandes UNIX rassemblées dans un fichier. Pour lancer l'exécution d'un script contenu dans le fichier nom_script, on peut :

tgv% chmod u+x [nom_script]
tgv% [nom_script] [paramètres]
 



Les paramètres positionnels

$0, $1, $2, $3, $4, $5, $6, $7, $8 et $9 désignent les paramètres positionnels, à l'appel d'un script. $0 désigne le nom du script. On désigne également par $# le nombre total de paramètres positionnels ($0 non compris), et par $* la liste des paramètres positionnels. Enfin, $? contient le code de retour de la dernière commande exécutée.

Exemple :

On écrit, dans le fichier exemple.sh, les commandes suivantes :
 

exemple.sh


echo "exécution de la commande $0"
echo "contenu du fichier 1"
cat $1
echo "contenu du fichier 2"
cat $2
 

On rend ce script exécutable en tapant, dans le répertoire de travail :
 


tgv% chmod u+x exemple.sh
 

Puis on l'exécute, en tapant :
 


tgv% exemple.sh fich1 fich2
 


Les opérateurs && et ||

Syntaxe :
 


if condition1
then
liste_commandes_1
elif condition2
then
liste_commandes_2
else
liste_commandes_3
fi
 

Remarques :

Exemple :
 


if [ $# -eq 1 ]
then
echo "Le répertoire $1 a le contenu suivant : `ls $1`"
else
echo 'Mauvais nombre de paramètres'
fi
 

Ce "script" affiche le contenu du répertoire donné en paramètre. S'il n'y a pas exactement un paramètre, un message est affiché.

La structure de contrôle d'aiguillage à choix multiple

Cette structure de contrôle permet d'effectuer un branchement conditionnel sur une séquence de commandes, en fonction de la valeur d'une variable.

Syntaxe :
 


case variable in
cas1)
liste_commandes_1
;;
cas2)
liste_commandes_2
;;
cas3|cas4)
liste_commandes_3
;;
*)
liste_commandes_4
;;
esac
 

Dans ce modèle :

Exemple :
 


case $# in
0)
set variable=`pwd`
;;
1)
set variable=$1
;;
*)
echo "Erreur de syntaxe" ; exit
;;
esac
 

Dans ce "script", la variable variable reçoit comme valeur le répertoire courant (si le nombre de paramètres est nul) ou la valeur du paramètre positionnel $1 (s'il n'y a qu'un paramètre). S'il y a plus d'un paramètre, un message est affiché.



Remarque :

La commande break (équivalente à l'instruction break du langage C) existe, mais elle n'est pas nécessaire dans la structure de contrôle d'aiguillage à choix multiple, car le double point-virgule ;; est équivalent à cette commande.


La structure de contrôle "boucle For"

Cette structure de contrôle permet de lancer une séquence de commandes en boucle.

Syntaxe :
 


for variable in liste_de_cas
do
liste_commandes
done
 

Dans ce modèle, liste_de_cas est une liste de chaînes de caractères, utilisant éventuellement les métacaractères du shell.

Exemple :
 


for fichier in `ls *.c`
do
chmod go-r $fichier
done
 

Cette séquence change les droits d'accès de tous les fichiers du répertoire courant comprenant l'extension .c

Remarques :

- Dans les structures de contrôle de boucles, la commande break peut être utilisée.

- La syntaxe suivante :

for i
do
...

est équivalente à :

for i in $*
do
...

La structure de contrôle "boucle While"

Cette structure de contrôle permet d'exécuter une séquence de commandes en boucle tant qu'une condition est vérifiée.

Syntaxe :
 


while condition
do
liste_commandes
done
 


La structure de contrôle "boucle Until"

Cette structure de contrôle permet de boucler sur une séquence de commandes jusqu'à ce qu'une condition devienne vraie.

Syntaxe :
 


until condition
do
liste_commandes
done
 


Les variables du shell

Tout shell permet de gérer des variables non typées. Le nom d'une variable peut comporter des lettres, des chiffres et le caractère _ et le premier caractère ne peut pas être un chiffre.
Avec le shell de Bourne, l'initialisation d'une variable s'effectue à l'aide de la commande d'affectation, pour laquelle l'opérateur = est utilisé, comme en langage C :

x=7

Attention : il ne doit pas y avoir d'espace ni avant ni après l'opérateur =
Une variable peut recevoir comme valeur :

En fait, la seule "combinaison" que l'on peut faire directement est la concaténation de plusieurs valeurs. Toute autre opération doit être faite à l'aide de la commande expr, qui sera vue plus loin.
Pour faire référence à la valeur d'une variable du shell, il faut faire précéder son nom du métacaractère $

Remarques :

- Il existe, dans tout shell, un certain nombre de variables prédéfinies. Dans un shell de Bourne, sur tgv, il y en a 22, dont les noms ne comportent que des lettres majuscules, des chiffres et le caractère _

- Il ne faut pas confondre les variables d'un shell avec ses paramètres positionnels. Pour modifier la valeur d'un paramètre positionnel, il faut utiliser la commande set.

Exemple :

x=7
y=`pwd`
x=$y$x
echo $x

Si le répertoire de travail est /home/mod4g0 alors la commande echo produira l'affichage suivant :

/home/mod4g07


Lancement d'un "shell fils"

Une séquence de commandes placée entre parenthèses est exécutée par un "sous-shell" ou "shell fils". Tout déplacement dans l'arborescence des répertoires et toute modification de la valeur d'une variable dans un shell fils ne sont plus effectifs dès le retour dans le shell père.

Exemple :


$ cd
$ pwd
/home/mod4g0
$ a=1
$ (cd /usr/include; a=2; echo $a; pwd)
2
/usr/include
$ pwd
/home/mod4g0
$ echo $a
1
 

Remarques :

- L'entrée et la sortie standard d'un shell fils peuvent être redirigées au moment de l'appel. Ceci redirige alors implicitement toutes les entrées et sorties standard des commandes appelées dans le shell fils.
- Une variable x du shell père ne sera connue dans un shell fils qu'après lancement de la commande export x, mais les modifications de la valeur de x effectuées dans le shell fils ne seront pas répercutées dans le shell père.


Les fonctions en shell

En shell, on appelle "fonction" une séquence de commandes repérable par un nom qui est le nom de la fonction. Les commandes constituant une fonction sont exécutées dans le cadre du shell courant, et non dans le cadre d'un shell fils, comme c'est le cas pour un script ou pour une séquence de commandes placées entre parenthèses.

Syntaxe de la déclaration d'une fonction :

nom()
{
commandes
}

Une fonction doit être déclarée avant d'être appelée. Pour appeler une fonction, il suffit d'utiliser son nom, sans les parenthèses. Comme pour un script shell, l'appel d'une fonction peut être éventuellement suivi d'une liste d'arguments, accessibles dans la fonction à l'aide des paramètres positionnels $1, $2, ..., $9 (les paramètres $# et $* sont également initialisés).

Une fonction se termine soit après exécution de la dernière commande située avant l'accolade fermante, auquel cas le code de retour est celui de cette dernière commande, soit après exécution d'une commande return [n], auquel cas le code de retour est l'argument n de la commande return (ou 0 si cet argument est absent). Dans les deux cas, le code de retour de la fonction est affecté au paramètre $? du shell courant.

Attention : la commande return ne peut être utilisée qu'à l'intérieur d'une fonction (remarquer l'analogie avec la fonction return du langage C).


Les principales commandes sous UNIX

cat

grep

rm

cd

head

rmdir

chmod

kill

set

cmp

ls

sh

cp

mail

shift

cut

man

sort

date

mkdir

tail

echo

more

tee

eval

mv

test

exit

ps

tr

expr

pwd

wc

file

read



La commande cat

Elle permet d'afficher le contenu de l'entrée standard (ou, s'il y a lieu, le contenu du ou des fichiers donnés en arguments, en les concaténant) sur la sortie standard.

Syntaxe :

cat [-nbsuvet] [nom_fichier ...]

Options :

Exemple :

cat fich1 fich2 > fich3

Cette commande recopie fich1 puis, à la suite, fich2, le tout dans fich3

Codes d'erreur retournés :

La commande cd

Elle permet de changer de répertoire, de manière relative ou absolue.

Syntaxe :

cd [nom_répertoire]

Lorsque la commande est tapée sans argument, on se positionne dans le répertoire principal ("home directory").

Options :

néant.

Exemple :

cd ../../TD

Codes d'erreur retournés :

La commande chmod

Elle permet de modifier les droits d'accès à un ou à plusieurs fichiers ou répertoires dont on est le propriétaire.

Syntaxe :

chmod [-fR] [type_utilisateur...]+|-r|w|x nom_de_fichier [...]
 

Options :

cf. la description de la commande chmod, en tapant : man chmod

Exemple :

chmod g+rx /home/mod4g0/TD/td12ex*

Codes d'erreur retournés :

La commande cmp

Elle effectue la comparaison des contenus de deux fichiers. Appelée sans option, elle renvoie le numéro du premier octet qui diffère. Elle ne retourne rien si les deux fichiers sont identiques.

Syntaxe :

cmp [-l] [-s] nom_fichier1 nom_fichier2 [skip1] [skip2]

Options :

Exemple :

cmp `ls|head -1` `ls|tail -1`

Codes d'erreur retournés :

Remarques :

- Si nom_fichier1 vaut -, alors la comparaison est effectuée sur l'entrée standard.
- Les arguments optionnels skip1 et skip2 permettent de comparer le contenu du premier fichier, à partir de l'octet numéro skip1, au contenu du deuxième fichier, à partir de l'octet numéro skip2.

La commande cp

Elle permet de copier un ou plusieurs fichiers, en changeant éventuellement leurs noms.

Syntaxe :

cp [-fip] nom_fichier nom_copie_fichier

Si on désire copier plusieurs fichiers en une seule commande, on peut utiliser les métacaractères du shell, comme dans l'exemple ci-après, mais on ne peut pas écrire une liste de fichiers.

Options :

cf. la description de la commande cp, en tapant : man cp

Exemple :

cp PREPA/TD/td12ex* TD

Cette commande copie tous les fichiers du répertoire PREPA/TD, de nom commençant par td12ex, dans le répertoire TD, sans changer leurs noms.

Codes d'erreur retournés :

La commande cut

Elle permet de supprimer une partie des lignes d'un ou de plusieurs fichiers, ou de l'entrée standard.

Syntaxe :

cut -bliste [-n] [nom_fichier ...]

ou :

cut -cliste [nom_fichier ...]

ou :

cut -fliste [-ddélimiteur] [-s] [nom_fichier ...]

Options :

Exemple :

ls | cut -f1-2 -s -d'.'

Cette commande affiche la liste des noms de fichiers ou de sous-répertoires du répertoire courant comprenant une extension.

Codes d'erreur retournés :

Remarque :

Les options -bliste, -cliste, -fliste et -ddélimiteur peuvent être écrites avec un espace situé juste avant la liste ou le délimiteur.

La commande date

Elle affiche la date.

Syntaxe :

date [-u] [+format]

Options :

cf. la description de la commande date, en tapant : man date

Exemple :

date

affiche la date sous la forme :

Mon Dec 8 21:05:47 MET 1997

Codes d'erreur retournés :

La commande echo

Elle permet d'afficher une ou plusieurs chaînes de caractères à l'écran. Cette commande est interprétée de manière sensiblement différente d'un shell à un autre.

Syntaxe :

echo [chaîne ...]

Options :

néant.

Exemple :

echo "répertoire courant : `ls`"

Cette commande affiche le message répertoire courant : , suivi de la liste des fichiers et sous-répertoires contenus dans le répertoire courant.

Codes d'erreur retournés :

Remarque :

La commande echo reconnaît également certains caractères spéciaux commençant par \ et appelés "caractères de contrôle", qui peuvent être écrits de deux manières différentes :

La commande eval

Elle procède en deux temps :

Syntaxe :

eval [argument1 ...]

Options :

néant.

Exemple :

a=1
c=a
a1=3
eval b=\$$c$a
echo $b

Cette séquence affichera la valeur 3, car la première évaluation de la commande eval produit la commande suivante :

b=$a1

Codes d'erreur retournés :

La commande exit

Elle permet de sortir du shell courant, en précisant éventuellement la valeur du code de retour.

Syntaxe :

exit [code_retour]

Options :

néant.





Exemple :

Si la commande :

exit

est tapée dans la fenêtre "racine", cela provoque une déconnexion.

Codes d'erreur retournés :

La commande expr

Elle permet d'effectuer des opérations arithmétiques et logiques, ainsi que des manipulations de chaînes de caractères, et renvoie le résultat sur la sortie standard.

Syntaxe :

expr argument1 opérateur1 argument2 [opérateur2 argument3 ...]

où les arguments argument1, argument2, argument3,... peuvent être des chaînes de caractères, des entiers, des résultats de commandes, des valeurs de paramètres positionnels, des valeurs de variables ou toute combinaison des cas précédents, et où l'opérateur appartient à la liste non exhaustive suivante :

Options : néant.

Exemple 1 :

a=2
b=3
a=`expr $b % $a`
echo $a

produira l'affichage de la valeur 1

Exemple 2 :

chaine="caracteres"
sschaine=`expr $chaine : '\(.*\)t'`
echo $sschaine

produira l'affichage suivant :

carac

On aurait pu écrire l'expression régulière sous d'autres formes :

'\(.*\)t.*'
'\(.*\)teres'
...

Codes d'erreur retournés :

Remarque :

Dans le cas où la commande expr est lancée avec plusieurs opérateurs, il faut être vigilant, car l'ordre des opérations ne se fait ni de gauche à droite, ni de droite à gauche, mais suivant un ordre prédéfini de priorité des opérateurs.

La commande file

Elle permet de déterminer le type d'un ou de plusieurs fichiers, ce type appartenant à la liste non exhaustive suivante :
 

Syntaxe :

file [-h] [-m types_fichiers] [-f fichier_liste] nom_fichier [...]

Options : cf. la description de la commande file, en tapant : man file

Exemple :

Si le fichier exo1.c contient un programme C, la commande :

file exo1.c

produira l'affichage suivant :

xo1.c: ascii text

Codes d'erreur retournés :

La commande grep

Elle permet de rechercher une expression régulière dans un ou plusieurs fichiers donnés en arguments.

Syntaxe :

grep [-bchilnsvw] expression_régulière [nom_fichier ...]

Options :

Exemple :

grep 'grep' *

Cette commande affiche toutes les lignes de tous les fichiers du répertoire de travail qui contiennent une occurence de la chaîne de caractères grep

Codes d'erreur retournés :

La commande head

Elle copie l'entrée standard, ou le ou les fichiers donnés en arguments, sur la sortie standard, jusqu'à une position désignée.

Syntaxe :

head [-position|-nposition] [nom_fichier ...]

Options :

Exemple :

head -5 fichier.c

Cette commande renvoie les 5 premières lignes du fichier fichier.c

Codes d'erreur retournés :

La commande kill

Elle permet d'envoyer un signal à un ou à plusieurs processus dont on connaît les identificateurs.

Syntaxe :

kill [-signal] identificateur_processus [...]

ou :

kill -l

Options :

Exemple :

kill -9 1345

Cette commande envoie le signal 9 au processus d'identificateur 1345
Le signal 9, qui permet de "tuer" un processus, est le plus souvent utilisé. Le signal envoyé par défaut est 15



Codes d'erreur retournés :

La commande ls

Cette commande permet d'afficher le contenu d'un ou de plusieurs répertoires, ou des renseignements concernant un ou plusieurs fichiers.

Syntaxe :

ls [-RadLCxmlnogrtucpFbqisf1AM] [nom_répertoire ...]
ou :
ls [-RadLCxmlnogrtucpFbqisf1AM] [nom_fichier ...]

Cas particulier :

Options :

Exemple 1 :

tgv% ls -l

Exemple 2 :

ls `ls`

Cette commande affiche la liste des fichiers du répertoire courant, puis la liste des contenus des sous-répertoires du répertoire courant.

Codes d'erreur retournés :

La commande mail

Elle permet d'envoyer ou de lire un courrier électronique.

Syntaxe :

Envoi d'un courrier : mail [-tw] [-mtype_du_message] adresse_destinataire [...]
Lecture du courrier : mail [-ehpPqr] [-ffichier]

Options :

cf. la description de la commande mail, en tapant : man mail

Exemple :

mail mod4g0@mdi.edu.ups-tlse.fr < message

Cette commande envoie le texte contenu dans le fichier message à l'adresse du destinataire.

Codes d'erreur retournés :

La commande man

Elle permet d'obtenir la description d'une commande à l'écran.

Syntaxe :

man [-] [-adFlrt] [-Marborescence] [-Tmacro-package] [-ssection] nom_commande [...]

Options :

cf. la description de la commande man, en tapant : man man

Exemple :

man ls

Codes d'erreur retournés :

La commande mkdir

Elle permet de créer un ou plusieurs répertoires, dont les noms sont précisés en arguments. Elle renvoie un message d'erreur dans les cas où la création est impossible.

Syntaxe :

mkdir [-mmode] [-p] nom_répertoire [...]

Options :

Exemple 1 :

Supposons que l'on veuille créer le répertoire rep1 et son sous-répertoire ssrep1, dans le répertoire rep du répertoire courant. Il faut taper la commande :

mkdir -p rep/rep1/ssrep1Exemple 2 :

Supposons que l'on veuille créer le répertoire rep2 dans le répertoire courant, en enlevant les droits en lecture et en écriture à toute personne non propriétaire du compte. Il faut taper la commande :

mkdir -mog-rw rep2Codes d'erreur retournés :

La commande more

Elle permet de faire afficher le contenu d'un ou de plusieurs fichiers page par page. Elle est une version plus interactive de la commande cat :
 

Syntaxe :

more [-cdflrsuw] [-lignes] [+numéro_ligne] [+/modèle] [nom_fichier ...]

Options :

cf. la description de la commande more, en tapant : man more

Exemple :

more temp

Codes d'erreur retournés :

cf. la description de la commande more, en tapant : man more
 

La commande mv

Elle permet de renommer un fichiers ou un répertoire, ou de déplacer un ou plusieurs fichiers dans l'arborescence, en changeant éventuellement leurs noms.

Syntaxe :

mv [-fi] ancien_nom nouveau_nom

ou :

mv [-fi] nom_fichier ... nom_répertoire

Options :

cf. la description de la commande mv, en tapant : man mv

Exemple 1 :

mv charabia.c ex1.c

Exemple 2 :

mv TD/td12ex* TD/td13ex* PREPA

Codes d'erreur retournés :

La commande ps

Elle permet d'afficher la liste des processus en cours d'activité. Lancée sans option, elle n'affiche que les processus actifs de l'utilisateur associés au terminal utilisé.

Syntaxe :

ps [-aAcdefjl] [-g nom] [-n nom] [[-o format] ...] [-p nom] [-s nom] [-t terminaux] [-u utilisateurs] [-U nom] [-G nom]

Les processus sont affichés suivant un format variable, mais le format par défaut comprend les quatre champs suivants sur une même ligne :

Options :

Exemple :

ps -e | grep asedit | wc -l

Cette commande retourne le nombre de processus en cours d'exécution associés à l'éditeur asedit

Codes d'erreur retournés :

La commande pwd

Elle affiche le nom absolu du répertoire de travail (appelé aussi "répertoire courant").

Syntaxe :

pwd

Options :

néant.

Exemple :

tgv% pwd
/home/mod4g0/TD

Codes d'erreur retournés :

La commande read

Cette commande permet d'affecter des valeurs à des variables à partir de l'entrée standard.
Syntaxe :

read [-r] nom_variable [...]

Options :

-r : le caractère \ est considéré comme un caractère ordinaire.



Exemple :

read a b
echo $a
echo $b

Si la ligne suivante est tapée au clavier :

c'est un exemple

alors les commandes echo produiront les affichages suivants :

c'est
un exemple

ce qui signifie que, si le nombre de mots (séparés par des espaces ou des tabulations) est supérieur au nombre d'arguments de la commande read, alors la variable correspondant au dernier argument reçoit toute la fin de la ligne.

Codes d'erreur retournés :

La commande rm

Elle permet d'effacer un ou plusieurs fichiers passés en arguments.

Syntaxe :

rm [-f] [-i] nom_fichier [...]

Options :

Exemple :

rm *

Cet exemple doit être évité en général !

Codes d'erreur retournés :

La commande rmdir

Elle permet d'effacer un ou plusieurs répertoires passés en arguments. Ces répertoires doivent être vides.

Syntaxe :

rmdir [-ps] nom_répertoire ...

Options :

cf. la description de la commande rmdir, en tapant : man rmdir

Exemple :

rmdir ..

Cette commande provoque systématiquement une erreur, car le répertoire père du répertoire de travail ne peut pas être vide !

Codes d'erreur retournés :

La commande set

Cette commande permet d'affecter des valeurs aux paramètres positionnels $1, $2, $3, ..., $9. Appelée sans paramètres, elle permet aussi d'afficher les valeurs de toutes les variables du shell courant :

Cette commande est très différente entre shell de Bourne, Korn shell et C_shell. On rappelle que c'est le shell de Bourne qui est présenté ici.

Syntaxe :

set [-aefhkntuvx] [valeur1] [...]

Options :

cf. la description de la commande set, en tapant : man set

Exemple 1 :

set alpha beta

Cette commande affecte la valeur alpha au paramètre positionnel $1, et la valeur beta au paramètre positionnel $2

Exemple 2 :

x=1
set

produira l'affichage suivant :

DISPLAY=141.115.12.137:0
GUIDEHOME=/usr/openwin/devguide
HOME=/home/mod4g0
...
x=1

Codes d'erreur retournés :

cf. la description de la commande set, en tapant : man set
 

La commande sh

Cette commande permet de lancer un shell fils de type shell de Bourne. Elle permet aussi d'exécuter un script shell dans le cadre de ce shell fils.

Syntaxe 1 :

sh [-acefhiknprstuvx]

Le shell fils qui est lancé lit et interprète les commandes tapées sur l'entrée standard. Pour retourner au shell père, il faut taper la commande exit

Syntaxe 2 :

sh [-acefhiknprstuvx] [nom_script ...]

Les arguments sont des noms de scripts shell.

Options :

cf. la description de la commande sh, en tapant : man sh

Exemple 1 :

tgv% sh
$ pwd
/home/mod4g0
$ exit
tgv%

Exemple 2 :

sh exo1.sh

Cette commande lance le script shell contenu dans le fichier exo1.sh
Une façon équivalente de lancer ce script est de le rendre exécutable, en tapant la commande :

chmod u+x exo1.sh

puis en tapant :

exo1.sh

Codes d'erreur retournés :

Le code d'erreur retourné par la commande sh est le code d'erreur retourné par la dernière commande exécutée dans le cadre du shell fils. Dans le cas où un script shell est lancé, si une commande retourne un code d'erreur non nul, alors l'exécution du script est interrompue.

La commande shift

Elle permet de décaler les arguments passés à l'appel d'un script d'un rang ou de n rangs vers la droite.

Syntaxe :

shift [n]

Options :

néant.

Exemple :

Soit le script :
 

deca.sh


echo "\nAvant décalage : $1 $2 $3 $4 $5 $6 $7 $8 $9"
shift
echo "Après décalage : $1 $2 $3 $4 $5 $6 $7 $8 $9\n"
 

Voici deux exemples d'exécution de ce script, avec des nombres d'arguments différents :
 


$ deca.sh 10 9 8 7 6 5 4 3 2 1

Avant décalage : 10 9 8 7 6 5 4 3 2
Après décalage : 9 8 7 6 5 4 3 2 1

$ deca.sh 5 4 3 2 1

Avant décalage : 5 4 3 2 1
Après décalage : 4 3 2 1
 

Donc $1 reçoit la valeur de $2, $2 reçoit la valeur de $3, etc...



Codes d'erreur retournés :

Remarques :

- Lors de l'appel de la commande shift, l'absence d'argument n équivaut à une valeur de cet argument égale à 1.
- La valeur de $# est mise à jour par la commande shift.

La commande sort

Elle lit un ou plusieurs fichiers ou l'entrée standard, et affiche les différentes lignes, triées sur un ou plusieurs champs (par défaut, sur un seul champ qui est la ligne), selon l'ordre lexicographique (les séparateurs de deux champs sont par défaut l'espace et la tabulation).

Syntaxe :

sort [-cmu] [-o sortie] [-T répertoire] [-y[mémoire]] [-dfiMnr] [-b] [-t caractère] [-k clé] [+pos1 [-pos2]] [nom_fichier ...]

Options :



Exemple :

Si le fichier liste_noms contient une liste de noms-prénoms structurés de la manière suivante :

Alain VERSE
Jean REVE
...

alors la commande :

sort +1 liste_noms

affichera ce fichier, trié par ordre alphabétique des noms de famille.



Codes d'erreur retournés :

La commande tail

Elle copie l'entrée standard, ou le fichier donné en argument, sur la sortie standard, à partir de la position désignée.

Syntaxe :

tail [+/-position[lbcr]] [nom_fichier]

Options :

Exemple :

tail -15c fichier.c

Cette commande renvoie les 15 derniers caractères du fichier fichier.c

Codes d'erreur retournés :

La commande tee

Elle permet d'afficher l'entrée standard simultanément sur la sortie standard et sur le ou les fichiers passés en arguments.

Syntaxe :

tee [-ai] [nom_fichier ...]

Options :
 



Exemple :

ls | tee liste_fichiers

Cette commande affiche, d'une part, le contenu du répertoire courant à l'écran et écrit, d'autre part, ce contenu dans le fichier liste_fichiers

Codes d'erreur retournés :

La commande test

Elle permet d'effectuer des tests de comparaison, en renvoyant la valeur 0 lorsque la comparaison est vraie, et une autre valeur sinon. Cette commande est surtout utile en complément aux structures de contrôle, comme la structure de contrôle de condition qui sera vue dans le paragraphe suivant.

Syntaxe 1 :

test comparaison

ou :

[ comparaison ](bien respecter les espaces dans ce cas !)

La comparaison comparaison peut être la combinaison booléenne de plusieurs comparaisons élémentaires :

Des parenthèses précédées de caractères \ (les parenthèses étant des métacaractères du shell) peuvent être nécessaires en cas combinaisons un peu plus compliquées, pour préciser les priorités, comme dans l'exemple suivant :

! \( comparaison1 -o comparaison2 \)

Chaque comparaison élémentaire doit être écrite avec la syntaxe suivante :

v1 comparateur v2

où v1 et v2 sont des expressions du shell courant.

Le comparateur comparateur ne s'écrit pas comme en C. Si v1 et v2 sont entières :
 

Si v1 et v2 sont des chaînes de caractères :
 

Remarque :

Pour tester si la variable chaine a comme valeur la chaîne vide, on ne peut pas écrire test $chaine = "" car, si cette chaîne est vraiment vide, après évaluation des métacaractères, cette commande sera évaluée sous la forme test = "", qui est incorrecte. Cela justifie l'introduction de la deuxième syntaxe suivante pour la commande test :

Syntaxe 2 :

test chaine

Dans cette écriture, la commande test teste si chaine est une chaîne vide. Il existe une troisième syntaxe pour la commande test :

Syntaxe 3 :

test -fdrwx nom ...

Options :
 

Exemple 1 :

test $1 -gt 0 -a $# -eq 2

Exemple 2 :

test $chaine

Exemple 3 :

test -d /home/mod4g0/TD



Codes d'erreur retournés :

La commande tr

Elle permet le "transcodage" de caractères entre l'entrée standard et la sortie standard. Cette commande fonctionne aussi avec les caractères de contrôle déjà signalés plus haut.

Syntaxe :

tr -ds chaine

ou :

tr [-c] chaine1 chaine2

Options :

Exemple 1 :

tr 'abc' 'ABC'

Cette commande attend l'entrée de données au clavier. Si on tape :

calebasse

chaque occurence d'un a est remplacé par un A, chaque occurence d'un b est remplacé par un B et chaque occurence d'un c est remplacé par un C, ce qui donne dans le cas présent :

CAleBAsse

Exemple 2 :

tr '\012' ' '

Cette commande va substituer chaque saut de ligne par un espace.

Codes d'erreur retournés :

La commande wc

Cette commande (abréviation de "word count") permet de compter le nombre de lignes, de mots ou de lettres dans le ou les fichiers passés en arguments ou, à défaut, sur l'entrée standard.

Syntaxe :

wc [-c|-m|-C] [-lw] [nom_fichier ...]

Options :

Exemple :

wc -l exam

Cette commande affiche le nombre de lignes du fichier exam

Codes d'erreur retournés :


Ces pages ont été réalisées par J.D. Durou et Ph. Joly. Pour tout commentaire, envoyer un mail à durou@irit.fr ou à joly@irit.fr
 

Commandes de base de l'éditeur Emacs


Lancement


emacs

emacs &

emacs toto.c

emacs toto.c &


Le caractère & qui est à la fin de la commande sert à la lancer en "arrière-plan", ce qui libère le terminal pendant l'édition et permet d'entrer d'autres commandes, pour la compilation, par exemple.


Utilisation "à la souris"


Lorsqu'il est lancé dans l'environnement X-Window, Emacs permet de réaliser toutes les fonctions d'édition de base "à la souris", notamment :



En particulier, dans le menu Files, on trouve Save Buffer et Exit Emacs. Dans la terminologie d'Emacs, le buffer est la zone de mémoire qui contient la version du texte en cours d'édition et Save Buffer permet de la sauver dans un fichier.


Les commandes Emacs


Dans le menu Files, par exemple, à côté de Save Buffer on voit C-x C-s entre parenthèses. Sous ce raccourci clavier se cache une vraie fonction Lisp « Save Buffer » interne à Emacs.


C-x C-s représente la séquence de touches « Control x Control s », i.e. la touche Ctrl étant enfoncée, on appuie successivement sur les touches x puis s.


De manière similaire, on retiendra que C-x C-c permet de quitter Emacs.


Il y a aussi des commandes Meta, par exemple M-v qui remonte d'une page. Une commande Meta s'obtient avec la touche Alt qui s'utilise comme Ctrl.

Si le clavier ne comporte pas de touche Meta, on peut utiliser la touche Escape, par exemple, M-v s'obtient aussi par la séquence de touches "Escape v", i.e. on appuie successivement sur les touches Esc puis v.


Emacs ayant été conçu initialement pour une utilisation tout au clavier, on peut accéder à toutes ses fonctions internes en tapant le nom de la fonction dans le buffer créé par le raccourci M-x .


exemple : M-x suivi de « insert-file » a le même effet que le raccourci clavier C-x i .


Il existe un mécanisme d'historique des commandes, accessible par les flèches haut et bas.


Certains raccourcis sont très intéressants à connaître parce qu'ils se retrouvent dans d'autres applications, avec le même effet.

Voici quelques commandes de base d'Emacs qui sont également reconnues par l'interpréteur de commandes tcsh et par les boîtes de saisie de l'interface X-Window :


Commande Action Fonction Lisp associée


C-b Recule le curseur d'un caractère backward-char

C-f Avance le curseur d'un caractère forward-char

C-a Envoie le curseur en début de ligne beginning-of-line

C-e Envoie le curseur en fin de ligne end-of-line

C-p Remonte le curseur d'une ligne previous-line

C-n Descend le curseur d'une ligne next-line

C-d Efface le caractère situé sous le curseur delete-char

C-k Détruit le reste de la ligne kill-line



Autres commandes, plus spécifiques à Emacs :


Annulation-Répétition d'une commande :


C-_ Défait la dernière commande (réitérable) undo

C-x u Idem

C-g Interrompt la frappe d'une commande keyboard-quit

C-x Esc Répète la dernière commande repeat-complex-command


Déplacement du curseur :


M-b Recule d'un mot backward-word

M-f Avance d'un mot forward-word

C-v Écran suivant scrool-up

M-v Écran précédent scrool-down

M-< Curseur au début du buffer beginning-of-buffer

M-> Curseur en fin de buffer end-of-buffer


M-x goto-line n Curseur à la ligne n

M-x what-page Affiche la position courante du curseur


Sélection d'une zone de texte :


La sélection courante (région) est la partie du texte comprise entre le dernier marquage (obtenu par C-Space) et la position actuelle du curseur. On peut connaître la position actuelle du marqueur en utilisant la commande C-x C-x expliquée ci-dessous.


C-x C-x Échange les positions respectives du marqueur et du curseur

C-Space Positionne le marqueur là où se trouve le curseur (Space = barre d'espacement)

C-@ Idem.

M-h Sélectionne le paragraphe contenant le curseur

C-x h Sélectionne tout le texte mark-whole-buffer


Remarque : cliquer sur le bouton gauche de la souris est une autre façon de réaliser un marquage.


Couper, copier, coller :


Après avoir sélectionné une zone de texte (voir paragraphe précédent) on applique les commandes :


C-w Coupe la région sélectionnée kill-region

M-w Copie la région sélectionnée copy-region-as-kill

C-y Colle le dernier bloc coupé ou copié yank


Recherche-remplacement :


C-s Recherche la première occurrence d'une chaîne de caractères,

de la position du curseur jusqu'à la fin du texte (isearch-forward).

C-r Recherche la première occurrence d'une chaîne de caractères,

de la position du curseur jusqu'au début du texte (isearch-backward).


En retapant C-s ou C-r on poursuit la recherche; en tapant RET on arrête la recherche.


M-x replace-string RET ancienne chaîne RET nouvelle chaîne RET

Remplace toutes les occurrences de l'ancienne chaîne par la nouvelle chaîne,

de la position du curseur jusqu'à la fin du texte.

M-% Remplace sur demande la chaîne spécifiée (replace-query)


Remarque : pour insérer un caractère de contrôle, comme un saut de ligne (^J) dans une chaîne de caractères, il faut le faire précéder de C-q (quoted-insert).


Utilisation des fenêtres :


C-x 2 Donne deux fenêtres dans le sens de la hauteur split-window-vertically

C-x 5 Donne deux fenêtres dans le sens de la largeur split-window-horizontally

C-x 0 Supprime la fenêtre courante delete-window

C-x 1 Supprime toutes les fenêtres sauf la fenêtre courante delete-other-windows

C-x o Change la fenêtre courante other-window


Fichiers et buffers :


C-x C-f Charge un fichier dans la fenêtre active find-file

avec création d'un nouveau buffer

C-x 4 f Comme C-x C-f avec création d'une nouvelle fenêtre find-file-other-window

C-x C-v Remplace le fichier du buffer courant find-alternate-file

C-x C-s Enregistre le buffer courant save-buffer

C-x C-w Enregistre le buffer courant sous un autre nom write-file

C-x C-u Liste les buffers list-buffers

* pour tuer un buffer : mettre un "d" en face du nom

et valider la sélection en tapant "x".

* pour activer un buffer: mettre un "f" en face du nom.

C-x k Tue le buffer spécifié kill-buffer

C-x d Liste le contenu d'un répertoire dans la fenêtre active dired

C-x 4 d Comme C-x d avec création d'une nouvelle fenêtre dired-other-window


M-x revert-buffer Revient à la dernière version enregistrée.

M-x c-mode Pour choisir le mode d'édition en C (idem pour tex-mode, ....)



Trouver de l'aide :


C-h a chaîne Affiche les commandes dont le nom contient la chaîne command-apropos

C-h b Affiche une table des commandes describe-bindings

C-h f fonction Affiche des renseignements sur la fonction describe-function

C-h k clé Affiche des renseignements sur la commande associée à la clé describe-key




Merci de signaler d'éventuelles erreurs à Christian.Labesse@math.u-bordeaux.fr


Emacs et langage C


Éditer : le mode C


Le mode C d'Emacs offre des facilités pour écrire les programmes. Ce mode est activé automatiquement quand on édite un fichier dont le nom se termine par .c ou .h .


TAB Aligne correctement le texte de la ligne courante c-indent-command

C-M-q Au début d'un groupe () ou {}, aligne correctement c-indent-exp

le texte à l'intérieur du groupe


M-x c-indent-line-or-region Aligne correctement le texte dans la zone sélectionnée



Compiler : le compilateur gcc


M-x compile Lance une compilation dans le répertoire courant ; par défaut la commande

make est appelée, mais on peut indiquer une autre commande


C-x ` Après une commande M-x compile, positionne le curseur sur la première

erreur de compilation. Renouvelable.


M-x recompile Relance la dernière commande de compilation




Déboguer : le débogueur gdb


En lançant le débogueur sous Emacs, on peut suivre automatiquement dans le fenêtre d'édition les lignes de commandes qui s 'exécutent dans le débogueur.

Ne pas oublier de compiler avec l'option -g de gcc.


M-x gdb Lance le débogueur


Une fois le débogueur lancé, on peut charger un programme et poser un point d'arrêt sur une fonction ( par exemple main() ), puis on lance l'exécution du programme. Le source C apparaît alors dans une autre fenêtre.


(gdb) file nom_de_programme Charge le fichier binaire à déboguer


(gdb) break nom_de_fonction Pose un point d'arrêt à l'entrée de la fonction


(gdb) run [arguments] Lance le programme avec d'éventuels arguments


Quand le programme est arrêté , par exemple à un point d'arrêt, on peut utiliser les commandes :


(gdb) cont Continue le programme après un arrêt

(gdb) next Exécute le programme jusqu'à la ligne du source suivante,

sans rentrer dans les fonctions appelées

(gdb) step Idem en rentrant dans la(les) fonction(s) appelée(s)

(gdb) nexti Exécute l'instruction suivante, sans rentrer dans les fonctions appelées

(gdb) stepi Idem en rentrant dans la(les) fonction(s) appelée(s)

(gdb) print expr Affiche la valeur de l'expression C donnée en argument

(gdb) where Affiche les appels de fonctions actifs, c-à-d le contenu de la pile

Make et Makefile

Dominante Informatique et Filière Eurecom

Philippe Dax


Utilité et domaine d'utilisation



Schéma de production d'une application

Algorithme de make

Actions de compilation

Graphe de dépendance

#
# Makefile
#
prog:   mod1.o mod2.o mod3.o
    cc mod1.o mod2.o mod3.o -o prog
mod1.o: mod1.c
    cc -c mod1.c
mod2.o: mod2.c inc1.h
    cc -c mod2.c
mod3.o: mod3.c inc1.h inc2.h
    cc -c mod3.c

Macros de substitution

#
# Makefile
#
OBJS = mod1.o mod2.o mod3.o
prog:   $(OBJS)
        cc $(OBJS) -o prog
mod1.o: mod1.c
        cc -c mod1.c
mod2.o: mod1.c inc1.h
        cc -c mod2.c>
mod3.o: mod3.c inc1.h inc2.h
        cc -c mod3.c

Connaissances implicites

#
# Makefile  -  (Exemple de dépendance implicite)
#
OBJS = mod1.o mod2.o mod3.o
prog:   $(OBJS)
        cc $(OBJS) -o prog
mod2.o: inc1.h
mod3.o: inc1.h inc2.h

Macros spéciales


#
# Makefile  -  (Exemple d'utilisation des macros spéciales)
#
OBJS = mod1.o mod2.o mod3.o
prog:   $(OBJS)
        cc $(OBJS) -o $@
        @echo "On reconstruit $@ a cause de $?"
mod1.o: mod1.c; cc -c $<
# mod1.o: mod1.c; cc -c $*.c
mod2.o: inc1.h
mod3.o: inc1.h inc2.h

Règles de précédence et d'inférence

#
# Makefile  -  (Exemple de règle d'inférence)
#
OBJS = mod1.o mod2.o mod3.o
.c.o:
        $(CC) $(CFLAGS) -c $<
prog:   $(OBJS)
        $(CC) $(OBJS) -o $@
mod2.o: inc1.h
mod3.o: inc1.h inc2.h

Directives

#
# Makefile
#
.PRECIOUS mod2.o
.DEFAULT:; echo "$< n'existe pas"
OBJS = mod1.o mod2.o mod3.o
prog:   $(OBJS)
        $(CC) $(OBJS) -o $@
mod2.o: inc1.h inc3.h
mod3.o: inc1.h inc2.h

Exemple d'un Makefile générique

#
# Makefile - maintained by author - date
#
APPL = prog

SHELL = /bin/sh
PRINTER = dominique
COMPRESS = gzip

# Paramètres de compilation et d'édition de liens
CC = gcc
LD = $(CC)
CFLAGS = -g
LDFLAGS = -static
DEFS = -DENST -DPATH=\"/usr/local/$(APPL)\"
# Paramètres d'installation
BINDIR = /usr/local/bin
MANDIR = /usr/local/man
MANEXT = 1

# Objets de l'application
LIBS = 
OBJS = mod1.o mod2.o mod3.o
SRCS = mod1.c mod2.c mod3.c
INCL = inc1.h inc2.h
MANS = $(APPL).1
SOURCES = README COPYRIGHT INSTALL Makefile $(SRCS) $(INCL) $(MANS)
EXEC = $(APPL)

# Règle d'inférence
.DEFAULT:; @echo "$< n'existe pas"
.c.o:
        -$(CC) $(DEFS) $(CFLAGS) $<

# Construction de l'application
.PRECIOUS $(EXEC)
$(EXEC): $(OBJS)
        $(LD) $(LDFLAGS) $(OBJS) $(LIBS) -o $@

clean:
        -@rm $(OBJS) $(EXEC) core a.out 2>/dev/null
install:
        install -m 755 -o root -g staff $(EXEC) $(BINDIR)
install_man:
        install -m 444 $(EXEC).$(MANEXT) $(MANDIR)/man$(MANEXT)
print: $(SRCS) $(INCL)
        -@lpr -P$(PRINTER) $?
        -@touch $@
printall:
        -@lpr -P$(PRINTER) $(SOURCES)
tar:
        tar cvf $(APPL).tar $(SOURCES)
archive: tar
        $(COMPRESS) $(APPL).tar

#
# Dépendances des objets
#
mod2.o: inc1.h inc3.h
mod3.o: inc1.h inc2.h



La commande make et ses options

Génération automatique de Makefile

© (Copyright) Philippe Dax - 1994-2000 visitors since Oct 1995.

1/49