Kornshell

GUIDE
du
KornShell
sous
UNIX
(HP-UX 8.0, SUNOS 5.1, AIX 3.2)
jh Soulier
Jean Franois Pujol aot 93
jf pujol, 18 aot 1993
page 2 - Guide du KornShell sous UNIX
INTRODUCTION
Ce document constitue une aide la programmation du KornShell (ksh), et non un manuel de rfrence; cest pourquoi il est destin aux utilisateurs ayant dj des connaissances de base dun shell (sh ou csh). Il contient des exemples qui se veulent instructifs, et pas une base rigide de programmation : vous y piocherez donc ce qui vous semble bon. Tous les exemples ont t excuts lorigine sur un hp9000 srie 400, sous HP-UX 8.0, avec une version du KornShell date du 16/11/88. La version HP-UX 9.0 na apport que de lgres modications au niveau des commandes (convergence vers POSIX 1003.2), mais na pas t teste ici spciquement. Dans le cas o une incompatibilit apparatrait, le mieux est de se rfrer aux spcicits SUN ou IBM: il est probable que lune dentre elles permette de comprendre le phnomne. Il faut savoir que HP fournit le shell POSIX (appel sh, comme le BourneShell) partir de la version 9.0, et que le shell POSIX est presque une copie conforme du KornShell. Pour tenir compte des utilisateurs travaillant sous SUN-OS 5.X (SOLARIS 2.X), ou AIX 3.2, les exemples ont t tests galement dans ces environnements, et les diffrences qui apparaissent par rapport la version HP-UX gurent en annexe. Pour SUN-OS 5.1, la plate-forme tait une "SparcStation 1+", et pour AIX 3.2, une station RS6000 modle 340, avec un clavier (et des messages) en version franaise. voir Dans la suite du document, un symbole dans la colonne signiera que lexemple en cours nest pas directement adaptable dans lenvironnement SUN-OS: il faudra se reporter au chapitre adquat pour y retrouver les particularits; voir De la mme faon, un symbole correspondra une remarque spcique AIX. Le fait que la version de base soit crite pour HP-UX nest en rien li une quelconque norme ou rfrence: le choix est arbitraire. Surtout, nhsitez pas me communiquer vos remarques : cela me permettra de corriger les imperfections, qui, je nen doute pas, doivent encore mailler ce document. Guide du KornShell sous UNIX - page 3
Guide dutilisation du guide
oui tes vous press(e)?
non
essayez de trouver une solution votre problme parmi les cas types ou les messages derreur courants
non
est - ce sufsant?
oui
bye un renvoi vous indique o trouver des informations supplmentaires commencez par vous intresser la manipulation des chiers, aux redirections, aux droits daccs, la manire dcrire un programme shell propre non oui
tes - vous compltement dsoeuvr(e)?
lisez tout
Guide du KornShell sous UNIX - page 5
Table des matires
Table des Matires
INTRODUCTION ..................................................................................................... 3 Guide dutilisation du guide ...................................................................................... 5 Table des Matires ..................................................................................................... 7
I. Description ...........................................................................................13
I.1. Introduction : quest ce que le shell? ............................................................. 14
I.1.1. Description ....................................................................................................................14 I.1.2. Algorithme simplifi ....................................................................................................14 I.1.3. Les diffrents shells disponibles ...................................................................................15
I.2. Quest ce quun processus UNIX ? ............................................................... 16 I.3. Format dune commande UNIX lmentaire ................................................ 17
I.3.1. Description ....................................................................................................................17 I.3.2. Exemples ......................................................................................................................17
I.4. Les entres-sorties dune commande UNIX lmentaire .............................. 19 I.5. La manipulation des fichiers ......................................................................... 21
I.5.1. Description ....................................................................................................................21 I.5.2. Exemple ........................................................................................................................21 I.5.3. Les droits et la manipulation des fichiers .....................................................................23 I.5.4. Les liens ........................................................................................................................27
1.5.4.1. Les liens physiques ...............................................................................................................................27 1.5.4.2. Les liens symboliques ..........................................................................................................................31
I.6. Interprtation dune commande shell ............................................................ 34

I.6.1. Etape 1 : Interprtation des sparateurs .......................................................................34 I.6.2. Etape 2 : Le caractre spcial quote ........................................................................35 I.6.3. Etape 3 : Les variables et le caractre spcial anti-quote ou $() .................................35
1.6.3.1. Etape 3.1 : Les variables .....................................................................................................................35 1.6.3.2. Etape 3.2 : Le caractre spcial anti-quote ou $( ) ........................................................................... 41
I.6.4. Etape 4 : I.6.5. Etape 5 : I.6.6. Etape 6 : I.6.7. Etape 7 :
Le caractre spcial double-quote " ............................................................42 Les caractres spciaux * [] ? ~ \ ................................................................43 les squences () et {} ...................................................................................46 Les caractres spciaux ; | && & | ..........................................................47 Guide du KornShell sous UNIX - page 7
Table des matires
1.6.7.1. caractre ; ..............................................................................................................................................47 1.6.7.2. squence || .............................................................................................................................................47 1.6.7.3. squence && ........................................................................................................................................48 1.6.7.4. caractre & ............................................................................................................................................48 1.6.7.5. le caractre | ou pipe ..........................................................................................................................48
I.6.8. Etape 8 : Les redirections ............................................................................................49 I.6.9. Etape 9 : La localisation de la commande ..................................................................55
1.6.9.1. Les alias ................................................................................................................................................55 1.6.9.2. Les fonctions .........................................................................................................................................55 1.6.9.3. Le path ..................................................................................................................................................58
I.7. Le contrle des processus ............................................................................. 60

I.7.1. La commande ps ...........................................................................................................60 I.7.2. Le contrle des processus par le clavier .......................................................................61 I.7.3. La commande jobs ........................................................................................................62 I.7.4. Les commandes fg et bg ...............................................................................................63 I.7.5. La commande kill .........................................................................................................65
II. Les Expressions ...................................................................................69

II.1. Les expressions du KornShell ..................................................................... 70
II.1.1. Lexpression arithmtique ...........................................................................................70 II.1.2. Lexpression gnrique ................................................................................................70 II.1.3. Lexpression conditionnelle ........................................................................................71
II.2. Les expressions rgulires ........................................................................... 76

II.2.1. Expressions rgulires de base ( ER ) .........................................................................76 II.2.2. Expressions rgulires tendues ( ERE ) .....................................................................79
III. Exemples dutilisation de commandes ...............................................81

III.1. Quelques fonctions du KornShell .............................................................. 82
III.1.1. cd, pwd .......................................................................................................................82 III.1.2. if .................................................................................................................................82 III.1.3. for ...............................................................................................................................83 III.1.4. la commande point . ................................................................................................83 III.1.5. print ............................................................................................................................84 III.1.6. set ...............................................................................................................................85 III.1.7. shift .............................................................................................................................86 III.1.8. trap ..............................................................................................................................86 III.1.9. typeset .........................................................................................................................89 III.1.10. unset .........................................................................................................................92 III.1.11. wait ...........................................................................................................................92 page 8 - Guide du KornShell sous UNIX
Table des matires
III.1.12. whence .....................................................................................................................93 III.1.13. while .........................................................................................................................93
III.2. Quelques commandes UNIX ...................................................................... 94

III.2.1. awk .............................................................................................................................94 III.2.2. basename, dirname ...................................................................................................109 III.2.3. bs ..............................................................................................................................109 III.2.4. dc ..............................................................................................................................111 III.2.5. file ............................................................................................................................112 III.2.6. find ...........................................................................................................................113 III.2.7. grep ..........................................................................................................................115 III.2.8. head ..........................................................................................................................116 III.2.9. join ...........................................................................................................................116 III.2.10. nohup ......................................................................................................................118 III.2.11. sed ..........................................................................................................................119 III.2.12. sort ..........................................................................................................................126 III.2.13. strings .....................................................................................................................132 III.2.14. tail ..........................................................................................................................134 III.2.15. uniq ........................................................................................................................134 III.2.16. xargs .......................................................................................................................136
IV. Cas types ..........................................................................................143

IV.1. Cas types dans un programme shell ......................................................... 144
IV.1.1. Comment affecter une variable avec le rsultat dune commande? ........................144 IV.1.2. Comment lire un fichier ligne ligne? ....................................................................145 IV.1.3. Comment mettre une trace dexcution? .................................................................145 IV.1.4. Comment tester si un fichier existe? sil est vide? ..................................................146 IV.1.5. Comment excuter une commande sur plusieurs fichiers de mon rpertoire? ........147 IV.1.6. Comment additionner ou multiplier deux entiers? ..................................................147 IV.1.7. Comment transformer le contenu dune variable en majuscules? en minuscules? .148 IV.1.8. Comment contraindre une variable une longueur donne? ...................................148 IV.1.9. Comment lancer mes propres commandes sans tre oblig de spcifier leur chemin absolu? .....................................................................................................................................148 IV.1.10. Comment rediriger les sorties standard et derreur vers des fichiers spars? ......149 IV.1.11. Comment crire un script qui ait 3 sorties standard? .............................................149 IV.1.12. Comment drouter lexcution dun programme sur rception dun signal? ........151 IV.1.13. Comment effectuer une slection parmi plusieurs solutions (CASE)? .................152 IV.1.14. Comment ter le suffixe un nom de fichier? ......................................................154 IV.1.15. Comment associer plusieurs conditions dans un test (IF)? ....................................154 IV.1.16. Comment se dbarrasser de messages derreurs qui ne mintressent pas? ..........155
Table des matires
IV.2. Cas types avec la ligne de commande ...................................................... 156

IV.2.1. Comment bnficier des facilits de lhistorique des commandes? ........................156 IV.2.2. Comment retrouver une commande contenant un mot particulier? .........................156 IV.2.3. Comment tendre le nom dun fichier que lon est en train de taper? .....................158 IV.2.4. Comment lancer une commande sans avoir attendre sa fin? ................................159 IV.2.5. Comment lancer une commande qui ne soit pas tue si on se dconnecte? ............161 IV.2.6. Comment se replacer dans le rpertoire que lon vient de quitter? ..........................162 IV.2.7. Comment lister les variables positionnes? celles exportes? .................................162 IV.2.8. Comment mettre le rpertoire courant dans le prompt? ...........................................162 IV.2.9. Comment crire un alias? .........................................................................................162 IV.2.10. Dans quel fichier faut-il dclarer les variables et les alias pour les avoir positionnes chaque session? ....................................................................................................................163 IV.2.11. Comment lancer une commande avec le contenu du buffer de la souris? .............163 IV.2.12. O trouver la liste des caractres ascii? .................................................................164 IV.2.13. Comment lister les fichiers par ordre de taille? .....................................................164 IV.2.14. Que faire lorsque le shell refuse dafficher le prompt et dexcuter mes commandes aprs chaque retour chariot? .................................................................................................164 IV.2.15. Pourquoi la sortie dcran continue t-elle de dfiler alors que je viens de taper plusieurs fois <control>C? ...................................................................................................................165
IV.3. Cas types avec les commandes UNIX ..................................................... 166

IV.3.1. Comment trier un fichier sur le 3me champ? .........................................................166 IV.3.2. Comment trier un fichier sur plusieurs champs? .....................................................166 IV.3.3. Comment rechercher un fichier dans mon arborescence? .......................................166 IV.3.4. Comment excuter une commande sur une liste de fichiers? ..................................167 IV.3.5. Comment excuter une commande sur tous les fichiers de mon arborescence? .....168 IV.3.6. Dans un fichier, comment supprimer les lignes dont les 2 derniers champs sont identiques? .....................................................................................................................................168 IV.3.7. Dans un fichier tri, comment conserver une seule ligne parmi celles dont le 2me champ est identique? ............................................................................................................169 IV.3.8. Comment convertir un nombre dcimal en hexa? ..................................................170 IV.3.9. Comment lancer une commande une date donne? ..............................................171 IV.3.10. Comment retrouver les fichiers qui nont pas t modifis depuis plus de trois jours? depuis moins de 3 jours? ......................................................................................................171 IV.3.11. Comment extraire les 4me et 5me champs des lignes de mon fichier? ..............172 IV.3.12. Comment garder toutes les lignes de mon fichier qui ne contiennent pas une chane particulire? ..........................................................................................................................172 IV.3.13. Comment recopier un rpertoire entier? ................................................................172 IV.3.14. Comment retrouver les fichiers qui font un lien sur un fichier donn? .................174 IV.3.15. Pourquoi je narrive pas supprimer mon fichier? en crer un? ........................175 IV.3.16. Comment positionner par dfaut les droits dun fichier ? ......................................176 IV.3.17. Comment dterminer le type ou le contenu dun fichier? ......................................177 IV.3.18. Comment avoir la rponse une question qui napparait pas ci-dessus? ..............178 page 10 - Guide du KornShell sous UNIX
Table des matires
V. Optimiser un programme shell .........................................................179

V.1. Cot dexcution ........................................................................................ 180 V.2. Quelques conseils en vrac .......................................................................... 182 V.3. Exemples pour viter les boucles .............................................................. 183
V.3.1. Recherches de chanes ..............................................................................................183 V.3.2. Manipulation dune partie de ligne ...........................................................................184
VI. Ecrire un programme shell propre ...................................................187

VI.1. Pourquoi perdre du temps? ....................................................................... 188 VI.2. Choix du shell utiliser ............................................................................ 189 VI.3. O mettre le nouveau programme ............................................................ 190 VI.4. Commentaires, version ............................................................................. 191 VI.5. Test des options, vrification des arguments ............................................ 192
VI.5.1. Test de la prsence des options et paramtres .........................................................193 VI.5.2. Test de la validit des paramtres ............................................................................195
VI.6. Entre standard et/ou fichiers nomms .................................................... 197 VI.7. Manipulation des fichiers temporaires ..................................................... 199 VI.8. Traitements des signaux ........................................................................... 200 VI.9. Emission des messages derreur ............................................................... 202 VI.10. Gnration du code de retour ................................................................. 203
VII. Quelques messages derreur courants ............................................205

VII.1. Format du message .................................................................................. 206
VII.2. Liste des principaux messages derreur .................................................. 208
VIII. Spcificits SUN-OS 5.1 ..............................................................213
Table des matires
IX. Spcificits AIX 3.2 .........................................................................223

INDEX .................................................................................................................. 231 Bibliographie ......................................................................................................... 237
Description
I.
I. Description
Description : Introduction : quest ce que le shell?
I.1. Introduction : quest ce que le shell?

I.1.1. Description
Le shell est un interprteur de commandes. Il permet de lancer les commandes UNIX disponibles sur votre station, en leur affectant un certain nombre de paramtres dexcution, de contrler les donnes dentre et de sortie, les messages derreur ventuels, et surtout de les enchaner de manire efcace et pratique. Un shell est dmarr pour chaque console ouverte (ou fentre X11 quivalente cre) ; il est intractif dans ce cas, car les lignes de commande tapes au clavier sont excutes une par une avec conrmation systmatique (touche <return>). Un shell est galement cr chaque fois que la commande excuter se trouve tre un chier ascii : le shell lit successivement toutes les lignes du chier, supposant que ce sont des commandes ; il disparat (rend la main) une fois la n de chier atteinte.
I.1.1.
I.1.2. Algorithme simpli

Si le shell est intractif, on peut reprsenter son fonctionnement sous la forme de lalgorithme simpli suivant :
TANT QUE < dure de la connexion> lire_ligne_au_clavier(ligne) traiter_ligne(ligne) afcher_resultats() afcher_prompt() FIN TANT QUE
Si le shell nest pas intractif, alors on peut considrer quil est lanc directement travers la fonction traiter_ligne() dont le paramtre est le nom du chier traiter ;
Description : Introduction : quest ce que le shell?
I.1.3.
Voici lalgorithme de la fonction traiter_ligne() :
traiter_ligne(ligne) POUR <premier champ de la ligne> DANS * <nom de chier ascii> : TANT QUE <chier ascii> NON VIDE traiter_ligne(<ligne courante du chier ascii>) FIN TANT QUE * <nom de binaire executable> : charger_et_lancer(<chier binaire>) * <commande shell> : executer_commande() * AUTRE : afcher_message(command not found) FIN POUR
I.1.3. Les diffrents shells disponibles

Le shell est lui mme un chier binaire, quil est possible de lancer comme nimporte quelle autre commande UNIX. Ainsi, lorsquon parle du shell, cela recouvre en fait un ensemble de trois interprteurs diffrents, possdant chacun un excutable spcique : i. Le BourneShell, (commande sh), est loriginal, le plus ancien ayant exist sous UNIX ; cest celui qui possde aussi le moins de fonctionnalits, et qui est le moins pratique utiliser ; par contre, on est sr de le trouver quelque soit le type de machine. ii. Le Csh (commande csh), est plus rcent et intgre des fonctions supplmentaires comme lhistorique des commandes, indispensable en usage courant ; on le trouve en standard sur la plupart des machines ; par contre sa syntaxe nest pas compatible avec le Bourne Shell ; iii.Le Ksh (commande ksh), est le dernier n et le plus complet ; il accepte toutes les commandes du Bourne Shell, possde un historique de commandes perfectionn, et la plupart des fonctionnalits du Csh. Cest ce dernier qui servira de base pour les exemples qui suivent, bien que beaucoup de remarques soient valables quelque soit le shell utilis. Guide du KornShell sous UNIX - page 15
Description : Quest ce quun processus UNIX ?
I.2. Quest ce quun processus UNIX ?

Un processus UNIX est un chier binaire en train de sexcuter avec un certain environnement : - des pointeurs sur les chiers ouverts ; - des ractions programmes aux signaux : - division par zro - perte de connexion avec la console - rception du signal INTERRUPT (touche CTRL C) ... - etc... Pour dmarrer un nouveau processus, cest dire chaque fois que lon veut lancer une nouvelle commande (grep, sort, compile, ..), une technique standard est applique ; Le processus en cours fait appel une fonction spciale qui lui permet de se recopier lui-mme intgralement. Tout est recopi exactement en double, la zone mmoire, la zone de code, les pointeurs sur les chiers, etc... Seul, le code de retour de la fonction permet de diffrencier loriginal (le pre) de la copie (le ls) ; lenvironnement du processus ls est modi en partie si ncessaire (descripteurs de chier, variables exportes, signaux,...), puis la zone de code du ls est crase avec le code du nouveau programme excuter, qui dmarre ; le pre attend la n du ls, puis continue de sexcuter. Cette mthode peut paratre complexe, mais cest exactement ce qui se passe chaque fois que le shell lance une commande (par la fonction charger_et_lancer() de notre pseudo-interprteur vu plus haut). On y dcouvre loccasion la raison pour laquelle le vocabulaire li aux processus est souvent tir de tout ce qui touche la descendance ; cest une constante : tout processus a t lanc par un processus pre (sauf le premier !) et il hrite de la plupart des ses caractristiques. Si votre shell possde un paramtrage dont vous ne savez attribuer la provenance en tudiant vos chiers de conguration, il y a de grandes chances que ce soit un processus anctre qui lai positionn. Mais la cration dun nouveau processus est une action coteuse en ressources systme, et nous verrons plus loin quelles sont les rgles appliquer pour viter dy faire trop souvent appel lors de lexcution de programmes.
I.1.3.
Description : Format dune commande UNIX lmentaire
I.3.1.
I.3. Format dune commande UNIX lmentaire

I.3.1. Description
Si lon oublie pour linstant les caractres de contrle du shell comme ; | ou &, et la syntaxe de certaines commandes internes au shell (affectation, tests, boucles for,...), une ligne de commande lmentaire a la forme suivante : <champ0> <champ1> <champ2> ... <champN> les champs tant des suites de caractres termins par des <espace>, ou des <tabulation>. Alors : - le <champ> 0 est suppos tre le nom dun chier binaire ou ascii, ou le nom dune commande interne au shell ; - les <champ> 0 N sont des paramtres qui seront passs au dmarrage lexcutable <champ0> (comme un appel de fonction). Le shell va essayer de transformer chaque ligne de commande de manire retomber sur ce schma : - le premier champ de la ligne prend le rle de lexcutable lancer ; - tous les arguments (de 0 N) sont empils lors de lappel. Au programme appel de soccuper correctement de ses paramtres, en faisant le tri, et en les utilisant de manire souhaite.
I.3.2. Exemples
exemple 1 : grep -i -v TOTO /tmp/essai Cette commande est destine rechercher dans le chier /tmp/essai toutes les lignes qui ne comprennent pas (option -v) la chane de caractres toto apparaissant indiffremment en majuscules ou minuscules (option -i). Cette commande se dcompose en : <champ0> = grep : la commande <champ1> = -i : le premier argument <champ2> = -v : le second <champ3> = TOTO : le troisime <champ4> = /tmp/essai : le quatrime Au moment de lappel de grep, aucune diffrence nest faite entre les quatre arguments ; le shell lance lexcutable grep en lui fournissant les quatre arguments, sans se proccuper de leur ordre, ni de leur valeur ou signication.
Description : Format dune commande UNIX lmentaire
Par contre, lorsque la commande grep commence travailler, sa premire action est de I.3.2. faire le tri et de tester les paramtres qui lui t fournis. Cest ce moment que le type des arguments a une signication : certains doivent commencer par un tiret (ce sont des options de la commande) et dautres non (ce sont des paramtres de la commande). En rsum, le shell spare et fournit la commande les diffrents champs constituant la ligne ; la commande rcupre les champs et vrie quils correspondent bien sa syntaxe. exemple 2 : sed s/^#// /tmp/toto Cette commande renvoie le chier /tmp/toto sans caractre # en dbut de ligne. Elle se dcompose en : <champ0> = sed : la commande <champ1> = s/^#// : le premier argument <champ2> = /tmp/toto : le second On voit ainsi que la commande sed utilise le premier argument comme la commande excuter sur le chier dont le nom est indiqu par le second argument.
Description : Les entres-sorties dune commande UNIX lmentaire
I.3.2.
I.4. Les entres-sorties dune commande UNIX lmentaire

Pour faire dialoguer une commande (un processus) avec lextrieur, et le shell en particulier, on dispose de diffrentes solutions ; en ENTREE : Les paramtres de position1: de 0 N, comme on a vu au paragraphe prcdent. (le nom de la commande est pass aussi en tant quargument 0). Si la ligne de commande est : cmd arg1 arg2 lappel de cmd pourrait tre assimil lappel dune fonction cmd() avec les 3 arguments cmd, arg1, arg2 passs par valeur ; Les variables exportes : Toutes les variables faisant partie de lenvironnement export sont visibles et utilisables par la commande ; par contre, la modication du contenu dune de ces variables exportes naura quune porte locale (pas de possibilit de retourner une valeur de cette manire). On place une variable dans lenvironnement export par la commande shell : export NOM_DE_LA_VARIABLE en SORTIE : le code de retour : La variable shell $? contient le code de retour de la dernire commande lance par le shell. Si la commande sest termine normalement, le code de retour vaut gnralement 0 ; (le manuel de rfrence indique le code de retour de chaque commande). Si la commande est elle-mme un programme shell qui sest termin sur une instruction exit <valeur>, le code de retour vaut <valeur>, sinon il vaut le code de retour de la dernire commande excute dans le programme. en ENTREE / SORTIE : les chiers. Par dfaut, il y en a trois douverts par le shell avant le lancement de chaque commande : - 1 en entre : lentre standard - 2 en sortie : la sortie standard et la sortie derreur.
1. on appelle ici argument un champ plac aprs le nom de la commande sur la ligne de commande, et paramtre de position, cet argument, mais vu par la commande pendant son excution.
Description : Les entres-sorties dune commande UNIX lmentaire
Il est rappele que le shell qui lance une commande positionne le ncessaire pour que ces I.3.2. entres-sorties soient disponibles : mais, une fois lance, il est du ressort de la commande de les utiliser et de retourner des valeurs couramment attendues1. En gnral, une commande UNIX lit les donnes sur lentre standard, les modie en fonction des arguments spcis, (options ou paramtrage) et renvoie le rsultat sur la sortie standard. Si une erreur intervient, elle afche un message sur la sortie derreur, et renvoie un code de retour diffrent de zro. Une bonne habitude consiste respecter cette convention, ce qui permet ainsi dcrire et dintgrer facilement de nouvelles commandes au milieu de celles dj existantes.
1.
voir le chapitre consacr ce sujet plus loin : crire un shell propre page 187
Description : La manipulation des chiers
I.5.1.
I.5. La manipulation des chiers

I.5.1. Description
La manipulation dun chier passe toujours par les tapes suivantes : 1/ ouvrir le chier 2/ crire, lire dans le chier 3/ fermer le chier Sous UNIX, on ne spcie dans les commandes le nom du chier physique utilis que lors de ltape 1 ; le systme renvoie alors un numro (un entier de 0 20) qui sert ensuite de rfrence logique pour toutes les autres actions lies ce chier : cest le descripteur. Le descripteur 0 est nomm aussi : entre standard 1 sortie standard 2 sortie derreur Lorsquune commande standard dUNIX travaille, elle lit les donnes sur le descripteur 0, crit le rsultat sur le 1, et ventuellement les erreurs sur le 2, sans rien connatre en fait du nom des chiers physiques qui lui sont associs. Le shell, lui, ouvre en fonction de certaines directives (> < >> |, etc) les chiers spcis en lecture ou en criture, leur affecte chacun un descripteur, lance la commande, attend la n, puis ferme les chiers associs aux descripteurs. Par exemple, la commande echo crit par convention sur le descripteur 1 ; mais ce rsultat peut tre dirig vers nimporte quel chier pourvu que le shell ait auparavant associ ce chier au descripteur 1. Une caractristique importante des descripteurs est quils font partie de lhritage lors de la cration dun nouveau processus : un processus qui nat a des descripteurs qui pointent sur les mmes chiers que ceux de son pre ; le shell de login (le premier lanc lors de votre connexion) affecte le descripteur 0 au clavier, et les descripteurs 1 et 2 la console ; tant que vous ne modierez pas la sortie standard (descripteur 1), tous les processus ls crs auront leur sortie standard associe la console et leurs rsultats sy afcheront.
I.5.2. Exemple
commande : grep truc <toto 2>trace Le shell qui value la ligne interprte : <toto par 2>trace par : ouvrir le chier toto en lecture et laffecter au descripteur No 0 (entre standard) du nouveau processus grep : ouvrir le chier trace en criture et lui affecter le descripteur 2. Guide du KornShell sous UNIX - page 21
Comme aucune directive ne touche le descripteur 1, on ne le modie pas. Lanctre du shell I.5.2. actuel, le shell de login par exemple, lavait dj affect la console : il y est encore par hritage. Le nouveau processus grep lit les lignes prsentes sur son entre standard (descripteur 0), et recopie celles contenant la chane truc sur la sortie standard (descripteur 1). Rsultat : les lignes du chier toto qui contiennent la chane truc safchent lcran, et le chier trace est vide.
On peut suivre les connexions des diffrentes sorties de la commande sur le schma suivant :
ksh (login) ksh (ligne de commande) toto grep (truc) 0 1 1 2 2 2 trace 0 0 1
ches grises : ches noires :
ltat des connexions de la commande grep sans les redirections ; avec les redirections.
I.5.3.
Remarque 1 : laffectation des descripteurs (redirection) pour une commande ne touche pas le shell qui la effectue ; on verra ensuite comment modier les descripteurs lintrieur dun shell. Remarque 2 : Imaginons que la commande grep envoie ses messages derreur sur le descripteur 6 plutt que sur le 2 comme le veut la convention, alors il aurait fallu crire pour faire la mme chose : grep truc <toto 6>trace Remarque 3 : Les redirections ne sont pas considres comme des paramtres de la commande. Dans le cas de : grep truc <toto le shell applique la redirection et lance la commande grep avec les deux paramtres grep et truc. Dans le cas de : grep truc toto le shell conserve les redirections dj existantes et lance la commande grep avec les trois paramtres grep, truc et toto1. En conclusion : les descripteurs sont des passerelles ; le shell ouvre des chiers et affecte les descripteurs ; la commande lit et crit sur les descripteurs (quelle que soit leur affectation). Nous dtaillerons tous les types de redirections plus loin.
I.5.3. Les droits et la manipulation des chiers

Tous les processus et chiers UNIX existant sur une machine peuvent tre rpartis dans trois ensembles diffrents : - ceux appartenant lutilisateur donn U ; - ceux appartenant un autre utilisateur que U, mais faisant partie du mme groupe G que U ; - ceux nappartenant ni lutilisateur U, ni son groupe G : tous les autres.
Ces ensembles sont disjoints : il nest pas possible quun processus ou un chier appartiennent plus dun de ces ensembles. Autant un utilisateur est dni de manire unique sur une machine par son numro didentication (uid), autant le groupe de lutilisateur (gid) est ottant : il est unique pour un
1. La commande grep doit se dbrouiller seule pour savoir si elle doit lire les lignes de donnes sur le descripteur 0 (cest ce quelle fait s il ny a que deux paramtres), ou si elle doit commencer par ouvrir le chier dont le nom est le troisime paramtre (ce quelle fait uniquement sil y a trois paramtres).
processus ou un chier donn, mais un utilisateur peut avoir de manire simultane plusieurs I.5.3. processus ou chiers ayant des groupes diffrents. Cest ladministrateur du systme qui dnit les groupes dans lesquels vous pouvez vous positionner, ou positionner vos chiers. Un processus ou un chier est li dans tous les cas un doubl (uid,gid) : - uid tant lidenticateur de lutilisateur ayant cr le processus ou le chier ; - gid tant le groupe courant au moment de la cration du processus ou du chier.
others
chier(uid4,gid5) process(uid2,gid1) chier(uid3,gid1)
group (gid1)
chier(uid1,gid1) process(uid1,gid2)
user (uid1)
Les trois ensembles ci-dessus dnissent trois classes dappartenance : - user - group - others : la classe de tous les chiers ou processus ayant le mme propritaire que lutilisateur (ici, uid1) : la classe des chiers ou processus ayant le mme groupe que lutilisateur (ici, gid1). : celle des chiers ou processus nayant ni le mme propritaire, ni le mme groupe que lutilisateur (uid1).
On remarquera quil nest possible dappartenir qu une seule classe la fois, et que la priorit va la classe user. Ainsi, le propritaire dun chier appartient dofce la classe user, et par consquent ne peut jamais appartenir ni la classe group, ni la classe others. On peut dnir sous UNIX des droits dun chier en lecture (r), en criture (w), et en excution (x) pour chacune de ces classes. Seul le propritaire dun chier (ou ladministrateur1) peut modier les droits de celui-ci .
1. Voir le paramtrage possible avec la commande umask: page 176
I.5.3.
Symbologie : $ ls -l essai1
-rwxr-xr-x 1 logis users 80 Apr 21 10:05 essai1

(uid) (gid)
droits pour la classe others droits pour la classe group droits pour la classe user
rwx
droit en excution valide pour la classe considre droit en criture valide ... droit en lecture valide ... si un tiret - remplace une des lettres, cest que le droit correspondant est supprim.
Dans lexemple du chier essai1 qui est indiqu ici : - la classe user est en criture, en lecture et en excution : cest dire que le propritaire peut lire, crire et faire excuter le chier. - la classe group a les droits en lecture et en excution : cest dire que les utilisateurs ou les processus autres que le propritaire et dont le groupe est identique celui du chier pourront lire et excuter le chier. - la classe others a les droits en lecture et en excution : les utilisateurs autres que le propritaire du chier et dont le groupe est diffrent de celui du chier pourront le lire et lexcuter. On a indiqu plus haut quun utilisateur ou un processus ne pouvait appartenir qu une seule classe, cela signie quil nest concern que par les droits de la classe qui lui correspond, les autres (pour les deux autres classes) tant non signicatifs.
Pour connatre les droits que lon possde sur un chier, il suft de comparer ses propres uid et gid (que lon peut avoir en tapant la commande id) avec ceux du chier : $ id uid=207(logis) gid=20(users) $ - si mon uid est celui du chier : je suis le propritaire et les droits qui me concernent sont ceux de la classe user. Guide du KornShell sous UNIX - page 25
- si mon uid nest pas celui du chier, mais mon gid est celui du chier, mes droits I.5.3. sont ceux de la classe group. - si mon uid nest pas celui du chier, pas plus que mon gid, alors mes droits sont ceux de la classe others. Droits sur les rpertoires. Pour linstant, il na pas t indiqu comment on pouvait autoriser la cration ou la suppression dun chier. Lorsquon cre un chier dans un rpertoire, ou quon le dtruit, cela revient modier le contenu du rpertoire correspondant : on rajoute ou on enlve un lment dans la liste. Pour modier le rpertoire, il faut avoir les droits en criture dessus. Le fonctionnement des droits en lecture et en criture sur un rpertoire se fait de la mme manire que pour les chiers, en gardant lesprit que : - la lecture dun rpertoire se fait lorsquon liste son contenu (par la commande ls par exemple, ou si on utilise des caractres spciaux symbolisant les noms de chiers : * ? [ ] ...) Mme sil nest pas possible de lister le contenu dun rpertoire, on peut nanmoins atteindre et lister les chiers des sous-rpertoires, sil en existe, et si on connat leur nom. - lcriture dans un rpertoire se fait lorsquon cre ou dtruit un chier - lexcution se fait lorsquun chemin de chier ou une commande cd spcie le nom de ce rpertoire. De manire image, on pourrait penser que lon passe par un rpertoire lorsquon essaie datteindre un chier que ce rpertoire contient, ou quun sous-rpertoire contient ; si lexcution est interdite, on ne peut plus passer. En conclusion, si les droits en excution sont enlevs sur un rpertoire, il ne sera plus possible pour les utilisateurs de la classe correspondante dutiliser des chemins qui contiennent ce rpertoire. En rsum : Pour crer ou supprimer un chier, il faut avoir les droits sufsant sur le rpertoire qui le contient ; Pour crire, lire ou excuter un chier, il faut avoir des droits sufsants sur le chier lui-mme. Remarque : Lorsque vous crez un chier de commande, pensez rajouter les droits dexcution dessus sans quoi vous ne pourrez pas le lancer ; vous obtiendrez le message : cannot execute.
I.5.4.
I.5.4. Les liens

Il arrive parfois davoir besoin, dans plusieurs rpertoires, ou sous diffrents noms, de plusieurs exemplaires dun chier de rfrence. Une premire solution consiste recopier physiquement le chier aux diffrents endroits ou sous les diffrents noms. Mais cela a deux inconvnients majeurs : - dune part, si ce chier est commun plusieurs utilisateurs ou applications, il est indispensable, chaque fois quune modication simpose, de retoucher successivement les N copies dj faites ; - dautre part, la place occupe au total est proportionnelle au nombre dexemplaires ncessaires. La solution consiste faire des liens plutt que des copies : il existe alors un seul exemplaire physique du corps du chier (contenant les donnes), et plusieurs rfrences pointant toutes vers cet unique corps. La cration dun lien se fait avec une syntaxe identique une copie classique : pour une copie : cp ancien nouveau pour un lien : ln ancien nouveau ou bien ln -s ancien nouveau Il y a deux faons de crer un lien, car il existe en fait deux types de liens : - les liens physiques - les liens symboliques
1.5.4.1. Les liens physiques

