Get documents about "Cours Unix 5
Document Sample
Cours Unix 5
Michel Mauny
La commande awk
ETGL
Le cours 4 est disponible sur http://quincy.inria.fr/courses/unix/
[La commande awk – 2]
Plan du cours 5 La commande awk
a
Similaire ` sed, mais plus puissant.
Avec sed:
e e e
• difficile de m´moriser la ligne pr´c´dente
e
• on ne peut aller en arri`re dans le fichier
1. La commande awk
e
• on ne peut pas s´lectionner une ligne par quelque chose
2. La commande make comme /.../+1
e
• rien pour effectuer des calculs arithm´tiques
La commande awk, dont les auteurs sont Aho, Weinberger et
Kernighan, permet ce genre choses. . .
[ – 1] [La commande awk – 3]
La commande awk Invocation
awk est un filtre programmable qui travaille aussi bien avec des
ınes qu’avec des nombres.
chaˆ Invocations:
awk traite des champs alors que sed traite des lignes.
• awk ’programme’ fichier ...: le programme est donn´ e
Tout comme sed et comme de nombreux outils Unix, awk traite sur la ligne de commande. Les fichier ... sont les fichiers
e e
des donn´es ´manant de a
` traiter.
• fichiers e
• awk ’programme’: idem, mais c’est l’entr´e standard qui est
• redirections et pilelines e
trait´e.
e
• l’entr´e standard. e
• awk -f pfichier fichier ...: le programme est trouv´
Tout comme sed, awk est un langage de motifs-actions, mais dans pfichier.
avec une syntaxe plus proche de C.
[La commande awk – 4] [La commande awk – 6]
La commande awk Motifs et actions
e
Un programme awk est constitu´ de:
e e
1. un segment optionnel BEGIN: action ex´cut´e avant la lecture
de l’entr´e
e a
Similaire ` sed:
e e
2. des paires motif-action: les actions sont ex´cut´es sur chaque • Chercher des motifs dans un ensemble de fichiers.
e
motif filtr´
e e e
• Ex´cuter les actions sp´cifi´es sur les lignes ou champs
e e e
3. un segment optionnel END: action ex´cut´e apr`s la fin de la contenant des occurrences de ces motifs.
lecture
e e
• Traite une ligne (plus g´n´ralement un enregistrement – cf.
BEGIN { action }
motif { action } a
plus loin) ` la fois.
...
motif { action }
END { action }
[La commande awk – 5] [La commande awk – 7]
Motifs et actions Actions
e a
Une instruction ou s´quence d’instructions ` la C.
BEGIN { action } optionnel, pour imprimer un message et/ou Exemple:
initialiser de variables, par exemple.
$ ls | awk ’
motif { action } l’un au moins de motif et { action } doit BEGIN { print "Les fichiers PDF sont:" }
e e
ˆtre pr´sent. /\.pdf$/ { print }
e e e a
• si motif est absent, { action } est ´x´cut´e ` chaque END a
{ print "Et voil`!" }
ligne; ’
• si { action } est absent, la ligne est imprim´e.
e Les fichiers PDF sont:
cours1.pdf
END { action } optionnel, pour imprimer un message. ...
a
Et voil`!
[La commande awk – 8] [La commande awk – 10]
Motifs e
D´finition et usage de variables
e
Un programme awk qui compte les lignes en entr´e:
BEGIN { total = 0 }
e
Les motifs agissent comme des s´lecteurs: { total ++ }
e
BEGIN ou END : motifs sp´ciaux. END { print total }
e e
/regexpr/ expression r´guli`re.
e e
Certaines variables sont pr´d´finies:
e
pr´dicat par exemple x > 0
e
• RS (record separator). Par d´faut, c’est <NEWLINE> (not´ e
motif && motif , (ou ||), e e e
\n), mais peut ˆtre n’importe quelle expression r´guli`re (le
par exemple /ETGL/ && name == "Cours UNIX" e a
changer dans l’action associ´e ` BEGIN);
• NR (number of records): nombre d’enregistrements lus
jusqu’alors.
[La commande awk – 9] [La commande awk – 11]
Champs Imprimer
e e
Chaque ligne en entr´e est divis´e en champs:
e
• FS (field separator), par d´faut c’est [ \t]+
ıne e
– Peut valoir la chaˆ vide (chaque caract`re est alors un
e
• le r´sultat de calculs
e e e
champ), un seul caract`re, ou une expression r´guli`re.
– { print $1, $2 * $3 }
e e
– Peut ˆtre chang´ dans l’action du BEGIN
– { print "la dette de" $1, "est", $2 * $3 }
e e e
– Peut ˆtre sp´cifi´ par awk -Fr pour changer FS en r
Il existe aussi une commande printf qui permet de formatter les
e
• $0 est la ligne enti`re, $1, $2, . . . , les champs
impressions (similaire au printf de C).
Attention: seuls les noms de champs commencent par $, les
e
autres variables sont utilis´es comme dans un langage de
programmation habituel (au contraire du shell).
[La commande awk – 12] [La commande awk – 14]
Imprimer e
S´lection
Imprimer:
Comparaison:
• chaque ligne:
• $2 >= 5 { print }
– awk ’{ print }’ ...
• $2 * $3 > 50 { printf("%6.2f pour %s\n", $2 * $3, $1) }
– awk ’{ print $0 }’ ...
Filtrage de texte:
• certains champs:
• $1 == "ETGL"
– awk ’{ print $1, $3 }’ ... • /ETGL/
– awk ’{ print $1, $NF }’ ... (le $ accepte une
Combinaison de motifs:
e
expression arithm´tique)
• $2 >= 4 || $3 >= 20
– awk ’{ print NF, $1, $(NF-2) }’ ... imprime le • NR >= 10 && NR <= 20
e e e
nombre de champs, le premier champ, et l’ant´p´nulti`me
[La commande awk – 13] [La commande awk – 15]
Variables e e
Quelques fonctions pr´d´finies
• length(s)
{ nc = nc + length($0) + 1
• Les variables de awk sont vues comme de type num´rique ou
e nw = nw + NF }
texte selon le contexte. END { print NR, "lines,", nw, "words,", nc, "chars" }
• Elles n’ont pas besoin d’ˆtre d´clar´es, et valent soit 0 soit la
e e e ıne
• substr(s,i,len) produit la sous-chaˆ de s commen¸ant c
au i e
`me caract`re et de longueur au plus ´gale ` len.
e e a
ıne
chaˆ vide, selon le contexte.
• tolower(s)
• toupper(s)
[La commande awk – 16] [La commande awk – 18]
ınes
Manipulation de chaˆ o
Structures de contrˆle
• La concat´nation de chaˆ
e ınes se note par juxtaposition: Conditionnelle:
{ names = names $1 " " } $2 > 1 { n = n + 1; dette = dette + $2 * $3 }
END { print names }
END { if (n > 0)
e
• Imprimer la derni`re ligne. e
print n, "d´biteurs multiples, de dette dotale:",
NR garde sa valeur apr`s la derni`re lecture, mais pas $0:
e e dette, "-- moyenne: ", dette/n
else
{ last = $0 } e e
print "aucun d´biteur n’a emprunt´ plus d’une fois"
END { print last } }
[La commande awk – 17] [La commande awk – 19]
o
Structures de contrˆle e
Structures de donn´es: tableaux
Boucle while:
ee e e
• Les ´l´ments de tableaux ne sont pas d´clar´s
# interest1 - compute compound interest
# input: amount, rate, years e
• Les indices de tableaux peuvent ˆtre
# output: compound value at end of each year – des nombres
{ i = 1
ınes (tableaux associatifs)
– des chaˆ
while (i <= $3) {
printf("\t%.2f\n", $1 * (1 + $2) ^ i) • Exemples:
i = i + 1 – tab[3]="une chaine"
} – note["Jean"]=14.5
}
[La commande awk – 20] [La commande awk – 22]
o
Structures de contrˆle Exemple d’utilisation de tableaux
# reverse
Boucle for: e
# - imprime l’entr´e dans l’ordre inverse des lignes
# interest2 - compute compound interest
# input: amount, rate, years { line[NR] = $0 } e
# m´morise chaque ligne
# output: compound value at end of each year
END {
{ for (i = 1; i <= $3; i = i + 1) for (i=NR; (i > 0); i=i-1) {
printf("\t%.2f\n", $1 * (1 + $2) ^ i) print line[i]
} }
}
[La commande awk – 21] [La commande awk – 23]
Quelques exemples courts e
Op´rateurs
• /chaine/ { nlines = nlines + 1 } • = affectation
END { print nlines }
e e
• ==, != tests d’´galit´
• $1 > max { max = $1; maxline = $0 }
END { print max, maxline } ı
• ~, !~ test de filtrage (cha^ne ~ /motif/ )
• { temp = $1; $1 = $2; $2 = temp; print } • && ||, conjonction, disjonction
• { sum = 0 e
• ! n´gation
for (i = 1; i <= NF; i = i + 1)
• <, >, <=, >=
sum = sum + $i
print sum • +, -, /, *, %, ^
}
e ıne
• juxtaposition: concat´nation de chaˆ
[La commande awk – 24] [La commande awk – 26]
Quelques variables de awk e e
Functions pr´d´finies
e
Arithm´tiques
• $0, $1, $2, . . . , $NF • sin, cos, atan, . . .
• NR – nombre d’enregistrements trait´s
e ınes
Chaˆ
ınes, . . .
• length, substitution, recherche de sous-chaˆ
• NF – nombre de champs dans l’enregistrement courant
Impression
e
• FILENAME – nom du fichier d’entr´e courant
• print, printf
e
• FS – s´parateur de champs
e
Sp´ciales
e e
• OFS – s´parateur de champs en sortie (espace, par d´faut)
e
• system ex´cute une commande Unix (system("pwd"))
e e e a
• exit arrˆte la lecture, et ex´cute l’action associ´e ` END si elle existe.
[La commande awk – 25] [La commande awk – 27]
La commande make
e e e
Dans l’exemple pr´c´dent, on sait que prog d´pend de
version.h et de prog.c: toute modification de l’un ou de
e e
l’autre implique de reg´n´rer prog.
La commande make
La commande make permet de:
e e
• repr´senter ces d´pendances;
e a
• indiquer les op´rations ` effectuer pour refabriquer les cibles
e
en cas de modification (de la date) des pr´requis.
[La commande make – 28] [La commande make – 30]
e e e
G´n´ralit´s e
La commande make: d´pendances
a e
De nombreuses tˆches (d´veloppement, production de e e e
Une r`gle de d´pendance est not´e comme suit:
e e e e
documents, etc) n´cessitent des op´rations r´p´titives:
e e
cible: pr´requis1 pr´requis2 ...
$ emacs progr.c & e
# ´dition
------->action1
$ cc -o ./prog prog.c e
# test, ´dition et ...
$ cc -o ./prog prog.c # test, ´dition et ...
e ------->action2
$ ... ------->...
C’est encore pire si la modification d’un fichier a un impact sur Les lignes d’actions commencent obligatoirement par un
d’autres: e
caract`re tabulation.
e
$ emacs version.h & # ´dition. Exemple:
e
# version.h contient le num´ro de version
# et prog.c mentionne version.h prog: version.h prog.c
$ cc -o ./prog ./prog.c ------->cc -o prog prog.c
[La commande make – 29] [La commande make – 31]
La commande make Exemple
e e e e
La description des d´pendances est g´n´ralement donn´e dans un $ cat Makefile
e
fichier nomm´ makefile ou Makefile.
prog: f1.o f2.o f3.o
$ cat Makefile ------->cc -o prog f1.o f2.o f3.o
prog: version.h prog.c
------->cc -o prog prog.c
f1.o: f1.c
$ make
cc -o prog prog.c ------->cc -c f1.c
e a a
Ici, prog n’´tait pas ` jour. La commande make l’a mis ` jour.
f2.o: f2.c i1.h
$ make ------->cc -c f2.c
make: ‘prog’ is up to date.
a a
Ce second appel ` make remarque que prog est ` jour, et f3.o: f3.c i1.h i2.h
e
n’effectue aucune op´ration. ------->cc -c f3.c
[La commande make – 32] [La commande make – 34]
Fonctionnement de make Exemple
´ e e e
Etant donn´ un makefile (fichier d´crivant les d´pendances), et
une cible, make construit un graphe (acyclique) de d´pendances
e e e
Le graphe de d´pendances associ´ est:
pour cette cible: prog
cc −o prog f1.o f2.o f3.o
prog
f1.o f2.o f3.o
cc −c f1.c cc −c f2.c cc −c f3.c
version.h prog.c
e
Les feuilles de ce graphe ne d´pendent de rien (sont toujours `a
e e
jour), et les nœuds sont reconstruits (si n´cessaire) en ex´cutant f1.c f2.c f3.c i1.h i2.h
e e
les actions sp´cifi´es par le makefile.
[La commande make – 33] [La commande make – 35]
La commande make Make
e a
make construit et traite le graphe de d´pendances ` partir de la
e e e
premi`re cible (ou de la ou des cibles sp´cifi´es). Les cibles non
e e
rencontr´es durant ce parcours sont ignor´es.
La commande make: make utilise pour cela:
a e e
• automatise ces tˆches r´p´titives e e
• les r`gles explicites pr´sentes dans le makefile
e a a
• effectue le minimum de travail n´cessaire ` la mise ` jour des e e
• les r`gles de suffixes pr´sentes dans le makefile
cibles
e e e
• et des r`gles implicites pr´d´finies
e
Le traitement des r`gles est soumis a l’expansion des variables.
e
Les commentaires sont ignor´s.
[La commande make – 36] [La commande make – 38]
Contenu d’un makefile Variables (macros)
Un makefile contient: e a e
Variables ou macros sont destin´es ` simplifier ou param´trer un
makefile.
c
• des commentaires (lignes commen¸ant par #)
e
D´finition:
e e e
• des r`gles (cible + pr´requis + actions), d´finissant des cibles
nom = valeur
a e a e
` construire, leurs pr´requis, et les actions ` ex´cuter pour
leur construction e e
Les macros sont utilis´es dans les r`gles et dans les actions par:
$(nom)
e e e
• des d´finitions de variables (appel´es aussi macros), destin´es
ou bien par
ae e
` ˆtre utilis´es dans le makefile
${nom}
e e e e
• des r`gles de suffixes (suffix rules) ou r`gles g´n´riques,
u e
Dans le cas o` le nom de la variable est monocaract`re, on peut
indiquant comment produire un fichier avec un certain suffixe utiliser:
a e e
` partir d’un fichier de mˆme nom avec un suffixe diff´rent.
$x
[La commande make – 37] [La commande make – 39]
Variables (suite) e e
Variables pr´d´finies
Attention: les actions contiennent des commandes et des variables e e
Les variables vues pr´c´demment ont une valeur “globale”
e e e e
shell. Les caract`res $ destin´s au shell doivent ˆtre not´s $$ a
(uniforme), c’est-`-dire que toutes leurs occurrences dans le
Exemple: e
makefile ont la mˆme valeur.
# Un exemple de Makefile e e
La valeur d’une variable est recherch´e par make, par priorit´
BINDIR=/usr/local/bin
e
d´croissante, dans:
install: prog 1. les arguments de make;
------->test -d $(BINDIR) && cp prog $(BINDIR)/prog || \ 2. e
les variables d´finies dans le makefile;
cp prog $$HOME/bin/prog 3. les variables d’environnement (les variables du shell);
prog: prog.c version.h 4. e e
variables internes pr´d´finies.
------->...
e e
Il existe aussi des variables pr´d´finies, telles:
clean:
------->/bin/rm -f *.o *.c~ prog CC=cc
[La commande make – 40] [La commande make – 42]
exemple Variables non uniformes
Il existe des variables dont la valeur n’est pas uniforme mais varie
e
Les noms de cibles, des listes d’objets peuvent ˆtre des variables:
e e
de r`gle en r`gle.
EXE = prog
OBJ = main.o f1.o f3.o e e
Elles permettent de d´signer la cible courante ou les pr´requis de
la cible courante:
$(EXE): $(OBJ)
• $@ le nom de la cible courante;
------->cc -o $(EXE) $(OBJ) -lm
e e
• $? liste des pr´requis plus r´cents que la cible.
e e ıne
Les variables non d´finies sont remplac´es par la chaˆ vide.
prog: f1.c f2.c
e e
Les valeurs de variables peuvent ˆtre forc´es sur la ligne de ------->cc -o $@ f1.c fic2.c
commande (prenant le pas sur celles contenues dans le makefile):
prog: prog.c
$ make "EXE=testprog"
------->cc -o $@ $?
[La commande make – 41] [La commande make – 43]
R`gles de suffixes (dites aussi r`gles g´n´riques)
e e e e Usage de make
e
On utilise souvent les mˆmes actions pour passer d’un fichier avec Syntaxe:
a
un certain suffixe (.c, par ex.) ` un fichier avec un autre (.o).
make [options] [cible ...]
e e e c
make permet d’exprimer ces r`gles g´n´riques de la fa¸on
Options:
suivante:
• -f file utilise file comme makefile
.c.o: • -d imprime des informations de debug
------->echo Rebuilding $*.o from $*.c a e
• -k met ` jour le plus possible de cibles interm´diaires (au lieu de
------->$(CC) -c $< e e e
s’arrˆter d`s la premi`re erreur)
• -i ignore les codes de retour des actions
Ici, a e e
• -n imprime les actions ` ex´cuter (sans les ex´cuter)
e e e e
• $< est le pr´requis qui a d´clench´ la r`gle (le .c);
e e e
Si aucune cible n’est sp´cifi´e, la cible par d´faut est celle de la
e e
• $* est le pr´fixe de la cible (c’est aussi celui du pr´requis) e e
premi`re r`gle du makefile.
[La commande make – 44] [La commande make – 46]
e e e
R`gles g´n´riques Usage de make
ıt e
make connaˆ un certain nombre de suffixes et de r`gles e
Si l’option -f file n’est pas pr´sente, make teste d’abord la
e e e e
g´n´riques pr´d´finies. e e
pr´sence d’un fichier nomm´ makefile, puis celle de Makefile.
e e e
Il est souvent plus clair d’effacer ces suffixes et r`gles pr´d´finies e
Ex´cution des actions:
e
pour en donner une d´finition explicite:
e e
Chaque action est ex´cut´e dans un nouveau shell.
# On efface les suffixes connus
.SUFFIXES: e
Il ne faut donc pas ´crire:
e
# Et on se d´finit les siens:
.SUFFIXES: .tex .dvi .pdf ------->cd quelque_part
# R`gles
e a e
------->commande ` ex´cuter
.tex.dvi:
------->latex $< mais:
.dvi.pdf:
------->dvipdfm $<
a e
------->cd quelque_part && commande ` ex´cuter
[La commande make – 45] [La commande make – 47]
make: erreurs communes
Erreurs courantes:
• une ligne d’action ne commence pas par <TAB>
e
• une action sur plusieurs lignes n’est pas continu´e par un \ en
fin de ligne
e ee
• un $ dans une action qui est destin´ au shell n’a pas ´t´
e
doubl´ ($$)
e
• une variable FOO de make est ´crite $FOO au lieu de $(FOO)
ou ${FOO}
• mauvaise utilisation des variables $@, $?, $<, . . .
[La commande make – 48]