Pour comprendre ce quest un lien physique, il faut savoir quun chier UNIX est compos de deux parties principales : le corps, qui contient les donnes proprement dites;
linode, qui contient les informations sur le chier lui-mme : droits, propritaire, type, date I.5.4. de modication, etc... Voil ce quon peut imaginer trouver dans le rpertoire jef aprs avoir lanc la commande cp fic1 fic2, partir dun chier fic1 dj existant.
jef/ bin/
rfrence
FIC1 12657
FIC2 8754
inode
corps
Crer un lien physique, cest crer une deuxime rfrence, dans le mme rpertoire, ou dans un autre, pointant sur une inode d un chier dj existant. Voil le rsultat de la commande ln fic1 fic2, partir du chier fic1 dj existant :
jef/ bin/
rfrence
FIC1
FIC2
inode
12657
corps
Dans le cas ci-dessus, les deux rfrences jouent exactement le mme rle, la premire nayant aucune caractristique supplmentaire par rapport la seconde (cest encore vrai sil y N liens sur un chier, au lieu de deux comme ici). cration du lien On vient de voir que la commande qui permet de crer un lien physique, appel nouveau, et pointant sur le chier ancien dj existant est : ln ancien nouveau page 28 - Guide du KornShell sous UNIX
I.5.4.
Exemple : $ date >ancien $ ls -l * -rw-r--r-- 1 logis users $ ln ancien nouveau $ ls -l * -rw-r--r-- 2 logis users -rw-r--r-- 2 logis users $ echo >nouveau $ ls -l * -rw-r--r-- 2 logis users -rw-r--r-- 2 logis users
32 Jul 3 15:26 ancien 32 Jul 3 15:26 ancien 32 Jul 3 15:26 nouveau 1 Jul 3 15:27 ancien 1 Jul 3 15:27 nouveau
nombre de liens sur le chier
Vous remarquerez que les deux chiers, une fois le lien fait, ont tout en commun, sauf la rfrence (le nom) : toute modication apporte un des deux chiers est reporte sur lautre. Il nest pas possible par exemple, que ces deux chiers lis aient des propritaires diffrents, ou des droits diffrents. La commande ls -l indique le nombre de liens physiques qui pointent sur le corps dun chier donn (voir lexemple ci-dessus). Avant la commande de cration du lien, le chier ancien possdait un lien sur son corps. Aprs, on voit quil existe deux liens sur le corps duquel pointent les deux chiers ancien et nouveau. Remarque: il est possible de lier des chiers depuis des rpertoires diffrents. Il existe cependant des restrictions qui sont indiques un peu plus loin. suppression du lien $ ls -l * -rw-r--r-- 2 logis users 1 Jul 3 15:27 ancien -rw-r--r-- 2 logis users 1 Jul 3 15:27 nouveau $ rm ancien $ ls -l * -rw-r--r-- 1 logis users 1 Jul 3 15:27 nouveau $
Chaque rfrence ayant un rle quivalent, on peut supprimer nimporte laquelle (nimporte lequel des chiers lis) sans toucher aux autres. Ce nest que lorsquon supprime la dernire rfrence que le corps du chier est supprim aussi. La suppression dun lien physique se fait comme pour un chier normal, avec la commande rm.
petit exercice distrayant Dterminer partir du rsultat de la commande ls -l1 donn ci-dessous le nombre de sousrpertoires prsents dans le rpertoire manuel_shell : $ ls -ld manuel_shell drwxr-xr-x 4 logis users 1024 Apr 24 12:15 manuel_shell $
I.5.4.
correction (pour les feignants) Les rpertoires constituent un arbre ; ils sont chans les uns aux autres par lintermdiaire des deux sous-rpertoires : . et .., que lon retrouve dans tout rpertoire, mme vide. Ces deux rpertoires gnriques sont en fait des liens : .. est un lien sur le rpertoire de niveau suprieur (cd .. permet de remonter dun cran vers la racine / ), et . un lien sur le rpertoire courant. A la cration dun rpertoire (par mkdir par exemple), celui-ci est li deux fois. Or chaque fois que lon rajoute un sous-rpertoire, on rajoute par la mme occasion un lien .. sur le rpertoire courant. Donc, on a la relation suivante : nombre de sous-rpertoires = nombre de liens sur le rpertoire courant - 2 Ici, on voit que le nombre de liens est 4 ; donc le nombre de sous-rpertoires doit tre 2. : $ ls -l manuel_shell total 6 drwxr-xr-x 3 logis users 2048 Jul 3 13:54 exemples drwxr-xr-x 2 logis users 1024 Apr 24 12:48 perf $
gagn ! Attention : Il nest pas possible de faire des liens physiques sur des rpertoires... cest une manipulation qui est rserve au systme pour grer les arborescences, mais qui nest pas accessible aux utilisateurs.
1. la commande ls -l rpertoire donne des informations sur le contenu de rpertoire, alors que la commande ls -ld rpertoire donne les informations sur le rpertoire (ou dfaut le chier) lui-mme.
I.5.4.
Inconvnients dun lien physique La rfrence,linode et le corps dun chier sont des entits qui sont toujours runies ensemble sur la mme unit de disque, voire la mme partition de disque. Or, la totalit de larborescence logique que vous pouvez accder est le plus souvent dcoupe en plusieurs sous-arborescences, lies chacune une unit de disque, ou une partition. Il nest donc pas possible de lier des chiers en les localisant dans deux rpertoires appartenant des disques ou partitions diffrents. voir $ ln ancien /tmp/nouveau ln: different file system $
On a essay de lier le chier ancien qui se trouve sur le disque utilisateur, avec un que lon voudrait placer dans /tmp qui se trouve (ici) sur le disque systme : impossible. Il nest pas possible de faire un lien physique sur un rpertoire. Avantage Si vous dplacez par la commande mv un des chiers lis, (dans la limite du disque ou de la partition) tous les liens restent intacts.
1.5.4.2. Les liens symboliques

Plutt que de dupliquer la rfrence, la cration du lien symbolique va consister crer un tout petit chier dun type spcial, et dont le contenu (la partie donnes) correspond la localisation (absolue ou relative) du chier auquel il est li. cration du lien La commande de cration du lien symbolique nouveau pointant sur le chier ancien est : ln -s ancien nouveau $ ls -l total 2 -rw-r--r-- 1 logis users 1 Jul 3 15:27 ancien $ ln -s ancien nouveau $ ls -l total 4 -rw-r--r-- 1 logis users 1 Jul 3 15:27 ancien lrwxr-xr-x 1 logis users 6 Jul 3 17:35 nouveau -> ancien $
Ici, on reconnat le lien symbolique au caractre l qui prcde les droits, et au nom du chier I.5.4. sur lequel il pointe qui indiqu en n de ligne.
jef/
ancien nouveau
lecture ou criture
bin/
ancien
voir voir
Tant quon nessaie pas de lire son contenu, un lien symbolique se comporte peu prs comme un chier standard : on peut par exemple modier son propritaire. Par contre, ds quon tente dy lire ou crire, ou de changer ses droits daccs, on accde en fait au donnes, ou linode du chier dont il a enregistr le nom (ou le chemin, sil pointe sur un chier dun autre rpertoire). Un accs au contenu dun lien symbolique ncessite pour le systme deux accs successifs : - le premier, pour lire sur quel chier pointe le lien ; - le second, pour accder au chier point, et lire ses donnes. Remarquez donc que pour lire le contenu de nouveau, il faut avoir les droits en lecture dessus (pour pouvoir lire le chemin vers lequel il pointe), puis ensuite les droits sur le chier point (cest dire ancien, pour pouvoir lire les donnes quil contient). suppression du lien Le chier initial (qui contient rellement les donnes) nest absolument pas touch de quelque manire que ce soit lorsquon dclare un lien symbolique pointant sur lui. Ce qui veut dire que si le chier initial est dtruit ou dplac, alors quil existait un lien symbolique pointant sur lui, le lien pointe maintenant sur RIEN ! Par contre, si on lance la commande rm sur le lien symbolique, seul le lien est perdu ; le chier sur lequel il pointait nest pas concern.
I.5.4.
Une tentative de lecture dun lien symbolique pointant sur un chier inexistant provoque le message : No such file or directory
jef/
ancien nouveau
ancien
jef/
rm ancien
nouveau
ancien
lecture ou criture
RIEN
lecture ou criture
Inconvnients Un lien symbolique augmente le temps daccs au donnes : le systme de chiers doit faire une premire lecture dans le lien pour connatre le chemin du chier contenant les donnes ; puis un deuxime accs vers le chier de donnes lui-mme. Si le chier sur lequel pointe le lien symbolique est dplac ou supprim, le lien continue de pointer vers un chier inexistant : il faut le dtruire et le reconstruire. Avantages Le problme de disque physique ou de partition napparait pas ici ; on peut faire un lien symbolique sur tout chier de larborescence. Il est possible de faire des liens symboliques sur des rpertoires la commande ls -l permet de savoir clairement vers quel chier pointe le lien. Si le chier ancien est supprim puis recr ensuite sous le mme nom au mme endroit, (par une procdure automatique, ou lors dune monte de niveau logicielle par exemple), le lien est toujours valide.
Pour les deux types de liens, vous trouverez dans le chapitre sur les cas types des exemples de commandes permettant de lister tous les liens qui pointent vers un chier donn : voir page 174
Description : Interprtation dune commande shell
I.6. Interprtation dune commande shell

Une ligne shell comprend gnralement un certain nombre de symboles et de caractres spciaux. Linterprteur va les valuer, puis les remplacer par les chanes de caractres correspondantes, en fonction de certaines rgles que nous allons dtailler. Pour bien valuer ce que votre ligne va devenir une fois interprte, il est bon dimaginer la dmarche du shell lorsquil manipule votre ligne. On peut considrer que la transformation se fait par passes, en seffectuant dans lordre qui suit : 1 2 3.1 3.2 4 5 6 7 8 9 Interprter les sparateurs et sparer les champs Isoler les chanes de caractres encadres par des quotes Remplacer les variables par leur contenu Excuter les commandes encadres par des anti-quotes ou la squence $() et les remplacer par leur rsultat Isoler les chanes de caractres encadres par des double-quotes Remplacer les caractres spciaux (*, [], ?, ~ , etc...) par leur valeur Reprer les squences () ou {} Positionner certains paramtres en fonction des caractres spciaux ; | & && || Mettre en place les redirections Localiser les commandes lmentaires (alias, fonctions, path)
I.6.1.
Ltape 3 est dcompose en deux sous-niveaux quivalents car les rsultats respectifs de ces deux sous-niveaux ne peuvent pas tre utiliss lun par lautre (en quelque sorte, les deux transformations sont faites en parallle). Evidemment, il existe des cas particuliers qui namliorent pas vraiment la simplicit de lalgorithme donne ci-dessus ; vous pouvez toujours vous reporter au manuel des commandes UNIX (section 1) sur le ksh, section Specials commands, pour les dtailler.
I.6.1. Etape 1 : Interprtation des sparateurs

Comme dans le cas dune commande simple, une commande shell est dcoupe en paquets qui seront valus un un. Couramment, les sparateurs de champs (ou paquets) sont les caractres <espace> et <tabulation>. En fait, ces sparateurs sont placs dans la variable IFS de lenvironnement, et rien nempche de modier son contenu pour que le shell travaille avec dautres sparateurs. En n dvaluation de la ligne, tout ce qui est accol sans sparateur forme un champ ; ainsi pour concatner plusieurs chanes, il suft de les mettre bout bout.
I.6.2.
I.6.2. Etape 2 : Le caractre spcial quote

Toute chane encadre par des caractres quote est prise telle quelle et nest pas transforme. Aucun des symboles du shell ni des caractres spciaux nest valu.La chane contenue (y compris les espaces, tabulations, etc..) constituera un champ de la commande qui sera lance. Ceci explique lexemple suivant :
$ ls $ ls toto1.c toto2.c toto_base.c tutu tutu toto1.c toto2.c toto_base.c $ ls toto1.c toto2.c $ echo toto[^_].c toto1.c toto2.c toto1.c toto2.c not found $ ls toto1.c toto2.c toto1.c toto2.c
Lorsque les noms des deux chiers sont placs entre quotes, lensemble, y compris lespace entre les deux noms forme un seul champ, qui est donc valu par la commande UNIX ls ; or, il nexiste pas dans le rpertoire de chier dont le nom est : toto1.c<espace>toto2.c ; la commande choue. Attention : Il nest pas possible de placer un caractre quote lintrieur dune chane ellemme dnie par des quotes. Pour faire perdre au caractre quote sa signication particulire, on peut le protger par le caractre \, ou bien le placer lui mme lintrieur dune chane encadre par des double-quotes (!!).
I.6.3. Etape 3 : Les variables et le caractre spcial anti-quote ou $() 1.6.3.1. Etape 3.1 : Les variables
Les variables du shell sont composes de lettres de lalphabet, majuscules ou minuscules (plus le caractre soulign : _), et de chiffres, sauf en premire position ; par dfaut, elles ont toutes le type : chane de caractres.
Si le nom de la variable nest constitu que de chiffres, son contenu est un des paramtres fourni au programme en cours lors de son dmarrage. ($0 est le nom du programme en cours, $1 le premier argument fourni lappel du programme en cours, $3 le troisime et ${10}1 le dixime : voir les variables prpositionnes page 38.
1. $10 nest pas le contenu du 10me paramtre, mais le contenu du premier paramtre suivi dun zro. Voir plus loin la signication des { } dans les noms de variable.
Pour affecter une variable, on la fait suivre, sans sparateur, du signe gal et dun champ (la I.6.3. chane voulue). Pour utiliser une variable (la lire), on fait prcder son nom du caractre $
$ ls $ tutu=deux trois toto1.c toto2.c toto_base.c tutu $ echo $toto $tutu toto $ echo un deux trois toto toto[^_].c toto1.c toto2.c
$ toto=un
On voit ci-dessus que le champ avec lequel on affecte la variable peut tre compos grce aux quotes, ou de la mme faon avec des double-quotes, quon dcrit plus loin page 42. Pour concatner le contenu de plusieurs variables, il suft de les accoler entre elles ; de la mme manire, pour concatner le contenu dune variable et une chane xe, il suft de les accoler.
$ ls $ s2=Shell toto1.c toto2.c toto_base.c tutu $ echo $s1$s2 $ echo KornShell toto[^_].c $ toto2.c toto1.c echo Korn$s2
KornShell $ echo $s1-$s2 Korn-Shell
$ s1=Korn
Mais dans ce cas, il peut exister des ambiguts sur le nom de la variable (o nit le nom de la variable et o commence la chane xe?), sauf si la chane xe commence par un caractre autre que ceux autoriss pour les noms de variables.
I.6.3.
Pour lever lambigut, si ncessaire, on encadre alors le nom de la variable par des accolades { }, toujours prcdes du caractre $.
$ s1=Korn
$ ls $ echo $s1Shell toto1.c toto2.c toto_base.c tutu $ echo ${s1}Shell $ echo toto[^_].c KornShell toto1.c toto2.c
Dans lexemple ci-dessus, la commande echo $s1Shell ne donne rien car le shell essaie de fournir le contenu de la variable dont le nom est s1Shell, qui nexiste pas. Une commande du shell (la commande set) permet de choisir si une tentative de lecture dune variable inexistante doit provoquer un message derreur ou non ; ici, il ny a pas de message derreur. Cela peut tre pratique, mais aussi la cause de disfonctionnement apparemment incomprhensible, si une faute de frappe sest glisse dans votre programme (oubli du caractre $ devant un nom de variable !). Environnement export Pour quune variable soit place dans lenvironnement export1, on utilise la commande export : export nom_de_variable On peut raliser laffectation en mme temps : export nom_de_variable=valeur Tableaux Il est possible de dnir des tableaux une dimension de la manire suivante : nom_du_tableau[indice1]=<champ1> nom_du_tableau[indice2]=<champ2> etc.. ou de cette faon : set +A nom_du_tableau <champ1> <champ2> ... auquel cas le tableau nom_du_tableau est initialis dans lordre avec les paramtres fournis. (voir la commande set au chapitre qui est consacr aux commandes du shell)
1. cest dire lenvironnement vu automatiquement par tout processus au moment de sa naissance
Pour lire un lment du tableau toto, on utilise la syntaxe suivante : ${toto[<indice>]}
I.6.3.
$ toto=ksh $ ls $ toto[1]=Korn toto1.c toto2.c toto_base.c tutu $ toto[2]=Shell $ echo toto[^_].c $ i=1 toto1.c toto2.c ${toto[$i]} $ echo Korn $ echo $toto[1] ksh[1]
La dernire commande montre bien que la syntaxe du shell est parfois peu orthodoxe ! ($toto[1] nest pas considr comme le premier lment du tableau toto, mais comme le contenu de la variable toto accol avec la chane littrale [1]) Il nest pas possible dexporter des tableaux entiers : vous narriverez qu exporter le premier lment du tableau en utilisant la commande export. Variables prpositionnes Lorsque le shell courant ou un programme en shell dmarre, son environnement contient un certain nombre de variables qui sont positionnes dynamiquement, et dont le contenu, pour les principales, est le suivant : $0 le nom du programme shell en cours. $1, ..${N} les N paramtres passs au programme (au shell) lors de son appel. $# le nombre de paramtres passs lappel du programme shell (non compris le paramtre $0) $* la liste des paramtres passs lappel du programme shell (non compris le paramtre $0) $$ le numro de processus courant (il y a un numro unique par processus sur la machine) $PPID le numro du processus parent du processus courant (de ce shell) $RANDOM un nombre alatoire, entre 0 et 32767 (change chaque lecture) $IFS la liste des sparateurs de champs dans une ligne du shell (par dfaut <espace> et <tabulation>) $HOME votre rpertoire principal $PWD le rpertoire courant la liste des rpertoires o le shell est susceptible de trouver les commandes $PATH1 lmentaires excuter. Cette variable est toujours positionne dans les
1. voir aussi le paragraphe sur le path page 58
I.6.3.
chiers prole (/etc/profile et .profile) au moment du dmarrage, mais nest pas, en fait, modie dynamiquement par la suite. $SECONDS le contenu initial de la variable SECONDS plus le nombre de secondes coules depuis sa dernire affectation. Si la variable na jamais t affecte, elle napparait pas. $LINENO le numro de la ligne dans le programme ou la fonction en cours $PS1 votre prompt (ce qui safche aprs chaque ligne de commande en mode intractif) $? le code derreur de la dernire commande excute. Oprateurs sur les variables. Il existe de nombreux oprateurs que lon peut appliquer lorsquon lit une variable. Voici les plus courant : ${#toto} la longueur du contenu de la variable toto (Par la suite, on dsignera par un pattern,ou expression gnrique1, cest dire une suite de caractres ventuellement spciaux qui reprsente un ensemble de chanes correspondantes. Par exemple, toto* est un pattern, qui reprsente toutes les chanes de caractres commenant par toto et suivies par nimporte quoi.) ${toto#}le contenu de la variable toto sans son dbut si celui-ci correspond au pattern. ${toto##} la mme chose que prcdemment, mais la plus grande partie possible est supprime. ${toto%}le contenu de la variable toto sans sa n si celle-ci correspond au pattern
1. Voir page 70
${toto%%} la mme chose que prcdemment, mais la plus grande partie possible I.6.3. est supprime.
$ ls $ toto=/users/petrus/logis/truc.def $ toto2.c toto_base.c tutu toto1.cecho ${#toto} 28 $ echo toto[^_].c $ echo ${toto#*/} toto1.c toto2.c users/petrus/logis/truc.def
$ echo ${toto##*/} truc.def $ echo ${toto%.def} /users/petrus/logis/truc $ echo ${toto%.*} /users/petrus/logis/truc $ echo ${toto%pouet} /users/petrus/logis/truc.def $ echo ${toto%ru*} /users/petrus/logis/t $ echo ${toto%%ru*} /users/pet
Dans lexemple ci-dessus, on utilise souvent pour former le pattern le caractre * , qui est un caractre spcial signiant : < une chane comprenant nimporte quel nombre de nimporte quel caractre1>. De plus, il est possible de placer le pattern dans une variable, et de dcomposer le pattern en plusieurs lments:: $ toto=/users/petrus/logis/truc.def $ pattern=ru* $ echo ${toto%%$pattern} /users/pet $ pattern=ru $ expand=* $ echo ${toto%%${pattern}${expand}} /users/pet $
1. Voir page 70
I.6.3.
et, toujours plus fort, dimbriquer les substitutions: $ toto=/users/petrus/logis/truc.def $ pattern1=rubis $ pattern2=bis $ expand=* $ echo ${toto%%${pattern1%$pattern2}$expand} /users/pet $
1.6.3.2. Etape 3.2 : Le caractre spcial anti-quote ou $( )

Lorsquune chane est encadre par des anti-quotes ou par la squence $( ), elle est considre comme une commande, et la squence est remplace par son rsultat (sortie standard de la commande) une fois excute. Cependant, les tapes vues au-dessus ne sont pas rvalues : la chane est excute telle quelle ce niveau dinterprtation, en fonction des tapes 4 et suivantes.
$ toto1.c toto2.c toto_base.c tutu ls toto1.c toto2.c toto_base.c tutu echo $(ls) $(echo $ $echo toto[^_].c $PWD) toto1.c toto2.c toto_base.c tutu $PWD toto1.c toto2.c
$ ls
Si on dcompose linterprtation de la ligne donne en exemple ci-dessus, - la chane $PWD est encadre par des quotes, elle est donc protge (tape 2) ; - $(ls) est remplac par le rsultat de la commande ls, (tape 3) soit : toto1.c toto2.c toto_base.c tutu - $(echo $PWD) est remplac (tape 3) par le rsultat de la commande echo sur la chane littrale $PWD (puisque la chane $PWD a t protge) ; A la n de cette tape, la ligne se prsente donc sous la forme suivante : echo toto1.c toto2.c toto_base.c tutu $PWD Comme ltape de transformation des variables nest faite quune fois, $PWD nest pas value ce niveau (nous sommes ltape 4 ou plus), et on obtient le rsultat indiqu.
Il est possible de faire des redirections, pour rcuprer un message derreur, par exemple :
I.6.4.
$ ls $ ls toto1.c toto2.c toto_base.c tutu $ toto1.ctoto[^_].c echo toto2.c toto_base.c tutu $ res=$(ls truc) toto1.c toto2.c ; echo $res
truc not found $ res=$(ls truc 2>&1) ; echo $res truc not found $
Si on dcompose linterprtation de la premire ligne donne en exemple ci-dessus, - la variable res est affecte avec la sortie standard de la commande ls truc, cest dire rien puisque le chier truc nexiste pas dans le rpertoire courant. La ligne vide qui apparait est le rsultat de la commande echo $res, puisque la variable res est vide. On remarque cependant que le message truc not found apparait : cela vient du fait que la sortie derreur de la commande ls truc est hrite du shell, cest donc la console. Si on dcompose la deuxime ligne donne en exemple, on constate que la seule diffrence vient de la redirection : la variable res est affecte avec la sortie standard de la commande ls truc, mais aussi avec sa sortie derreur ; le message derreur truc not found nest donc plus envoy vers la console, mais dans la variable res (qui est ensuite afche).
I.6.4. Etape 4 : Le caractre spcial double-quote "

La chane de caractres comprise entre deux double-quotes formera un champ de la commande lmentaire qui sera lance, de la mme faon que pour les chanes encadres par des quotes simples. La diffrence avec le caractre simple quote est qu cette tape, les transformations des symboles de variables, et squence de $() ont dj t values. Par contre, les caractres spciaux * ~ [] etc.. (voir tape 5) perdent leur signication sils sont placs entre double-quotes. On encadrera donc de double-quotes des chanes qui contiennent des variables, $(), etc... que le shell doit valuer, et de simples quotes les chanes qui ne doivent pas tre values. Les chanes encadres de double-quotes peuvent tre concatnes entre elles ou avec une autre chane en les accolant ; mme si elles contiennent des sparateurs, elles seront considres comme un champ unique lors de lappel nal de la commande lmentaire.
I.6.5.
Un caractre quote lintrieur dune chane encadre par des doubles-quotes perd sa signication spciale ; linverse est vrai galement. Pour placer le caractre littral (passif) doublequote dans une chane elle-mme encadre par des double-quotes, on peut le protger par un \.
$ echo "" $ echo " " $ echo "$PWD $(pwd) $PWD" /tmp /tmp /tmp $ echo "~ *" ~ * $ echo ~ * /users/logis toto1.c toto2.c tutu $ echo " $RANDOM"===="12 34"56 31079====12 3456
On peut vrier sur les exemples ci-dessus le rle des double-quotes. En particulier, le 3me echo encadre son argument entre double-quotes : cela veut qu lintrieur, le simple-quote perd sa signication, mais que les variables sont remplaces par leur valeur; cest bien ce qui se passe pour le $PWD en bout de ligne.
I.6.5. Etape 5 : Les caractres spciaux * [] ? ~ \

Lorsquon dsigne un nom de chier, il est souvent peu pratique dindiquer le nom ou le chemin complet. Il existe des caractres spciaux qui permettent de dsigner symboliquement des caractres, ou des parties du nom de chiers. Le shell recherche alors dans les rpertoires dsigns, ou par dfaut dans le rpertoire courant le ou les chiers dont le nom est conforme la description spcie. Attention : on imagine souvent que cest la commande qui interprte ces caractres ; en fait, il sont transforms par le shell avant que la commande ne soit lance. Voici la correspondance : caractre * : nimporte quelle partie ou totalit du nom dun chier ou de rpertoire. Si plusieurs occurrences sont possibles, la chane contenant * (galement nomme pouet) est tendue autant de fois.
Exemple : $ ls toto1.c toto2.c toto_base.c tutu $ echo toto*.c toto1.c toto2.c toto_base.c
I.6.5.
caractre ? :
un caractre quelconque. Exemple :
$ ls ls toto1.ctoto2.c toto_base.c tutu tutu toto1.c toto2.c toto_base.c $ echo toto?.c echo toto?.c toto1.ctoto2.c toto1.c toto2.c
squence [ ] :
un caractre parmi ceux spcis entre les crochets. [12] : le caractre 1 ou 2 [1-5] : le caractre 1 ou 2 ou 3 ou 4 ou 5 [A-] : un caractre parmi la liste des caractres ascii de rang suprieur ou gal A. [!1-5] : un caractre parmi les caractres ascii qui ne font pas partie de lensemble des caractres de 1 5. Exemple :
$ ls $ ls toto1.c toto2.c toto_base.c toto1.c toto2.c toto_base.c tutu tutu $ echo toto[^_].c $ echo toto[!_].c toto1.c toto2.c toto1.c toto2.c
caractre ~ :
le chemin absolu du rpertoire courant au moment de votre login (home directory). Si ~ prcde un nom dutilisateur, alors cela reprsente le chemin absolu du home directory de lutilisateur.
I.6.5.
Exemple :
$ echo ~logis/.profile /users/petrus/logis/.profile
Le symbole / est le sparateur entre les diffrents noms de rpertoires qui composent un chemin de chier (un chemin absolu commence par /, alors quun chemin relatif dbute dans le rpertoire courant par un terme non prcd de /). Attention : Crer un chier dont le nom comprend un caractre spcial (un de ceux vu cidessus) namne en gnral que des ennuis : il est trs difcile de dsigner ce chier par la suite. caractre \ : Si vous voulez rendre inactif un des caractres spciaux du shell, il faut le faire prcder du caractre \. la squence \* vaut * et non pas la liste des chiers du rpertoire courant. la squence \\ vaut \ la squence \ vaut et nest pas le symbole du dbut dune chane protge. Il est possible de composer les caractres ci-dessus pour obtenir des expressions plus complexes1. Si on note expression une suite de caractres, ventuellement spciaux, alors : ?(expression) ?(expression1|expression2|...) remplace zro ou une occurrence des expressions fournies. *(expression) *(expression1|expression2|...) remplace zro ou plusieurs occurrences des expressions. +(expression) +(expression1|expression2|...) remplace une ou plusieurs occurrences des expressions. @(expression) @(expression1|expression2|...) remplace une occurrence exactement dune des expressions fournies.
caractre / :
1. appeles aussi expressions gnriques: voir page 70
I.6.6. !(expression) !(expression1|expression2|...) est remplac par toutes les occurrences possibles sauf celles correspondant aux expressions fournies. Exemples :
$ ls essai1 essai1.c toto1.c toto_base.c essai1.0 essai2 toto22.c tyty $ echo !(toto*) essai1 essai1.0 essai1.c essai2 tyty $ echo +(to)* toto1.c toto22.c toto_base.c $ echo essai1?(.c) essai1 essai1.c $ echo *+([0-9]).c essai1.c toto1.c toto22.c $
Il est rappel que les expressions sont values en fonction des noms de chiers qui existent dans le rpertoire courant si lexpression ne contient pas de caractre /, et dans le rpertoire indiqu sinon.
I.6.6. Etape 6 : les squences () et {}

Il est possible de fabriquer une macro-commande partir de plusieurs commandes lmentaires ; une macro-commande est encadre par des () ou des {}, et se comporte comme une commande normale : par exemple, on peut rediriger ses entres et ses sorties. Si on dsire que la macro-commande sexcute dans lenvironnement courant, on utilisera les {} ; si on prfre quelle sxcute dans un environnement spar, on utilisera les () ; en pratique, cest cette conguration qui est la plus intressante.
I.6.7.
Exemple :
$ pwd; (cd /usr/pub/; pwd ; ls); pwd /tmp /usr/pub ascii eqnchar /tmp $ pwd; { cd /usr/pub/; pwd ; ls ; }; pwd /tmp /usr/pub ascii eqnchar /usr/pub $
Vous constatez que le changement de rpertoire est local pour une macro-commande encadre par des (), alors quelle continue garder son effet lorsquon utilise des {}. De plus, la syntaxe de la macro-commande est un peu plus rigide si on utilise des {} : il faut isoler les { } entre des espaces et faire suivre chaque commande par un point virgule.
I.6.7. Etape 7 : Les caractres spciaux ; | && & |

Ces caractres (ou squences) dnissent la n dune commande lmentaire. On peut donc composer une ligne shell par plusieurs commandes lmentaires spares par un de ces caractres ; suivant le choix du caractre, lintraction entre les deux commandes contigus sera diffrente.
1.6.7.1. caractre ;
Ce caractre peut tre considr comme un oprateur squentiel : les deux commandes contigus sont excutes lune aprs lautre (la seconde dmarre lorsque la premire est termine). Leffet est le mme si on place les deux commandes lune aprs lautre sur deux lignes conscutives du programme.
1.6.7.2. squence ||
Dans le cas o deux commandes sont spares par des ||, la deuxime nest excute que si la premire choue, cest dire si son code de retour est diffrent de zro.1
1. Des exemples sont visibles au chapitre sur les expressions conditionnelles. Voir page 71
1.6.7.3. squence &&

Dans le cas o deux commandes sont spares par des &&, la deuxime nest excute que si la premire russit, cest dire si son code de retour est gal zro1.
I.6.7.
1.6.7.4. caractre &

Ce caractre peut tre considr comme un oprateur asynchrone (parallle) ; le shell nattend pas la n de la commande prcdent le & pour lancer celle qui le suit. Par exemple, si la ligne de commande shell est de la forme : cmd1 & cmd2 & cmd3 alors, la commande cmd1 est excute, puis sans attendre la n de cmd1, la commande cmd2 est lance, de mme la commande cmd3. Lorsque la commande cmd3 est nie, on passe la ligne suivante du programme. Autre exemple : cmd1 & cmd2 & la commande cmd1 est lance, puis sans attendre, la commande cmd2 aussi ; et comme elle est suivie du &, le shell passe linterprtation de la ligne de programme suivante, sans attendre la n de cmd1 ni cmd2. Le fait de lancer une commande de manire asynchrone avec un & ncessite de crer un processus indpendant ; ce que nous avons dj vu sur lhritage est valable ici aussi (en particulier pour les redirections) ; nous verrons quil est possible depuis un shell interactif de garder un certain contrle sur ce types de processus, appels aussi jobs. Il arrive quon nomme arrire plan ou background la classe de processus lancs de manire asynchrone, en opposition avec lavant plan ou foreground qui est la classe des processus sexcutant squenciellement dans un programme.
1.6.7.5. le caractre | ou pipe

Cet oprateur permet de lancer les deux commandes contigus en reliant la sortie standard (descripteur 1) de la premire commande dans lentre standard (descripteur 0) de la seconde. Le nom pipe donne lide dun tuyau par lequel les donnes transitent dune commande lautre. Il est possible ainsi de chaner autant de commandes que lon dsire, le seul impratif tant que chacune des commandes lise les donnes dentre sur le descripteur 0 et fournisse les rsultats sur le descripteur 1 (ventuellement aprs une redirection).
Les deux ou N commandes relies par des pipes sont dmarres simultanment dans autant de processus diffrents et disparaissent une une lorsque leur entre standard est vide. Le shell passe
1. Voir les expressions conditionnelles: page 71
I.6.8.
lexcution de la commande ou de la ligne de programme suivante lorsque toutes les commandes lies par des pipes ont disparu. $ ls $ ls toto1.c toto2.c toto_base.c tutu toto1.c toto2.c sort $ ls | grep toto | toto_base.c tutu toto1.c toto[^_].c $ echo toto2.c toto2.c toto1.c toto_base.c
Lexemple ci-dessus est bien compliqu pour le rsultat escompt, mais il montre comment il est possible de combiner plusieurs commande UNIX pour en constituer une plus puissante ou mieux adapte au besoin courant. voir $ ls toto1.c toto2.c toto_base.c tutu $ ls toto tata | wc -l toto not found tata not found 0 $ ls toto tata 2>&1 | wc -l 2
Dans ce cas, on met jour leffet des redirections : - la premire ligne de lexemple consiste piper une commande qui gnre des messages derreur dans une autre (wc -l compte les lignes de lentre standard). Comme les chiers toto et tata nexistent pas dans le rpertoire courant, la commande ls ne fournit rien sur la sortie standard, et deux messages apparaissent sur la sortie derreur, un pour le chier toto et un pour le chier tata ; ayant hrit des descripteurs du shell intractif, ces messages sont envoys sur la console et la commande wc -l indique un nombre nul de lignes provenant de lentre standard. - la deuxime ligne est identique, ceci prs que, grce la redirection, les messages derreur sont redirigs dans lentre standard du pipe et que ces deux lignes sont bien comptes par la commande wc -l Il est possible de piper entre elles des commandes UNIX, des commandes internes du shell, mais aussi des macro-commandes, comme elles ont t dcrites au chapitre prcdent.
I.6.8. Etape 8 : Les redirections

Nous avons dj vu dans le chapitre sur les chiers ce qutaient les redirections : une association entre un descripteur et un nom de chier physique.
Voici les diffrentes manires de rediriger les sorties et les entres dune commande, sachant I.6.8. quon peut en combiner plusieurs sur une commande donne : digit>name : le descripteur de numro digit est associ avec le chier physique de nom name ouvert en criture. Si le chier nexistait pas auparavant, il est cr. Si digit est omis, la valeur 1 est prise par dfaut (sortie standard). digit>>name : la mme chose, mais le chier est ouvert en mode ajout (on crit la n du chier existant). digit<name : la mme chose, mais cette fois le chier name est ouvert en lecture ; il doit exister. Si digit est omis, la valeur 0 est prise par dfaut (entre standard). digit<<word : associe le descripteur digit avec le chier du programme en cours, partir de la ligne qui suit cette dclaration jusqu la ligne prcdant celle dbutant par le terme word. Cela permet dinclure dans des programmes des zones de texte utiliser ou recopier dans dautres chiers au moment de lexcution. La commande redirige de cette manire utilise comme entre standard les lignes qui suivent immdiatement dans le programme, jusquau terme word. d1>&d2 : le descripteur d1 est associ en mode criture avec le chier dj associ au descripteur d2. Si d1 est omis, la valeur 1 est prise par dfaut ; d2 ne peut pas tre omis. Le chier dj associ au descripteur d2 doit avoir t ouvert lui aussi en criture. d1>>&d2 : mme chose mais d1 est associ en mode ajout. d1<&d2 : mme chose, mais d1 est associ en mode lecture ; si d1 est omis, la valeur 0 est prise par dfaut ; le chier associ d2 doit avoir t ouvert en lecture. Les redirections ci-dessus sont places la n dune commande et ne prennent effet que sur la commande qui prcde juste. Pour modier une fois pour toutes la redirection dun descripteur lintrieur dun programme shell, on utilise la syntaxe suivante : exec <redirection> la redirection <redirection> qui prend une des formes vues ci- dessus est applique au shell en cours et donc par hritage, toutes les commandes que celui-ci lancera. Si vous tapez par exemple exec >/tmp/toto, vous naurez plus sur votre console que le prompt et les messages derreur qui vont safcher ; le rsultat de toutes vos commandes (comme ls, pwd, etc...) sera envoy dans le chier /tmp/toto. Evidemment, cest peu intressant de travailler de cette manire, par contre, on peut vouloir rediriger tous les messages derreur des commandes dun programme vers un chier particulier : dans ce cas, il suft de placer en dbut de programme une commande du type : exec 2>liste_erreurs page 50 - Guide du KornShell sous UNIX
I.6.8.
Il existe dautres types de combinaison, mais qui sont bien moins usits. Par exemple, il est possible de faire une redirection en mode entre-sortie (digit<>name), mais le mode sortie est en fait un mode ajout, ce qui nest pas vraiment intressant. De toute faon, la quasi-totalit des commandes UNIX nacceptent pas davoir des descripteurs dentre et de sortie qui pointent sur un mme chier : on sera presque toujours oblig dutiliser un chier intermdiaire pour simuler le mode entre-sortie sur un chier ouvert. Un bon usage des redirections ci-dessus permet dj beaucoup de manipulations dentressorties. Exemple 1 : plus de trois descripteurs pour une commande $ more essai1 while read -u4 ligne do print -u6 $ligne done $ essai1 4<toto1.c essai1[3]: print: bad file unit number essai1[3]: print: bad file unit number $ essai1 4<toto1.c 6>&1 ceci est la 1ere ligne du fichier toto1.c ceci est la 2eme 1igne du fichier toto1.c $
Pour cet exemple, on a crit un petit programme shell (dont le chier se nomme essai1), qui lit des lignes sur le descripteur 4 et les recopie sur le descripteur 6. La premire commande lance (essai1 4<toto1.c) provoque une erreur ; notez que le numro indiqu dans le message derreur est li la ligne o sest produite lerreur, et na rien voir avec le descripteur 41.
1. voir le chapitre sur les messages derreur. page 205
On peut suivre ltat des redirections sur le schma suivant : ksh (login) ksh (ligne de commande) toto1.c essai1 0 1 1 2 2 2 0 0 1
I.6.8.
read print
6
Le script essai1 est reli lors de son lancement au shell de la ligne de commande par les entre-sorties standard, puisque aucune redirection sur un des descripteurs 0, 1 ou 2 na t spcie ; Cependant, essai1, de par sa construction, lit ses donnes sur le descripteur 4, vers lequel la redirection 4<toto1.c fait pointer un chier en lecture, et crit sur le descripteur 6, qui nest associ aucun chier physique : cest lerreur dtecte.
I.6.8.
Voici maintenant le schma correspondant la deuxime commande, o les redirections en entre et en sortie sont spcies : ksh (login) ksh (ligne de commande) toto1.c essai1 0 1 1 2 2 2 0 0 1
read print
6
Le programme essai1 peut maintenant crire sur le descripteur 6 qui est reli par la redirection 6>&1 au mme chier physique que le descripteur 1, cest dire la console. Dans le cas ci-dessus, on voit que le shell a associ, comme toujours, les trois descripteurs standards 0, 1 et 2 au programme essai1 (en plus des descripteurs 4 et 6), sans savoir sils seraient utiliss ou non. Ici, rien nempcherait de rajouter dans le programme essai1 des commandes echo par exemple, qui criraient sur le descripteur 1 (donc vers la console) : les cinq descripteurs sont disponibles. Exemple 2 : les redirections avec une macro-commande. voir
voir
$ pwd /users/logis/doc/manuell_shell/exemples $ ( cd /usr/pub ; ls >&4 ) 4>resu_ls $ pwd /users/logis/doc/manuell_shell/exemples $ more resu_ls ascii eqnchar $
La macro-commande ci-dessus permet dans le shell courant de crer un environnement spar dans lequel sont excutes les commandes cd /usr/pub et ls, cette Guide du KornShell sous UNIX - page 53
commande envoyant son rsultat sur le descripteur 4. Le shell redirige le descripteur 4 I.6.8. de la macro-commande vers le chier physique resu_ls. Voici le schma correspondant : ksh (login) ksh (ligne de commande) resu_ls 4 0 1 1 2 2 2 0 (macro-commande) ls 0 1
On sintresse ici uniquement aux redirections de la commande ls, la commande cd ayant conserv les entres-sorties standard. On constate que la macro-commande se comporte au vu des redirections exactement de la mme manire quun script et quil est possible de multiplier le nombre de descripteurs. En conclusion, on peut mettre sur une ligne autant de redirections que la commande concerne manipule de descripteurs, et vice-versa. Les commandes standards dUNIX en utilisent gnralement trois comme on la dj dit ; mais ces exemples montrent quil est possible den crer avec plus de trois. La limite de 20 1 qui a t indique prcdemment est le nombre maximum de chiers ouverts quun processus peut possder ; cest une valeur paramtrable par ladministrateur de la station.
1.
voir la manipulation des chiers page 21
I.6.9.
I.6.9. Etape 9 : La localisation de la commande

A ce stade, on peut imaginer la ligne initiale une fois que toutes les transformations correspondant aux tapes 1 8 qui prcdent ont t ralises. Le premier champ de la ligne est alors normalement la commande.
1.6.9.1. Les alias

Un alias est une correspondance entre deux chanes de caractres. On peut renommer ou crer de nouvelles commandes en utilisant des alias. La premire chane est quelconque (mais sans sparateur) ; la deuxime est la chane (qui peut contenir des sparateurs) avec laquelle on remplace la premire si celle ci est trouve dans la ligne de commande. Pour dclarer un alias, on excute la commande : alias ancien_terme=chaine_de_remplacement Chaque fois que le premier champ dune ligne est gal ancien_terme, il est remplac de manire littrale par la chane chaine_de_remplacement. La transformation nest faite quune seule fois (pas de manire rcursive). De plus comme la transformation est faite de manire littrale, il nest pas possible de spcier dans un alias des noms de variables ou des paramtres de position ($1, $2,...). Lalias une fois dclar est valable dans lenvironnement courant, et dans les macro-commandes de type () si on spcie loption -x au moment de la dclaration. Si on dsire quun alias soit valable dans tous les programmes et les interprteurs shell dmarrs, il faut placer sa dclaration dans le chier de conguration du shell1. Pour consulter la liste des alias valables dans le shell courant, taper la commande : alias et pour supprimer un alias existant dans le shell courant : unalias ancien_terme Si un alias a le mme nom quune commande interne au shell ou non, il la remplace.
1.6.9.2. Les fonctions

Une fonction est une macro-commande nomme, que lon peut appeler avec des paramtres. Une fois dclare, une fonction devient en quelque sorte une nouvelle commande du shell, quil est possible de manipuler comme les autres. Pour dclarer une fonction, on procde de la manire suivante : .kshrc : voir le paragraphe qui se rapporte ce sujet page 163 Guide du KornShell sous UNIX - page 55
1.
nom_de_la_fonction() macro-commande La macro-commande1 peut tre de type () si on dsire que la fonction sexcute dans un environnement protg, ou {} pour quelle sexcute dans lenvironnement courant, ce qui est en pratique le plus intressant. Dans les deux cas, les paramtres de position $1, $2, $... sont utilisables dans une fonction et correspondent aux diffrents paramtres dappel. Les problmes de visibilit et de dclaration dans le shell sont identiques ceux indiqus pour les alias. Pour lister les fonctions dclares dans le shell courant, vous pouvez taper la commande : typeset -f Les alias sont valus avant les fonctions, ce qui veut dire que le rsultat dun alias peut tre un nom de fonction dclar dans le shell courant. Lexemple suivant est une combinaison dalias avec des fonctions, et permet de modier le fonctionnement de la commande interne cd de manire ce que le rpertoire courant et le nom de la station sur laquelle vous travaillez safchent sur le bandeau qui surmonte les fentres de type hpterm (valables sur les stations hp). Il faut placer ces lignes dans votre chier .kshrc pour que chacun de vos shells intractifs dmarr dans une fentre positionne cette combinaison. Si vous travaillez aussi avec dautres types
I.6.9.
1. Voir le paragraphe sur les macro-commandes: page 46
I.6.9.
de fentres ou de terminaux, il vous faudra rajouter un test, ou lancer le chier de conguration la main uniquement dans les fentres hpterm. voir # # affichage sur une fenetre hpterm du repertoire # et de la machine courante # export HOSTNAME=$(hostname) xname() { _title="$*" echo "\033&f0k${#_title}D${_title}\c"; echo "\033&f-1k${#_title}D${_title}\c; } cdx() { unalias cd cd $1; alias cd=cdx xname $HOSTNAME [pwd=$PWD] } alias cd=cdx set +u cd
voir
Explications : On dclare ici deux fonctions xname et cdx, et un alias qui remplace la commande interne cd. xname() : cette fonction afche sur le bandeau dune fentre hpterm les arguments qui lui ont t passs lappel. Les deux commandes echo envoient sur la sortie standard, cest dire la console hpterm des suites de caractres (<escape>&f0k...) qui indiquent une action particulire effectuer, et qui ne sont pas afchs. Dans le premier cas, cela consiste modier le bandeau de la fentre si elle est ouverte, dans le deuxime son nom si elle est iconie. cdx() : Cette fonction excute la commande cd standard, puis appelle la fonction xname pour mettre jour le bandeau de la fentre. Pour viter une boucle innie, il faut supprimer lalias pour excuter rellement la commande cd, puis le remettre pour reprendre la conguration initiale. (En effet, cd est alias en cdx, elle mme fonction faisant appel la commande cd...) A ce niveau, on a dclar deux fonctions ; pour mettre en pratique notre nouvelle fonctionnalit de la commande cd, on rajoute un alias qui remplace la commande tape cd en cdx. A partir de ce moment, lorsque on tape cd nom_de_repertoire, le rpertoire courant est chang et son nom apparait sur le bandeau de la fentre. Guide du KornShell sous UNIX - page 57
Si vous prfrez avoir une commande cdx dont le nom reste distinct de la commande I.6.9. interne cd, il suft de supprimer partout les alias et unalias cd. La commande set +u rajoute la n supprime les messages derreur lorsque on essaie dutiliser une variable non positionne : cest le cas ici lorsquon tape la commande cd, pour revenir dans le rpertoire principal ; la commande cd nayant pas dargument, la fonction cdx nen a pas non plus, et la variable $1 nest pas positionne, ce qui provoque en tant normal un message derreur du shell. Une fois dclare, la fonction xname() par exemple, peut tre utilise seule, comme une commande normale, ainsi que nimporte quelle fonction ou alias existant dans le shell courant. Ainsi, en tapant : xname essais le bandeau de la fentre sintitule essais (ainsi que licne une fois la fentre referme). Attention : Si une fonction a le mme nom quune commande lmentaire UNIX, elle la remplace ; ce nest pas le cas si elle a le mme nom quun alias ou une commande interne du shell qui gardent leur prsance.
1.6.9.3. Le path
La variable $PATH contient la liste des rpertoires dans lesquels le shell recherche le chier excutable correspondant au nom dune commande lmentaire. Une fois toutes les transformations (vues ci-dessus) effectues, le premier champ de la commande doit tre : une commande interne : auquel cas elle est excute avec comme arguments les champs qui la suivent ; autre chose : auquel cas le premier champ est considr comme un nom de chier excutable. Si le premier champ comporte un caractre /, le shell va chercher le chier dans le rpertoire indiqu ; Si le premier champ ne comporte pas de caractre /, le shell va chercher dans un des rpertoires qui apparaissent dans la variable $PATH le chier excutable. Le contenu de la variable $PATH a la forme suivante : rpertoire1 : rpertoire2 : rpertoire3 : etc... Cette variable est toujours positionne par dfaut avec une liste minimale ; mais si vous faites appel des commandes particulires, ou que vous avez cres vous-mme, il suft de rajouter les rpertoires correspondant de la faon suivante : PATH=$PATH : rpertoire1 : rpertoire2 : rpertoire3 : etc...
I.6.9.
La recherche est effectue dans lordre dapparition ; ce qui veut dire que si deux chiers excutables portent le mme nom, mais sont placs dans deux rpertoires diffrents, celui qui sera lanc est celui qui apparait dans le rpertoire cit en premier dans la liste du PATH. Parmi les rpertoires, vous pouvez mettre le rpertoire courant qui est symbolis par le caractre point ; il existe deux philosophies lorsquon veut utiliser des commandes dont lexcutable se trouve dans le rpertoire courant : PATH=$PATH : . dans ce cas, une commande dont le chier excutable est plac dans le rpertoire courant est excute uniquement si un chier (une commande) de mme nom nexiste pas dans les rpertoires placs avant dans la liste ; PATH=. : $PATH dans ce cas, cest le contraire : les commandes dont lexcutable se trouve dans le rpertoire courant sont excutes en priorit. Cette dclaration peut provoquer des confusions : une commande na plus la mme signication suivant le rpertoire dans lequel on la tape. Remarque : seuls sont considrs dans les rpertoires donns dans $PATH les chiers de type excutable, cest dire dont les droits apparaissent en x (lors dune commande ls -l) pour la classe de lutilisateur.
Description : Le contrle des processus
I.7. Le contrle des processus

I.7.1. La commande ps
La commande ps permet de lister les processus actifs : voir $ ps -fu logis UID PID PPID C STIME TTY TIME COMMAND logis 25723 24887 4 11:44:21 ttyu0 0:00 ps -fu logis logis 24887 24886 1 07:53:50 ttyu0 0:02 -ksh
I.7.1.
voir
Utilis de cette manire, la commande ps afche la liste des processus appartenant lutilisateur logis : UID : cest le propritaire du processus. Toute action sur ce processus ne peut tre faite que par lui ou par le super-utilisateur. PID : cest le numro du processus correspondant. Un processus est toujours rattach un numro unique sur une machine. PPID : cest le numro du processus pre (celui qui a lanc le processus PID) ; si le processus pre meurt avant son ls, ce dernier est alors rattach au processus 1. (PPID vaut 1) On peut ainsi suivre toute larborescence des processus en chanant les valeurs PID et PPID. STIME : date de dmarrage du processus TIME : temps dexcution en minutes et secondes CPU depuis le dmarrage du processus COMMAND : intitul de la commande correspondant au processus TTY : le nom de la console laquelle le processus est rattach. Tous les processus lancs en intractif sont rattachs une console ou un terminal : si Xwindows fonctionne, le terminal correspond alors une fentre, sinon cest la console elle-mme. Sauf manipulation particulire, un processus est rattach la mme console que son pre. En contrepartie, les processus lancs en mode batch (par des commandes comme at ou batch) et les processus serveurs (les daemons) ne sont rattachs aucun terminal1. Le fait quun processus soit rattach un terminal indique quil est susceptible de ragir certains vnements lis aux terminaux, cest dire, certaines frappes de caractres de contrle, les dconnexions, etc... Ces indications sont sufsantes dans la trs large majorit des cas pour grer ses processus.
1. le nom de la console est alors remplac par un ? ou un -
I.7.2.
La commande ps est intressante utiliser de deux manires : ps -fu nom_utilisateur pour connatre les processus attachs un utilisateur particulier ; ps -ef pour connatre tous les processus tournant sur le systme. Sachez quun processus tel le serveur X11 (intitul : X : 0) qui est trs gourmand et tourne souvent toute la journe, utilise par jour une dizaine de minutes de temps CPU, que certains processus comme les compilations ada atteignent quelques minutes dutilisation, mais que la grande majorit des processus ne dpassent pas quelques secondes dans leur vie.
I.7.2. Le contrle des processus par le clavier

Une fentre X11 est en fait une mulation dune console cran-clavier. Donc, la plupart des fonctionnalits dune console sont supports : on peut avoir le nom de la console en tapant la commande tty (lcran nu sans utilisation dX11 sappelle console), et ses caractristiques (type dmulation, cho, ...) par la commande stty -a . Une des caractristiques dune console est de possder des squences de caractres qui permettent dintragir par lintermdiaire de signaux avec les processus qui lui sont rattachs : en gnral, la squence est compose de la touche <control> et dune autre touche. Pour associer une squence de caractres avec un signal, on utilise la commande stty qui congure la console ou le pseudo-terminal si on travaille avec X11. Voici les squences couramment utilises et leur fonctionnalit : <control>C cette squence est la plus connue : son effet consiste envoyer un signal SIGINT dinterruption au processus en avant-plan (foreground), autrement dit celui qui est en cours dexcution. Dans la majorit des cas, lenvoi du signal SIGINT provoque la mort du processus en cours et le shell rend la main en afchant le prompt. Pour positionner la squence : stty intr ^c <control>Z cette squence envoie un signal SIGTSTP au processus en avant-plan ; ce signal suspend lexcution du processus dans ltat en cours et rend la main au shell. Grce aux commandes fg et bg, il est possible de reprendre lexcution du processus, soit en avant-plan, soit en arrire plan. Pour positionner la squence : stty susp ^z
<control>S cette squence suspend le dlement de lafchage lcran, mais le I.7.3. processus continue de sexcuter (sauf si le buffer dafchage est plein). Pour positionner : stty stop ^s <control>Q permet de reprendre le dlement de lcran. Pour positionner : stty start ^q <control>D spcie au processus dont lentre standard est la console que la n de chier est atteinte. On tape cette squence par exemple aprs avoir fourni lentre standard dune commande le contenu du buffer de la souris. Pour positionner : stty eof ^d <erase> spcie au shell la squence qui correspond leffacement dun caractre sur la ligne de commande. Pour positionner : stty erase <backspace> ou stty erase <delete> suivant le type de votre clavier. Les squences qui sont indiques ici sont celles qui sont positionnes normalement lorsque vous vous connectez une console ou un pseudo-terminal (les commandes stty sont places dans le chier .profile de conguration de login), mais rien ne vous empche de les modier, ou de les complter si votre conguration est incomplte.
I.7.3. La commande jobs

Grce au shell intractif, il vous est possible de lancer des commandes (cest dire des processus) en avant-plan (foreground), ou en arrire-plan (background) si vous rajoutez loprateur &. Comme il ne peut y avoir pour un shell intractif quun processus en avant-plan la fois, on comprend quil est facile de le grer, en particulier grce aux caractres de contrle vus ci-dessus. Par contre, il est possible davoir simultanment plusieurs processus en arrire-plan, lancs partir du mme shell intractif. Dans ce cas, on contrle ces processus en obtenant leur identiant et leur tat par la commande jobs, puis ventuellement en modiant leur tat par les commandes fg, bg ou kill.
I.7.4.
Exemple : voir $ sleep 1000 <control>Z [1] + Stopped sleep 1000 $ sleep 2000 & [2] 2012 $ jobs [2] + Running sleep 2000 & [1] - Stopped sleep 1000 $
Voici la description de la manipulation ralise : 1/ un processus est lanc en avant-plan (sleep 1000) 2/ on tape la squence de contrle <control>Z1, le processus est stopp, et le shell donne un message indiquant : [1] : le descripteur du processus ; chaque processus gr ainsi par le shell possde un numro qui permet de le dsigner par la suite. Stopped : ltat du processus. On peut avoir stopped qui indique que le processus est en sommeil, running qui indique que le processus sexcute, done qui indique que le processus vient de se terminer, et terminated quon vient de le tuer. Dans les autres cas, le type dtat est li au type du signal que le processus vient de recevoir. sleep 1000 : lintitul de la commande correspondant au processus. 3/ un deuxime processus est lanc (sleep 2000), mais celui-ci directement en arrire-plan. Le shell indique : [2] : le descripteur du nouveau processus 2012 : lidenticateur de processus, tel quil apparait si vous listez les processus avec la commande ps. Attention, pas de confusion : le descripteur est un numro propre au shell, alors que lidenticateur est le numro qui dnit de manire unique le processus dans le systme. 4/ on tape la commande jobs qui liste les processus en arrire-plan contrls par le shell.
I.7.4. Les commandes fg et bg

La commande fg %id permet de faire passer un job didenticateur id de ltat stopped ou running en arrire-plan vers ltat running de lavant-plan.
1. pour que la frappe du <control>Z ait un effet, il faut que la console ait t congure pour y ragir ; voir le paragraphe qui prcde.
La commande bg %id permet de faire passer un job didenticateur id de ltat stopped en I.7.4. arrire-plan vers ltat running de larrire-plan. Schmatisation :
bg
stopped arrire-plan running arrire-plan
suspend fg <control>Z
running avant-plan
fg
La commande suspend nexiste pas en standard, mais on peut la dnir avec un alias : alias suspend=kill -STOP Nous allons voir leffet de la commande kill au paragraphe suivant. Exemple : voir $ sleep 1000 <control>Z [1] + Stopped sleep 1000 $ bg %1 [1] sleep 1000& $ suspend %1 [1] + Stopped (signal) sleep 1000 $ bg %1 [1] sleep 1000& $ fg %1 sleep 1000
Voici les diffrentes tapes : 1/ cration du processus sleep 1000 en avant-plan 2/ frappe de la squence <control>Z qui fait passer le processus vers larrire-plan en mode stopped
I.7.5.
3/ la commande bg fait passer le processus de ltat stopped vers ltat running, toujours en arrire-plan. 4/ la commande suspend refait passer le processus en mode stopped 5/ bg repasse le processus en mode running de larrire-plan 6/ la commande fg fait passer le processus en mode running de larrire-plan vers lavant-plan Remarque : La commande jobs liste les processus, prcds dun caractre + ou -. Une commande bg ou fg sans paramtre sappliquera au seul processus indiqu avec un + (en gnral, cest le dernier cr ou manipul).
I.7.5. La commande kill

Contrairement son nom, cette commande nest pas destine rellement tuer un processus, mais plutt lui envoyer un signal. Il existe un certain nombre de signaux que lont peut mettre vers un processus : voir voir $ kill -l 1) HUP 2) INT 3) QUIT 4) ILL 5) TRAP 6) IOT 7) EMT 8) FPE 9) KILL 10) BUS 11) SEGV 12) SYS 13) PIPE 14) ALRM 15) TERM 16) USR1 17) USR2 18) CHLD 19) PWR 20) VTALR 21) PROF 22) IO 23) WINDO 24) STOP 25) TSTP 26) CONT 27) TTIN 28) TTOU 29) URG 30) LOST
On peut rajouter deux autres signaux qui sont ignors par le shell en temps normal : 0) EXIT qui est dclench en n de programme shell 35) DEBUG qui est dclench aprs chaque commande Pour envoyer un signal un processus, on utilise la commande suivante : kill -signal No_process
signal est soit le numro, soit la dsignation du signal telle quelle apparait ci-dessus. I.7.5. Si -signal est omis, cest -TERM qui est pris par dfaut. No_process vaut :
%descripteur, avec descripteur gal un numro de descripteur donn par le shell, ou bien directement : identificateur, avec identificateur gal au numro didentication du processus, tel quil apparait avec la commande ps. Le processus qui reoit un signal peut ragir de trois manires diffrentes : a/ le processus a t congur lors de son dmarrage pour ignorer le signal donn : aucun effet b/ le processus a t congur lors de son dmarrage pour attraper le signal donn : la rception du signal, le processus excute un droutement vers la fonction associe. c/ rien na t prvu : le processus meurt. Dans ce cas, le processus peut tre tu par nimporte quel signal. Un cas particulier existe avec le signal 9 (KILL) : il est impossible de lignorer ou de lattraper : on est donc sr de tuer un processus en lui envoyant un signal KILL. Un processus peut recevoir un signal dun autre processus, (cest ce qui se passe par exemple quand vous tapez la commande kill), de la console (si vous tapez une squence de contrle) ou du hardware (Bus error par exemple) Exemple : voir $ sleep 1000 & [1] 3800 $ sleep 2000 & [2] 3801 $ jobs [2] + Running sleep [1] - Running sleep $ kill -9 %1 [1] - Killed sleep $ kill -INT 3801 [2] + Interrupt sleep $ jobs $
2000 & 1000 & 1000 & 2000 &
On a utilis la premire fois le signal 9 (KILL), et la deuxime le signal 2 (INT), qui correspond au signal mis par la console lorsque vous tapez la squence <control>C : cest une bonne faon pour essayer de tuer un processus proprement : sur rception dun signal 9, un processus meurt immdiatement, alors que si le signal est INT par exemple, une commande bien crite peut toujours se drouter pour supprimer ses chiers ou objets temporaires avant de sarrter. page 66 - Guide du KornShell sous UNIX
I.7.5.
Il est possible dattraper ou dignorer des signaux depuis un programme shell ; un exemple dutilisation est donn plus loin1 grce la commande shell trap. Vous pouvez trouver une signication succincte des signaux utiliss sur votre machine en explorant le chier /usr/include/sys/signal.h.
1. voir chapitre page 86
I.7.5.
Les Expressions
II.
II. Les Expressions
Les Expressions : Les expressions du KornShell
II.1. Les expressions du KornShell

II.1.1. Lexpression arithmtique
Les indices de tableau, les variables de type entier (voir typeset) peuvent tre affectes avec une expression arithmtique. Lexpression arithmtique est une combinaison de signes arithmtiques + - * / , de nom de variables de type entier et de parenthses : Exemples : val*10+1 (val * val) * 2 On rajoute les simple-quotes lorsquon utilise des parenthses, ou que lon a plac des espaces entre les termes de lexpression. Il nest pas ncessaire de mettre devant les noms de variable le symbole $. Utilisation : (on note <exp_arith> une expression arithmtique quelconque) affectation dune variable de type entier ou indexation dun tableau variable=<exp_arith> echo ${tableau[<exp_arith>]} affectation dune variable de type non-entier ou obtention du rsultat variable=$((<exp_arith>)) echo $((<exp_arith>))
II.1.1.
II.1.2. Lexpression gnrique

On a vu, en tudiant la transformation dune ligne de commande1, la faon dont les caractres spciaux *,[],?, etc..., pouvaient correspondre des parties de nom de chiers prsents dans un rpertoire donn. Une chane de caractres qui comprend ce type de caractres spciaux est appele expression gnrique, car elle dsigne en fait une classe de noms. Lorsque une expression gnrique est employe la place dun nom de chier sur la ligne de commande, le shell instancie la classe correspondante avec tous les chiers dont le nom sadapte la classe dnie. Mais on peut aussi utiliser des expressions gnriques dans des tests lorsque vous utilisez les commandes if, case ou while. Dans ce cas, la partie droite du test classique : if [ valeur1 = valeur2 ] ...
1. Voir page 43
II.1.3.
peut tre une expression gnrique, condition dutiliser loprateur [[ ]] au lieu des [ ] classiques. Exemple1 : $ [ toto = toto ] && print ok ok $ [ toto = t* ] && print ok $ [[ toto = t* ]] && print ok ok $ [[ toto = a* ]] && print ok $
Lutilisation avec if , case ou while se fait de la mme faon : vous aurez des exemples dans les paragraphes ddis ces commandes : voir page 82 Voici un rappel de la combinaison des expressions: ?(expression) ?(expression1|expression2|...) remplace zro ou une occurrence des expressions fournies. *(expression) *(expression1|expression2|...) remplace zro ou plusieurs occurrences des expressions. +(expression) +(expression1|expression2|...) remplace une ou plusieurs occurrences des expressions. @(expression) @(expression1|expression2|...) remplace une occurrence exactement dune des expressions fournies. !(expression) !(expression1|expression2|...) est remplac par toutes les occurrences possibles sauf celles correspondant aux expressions fournies.
II.1.3. Lexpression conditionnelle

Une expression conditionnelle est principalement utilise avec la commande if pour les structures conditionnelles et la commande while pour les boucles. Son valuation donne un rsultat vrai ( = 0 ) ou faux ( <> 0 ).
1. Voir page 74 le dtail de loprateur && (et logique entre deux commandes)
Pour pouvoir donner des exemples pratiques, on va tout dabord dsigner partir dici une II.1.3. expression conditionnelle par <exp_cond>, et loprateur [] : [<exp_cond>] loprateur [ ] est une commande applique sur lexpression <exp_cond> et dont le seul effet est de renvoyer un code de retour gal zro si lexpression est vraie ou diffrent de zro si lexpression est fausse. De plus, nous allons aussi utiliser les squences && et || dont voici un rappel du fonctionnement : cmd1 && cmd2 la commande cmd2 est lance si le code de retour de la commande cmd1 est zro (commande russie) cmd1 || cmd2 la commande cmd2 est lance uniquement si cmd1 a choue (code de retour non nul) Exemple : $ [ $ [ ok $ [ ok $ [ $ 0 = 0 ] || print ok 0 = 1 ] || print ok 1 = 1 ] && print ok 1 = 2 ] && print ok
Ici, la premire commande correspond lvaluation de lexpression conditionnelle, grce loprateur [ ] , et la seconde est la commande print ok. Une expression conditionnelle <exp_cond> peut prendre une des formes suivantes : un test sur un chier : -a chier vrai si le chier chier existe -d chier vrai si chier est un rpertoire ... Il y en a comme a une bonne vingtaine1. $ ls -l travail -rw-r--r-- 1 logis users 143 Jun 22 10:41 travail $ [ -a travail ] && print ok ok $ [ ! -a absent ] && print inconnu inconnu
1. on peut avoir la liste complte dans la section 1 du manuel de rfrence UNIX, la rubrique ksh, ou avec le manuel en ligne, en tapant: man ksh
II.1.3.
un test sur une variable ou chane de caractres : -z chane vrai si la longueur de chane est nulle -n chane vrai si la longueur de chane est non nulle $ chaine="coucou" $ [ -n "$chaine" ] && print non vide non vide $ [ -z "" ] && print vide vide $
un test entre deux chiers : c1 -nt c2 vrai si c1 a t modi plus rcemment que c2 ... $ ls -l travail tutu -rw-r--r-- 1 logis users 143 Jun 22 10:41 travail -rw-r--r-- 1 logis users 78 Apr 15 15:34 tutu $ [ travail -nt tutu ] && print travail est plus jeune travail est plus jeune $
un test entre deux variables ou chanes de caractres chane = <expression_gnrique> $ reply=oui $ [ "$reply" = oui ] && print oui oui $ [ "$reply" = [Oo]* ] && print oui $ [[ "$reply" = [Oo]* ]] && print oui oui $ reply=OUI $ [[ "$reply" = [Oo]* ]] && print oui oui $
Remarques : lutilisation dune expression gnrique ncessite dutiliser des [[ ]] la place des [ ] simples. Dautre part, la prsence du caractre = dans le test force <chane> le type des arguments fournis; les tests sur des valeurs numriques se font avec les oprateurs -ne, -ge, etc.. au lieu du =.
un test entre deux expressions arithmtiques. $ [ 3*2+1 -eq 1+2*3 ] && print ok ok $ [ 3 *2+1 -eq 1+2*3 ] && print ok ksh: *2+1: unknown test operator $ [ 3 * (2 + 1) -gt 1+2*3 ] && print ok ok $
II.1.3.
Voici les diffrents tests arithmtiques : -eq galit -ne diffrent -gt suprieur -lt -ge -le infrieur suprieur ou gal infrieur ou gal
On peut combiner plusieurs expressions conditionnelles pour en fabriquer une plus complexe (pour la suite, on note <exp_cond> une expression vue ci-dessus) : <exp_cond1> && <exp_cond2> cette expression est vraie si les deux sont vraies <exp_cond1> || <exp_cond2> cette expression est vraie si lune des deux est vraie ! <exp_cond> cette expression est vrai si <exp_cond> est fausse Exemples : $ echo $reply OUI $ [ ! 3 -eq 2 -a "$reply" = OUI ] && print ok ok $ [ ! 3 -eq 2 && "$reply" = OUI ] && print ok ksh: test: ] missing $ [ ! 3 -eq 2 \&\& "$reply" = OUI ] && print ok ok $ [ ! 3 -eq 2 && "$reply" = OUI ] && print ok ok $ [[ ! 3 -eq 2 && "$reply" = OUI ]] && print ok ok $
II.1.3.
Vous remarquerez quil peut y avoir sur la mme ligne, comme ici, des oprateurs && lis des commandes, et des oprateurs && lis des expressions. Pour ne pas que le shell confonde les deux, il faut : - protger par des \, des "", ou des les oprateurs && destins aux expressions1, ou alors les faire gurer dans des [[ ]] plutt que des []. - ne pas protger les oprateurs && destins aux commandes. La remarque vaut aussi pour loprateur ||. Pour plus de deux expressions, on groupe avec des parenthses () : $ [ 3 -eq 2*3 && \( "1" = "2" || 3 -eq 3 ) ] && print ok $ [[ 3 -eq 3 && ( "1" = "2" || 3 -eq 3 ) ]] && print ok ok $
Le problme de protection des ( ) est le mme que pour les && ou les ||.
1. lire dans le paragraphe sur linterprtation des lignes de commande la faon dont les caractres spciaux du shell conservent (ou perdent) leur signication particulire : voir page 35
Les Expressions : Les expressions rgulires
II.2. Les expressions rgulires

Les expressions rgulires sont pour les commandes Unix lquivalent des expressions gnriques pour le shell : ce sont des chanes de caractres (ventuellement spciaux) qui reprsentent des classes de chanes de caractres. A une expression rgulire donne, on peut associer un certain nombre de chanes de caractres, qui ont toutes des caractristiques communes : celles de lexpression rgulire. Les commandes qui utilisent les expressions rgulires (appeles aussi pattern) sont : - vi , ex - ed, sed, expr - grep, (ou egrep) - awk - etc... Elles permettent pour ces commandes de reprer dans du texte des suites de caractres ayant des caractristiques particulires. Attention1 : - Bien que se rapprochant beaucoup de la syntaxe des expressions gnriques reconnues par le shell, les expressions rgulires ont une syntaxe spcique, et qui nest pas compatible. - Il existe des expressions rgulires de base, et des expressions rgulires tendues, qui sont un sur-ensemble des premires (!!) . Les premires sont acceptes par toutes les commandes indiques ci-dessus, et les secondes uniquement par le awk, et le grep avec loption -E, (ou le egrep).
II.2.1.
voir
voir
La rfrence peut tre trouve pour les deux types dexpressions dans le manuel(5) UNIX, au terme regexp, ou dans le manuel en ligne (taper : man regexp) ; Les explications gnrales qui suivent en sont tires.
II.2.1. Expressions rgulires de base ( ER )

caractres ordinaires Un caractre ordinaire est nimporte lequel des caractres alphanumriques, except les caractres spciaux qui suivent ci-dessous, et le caractre <newline>. Un caractre ordinaire correspond sa propre valeur. ER correspond a a
1. tout ce qui est complexe est encore beaucoup trop simple.
II.2.1.
% % abc abc \b b un caractre ordinaire prcd dun \ conserve sa signication, except (, ), {, }, et les chiffres de 1 9 (voir ci-dessous, ainsi qu la commande sed) caractres spciaux les caractres spciaux ont une signication particulire, (quils perdent si on les fait prcder dun \ ) : \ ER \. \\ \$ => annule la signication particulire du caractre suivant (sauf pour (, ), {, }, et les chiffres de 1 9) correspond . \ $
----------------------------------------------------------------------------------. => peut prendre nimporte quelle valeur de caractre ER correspond . a ou b ou c ... ou A ou B ...ou 1 ou 2 ... .. aa ou ab ou Aa ou A1 ou ... ----------------------------------------------------------------------------------[] => peut prendre nimporte quelle valeur de caractre parmi ceux spcis entre les crochets ER correspond [abd9] a ou b ou d ou 9 [a-z] a ou b ou c ... ou z [a-z_1] un caractre compris entre a et z comme cidessus ou alors un _ ou alors un 1 [ab][12] a1 ou a2 ou b1 ou b2 [â-z1] nimporte quel caractre sauf les caractres de a z et sauf le 1 z[ab]z zaz, ou zbz ----------------------------------------------------------------------------------* => une squence ER* correspond une chane compose de 0 ou n rptitions de lexpression rgulire ER ER correspond Guide du KornShell sous UNIX - page 77
<rien> ou a ou aa ou aaa ou aaaa ... une srie (ventuellement nulle) de a et de b dans nimporte quel ordre [ab][ab]* idem prcdent, mais la srie comporte au moins un a ou un b [âb]* une srie de nimporte quel caractre sauf a et b, dans nimporte quel ordre, ou alors <rien> z[a]*z zz ou zaz ou zaaz ou zaaaz ou ... .* <rien> ou alors une suite dun nombre quelconque de nimporte quel caractre. ----------------------------------------------------------------------------------=> une squence ÊR correspond une chane place en dbut de ligne et vriant lexpression ER ER correspond â une ligne commenant par un a ^toto une ligne commenant par toto ^[ \t]*-une ligne commenant par des <espace> ou <tabulations> rpts 0 ou n fois, suivis par -----------------------------------------------------------------------------------^ => une squence ER$ correspond une chane place en n de ligne et vriant lexpression ER ER correspond a$ une ligne nissant par un a toto$ une ligne nissant par toto [ \t]$ une ligne nissant par un <espace> ou une <tabulation> ^$ une ligne vide ^[ \t]*$ une ligne vide ou alors ne contenant que des <espace> ou <tabulation> ^.*$ la totalit de la ligne, quelque soit son contenu. ----------------------------------------------------------------------------------\{ \} => une squence ER\{m,n\} correspond une chane vriant lexpression ER, rpte au minimum m fois et au maximum n. => ER\{m,\} : il doit y avoir au minimum m occurrences de ER => ER\{m\} : il doit y avoir exactement m occurrences de ER ER correspond za\{2,4\}z zaaz ou zaaaz ou zaaaaz [A-Z]\{3\} une squence de trois majuscules conscutives. $
a* [ab]*
II.2.1.
voir voir
II.2.2.
ATTENTION: Tel quest fait le mcanisme de recherche dans les chanes, il faut se mer lorsquon crit une expression rgulire devant reconnatre un nombre exact doccurrences: Par exemple, lexpression a\{2\} est cense correspondre une chane contenant exactement 2 lettres a conscutives; et pourtant, la chane zaaaz sera reconnue. Cela est d au fait que le mcanisme considre la chane zaaaz comme un z, suivi par exactement 2 lettres a, suivi par la squence az: ce nest pas tout fait ce que lon recherchait ! Pour que la recherche soit correcte, il faut inclure dans lexpression quelque chose de reconnaissable avant et aprs la squence rpte: ici, on mettrait: za\{3\}z, qui correspond alors exactement 3 lettres a encadres par une lettre z; il ne peut plus y avoir dambigut.
II.2.2. Expressions rgulires tendues ( ERE )

Les expressions tendues reprennent les caractristiques des expressions rgulires de base ( ER ), plus les suivantes : + ? () voir => une squence ERE+ correspond une chane compose dune ou n rptitions de lexpression rgulire ERE => une squence ERE? correspond une chane compose de zro ou une rptition de lexpression rgulire ERE => une squence (EREERE) compose une expression rgulire plus complexe partir de celles lmentaires ERE correspond z(ab)?z zz ou zabz ([abc]z)\{3\} azbzcz ou azczbz ou bzazcz ou bzczaz ou czazbz ou czbzaz => une squence (ERE|ERE) compose une expression rgulire gale lune ou lautre des deux expressions lmentaires ERE correspond (a|zzz)c ac ou zzzc ([abc])\{3\} abc ou acb ou bac ou bca ou cab ou cba
II.2.2.
Exemples dutilisation de commandes
III.
III. Exemples dutilisation de commandes
Exemples dutilisation de commandes : Quelques fonctions du KornShell
III.1. Quelques fonctions du KornShell

III.1.1. cd, pwd
Les commandes cd et pwd sont des commandes internes au shell, qui, respectivement, positionnent et lisent la variable PWD dans lenvironnement courant. Pensez-y lorsque vous crez des chiers de commandes ou des macro-commandes de type (), car il y cration dun environnement spar et leffet de la commande cd sera perdu au retour, en mme temps que lenvironnement. $ cd /usr/tmp $ echo $PWD $OLDPWD /usr/tmp /users/logis/doc/manuell_shell/exemples $ pwd /usr/tmp $ cd /users/logis/doc/manuell_shell/exemples $
III.1.1.
La variable OLDPWD contient le rpertoire courant prcdant la dernire commande cd ; on peut retrouver le prcdent rpertoire en tapant cd - ; le rpertoire courant est alors afch automatiquement.
III.1.2. if
La commande if permet de crer dans les programmes des structures conditionnelles. Principe : if expression_conditionnelle then then instruction10 instruction11 ... else instruction20 instruction21 ... fi
III.1.3.
La squence else est optionnelle, et une squence if - then - else - fi ou if then - fi est considre comme une instruction, ce qui permet dimbriquer les tests ; mais attention : il devra y avoir toujours autant de if que de fi.
III.1.3. for
La commande for permet de raliser des boucles avec un nombre ditrations ni, dtermin par le nombre darguments donns au for. Attention : son fonctionnement nest pas celui habituellement rencontr dans les langages de programmation courant ! Principe : for var in para1 para2 para3 ... do instruction1 instruction2 ... done La boucle est constitu des instructions (commandes shell, fonctions, etc) situes entre le do et le done. Avant chaque excution de la boucle, la variable var est instancie avec un nouveau paramtre para, et la boucle est parcourue autant de fois quil y a de paramtres para. La squence for - do - done est considre elle-mme comme une instruction, ce qui veut dire quon peut imbriquer plusieurs boucles. $ for fichier in toto* > do > print $fichier > done toto1.c toto2.c toto_base.c $
Ici, les paramtres sont tous les noms de chiers du rpertoire courant dont le nom commence par toto, aprs transformation par le shell du terme toto*.
III.1.4. la commande point .

Un chier de commande ou un programme shell est dmarr dans un environnement spar, ce qui veut dire quun chier de conguration ne peut pas tre lanc de manire classique sur la ligne Guide du KornShell sous UNIX - page 83
de commande, puisquen n dexcution, lenvironnement local qui vient dtre positionn est III.1.5. perdu. Pour viter cela, on lance le chier de conguration par lintermdiaire de la commande point, qui conserve lenvironnement du shell courant. $ more point # positionnement dune variable variable=COUCOU_TRALALA $ echo $variable $ point $ echo $variable $ . point $ echo $variable COUCOU_TRALALA $
Si vous placez le positionnement de variables, dalias et de fonctions dans un chier nomm config_perso par exemple, vous pourrez congurer le shell avec votre conguration par la commande : ou
. config_perso . /chemin_absolu/config_perso
si le chier nest pas dans le rpertoire courant. Si vous voulez que chaque shell dmarr dans une fentre ait automatiquement cette conguration, vous pouvez mettre cette commande dans votre chier .kshrc1.
III.1.5. print
La commande print a les mme fonctionnalits que la commande echo, mais : print est interne au shell alors que echo est une commande UNIX (binaire excutable) : il est moins coteux dutiliser print que echo. print utilis avec loption -un permet dcrire directement dans le descripteur n ; vous serez oblig de manipuler les redirections pour obtenir le mme rsultat avec echo. print possdant une option, il vous sera impossible dafcher une ligne dont le premier caractre commence par un tiret : par convention, le tiret dsigne une option ; donc une ligne commenant par un tiret provoquera un message derreur du style : print : bad option(s). Par contre echo na pas doption, donc peut tout afcher.
1. Voir page 163
III.1.6.
III.1.6. set
La commande set permet de positionner certains paramtres de fonctionnement du shell ; en gnral, lorsque loption est fournie avec un moins, la caractristique est valide, avec un plus, elle est supprime. set -A tableau arg1 arg2 arg3 arg4 ... supprime la variable tableau si elle existe, puis cre un tableau nomm tableau dont les lments sont ceux fournis comme arguments. Avec +A, la variable tableau nest pas supprime en premier lieu. set -s trie les paramtres de position $0, $1, $2 etc... $ more pos_p # # donne les parametres de position avec # lesquels ce programme a ete appele et les trie. print $0,$1,$2,$3,$4 set -s print $0,$1,$2,$3,$4 $ pos_p UN deux zzzzz coucou pos_p,UN,deux,zzzzz,coucou pos_p,UN,coucou,deux,zzzzz $
set -a set -u set -v set -x
aprs lexcution de cette commande, toutes les variables affectes sont exportes. lire une variable non initialise provoque une erreur. Avec +u , une variable non initialise est gale une chane vide. la ligne qui va tre excute, avant transformation, est afche par le shell sur la sortie derreur. Pour repasser en mode normal, utiliser +v. la ligne qui va tre excute, aprs transformation, est afche par le shell sur la sortie derreur. Pour repasser en mode normal, utiliser +x.
Ces deux commandes sont intressantes dans un programme pour fournir une trace III.1.7. dexcution.
$ set -v $ set -x set -x $ exec 1>/dev/null exec 1>/dev/null + exec + 1> /dev/null $ ls * ls * + ls -FC essai1 essai2 pos_p resu_ls toto1.c toto2.c toto_base.c tutu tyty $
Dans lexemple ci-dessus, on positionne les options -v et -x pour avoir une trace de chaque commande, respectivement avant et aprs les transformations ; et pour se dbarrasser du rsultat qui importe peu ici, on redirige la sortie standard vers le chier /dev/null. Les lignes qui apparaissent avec un + sont celles gnres suite loption -x ; la copie de la commande tape (avant interprtation par le shell) est due loption -v. On voit que la commande ls * a t transforme en deux temps : - ls est devenu ls -FC : un alias existe donc vraisemblablement - * est devenu la liste des chiers dans le rpertoire courant
III.1.7. shift
shift n dcale de n rang gauche, ou dun rang si n est omis, les paramtres $1, $2, $3, etc positionn lappel dun programme shell avec les paramtres fournis. Cette commande est intressante lorsquon teste les arguments en dbut dun programme1.
III.1.8. trap
Permet dattraper un signal ou de lignorer. Cette commande doit tre place en dbut de programme shell, avant rception du premier signal possible. Pour attraper un signal : trap commande signal1 signal2 signal3 ... Sur rception dun des signaux indiqus, un droutement du programme est effectu et commande est excute. Si commande ne fait pas appel exit, le programme reprend alors lendroit o il se trouvait au moment de la rception du signal.
1. voir le chapitre sur les programmes propres page 194.
III.1.8.
commande peut tre une commande UNIX, un chier de commandes, une fonction...
Pour ignorer un signal : trap "" signal1 signal2 signal3 ... Le programme qui a fait appel cette commande nest plus sensible la rception des signaux indiqus. Pour lister les signaux attraps : trap Exemple 1 :
$ trap "print Reception du signal USR1" USR1 $ kill -USR1 $$ Reception du signal USR1 $
Les signaux USR1 et USR2 nont pas de signication particulire et sont entirement disponibles pour les utilisateurs. La variable $$ contient lidenticateur du processus courant, cest dire le shell lui-mme : le shell sest donc envoy un signal USR1 luimme et il ragit en afchant le message. Exemple 2 : Lorsque vous vous dconnectez, tous les processus lancs par le shell intractif reoivent un signal HUP, mme ceux qui sexcutent en background ce moment l : ils sont tous tus. Pour quune commande ne soit pas tue si elle sexcute et que vous vous dconnectez, vous pouvez : - la lancer par lintermdiaire de la commande nohup - si cest un programme shell, rajouter : trap "" HUP La commande nohup ne fait rien de plus que dignorer le signal HUP avant de lancer la commande que vous lui avez fournie en argument. La commande trap est trs utile dans les programmes shell qui utilisent des chiers temporaires : on peut drouter le signal INT provoqu par un appui <control>C, et supprimer proprement ces chiers avant de rendre la main1 voir le chapitre consacr aux programmes shell propres. De la mme faon, trap est intressant avec deux signaux : DEBUG qui droute aprs chaque commande
1. Voir le chapitre consacr aux programmes shell propres page 200
EXIT qui droute aprs lexcution de la dernire ligne dun programme shell: 1 #!/bin/ksh 2 # manipulation des traps 3 # 4 trap "echo FIN DU SCRIPT" EXIT 5 trap 'echo ligne $LINENO: temps: $SECONDS' DEBUG 6 # debut du programme ... 7 SECONDS=0 8 date 9 sleep 3 10 date 11 sleep 5 12 date 13 exit 0 14 ~ ~"toto" 14 lines, 192 characters
III.1.8.
$ toto ligne 7: temps: 0 Sat Jun 05 15:38:35 1993 ligne 8: temps: 0 ligne 9: temps: 3 Sat Jun 05 15:38:38 1993 ligne 10: temps: 3 ligne 11: temps: 8 Sat Jun 05 15:38:43 1993 ligne 12: temps: 8 FIN DU SCRIPT ligne 13: temps: 8 $
III.1.9.
III.1.9. typeset
La commande typeset permet de typer les variables utilises. Le principe doption avec + ou - est le mme que pour set : - pour valider, et + pour invalider. Laffectation peut tre faite en mme temps (en rajoutant =valeur juste la suite) typeset -L variable typeset -Ln variable justie gauche la variable. Si n est donn, la largeur de la variable est impose n caractres, ventuellement complte par des blancs ; sinon elle vaut la largeur lors de la premire affectation. Les blancs en dbut de champ sont ignors. Pour proter de la justication, il est ncessaire lorsquon emploie une variable justie de lencadrer avec des double-quotes. $ $ $ 1 $ 1 typeset -L8 toto toto=1 echo $toto FIN FIN echo "$toto FIN" FIN
typeset -R variable typeset -Rn variable idem prcdent, mais la justication se fait droite. typeset -Z variable typeset -Zn variable justie droite et complte avec des zros si ncessaire. typeset -ibase variable la variable est de type entier en base base. Si base est omis, la valeur par dfaut est la base 10. On peut alors crire directement (et sans espace) : variable=variable+1 pour incrmenter une variable de type entier.
En effet, seules les variables de type entier peuvent tre affectes III.1.9. directement avec des expressions arithmtiques. $ typeset -i2 val $ val=(8*4+1) ksh: syntax error: ( unexpected $ val="(8*4+1)" $ echo $val 2#100001 $ echo "(8*4+1)" (8*4+1) On voit dans lexemple qui prcde que les expressions arithmtiques ne sont values que sil y affectation dans une variable de type entier ; sinon, lexpression est prise comme une chane. Il se peut que le shell pose problme avec certains caractres de lexpression : dans ce cas, on lencadre avec des double-quotes. Lorsque la base est diffrente de 10, son indication lafchage est explicite, sous la forme suivante: base#nombre.Dans lexemple cidessus, on affecte la variable val type en entier base 2 avec la valeur 33 (8*4+1), et on obtient lors de sa lecture 2#100001, cest dire le nombre 100001 en base 2. (Voir ci-dessous comment enlever lindication de la base) typeset -r variable la variable est de type read-only : on ne peut plus la modier. typeset -u variable chaque affectation, le contenu de la variable est pass automatiquement en majuscules. typeset -l variable idem en minuscules. Il est possible de changer de type une variable dj type : $ typeset -R3 val=123456 $ echo $val 456 $ typeset -i val $ val=val*10+1 $ echo $val 4561
III.1.9.
ou de faire des conversions de type : $ typeset -u chaine="ToTo" ; echo $chaine TOTO $ typeset -l chaine ; echo $chaine toto $ typeset -i2 entier=255 ; echo $entier 2#11111111 $ typeset -i16 entier ; echo $entier 16#ff $ echo ${entier#*#} ff
pour se dbarrasser de la valeur de la base quand on veut afcher des entiers dans une base autre que 10, on peut utiliser les oprateurs sur les variables qui permettent de supprimer les premiers caractres (la base et le #) : cest la dernire commande de lexemple ci-dessus. Il est possible galement de manipuler des constantes dans une base quelconque : $ typeset -i decimal1 $ decimal1="2#101010101010" $ echo $decimal1 2#101010101010 $ typeset -i10 decimal2 $ decimal2="2#101010101010" $ echo $decimal2 2730
Ci-dessus, on constate quune variable de type entier mais sans indication de base, adopte la base de la premire valeur affecte. Par contre, si on spcie la base au dpart, une conversion est effectue automatiquement.
Une autre utilisation de typeset permet de lister les fonctions enregistres dans le shell courant : typeset -f
ou les variables de type entier : typeset -i etc ...
III.1.10.
III.1.10. unset
unset variable Cette commande permet de supprimer la variable variable de lenvironnement (export ou non).
III.1.11. wait
wait job Cette commande permet de synchroniser le shell ou programme courant avec un processus sexcutant en arrire-plan, et lanc par le shell ou le programme courant. La commande wait se bloque jusqu ce que le job soit termin, ou si job est omis, que tous les processus qui tournent en arrire-plan soient termins.
job peut prendre la forme :

%des pid avec des descripteur de processus (donn par le shell au moment du lancement) identicateur (numro du processus pour le systme, donn par ps)
Vous pouvez ainsi lancer en parallle plusieurs traitements secondaires en arrire-plan depuis votre programme principal, puis attendre leur n, avant de continuer les calculs ; dans lexemple cidessous, la macro-commande () symbolise le traitement secondaire. $ ( sleep 100 ; echo fin du process1 [1] 7181 $ ( sleep 100 ; echo fin du process2 [2] 7183 $ wait ; print "Reprise dexecution" fin du process1 fin du process2 Reprise dexecution [2] + Done ( sleep 100 ; echo fin du [1] + Done ( sleep 100 ; echo fin du $ ) & ) &
process2 ) & process1 ) &
III.1.12.
III.1.12. whence
whence -v command Indique comment le shell va interprter le terme command si celui-ci est suppos tre une commande. Dans le cas o un chier excutable correspond command, le chemin complet est donn, si command est un alias ou une fonction, whence lindique aussi. Si plusieurs possibilits existent (un terme peut correspondre la fois un alias, une fonction et plusieurs chiers excutables trouvs dans le PATH), whence ne donne que celle qui est prise en considration au moment de lexcution de command.
III.1.13. while
La commande while permet de raliser des boucles avec un nombre ditrations indtermin. Principe : while expression_conditionnelle do instruction1 instruction2 ... done Tant que lexpression est vraie, cest dire que son code de retour vaut zro, la boucle constitue des instructions comprises entre le do et le done est excute cycliquement. Le type de lexpression est celui indiqu pour la commande conditionnelle if (voir page 82). Comme cest le code de retour qui est test, rien nempche de remplacer expression_conditionnelle par une commande : tant que lexcution de la commande provoque un code de retour nul, le while continue boucler. La squence while-do-done tant considre elle-mme comme une instruction, il est possible den imbriquer plusieurs.
Exemples dutilisation de commandes : Quelques commandes UNIX
III.2. Quelques commandes UNIX

Avertissement Ce chapitre nest pas une rfrence sur lutilisation des commandes et de leurs options : il est destin uniquement en mieux matriser quelques-unes des plus courantes. Cest pourquoi il ne dispense pas de jeter un coup doeil sur le manuel de rfrence(manuel(1)) qui les dtaille de manire exhaustive.
III.2.1.
III.2.1. awk
But Travailler le contenu dun chier texte Le mode naturel de manipulation de awk consiste dcomposer la ligne courante en champs (contrairement sed qui travaille caractre par caractre). Version Attention la version du awk dont vous disposez : certaines versions sont moins riches, bien que le fonctionnement soit globalement quivalent. voir voir $ what $(whence awk) /usr/bin/awk: $Revision: 66.49 $ $
Structure du programme awk permet dcrire des programmes complets, avec structures itratives, tests, etc... Le programme est pass comme paramtre (encadr avec des quotes) awk, ou crit dans un chier dont le nom est fourni par lintermdiaire de loption -f. Exemple : awk /ACE/ { print $1, $3 } mon_fichier Dans lexemple ci-dessus, le programme fourni awk est constitu par la chane
/ACE/ { print $1, $3 } et sexcute sur mon_fichier.
III.2.1.
Structure gnrale : BEGIN{ action_begin } slection_1 { action_1 } slection_2 { action_2 } ... END{ action_end } Le fonctionnement est le suivant : - avant de commencer lire mon_fichier, awk excute action_begin - pour chaque ligne de mon_fichier, awk value successivement les slections du programme : si la slection est valide pour la ligne courante, laction correspondante est excute. Si plusieurs slections sont valides pour une ligne de mon_fichier, alors plusieurs actions (celles correspondantes) seront excutes - aprs lecture complte de mon_fichier, awk excute action_end. Structure modulaire Aucun des lments indiqu ci-dessus nest indispensable lorsquon crit un programme awk. - On peut omettre la squence BEGIN{...}, aussi bien que celle END{...}. - Si on omet slection_1, alors { action_1 } est excute pour toutes les lignes de mon_fichier. - Si on omet { action_1 }, alors les lignes pour lesquelles slection_1 est valide sont recopies in-extenso sur la sortie standard. Exemple : awk /ACE/ { print $1, $3 } mon_fichier * pas de squence BEGIN{ } * pas de squence END{ } * une slection : /ACE/ laction correspondante : { print $1, $3 } Rsultat : toutes les lignes qui contiennent la chane ACE ont leur premier et troisime champs imprims sur la sortie standard. Sparation des champs
Par dfaut, les champs sont dnis comme une suite de caractres ne comprenant ni <espace>, ni <tabulation>. Mais il possible dutiliser dautres caractres de sparation de champs que ceux par dfaut, et mme de dnir le sparateur de champs avec une expression rgulire. Pour ce faire on utilise loption -Fsparateur de la commande awk, ou alors on positionne la variable FS dans la squence BEGIN{ } du programme. Guide du KornShell sous UNIX - page 95
Exemple 1 : On considre le sparateur de champs : / $ echo "05/11/92" | > awk -F/ { print $3} 92 $
III.2.1.
Exemple 2 : On considre le sparateur de champs constitu de la chane : val= prcde ou suivie par des caractres <espace>, <tabulation>1 ou <virgule> voir $ more sep_awk val=3, val=4,val=5 110 val=2, val=5 val=3 , val= "valeur" val=6, val=9 $ awk BEGIN{ FS = "[ \t,]*val=[ \t,]*" } > { $1 = $1 ; print } sep_awk 3 4 5 110 2 5 3 "valeur" 6 9 $
On remarque que certaines lignes du chier rsultat commencent par un caractre blanc : ce sont celles qui correspondent dans le chier de dpart aux lignes dbutant par "val=". Ce terme tant le sparateur, et se trouvant en dbut de ligne, on retrouve un espace en dbut de ligne dans le chier de sortie. La commande ci-dessus revient faire une conversion du sparateur "val=" en un sparateur <espace> en sortie. Or, si aucune manipulation nest faite sur un des champs de la ligne dentre, awk ne ralise pas cette conversion, et recopie les lignes dans ltat o elles sont en entre. Cest pourquoi le petit programme awk prcdent contient linstruction "$1 = $1" qui na ici aucune utilit sinon de manipuler un champ de la ligne et donc de forcer la conversion des sparateurs.
Variables internes awk possde des variables internes positionnes dynamiquement la lecture de chacune des lignes de mon_fichier.
1. symbolis par la squence : \t
III.2.1.
Parmi les plus intressantes : NF : le nombre de champs dans la ligne NR : le numro de la ligne courante dans mon_fichier ENVIRON["var"] : le contenu de la variable shell var exporte avant appel de awk $i : le ime champ de la ligne. Il est possible de crer autant de variables que lon veut, ou de modier celles existantes dans les actions. Remarques : Si la variable A vaut 3, alors $A est le troisime champ de la ligne. De la mme faon, $NF est le dernier champ de la ligne, et $(NF-1) est lavant dernier champ de la ligne. Bien sr, il ne vous viendrait pas lide de confondre la notation : - $NF pour le shell, qui vaut le contenu de la variable shell NF, avec : - NF pour le awk, qui vaut le contenu de la variable awk NF, et avec : - $NF pour le awk, qui vaut le contenu du champ dont le numro est donn par la variable NF. Attention: dans un programme awk, toute chane de caractres non encadre par des doublequotes est considre comme tant le nom dune variable, (et si cette variable na jamais t affecte, une chane vide est renvoye lors de sa lecture).
Description dune slection La slection peut prendre principalement deux formes : Une expression rgulire : * sous la forme : /expression/ dans ce cas, toutes les lignes qui vrient lexpression rgulire expression vrient la slection. * sous la forme : $i ~ /expression/ dans ce cas, la slection est vrie si le champ i vrie lexpression rgulire expression. Exemple : $1 ~ /^[0-9]/ cette slection est vrie quand lexpression rgulire ^[0-9]1 est vrie sur le premier champ de la ligne.
1. elle signifie : le premier caractre (^) est un chiffre ([0-9])
Une relation : Avec les oprateurs < <= == != >= > Exemples : $1 == "toto" vrai si le premier champ est gal au terme toto $3 > "toto" vrai si le troisime champ est suprieur alphabtiquement au terme toto NR == 10 vrai si la variable NR est gale 10 (si le numro de la ligne courante est gal 10) Combinaison des slections On peut combiner des slections avec les oprateurs : && || ! () , ET logique OU logique NON logique association dnition dune squence de bloc : les deux slections spares par une virgule dterminent respectivement la ligne de dbut et celle de n de bloc. Toutes les lignes du bloc, y compris celle de dbut et de n sont slectionnes. Exemple : /begin/,/end/ slectionne dans le chier tous les blocs de lignes commenant par une ligne contenant "begin", et nissant par une ligne contenant "end".
III.2.1.
Exemples de slections : NF == 3 les lignes contenant exactement trois champs sont slectionnes. /debut/ && $NF !~ /^[0-9]/ les lignes qui contiennent "debut" et dont le dernier champ ne commence pas par un chiffre. ( /un/ && /deux/ ) || /trois/ les lignes qui contiennent "un" et "deux", ou les lignes qui contiennent "trois". ! /exemple/ && NR >10 les lignes qui ne contiennent pas "exemple", et dont le numro partir du dbut du chier est suprieur 10. page 98 - Guide du KornShell sous UNIX
III.2.1.
Description dune action Une action ressemble en gros une portion de code en langage C. Cependant, un programme awk est interprt, ce qui vite ici davoir dclarer les variables utilises : une variable non dclare est toujours nulle ou vide la premire utilisation. Toute constante de type chane apparaissant dans un programme awk doit tre encadre par des double-quotes. Les oprateurs de calcul sont : +, -, *, /, %1 et ^2 Lors dune affectation, on peut concatner des champs en les sparant par des <espace> : $ awk END{ a = "toto" "tutu"; print a } /dev/null tototutu $
Dans lexemple ci-dessus, on ne veut pas travailler avec un chier dentre : on utilise alors /dev/null qui est toujours vide, et la squence END{ } du programme awk. Fonctions internes Il existe des fonctions internes mathmatiques (cos, sin, sqrt,...), et de manipulation de champs. Les plus intressantes sont celles de manipulation de champs et dimpression : print Permet dimprimer un rsultat. Chaque commande print provoque un retour la ligne. Sans paramtre, la ligne courante du chier dentre est recopie telle quelle. Avec des paramtres spars par des blancs, les paramtres sont imprims concatns sur la sortie standard.
1. modulo 2. exponentielle
Lorsque les paramtres du print sont spars par des virgules, ils sont imprims III.2.1. spars par des <espace> ; si les paramtres sont spars par des <espace>, ils sont imprims concatns. $ echo "12345 7 9" | > awk { print ; > print $1,$2 ; > print $1 $2 } 12345 7 9 12345 7 123457 $
On peut envoyer le rsultat dans un autre chier que la sortie standard : print $1, $2, $3 >"resultat" envoie les champs un, deux et trois de la ligne courante dans le chier "resultat". printf Idem la commande print, mais la sortie est formate. Cette fonction travaille de la mme manire quen langage C. (le premier paramtre est imprativement une chane contenant le format des paramtres suivants) voir $ echo "123.456 111 255 16 un deux" | > awk { printf "%3.2f %d %X %X", $1, $2, $3, $4; > printf "%5s %s\n", $5, $6 } 123.46 111 FF 10 un deux $
Il y a deux commandes printf : la premire imprime les 4 premiers champs de la ligne dentre, et la seconde, les 2 champs restant. La commande printf ne ralise un retour la ligne uniquement si la squence \n est spcie dans le format (cest le cas ici dans la deuxime commande seulement, ce qui fait que la sortie se trouve nalement sur une seule ligne).
III.2.1.
Schma du formatage : $ echo "123.456 111 255 16 un deux" | > awk { printf "%3.2f %d %X %X", $1, $2, $3, $4 ;
123.46 111 FF 10 { 3 { 2
un deux
$ echo "123.456 111 255 16 un deux" |
>
printf "%5s %s\n", $5, $6 }
123.46 111 FF 10 $
un deux
5 caractres prvus
Dans lexemple donn, on repre les principaux symboles reprsentant le type des donnes imprimer : - %f pour ottant ; - %d pour dcimal - %X pour hexadcimal majuscule (avec conversion) - %s pour chane ascii Le nombre apparaissant parfois est une indication de la longueur du champ pour le formatage. On peut avoir plus dindications sur cette commande en consultant le manuel(3) la rubrique printf. sprintf Idem printf, mais le rsultat nest pas envoy sur la sortie standard: cela permet daffecter des variables. $ echo "123.456 12 12.123456" | > awk { res = sprintf("%3.2f %3.2f %3.2f",$1,$2,$3); > print "res=", res } res= 123.46 12.00 12.12 $
III.2.1.
length Donne la longueur totale de la ligne, ou dun champ si on le fournit en argument. $ echo "12345 789" | > awk { print length, length($1) } 9 5 $ Sans argument, on a la longueur totale de la ligne (ici 9 caractres) ; ensuite, la longueur du premier champ ($1) (ici, 5 caractres). index Donne la position dune sous-chane lintrieur dune chane. $ echo "T_SPE_CTXP_DF1" | > awk { print index($1,"SPE") } 3 $
match Idem prcdent, mais on peut spcier une expression rgulire rechercher plutt quune chane xe. substr Extraction dune partie de chane $ echo "T_SPE_CTXP_DF1" | > awk { print substr($1,7,4) } CTXP $ (extrait 4 caractres partir de la position 7 du premier champ) sub Substitution $ echo "T_SPE_CTXP_DF1" | > awk { sub("DF[012]","DFL",$1); print $1 } T_SPE_CTXP_DFL $
III.2.1.
Le premier paramtre de sub est une expression rgulire tendue1, le second, le terme de remplacement, le troisime, la variable modier. La fonction renvoie 1 si la modication sest bien passe, 0 sinon. La modication nest faite que sur le premier terme trouv correspondant lexpression rgulire. gsub Idem prcdent mais toutes les occurrences de lexpression rgulire sont modies (pas seulement la premire rencontre). split Dcompose en plusieurs lments et affecte un tableau. $ echo "T_SPE_CTXP_DF1" | > awk { n = split($1,tab,"_") ; > print "nombre de sous-champs:", n ; > for(i=1 ;i<=n ;i++) > print "No",i,"=",tab[i] ; > } nombre de sous-champs: 4 No 1 = T No 2 = SPE No 3 = CTXP No 4 = DF1 $
Ici, on dcompose le premier champ ($1) en sous-champs (spars par des "_") dans un tableau nomm "tab". Au passage, on voit comment faire une boucle for (comme en C). toupper tolower Convertit respectivement en majuscules et en minuscules. Vous pouvez, par exemple, faire un test sur un champ indpendamment de la taille de caractres : tolower($1) == "toto" teste si le premier champ vaut "toto" ou "TOTO" ou "ToTo", etc... Commentaires Vous pouvez placer des commentaires dans le programme derrire le caractre #.
1. attention aux caractres rservs comme (, ), + etc. des expressions rgulires; voir page 76.
Les commentaires doivent se trouver lintrieur dune squence { }, cest dire III.2.1. quil nest pas possible den mettre entre le corps BEGIN{} et le corps principal, ou alors entre le corps principal et le corps END{}. Attention: si votre programme awk est plac entre quotes sur la ligne de commande, comme cela est fait dans les exemples qui prcdent, il nest pas question dinsrer une apostrophe (apostrophe = quote) dans le texte, mme si cest du commentaire: si vous faites cela, votre apostrophe sera considre comme la quote de n de programme, et vous aurez une erreur de syntaxe lexcution. Par contre, si votre programme est plac dans un chier (option -f de awk), il nest alors pas encadr avec des quotes, et rien ne vous empche de mettre des apostrophes dans vos commentaires. Passage la ligne Vous pouvez couper les lignes du programme, par exemple aprs les caractres <point virgule>, <virgule>, && , ||, et entre les mots cl (if, then, for...), mais pas au milieu dune chane (encadre par des double-quotes " ). Exemples complets de programmes awk Exemple 1 : total sur une colonne dun chier On veut connatre la taille globale des chiers sufxs en .c dans le rpertoire courant. La taille en octets dun chier est le cinquime champ dans le rsultat dune commande ls -l ; do : $ ls -l *.c -rw-r--r-- 1 logis users 84 Apr 15 15:38 toto1.c -rw-r--r-- 1 logis users 84 Apr 15 15:39 toto2.c -rw-r--r-- 1 logis users 92 Apr 15 15:39 toto_base.c $ ls -l *.c | > awk { total += $5 ; > printf "%14s: taille = %d \n", $NF, $5 ; > } > END{ print "Total = " total } toto1.c: taille = 84 toto2.c: taille = 84 toto_base.c: taille = 92 Total = 260 $
Explication : - Pour toutes les lignes, on somme dans la variable total la taille du chier ( $5 ), et on imprime le nom du chier ( $NF ) avec la taille correspondante ( $5 ). Pour garder les noms des chiers aligns en sortie quelque soit leur longueur, on utilise la fonction printf pour le formatage. - Une fois toutes les lignes lues (squence END{ }), on imprime la variable total qui contient le rsultat. page 104 - Guide du KornShell sous UNIX
III.2.1.
Exemple 2 : idem prcdent mais suivant plusieurs critres On recherche par exemple le total pour chacun des groupes (au sens UNIX) des chiers se trouvant dans le rpertoire /tmp. La base est la mme que prcdemment, mais il faut tenir un total pour chacun des groupes rencontrs ; (le groupe est le 4me champ dans un listing de la commande ls l ; dans lexemple au dessus, ce serait "users"). Cette fois, on nafchera que les totaux, et non plus les valeurs pour chacun des chiers. $ cd /tmp $ ls -l | awk NF>3 { tabtot[$4] += $5 ; total += $5 ; } END{ for ( i in tabtot ) printf "total %6s = %7d\n",i,tabtot[i]; print "\nTotal general = " total ; } root = 11532 ML2 = 865864 sys = 993 iliade = 273408 CMFR = 1203305
total total total total total
Total general = 2355102 $
Explications : La structure du programme est la suivante : slection { action1} END{ action2 } * La slection : NF > 3 les totaux (action1) ne sont raliss que si le nombre de champs dans la ligne est suprieur 3 ; le rsultat de la commande ls -l fournit en premire ligne le total en nombre de bloc (512 octets) du rpertoire list ; cette ligne ne contient que 2 champs : "total" et la valeur en nombre de blocs. En ne gardant que les lignes ayant plus de 3 champs, on ignore donc cette ligne indsirable. * action1 on cre un tableau dont lindice est le nom du groupe rencontr : de cette manire, on nest pas oblig de connatre le nombre ou la liste des groupes qui peuvent exister. Cest la dmonstration que les tableaux acceptent comme indice une chane de caractres, et non pas seulement un entier. Si le groupe est ML2 par exemple, laffectation est alors : Guide du KornShell sous UNIX - page 105
III.2.1. tabtot["ML2"] += xxx avec xxx gal la valeur du 5me champ pour cette ligne. * action2 Ceci correspond lafchage des rsultats. Telle quelle est crite, la boucle for liste tous les lments du tableau tabtot sans avoir besoin den connatre le nombre. Conclusion : La manipulation des tableaux par awk est trs puissante, et permet une grande souplesse dutilisation.
Exemple 3 : mise sur une ligne de donnes trouves sur des lignes successives La transformation consiste passer dun chier de la forme suivante : nom val1 prenom val2 age val3 nom val4 ... un chier de la forme : val1 val2 val3 val4 ... Voici un exemple de programme awk dans le cas le gnral o les lignes "nom", "prenom", "age" apparaissent dans lordre mais ne sont pas toutes les trois toujours prsentes (il peut y avoir un saut de "nom" "age" avec omission de "prenom" par exemple).
III.2.1.
Notez quil existe des solutions beaucoup plus simples quand le format du chier est trs rigide ; mais ce nest pas le cas ici, et on dcouvre ainsi la souplesse de awk pour traiter des cas complexes : $ # # # more convers.awk --- programme AWK --passage de donnees reparties dans plusieurs lignes en une seule ligne info1 = info2 = info3 = "-" ; } 0 = = = } $2 ; nr = 1 ; } $2 ; nr = 2 ; } $2 ; nr = 3 ; }
BEGIN{
{ nr = $1 == "nom" { info $1 == "prenom" { info $1 == "age" { info { # la derniere info de if (
la serie 1 2 3 est atteinte (nr <= old_nr) && (nr != 0) ) { printf "%10s %8s %2s\n", \ info1, info2, info3 ; info1 = info2 = info3 = "-" ; old_nr = nr ; reset = 0 ;
} nr nr nr nr > old_nr == 1 == 2 == 3 } { { { { old_nr = nr } info1 = info ; reset = 1 } info2 = info ; reset = 1 } info3 = info ; reset = 1 } if ( reset == 1 ) printf "%10s %8s %2s\n", \ info1, info2, info3
END{ }
Le principe est le suivant : Chaque type dinformation est associ un numro croissant en fonction de sa position prvue dans la suite : "nom", "prenom", "age". On repre le type de la ligne courante, on limine les commentaires et les lignes blanches. Normalement, le type de linformation courante doit tre de rang plus lev que celui de la ligne prcdente ; sinon, cest quon change denregistrement. Dans ce cas, on imprime une ligne avec les informations recueillies dans les lignes successives du chier dentre.
Et voici un exemple dexcution avec un chier contenant les informations "nom", III.2.1. "prenom" et "age", dans lordre, pour plusieurs personnes. Les informations sont incompltes. $ more convers.input # M Dubois nom Dubois prenom jules age 12 age 12 # M Dupond Albert nom Dupond age 52 nom Dupont nom Pierre $ awk -f convers.awk Dubois jules Dupond Dupont Pierre $
convers.input 12 12 52 -
On voit galement ci-dessus la mthode permettant de placer le programme awk dans un chier spar.
Remarque Une erreur courante lorsquon crit des programmes awk est doublier dencadrer les constantes de type chane de caractres entre des guillemets. Une chane de caractres non encadre par des guillemets est considre comme une variable, qui plus est, nulle, car il nest pas indispensable de faire des dclarations. Par exemple, si vous crivez le test : $1 == bind alors, bind est une variable, qui, si elle na pas t dj affecte, est considre comme une chane nulle : le test sera toujours faux (si le premier champ existe, il ne pas tre vide) alors que pour
$1 == "bind" "bind" est une chane de caractres de valeur : bind
III.2.2.
III.2.2. basename, dirname

But Donne respectivement le nom du chier et son chemin lorsquon applique ces deux commandes sur un chemin absolu de chier. Exemple $ basename /usr/include/signal.h signal.h $ dirname /usr/include/signal.h /usr/include $
III.2.3. bs
But bs est un interprteur-compilateur dun langage se rapprochant du basic. Lintrt de bs est quil possde la plupart des fonctions mathmatiques de base, et quil calcule en virgule ottante. Dautre part, il permet de compiler des parties de programmes, et donc de faire des calculs numriques complexes de manire efcace. Utilisation bs sutilise normalement en mode intractif, mais il est aussi possible denvoyer la srie des ordres et des donnes passs dans son entre standard. Les exemples prsents ici sont triviaux. Pour le dtail (qui est trs fourni), se reporter au manuel(1) des commandes. voir
Exemples en mode intractif : $ bs 2 * 3 + 0.5 6.5 u = 18 * log(2) * 1e-2 u 0.1247664925 obase 8 12 14 q $ Lorsquon tape une expression, elle est value, et son rsultat ventuel est afch la ligne suivante. obase 8 signie base 8 en sortie ( lafchage). Il nest possible de manipuler que les bases 8, 16 et 10. q pour sortir en mode pilot $ echo "rand()" | bs 0.5695495605 $ echo "floor(rand()*100)" | bs 17 $ echo "floor(rand()*100)" | bs 23 $ Ici on utilise quelques-unes des fonctions du langage (pseudo-basic) : rand gnrateur de nombres alatoires oor partie entire. Remarques bs manipulant des variables, seuls les champs commenant par des chiffres sont considrs comme des nombres ; les autres sont supposs tre des variables numriques nulles, si elles nont pas encore t initialises. Par exemple : 123 FFF 0f vaut 123 vaut 0 , mme en base 16 (cest cens tre une variable) vaut 15 en base 16
III.2.3.
Dautre part, les lettres dans les nombres hexa doivent apparatre en minuscules. page 110 - Guide du KornShell sous UNIX
III.2.4.
III.2.4. dc
But Permet entre autres de faire du calcul sur des nombres entiers, et des conversions dunit. Utilisation dc sutilise normalement en mode interactif, mais il est aussi possible denvoyer la srie des ordres et des donnes passs dans son entre standard. Comme dc travaille par pile, la syntaxe est de type notation inverse. Pour les calculs, on lui prfrera bs. Exemples en mode interactif : $ dc 2o 16i FF p 11111111 q $
2o 16i p q en mode pilot
signie base 2 en sortie. signie base 16 en entre. est la commande dimpression du haut de la pile pour sortir
$ echo "1 2 + 3 * p" | dc 9 $
Remarque : Les lettres dans les nombres hexa doivent apparatre en majuscules.
III.2.5.
III.2.5. le
But Dterminer le type et le contenu dun chier. Utilisation file mon_fichier Principe Il existe pour le systme UNIX une mthode didentication du type des chiers quil manipule : le test du magic number. Ce numro fait partie des attributs du chier1 , et le caractrise : il peut indiquer un chier binaire excutable, un chier texte, un module relogeable (.o), etc.. Lorsque le chier est de type texte, lventail des possibilits reste large, et la commande file tudie les 500 premiers caractres pour essayer didentier le type du contenu. Il ne faut pas sattendre des miracles dans cette situation, sauf si le chier est fortement typ : un programme shell commenant par #!/bin/ksh par exemple... Le contre exemple classique est un chier contenant un programme awk, que la commande file confond le plus souvent avec un programme C. Dans le cas o le chier est de type texte, il est de toute manire bien plus simple de lditer directement que dutiliser la commande file ; dans le cas de chiers binaires, on na pas tellement le choix... Types reconnus : voir voir English text [nt]roff, tbl, or eqn input text ascii text assembler program text awk program text basic program text c program text commands text fortran program text lex command text pascal program text s200 assembler program text s500 assembler program text s800 assembler program text sed program text texte (ascii) idem ... ... ... ... ... ... ... ... ... ... ... ... ...
1. dans linode (voir le paragraphe sur les liens physiques: page 27)
III.2.6.
yacc program text s200 pure executable
... binaire
III.2.6. nd
But Le but principal de find est de lister les chiers et rpertoires dune arborescence complte partir dun rpertoire donn. Exemple : find /users -print liste lensemble des chiers et rpertoires qui se trouvent sous /users, ainsi que tous ceux placs dans les sous-rpertoires (ainsi de suite ...) find . -print fait de mme pour le rpertoire courant. Filtres Lintrt majeur du find est quil est possible de rajouter des ltres pour ne conserver que certains chiers ou rpertoires ayant des caractristiques particulires. Exemple : ltre sur le nom de chier find /users -name *.c -print explore rcursivement /users mais ne conserve lafchage que les chiers ayant un sufxe .c On peut mettre plusieurs ltres pour afner la recherche. Exemple : ltre sur le nom et ltre sur la date de dernire modication find /users -name *.c -mtime -3 -print explore /users et ne conserve que les chiers de sufxe .c modis il y a moins de trois jours. Enchanement des ltres Lorsquil y a plusieurs ltres, linterprtation est la suivante :
pour chaque chier list, on applique successivement les ltres dans lordre dapparition dans la commande ; un ltre renvoie un code de retour gal 0 ou 1 suivant que la proprit est vrie ou non. - Si le code est nul, on passe au deuxime ltre, et ainsi de suite. - Si tous sont valides, le nom du chier est fourni en sortie (voir laction du ltre -print plus loin)
Oprateurs Un ltre tant un oprateur binaire (son rsultat est valide ou invalide), il est possible den combiner plusieurs avec les oprateurs NON et OU logique. Exemples : ! -filtre a la validit inverse de -filtre $ -filtre1 -o -filtre2 $ est valide si lun des deux ltres est valide. (Les parenthses tant des caractres spciaux du shell, il faut les protger avec un \). find .$ -name *.c -o -name *.o $ -mtime +3 -print imprime le nom des chiers de sufxe .c ou .o vieux de plus de trois jours. Commandes Il existe des ltres particuliers qui consistent excuter une commande : -print : -exec : afche le nom du chier courant. Ce ltre est toujours valide (son code de retour est toujours nul) ce ltre spcie une commande UNIX excuter. Le ltre est valide si le code de retour de la commande UNIX est nul (commande russie). La commande UNIX peut comporter des arguments et doit tre suivie dun blanc et dun point-virgule pour reprer sa n. Comme le shell interprte les point-virgules, il faut les protger avec un \ Exemple : find /users -exec date \; excute la commande date pour chaque chier du rpertoire contenu dans /users On peut passer la commande UNIX le nom du chier en cours, symbolis par la squence {} Exemple : find . -exec chmod g+w {} \; donne les droits en criture pour la classe groupe tous les chiers et sousrpertoires du rpertoire local (.). Il existe dautres types de ltres de commande, mais moins utiles.
III.2.6.
Agencement des ltres Comme on la vu prcdemment, les ltres sont valus un un dans lordre, donc : find -users -print -name *.c afche tous les noms de chiers existant sous /users, alors que page 114 - Guide du KornShell sous UNIX
III.2.7.
find /users -name *.c -print afche uniquement les noms de chiers de sufxe .c Cette remarque est valable quelque soit le type du ltre utilis. Exemple complexe On utilise la commande UNIX grep -q chane qui renvoie uniquement le code de retour positionn suivant que la chane a t trouve ou pas dans le chier spci. find . -exec grep -q chane {} \; ! -exec rm {} \; -print Pour chaque chier trouv sous le rpertoire courant : le ltre -exec grep -q chane {} \; est valu ; si chane est trouve dans le chier, le code de retour est nul, et le ltre est valide : on passe au ltre suivant. le ltre -exec rm {} \; est valu. Si la commande rm sur le chier courant sest bien passe, le code de retour est nul, et le ltre -exec est valide ; donc, le ltre ! -exec est invalide, et le ltre suivant (print) nest pas valu. Si la commande rm sest mal passe, -exec est invalide, do !-exec est valide, et donc -print est valu. En conclusion : cette commande supprime tous les chiers contenant chane du rpertoire courant (ainsi que ses sous-rpertoires), et si la suppression est impossible, liste le nom du chier correspondant. Options Voir le manuel(1) pour la liste des ltres et options, qui est trs fournie.
voir
III.2.7. grep
But Rechercher dans un ou plusieurs chiers une chane particulire. Utilisation pour un chier :
grep ma_chaine mon_fichier Le rsultat est un chier constitu de la suite des lignes dans lesquelles se trouve ma_chaine. Pour plusieurs chiers : grep ma_chaine mon_fic1 mon_fic2 mon_fic3 ...
Le rsultat est un chier constitu dune suite de lignes de la forme suivante : <nom du chier> : <ligne contenant ma_chaine> Quelques options -c -l -q -i -v donne le nombre de lignes contenant ma_chaine. seuls les noms des chiers contenant ma_chaine sont fournis. rien nest afch ; seul le code de retour est positionn suivant que ma_chaine a t trouve ou pas. pas de distinction entre les majuscules et minuscules pendant la recherche. seules les lignes ne contenant pas ma_chaine sont listes.
III.2.8.
III.2.8. head
But Donne les premires lignes dun chier. head mon_fichier donne les 10 premires (par dfaut) lignes de mon_fichier. Quelques options -N indique le nombre de lignes N imprimer.
III.2.9. join
But En supposant quon ait deux chiers organiss en colonnes (de la mme faon quon aurait deux tables SQL), join permet de faire une jointure entre ces deux chiers sur une colonne commune. Utilisation Les deux chiers doivent tre pralablement tris sur la colonne commune qui servira de jointure.
III.2.9.
Exemple : Voici les deux chiers sur lesquels on veut faire une jointure : $ more j_tab* :::::::::::::: j_tab1 :::::::::::::: 205 Cabours R4 Dupond ferrari Durand 2CV Jules 405 Pierre :::::::::::::: j_tab2 :::::::::::::: Cabours 62 Dupond 53 Durand 22 Paul 18 Pierre 35 $
Paimpol Paris Nice Lourdes Lyon
La jointure est faire sur le nom, cest dire sur la deuxime colonne de j_tab1, et la premire de j_tab2. Les chiers tels quils sont prsents ont t tris : - sur la deuxime colonne pour j_tab11 sort -o j_tab1 -b +1 j_tab1 - sur la premire colonne pour j_tab2 sort -o j_tab2 j_tab2 (pour le dtail, voir la commande sort plus loin) La commande de jointure permettant dobtenir en sortie toutes les informations des deux chiers est la suivante : voir $ join -1 2 -2 1 -o 1.2 2.2 1.3 1.1 j_tab1 j_tab2 Cabours 62 Paimpol 205 Dupond 53 Paris R4 Durand 22 Nice ferrari Pierre 35 Lyon 405 $
1. loption -b permet de ne pas tenir compte des blancs ou tabulations multiples entre les champs; voir le dtail avec la commande sort page 126
Options utilises : indique que la colonne 2 du chier 1 (dans lordre des arguments de la commande join) sert de jointure. -2 1 indique que la colonne 1 du chier 2 sert de jointure. -o 1.2 2.2 1.3 1.1 indique dans lordre les diffrentes colonnes afcher en sortie. Le symbolisme est le suivant : f.c c est le numro de colonne du chier f. Les numros de colonne dmarrent 1. -1 2 Autre option : -v f voir seules les lignes du chier numrot f qui nont pu tre apparies sont imprimes. $ join -1 2 -2 1 -v 1 j_tab1 j_tab2 Jules 2CV Lourdes $ join -1 2 -2 1 -v 2 j_tab1 j_tab2 Paul 18 $
III.2.10.
III.2.10. nohup
But Eviter quune commande trs longue, lance pendant une session, ne soit tue lors de la dconnexion. Utilisation Il suft de rajouter nohup devant la commande que vous dsirez lancer. nohup ma_commande & Exemple $ nohup id Sending output to nohup.out $ nohup "id ;pwd" Sending output to nohup.out nohup: id;pwd: No such file or directory $ more nohup.out uid=207(logis) gid=20(users) $
III.2.11.
Attention, votre commande doit tre un chier excutable (ce nest pas possible de lancer une fonction du shell avec nohup), et ne doit pas tre compose (avec des points virgules par exemple). Si votre commande doit envoyer des rsultats sur la console, ils seront automatiquement drouts vers un chier nomm nohup.out que vous trouverez dans le rpertoire courant si le chier peut y tre mis, ou dans votre rpertoire principal sinon. lancement en arrire plan Vous utilisez nohup gnralement lorsque vous vous apprtez lancer une commande qui prendra beaucoup de temps avant de se terminer. Cest donc loccasion de rajouter en n de ligne le caractre & qui lance la commande en arrire plan, et vous permet de reprendre la main de suite. commandes composes Pour lancer par nohup des commandes composes, il faut passer par lintermdiaire du shell. Exemple : $ nohup ksh -c "id ;pwd" Sending output to nohup.out $ more nohup.out uid=207(logis) gid=20(users) /users/petrus/logis/doc/manuel_shell/exemples $
Il est bien sr possible de rajouter un & en n de ligne pour lancer le tout en arrire-plan et reprendre la main de suite.
III.2.11. sed
But sed est la version non intractive de lditeur de lignes ed. Il reprend donc la plupart des fonctions de ce dernier. On peut lutiliser pour modier de manire automatique le contenu de chiers. Cet diteur proposant un grand nombre de fonctionnalits, on se contentera ici den signaler quelques-unes des plus intressantes :
- la transformation dune suite de caractres pour un ensemble de lignes dun chier - la suppression dun ensemble de lignes - la duplication dun groupe de lignes lintrieur dun chier.
Utilisation On indique sed une adresse ou un ensemble dadresses correspondant aux lignes traiter, puis la commande excuter sur chacune des lignes slectes. Dans le mode normal, les lignes non slectes sont recopies telles quelles sur la sortie standard.1 Description des adresses On peut dsigner les lignes traiter : - par le numro de la ligne ou le caractre $ qui symbolise la dernire ligne du chier. - par un contenu commun aux diffrentes lignes : /expression_rgulire/ (cest dire une expression rgulire dcrivant le contenu entre 2 caractres /) Si vous voulez utiliser un autre caractre que le /, il faut alors crire : \+expression_rgulire+ pour utiliser un caractre + comme sparateur. - par un bloc, cest dire une suite de lignes dont la premire et la dernire sont dnies comme dans les deux cas ci-dessus, et spares par un caractre virgule , Si plusieurs blocs du type spci sont prsents dans le chier, ils sont tous pris en compte. Si aucune adresse nest spcie, tout le chier est trait. Exemples 128 128,241 128,$ /^[^0-9]*$/2 /debut/,/n/ la ligne 128 du chier les lignes 128 241 (comprises) toutes les lignes depuis la ligne 128 jusqu la n du chier les lignes qui ne contiennent aucun chiffre les lignes contenues dans les blocs commenant par une ligne contenant la chane "debut" et nissant par une ligne contenant la chane "n".
III.2.11.
1. Pour viter que les lignes non slectes soient recopies en sortie, il faut appeler sed avec loption -n. 2. la squence [0-9] dsigne un chiffre, donc [^0-9] dsigne tout caractre autre quun chiffre. Entre deux /, ^ symbolise le dbut de la ligne, et $ la fin. Le caractre * dsigne une chane de longueur quelconque constitue uniquement de ce qui prcde le * dans lexpression rgulire. Donc lensemble correspond aux lignes qui ne comprennent que des caractres autre quun chiffre entre le dbut et la fin de ligne.
III.2.11.
Description de quelques commandes Substitution s/expression_rgulire/chaine_remplacement/g s dsignation de la commande de substitution / le sparateur entre les deux termes qui suivent. Ce nest pas obligatoirement un / : le sparateur est le caractre qui vient immdiatement aprs le s . Gnralement, on utilise un /, mais si lexpression rgulire ou la chane de remplacement contient un /, il vaut mieux utiliser un autre caractre (dans ce cas, les trois / sont remplacer)
expression_rgulire une expression rgulire qui reprsente la zone de texte remplacer. Cette chane de recherche est souvent appele pattern. chaine_remplacement la chane qui remplacera la zone de texte repre par lexpression rgulire
g optionnel. Indique que toutes les occurrences de lexpression rgulire rencontres sur la ligne sont transformes. Si g est absent, seule la premire est transforme.
Exemple complet Remplacer dans toutes les lignes qui contiennent des chiffres, chaque chiffre par un X sed /[0-9]/s+[0-9]+X+g o on reconnat : /[0-9]/ adresse correspondant aux lignes contenant des chiffres s+ + + la commande de substitution avec ses sparateurs [0-9] lexpression rgulire qui dsigne un chiffre X le caractre qui doit remplacer le chiffre dsign par lexpression rgulire g loption qui indique de modier tous les chiffres apparaissant dans une ligne. Suppression d
commande de suppression de ligne. Les lignes non supprimes sont envoyes sur la sortie standard de la commande sed.
Exemple complet Supprimer la partie du chier, depuis la ligne contenant la chane "debut", jusqu la dernire ligne du chier. sed /debut/,$d
o on reconnat : /debut/ adresse correspondant une ligne contenant la chane "debut" $ adresse symbolisant la dernire ligne du chier. d la commande de suppression.
III.2.11.
Duplication p commande de duplication de ligne. La ligne dont ladresse est valide est recopie sur la sortie standard.
Exemples complets Dupliquer chaque ligne du chier, depuis la premire ligne jusqu la ligne contenant la chane "n". sed 1,/fin/p o on reconnat : 1 adresse de la premire ligne du chier. /n/ adresse correspondant une ligne contenant la chane "n" p la commande de duplication. Les lignes non refrences par lindication des adresses sont quand mme envoyes sur la sortie standard, ce qui veut dire que : - toutes les lignes apparaissent au moins une fois sur la sortie standard - les lignes dont ladresse est valide apparaissent deux fois. Conserver la partie du chier, depuis la premire ligne jusqu la ligne contenant la chane "n". sed -n 1,/fin/p o on reconnat la mme commande que prcdemment, part loption : -n qui indique que les lignes dont ladresse nest pas slectionne ne sont pas recopies en sortie. Seules les lignes refrences par lindication des adresses sont donc envoyes sur la sortie standard
Utilisation des buffer pour la commande de substitution Le principe dcrit pour une substitution consiste reprer une chane particulire, et la remplacer par une autre.
Un problme se pose lorsque la chane de remplacement doit intgrer une partie de la chane substituer. Exemple : dans un chier, on veut remplacer tout nombre ngatif par le mme nombre, mais rendu positif (par suppression du "tiret" qui le prcde). page 122 - Guide du KornShell sous UNIX
III.2.11.
La chane rechercher est un "tiret" suivi dun chiffre. La chane de remplacement est le chiffre trouv dans la chane rechercher (sans le tiret). Donc, il faut pouvoir, lors de la recherche, mettre en mmoire une partie de la chane substituer. sed permet de placer dans des buffers des parties de la chane substituer, pour les intgrer la chane de remplacement. buffer principal Pendant une substitution, toute chane qui satisfait lexpression rgulire de recherche est place dans le buffer principal. Le contenu du buffer peut tre plac dans la chane de remplacement en utilisant le caractre &. Exemple : $ more j_tab2 Cabours 62 Dupond 53 Durand 22 Paul 18 Pierre 35 $ sed s/[0-9][0-9]*/& &/ j_tab2 Cabours 62 62 Dupond 53 53 Durand 22 22 Paul 18 18 Pierre 35 35 $ Ici, lexpression rgulire correspond une suite de caractres compose : - dun chiffre - suivi dun nombre positif ou nul dautres chiffres cest dire : au moins un chiffre. Dautre part, la chane de remplacement est gale deux fois le contenu du buffer, spar par un <espace>. Donc dans le chier de sortie, chaque suite de chiffre est remplace par deux fois elle mme, plus un <espace> entre les deux. Buffers secondaires Pour rcuprer une partie seulement de la chane de recherche, on utilise un buffer secondaire. On indique lintrieur de lexpression rgulire la partie de la chane mettre dans le buffer secondaire en lencadrant entre des : Dans la chane de remplacement, le contenu du buffer est dsign par : \1 Guide du KornShell sous UNIX - page 123
La prsence de ne modie en rien la signication de lexpression rgulire : la III.2.11. seule action est donc de placer dans le buffer la partie de la ligne correspondant la partie dexpression rgulire encadre par les . Exemple du changement de signe ngatif en positif en utilisant un buffer secondaire : $ more chg_sign ESSAI-8 -11 jean-francois +10 valeur -moins -5 $ sed s/-$[0-9][0-9]*$/\1/g chg_sign ESSAI8 11 jean-francois +10 valeur -moins 5 $ La chane recherche est : : un tiret suivi par [0-9] : un caractre entre 0 et 9 (un chiffre donc) suivi par [0-9]* : un chiffre rpt 0 ou n fois Lorsquelle est localise, la squence [0-9][0-9]* (cest dire, une srie dau moins un chiffre) est place dans le buffer, puisque cette squence est encadre par des . La chane de remplacement est le buffer. La chane de recherche est un tiret suivi de chiffres ; la chane de remplacement ne contient plus que les chiffres : on supprime le tiret devant les termes constitus dau moins un chiffre. On remarque dans le rsultat : - que les chanes jean-francois et -moins nont pas t transformes, ce qui est conforme aux spcications ; - par contre, que la chane ESSAI-8 a t modie, ce qui nest peut-tre pas tout fait lobjectif de dpart.1 Buffers secondaires multiples Il est possible de dnir plusieurs buffers secondaires : il suft de faire apparatre plusieurs squences dans la chane de recherche. La premire squence est note \1 dans la chane de remplacement, la seconde \2, etc...
1. En effet, un nombre tel quon limagine est une suite de chiffres ventuellement prcde dun tiret, mais isole entre des sparateurs. Donc, dans la chane de recherche, il aurait fallu ajouter un caractre <espace> ou <tabulation> avant et aprs la squence -[0-9][0-9]*. Mais dans ce cas, on ne tient pas compte des nombres colls en dbut ou en n de ligne (pas de sparateur)... En fait, la recherche consisterait trouver un champ constitu uniquement de chiffres (et prcds ventuellement du caractre tiret). Pour cela, il faut savoir que la commande awk est mieux adapte (laccs aux diffrents champs est immdiat... : voir la fonction gsub de awk)
III.2.11.
Exemple dchange de position pour un couple de chiffres : $ more j_tab2 Cabours 62 Dupond 53 Durand 22 Paul 18 Pierre 35 $ sed s/$[0-9]$$[0-9]$/\2\1/ j_tab2 Cabours 26 Dupond 35 Durand 22 Paul 81 Pierre 53 $
Les deux chiffres conscutifs sont placs chacun dans un buffer secondaire, et on remplace le couple par lui mme, mais dans lordre inverse ( ...\2\1.. )
Remarques gnrales sur lutilisation des substitutions avec sed - Les chanes de recherche de sed sont utilisables en priorit sur des suites de caractres : si vous devez isoler des champs, choisissez plutt la commande awk qui est mieux adapte. - Dans tous les exemples, la chane de commande passe sed est encadre par des quotes simples. Ceci nest pas indispensable, mais attention : beaucoup de caractres spciaux pour sed (*,$,\,[],...) le sont aussi pour le shell, qui risque de les interprter avant de passer le rsultat au sed (dans le cas o la chane nest pas protge par des quotes). Ainsi, on peut remplacer les quotes simples par des quotes doubles si la chane de commande ne contient pas de $ ou de ", et ne pas en mettre si la chane de commande ne contient aucun des caractres spciaux, ni de sparateurs <espace> ou <tabulation>. A linverse, vous pouvez construire la chane de commande du sed avec le contenu dune variable. Exemple : $ CONSOLE=tty $ echo "le nom de ma console est <cons>" le nom de ma console est <cons> $ echo $CONSOLE /dev/pty/ttyt1 $ echo "le nom de ma console est <cons>" | > sed "s+<cons>+$CONSOLE+" le nom de ma console est /dev/pty/ttyt1 $
Au moment de lvaluation de la ligne contenant le sed, le shell remplace dans la III.2.12. chane "s+<cons>+$CONSOLE+" la variable $CONSOLE par son contenu, puisque celle-ci est encadre par des ". Elle devient donc : s+<cons>+/dev/pty/ttyt1+, suite quoi, le shell lance la commande sed s+<cons>+/dev/pty/ttyt1+. La prsence de / dans la chane de remplacement impose lutilisation de + comme caractre de sparation. Une chane de commande passe sed est une chane comme une autre : vous pouvez donc la composer partir de variables, de rsultats dune autre commande, de chanes xes, le tout juxtapos. Mais, comme on la dj signal dans un chapitre prcdent1, les caractres spciaux du shell, ou les <espace>, qui ne sont pas protgs, seront tout dabord interprts par le shell et provoqueront donc souvent une erreur de syntaxe dans le sed. Cest pourquoi le mieux dans la majorit des cas est de dencadrer les commandes de sed avec des simple-quotes.
III.2.12. sort
But Trier un chier. Principe Le mode naturel du tri consiste comparer le premier caractre de chaque ligne et de les ordonner en consquence. Pour toutes les lignes dont le premier caractre est identique, on recommence la comparaison sur le deuxime caractre, et ainsi de suite. Dans le cas du tri numrique, un traitement de logique interne tabule droite les nombres au cas o ceux-ci seraient de longueur variable. chier dentre Il est possible de spcier le chier trier de plusieurs faons : ou bien ou encore sort mon_entree sort <mon__entree cat mon__entree | sort
1. Voir linterprtation dune ligne shell : page 34
III.2.12.
chier de sortie ou bien sort <mon_entree >ma_sortie sort mon_entree -o ma_sortie
Comme sort utilise des chiers temporaires pour effectuer ses manipulations, il est possible de donner comme chier de sortie celui dentre. sort mon_fichier -o mon_fichier Utilisation simple Pour les exemples qui suivront, le chier dentre sera toujours le mme : $ more sort.input 2 45 1 126 1 45 2 126 1 7 $ (Attention aux espaces, qui sont signicatifs dans la plupart des cas). Exemple trivial : $ sort sort.input 2 126 1 45 1 126 1 7 2 45 $ Par dfaut, le tri est alphanumrique (dans lordre des caractres ascii), et commence partir du premier caractre gauche pour chaque ligne. Ici, la premire ligne commenant par un <espace>, elle apparait donc en premire position1. Pour les trois lignes dbutant par un 1, le deuxime caractre nest pas sufsant pour assurer le tri : cest un <espace>. Donc, ce sera le troisime qui permettra de dpartager : un <espace>, un 1, un 7.
1. l<espace> est un caractre ascii de rang infrieur tous les caractres alphabtiques et numriques. La liste est consultable dans le fichier /usr/pub/ascii sur votre machine.
tri numrique Le tri ne tient pas compte des <espace> ou <tabulation> qui prcdent le terme numrique considr. $ sort -n sort.input 1 45 1 126 1 7 2 126 2 45 $
III.2.12.
On constate bien que les lignes qui commencent par un 1 prcdent celles qui commencent par un 2 ( ! ) Par contre, il apparait que le tri numrique ne sest pas effectu sur la deuxime colonne : le tri alphanumrique a t repris compter du premier <espace> ou <tabulation> qui suit le premier champ. cl Le tri par dfaut consiste trier partir du premier caractre de chaque ligne, et la ligne complte est utilise si les premiers caractres ne sufsent pas. On peut limiter le tri une partie de ligne. Cette partie qui est alors appele la cl. Une cl est repre dans la ligne par une position de dbut (inclue) et une position de n (non inclue). Juste avant le tri, la ligne est dcoupe de manire logique en champs, numrots partir de zro, et spars par des <espace> ou <tabulation>1. Un champ commence en dbut de ligne, ou partir de la position qui suit l <espace> ou la <tabulation> dnissant la n du champ prcdent. (ce qui veut dire que si deux champs sont spars par 3 <espace>, alors le deuxime champ comprendra 2 <espace> comme premiers caractres). Le dernier caractre du champ prcde toujours un <espace>, une <tabulation>, ou la n de ligne. Dans chaque champ, les caractres sont numrots, partir de zro eux aussi. Une cl se dnit de la manire suivante :
chp_debut.car_debut,chp_fin.car_fin
1. Il est possible de dfinir dautres caractres de sparation que <espace> et <tabulation>. Voir loption -t
III.2.12.
Si on omet car_debut ou car_fin, tout le champ est considr. Si on omet respectivement le terme avant ou aprs la virgule, le dbut ou la n de la ligne est considre. A lintrieur de la cl, les <espace> ou <tabulation> sont pris en compte.
champ : caractre : ligne : cl : 1,3 0.2,2.5 2.5,
0
0 3
1
0 17
2
0 9
3
0
2345 ACT_UTI_CONVERSION
t_uti_conv
cl = "ACT_UTI_CONVERSION t_uti_conv"
cl = "45 ACT_UTI_CONVERSION t_uti" cl = "_conv 8"
cl = "2345 ACT_UTI"
,1.7
tri restreint Pour utiliser une cl dans le tri, on spcie loption -k1 : voir voir sort -kcle1 -kcle2 -kcle3 ... On peut donner plusieurs cls, au cas o le chier contiendrait des lignes pour lesquelles la premire cl (voire la seconde, etc...) serait identique. Rien nempche de trier dabord sur une cl base sur la n de la ligne, puis, pour afner, sur une cl base sur le dbut de la ligne. Exemple simple : tri sur le champ No 1 voir voir
champ No 1 une fois cadr (1 sparateur ot) 45 126 126 45 7
$ sort -k1, sort.input 1 45 2 126 1 126 2 45 1 7 $
1. Par compatibilit avec les versions antrieures, la cl peut aussi tre spcifie par : sort +chp_debut.car_debut -chp_fin.car_fin
Remarquez bien que le tri tant ici alphanumrique (par dfaut), il est normal que le champ III.2.12. commenant par un 1 (126) prcde celui qui commence par un 4 (45), mme si le premier nombre est suprieur au second. Le champ numrot 1 tant le dernier de la ligne, il nest pas ncessaire dindiquer o se termine la cl ; mais on aurait pu aussi bien taper : voir voir sort -k1,2 sort.input
Suppression des sparateurs multiples Pour saffranchir du problme pos par des <espace> ou <tabulation> rpts entre deux cls et qui perturbent le tri, on utilise loption b. Pour cela on rajoute -b comme option du sort, (dans ce cas, la cl qui suit sur la ligne est concerne), ou ce qui est mieux, dans la spcication de la cl : voir voir $ sort -kb1, sort.input 2 126 1 126 1 45 2 45 1 7 $ On aurait pu aussi taper : sort -b -k1, sort.input Attention : - cette option nest valide que si une cl au moins est dnie. ( sort -b sort.input na pas deffet ) - lintrieur de la cl, les sparateurs ne sont pas ignors. tri multiple Exemple de tri sur le champ No 1, puis sur le champ No 0 : voir voir $ sort -b -k1,2 -k0,1 sort.input 1 126 2 126 1 45 2 45 1 7 $
tri sur le champ No 1 en supprimant les sparateurs multiples
champ No 1 une fois cadr (tous les sparateurs ots)
126 126 45 45 7
III.2.12.
options du tri Les options (comme b) peuvent tre spcies par : -opt comme une option de la commande sort sa validit porte alors sur la cl qui suit sur la ligne de commande. Donc sort -opt cl na pas la mme signication que sort cl -opt Attention, le rsultat nest pas toujours garanti : suivant les options et manipulations, il arrive que loption porte sur une cl, ou parfois toutes celles qui suivent. -koptcl sa validit ne porte que sur la cl. A utiliser de prfrence.
Voici les plus intressantes : b dj vue. supprime les sparateurs multiples en dbut du champ si elle sapplique sur une cl. Attention, lintrieur de la cl, les sparateurs ne sont pas ignors. tri numrique. Le champ concern est tabul droite. renverse le sens du tri de la cl spcie, ou de la totalit du tri si aucune cl nest dclare. pour la comparaison, toutes les lettres sont passes en majuscules.
n r f Exemple complexe
On veut trier le chier prcdent : - sans tenir compte des sparateurs multiples - dabord en numrique et invers sur le champ numrot 1 - ensuite en alphanumrique sur le champ numrot 0 : voir voir $ sort -krn1, -k0,1 sort.input 2 126 1 126 1 45 2 45 1 7 $
On vrie bien que les valeurs numriques du champ 1 dcroissent et que dans le champ 0 des deux premires lignes (o il y a ambigut sur le champ 1), l<espace> prcde le caractre 1.
autres options de la commande sort -u -tx -c aprs le tri, les lignes identiques dupliques (doublons) sont supprimes : une seule occurrence est conserve. le caractre x est le sparateur, la place de l<espace> et de la <tabulation> pris par dfaut. teste si le chier dentre est conforme au tri spci. renvoie 0 si le chier est dj correctement tri, ou 1 avec un message derreur sinon.
III.2.13.
III.2.13. strings
But Lister les chanes de caractres (de type constante) qui sont inclues dans un chier binaire, ou un chier core1. Utilisation strings mon_fichier | more le pipe suivi du more nest absolument pas indispensable, mais bien utile, car la liste est souvent longue. Option -N indique le nombre de caractres N partir de laquelle une chane est extraite. Par dfaut cette valeur vaut 4, et seules les chanes dau moins 4 caractres sont indiques.
Exemples de chanes extraites - binaire ou core issu dun programme source en C : ... start %20s ... done after usr=%5u sys=%5u exit %s newSubclass %s ... => les chanes contenant des %s , %d, %c, etc ... sont typiques du langage C ( format dun printf ). Lexcutable contient certainement un module provenant du langage C. - binaire ou core issu dun programme source en ADA :
1. voir la signication du terme core au paragraphe sur les messages derreur, page 209, : core dumped
III.2.13.
... to a non Ada scope. -- Program terminated by an exception propagated out of the main subprogram. ------------- Stack trace of the propagation in the main stack ------------------------------------ skipped scopes: --------------------CONSTRAINT_ERROR -- Exception raised: SUBPROGRAM NUMERIC_ERROR STORAGE_ERROR TASKING_ERROR PROGRAM_ERROR -- End of propagation: Program aborted. ... => l, pas de doute, cest crit noir sur blanc - le binaire ou un core du KornShell (ksh) : ... rksh [[ ! *macs $HOME $PWD $OLDPWD ... => les termes rksh et $OLDPWD sont caractristiques du ksh. Si votre chier est un core, il correspond probablement un programme shell "plant". - le binaire ou un core du BourneShell (sh) : ... sh internal 1K buffer overflow ... => cest crit noir sur blanc. - le binaire ou un core du Csh : ... Guide du KornShell sous UNIX - page 133
Not in while/foreach then default then/endif not found ... => les termes foreach caractristiques du Csh.
III.2.14.
et
endif
sont
III.2.14. tail
But Donne les dernires lignes dun chier. Utilisation tail mon_fichier donne les 10 dernires (par dfaut) lignes de mon_fichier. Quelques options -n N -f indique le nombre de lignes N imprimer. met la commande en mode suivi. la commande afche les lignes au fur et mesure que le chier se rempli.
III.2.15. uniq
But Supprime les occurrences multiples de lignes conscutives dans un chier tri. Utilisation uniq mon_fichier_tri conserve une seule occurrence des diffrentes lignes de mon_fichier_tri. Quelques options -u -d seules les lignes qui ne sont pas rptes sont imprimes. seule une copie des lignes rptes est imprime.
Par dfaut, la commande utilise ces deux options runies. les n premiers champs sont ignors pendant la comparaison. -n
III.2.15.
Exemple1 : $ 4 8 4 $ 4 4 $ 4 $ 4 $ 4 8 $ sort +2 tst_sort1 1 1 2 0 1 2 1 1 3 sort +2 tst_sort1 | uniq -2 1 1 2 1 1 3 sort +2 tst_sort1 | uniq -u -2 1 1 3 sort +2 tst_sort1 | uniq -d -2 1 1 2 sort tst_sort1 | rev | uniq -2 | rev 1 1 2 0 1 2
voir
Lexemple ci-dessus consiste manipuler un chier contenant trois lignes de chiffres. Premire manipulation On veut conserver une seule occurrence des lignes conscutives dont les deux derniers champs sont gaux (comparaison ligne ligne) ; les autres lignes sont conserves : - on trie partir de lavant dernier champ (sort +2), et on compare les lignes en ignorant les deux premiers champs (uniq -2) Deuxime manipulation On veut liminer les lignes conscutives ayant les deux derniers champs gaux (comparaison ligne ligne) : - la manipulation est identique la prcdente, part loption -u spcie la commande uniq. Troisime manipulation Identique la premire manipulation, mais les autres lignes ne sont pas afches - on spcie loption -d la commande uniq. Quatrime manipulation Identique la premire manipulation, mais la comparaison doit porter sur les deux premiers champs :
voir
1. La syntaxe utilise ici pour la commande sort est lancienne version, supporte encore aujourdhui par compatibilit. La syntaxe correcte serait : sort -k2, tst_sort1 pour trier depuis le champ numrot 2 jusqu la n de ligne.
- comme la commande uniq ne permet pas ce type de comparaison (ignorer N derniers III.2.16. champs), on inverse les caractres sur chaque ligne (symtrie par rapport au centre, les N derniers champs deviennent les N premiers) avec la commande rev, puis on applique uniq, puis on inverse nouveau pour retrouver la ligne dans ltat initial. Remarques : - il nest pas possible en utilisant uniq de comparer des lignes conscutives en ignorant des champs la fois en dbut et en n de ligne. - si le nombre ou la longueur des champs varient de ligne en ligne, lexemple qui utilise la commande rev nest plus valable.
III.2.16. xargs
But Lancer autant de fois une commande quil existe de paquets darguments pour cette commande dans un chier donn. Utilisation Les paramtres de xargs sont: la commande lancer; le chier contenant les paquets darguments pour cette commande. (xargs peut aussi travailler avec lentre standard) La commande lancer doit tre un binaire excutable ou un shell-script (pas dalias, ou de commande compose). Si elle nest pas spcie, alors echo est excut par dfaut. On peut indiquer en plus de la commande un ou plusieurs paramtres. Les donnes du chier (ou de lentre standard) sont des champs spars par des <espace>, <tabulation>, ou des <retour la ligne>. Il est possible de placer un de ces sparateurs dans un champ en encadrant le tout avec des quotes simples ou doubles, ou en le faisant prcder du caractre \ . Un paquet darguments est constitu dune suite de champs trouvs dans le chier, spars par des <espace>. Le nombre de champs successifs pris dans le chier pour faire un paquet dpend de loption utilise; en standard (cest dire sans option), le paquet est constitu de tous les champs du chier dentre. Si on prend :
cat fichier_arguments | xargs ma_commande
III.2.16.
Le fonctionnement standard consiste prendre ma_commande, rajouter derrire tous les champs du chier fichier_arguments, et excuter le tout.
fichier_arguments
... un deux trois ... ...
xargs ma_commande
ma_commande un deux trois..
Si fichier_arguments contient 25 champs, ma_commande sera lance avec ces 25 champs en paramtres. Exemple :
$ cat tst xargs un deux trois quatre cinq six $ xargs echo AA <tst xargs AA un deux trois quatre cinq six $
Quelques options -nN Au lieu de fabriquer un seul paquet avec tous les champs du chier, xargs constitue des paquets de N champs (sauf le dernier qui contient ce qui reste) et lance la commande autant de fois quil y a de paquets.
III.2.16.
Si on prend : cat fichier_arguments | xargs -n2 ma_commande xargs transforme fichier_arguments en une suite de paquets de 2 champs, et applique ma_commande sur chacun de ces paquets.
fichier_arguments
... a1 a2 a3 b1 c1 c2 c3 ...
xargs -n2 ma_commande ...
ma_commande a1 a2 ma_commande a3 b1 ma_commande c1 c2

...
Exemple: $ cat tst_xargs un deux trois quatre cinq six $ xargs -n4 echo AA <tst_xargs AA un deux trois quatre AA cinq six $
III.2.16.
-lN
Au lieu de fabriquer un seul paquet avec tous les champs du chier, xargs constitue un paquet par ensemble de N lignes, chaque paquet contenant lensemble des champs des N lignes correspondantes. Si N est omis, la valeur 1 est prise par dfaut.
Si on prend : cat fichier_arguments | xargs -l ma_commande Pour chaque ligne du chier dentre fichier_arguments, le fonctionnement consiste prendre ma_commande, rajouter au bout la ligne courante, et excuter le tout.
fichier_arguments
... lignei lignei+1 lignei+2 ...
xargs -l ma_commande ...
ma_commande lignei ma_commande lignei+1 ma_commande lignei+2

...
Exemple: $ cat tst_xargs un deux trois quatre cinq six $ xargs -l echo AA <tst_xargs AA un deux trois AA quatre AA cinq six $
-ichaine Au lieu de rajouter le paquet de champs en bout de ma_commande, il est III.2.16. insr en lieu et place de la chane chaine dans ma_commande. Si chaine est omise, la chane {} est prise par dfaut. Le paquet est constitu de lensemble des champs de la ligne courante. Si on prend : cat fichier_arguments | xargs -iX cmd X truc X Dans le texte de la commande fournie en argument xargs, chaque lettre X est remplace par le contenu de la ligne courante de fichier_arguments.
fichier_arguments
<=> ma_commande
... a1 a2 b1 c1 c2 ...
xargs -iX cmd X truc X ...
cmd a1 a2 truc a1 a2 cmd b1 cmd c1 c2

...
truc b1 truc c1 c2
Exemple: $ cat tst_xargs un deux trois quatre cinq six $ xargs -ipaquet echo paquet AA paquet <tst_xargs un deux trois AA un deux trois quatre AA quatre cinq six AA cinq six $
III.2.16.
Remarque : Les options -i et -nN ne sont pas compatibles : $ echo tata tutu | xargs -i -n1 echo "{} {} {} |" {} {} {} | tata {} {} {} | tutu $ echo tata tutu | xargs -n1 -i echo "{} {} {} |" tata tutu tata tutu tata tutu | $
alors que le rsultat attendu consiste en deux lignes, la premire contenant trois tata, et la seconde contenant trois tutu. La solution consiste oprer en deux temps : echo tata tutu | xargs -n1 | xargs -i echo {} {} {} | $ echo tata tutu | xargs -n1 | > xargs -i echo "{} {} {} |" tata tata tata | tutu tutu tutu | $
- le premier xargs applique la commande echo (par dfaut) champ aprs champ (option -n1) sur le chier dentre (lentre standard) - le deuxime applique un echo avec comme arguments trois fois chaque ligne dentre. En bref : Vous avez 200 chiers renommer: il faut leur rajouter le sufxe .ext . La liste des noms de ces chiers se trouve dans le chier liste, un nom par ligne: xargs -ific mv fic fic.ext <liste Idem, mais les ancien et nouveau noms sont placs par couple, un couple sur chaque ligne du chier liste: xargs -l mv <liste Vous voulez reformater un chier, en mettant les champs sur trois colonnes: xargs -n3 <fichier Vous voulez reformater un chier, en joignant les lignes 2 2: xargs -l2 <fichier
III.2.16.
Cas types
IV.
IV. Cas types
Cas types : Cas types dans un programme shell
IV.1. Cas types dans un programme shell

IV.1.1. Comment affecter une variable avec le rsultat dune commande?
1/ le rsultat de la commande doit se trouver sur la sortie standard : si ce nest pas le cas, rediriger la sortie avec une redirection vers la sortie standard (descripteur 1) exemple : vous voulez rcuprer la sortie derreur de la commande cmd, dans ce cas la redirection prvoir est : cmd 2>&1 2.1/ utilisez de prfrence loprateur $( ) exemple : toto=$(cmd) ou, si la sortie de la commande devait tre redirige : toto=$(cmd 2>&1) (dans le cas ci-dessus, vous rcuprez le rsultat de la sortie derreur de la commande cmd) Sinon, on peut aussi utiliser le caractre (anti-quote) : toto=cmd 2.2/ au cas o il y aurait plusieurs variables rcuprer sur la ligne de sortie de la commande utilisez la commande read exemple : cmd | read var1 var2 var3 (dans le cas ci-dessus, le rsultat de la commande cmd est une ligne, et on rcupre le premier champ du rsultat de cmd dans la variable var1, le 2me dans var2 et tout ce qui reste dans var3) Exemple : on veut rcuprer par la commande wc -l le nombre de lignes du chier toto1.c $ wc -l toto1.c 2 toto1.c $ nbl1=$(wc -l toto1.c) $ echo $nbl1 2 toto1.c $ wc -l toto1.c | read nbl2 fichier $ echo $fichier toto1.c $ echo $nbl2 2 $
IV.1.1.
informations : voir guide : les redirections loprateur $() ou anti-quote les variables
IV.1.2.
IV.1.2. Comment lire un chier ligne ligne?

1/ le chier est constitu par la sortie standard dune commande cmd Squelette : cmd | { while read ligne do VOTRE_TRAITEMENT done } Remarque : Si vous connaissez la structure de votre chier, vous pouvez rcuprer les diffrents champs directement dans plusieurs variables : remplacez read ligne par read chp1 chp2 chp3 ... 2/ le chier est un chier dj existant (par ex : toto) 2.1 : Choisir un numro de descripteur inutilis et suprieur 2 par ex : 3 2.2. : Squelette exec 3<toto while read -u3 ligne do VOTRE_TRAITEMENT done
informations : voir guide : les redirections la manipulation des chiers les variables les macro-commandes { } et ( ) la commande while Manuel UNIX : ksh(1) (commande interne read)
IV.1.3. Comment mettre une trace dexcution?

1/ lcran rajouter juste avant la zone tracer : Guide du KornShell sous UNIX - page 145
set -x et ventuellement aprs la zone, pour stopper la trace : set +x 2/ dans un chier idem prcdent, mais rajouter avant la commande set -x : exec 2>fichier_trace informations : voir guide : les redirections la manipulation des chiers la commande shell set
IV.1.4.
IV.1.4. Comment tester si un chier existe? sil est vide?

1/ le chier toto existe-t-il? squelette : if [ -a toto ] then # fichier existant votre_traitement1 else # fichier inexistant votre_traitement2 fi 2/ le chier toto est-il vide? squelette : if [ ! -s toto ] then # fichier vide votre_traitement1 else # fichier non vide votre_traitement2 fi Il existe une bonne vingtaine de tests diffrents sur les chiers informations : voir guide : les expressions conditionnelles la commande if Manuel(1) : ksh(1) expressions conditionnelles, liste des tests possibles
IV.1.5.
IV.1.5. Comment excuter une commande sur plusieurs chiers de mon rpertoire?
1/ uniquement au niveau du rpertoire considr : Exemples : tous les chiers du rpertoire courant, sans exception : ls -1 | xargs commande les chiers de sufxe .suff du sous-rpertoire tutu ls -1 tutu/*.suff | xargs commande Remarque : - chez les utilisateurs, la commande ls est souvent aliase pour avoir un listing personnalis : cest pour tre sur davoir un nom de chier par ligne quon utilise loption -1. 2/ sur le rpertoire considr et tous les sous-rpertoires On utilise la commande find. Exemple : lancer sur tous les chiers du rpertoire courant et de ses sous-rpertoires la commande commande : find . -exec commande {} \ ; -print Pour chaque fichier trouv par la commande find, laction ralise est : commande fichier 3 / mme chose quen 2, mais uniquement si le nom du chier comporte le sufxe .suff
find . -name *.suff -exec commande {} \ ; -print
informations : voir guide : la commande UNIX xargs la commande UNIX find les caractres spciaux et expressions gnriques Manuel UNIX : xargs(1) find(1)
IV.1.6. Comment additionner ou multiplier deux entiers?

1/ En typant la variable qui reoit le rsultat Exemple : typeset -i toto titi=2 toto=215+titi*312-4+2 2/ En utilisant loprateur (( )) titi=2 Guide du KornShell sous UNIX - page 147
(( toto = 215 + titi * 312 - 4 + 2 )) 3/ en utilisant loprateur $(( )) titi=2 toto=$(( 215 + titi * 312 - 4 + 2 )) informations : voir guide : les variables la commande typeset les expressions arithmtiques
IV.1.7.
IV.1.7. Comment transformer le contenu dune variable en majuscules? en minuscules?

pour transformer le contenu de la variable toto en majuscules : typeset -u toto en minuscules : typeset -l toto informations : voir guide : les variables la commande typeset
IV.1.8. Comment contraindre une variable une longueur donne?

variable toto cadre gauche, tronque 6 caractres : typeset -L6 toto variable toto cadre droite, tronque 6 caractres : typeset -R6 toto informations : voir guide : les variables la commande typeset
IV.1.9. Comment lancer mes propres commandes sans tre oblig de spcier leur chemin absolu?
Il faut mettre le rpertoire o se trouve la commande dans la liste de la variable PATH Si ma nouvelle commande se trouve dans le rpertoire repert : PATH=$PATH : repert Si vous voulez avoir la variable PATH correctement positionne chaque session, placez laffectation dans votre chier .prole
IV.1.10.
informations : voir guide : les variables la localisation des commandes
IV.1.10. Comment rediriger les sorties standard et derreur vers des chiers spars?
Cest la mise en pratique des redirections. exemple : command 2>trace_std_erreur 1>trace_std_sortie envoie la sortie derreur de la commande command dans le chier trace_std_erreur, et la sortie standard dans le chier trace_std_sortie. informations : voir guide : les chiers, les descripteurs les redirections
IV.1.11. Comment crire un script qui ait 3 sorties standard?

Il faut que le programme crive dans trois descripteurs diffrents.
1/ Exemple avec la commande print $ more troisdes_1 # # ce programme ecrit une ligne # sur les descripteurs 3, 5, et 8 # print "debut de traitement" print -u3 "sortie sur le descripteur 3" print -u5 "sortie sur le descripteur 5" print -u8 "sortie sur le descripteur 8" print "fin de traitement" $ troisdes_1 3>sortie_3 5>sortie_5 8>sortie_8 debut de traitement fin de traitement $ more sortie_* :::::::::::::: sortie_3 :::::::::::::: : : : : : sortie sur le descripteur 3 :::::::::::::: sortie_5 :::::::::::::: sortie sur le descripteur 5 :::::::::::::: sortie_8 :::::::::::::: sortie sur le descripteur 8 $
IV.1.11.
IV.1.12.
2/ Exemple avec les redirections $ more troisdes_2 # # ce programme ecrit une ligne # sur les descripteurs 4, 5, et 6 # print "debut de traitement" print "sortie sur le descripteur 4" >&4 ls toto* >&5 # sortie sur le descripteur 5 print "sortie sur le descripteur 6" >&6 print "fin de traitement" $ troisdes_2 4>sortie_4 5>sortie_5 6>sortie_6 debut de traitement fin de traitement $ more sortie_* :::::::::::::: sortie_4 :::::::::::::: sortie sur le descripteur 4 :::::::::::::: sortie_5 :::::::::::::: toto1.c toto2.c toto_base.c :::::::::::::: sortie_6 :::::::::::::: sortie sur le descripteur 6 $
Vous pouvez remarquer que dans les deux cas, on peut en plus utiliser les sorties standards correspondant aux descripteurs 0, 1 et 2. informations : voir guide : les chiers, les descripteurs les redirections
IV.1.12. Comment drouter lexcution dun programme sur rception dun signal?
On suppose que le signal est SIG, et que la commande excuter (qui peut dailleurs tre une fonction, ou plusieurs commandes spares par des point-virgules, le tout encadr par des quotes) est command. Il faut mettre en dbut de zone concerne : trap command SIG Il est possible de mettre plusieurs signaux pour un trap, ou de mettre plusieurs trap portant sur diffrents signaux. Guide du KornShell sous UNIX - page 151
La commande command doit tre excutable par le shell au moment de la rception du IV.1.13. signal SIG. informations : voir guide : la commande kill la commande trap comment crire un shell propre
IV.1.13. Comment effectuer une slection parmi plusieurs solutions (CASE)?

On note <exp_gn> une expression gnrique. Squelette : case $variable_a_tester in <exp_gn1> ) instruction1 instruction2 ... instructionN ; ; <exp_gn2> | <exp_gn3> | <exp_gn4> ) instruction ... ; ; esac Les | entre expressions gnriques signient des OU logiques. On est bien sr autoris mettre des constantes la place des <exp_gn>. Pour une variable_a_tester donne, tous les tests successifs sont valus jusqu ce quun dentre eux soit valide; alors les instructions qui correspondent sont excutes, puis linterprteur quitte le bloc case-esac : parmi toutes les tests, un seul peut tre vri.
IV.1.13.
Exemple : $ more essai_case # # test du case avec le premier # argument fourni au fichier # case "$1" in +([0-9]) ) print "c'est un entier";; toto | tata | tutu ) print "c'est un mot d'enfant";; A* ) if [[ $1 = AB* ]] then print "ca commence par AB" else print "ca commence par A" fi ;; "" ) print "il n'y a pas d'argument" print "usage: essai_case <argument>";; * ) print "valeur non repertoriee";; esac $ $ essai_case 123 c'est un entier $ essai_case tutu c'est un mot d'enfant $ essai_case ABC ca commence par AB $ essai_case AC ca commence par A $ essai_case il n'y a pas d'argument usage: essai_case <argument> $ essai_case ambigu valeur non repertoriee $
Notez que $variable_a_tester, cest dire $1 a t encadr avec des double-quotes ; cest une prcaution prendre au cas o la variable $1 ne serait pas instancie. informations : voir guide : les expressions conditionnelles les expressions gnriques
IV.1.14.
IV.1.14. Comment ter le sufxe un nom de chier?

Utiliser de prfrence un oprateur sur une variable affecte avec le nom du chier, sinon les commandes basename et dirname. $ fichier=/tmp/prefixe.suf $ echo ${fichier%.*} /tmp/prefixe $ basename $fichier prefixe.suf $ basename $fichier .suf prefixe $ echo ${fichier#*.} suf $ echo ${fichier##*/} prefixe.suf $ dirname $fichier /tmp
informations : voir guide :
les oprateurs sur les variables
IV.1.15. Comment associer plusieurs conditions dans un test (IF)?

La seule rgle est quil doit y avoir un pour chaque if ouvert. La condition else est optionnelle. $ if [ -d ./exemples ] > then print "./exemples est un repertoire" > if [ -w ./exemples ] > then print "autorise en ecriture" > else print "non autorise en ecriture" > fi > else print "./exemples nest pas repertoire" > fi ./exemples est un repertoire autorise en ecriture $
informations : voir guide : les expressions conditionnelles les expressions gnriques
IV.1.16.
IV.1.16. Comment se dbarrasser de messages derreurs qui ne mintressent pas?

La quasi-totalit des commandes UNIX envoient leurs messages derreur sur la sortie derreur standard, cest dire le descripteur 2. Il existe un chier poubelle, une sorte de trou sans fond, appel /dev/null ; en fait, ce nest pas un chier physique, et les informations quon crit dedans sont perdues. Rajouter aprs la commande la redirection : 2>/dev/null informations : voir guide : les descripteurs de chier les redirections
Cas types : Cas types avec la ligne de commande
IV.2. Cas types avec la ligne de commande

IV.2.1. Comment bncier des facilits de lhistorique des commandes?
* vrier que le shell que vous utilisez est bien le KornShell echo $SHELL doit donner : /bin/ksh * vrier que les variables suivantes sont bien affectes : HISTSIZE HISTFILE EDITOR sinon les affecter (en les plaant dans le chier .kshrc) : HISTSIZE=40 HISTFILE=~/.sh_history EDITOR=vi Chaque nouveau ksh sera alors correctement congur pour lhistorique. * taper une commande, (suivie dun <return>), puis sur la touche <escape>, puis sur la touche <moins>: vous devez retrouver sur la ligne en cours votre prcdente commande. informations : voir guide : les variables prpositionnes
IV.2.1.
IV.2.2. Comment retrouver une commande contenant un mot particulier?

Pour retrouver la prcdente commande, taper : <escape> (dabord sur <escape>, ensuite sur -) Pour retrouver la dernire commande lance contenant toto, taper : <escape> /toto <return> Explication : Les diffrentes commandes que vous tapez sont places par le shell dans le chier indiqu par la variable HISTFILE. Le nombre maximum de commandes conserves est donn par le contenu de la variable HISTSIZE.
IV.2.2.
La ligne de commande courante correspond la dernire ligne du chier, la prcdente commande lavant dernire ligne du chier, etc...
$ tail ~/.sh_history
HISTFILE
sleep 1000 typeset -x timout ( trap timout ALRM ; sleep 10 ) & sleep 1000 kill -l env cat >>/tmp/toto more /tmp/toto more ~/.sh_history tail -f ~/.sh_history $
la ligne de commande courante lavant-avant dernire lavant dernire commande la dernire commande lance Lorsque votre curseur est devant le caractre $ de la ligne de commande, il faut vous imaginer que vous venez de lancer vi sur le chier dhistorique, et que vous tes en mode insertion sur la dernire ligne. Les lignes qui prcdent sont les commandes lances prcdemment. Donc, pour retrouver une commande, on procde comme sous vi : - pour passer en mode dplacement, on tape <escape> - pour remonter dune ligne (i.e dune commande), on tape ensuite - ou K : la commande sur laquelle on pointe dans le chier HISTFILE prend place sur la ligne de commande courante. - pour redescendre dune ligne (i.e dune commande), on tape + ou J - pour repasser en mode insertion, on peut taper i ou a , etc... - pour rechercher une chane, il faut tre en mode dplacement (donc avoir tap <escape>), puis, taper le caractre / suivi de la chane rechercher, puis <return>. Une fois la premire occurrence trouve, on peut en obtenir une seconde en tapant n. La seule incohrence par rapport vi est que la recherche se fait en remontant vers le dbut du chier, mais sinon tout est pareil.
HISTSIZE
informations : voir guide : rfrence vi :
IV.2.3.
les variables prpositionnes (voir la bibliographie)
IV.2.3. Comment tendre le nom dun chier que lon est en train de taper?
voir voir taper le dbut du nom, puis : <escape> <escape> Dtail : Sur la ligne de commande, vous tes en train de taper un nom de chier. Arrtez vous aux premiers caractres, puis tapez <escape><escape> ; le shell complte le nom, entirement sil ny a quune possibilit dans le rpertoire concern. Sinon, il sarrte lendroit du nom partir duquel il existe plusieurs solutions.
IV.2.4.
Pour avoir la liste des possibilits, tapez <escape>=, puis, tapez nouveau <escape> et rajoutez le minimum de caractres pour lever lambigut, retaper <escape><escape> pour tendre le nom, etc... $ ls test1.bad test1.bet1 test1.bet2 test2.bad voir voir $ ls test1.bet2 <return> test1.bet2 $ - - - - - autre exemple - - - - - $ echo te $ echo test 1) 2) 3) 4) 5) 6) test1.bad test1.bet1 test1.bet2 test1.bet3 test1.res test2.bad <escape>= <escape><escape> $ ls *1*2 <escape><escape>
$ echo test $ echo test
<escape>
2<escape><escape> $ echo test2.bad
informations : rfrence vi : (voir la bibliographie)
IV.2.4. Comment lancer une commande sans avoir attendre sa n?

rajouter le caractre & aprs votre commande Explication : Si vous tapez une commande suivi de <return>, le shell ne ragit plus jusqu ce que la commande en cours soit termine.
Pour reprendre la main de suite, il faut lancer la commande dans larrire-plan (ou IV.2.4. background) en rajoutant la n de la ligne le caractre &. Attention : - si la commande que vous lancez en arrire-plan fournit des informations sur les sorties derreur ou standard, elles se feront vers les chiers correspondant au moment du lancement : en particulier, la sortie derreur, si elle nest pas redirige, pointe sur la console, et risque fort de venir se mler au texte que vous tes en train de taper sur la ligne de commande, ou sous vi, un moment inopportun. Donc, il est prfrable de lancer la commande avec des redirections : commande >resu 2>resu.err & - si la commande que vous lancez attend des informations en entre, elle va se bloquer, sauf si vous avez spci une redirection en entre. Exemple : voir $ more cmd_bg # # test d'une commande en attente de deux # valeurs sur l'entree standard read val1 read val2 print $val1 $val2 $ cmd_bg & [1] 29661 $ [1] + Stopped(tty output) cmd_bg & $ jobs [1] + Stopped(tty output) cmd_bg & $ more cmd_bg.input un deux $ cmd_bg <cmd_bg.input & [2] 29663 $ un deux $ echo "un\ndeux" | cmd_bg & [3] 29664 [2] - Done cmd_bg <cmd_bg.input & $ un deux
Les deux mthodes les plus simples utiliser imposent en premier lieu danticiper le nombre dentres ncessaires pour rpondre aux attentes de la commande. On place alors les rponses soit dans un chier vers lesquels on redirige lentre standard page 160 - Guide du KornShell sous UNIX
IV.2.5.
(premire solution propose ci-dessus), soit dans un echo pip avec la commande (le passage la ligne est symbolis par le caractre \n) informations : voir guide : le caractre spcial & la gestion des processus les redirections
IV.2.5. Comment lancer une commande qui ne soit pas tue si on se dconnecte?
nohup at, batch trap nohup est une commande UNIX qui permet de lancer votre commande sans quelle soit tue si vous vous dconnectez (elle inhibe la raction au signal HUP envoy lors de la dconnexion). nohup ma_commande & ma_commande doit tre un nom de chier binaire ou shell script excutable. Les sorties standard ou derreur sont rediriges vers un chier nomm nohup.out.Le & permet de reprendre la main de suite. at et batch sont des commandes qui permettent aussi de lancer des commandes de manire dtache. Avec batch, la commande commence sexcuter tout de suite, alors que at permet de spcier la date de dbut dexcution. echo ma_commande | batch echo ma_commande | at 18 : 05 echo ma_commande | at now + 3 hours permettent de lancer ma_commande respectivement de suite, 18 heures 5 minutes, et dans 3 heures. Pour lister les commandes prcdemment programmes par at et en attente de dexcution, taper : at -l Pour supprimer une commande programme par at et en attente dexcution, taper : at -r numro_de_job numro_de_job tant un terme de la forme xxxxxxx.a, que vous pouvez obtenir en listant les commandes par at -l. trap Si votre commande est un programme shell, vous pouvez aussi placer au dbut du programme la ligne : trap "" HUP Guide du KornShell sous UNIX - page 161
et lancer la commande normalement ; votre programme continuera de tourner aprs la IV.2.6. dconnexion. informations : voir guide : la gestion des processus la commande kill et les signaux la commande trap
IV.2.6. Comment se replacer dans le rpertoire que lon vient de quitter?

taper : ou informations : voir guide : les variables internes du shell cd cd $OLDPWD
IV.2.7. Comment lister les variables positionnes? celles exportes?

Pour les variables positionnes dans le shell courant, taper set Pour les variables positionnes et exportes : env informations : voir guide : les variables internes du shell la commande set
IV.2.8. Comment mettre le rpertoire courant dans le prompt?

PS1=$PWD $ informations : voir guide : les variables internes du shell le mode dinterprtation des commandes
IV.2.9. Comment crire un alias?

alias mon_alias=ma_commande La commande suivante : mon_alias para1 para2 para3 est transforme aprs substitution en : page 162 - Guide du KornShell sous UNIX
IV.2.10.
ma_commande para1 para2 para3

Remarque : les paramtres passs mon_alias sont recopis dans le mme ordre la suite de la chane ma_commande, sans possibilit de mixer. Pour que lalias soit positionn dans chaque interprteur de chaque fentre, placer la dclaration de lalias dans votre chier .kshrc
informations : voir guide : le mode dinterprtation des commandes : les alias o mettre les alias (voir ci-aprs)
IV.2.10. Dans quel chier faut-il dclarer les variables et les alias pour les avoir positionnes chaque session?
Il existe deux chiers de conguration dans votre rpertoire principal qui permettent de positionner variables et les alias : .profile qui est excut une seule fois au moment de la connexion une machine. On y met les variables exporter, le positionnement du PATH, la conguration de la console (caractre <backspace>, etc), en gros, tout ce qui doit tre positionn au moment du login. Il est conseill galement dindiquer le nom du chier de conguration du Ksh, en positionnant la variable ENV (voir ci-dessous). .kshrc qui est excut au dmarrage de chaque interprteur de commandes. On y positionne les variables non exportes, on y dnit les alias et les fonctions. Remarque: lorsque le ksh dmarre, il value la variable ENV et charge la conguration du chier indiqu par ENV: en standard, cest toujours .kshrc, mais rien ne vous empche de le changer.
IV.2.11. Comment lancer une commande avec le contenu du buffer de la souris?

La commande choisie doit accepter lentre standard comme source de donnes.
1/
2/
choisir une fentre et lancer la commande avec les bonnes options, mais sans chier de donnes ni redirection de lentre standard ; la commande doit se bloquer et rester en attente ; avec la souris, slectionner une zone alphanumrique dune fentre (noircir), puis vider le contenu du buffer dans la fentre o a t lance la
3/
commande. Vous pouvez aussi taper des caractres au clavier, des retour- IV.2.12. chariots, et rpter plusieurs reprises cette tape ; toujours dans la fentre o a t lance la commande, taper un retour chariot (<return>), puis le caractre <control D> : la commande commence alors sexcuter. voir guide : le contrle des processus par le clavier
informations :
IV.2.12. O trouver la liste des caractres ascii?

lister le chier /usr/pub/ascii
IV.2.13. Comment lister les chiers par ordre de taille?

ls -l| sort -n +4 la commande sort fait un tri sur le cinquime champ (les champs sont numrots partir de zro) du chier gnr par la commande ll ; le cinquime champ correspond la taille du chier. loption -n stipule que le classement se fait de manire numrique. Pour avoir le tri par ordre dcroissant : ls -l | sort -nr +4 avec loption -r comme reverse informations : voir guide : la commande sort
IV.2.14. Que faire lorsque le shell refuse dafcher le prompt et dexcuter mes commandes aprs chaque retour chariot?
1er cas : vous navez pas referm une quote ou double-quote de la prcdente commande tape, voire une boucle for ou une structure if : dans ce cas, chaque <return> doit provoquer le passage la ligne avec afchage du caractre > en premire position. => taper <control C>, puis rcuprer la commande avec lditeur et vrier la syntaxe. : la commande prcdente attend ses donnes sur lentre standard par dfaut, cest dire le clavier de votre fentre courante. => taper <control D> pour signier la commande la n de chier dans lentre standard : dans ce cas, les caractres dj taps lcran sont utiliss par la commande.
2me cas
IV.2.15.
3me cas
Mez vous cependant, car le shell lui-mme considre <control D> comme la n des commandes que vous tes en train de taper: Si cest lui qui rcupre la squence, il se termine et rend la main: vous perdez la fentre ou la connexion avec laquelle vous travailliez. => taper <control C> pour annuler la commande. : la commande prcdente nest pas termine ; => attendre ou => taper <control C> pour stopper la commande en cours.
informations : voir guide : le contrle des processus par le clavier
IV.2.15. Pourquoi la sortie dcran continue t-elle de dler alors que je viens de taper plusieurs fois <control>C?
Cela arrive gnralement avec des commandes qui gnrent des sorties assez importantes (les lignes dlent en grand nombre sur la fentre). Gnralement, lafchage des donnes lcran prend plus de temps que la gnration des informations par la commande : par suite, lafchage par X11 utilise un buffer pour stocker linformation momentanment. Lorsque vous interrompez lexcution dune commande, X11 continue de vider le buffer et dafcher les informations lcran. Pour stopper le dlement, utilisez <control S>, puis <control C> pour interrompre la commande correspondante, puis <control Q> pour reprendre lafchage normal.
informations : voir guide : le contrle des processus par le clavier
Cas types : Cas types avec les commandes UNIX
IV.3. Cas types avec les commandes UNIX

IV.3.1. Comment trier un chier sur le 3me champ?
sort voir
IV.3.1.
sort +2 mon_fichier ou, avec la nouvelle syntaxe : sort -k2, mon_fichier voir Pour la commande sort, les champs dun chier sont reprs partir du rang 0. informations : voir guide : la commande sort
IV.3.2. Comment trier un chier sur plusieurs champs?

La commande sort trie par dfaut sur le premier champ, puis, si plusieurs lignes ont le premier champ identique, trie ces lignes sur le deuxime champ, etc... Rien nempche de modier lordre de prise en compte des champs pour le tri : on peut commencer par trier sur le troisime champ, puis sil y a ambigut, sur le quatrime, puis sil y a encore ambigut, sur le premier ; cela donne (en notant les champs partir de zro) : voir sort -k2,4 -k0, mon_fichier voir La squence 2,4 indique que le tri est fait sur la squence de champs numrots de 2 4, 4 non inclus. Si le chiffre 4 ntait pas mis, le tri serait fait sur la squence de champs numrots de 2 jusqu la n de ligne.
Attention, ne pas oublier que les champs sont numrots partir de 0.
informations : voir guide : la commande sort
IV.3.3. Comment rechercher un chier dans mon arborescence?

nd Pour rechercher un chier de nom donn dans rpertoire, et dans les sous-rpertoires : find rpertoire -name nom_du_fichier -print
IV.3.4.
nom_du_fichier peut comprendre des caractres spciaux du shell, comme * ou ?, etc...

Pour rechercher les chier dont la taille est exactement N caractres : find rpertoire -size Nc -print Pour rechercher tous les chiers dont la taille est diffrente de N caractres : find rpertoire ! -size Nc -print Pour rechercher les chiers modis il y a moins de trois jours : find rpertoire -mtime -3 -print informations : voir guide : la commande find
IV.3.4. Comment excuter une commande sur une liste de chiers?

Les noms des chiers traiter sont prsent sur lentre standard, ou dans un autre chier (liste) : xargs cat liste | xargs ma_commande xargs lance ma_commande pour chaque ligne du chier dentre, en fournissant comme argument ma_commande chacun des champs de la ligne. Exemple : ls -1 | xargs rm excute une commande rm pour chacun des chiers lists par la commande ls. Loption -1 du ls force la sortie de la commande sur une colonne. while do done Dans un shell, on peut remplacer xargs (qui est pratique pour lancer une commande simple) par une boucle while do done si le traitement est plus complexe. informations : voir guide : la commande xargs les structures de boucle Comment lire un chier ligne ligne? manuel (1) : la commande xargs
IV.3.5.
IV.3.5. Comment excuter une commande sur tous les chiers de mon arborescence?
La commande est lancer sur tous les chiers dun rpertoire et de ses sous-rpertoires ; nd find rpertoire -exec ma_commande {} \; excute successivement ma_commande avec comme paramtre chacun des chiers trouvs dans rpertoire et ses sous-rpertoires. La squence {} symbolise le nom du chier courant (pass comme argument ma_commande), et la squence \; symbolise la n de la commande Exemple :
$ ls sort* sortie_4 sortie_5 sortie_6 $ find . -name sort* -exec ls -l {} \; --w-r--r-- 1 logis users 28 Apr 30 1:04 ./sortie_4 -rw-r--r-- 1 logis users 28 Apr 30 14:04 ./sortie_5 -rw-r--r-- 1 logis users 28 Apr 30 14:04 ./sortie_6 $ find . -name sort* -exec ls -l {} \; -exec echo {} "ok" \; --w-r--r-- 1 logis users 28 Apr 30 14:04 ./sortie_4 ./sortie_4 ok -rw-r--r-- 1 logis users 28 Apr 30 14:04 ./sortie_5 ./sortie_5 ok -rw-r--r-- 1 logis users 28 Apr 30 14:04 ./sortie_6 ./sortie_6 ok $ find . -name sort* -exec echo {} "ok" \; ./sortie_4 ok ./sortie_5 ok ./sortie_6 ok $
informations : voir guide : la commande find manuel (1) : la commande find
IV.3.6. Dans un chier, comment supprimer les lignes dont les 2 derniers champs sont identiques?
On recopie les lignes dont lavant-dernier et le dernier champ ne sont pas gaux entre eux : awk NF>=2 && $(NF-1)!=$NF {print} mon_fichier
IV.3.7.
Pour la commande awk, $i correspond la valeur du champ numrot i (en commenant au rang 1), et la variable NF indique le nombre de champs dans la ligne : donc, $NF correspond au dernier champ de la ligne, et $(NF-1) lavant dernier. La commande revient imprimer ( {print} ) les lignes qui ont au moins deux champs ( NF>=2 ) et (&&) dont les deux derniers champs sont gaux ( $NF==$(NF-1) ). La prsence de la commande print ( {print} ) est optionnelle, car cest laction ralise par dfaut. informations : voir guide : la commande awk manuel (1) : la commande awk
IV.3.7. Dans un chier tri, comment conserver une seule ligne parmi celles dont le 2me champ est identique?
Cela consiste trier le chier sur le deuxime champ, puis comparer les lignes conscutives pour supprimer celles dont le deuxime champ est identique celui de la ligne qui prcde. Exemple : $ more tst_uniq un deux trois quatre cinq un 2 trois quatre cinq un deux trois 4 cinq un deux trois quatre cinq un deux trois quatre 5 $ sort +1 tst_uniq | > awk chp2 != $2 { print } > { chp2 = $2 } un 2 trois quatre cinq un deux trois 4 cinq $
Explications : sort +1 tst_uniq on trie le chier tst_uniq sur le deuxime champ awk chp2 != $2 { print } { chp2 = $2 } * pour chaque ligne o le contenu de la variable chp2 nest pas gal au deuxime champ, on ralise laction {print}, cest dire lafchage de la ligne. * quelque soit la ligne, on ralise laffectation chp2 = <deuxime champ>. Cela revient mmoriser le deuxime champ pour le test qui aura lieu la ligne suivante. Guide du KornShell sous UNIX - page 169
Remarques : - pour awk, une variable non affecte vaut la chane nulle : cest ce que vaut chp2 la premire valuation. - les champs sont numrots partir de 1 pour la commande awk. informations : voir guide : la commande sort la commande awk
IV.3.8.
IV.3.8. Comment convertir un nombre dcimal en hexa?

1re solution : typage dune variable du shell $ typeset -i16 val $ val=35 $ echo $val 16#23 $ echo ${val#*#} 23 2me solution : la commande dc $ val=35 $ echo "16o${val}p" | dc 23 $
on passe la commande dc : * le terme 16o qui indique que la sortie se fait en hexa * le contenu de la variable val ( ${val} ) * le terme p qui provoque lafchage dans la base spcie.
informations : voir guide : la commande interne typeset la commande dc, la commande bs les oprateurs sur les variables
IV.3.9.
IV.3.9. Comment lancer une commande une date donne?

at Pour lancer ma_commande 21 heures 35 aujourdhui : echo ma_commande | at 21 : 35 Pour lancer ma_commande dici 3 heures : echo ma_commande | at now + 3 hours Pour lancer ma_commande dici 3 jours, la mme heure : echo ma_commande | at now + 3 days
informations : manuel (1) : la commande at
IV.3.10. Comment retrouver les chiers qui nont pas t modis depuis plus de trois jours? depuis moins de 3 jours?
plus de 3 jours : find . -mtime +3 -print pour chaque chier, le test -mtime +3 est ralis, et sil est valide, la commande -print est lance. moins de 3 jours : $ find . -mtime -3 drwxr-xr-x 2 logis -rw-r--r-- 1 logis -rw-r--r-- 1 logis -rw-r--r-- 1 logis -rw-r--r-- 1 logis $ -exec ls -ld {} \; users 1024 May 14 17:07 users 30 May 14 14:40 users 51 May 14 14:22 users 119 May 14 18:03 users 99 May 14 17:14
. ./tst_sort1 ./tst_sort ./tst_uniq ./tst_3chp
pour chaque chier, le test -mtime -3 est ralis, et sil est positif, la commande -exec ls -ld {} \; est lance, ce qui provoque lexcution du ls -ld avec le nom du chier courant (symbolis par {} ).
informations : voir guide : la commande find
IV.3.11.
IV.3.11. Comment extraire les 4me et 5me champs des lignes de mon chier?
awk awk { print $4, $5} mon_fichier cut cut -d" " -f4,5 mon_fichier loption -d"<space>" spcie que le sparateur de champs est le caractre <space> (<tab> par dfaut) informations : voir guide : la commande awk manuel (1) : la commande awk la commande cut
IV.3.12. Comment garder toutes les lignes de mon chier qui ne contiennent pas une chane particulire?
grep grep -v ma_chaine mon_fichier loption -v spcie que les lignes afches sont celles qui ne contiennent pas ma_chaine. awk awk ! /ma_chaine/ mon_fichier le caractre ! correspond un NON logique. Si la chane ma_chaine napparait pas dans la ligne courante, elle est afche (laction par dfaut est {print} ) informations : voir guide : la commande grep la commande awk
IV.3.13. Comment recopier un rpertoire entier?

cp La commande cp peut tre utilise en mode rcursif avec loption -r. cp -r ancien nouveau Si nouveau nexistait pas, il est cr, et son contenu est celui dancien. page 172 - Guide du KornShell sous UNIX
IV.3.13.
Si nouveau existait dj, une copie dancien est place dans nouveau, sous le mme nom. Avantage : Simplicit. Inconvnients : - les dates de tous les chiers du nouveau rpertoire sont les dates actuelles, et non pas celles des chiers dorigine. - les liens symboliques ne sont pas recopis, et les liens physiques sont recopis mais pas en temps que lien (le rsultat est un chier contenant la mme chose que le lien, mais ce nest plus un lien). tar cd ancien tar cf - . | ( cd nouveau ; tar xvf - ) Le rpertoire nouveau doit avoir t cr avant de lancer la commande. Avantages : - les dates de chiers sont celles des chiers originaux. - comme il y a un pipe, on peut faire passer facilement le tout par le rseau ; exemple : cd ancien tar cf - . | remsh machine "cd nouveau ;tar xvf -" Idem, prcdent, mais la recopie seffectue sur machine, plutt que sur la machine sur laquelle vous tes connect. - les liens symboliques et physiques sont conservs.
voir
Inconvnients : - complexit - les dates de chiers sont conserves, mais pas les dates de rpertoires, qui sont celles de cration du nouveau rpertoire. cpio cd ancien find . -depth -print | cpio -pd nouveau Le rpertoire nouveau doit avoir t cr avant de lancer la commande. Avantages : - les dates de chiers et rpertoires sont celles des chiers originaux. - les liens symboliques et physiques sont conservs. Guide du KornShell sous UNIX - page 173
Inconvnients : complexit
IV.3.14.
informations : voir guide : les liens manuel (1) : les commandes cp, cpio, tar
IV .3.14. Comment retrouver les chiers qui font un lien sur un chier donn?
find $ ln -s tst_uniq tst1 $ ln tst_uniq tst2 $ ls -l tst1 tst2 lrwxr-xr-x 1 logis users 8 May 15 11:56 tst1 -> tst_uniq -rw-r--r-- 2 logis users 119 May 14 18:03 tst2 $ find . -linkedto tst_uniq -print ./tst_uniq ./tst2 $ find . -follow -linkedto tst_uniq -print ./tst_uniq ./tst1 ./tst2 $ voir Explication : La premire commande ln cre un chier tst1 qui est un lien symbolique vers tst_uniq ; la deuxime cre un chier tst2 qui est un lien physique vers tst_uniq. La premire commande find recherche uniquement partir du rpertoire courant (symbolis par . ) les chiers lis physiquement tst_uniq (mme inode). Le deuxime find comporte loption -follow qui fait suivre les liens symboliques : les noms des chiers obtenus sont ceux lis physiquement ou symboliquement au chier tst_uniq.
voir
IV.3.15.
Une autre mthode consiste travailler avec le numro dinode qui rfrence de manire unique un chier.
$ ls -i tst_uniq 51351 tst_uniq $ find . -inum 51351 -print ./tst_uniq ./tst2 $ find . -follow -inum 51351 -print ./tst_uniq ./tst1 ./tst2 $
On commence par obtenir le numro dinode du chier de rfrence, puis on parcourt larborescence la recherche de tous les chiers ayant le mme inode. La premire commande donne les chiers tant lis physiquement, la seconde les chiers tant lis physiquement ou logiquement. Loption -linkedto du find fait en fait automatiquement le lien entre le nom du chier et linode: le principe de la recherche est en fait le mme.
informations : voir guide : la commande find les liens, la commande ln
IV.3.15. Pourquoi je narrive pas supprimer mon chier? en crer un?

Pour crer un chier ou le supprimer, il faut avoir les droits dcriture sur le rpertoire qui contient le chier. Donc, tapez la commande ls -ld le_rpertoire, puis la commande id et comparez les droits autoriss, le propritaire, le groupe du rpertoire avec vos noms dutilisateur et de groupe :
- le nom de propritaire et votre nom dutilisateur doivent correspondre si le rpertoire a les droits en w pour le propritaire, - ou alors les deux noms de groupe si le rpertoire a les droits en w sur le groupe, - ou alors le rpertoire doit avoir le droit w pour les autres (others)
Remarque : Si vous essayez de crer un chier qui, en fait, existe dj, le propritaire, le groupe, et les droits de lancien chier sont conservs. Par exemple, si vous faites ma_commande >/tmp/toto et que le chier /tmp/toto existe dj et na pas les bons droits pour vous, vous narriverez pas y crire dedans.
IV.3.16.
informations : voir guide : les droits sur les chiers
IV.3.16. Comment positionner par dfaut les droits dun chier ?

Lorsque on cre un chier, ses droits1 sont positionns en fonction de valeurs par dfaut. On peut consulter cette valeur par dfaut en tapant la commande umask, ou la modier si on fournit une valeur en paramtre. Le nombre qui est donn en rsultat, ou que lon donne en paramtre, est compos de trois chiffres, le premier sappliquant aux droits de lutilisateur, le second ceux du groupe, le troisime tous les autres utilisateurs. Ce nombre indique, pour chaque type dutilisateurs, les droits enlever en lecture, criture, et excution. Numriquement, le droit en lecture vaut 1, celui en criture vaut 2, et celui en excution vaut 4. Si le rsultat de la commande umask donne 022, cela indique qu toute nouvelle cration de chier, les droits dcriture (valeur = 2) pour le groupe et les tous les autres sont supprims. Le chier est donc du type -rw-r--r-Si vous dsirez que vos chiers ne soient autoriss en lecture que pour vous seul, il faut modier la valeur par dfaut en tapant la commande umask 066 : on enlve alors les droits de lecture (valeur = 2) et les droits en criture (valeur = 4), au total 6, pour le groupe (deuxime position) et tous les autres (troisime position). Toutes les combinaison sont possibles. Les droits par dfaut peuvent tre positionns diffremment dans les diffrents shells en activit: ce qui veut dire aussi que si vous modiez les droits dans un shell, ils seront inchangs dans les autres. Cest pourquoi la meilleure mthode est de placer la commande umask dans le chier .profile: la valeur est vue ensuite partout, par hritage. La commande chmod permet ensuite, au coup par coup, de changer les droits de chiers dj crs, suivant le mme principe.
1. Voir les droits sur les chiers, page 23
IV.3.17.
informations : voir guide : les droits sur les chiers manuel(1): les commandes chmod et umask
IV.3.17. Comment dterminer le type ou le contenu dun chier?

le strings what Il est facile de dterminer le contenu dun chier texte (programme shell, source ADA ou C, donnes, etc...) en le listant par une commande classique (more, vi, etc), mais plus dlicat de dcouvrir ce que renferme un chier binaire. En premier lieu, on peut appliquer la commande file sur le chier de type inconnu : - lindication donne mentionne un chier de type text : se mer, car lanalyse est souvent errone (au moins 50% dincertitude). Mais on peut en thorie lister son contenu. - lindication donne mentionne un chier de type executable : votre chier est un binaire excutable (100% exact). Une autre exploration peut tre faite en utilisant la commande what qui recherche dans le chier une chane de caractres prcde de la squence : voir @(#) Cest le cas de pratiquement tous les excutables UNIX qui intgrent ainsi leur version, ou leur date de mise jour1. Mais, malheureusement, la plupart des applications ou des commandes qui ne font pas partie intgrante du systme lui-mme ne comportent pas une telle indication. Si le chier est un excutable, ou un core2, il est possible tout de mme destimer son contenu en appliquant dessus la commande strings, qui liste toutes les constantes de type chane inclues dans le binaire : cest en gnral sufsant pour dterminer le type de langage dont il est issu (voir les exemples avec la description de la commande strings).
informations : voir guide : la commande file la commande strings
1. un exemple est donn sur la commande UNIX awk; voir page 94. 2. voir le chapitre sur les messages derreur: page 208
IV.3.18.
IV .3.18. Comment avoir la rponse une question qui napparait pas ci-dessus?
Linformation la plus able se trouve dans le manuel en ligne, par lintermdiaire de la commande man. (chaque constructeur propose au travers de son environnement graphique une aide intractive un peu plus labore, bien que linformation elle-mme soit identique). Faire man la_commande pour avoir des informations sur la_commande, et man ksh, pour avoir des informations sur le shell (variables, syntaxe des boucles, etc...). En plus des information sur les commandes, vous pouvez vous documenter sur le format de certains chiers. voir Voici quelques entres intressantes: man profile: donne le format du chier et quelques exemples. voir man ascii : liste des caractres ascii (idem /usr/pub/ascii) man regexp : dnition des expressions rgulires et des expressions gnriques. man suffix : convention des sufxes sous Unix Si vous possdez un manuel papier, cherchez dans le manuel de rfrence section 1 ; les informations sont celles du manuel en ligne, sauf si la version de la documentation ne correspond pas celle du systme dexploitation de votre machine. Le manuel est crit, cest vrai, de manire assez rbarbative, mais vous y trouverez quasiment toutes les informations dont vous pouvez avoir besoin. Vous pouvez aussi vous rapporter des ouvrages de librairie, utiles pour avoir une ide des diverses possibilits du shell, mais qui ne tiendront que rarement compte des spcicits de la version dUNIX que vous utilisez. (voir la bibliographie)
Optimiser un programme shell
V.
V. Optimiser un programme shell
Optimiser un programme shell : Cot dexcution
V.1. Cot dexcution

Lorsqu un programme sexcute, les deux actions les plus coteuses en ressources sont : la cration dun processus Lancer une commande UNIX (cp, ls, sort, vi...), ou un programme shell script, ncessite la cration dun processus. Or, la cration dun processus demande un grand nombre doprations : faire de la place en mmoire, charger lexcutable, mettre jour toutes les tables internes (chiers standard, signaux, etc..), vrier les droits, ... Et lorsque le processus se termine, une partie de ces oprations est reprendre... Si la commande travaille de plus sur une petite quantit de donnes, le temps pass par la machine crer, puis supprimer le processus est trs important par rapport au temps pass sur la tche rellement lie la commande de lutilisateur. Exemple : . $ time ( echo Durand | sed s/D/d/ ) durand real 0m0.08s user 0m0.02s sys 0m0.06s $
IV.3.18.
la commande time mesure le temps dexcution dune autre commande : real est le temps qui sest coul entre le dbut et la n de la commande : echo Durand | sed s/D/d/ user est le temps pass par le cpu travailler pour lutilisateur sys est le temps pass par le cpu pour grer le processus lui-mme (cration, etc..) et manipuler les ressources lies aux chiers ouverts (pointeurs, index, etc...) (la somme de user et de sys nest jamais gale real puisque le temps cpu est partag entre les diffrents utilisateurs) Vous pouvez remarquer que la commande : echo Durand | sed s/D/d/ a consomm ici trois fois plus de ressources systme que de ressources utilisateur. Cet exemple montre quil existe bien un cot xe lors du lancement dune commande. Si cette commande travaille sur un gros chier, ce cot xe est ngligeable.
Optimiser un programme shell : Cot dexcution
IV.3.18.
Par contre, lexemple indiqu ci-dessus, qui apparait souvent dans des scripts, parce que cest vrai quil repose sur des commandes bien connues, est assez contestable : - Si votre script comporte quelques excutions de ce type en tout et pour tout, la simplicit et la lisibilit lemportent sur un gain de performances nalement minime au total ; - Mais trs souvent, cette commande compose apparait dans des boucles while, par exemple sur des lectures de chier. Il suft que le chier fasse 500 lignes et elle sera donc lance 500 fois. Comme ici, la commande compose lance 2 processus pour se raliser (un echo et un sed), cest donc 1000 processus qui seront cres durant lexcution de ce script. Si cest la seule mthode existante pour aboutir la solution dsire, vous navez pas le choix. Mais le plus souvent, il est possible de remplacer les n lancements de commande sur un petit peu dinformation, par un seul lancement sur n fois un petit peu dinformation. Le principe consiste : - regrouper la totalit des donnes de dpart dans un chier ou dans un pipe - slectionner la partie, cest dire la ou les colonnes du chier (ou du pipe) dans laquelle les donnes sont traiter, et stocker le reste dans un chier (ou pipe) annexe - lancer la commande sur lensemble des donnes slectionnes - rassembler le tout se qui se traduit en pratique par peu prs autant de commandes que doprations dcrites cidessus : cest dire quatre ou cinq, et quelque soit la taille du chier dentre. Un exemple est donn ci-aprs.
la cration dun chier Comme on la indiqu ci-dessus, les chiers sont manipuls et contrls via le systme dexploitation : chaque fois que vous crez ou supprimez un chier, de nombreux index et tables sont mis jour ; or la plupart du temps, ces informations se trouvent sur le disque, dont le temps de rponse est trs important. Crer ou supprimer un chier, de la mme faon que pour un processus, nest rentable que si son contenu est consquent.
Cest donc du vrai gaspillage que de slectionner une ligne ou une chane de caractre et de la stocker dans un chier : mettez la plutt dans une variable !
Optimiser un programme shell : Quelques conseils en vrac
V.2. Quelques conseils en vrac

Utilisez de prfrence les commandes internes du shell (en particulier, les oprateurs sur les variables) des commandes quivalentes UNIX : comme il ny pas de nouveau processus crer, lexcution est beaucoup plus rapide. les fonctions crites en shell sont moins rapides que les commandes internes, mais plus rapides que les commandes UNIX. utilisez loprateur [ ] ou [[ ]] dans les tests if ou while plutt que la commande UNIX test. il est plus rapide de faire excuter une commande complexe (avec de nombreuses options) que plusieurs simples enchanes (en raison du cot xe de cration des processus).1 pour acclrer le dmarrage de commandes UNIX trs souvent appeles, il vaut mieux indiquer leur chemin daccs absolu, plutt que de laisser le shell les localiser dans le PATH. placez les rpertoires contenant les commandes les plus souvent utilises au dbut du PATH. Evitez davoir un PATH trop long. limitez dans le PATH la prsence de rpertoires vus par NFS (Network File System): chaque dmarrage (chaque console, chaque fentre), le shell tente daccder chacun des rpertoires du PATH, et si un des serveurs, ou le rseau, est indisponible, vous serez bloqu le temps du timeout (de lordre de la minute). Placez plutt lextension du PATH dans un script qui dmarre lutilitaire du serveur distant. spciez loption trackall2 qui gnre un alias interne chaque nouvelle commande lance et cherche dans le PATH : au lancement suivant, la localisation nest plus refaire. limitez les lectures de chier ligne ligne en utilisant des boucles while-do-read-done : le nombre de commandes lances lintrieur de la boucle doit tre diminu au maximum. si vous utilisez chacun des cycles du traitement un chier temporaire, inutile de le supprimer chaque fois : il suft dy crire en mode write (avec une redirection >), ce qui le rinitialise, sans avoir le recrer. vitez lappel des commandes UNIX lintrieur dun programme awk3.
IV.3.18.
1. cette remarque est moduler en fonction de la quantit des donnes traiter : sur de gros chiers, il est parfois plus intressant de lancer plusieurs commandes lmentaires mais dexcution rapide, plutt quune seule trs complexe et donc plus lente. 2. set -o trackall plac en dbut de programme 3. par lintermdiaire de la fonction system
Optimiser un programme shell : Exemples pour viter les boucles
V.3.1.
V.3. Exemples pour viter les boucles

V.3.1. Recherches de chanes
Un exemple classique consiste manipuler deux chiers de la faon suivante : - un premier chier reference contient des donnes de rfrence. Par exemple : Jef 17623 Jean-Hugues 16173 Agns 16579 Denis 16239 ... qui contient une correspondance entre des noms et des numros de tlphone. - un deuxime chier travail contient des donnes de travail. Par exemple : Agns "inviter au restaurant" Denis "proposer un squash" Jacques "annuler le rendez-vous" ... qui contient une liste de personnes et un message leur transmettre. Lobjectif est de crer un chier rsultat, qui contienne les noms des personnes appeler, le message correspondant et le numro de poste. Premire mthode avec une boucle : exec 3<travail while read -u3 nom message do poste=$(grep "^$nom " <reference) print $nom $poste $message done Si on analyse lexcution, on saperoit :
- que la commande grep est lance autant de fois quil y a de lignes dans le chier travail - que le chier reference est parcouru lui aussi par le grep autant de fois quil y a de lignes dans le chier travail. Si les chiers travail et reference sont trs gros, on voit bien que le traitement est loin dtre optimis. Guide du KornShell sous UNIX - page 183
Deuxime mthode sans boucle sort -o reference.trie reference sort -o travail.trie travail join -1 1 -2 1 travail.trie reference.trie Ici, on utilise pour faire la correspondance la commande join1 et deux commandes sort pour trier les chiers de dpart sur le champ qui sert de jointure entre les deux. En tout et pour tout, trois commandes, quelque soit la taille des chiers dentre. Les commandes sort et join sont dune complexit plus grande que grep, bien sr, mais le gain est cependant norme. Bien sr, le cas prsent ici est trivial, mais la dmarche gnrale est toujours la mme : elle consiste regrouper deux chiers dentre qui contiennent une partie des informations chacun, en un nouveau qui ne contient plus que les informations utiles, si possible ranges de manire homogne sur une mme ligne ou une mme colonne. On ritre lopration plusieurs fois jusqu avoir un chier qui contienne toutes les informations utiles pour gnrer le rsultat2. Notez que beaucoup de boucles while-do-read-done peuvent ainsi tre remplacs efcacement par un enchanement dun petit nombre de commandes : awk, sed, sort, join, paste.
V.3.2.
V.3.2. Manipulation dune partie de ligne

Lexemple que lon prend ici est celui dun chier (travail) qui sur chaque ligne contient deux valeurs en hexadcimal : Par exemple : Jef 125 f235 Totof d12 10a4 Agnes 394b 12 Jean-Hugues b456 312 Denis 0 8e97 ... Le but de lopration consiste rajouter en n de ligne la racine carre de la somme des deux valeurs dj existantes.
1. voir son utilisation en dtail dans le chapitre sur les commandes UNIX: page 116 2. attention quand mme la taille du chier : il ne sagit pas den fabriquer un norme !
V.3.2.
Premire mthode avec une boucle : exec 3<travail while read -u3 nom val1 val2 do val3=$(echo "ibase 16\nsqrt(0$val1+0$val2)"|bs) print $nom $val1 $val2 $val3 done
voir
Lexcution de cette boucle provoque la cration de deux processus par ligne de calcul : un echo et un bs. (Le zro rajout devant les nombres avant le calcul vite bs de confondre les nombres hexa commenant par une lettre avec une variable) Deuxime mthode sans boucle awk BEGIN{ print "ibase 16" } { print "sqrt(0" $2 "+0" $3 ")" } <travail | bs >tempo paste travail tempo Ici, on cre un chier temporaire (en fait, un pipe) contenant toutes les donnes dans le format adquat pour un calcul simultan par bs de toutes les valeurs. Puis, aprs passage par bs, on concatne ligne ligne avec un paste le chier rsultat avec celui de dpart, les deux chiers ayant logiquement chacun le mme nombre de lignes. Quelque soit le nombre de lignes du chier dentre, le calcul ncessite trois commandes (awk, bs, et paste) et un chier temporaire.
V.3.2.
Ecrire un programme shell propre
VI.
VI. Ecrire un programme shell propre
Ecrire un programme shell propre : Pourquoi perdre du temps?
VI.1. Pourquoi perdre du temps?

Chaque fois que vous passez du temps crire un programme shell pour une utilisation donne, pensez quil y a de fortes chances pour quil soit utilis plusieurs fois, dans des conditions vraisemblablement lgrement diffrentes, et alors que vous aurez oubli exactement la faon de lutiliser. Il se peut aussi que dautres personnes soient amenes lutiliser. Dans tous les cas, vous viterez beaucoup de fausses manipulations et de recherches inutiles par la suite si vous prenez quelques prcautions au moment de sa cration.
V.3.2.
Ecrire un programme shell propre : Choix du shell utiliser
V.3.2.
VI.2. Choix du shell utiliser

La version dUNIX que vous utilisez comporte trois shells spciques : le sh, le csh, et le ksh que vous utilisez probablement. Comme leur syntaxe prsente des particularits, un programme crit pour un shell a trs peu de chances de fonctionner correctement avec un autre. Pour imposer un shell particulier lors de lexcution dun programme, il faut rajouter en premire ligne : #! /bin/mon_shell
mon_shell pouvant prendre les valeurs : sh, csh ou ksh suivant la syntaxe choisie. Le commentaire doit dmarrer au dbut de la ligne.
Il vous est conseill dutiliser le ksh, celui-ci offrant tous les services des deux autres, plus quelques-uns supplmentaires...
Ecrire un programme shell propre : O mettre le nouveau programme
VI.3. O mettre le nouveau programme

Sauf dans certains cas particuliers, il vaut mieux placer la version au point de votre programme dans un rpertoire o seront runis tous vos scripts. Par exemple, vous pouvez crer un rpertoire bin dans votre rpertoire principal, et y mettre tous vos programmes jour. Pour lancer vos programmes depuis nimporte quel rpertoire, rajoutez dans votre chier de conguration .profile la modication adquate de la variable PATH : PATH=$PATH:$HOME/bin
V.3.2.
Ecrire un programme shell propre : Commentaires, version
V.3.2.
VI.4. Commentaires, version

Il y a de fortes chances pour quaprs quelques temps, vous ne sachiez plus exactement ce que fait votre programme, ni dans quelles conditions on peut lutiliser. Nhsitez pas mettre quelques lignes de commentaires (commenant par un caractre #) qui aident beaucoup. Lexprience montre que rapidement co-existent plusieurs versions du mme programme, des stades de dveloppement diffrents, ou destins des usages lgrement diffrents : si vous navez pas mis de commentaires, il devient trs difcile de retrouver lusage exact de prog, par rapport prog1, ou prog%, ou encore prog_ok, si leur contenu se ressemble un peu. Il arrive aussi quun mme programme soit recopi sur plusieurs machines, ou dans plusieurs rpertoires ; si la date de dernire modication napparait pas dans les commentaires, vous aurez certainement des doutes sur la version de rfrence. En rsum : Il est bon de rajouter en dbut de programme (aprs le #! /bin/ksh) : - le nom du programme - quoi il sert - la date de dernire modication - un exemple de commande complte (avec paramtres, options, etc...) - ventuellement, certaines particularits.... Remarque: Ce nest pas lobjet de ce document, mais sachez quil est trs utile, lorsque vous crivez des programmes en langage C, Ada, etc.. dinsrer une chane de type constante, dmarrant par @(#) et suivie des informations indiques ci-dessus. En effet, une fois votre source compil, vous pourrez retrouver ces informations en lanant la commande what sur votre excutable ou votre module objet. Sans quoi, vous naurez que la date de dernire modication, la taille, ou le nom du chier pour retrouver la version considre, ce qui est bien moins pratique et sr quun commentaire en clair !
Ecrire un programme shell propre : Test des options, vrication des arguments
VI.5. Test des options, vrication des arguments

Lorsque vous crez un programme, vous pouvez lui donner une certaine modularit en le paramtrant grce lusage des paramtres ($1, $2, $3, etc...) ventuellement sous la forme d options (-opt1, -opt2, etc...) spcies au lancement. Si la validit de ces paramtres ou ces options nest pas correctement teste, vous risquez fort aprs quelques temps doublier les conditions exactes de fonctionnement, de lancer de manire incorrecte votre programme et dobtenir un rsultat erron, voire catastrophique. De plus, il est particulirement dsagrable en retour dune commande davoir un message derreur du shell souvent incomprhensible premier abord (ce sera vraisemblablement le cas si vous passez votre programme un type dargument non prvu), plutt quune indication pertinente du mauvais usage que vous en avez fait. Il faut donc tester la validit de chacun des arguments passs au programme. Le test se droule en deux passes : - On commence par vrier que les options sont bien celles attendues et que les paramtres sont en nombre sufsant ; cest une sorte danalyse syntaxique. - Ensuite, on vrie que les valeurs recueillies sont pertinentes : nombres dans lintervalle attendu, test dexistence du chier si un paramtre correspond son nom, etc...
V.3.2.
VI.5.1.
VI.5.1. Test de la prsence des options et paramtres

Exemple : on crit un programme que lon peut ventuellement lancer avec loption -opt1, ventuellement avec loption -opt2 suivie dune valeur, et avec un paramtre obligatoire. Voici une
faon de tester la prsence des options et du paramtre : #! /bin/ksh # # exemple de test des options et arguments # 15/05/92 option1=0 option2=0 val2="" fic="" usage="$0: usage: prog [-opt1] [-opt2 val] fichier" while [ $# != 0 ] do case $1 in -opt1 ) # option No 1 option1=1 ; shift ;; -opt2 ) # option2 (suivie par la valeur associe) option2=1 ; shift if [[ "$1" = -* ]] || [ -z "$1" ] then print -u2 "$usage" exit 1 else val2=$1 ; shift fi ;; -* ) # option inconnue print -u2 "$0: ($1) option inconnue" print -u2 "$usage" exit 1 ;; * ) # le parametre en fin de commande if [ $# != 1 ] then print -u2 "$usage" exit 1 else fic=$1; shift fi ;; esac done if [ -z "$fic" ] then print -u2 "$usage" exit 1 fi # TRAITEMENT print PROG $option1 $option2 $val2 $fic exit 0
VI.5.1.
VI.5.2.
Et voici plusieurs situations de lancement : $ prog ./prog: usage: prog [-opt1] [-opt2 $ prog -opt1 ./prog: usage: prog [-opt1] [-opt2 $ prog -opt2 tutu toto PROG 0 1 tutu toto $ prog -opt2 -opt1 tutu toto ./prog: usage: prog [-opt1] [-opt2 $ prog -opt2 tutu -opt1 toto PROG 1 1 tutu toto $ prog -opt2 tutu -opt1 ./prog: usage: prog [-opt1] [-opt2 $ prog toto PROG 0 0 toto $ prog -tutu ./prog: (-tutu) option inconnue ./prog: usage: prog [-opt1] [-opt2
val] fichier val] fichier
val] fichier
val] fichier
val] fichier
Sachez quil existe aussi une commande UNIX qui permet de tester la syntaxe des options : getopt.On passe en paramtre cette commande une chane contenant la liste des options autorises, et leur type (option suivie ou non dune valeur associe), en plus des paramtres de position. La commande vrie que la syntaxe est correcte. Mais le nom de loption ne peut dpasser un seul caractre (cela donne des options du style : -a, -n 2, -f toto, etc...).
VI.5.2. Test de la validit des paramtres

Il faut sassurer lorsquon utilise un paramtre quil correspond la valeur quon attend ; ce nest pas toujours facile vrier, mais trs utile. Imaginez que le premier paramtre fournir un programme soit un nombre et le second un nom de chier (pour le rsultat) : vous devez supposer quun utilisateur, voire vous-mme, inverserez au moins une fois ces deux paramtres au moment de taper la commande. Donc, il faut essayer de caractriser les diffrents paramtres et de les reconnatre ; Exemples :
- le nombre de paramtres (y compris les options) doit tre au moins gal 4 : alors faire un test : if [ $# -ge 4 ]
- le paramtre $2 est un nom de chier : alors faire un test : if [ -f $2 ]
- le paramtre $1 est un nom de chier de donnes (on doit donc pouvoir le lire) : Guide du KornShell sous UNIX - page 195
alors faire un test :
if [ -r $1 ]
VI.5.2.
- le paramtre $1 est un nom de chier qui ne doit pas tre vide : alors faire un test : if [ -s $1 ]
- le paramtre $1 est un nom de chier rsultat (on doit donc pouvoir y crire dedans) : alors faire un test : if [ -w $1 ]
- le paramtre $1 est un nombre entre 1 et 20 alors faire un test : if [ $1 -ge 1 ] && [ $1 -le 20 ]
- le paramtre $3 est une chane commenant par toto et suivie par _un ou _deux alors faire un test : if [[ $3 = toto@(_un|_deux) ]]
- le paramtre $2 est une chane de 9 caractres : alors faire un test : etc ... if [ ${#2} = 9 ]
Ecrire un programme shell propre : Entre standard et/ou chiers nomms
VI.5.2.
VI.6. Entre standard et/ou chiers nomms

Vous avez remarqu quun grand nombre de commandes UNIX sont conues pour que, si le nom du chier dentre nest pas prsent parmi les paramtres, la commande attende les donnes sur lentre standard. Exemple : grep chane toto comporte le nom du chier de donnes comme paramtre de la commande, mais grep chane <toto ou cat toto | grep chane marchent aussi, et l, les donnes sont attendues sur lentre standard parce que le paramtre correspondant au nom du chier de donnes na pas t fourni. Lintrt principal est quon peut, si on dsire, piper le programme au milieu dautres commandes UNIX. Supposons que votre programme soit appel avec un paramtre qui est le nom du chier traiter. Voici la faon de structurer le programme pour quil accepte aussi lentre standard si ce paramtre est absent : #!/bin/ksh # # exemple de programme acceptant # un nom de fichier comme parametre # ou lentree standard par defaut # cat $1 | ( while read ligne do # VOTRE TRAITEMENT done ) 1er cas : on appelle le programme ci-dessus en spciant un paramtre ; alors la variable $1 est instancie, et la commande cat envoie dans le pipe le contenu du chier spci. on appelle le programme sans paramtre ; dans ce cas, la variable $1 nest pas instancie, et au moment de linterprtation de la ligne, elle est remplace par rien. Ce qui fait que la premire ligne du programme est alors quivalente : cat | La commande cat nayant pas de paramtre, elle attend les donnes sur lentre standard, qui par hritage, est celle du programme. Donc, on peut utiliser ce programme avec lentre standard, et par consquent, le piper.
2me cas :
Ecrire un programme shell propre : Entre standard et/ou chiers nomms
Lexemple prsente un traitement de chier encapsul dans une boucle while-do-read- VI.5.2. done : il est possible de remplacer toute cette partie (encadre par des () ) par une commande UNIX simple comme awk, sed, etc... Cest dailleurs prfrable, pour des raisons de performances, ds que votre chier dentre est dune taille importante1.
1.
Voir le chapitre prcdent, consacr ce sujet.
Ecrire un programme shell propre : Manipulation des chiers temporaires
VI.5.2.
VI.7. Manipulation des chiers temporaires

Lorsque vous avez besoin dun chier temporaire, il faut toujours penser : - quil devra tre dtruit lorsque le programme sera termin ; - que plusieurs programmes peuvent peut-tre tourner ensemble, et qu chaque lancement un nom spcique doit tre trouv. O mettre le chier? Dans un rpertoire fourre-tout, comme /tmp, ou /usr/tmp qui existent quelque soit la machine, et qui sont autoriss lcriture pour tous. De plus, ces rpertoires sont gnralement vids de temps en temps, et les chiers temporaires perdus ne sy accumuleront pas; mais il ne sagit pas de compter la-dessus pour travailler "salement" !! Comment le nommer? Notez tout dabord que dans certaines (anciennes) version dUnix, ou par choix de ladministrateur, vous ne disposez que de 14 caractres. Partons sur cette base. Chaque lancement de programme correspond un processus de numro unique sur une machine : il est donc pratique que le nom du chier temporaire contienne le numro de processus courant (sur 5 chiffres, disponible dans la variable $$) ; Chaque chier du programme peut tre diffrenci par un caractre particulier (A pour le premier, B pour le second, etc...). Il reste 8 caractres que vous pouvez affecter avec le nom du programme. Exemple : votre programme se nomme calcul, et il utilise deux chiers temporaires ; vous pouvez les dnir de la manire suivante : tmp1=/tmp/calculA$$ tmp2=/tmp/calculB$$ Une premire excution verra par exemple la cration de deux chiers : /tmp/calculA12481 et /tmp/calculB12481 alors quun deuxime lancement en parallle verra alors (par exemple) la cration de : /tmp/calculA12485 et /tmp/calculB12485 Dans votre programme, vous manipulez les chiers temporaires non plus par leur nom rel, mais par lintermdiaire des variables; le contenu de la variable est le nom rel du chier (qui change chaque appel du programme), alors que le nom de la variable est videmment toujours le mme, et peut tre signicatif du contenu du chier correspondant. Au lieu de faire, par exemple : cp /tmp/calculA$$ /tmp/calculB$$ vous crirez alors : cp $tmp1 $tmp2
Ecrire un programme shell propre : Traitements des signaux
VI.8. Traitements des signaux

Il peut tre intressant de traiter les signaux pour deux raisons opposes - on veut ignorer certains signaux : INT (lquivalent du <control>C), HUP (signal de dconnexion) - on veut ragir certains signaux Le premier cas se rencontre lorsquon veut ignorer des signaux qui interrompent le programme en cours dexcution. Dans cette situation, on place en dbut de programme trap "" SIG1 SIG2 SIG3 ... pour viter que les signaux SIG1, SIG2, SIG3, etc ne soient pris en compte. Le deuxime cas se rencontre par exemple si on utilise des chiers temporaires. Supposons que le programme est en cours dexcution et quil a cr des chiers temporaires : si on interrompt le programme par <control C>, le processus est tu, mais les chiers temporaires dj crs ne sont pas dtruits. Il est alors intressant de drouter le signal INT (provoqu par le <control C>) vers une fonction qui supprime les chiers temporaires. Exemple : #!/bin/ksh # # structure de suppression des fichiers # temporaires sur interruption. # declaration des fichiers temporaires tmp1=/tmp/testA$$ tmp2=/tmp/testB$$ # fonction darret arret() { echo "$0: arret." rm -f $tmp1 $tmp2 exit 0 } # deroutement des signaux trap "arret" INT HUP TERM # TRAITEMENT sleep 1000
VI.5.2.
Dans le dbut du programme, on dclare successivement - le nom des chiers temporaires (ou des objets traiter en cas dinterruption par un signal) ; page 200 - Guide du KornShell sous UNIX
Ecrire un programme shell propre : Traitements des signaux
VI.5.2.
- la fonction qui sera lance la rception de linterruption ; - les droutements considrer par la commande interne trap. Ici, tout signal INT, HUP ou TERM reu aprs lexcution de la commande trap sera drout vers la fonction arret.
Ecrire un programme shell propre : Emission des messages derreur
VI.9. Emission des messages derreur

Si vous faites des tests de validit lintrieur de votre programme, vous serez vraisemblablement amens gnrer des messages derreur. Pour respecter la convention UNIX, il est prfrable dcrire ces messages dans la sortie derreur : echo "message_erreur" >&2 ou bien : print -u2 "message_erreur" De plus, si votre programme ou utilitaire est intgr dans dautres commandes, il est trs utile durant lexcution de connatre la provenance exacte du message derreur, ceux-ci tant souvent ambigus hors du contexte. Donc, il est intressant de faire prcder le message derreur du nom du programme qui la produit. Exemple : print -u2 "$0 : message_erreur" la variable $0 tant le premier champ de la ligne de commande, cest dire le nom du programme lui-mme. Il se peut que $0 contienne le chemin absolu du programme (sil a t lanc en spciant le chemin absolu), ce qui nest pas trs joli. Plutt que $0, on peut alors utiliser ${0##*/}
VI.5.2.
Ecrire un programme shell propre : Gnration du code de retour
VI.5.2.
VI.10. Gnration du code de retour

Si vous ne gnrez pas de code de retour la n de votre programme, celui-ci est gal au code de retour de la dernire commande UNIX excute. Un code de retour est utile car lorsque votre programme est encapsul1, cest un moyen pratique de tester sil sest termin correctement ou non. On peut forcer le code de retour par la commande exit n. Cette commande provoque larrt de lexcution et gnre un code de retour de valeur n. La convention veut quune commande qui sest bien termine renvoie un code de retour nul.
1. cest dire lanc partir dune autre commande, UNIX ou non.
Ecrire un programme shell propre : Gnration du code de retour
VI.5.2.
Quelques messages derreur courants
VII.
VII. Quelques messages derreur courants
Quelques messages derreur courants : Format du message
VII.1. Format du message

La plupart des messages derreur apparaissent sous la forme suivante :
VI.5.2.
fichier: localisation: message derreur

avec : - fichier : le nom de la commande ou du chier lanc qui dtecte lerreur. Cela peut tre : - ksh si vous tiez en train de taper une commande dans une fentre : votre commande est inconnue ou impossible lancer : $ gros_gag ksh: gros_gag: not found $ => ici, linterprteur narrive pas lancer la commande gros_gag - un nom de commande UNIX : la commande a dmarr, mais par suite dun mauvais paramtre, de ressources ou de droits insufsants, (etc...), elle sinterrompt et vous donne le message derreur : $ grep toto titi grep: cant open titi $ => ici, la commande grep narrive pas accder au chier titi. - un nom de chier binaire excutable cre par vous : idem cas prcdent, - ou alors le nom de votre script shell, qui ne respecte pas la syntaxe, ou a rencontr une commande impossible lancer. Dans ce cas, fichier est suivi par une squence : [<numro>] qui indique que lerreur sest produite pendant linterprtation de la ligne <numro> 1 :
$ gros_bug ./gros_bug[2]: ppppp : not found ./gros_bug[2]: syntax error at line 4: then unmatched $
voir
voir
=> ici, le script gros_bug contient une commande inconnue (ppppp) et une erreur de syntaxe.
1. Le script doit dmarrer par : #!/bin/ksh sinon, les numros ne sont pas fournis. Attention, la notation est un peu bizarre : on note les lignes partir du haut du chier, en sautant celles qui ne peuvent tre interprtes ; par exemple, si on a deux messages derreur qui se suivent, le numro de ligne indiqu dans le deuxime ne tient pas compte de la ligne errone qui prcde : il y a dcalage de 1 entre le numro de ligne indiqu et le vritable dans le chier script.
Quelques messages derreur courants : Format du message
VI.5.2.
- localisation : Apparait lorsque fichier est linterprteur de commande (ksh) ou un chier script. Si fichier est un binaire excutable, cette zone nest pas renseigne.
$ more gros_bug #!/bin/ksh ppppp if [ -f gros_bug ] then echo "gros_bug existe" date $ gros_bug ./gros_bug[2]: ppppp: not found ./gros_bug[2]: syntax error at line 4: then unmatched $
Cela peut tre : - un nom : celui dune commande (ppppp) trouve pendant lexcution du script(gros_bug), et que le shell narrive pas lancer ; - le message "syntax error at line .."avec le numro de ligne du script fichier (gros_bug) partir de laquelle le shell dtecte un erreur de syntaxe. Dans ce cas, le shell tait en train dinterprter un ensemble de lignes, qui commence <numro> (2), et nit au numro indiqu par "syntax error at line .."(4) : il vous faut chercher votre erreur entre ces deux lignes1 - message derreur : le message en clair (!?) qui correspond lerreur dtecte. (voir ci-aprs)
1. ici, la ligne 4 correspond la n de chier, et le shell a dtect que la squence if qui dmarre la ligne 2 na pas de n.
Quelques messages derreur courants : Liste des principaux messages derreur
VII.2. Liste des principaux messages derreur

et leur signication (la plus courante) : arg list too long la ligne de commande est trop longue une fois dveloppe. bad file unit number on essaie dutiliser un numro de descripteur de chier qui na jamais t affect. (voir les redirections) bad number le paramtre numrique pass en argument est incorrect (trop grand, trop petit, ce nest pas un nombre, etc...) bad option(s) on essaie de lancer un ksh avec une mauvaise option. bad substitution un oprateur sur une variable ( ${ } ) dni de manire incorrecte. bad trap le numro de signal spci pour la commande trap est incorrect. Bus error lexcutable binaire lanc a fait une erreur dadresse. => bug dans le programme. cannot create les droits en criture sur le rpertoire dans lequel on veut crer un chier ne sont pas sufsants. cannot dup impossible de faire une redirection (probablement, trop de chiers ouverts la fois dans le programme) cannot execute droits en excution insufsants ou entte de script incorrect cannot fork: no swap space impossible de crer un nouveau processus (de lancer une commande) : pas assez de swap cannot stat . le rpertoire courant a t supprim (par un autre processus) et nexiste plus au moment o vous tapez la commande pwd. cannot open droits en lecture insufsants sur le chier ou le rpertoire spci
VI.5.2.
VI.5.2.
core dumped suite une erreur grave (erreur dadresse, de bus, etc...) une commande a voir t interrompue, et le systme recopie une image de la mmoire dans un chier nomm core, en vue dune ventuelle investigation. voir Dans 99,99% des cas, l ventuel se trouve tre improbable, et comme un chier core est assez, voire trs gros, il est bon de penser le dtruire. end of file unexpected at line ... dans un programme shell, une squence comportant un caractre (ou un terme) de dbut puis de n (par exemple : " " , ou if fi, ou do done, etc.. ) est incomplte : le terme nal est manquant. Executable file incompatible with hardware le binaire que vous essayez de lancer na pas t produit sur une machine ayant une architecture comparable. execute permission denied droits en excution insufsants sur le chier spci Floating exception division par zro (problme de calcul) fork failed - too many processes nombre de processus sur la machine ayant atteint son maximum Hangup la connexion a t perdue (problme rseau, fermeture de la fentre dans laquelle la connexion a t lance, etc...) ou alors rception du signal HUP (numro 1) is not an identifier la commande shell a t lance avec un nom de variable incorrect (ou alors un caractre non attendu est plac dans le nom de variable). ce message apparait aussi si une commande : export var=valeur est fournie un Bourne Shell (/bin/sh) : si les noms de variables sont corrects, cela peut indiquer que votre programme na pas t lanc avec un KornShell, mais avec un Bourne Shell ;(vrier la prsence du #!/bin/ ksh en tout dbut de chier). urne Shell (/bin/sh) : si les noms de variables sont corrects, cela peut indiquer que votre programme na pas t lanc avec un KornShell, mais avec un Bourne Shell ;(vrier la prsence du #!/bin/ksh en tout dbut de chier). is read only droits en criture insufsants sur le chier spci Killed le processus a reu un message KILL (numro 9)
VI.5.2. ln: different file system la commande ln tente de crer un lien physique entre deux chiers qui se trouveraient alors sur deux units de disques diffrentes : impossible. Si possible, utiliser un lien symbolique (avec ln -s) Memory fault lexcutable binaire lanc a fait une erreur dadresse. => bug dans le programme. more tokens expected probablement que dans un test, vous navez pas encadr les arguments entre double-quotes. mv: cant mv directories across file systems la commande mv est utilise pour dplacer un rpertoire dune position une autre nappartenant pas la mme unit de disque : impossible.
Copier le rpertoire dplacer avec un cpio par exemple (voir les cas types), et supprimer lancien. no space left on device plus de place sur le disque. not found le chier est inexistant, le chemin indiqu pour le chier est incorrect, ou alors le rpertoire contenant la commande lance nest pas dans le PATH1 une autre possibilit est que lun des rpertoires du chemin spci nait pas les droits en excution. no match dans le rpertoire spci ou courant, aucun chier na de nom correspondant lexpression indique (avec des caractres spciaux comme *, [], ?,etc...) No such file or directory le nom fourni est mauvais, ou alors il correspond un lien symbolique pointant sur un chier ou rpertoire inexistant. parameter not set la variable spcie na pas t affecte pralablement et le shell est en mode -u (voir la commande set du shell) Permission denied le chier que vous voulez craser, le rpertoire dans lequel il se trouve si vous essayez de le dplacer, ne vous appartiennent pas et nont pas les droits sufsants. Terminated processus interrompu par un signal TERM (numro 15)
1. il doit y avoir . dans le PATH pour que les commandes places dans le rpertoire courant soient excutes.
VI.5.2.
test argument expected il manque un argument entre les crochets dun if ou dun while le plus souvent, cela correspond une ligne : if [ $ma_variable = "valeur" ] avec ma_variable qui nest pas affecte ou qui vaut une chane vide. Encadrer $ma_variable avec des double-quotes (") test ] missing il manque un crochet au if ou au while text busy le chier que vous voulez modier, supprimer, ou dplacer est un binaire en cours dexcution ; il faut attendre sa n pour pouvoir y toucher. too big plus assez de place mmoire pour pouvoir lancer le programme unknown test operator le symbole utilis pour le test est incorrect (dans le if [ ... ] ou le while [ ... ]); plus probablement, vous navez pas encadr les arguments entre double-quotes, et le shell prend une partie de votre premier argument pour loprateur.
VI.5.2.
Spcicits SUN-OS 5.1
VIII.
VIII. Spcicits SUN-OS 5.1

Il est rappel que sont ici indiques des diffrences par rapport aux explications ou exemples fournis dans la description qui prcde (sous HP-UX), sans que lune ou lautre des versions ne constitue une quelconque rfrence ou norme. Vous trouverez les modications par ordre dapparition dans le document.
Spcicits SUN-OS 5.1 :
Voir page 32: Il est nest pas possible de changer les proprits du lien une fois celui-ci cr : chaque accs au lien est transparent, et concerne en fait le chier sur lequel le lien pointe. Voir page 49; Les messages derreur diffrent un peu dune version dOS une autre; ici, on a en fait: $ ls toto tata | wc -l $ ls toto: No such file or directory toto1.c toto2.c toto_base.c tutu tata: No such file or directory $ echo toto[^_].c 0toto1.c toto2.c $ ls toto tat 2>&1 | wc -l 2
Voir page 53: Le contenu du rpertoire /usr/pub est diffrent. Voir page 57 Les fentres gnres par dfaut varient en fonction de lOS; dans le cas de SUN-OS, qui est livr avec OpenWindow,ce sont des cmdtool. Les caractres de contrle tant diffrent, voici limplmentation de la fonction cdx
sur une cmdtool :

# # affichage sur une fenetre cmdtool du repertoire et # de la machine courante # PATH=/bin:/sbin:/usr/bin:/usr/sbin:/etc:/usr/ucb EDITOR=vi export HOSTNAME=$(hostname) typeset -L4 NHOST=$HOSTNAME export USER=$(whoami) xname() { _title="$*" print \033]l"$_title"\033\ \033]L"$_title"\033\ "\b\b\c" } cdx() { unalias cd cd $1; alias cd=cdx xname $HOSTNAME [pwd=$PWD] } alias cd=cdx set +u cd
Voir page 60 : Lintitul des donnes afches change un peu : - la dernire colonne est note : COMD. La signication ne change pas.
Voir page 64 : la commande suspend, cest dire kill -STOP est valide, mais ragit avec un temps de retard: comme on peut le voir dans lexemple qui suit, lindication de
changement dtat ne seffectue que lorsque une commande UNIX (jobs est une commande interne du shell) est lance: $ alias suspend='kill -STOP' $ sleep 1000 & [1] 25039 $ jobs [1] + Running sleep 1000 & $ suspend %1 $ jobs [1] + Running sleep 1000 & $ ls des jef nouveau prof_p [1] + Stopped (signal) sleep 1000 & $ jobs [1] + Stopped (signal) sleep 1000 & $
Par contre, le signal a bien t pris en compte de suite: on peut sen assurer en faisant le mme essai que ci-dessus et en remplaant le sleep 1000 par : sh -c "sleep 10; echo toto >/tmp/toto" Il suft depuis une autre fentre de surveiller lexitence du chier /tmp/toto; si, une fois excut la commande suspend , le chier apparait, cest donc que le process sleep a continu sexcuter, et que le chier /tmp/toto a t cr; en pratique, rien ne se passe: le signal STOP a bien t reu.
Voir page 65 : La liste des signaux est identique si on sen tient aux 19 premiers; pour les autres, il y a des diffrences: $ $ 1) 2) 3) 4) 5) 6) 7) 8) 9) 10) 11) $ kill -l HUP INT QUIT ILL TRAP IOT EMT FPE KILL BUS SEGV
12) 13) 14) 15) 16) 17) 18) 19) 20) 21) 22)
SYS PIPE ALRM TERM USR1 USR2 CHLD PWR WINCH URG POLL
23) 24) 25) 26) 27) 28) 29) 30) 31) 32) 33)
STOP TSTP CONT TTIN TTOU VTALRM PROF XCPU XFSZ WAITING LWP
Pour tous ceux dont lutilit a t indique, la signication est la mme. Voir page 76 : Loption -E pour la commande grep nexiste pas; on peut remplacer cependant le grep -E par la commande quivalente egrep. Toutefois, certaines expressions rgulires ne sont pas totalement supportes, en particulier la squence ER\{n,m\} (elle permet dindiquer un nombre de rptition donn pour une expression ER) qui nexiste pas. Cette remarque sapplique de la mme faon toute les squences contenant des {}, aucune ntant supporte. Voir page 78 : Cette squence nest pas disponible. Voir ci-dessus. Voir page 79: Les exemples ([abc]z)\{3\} , ou ([abc])\{3\} ne sont pas reproductibles, la squence \{ \} ntant pas disponible. Voir ci-dessus. Voir page 94: La commande what nest pas dans le PATH de dfaut: il faut indiquer sont chemin complet: /usr/ccs/bin/what; de plus le rsultat de la commande est diffrent, car il contient la liste de tous les modules constituant la commande. En outre, il faut savoir que la vieille version du awk est fournie encore en standard sous SOLARIS 5.1. Si vous voulez utiliser les fonctionnalits avances indiques dans Guide du KornShell sous UNIX - page 217
ce document, vous devez utiliser la commande nawk ( contraction de new awk )en lieu et place de awk. Dans la suite du document, les indications donnes pour awk devront tre comprises avec SOLARIS 5.1 comme se rapportant nawk. Voir page 109 La commande bs nest pas disponible. Si on se contente de calculs sur des entiers, on peut utiliser bc, qui possde aussi des fonctions arithmtiques volues (racine, exponentielle, etc..). Voir page 112: La liste est moins complte, mais les types principaux sont reconnus. Voir page 115: Loption -q de la commande grep nexiste pas; ici, il est possible dutiliser loption -l, qui provoque lafchage du chier contenant la chaine spcie; et comme la commande grep afche le nom du chier, le find peut viter de le faire. La commande complte devient: find . -exec grep -l chaine {}\; ! -exec rm {} \; Voir page 116: Idem ci-dessus; loption nest pas disponible. Voir page 117: Les options pour indiquer les colonnes de jointage sont diffrentes: au lieu de -1 et -2, il faut utiliser -j1 et -j2. $ join -j1 2 -j2 1 -o 1.2 2.2 1.3 1.1 j_tab1 j_tab2 Cabours 62 Paimpol 205 Dupond 53 Paris R4 Durand 22 Nice ferrari Pierre 35 Lyon 405 $
Voir page 118: Loption -v nexiste pas: on ne peut envisager dutiliser que loption -a qui rajoute les lignes non apparies la sortie standard. Voir page 129 : Loption -k nexiste pas: utiliser lancienne notation. page 218 - Guide du KornShell sous UNIX
Voir page 129 (Exemple simple) : Voir ci-dessus; la commande taper est: sort +1 sort.input Voir page 130 (remarques) : Voir ci-dessus; la commande taper est: sort +1 -2 sort.input Voir page 130 (sparateurs multiples) : Voir ci-dessus; la commande taper est: sort -b +1 sort.input Voir page 130 (tri multiple) : Voir ci-dessus; la commande taper est: sort -b +1 -2 +0 -1 sort.input Voir page 131 (exemple complexe) : Voir ci-dessus; la commande taper est: sort +rn1 +0 sort.input Voir page 135 : La commande rev nest pas disponible. Voir page 158 : La squence pour tendre le nom du chier en cours de frappe est : <escape> \ au lieu de <escape> <escape> Voir page 159 : dem ci-dessus: chaque squence de deux <escape> doit tre remplace par une squence <escape> suivi de \
Voir page 160 : Lorsque la commande cmd_bg & est lance, le message "Stopped(tty output)" napparait pas tout de suite, mme si on tape plusieurs <Return>; il apparait seulement aprs quune commande UNIX ait t tape (une commande Shell nest pas sufsante). Malgr cette diffrence, les fonctionnalits ne sont en rien modies.
$ cmd_bg & [1] 4518 $ $ $ jobs [1] + Running cmd_bg & $ $ $ id uid=17000(reseau) gid=17000(reseau) [1] + Stopped(tty output) cmd_bg & $
Voir page 166 : se rfrer aux remarques sur la commande sort vues plus haut. Avec lancienne notation, la commande est inchange, par contre, la nouvelle notation nest pas disponible. Voir page 166 : idem ci-dessus. La nouvelle notation ntant pas disponible, la commande devient: sort +2 -4 +0 mon_fichier Voir page 173 : la commande remsh se nomme rsh sur Sun. Voir page 174 : loption -linkedto nest pas disponible; il faut donc rechercher les chiers partir des numros dinode, comme cela est expliqu dans le deuxime exemple. Voir page 177 : la commande se trouve dans le rpertoire /usr/ccs/bin, qui nest gnralement pas intgre dans le PATH: il faut alors taper le chemin complet. Voir page 178 : il ny a pas dentre correspondant au terme suffix.
Voir page 185 : la commande bs nest pas disponible. Voir page 206 : la remarque en bas de page ne prend pas effet. Voir page 209 : On peut rajouter : couldnt set locale correctly la variable LANG nest pas positionne correctement. (langage courant du pays). Une valeur par dfaut passe partout est : C.
Spcicits AIX 3.2
IX.
IX. Spcicits AIX 3.2

Il est rappel que sont ici indiques des diffrences par rapport aux explications ou exemples fournis dans la description qui prcde (sous HP-UX), sans que lune ou lautre des versions ne constitue une quelconque rfrence ou norme. Vous trouverez les modications par ordre dapparition dans le document.
Spcicits AIX 3.2 :
Voir page 31 : Les messages derreur tant dispenss en franais, on a en fait: $ ln ancien /tmp/nouveau ln: 0653-422 ancien et /tmp/nouveau se trouvent sur des systmes de chiers diffrents. $ Pour un utilisateur averti dUnix, les messages traduits en franais sont parfois droutants; pour un nophite, ils sont, comme ici, gnralement plus accessibles. Voir page 32 : Il est nest pas possible de changer les proprits du lien une fois celui-ci cr : chaque accs au lien est transparent, et concerne en fait le chier sur lequel le lien pointe. Voir page 53 : Le contenu du rpertoire /usr/pub est diffrent. Voir page 57 : Les fentres gnres par dfaut varient en fonction de lOS; dans le cas de AIX,,ce sont des aixterm. Les caractres de contrle tant diffrent, voici limplmentation de la fonction cdx
Spcicits AIX 3.2 :
sur une aixterm:

# # affichage sur une fenetre aixterm du repertoire et # de la machine courante # PATH=/bin:/sbin:/usr/bin:/usr/sbin:/etc:/usr/ucb EDITOR=vi export HOSTNAME=$(hostname) typeset -L4 NHOST=$HOSTNAME export USER=$(whoami) xname() { _title="$*" print '\033]l'"$_title"'\033' '\033]L'"$_title"'\033' "\b\b\c" } cdx() { unalias cd cd $1; alias cd=cdx xname $HOSTNAME [pwd=$PWD] } alias cd=cdx set +u cd
Voir page 60 : Lintitul des donnes afches change un peu : - la premire colonne est note : USER, - la dernire CMD. La signication ne change pas.
Spcicits AIX 3.2 :
Voir page 63 : Lidenticateur de processus courant est indiqu, en plus du descripteur de processus, lorsquun process change dtat. $ sleep 1000 ^Z[1] + 16417 Stopped sleep 1000 $ sleep 2000 & [2] 30754 $ jobs [2] + Running sleep 2000 & [1] - Stopped sleep 1000 $
Voir page 65 : La liste des signaux est plus importante que pour les autres systmes; cependant, part quelques signaux, les numros sont spciques. Pour les principaux, dont lutilit a t indique, la signication ne change pas. $ kill -l 1) HUP 2) INT 3) QUIT 4) ILL 5) TRAP 6) LOST 7) EMT 8) FPE 9) KILL 10) BUS 11) SEGV 12) SYS 13) PIPE 14) ALRM 15) TERM 16) URG $
17) 18) 19) 20) 21) 22) 23) 24) 25) 26) 27) 28) 29) 30) 31) 32)
STOP TSTP CONT CHLD TTIN TTOU IO XCPU XFSZ bad trap MSG WINCH PWR USR1 USR2 PROF
33) 34) 35) 36) 37) 38) 39) 40) 41) 42) 43) 44) 45) 46) 47) 48)
DANGER VTALRM MIGRATE PRE bad trap bad trap bad trap bad trap bad trap bad trap bad trap bad trap bad trap bad trap bad trap bad trap
49) 50) 51) 52) 53) 54) 55) 56) 57) 58) 59) 60) 61) 62) 63)
bad trap bad trap bad trap bad trap bad trap bad trap bad trap bad trap bad trap bad trap bad trap GRANT RETRACT SOUND SAK
Spcicits AIX 3.2 :
Voir page 66 : Lafchage du changement dtat des process nest pas instantan: il faut taper une commande pour que le message safche: $ sleep 1000 & [1] 30763 $ sleep 2000 & [2] 16428 $ jobs [2] + Running sleep 2000 & [1] - Running sleep 1000 & $ kill -9 %1 $ kill -INT 16428 [1] - 30763 Killed sleep 1000 & $ jobs [2] + Interrupt sleep 2000 & $
Voir page 76 : Le manuel ne fournit aucune indication se rapportant au terme regexp. De plus, certaines expressions rgulires ne sont pas supportes exactement de la mme manire, en particulier la squence ER\{n,m\} (qui permet dindiquer un nombre de rptition donn pour une expression ER): elle doit tre note sans les antiquotes: ER{n,m}. Cette remarque sapplique toute les squences contenant des {}. Voir page 78 : Ce type dexpression est disponible, mais il ne faut pas mettre de \ devant les { ou les }. Voir ci-dessus. Voir page 94 : le rsultat de la commande est diffrent, car il contient la liste de tous les modules constituant la commande.
Voir page 96 : Il nest pas possible dindiquer un sparateur comportant plus dun caractre: lexemple nest pas reproductible. Voir page 100 : En thorie, la squence %X gnre une conversion dun dcimal en hexa avec des lettres majuscules, alors que %x fait une conversion hxa en minuscules. Ici, la squence %X (majuscules) nest pas supporte; mais %x est utilisable. Guide du KornShell sous UNIX - page 227
Spcicits AIX 3.2 :
Voir page 112 : La liste est moins complte, mais les types principaux sont reconnus. Voir page 129 Lorsquon utilise la nouvelle notation (avec -k), toutes les positions dmarrent un, aussi bien pour les champs que pour les caractres. Lancienne notation positionne cependant toujours le premier champ ou le premier caractre zro. Dans la suite du document, toutes les commandes utilisant la commande sort avec loption -k devront tre modies en augmentant systmatiquement de un les indices de position des champs et des caractres. Exemple: une cl 0.2,2.5 avec lancienne notation devient 1.3,3.6 avec la nouvelle (option -k). Voir page 129 (Exemple simple) : Voir ci-dessus; la commande taper est: sort -k2, sort.input Voir page 130 (remarques) : Voir ci-dessus; la commande taper est: sort -k2,3 sort.input Voir page 130 (sparateurs multiples) : Voir ci-dessus; la commande taper est: sort -kb2, sort.input Voir page 130 (tri multiple) : Voir ci-dessus; la commande taper est: sort -b -k2,3 -k1,2 sort.input Voir page 131(exemple complexe) : Voir ci-dessus; la commande taper est: sort -krn2, -k1,2 sort.input Voir page 135 : Voir ci-dessus; la commande taper est : sort -k3, tst_sort1 Voir page 158 : La squence pour tendre le nom du chier en cours de frappe est : <escape> \ page 228 - Guide du KornShell sous UNIX
Spcicits AIX 3.2 :
au lieu de <escape>
<escape>
Voir page 159 : idem ci-dessus: chaque squence de deux <escape> doit tre remplace par une squence <escape> suivi de \ Voir page 166 : se rfrer aux remarques sur la commande sort vues plus haut. Avec lancienne notation, la commande est inchange, par contre, avec la nouvelle, la commande devient: sort -k3 mon_fichier Voir page 166 : idem ci-dessus. La commande devient: sort -k3,5 -k1, mon_fichier Voir page 174 : les options -linkedto et -follow ne sont pas disponibles. Il est donc possible de rechercher seulement les chiers lis physiquement, en utilisant le numro dinode. Voir page 178 : il ny a pas dentre correspondant aux termes regexp, ou suffix. Voir page 206 : la remarque de bas de page ne prend pas effet. Voir page 209 : On peut rajouter : couldnt set locale correctly la variable LANG nest pas positionne correctement. (langage courant du pays). Une valeur par dfaut passe partout est : C.
Spcicits AIX 3.2 :
INDEX
| ..................................... 34, 79 || .................................... 47 ~ .................................... 34, 44 .................................... 34 .................................... 34
INDEX
Symboles
! ..................................... 46, 71 " ..................................... 34 # .................................... 38, 191 #! ................................... 189 $ .................................... 78 variable shell ........... 38 $(( )) .............................. 148 $() .................................. 41 & ................................... 34, 48, 62, 118, 159, 161 && ................................ 48, 75 (( )) ................................ 147 () .................................... 34, 46, 79 * .................................... 34, 38, 43, 77 + .................................... 79 , ?, ~ interprtation ........... 34 . ..................................... 77, 83 .kshrc ............................. 55, 56, 163 .profile ........................... 62, 148, 163, 190 / ..................................... 45 /dev/null ........................ 155 ; ..................................... 47 ? .................................... 34, 39, 44, 79 @ ................................... 45, 71 75 \ ..................................... 35, 43, 45, 77 ^ .................................... 78 {} .................................. 34, 46, 78
algorithme .................... 14 alias .............................. 34, 55, 84 dclaration .............. 55, 163 crire un .................. 162 exemple .................. 56 anti-quote ...................... 34, 41 arrire-plan ................... 62, 92, 160 avec nohup ............. 119 dplacement vers .... 63 ascii .............................. 127, 178 caractres ................ 164 at ................................... 60, 161, 171 avant-plan ..................... 62 dplacement vers .... 63 awk ............................... 76, 94, 168, 169, 172, ................... 182 version du ............... 94
B
background ................... 62, 87, 160 base,conversion de ....... 91 basename ...................... 109, 154 batch ............................. 60, 161 BEGIN (awk) ............... 95 bg .................................. 62, 63 BourneShell .................. 15 bs .................................. 109, 185 buffer de la souris ......... 163
C
caractre ! .............................. 46, 71 ? .............................. 44 @ ............................ 45, 71 ~ .............................. 44 ascii ........................ 164 de contrle .............. 17 caractres spciaux ....... 70 du shell ................... 34 interprtation .......... 43, 70 Guide du KornShell sous UNIX - page 231
INDEX
case ................................70, 152 cd ...................................26, 57, 82, 162 chaine concatnation ..........34, 42 recherche .................183 chmod ............................176 classe appartenance des fichiers 24 clavier contrle par le .........61 code de retour ................19 gnration ................203 combinaison de commandes .........49 commande combinaison de .......49 de tri ........................126 historique de ............156 interprteur, message derreur 207 ln .............................28 localisation ..............55, 93 multiple ...................147, 167 commentaire dans un programme shell 191 concatnation chaines ....................42 variable ....................36 configuration .................16, 84 alias .........................163 au login ...................163 du shell ....................16 conseils ..........................182 console ..........................61 contrle caractre de .............17 par le clavier ............61 processus .................60 conversion de base .....................91, 170 de type .....................91 de type pour une variable 148 core ................................209 corps dun fichier ..........27 cp ...................................172 cpio ................................173 cration dun fichier ..............181 dun processus .........180 de fichier .................26 page 232 - Guide du KornShell sous UNIX
de liens .................... 27 de liens symboliques 31 de processus ............ 16 csh ................................. 15, 189 CTRL C ........................ 16 cut ................................. 172
D
dc .................................. 111, 170 dclaration alias ......................... 55, 163 fonction ................... 55 droutement sur un signal ............ 86, 151 descripteur .................... 21, 50 hritage ................... 16 dirname ......................... 109, 154 done .............................. 63 double-quote ................. 34 interprtation ........... 42 fichier droits ....................... 23 droits en criture ............... 24 en excution ............ 24, 59 en lecture ................. 24 insuffisants, message derreurs 206 pour un groupe ........ 23 sur les fichiers ......... 23 sur un rpertoire ...... 26
E
cran dfilement ............... 165 criture droits en .................. 24 ed .................................. 76 EDITOR ........................ 156 END (awk) .................... 95 entre standard .............. 19, 21 (pipe) ....................... 48 pour un programme shell 197 entres ........................... 19 entre-sortie paramtre ................ 19 ENV .............................. 163 env ................................ 162 ENVIRON .................... 97
INDEX
environnement courant . 82, 84 erreur format des messages 206 sortie d ................... 21 ex .................................. 76 exec ............................... 145, 146, 183, 185 excution droits en .................. 24, 59 pour un rpertoire ... 26 trace ........................ 86, 145 exemple de fonction et dalias 56 for ............................ 83 redirection ............... 51 redirection avec une macro-commande 53 exit ................................ 203 export environnement ........ 37 variable ................... 19 expr ............................... 76 expression arithmtique ............ 70 combinaison ............ 74 conditionnelle ......... 71 gnrique ................ 39, 40, 45, 70, 76, 152, ............. 178 rgulire .................. 76, 120, 178 rgulire tendue ..... 76
test sur un ............... 72, 146 tri dun .................... 166 tri par taille ............. 164 find ............................... 113, 147, 166, 171, 173, ................... 174 fonction ........................ 34, 84 dclaration .............. 55 exemple .................. 56 liste des ................... 56 for exemple .................. 83 foreground .................... 62 format dune commande unix 17 formater un fichier ................ 141
G
getopt ............................ 195 gid ................................. 23 grep ............................... 17, 21, 76, 115, 172, 197 groupe droits pour .............. 23 gsub .............................. 103
H
head .............................. 116 hritage ......................... 16, 21 descripteur .............. 16 HISTFILE .................... 156 historique ...................... 15 des commandes ...... 156 HISTSIZE .................... 156 HOME .......................... 38 hpterm .......................... 57 HUP .............................. 200
F
fg ................................... 62, 63 fichier classe dappartenance 24 corps dun ............... 27 cration dun ........... 181 cration de ,suppression 26 droits ....................... 23 formatage dun ........ 141 inode dun ............... 28 lire par ligne ............ 144, 145 manipulation ........... 21 permissions ............. 23 propritaire dun ..... 24 recherche dun ........ 166 standard ................... 19 suffixe ..................... 152, 154 suppression ............. 175 temporaire,manipulation 199
I
ibase .............................. 110 if ................................... 70, 71, 146, 154, 182, ................... 195 exemple .................. 82 IFS ................................ 38 index ............................. 102 inode ............................. 28, 175 INT ............................... 200 Guide du KornShell sous UNIX - page 233
INDEX
intractif ........................14 interprtation " ...............................34 & .............................34, 48 && ..........................48 () ..............................34, 46 * ..............................34, 43 / ...............................45 ; ...............................47 ? ...............................34 \ ...............................45 {} .............................34, 46 | ................................34 || ...............................47 ~ ..............................34 ...............................34 ...............................34 des caractres spciaux 43, 70 double-quote ...........42 sparateur ................34 interprteur ....................14, 15
LINENO ....................... 39 ll .................................... 164 ln ................................... 28, 174 localisation dune commande ..... 55, 93 login shell ......................... 21 ls .................................... 26, 167
M
macro-commande ......... 46 exemple de redirection 53 man ............................... 178 manipulation fichier ...................... 21 manuel de rfrence ............. 94 match ............................ 102 messages derreur ......... 155 format ...................... 206 gnration ............... 202
J
jobs ................................62 join ................................116, 184
N
NF ................................. 97 NFS ............................... 182 nohup ............................ 87, 118, 161 arrire-plan .............. 119 NR ................................. 97 numro didentification 23
K
kill .................................64, 65 ksh .................................15, 189 Ksh,KornShell ...............15 kshrc ..............................55, 56, 84, 163
O
obase ............................. 110 oprateur sur des commandes,expressions 72 sur une variable shell 39 option dans un programme shell 192 test d ...................... 193
L
lecture droits en ...................24 length ............................102 liens ...............................27 avantages .................31, 33 cration de ...............27 inconvnients ..........31, 33 lister tous les ...........33 physiques ................27 physiques,recherche 174 suppression ..............29 symboliques,cration 31 symboliques,recherche 174 ligne manipulation ...........184 page 234 - Guide du KornShell sous UNIX
P
paramtre entre-sortie ............ 19 validit dun ............ 195 paste .............................. 185 PATH ............................ 34, 38, 58, 148, 163, 182, ................... 190 rpertoire courant .... 59
INDEX
pattern ........................... 39, 76 performance .................. 181 dun programme shell 198 fichier permissions ............. 23 PID ................................ 60 pipe ............................... 48, 49, 181, 197 pour un programme shell 197 point (commande) ......... 83 PPID .............................. 38, 60 print ............................... 84, 99, 150 printf ............................. 100 processus ....................... 16 contrle ................... 60 cration dun ........... 180 cration de ............... 16 limiter le nombre de 184 tuer un ..................... 66 profile ............................ 62, 163, 178 programme localisation .............. 190 options,paramtres .. 192 performances dun .. 198 prompt ........................... 162 propritaire dun fichier ............. 24 ps ................................... 60 PS1 ................................ 39, 162 PWD ............................. 38 pwd ............................... 82
rpertoire changement ............ 162 courant dans le PATH 59 droits sur un ............ 26 excution pour un ... 26 recopie dun ............ 172 ressources optimisation des ..... 180 rev ................................. 136 rm ................................. 29 running ......................... 63
S
SECONDS .................... 39 sed ................................ 18, 76, 119 slection ........................ 152 sparateur interprtation .......... 34 session configuration .......... 163 set ................................. 37, 58, 85, 146, 162 sh .................................. 189 caractres spciaux du shell ................... 34 shell .............................. 14, 15 choix du .................. 189 configuration du ..... 16 login ........................ 21 message derreur .... 207 symboles du ............ 34 transformation dune ligne 34 shift ............................... 86 signal ............................ 61 droutement sur un . 86, 151 liste ......................... 65 traitement ................ 200 sleep .............................. 63 sort ................................ 117, 126, 135, 164, 166, ................... 169, 184 sortie dcran .................... 165 derreur ................... 21, 42 standard .................. 19, 21, 42, 144, 149 standard:(pipe) ........ 48 souris buffer ...................... 163 split ............................... 103 sprintf ........................... 101 Guide du KornShell sous UNIX - page 235
Q
quote ............................. 34, 35
R
RANDOM .................... 38 read ............................... 144 recherche dun fichier ............. 166 recopie dun rpertoire ........ 172 redirection ..................... 21, 42, 49, 144, 149, 151 exemple ................... 51 exemple avec une macro-commande 53 types de ................... 49 regexp ........................... 76, 178 remsh ............................ 173
INDEX
standard entre .......................19, 21 sortie ........................19, 21 stopped ..........................63 stty .................................61 sub .................................102 sub-shell ........................34 substr .............................102 suffixe ...........................178 fichier ......................154 suppression dun fichier ..............26, 175 symbole du shell ....................34 syntax error ...................207
U
uid ................................. 23, 60 unalias ........................... 55, 58 uniq ............................... 134 unset .............................. 92
V
validit dun paramtre . 195 variable concatnation .......... 36 conversion de type .. 148 exporte .................. 19, 37 justification ............. 148 lister une ................. 162 oprateur sur ........... 39 positionnement par set 85 prpositionne ......... 38 rsultat de commande 144 typage ...................... 89 utilisation ................ 35 version du awk ..................... 94 vi ................................... 76
T
Tableau affectation (shell) ....37 tail .................................134 tar ..................................173 TERM ...........................201 terminated .....................63 test .................................182 multiple ...................154 options,paramtres ..193 sur un fichier ...........72, 146 time ...............................180 timeout ..........................182 tolower ..........................103 touche <control> ...........61 toupper ..........................103 trace dexcution ...........86, 145 trackall ..........................182 traitement dun signal ...............200 transformation dune ligne shell 34 trap ................................67, 86, 151, 161, 200 tri commande de ..........126 dun fichier ..............166 TTY ...............................60 tty ..................................61 typage de variable .........89 type conversion de ..........91 typeset ...........................56, 89, 148
W
wait ............................... 92 wc .................................. 49 what .............................. 94 whence .......................... 93, 94 while ............................. 70, 93, 145, 167, 181, 182, ................... 183
X
X11 ............................... 61, 165 xargs .............................. 136, 147, 167
Bibliographie
Bibliographie
Bibliographie
Bibliographie
Ouvrages de rfrence : liste des commandes Unix (utilisateurs): HP-UX Reference Section 1 HP-UX 8.05 Manual formats type (chiers, signaux, expressions rgulires, etc...): HP-UX Reference Section 5 HP-UX 8.05 Manual KornShell: Le KornShell, langage de commande et de programmation M.I. BOLSKY, D.G. KORN MASSON PRENTICE HALL vi, ex: Ultimate guide to the VI and EX text editors Hewlet Packard BENJAMIN/CUMMINGS awk, ed, sed: Text Processing: Users Guide HP-UX 8.05 Manual bc, bs, dc: Number Processing: Users Guide HP-UX 8.05 Manual
Pour complter ses connaissances: guide du C shell: The UNIX C Shell Field Guide Gail Anderson, Paul Anderson PRENTICE HALL guide du Bourne Shell (sh), du Csh, utilitaires du langage C, appels systme: Advanced Programmers Guide to UNIX System V Rebecca Thomas, PhD, Lawrence R.Rogers, Jean L.Yates Osborne McGRAW-HILL
Bibliographie

Kornshell

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Kornshell

Uploaded by

Copyright:

Available Formats

GUIDE

Jean Franois Pujol aot 93

jf pujol, 18 aot 1993

page 2 - Guide du KornShell sous UNIX

jf pujol, 18 aot 1993

jf pujol, 18 aot 1993

page 4 - Guide du KornShell sous UNIX

Guide dutilisation du guide

oui tes vous press(e)?

tes - vous compltement dsoeuvr(e)?

jf pujol, 18 aot 1993

Guide du KornShell sous UNIX - page 5

jf pujol, 18 aot 1993

page 6 - Guide du KornShell sous UNIX

Table des matires

Table des Matires

I.6. Interprtation dune commande shell ............................................................ 34

I.6.4. Etape 4 : I.6.5. Etape 5 : I.6.6. Etape 6 : I.6.7. Etape 7 :

Table des matires

I.7. Le contrle des processus ............................................................................. 60

II. Les Expressions ...................................................................................69

II.2. Les expressions rgulires ........................................................................... 76

III. Exemples dutilisation de commandes ...............................................81

jf pujol, 18 aot 1993

Table des matires

III.1.12. whence .....................................................................................................................93 III.1.13. while .........................................................................................................................93

III.2. Quelques commandes UNIX ...................................................................... 94

IV. Cas types ..........................................................................................143

jf pujol, 18 aot 1993

Guide du KornShell sous UNIX - page 9

Table des matires

IV.2. Cas types avec la ligne de commande ...................................................... 156

IV.3. Cas types avec les commandes UNIX ..................................................... 166

jf pujol, 18 aot 1993

Table des matires

V. Optimiser un programme shell .........................................................179

VI. Ecrire un programme shell propre ...................................................187

VII. Quelques messages derreur courants ............................................205

VII.2. Liste des principaux messages derreur .................................................. 208

VIII. Spcificits SUN-OS 5.1 ..............................................................213

Guide du KornShell sous UNIX - page 11

Table des matires

IX. Spcificits AIX 3.2 .........................................................................223

jf pujol, 18 aot 1993

page 12 - Guide du KornShell sous UNIX

jf pujol, 18 aot 1993

Guide du KornShell sous UNIX - page 13

Description : Introduction : quest ce que le shell?

I.1. Introduction : quest ce que le shell?

I.1.2. Algorithme simpli

jf pujol, 18 aot 1993

page 14 - Guide du KornShell sous UNIX

Description : Introduction : quest ce que le shell?

Voici lalgorithme de la fonction traiter_ligne() :

I.1.3. Les diffrents shells disponibles

jf pujol, 18 aot 1993

Description : Quest ce quun processus UNIX ?

I.2. Quest ce quun processus UNIX ?

jf pujol, 18 aot 1993

page 16 - Guide du KornShell sous UNIX

Description : Format dune commande UNIX lmentaire

I.3. Format dune commande UNIX lmentaire

jf pujol, 18 aot 1993