gawk

Nom

Synopsis

Description

La ligne de commande consiste en des options de gawk lui-même, le texte du programme AWK (s'il n'est pas fourni par une option -f ou --file ), et les valeurs à rendre accessibles aux variables AWK prédéfinies ARGC et ARGV

Format Des Options

Les options de Gawk peuvent être ou bien les options traditionnelles d'une lettre , ou bien les options longues du type GNU. Les options commencent par un unique ``-'', alors que les options longues débutent par ``--''. Les options longues sont fournies pour des caractéristiques spécifiques à la fois à GNU et à .

Suivant le standard , les options spécifiquesàawk sont fournies via des arguments à l'option -W De multiples options -W peuvent être fournies. Chaque option -W a une option longue correspondante, comme détaillé ci-dessous. Les arguments des options longues sont jointes à l'option par un signe = , sans espaces, ou peuvent être fournies à l'argument suivant de la ligne de commandes. Les options longues peuvent être abrégées, pour autant que l'abréviation reste unique.

Options

Gawk accepte les options suivantes

-F fs

--field-separator fs

Utiliser fs pour le séparateur de champs (la valeur de la variable prédéfinie FS ).

-v var=val

--assign var=val

Affecter la valeur val, à la variable var, avant le début de l'exécution du programme. De telles valeurs de variables sont disponibles pour le bloc BEGIN d'un programme AWK.

-f fichier-programme

--file fichier-programme

Lire le programme source AWK à partir du fichier fichier-programme, au lieu du premier argument de la ligne de commandes. De multiples options -f (ou --file) peuvent être utilisées.

-mf NNN

-mr NNN

Donner des limites de mémoire variées à la valeur NNN. Le drapeau f fixe le nombre maximal de champs, et le drapeau r fixe la taille d'enregistrement maximale. Ces deux drapeaux et l'option -m viennent de la version de recherche des Laboratoires Bell de awk . Elles sont ignorées par gawk, car gawk n'a pas de limites prédéfinies.

-W traditional

-W compat

--traditional

--compat

Exécuter en mode de compatibilité En mode de compatibilité, gawk se comporte identiquement à awk ; aucune des extensions spécifiques GNU ne sont reconnues. L'utilisation de --traditional est préférée aux autres formes de cette option. Voyez EXTENSIONS GNU, ci-dessous pour de plus amples informations.

-W copyleft

-W copyright

--copyleft

--copyright

Affiche la version courte du message d'information sur le copyright GNU copyright sur la sortie standard, et se termine avec succès.

-W help

-W usage

--help

--usage

Affiche un résumé relativement court des options disponibles sur la sortie standard. (Pour les Standards de Codage GNU, ces options provoquent un arrêt immédiat et une terminaison avec succès.)

-W lint

--lint

Fournir des avertissements sur des constructions qui sont douteuses ou non portables aux autres implémentations d'AWK.

-W lint-old

--lint-old

Fournir des avertissements sur des constructions qui ne sont pas portables sur la version originale de l' awk Unix.

-W posix

--posix

Ceci active le mode de compatibilité avec les restrictions additionnelles suivantes :

les séquences d'échappement \x ne sont pas reconnues.

Seuls les espaces et les tabulations peuvent servir de séparateurs de champs quand FS est fixé à un unique espace, les sauts de ligne (\n) ne le peuvent pas.

Le synonyme func du mot-clé function n'est pas reconnu.

Les opérateurs ** et **= ne peuvent être utilisés au lieu de ^ et ^=.

La fonction fflush() n'est pas disponible.

-W re-interval

--re-interval

Activer l'utilisation d' expressions intervalles dans des expressions régulières correspondantes. (voir Expressions Régulières, ci-dessous). Les expressions d'intervalles n'étaient pas traditionnellement disponibles dans le langage AWK. Le standard POSIX les a ajoutées, pour rendre awk et egrep cohérents l'un avec l'autre. Néanmoins, leur usage va probablement empêcher les anciens programmes AWK de bien fonctionner, donc gawk les fournit uniquement si elles sont requises avec cette ou si --posix est spécifié.

-W source texte-programme

--source texte-programme

Utiliser program-text comme code source AWK. Cette option permet le mélange de librairies de fonctions (utilisées via les options -f et --file ) avec le code source entré sur la ligne de commandes. C'est prévu à l'origine pour les programmes AWK moyens à grands utilisés dans les scripts shell.

-W version

--version

Afficher de l'information sur la version de gawk utilisée par cette copie, sur la sortie standard. C'est utile principalement pour savoir si la copie actuelle de gawk présente sur votre système est à jour par rapport à celle que la Free Software Foundation distribue. C'est également utile lorsque vous reportez des bogues. (Pour les Standards de Codage GNU, ces options provoquent un arrêt immédiat et une terminaison avec succès.)

--

Signaler la fin des options. C'est utile pour permettre à des arguments ultérieurs du programme AWK lui-même de débuter avec un ``-''. C'est utilisé principalement pour la cohérence avec la convention de parsage des arguments utilisée par la plupart des autres programmes .

Dans le mode de compatibilité, toute autre option est marquée comme étant illégale, mais est ignorée dans les autres cas. Dans les opérations normales, aussi longtemps que le texte du programme est fourni, les options non reconnues sont passées au programme AWK dans le tableau ARGV pour être traitées. Ceci est particulièrement utile pour exécuter des programmes via le mécanisme ``#!'' d'interpréteur exécutable.

Execution D'un Programme AWK

Un programme AWK consiste d'une séquence d'instructions motif-action et de définitions optionnelles de fonctions.

motif    { instructions d'action }
fonction nom(liste de paramètres) { instructions }

Gawk lit d'abord le source du programme du (des) fichier(s)-programme(s) si spécifié(s), des arguments de --source, ou du premier argument non option sur la ligne de commandes. Les options -f et --source peuvent être utilisées de multiples fois sur la ligne de commande. Gawk lira le texte du programme comme si tous les fichiers-programmes avaient été concaténés ensemble. Ceci est utile pour la construction de librairies de fonctions AWK, sans avoir à les inclure dans chaque nouveau programme AWK qui les utilise. Cela permet également de mélanger les fonctions de librairies avec des programmes en ligne de commande.

La variable d'environnement AWKPATH spécifie un chemin de recherche à utiliser pour trouver les sources nommées avec l'option -f. Si cette variable n'existe pas, le chemin par défaut est
".:/usr/local/share/awk". (Le répertoire réel peut varier, selon la façon dont gawk a été construit et installé.) Si un nom de fichier donné à l'option -f contient un caractère ``/'' , aucune recherche n'est effectuée dans le chemin de recherche.

Gawk exécute les programmes AWK dans l'ordre suivant. D'abord, toutes les affectations de variable spécifiées par l'option -v sont effectuées. Ensuite, gawk compile le programme dans une forme interne. Après cela, gawk exécute le code du (des) bloc(s) BEGIN (s'il y en a), et poursuit en lisant chaque fichier nommé dans le tableau ARGV . S'il n'y a aucun fichier nommé sur la ligne de commandes, gawk lit l'entrée standard.

Si un nom de fichier sur la ligne de commandes a la forme var=val , il est traité comme une affectation de variable. La variable var se verra affecter la valeur val. (Ceci se produit après que tous les blocs BEGIN aient été exécutés.) L'affectation d'une variable sur la ligne de commande est utile principalement pour assigner dynamiquement des valeurs aux variables qu'utilise AWK pour contrôler comment l'entrée est découpée en champs et en enregistrements. Elle elle aussi utile pour contrôler l'état si plusieurs passes sont nécessaires sur un unique fichier de données.

Si la valeur d'un élément particulier de ARGV est vide (""), gawk l'ignore.

Pour chaque enregistrement en entrée, gawk effectue des tests pour voir s'il correspond à un des motifs du programme AWK. Pour chaque motif auquel correspond l'enregistrement, l' action associée est exécutée. Les motifs sont testés dans leur ordre d'apparition dans le programme.

Finalement, après que toute l'entrée ait été épuisée, gawk exécute le code du (des) bloc(s) END (s'il y en a).

Variables, Enregistrements Et Champs

Les variables AWK sont dynamiques, elles commencent leur existence quand elles sont utilisées pour la première fois. Leurs valeurs sont soit des nombres flottants, soit des chaînes de caractères, soit les deux, ceci dépendant de la façon dont ils sont utilisés. AWK a également des tableaux à une dimension; les tableaux à plus d'une dimension peuvent être simulés. Plusieurs variables prédéfinies sont fixées quand un programme s'exécute; celles-ci seront décrites au moment voulu et sont résumées ci-après.

Enregistrements

Normalement, les enregistrements sont séparés par des sauts de ligne (newline). Vous pouvez contrôler comment les enregistrements sont séparés en affectant des valeurs à la variable prédéfinie RS. Si RS est n'importe quel caractère unique, ce caractère séparera les enregistrements. Sinon, RS est une expression régulière. Le texte en entrée qui correspond à cette expression régulière séparera l'enregistrement. Néanmoins, dans le mode de compatibilité, seul le premier caractère de chaque chaîne de caractères est utilisé pour séparer les enregistrements. Si on affecte à RS la chaîne vide, alors les enregistrements sont séparés par des lignes blanches. Quand on affecte à RS la chaîne vide, alors le saut de ligne agit toujours comme un séparateur de champ, en plus de n'importe quelle valeur que FS puisse avoir.

Champs

Quand un enregistrement est lu, gawk le découpe en champs, en utilisant la valeur de la variable FS comme séparateur de champs. Si FS est un unique caractère, les champs sont séparés par ce caractère. Si FS est la chaîne vide, alors chaque caractère individuel devient un champ séparé. Sinon, FS est supposé être une expression régulière complète. Dans le cas spécial où FS est un espace unique, les champs sont séparés par des tas d'espaces et/ou de tabulations et/ou de sauts de lignes. (Mais voyez la discussion sur --posix, ci-dessous). Notez que la valeur de IGNORECASE (voir ci-dessous) affectera également la façon dont les champs seront découpés quand FS est une expression régulière, et la façon dont les enregistrements seront séparés quand RS est une expression régulière.

Si on affecte à la variable FIELDWIDTHS une liste de nombres séparés chaque fois par un espace, chaque champ est supposé avoir une largeur fixe, et gawk découpera l'enregistrement en utilisant les largeurs spécifiées. La valeur de FS est ignorée. Affecter une nouvelle valeur à FS passe outre l'utilisation de FIELDWIDTHS, et restaure le comportement par défaut.

Chaque champ dans l'enregistrement d'entrée peut être référencé par sa position : $1, $2, etc. $0 est l'enregistrement complet. La valeur d'un champ peut également être affectée. Les champs ne doivent pas forcément être référencés par des constantes :

n = 5
print $n

imprime le cinquième champ dans l'enregistrement d'entrée. La variable NF contient le nombre total de champs dans l'enregistrement d'entrée.

Les références à des champs non existantes (çàd les champs après $NF) produiront la chaîne vide. Néanmoins, affecter vers un champ non existant (p. ex. (e.g., $(NF+2) = 5) augmenteront la valeur de NF, en créant tous les champs interposés avec la chaîne vide comme valeur, et force à recalculer la valeur de $0 , les champs étant séparés par la valeur de OFS. Les références à des champs de numéros négatifs provoqueront une erreur fatale. Décrémenter NF oblige les valeurs des champs suivant la nouvelle valeur à être perdus, et à recalculer la valeur de $0 , les champs étant séparés par la valeur de OFS.

Variables prédéfinies

Les variables prédéfinies de Gawk sont :

ARGC

Le nombre d'arguments en ligne de commandes (n'inclut pas les options de gawk, ni le source du programme).

ARGIND

La position dans ARGV du fichier courant étant en train d'être traité.

ARGV

Tableau des arguments en ligne de commandes. Le tableau est indexé de 0 à ARGC - 1. Changer dynamiquement le contenu de ARGV peut contrôler les fichiers utilisés pour données.

CONVFMT

Le format de conversion pour les nombres, "%.6g", par défaut.

ENVIRON

Un tableau contenant les valeurs de l'environnement actuel. Le tableau est indexé par les variables d'environnement, chaque élément étant la valeur de cette variable (çàd ENVIRON["HOME"] pouvant être /home/fred). Changer ce tableau n'affecte pas l'environnement vu par les programmes qu'engendre gawk via une redirection où la fonction system() gawk.)

ERRNO

Si une erreur système se produit ou bien en faisant une redirection pour getline, durant une lecture pour getline, or durant un close(), alors ERRNO contiendra une chaîne de caractères décrivant l'erreur.

FIELDWIDTHS

Une liste de largeurs de champs séparés chaque fois par un espace. Quand elle est remplie, gawk parse l'entrée en champs de largeurs fixées, au lieu d'utiliser la valeur de la variable FS comme séparateur de champs. La facilité apportée par les champs de largeurs fixées est toujours expérimentale; la sémantique peut changer en même temps qu'évolue gawk au fil du temps.

FILENAME

Le nom du fichier d'entrée actuel. Si aucun fichier n'a été spécifié sur la ligne de commandes, la valeur de FILENAME est ``-''. Néanmoins, FILENAME n'est pas défini à l'intérieur du bloc BEGIN

FNR

Le numéro d'enregistrement d'entrée dans le fichier d'entrée courant.

FS

Le séparateur des champs en entrée, un espace par défaut. Voir champs, ci-dessus.

IGNORECASE

Contrôle la sensibilité à la casse de toutes les expressions régulières et des opérations sur les chaînes de caractères. Si IGNORECASE a une valeur non nulle, alors les comparaisons de chaînes de caractères et la correspondance de motifs dans les règles, la découpe en champs avec FS, la séparation d'enregistrements avec RS, les expression régulières correspondant avev ~ et !~, et les fonctions prédéfinies gensub(), gsub(), index(), match(), split(), et sub() ignoreront la casse quand elles effectueront des opérations sur des expressionns régulières. Donc, si IGNORECASE n'est pas égal à zéro, /aB/ correspond à toutes les chaînes de caractères "ab", "aB", "Ab", et "AB". Comme pour toutes les variables AWK, la valeur initiale de IGNORECASE est de zéro, de sorte que toutes les expressions régulières et les opérations sur des chaînes de caractères sont normalement sensibles à la casse. Sous Unix, l'ensemble entier de caractères ISO 8859-1 Latin-1 est utilisé quand on ignore la casse. NOTE: Dans les versions de gawk préalables à 3.0, IGNORECASE affecte uniquement les opérations sur les expressions régulières. Maintenant, il affecte également les comparaisons de chaînes de caractères.

NF

Le nombre de champs dans l'enregistrement d'entrée courant.

NR

Le nombre total d'enregistrements d'entrée rencontrés à ce moment.

OFMT

Le format de sortie pour les nombres,, "%.6g", par défaut.

OFS

Le séparateur de champs en sortie, un espace par défaut.

ORS

Le séparateur d'enregistrements en sortie, un saut de ligne par défaut.

RS

Le séparateur d'enregistrements en entrée, un saut de ligne par défaut.

RT

Le terminateur d'enregistrement. Gawk affecte à RT le texte d'entrée qui correspond au caractère ou à l'expression régulière spécifié(e) par RS.

RSTART

L'indice du premier caractère qui correspond par match(); 0 s'il n'y a pas de correspondance.

RLENGTH

La longueur de la chaîne de caractères qui correspond par match(); -1 s'il n'y a pas de correspondance.

SUBSEP

Le caractère utilisé pour séparer les sous-indices multiples des éléments de tableaux, par défaut "\034".

Tableaux

Les tableaux sont indicés par une expression entre crochets ([ et ]). Si l'expression est une liste d'expressions (expr, expr ...) alors le SUBSCRIPT du tableau est une chaîne de caractères consistant en la concaténation de la valeur (chaîne de caractères) de chaque expression, séparées par la valeur de la variable SUBSEP . Cette facilité est utilisée pour simuler les tableaux multi-dimensionnels. Par exemple :

i = "A"; j = "B"; k = "C"
x[i, j, k] = "hello, world\n"

affecte la chaîne de caractères "hello, world\n" à l'élément du tableau x qui est indexé par la chaîne de caractères "A\034B\034C". Tous les tableaux dans AWK sont associatifs, çàd qu'ils sont indexés par des valeurs de type chaîne de caractères

L'opérateur spécial in peut être utilisé dans une instruction if ou while pour voir si un tableau comporte un indixe consistant en cette valeur particulière.

if (val in tableau)
    print tableau[val]

Si le tableau a de multiples SUBSCRIPTS, utilisez (i, j) in tableau .

La construction in peut également être utilisée dans une boucle for pour itérer sur tous les éléments du tableau.

Un élément peut être supprimé d'un tableau en utilisant l'instruction delete . L'instruction delete peut aussi être utilisée pour supprimer l'entièreté du contenu d'un tableau, en spécifiant uniquement le nom du tableau sans indices.

Typage des Variables et Conversion

Les variables et les champs peuvent être des nombres (flottants), ou des chaînes de caractères, ou les deux. Savoir comment la valeur d'une variable est interprétée dépend du contexte. Si elle est utilisée dans une expression numérique, elle sera traitée en tant que nombre; si elle est utilisée en tant que chaîne de caractères, elle sera traitée comme une chaîne de caractères.

Pour forcer une variable à être traitée comme un nombre, ajoutez-lui zéro; pour la forcer à être traitée comme une chaîne de caractères, concaténez-la avec la chaîne de caractères vide.

Quand une chaîne de caractères doit être convertie en nombre, la conversion est accomplie en utilisant atof(3) . Un nombre est converti en une chaîne de caractères en utilisant la valeur de CONVFMT en tant que chaîne de format pour sprintf(3) , avec la valeur numérique de la variable comme argument. Néanmoins, même si tous les nombres en AWK sont des flottants, les valeurs intégrales sont toujours converties en entiers. Donc, en ayant

CONVFMT = "%2.2f"
a = 12
b = a ""

la variable b à une valeur de type chaîne de caractères de "12" et non de "12.00".

Gawk effectue les comparaisons comme suit : si deux variables sont numériques, elles sont comparées numériquement. Si une valeur est numérique et l'autre a une valeur de type chaîne de caractères qui est une ``chaîne de caractères numérique'', alors les comparaisons sont effectuées numériquement. Sinon, la valeur numérique est convertie en une chaîne de caractères et une comparaison de chaînes de caractères est effectuée. Les deux chaînes de caractères sont comparées, bien sûr, comme des chaînes de caractères. Selon le standard , même si deux chaînes de caractères sont des chaînes de caractères numériques, une comparaison de chaînes de caractères est effectuée. Néanmoins, c'est clairement incorrect, et gawk ne fait pas cela.

Notez que les constantes de type chaîne de caractères, telles que "57", ne sont pas des chaînes de caractères numériques, ce sont des constantes de type chaîne de caractères. L'idée de ``chaîne de caractères numérique'' s'applique uniquement aux champs, à l'entrée de getline , à FILENAME, aux éléments de ARGV , aux éléments de ENVIRON et aux éléments d'un tableau créé par split() qui sont des chaînes de caractères numériques. L'idée de base est que l'entrée de l'utilisateur, et uniquement l'entrée de l'utilisateur, qui semble numérique, devrait être traitée de cette façon.

Les variables non initialisées ont la valeur numérique 0 et la valeur de type chaîne de caractères "" (la chaîne de caractères vide).

Motifs Et Actions

AWK est un langage orienté ligne. Le motif vient en premier lieu, et ensuite vient l'action. Les instructions d'action sont enfermées dans des accolades { et }. Le motif peut être absent, ou bien l'action, mais pas les deux. Si le motif est manquant, l'action sera exécutée une fois pour chaque enregistrement d'entrée. Une action manquante est équivalente à

{ print }

qui affiche l'enregistrement en entier.

Les commentaires commencent avec le caractère ``#'' , et continuent jusqu'à la fin de la ligne. Les lignes blanches peuvent être utilisées pour séparer des instructions. Normalement, une instruction se termine par un saut de ligne; néanmoins, ce n'est pas le cas pour les lignes se terminant par ``,'', {, ?, :, &&, ou ||. Les lignes se terminant par do ou else voient leurs instructions automatiquement continuées sur la ligne suivante. Dans les autres cas, une ligne peut être continuée en la terminant par un ``\'', auquel cas le saut de ligne est ignoré.

De multiples instructions peuvent être placées sur une ligne en les séparant par un ``;''. Ceci s'applique aussi bien aux instructions de la partie action d'une paire motif-action (le cas habituel), qu'aux instructions motif-action elles-mêmes.

Motifs

Les motifs AWK peuvent prendre une des formes suivantes :

BEGINEND/expression régulière/expression relationnellemotif && motifmotif
|| motifmotif ? motif : motif(motif)! motifmotif1, motif2

BEGIN et END sont deux types de motifs particuliers qui ne sont pas testées en fonction de l'entrée. Les actions de tous les motifs BEGIN sont fusionnés comme si toutes les instructions avaient été écrites dans un seul bloc BEGIN . Elles sont exécutées avant la lecture de quoi que ce soit en entrée. De façon similaire, tous les blocs END sont fusionnés quand l'entrée est épuisée (ou quand une instruction exit est éxécutée). Les motifs BEGIN et END ne peuvent être combinés avec d'autres motifs dans les expressions de motif. Les motifs BEGIN et END ne peuvent avoir de partie action manquante.

Pour les motifs de type /expression régulière/ , l'instruction associée est exécutée pour chaque enregistrement d'entrée qui correspond à l'expression régulière. Les expressions régulières sont les mêmes que celles de egrep(1) , et sont résumées ci-dessous.

Une expression relationnelle peut utiliser n'importe quel opérateur défini plus bas dans la section dédiée aux actions. Ces expressions testent en général si certains champs correspondent à certaines expressions régulières.

Les opérateurs &&, ||, et ! sont des OU, des ET, et des NON logiques respectivement, comme en C. Ils effectuent une évaluation paresseuse, encore comme en C, et sont utilisées pour combiner des expressions de motif plus primitives. Comme dans la plupart des langages, les parenthèses peuvent être employées pour modifier l'ordre d'évaluation.

L'opérateur ?: se comporte comme le même opérateur en C. Si le premier motif correspond, alors le motif utilisé pour le test de correspondance sera le deuxième motif; sinon, ce sera le troisième. Seul un seul d'entre les deux- et troisième motifs est évalué.

La forme motif1, motif2 d'une expression est appelée un motif de portée. Il correspond à tous les enregistrements d'entrée dont le début correspond à pattern1, et continue jusqu'à ce qu'un enregistrement corresponde entièrement à pattern2. Il ne se combine avec aucun autre type d'expression de motif.

Expressions Régulières

Les Expressions Régulières utilisent la forme étendue trouvée dans egrep. Elles sont composées de caractères de la façon suivant :

c

correspond caractère (non méta) c.

\c

corespond au caractère littéral c. .

correspond à tout caractère incluant le saut de ligne.

^

correspond au début d'une chaîne de caractères.

$

correspond à la fin d'une chaîne de caractères.

[abc...]

: correspond à n'importe lequel des caractères abc....

[^abc...]

: liste de caractères niés, correspond à tous les caractères sauf abc....

r1|r2

: alternative à laquelle correspond r1 ou r2.

r1r2

: concaténation à laquelle correspond à
r1, puis r2.

r+

correspond à au moins un r.

r*

correspond à un nombre (événetuellement nul) quelconque de r.

r?

correspond à zéro ou un r.

(r)

: correspond à
r.

r{n}

r{n,}

r{n,m}

Un des deux nombres à l'intérieur des accolades dénote une expression d'intervalle. S'il n'y a qu'un nombre à l'intérieur des accolades, l'expression régulière r est répétée n fois. S'il y a deux nombres séparés par une virgule, r est répété de n à m fois. S'il y a un seul nombre suivi d'une virgule, alors r est répété au moins n fois.

Les expressions d'intervalle sont uniquement disponibles si --posix ou bien si --re-interval est spécifié sur la ligne de commandes.

\y

correspond à la chaîne de caractères vide au début ou à la fin d'un mot.

\B

correspond à la chaîne de caractères à l'intérieur d'un mot.

\<

correspond à la chaîne de caractères vide au début d'un mot.

\>

correspond à la chaîne de caractères vide à la fin d'un mot.

\w

correspond à n'importe caractère (lettre, chiffre ou caractère de soulignement) faisant partie du mot.

\W

correspond à n'importe caractère ne faisant pas partie du mot.

\`

correspond à la chaîne de caractères vide au début d'un tampon (chaîne de caractères).

\'

correspond à la chaîne de caractères vide à la fin d'un tampon.

Les séquences d'échappement qui sont valides dans les constantes de type chaîne de caractères (voir ci-dessous) sont également légales dans les expressions régulières.

Les Classes de Caractères forment une nouvelle caractéristique introduite par le standard POSIX. Une classe de caractères est une notation spéciale pour décrire des listes de caractères qui ont un attribut spécifique, mais les caractères réels eux-mêmes peuvent varier de pays en pays et/ou de table de caractères à table de caractères. Par exemple, la notion de ce qu'est un caractère alphabétique diffère aux USA et en France.

Une classe de caractères est uniquement valide dans une expression régulière à l'intérieur des crochets d'une liste de caractères. Les classes de caractères consistent en [:, un mot-clé dénotant la classe, et en :]. Voici les classes de caractères définies par le standard POSIX.

[:alnum:]

Caractères alphanumériques.

[:alpha:]

Caractères alphabétiques.

[:blank:]

Espaces ou tabulations.

[:cntrl:]

Caractères de contrôle.

[:digit:]

Caractères numériques.

[:graph:]

Caractères qui sont à la fois imprimables et visibles. (Un espace est imprimable, mais pas visible, alors qu'un a est les deux à la fois.)

[:lower:]

Caractères alphabétiques en minuscules.

[:print:]

Caractères imprimables (qui ne sont pas des caractères de contrôle.)

[:punct:]

Caractères de ponctuation (caractères qui ne sont ni des lettres, ni des chiffres, ni des caractères de contrôle, ou encore des caractères d'espacements).

[:space:]

Caractères d'espacements (comme l'espace ou la tabulation pour n'en nommer que quelques uns).

[:upper:]

Caractères alphabétiques en majuscules.

[:xdigit:]

Caractères qui sont des chiffres hexadécimaux.

Par exemple, avant le standard POSIX, pour détecter les caractères alphanumériques, vous auriez dû écrire /[A-Za-z0-9]/. Si votre page de caractères contenait d'autres caractères alphanumériques, ceci ne les aurait pas fait correspondre. Avec les classes de caractères POSIX, vous pouvez écrire /[[:alnum:]]/, et ceci "détectera" tous les caractères alphabétiques et alphanumériques que contient votre page de caractères.

Deux séquences additionnelles spéciales peuvent apparaître dans les listes de caractères. Elles s'appliquent aux pages de caractères non ASCII, qui peuvent avoir des simples symboles (appelés éléments assemblés) qui sont représentés par plus d'un caractère, de même que certains caractères qui sont équivalent pour des buts d'assemblage, où de triage. (P.ex., en français, un ``e'' simple, et un e accent-grave sont équivalents.)

Symboles Assemblés

Un symbole assemblé est un élément assemblé multi-caractères enfermé dans des [. et .]. Par exemple, si ch est un élément assemblé, alors [[.ch.]] est une expression régulière qui correspond à cet élément, alors que [ch] est une expression régulière qui correspond à c ou h.

Classes d'Equivalences

Une classe d'équivalence est un nom spécifique au lieu pour une liste de caractères qui sont équivalents. Le nom est enfermé dans des [= et =]. Par exemple, le nom e pourrait être utilisé pour représenter tous les ``e'', ``é'', ou ``è.'' Dans ce cas, [[=e]] est une expression régulière qui correspond à n'importe lequel des e, é, ou è.

Ces caractéristiques sont très précieuses dans les lieux où l'on ne parle pas l'anglais. Les fonctions de librairie qu'utilise gawk pour effectuer la correspondance avec des expressions régulières ne reconnaîssent actuellement que les classes de caractères POSIX; elles ne reconnaîssent ni les symboles assemblés, ni les classes d'équivalence.

Les opérateurs \y, \B, \<, \>, \w, \W, \`, et \' sont spécifiques à gawk; ce sont des extensions basées sur des facilités offertes par les librairies GNU sur les expressions régulières.

Les options variées de la ligne de commandes contrôlent comment gawk interprète les caractères dans les expressions régulières.

Pas d'options

Dans le cas par défaut, gawk fournit toutes les facilités des expressions régulières POSIX et des opérateurs GNU sur les expressions régulières décrits ci-dessus. Néanmoins, les expressions d'intervalle ne sont pas supportées.

--posix

Seules les expressions régulières POSIX sont supportées, les opérateurs GNU perdent toute signification spéciale (p.ex., \w correspond à un w littéral). Les expressions d'intervalle sont permises.

--traditional

Les expressions régulières traditionnelles de l' awk UNIX sont utilisées. Les opérateurs GNU perdent toute signification spéciale, les expressions d'intervalle ne sont pas disponibles, ni les classes de caractères POSIX ([[:alnum:]] , etc). Les caractères décrits par des séquences d'échappement octales ou hexadécimales sont traitées littéralement, même s'ils représentent des métacaractères d'expressions régulières.

--re-interval

Permet l'usage d'expressions d'intervalle dans les expressions régulières, même si --traditional a été fourni.

Actions

Les instructions d'action sont enfermées dans des accolades, { et }. Les instructions d'action consistent en les instructions d'affectation usuelles, d'alternative et de boucles trouvées dans la plupart des langages. Les opérateurs, instructions de contrôle et instructions d'entrée/sortie disponibles sont calquées sur celles du C.

Opérateurs

En AWK, les opérateurs sont, par ordre décroissant de priorité,

(...)

Groupement

$

Référence de champ.

++ --

Incrémentation et décrémentation, à la fois préfixées et postfixées.

^

Exponentiation (** peut également être utilisé, et **= pour l'opérateur d'affectation).

+ - !

Plus unaire, moins unaire et négation logique.

* / %

Multiplication, division, et modulo.

+ -

Addition et soustraction.

espace

Concaténation de chaînes de caractères.

< >

<= >=

!= ==

Les opérateurs relationnels normaux.

~ !~

Correspondance (négation) d'expressions régulières. NOTE: N'utilisez pas d'expression régulière constante (/foo/) du côté gauche d'un ~ ou un !~. Utilisez-la uniquement du côté droit. L'expression /foo/ ~ exp possède la même signification que (($0 ~ /foo/) ~ exp). Ce n'est d'habitude pas ce à quoi on s'attendait.

in

Appartenance à un tableau.

&&

ET logique.

||

OU logique.

?:

L'expression conditionnelle C. Elle a la forme expr1 ? expr2 : expr3. Si expr1 est vraie, la valeur de l'expression sera expr2, sinon, elle sera expr3. Seule une expression d'entre expr2 et expr3 est évaluée.

= += -=

*= /= %= ^=

Affectation. A la fois l'affectation (var = valeur) et l'affection-opérateur (les autres formes) sont supportées.

Instruction de Contrôle

Les instruction de contrôle sont les suivantes :

if (condition) instruction [ else instruction ]
while (condition) instruction 
do instruction while (condition)
for (expr1; expr2; expr3) instruction
for (var in tableau) instruction
break
continue
delete tableau[indice]
delete tableau
exit [ expression ]
{ instructions }

Instructions d'E/S

Les instruction d'entrée-sortie sont les suivantes :

close(fichier)

Fermer un fichier (ou un tube, voir ci-dessous).

getline

Fixer $0 à partir de l'enregistrement d'entrée suivant; fixer NF, NR, FNR.

getline <fichier

Fixer $0 à partir du prochain enregistrement de fichier; fixer NF.

getline var

Fixer var à partir du prochain enregistrement d'entrée; fixer NR, FNR.

getline var <fichier

Fixer var à partir du prochain enregistrement de fichier.

next

Arrêter de traiter l'enregistrement d'entrée courant. L'enregistrement d'entrée suivant est lu et le traitement commence avec le premier motif du programme AWK. Si la fin des données d'entrée est atteinte, le ou les blocs END , s'il y en a, sont exécutés.

nextfile

Arrêter de traiter le fichier d'entrée actuel. Le prochain enregistrement d'entrée lu provient du fichier d'entrée suivant. FILENAME et ARGIND sont mis à jour, FNR est réinitialisé à 1, et le traitement recommence avec le premier motif du programme AWK. Si la fin des données d'entrée est atteinte, le ou les blocs END , s'il y en a, sont exécutés. NOTE: Des versions plus anciennes de gawk utilisaient next file en deux mots. Bien que cette utilisation soit toujours reconnue, elle génère un message d'avertissement et sera éventuellement supprimée.

print

Affiche l'enregistrement courant. L'enregistrement de sortie est terminé par la valeur de la variable ORS .

print liste-expr

Affiche des expressions. Chaque expression est séparée par la valeur de la variable OFS . L'enregistrement de sortie est terminé par la valeur de la variable ORS .

print liste-expr >fichier

Affiche des expressions dans fichier. Chaque expression est séparée par la valeur de la variable
OFS . L'enregistrement de sortie est terminé par la valeur de la variable ORS .

printf fmt, liste-expr

Formatte et affiche.

printf fmt, liste-expr >fichier

Formatte et affiche dans fichier.

system(cmd-line)

Exécute la commande cmd-line, et renvoie la valeur de sortie. (Ceci peut ne pas être disponible sur les systèmes non .)

fflush([fichier])

Vide tous les tampons associés au fichier d'entrée ouvert ou au tube fichier. Si fichier est manquant, alors la sortie standard est vidée. Si fichier est la chaîne de caractères vide, alors les tampons de tous les fichiers de sortie ouverts et de tous les tubes sont vidés.

Les autres redirections d'entrée/sortie sont également permises. Pour print et printf, >>fichier concatène la sortie à fichier, alors que | commande écrit dans un tube. D'une manière similaire, commande | getline écrit via un tube à getline. La commande getline renvoie 0 à la fin du fichier, et -1 en cas d'erreur.

L'instruction printf

Les versions AWK de l'instruction printf et de la fonction sprintf() (voir ci-dessous) acceptent les formats de spécification de conversion de formats suivants :

%c

Un caractère ASCII . Si l'argument utilisé pour %c est numérique, il est traité en tant que caractère et est affiché. Sinon, l'argument est supposé être une chaîne de caractères, et seul le premier caractère de cette chaîne de caractères est affiché.

%d

%i

Un nombre décimal (la partie entière).

%e

%E

Un nombre flottant de la forme [-]d.dddddde[+-]dd. Le format %E utilise E au lieu de e.

%f

Un nombre flottant de la forme [-]ddd.dddddd.

%g

%G

Utilise la conversion %e ou %f (prend la plus courte), les zéros non significatifs étant supprimés. Le format %G utilise %E au lieu de %e.

%o

Un nombre octal non signé (à nouveau un entier).

%s

Une chaîne de caractères.

%x

%X

Un nombre hexadécimal non signé (un entier). Le format %X utilise ABCDEF au lieu de abcdef.

%%

Un unique % caractère; aucun argument n'est converti.

Il y a des paramètres supplémentaires optionnels qui peuvent être placés entre % et la lettre de contrôle :

-

L'expression devrait être justifiée à gauche à l'intérieur de son champ.

espace

Pour les conversions numériques, préfixe les valeurs positives avec un espace, et les valeurs négatives avec un signe moins.

+

Le signe plus, utilisé avant le modificateur de largeur (voir ci-dessous), indique de toujours fournir un signe pour les conversions numériques, même si la donnée à être formatée est positive. Le + surcharge le modificateur espace.

#

Utiliser une ``forme alternative'' pour certaines lettres de contrôle. Pour %o, fournir un zéro de tête. Pour %x, et %X, fournir un 0x ou un 0X de tête pour un résultat non nul. Pour %e, %E, et %f, le résultat comprendra toujours un point décimal. Pour %g, et %G, les zéros de queue ne sont pas supprimés du résultat.

Un 0 (zéro) de tête agit comme un drapeau, qui indique que la sortie devrait être complétée avec des zéros plutôt qu'avec des espaces. Cela s'applique même pour les formats de sortie non numériques. Ce drapeau a un effet uniquement lorsque la largeur du champ est plus grande que la valeur à afficher.

largeur

Le champ devrait être complété jusqu'à cette largeur. Le champ est normalement complété par des espaces. Si le drapeau 0 a été utilisé, le champ est complété par des zéros. .

Un nom qui spécifie la précision à utiliser lors de l'affichage. Pour les formats %e, %E, et %f , il spécifie le nombre de chiffres à afficher à la droite du point décimal. Pour les formats %g, et %G , il spécifie le nombre maximal de chiffres significatifs. Pour les formats %d, %o, %i, %u, %x, et %X , il spécifie le nombre minimal de chiffres à afficher. Pour une chaîne de caractères, il spécifie le nombre maximal de caractères de cette chaîne à être affichés.

Les aptitudes dynamiques ( largeur et précision ) des routines printf() du C sont supportées. Une * au lieu des spécifications largeur ou précision obligera à prendre leurs valeurs de la liste d'arguments de printf ou de sprintf().

Noms de Fichiers Spéciaux

Quand il effectue une redirection entrée/sortie de print ou de printf dans un fichier, ou via getline à partir d'un fichier, gawk reconnaît certains noms de fichiers spéciaux en interne. Ces noms de fichiers permettent l'accès aux descripteurs des fichiers ouverts hérités du processus parent de gawk (habituellement le shell). D'autres noms de fichiers spéciaux permettent l'accès à de l'information sur le processus gawk en cours d'exécution. Les noms de fichiers sont :

/dev/pid

Lire ce fichier renvoie l'identificateur de processus du processus courant, en décimal, terminé par un saut de ligne.

/dev/ppid

Lire ce fichier renvoie l'identificateur de processus du processus père du processus courant, en décimal, terminé par un saut de ligne.

/dev/pgrpid

Lire ce fichier renvoie l'identificateur de groupe de processus du processus courant, en décimal, terminé par un saut de ligne.

/dev/user

Lire ce fichier renvoie un simple enregistement terminé par un saut de ligne. Les champs sont séparés par des espaces. $1 est la valeur de l'appel système getuid(2) , $2 est la valeur de l'appel système geteuid(2) , $3 est la valeur de l'appel système getgid(2) , et $4 est la valeur de l'appel système getegid(2) . S'il y a des champs additionnels, ce sont les identificateurs de groupe renvoyés par getgroups(2) . Les groupes multiples peuvent ne pas être supportés sur tous les systèmes.

/dev/stdin

L'entrée standard.

/dev/stdout

La sortie standard.

/dev/stderr

La sortie d'erreur standard.

/dev/fd/n

Le fichier associé au descripteur du fichier ouvert n.

Ceux-ci sont particulièrement utiles pour les messages d'erreur. Par exemple :

print "Vous êtes grillés!" > "/dev/stderr"

alors que vous auriez du utiliser à la place

print "Vous êtes grillés!" | "cat 1>&2"

Ces noms de fichiers peuvent également être utilisés sur la ligne de commandes pour nommer les fichiers de données.

Fonctions Numériques

AWK comprend les fonctions arithmétiques prédéfinies suivantes :

atan2(y, x)

renvoie l'arctangente def y/x exprimée en radians.

cos(expr)

renvoie le cosinus de expr, en radians.

exp(expr)

la fonction d'exponentiation.

int(expr)

tronque en entier.

log(expr)

la fonction logarithmique naturelle (logarithme népérien).

rand()

renvoie un nombre aléatoire entre 0 et 1.

sin(expr)

renvoie le sinus de expr, en radians.

sqrt(expr)

la fonction de prise de racine carrée.

srand([expr])

utilise expr comme une nouvelle "semence" pour le générateur de nombres aléatoires. Si expr n'est pas fourni, l'heure du moment sera utilisée. La valeur de retour est la semence précédente du générateur de nombres aléatoires.

Fonctions sur les Chaînes de Caractères

Gawk possède les fonctions prédéfinies suivantes sur les chaînes de caractères :

gensub(r, s, h [, t])

recherche dans la chaîne de caractères cible t pour y trouver des occurences de l'expression régulière r. Si h est une chaîne de caractères commençant par g ou G, alors, remplacer toutes les occurences de r par s. Sinon, h est un nombre indiquant quelle occurence de r remplacer. Si t n'est pas fourni, $0 est utilisé à la place. A l'intérieur du texte de remplacement s, la séquence \n, où n est un chiffre de 1 à 9, peut être utilisée pour indiquer exactement le texte qui correspond à la n-ième sous-expression parenthésée. La séquence \0 représente le texte trouvé en entier, comme le fait le caractère &. A la différence de sub() et de gsub(), la chaîne de caractères modifiée est renvoyée comme résultat de la fonction, et la chaîne de caractères cible originale n'est pas changée.

gsub(r, s [, t])

pour chaque sous-chaîne correspondant à l'expression régulière r dans la chaîne t, substituer la chaîne de caractères s, et renvoyer le nombre de substitutions. Si t n'est pas fourni, utiliser $0. Un & dans le texte de remplacement est remplacé par le texte qui correspondait réellement. Utilisez \& pour obtenir un & littéral. Voyez AWK Language Programming pour une discussion plus complète sur les règles pour les & et les backslashs dans le texte de remplacement de sub(), gsub(), et gensub().

index(s, t)

renvoie la position de la chaîne de caractères t dans la chaîne de caractères s, ou 0 si t n'y est pas présent.

length([s])

renvoie la longueur de la chaîne de caractères s, ou la longueur de $0 si s n'est pas fourni.

match(s, r)

renvoie la position dans s où l'expression régulière r est trouvée, ou 0 si r n'est pas présent, et fixe les valeurs de RSTART et de RLENGTH.

split(s, a [, r])

découpe la chaîne de caractères s dans le tableau a sur base de l'expression régulière r, et renvoie le nombre de champs. Si r est omis, FS est utilisé à la place. Le tableau a est d'abord "nettoyé". La découpe se conduit de la même façon que la découpe en champs, décrite plus haut.

sprintf(fmt, liste-expr)

affiche liste-expr selon le format fmt, et renvoie la chaîne de caractères résultante.

sub(r, s [, t])

comme gsub(), mais seule la première chaîne de caractères correspondant est remplacée.

substr(s, i [, n])

renvoie une chaîne de caractères d'au plus n caractères de la sous-chaîne de s débutant à l'indice i. Si n est omis, le reste de s est utilisé.

tolower(str)

renvoie une copie de la chaîne de caractères str, où tous les caractères de str en majuscule sont traduits dans leur contre-partie en minuscule. Les caractères non alphabétiques demeurent inchangés.

toupper(str)

renvoie une copie de la chaîne de caractères str, où tous les caractères de str en minuscule sont traduits dans leur contre-partie en majuscule. Les caractères non alphabétiques demeurent inchangés.

Fonctions de Temps

Puisqu'une des utilisations premières des programmes AWK est le traitement de fichiers de connexion qui contiennent de l'information sur des cachets temporels (time stamps), gawk fournit les deux fonctions suivantes pour obtenir les cachets temporels et les formater.

systime()

renvoie l'heure actuelle sous forme du nombre de secondes écoulées depuis le début de l'Epoque (le 1er Janvier 1970 à minuit GMT sur les systèmes ).

strftime([format [, cachet_temporel]])

formatte cachet_temporel selon les spécifications de format. Le cachet_temporel devrait être de la même forme que celle renvoyée par systime(). Si cachet_temporel est manquant, l'heure actuelle est utilisée. Si format est manquant, un format par défaut équivalent à la sortie de date(1) sera utilisé. Voyez la spécification de la fonction strftime() du C pour obtenir les conversions de format qui sont garanties comme étant disponibles. Une version dans le domaine public de strftime(3) et une page de manuel pour cela vient avec gawk; si cette version a été utilisée pour construire gawk, alors toutes les conversions décrites dans cette page de manuel sont accessibles par gawk.

Constantes de type Chaîne de Caractères.

Les constantes de type chaîne de caractères dans AWK sont des séquences de caractères enfermées entre des guillemets. A l'intérieur des chaînes de caractères, certaines séquences d'échappement sont reconnues, comme en C. Les voici :

\\

Un backslash (\) littéral.

\a

Le caractère d'alerte ; d'habitude le caractère ASCII BELL .

\b

caractère d'effacement arrière (backspace).

\f

retout chariot

\n

saut de ligne.

\r

retour chariot.

\t

tabulation horizontale.

\v

tabulation verticale.

\xchiffres hexadécimaux

Le caractère représenté par la chaîne de caractères de chiffres hexadécimaux suivant le \x. Comme dans le C C, tous les chiffres hexadécimaux suivants sont considérés comme faisant partie de la séquence d'échappement. (Cette caractéristique devrait nous dire quelquechose sur la conception du langage par le comité.) Par exemple, "\x1B" est le caractère (d'échappement) ASCII ESC .

\ddd

Le caractère représenté par la séquence de 1,2 ou 3 chiffres octals. P.ex., "\033" est le caractère (d'échappement) ASCII ESC .

\c

Le caractère littéral c.

Les séquences d'échappement peuvent également être utilisées à l'intérieur d'expressions régulières (p.ex., /[ \t\f\n\r\v]/ détecte les caractères d'espacement).

Dans le mode de compatibilité, les caractères représentés par des séquences d'échappement octales ou hexadécimales sont traitées littéralement quand elles sont utilisées dans des constantes d'expressions régulières. Donc, /a\52b/ est équivalent à /a\*b/.

Fonctions

Les fonctions en AWK se définissent comme suit :

function nom(liste de paramètres) { instructions }

Les fonctions sont exécutées quand elles sont appelées à l'intérieur d'expressions dans les motifs ou les actions. Les paramètres réels fournis à l'appel de fonction sont utilisés pour instancier les paramètres formels déclarés dans la fonction. Les tableaux sont passés par adresse, les autres variables sont passées par valeur.

Puisque les fonctions ne faisaient pas partie à l'origine du langage AWK, les mesures prises pour les variables locales sont plutôt maladroites : elles sont déclarées comme des paramètres supplémentaires dans la liste de paramètres. La convention est de séparer les variables locales des paramètres réels en ajoutant des espaces supplémentaires dans la liste de paramètres. Par exemple :

function  f(p, q,     a, b)    # a & b sont locales
{
    .....
}
/abc/    { ... ; f(1, 2) ; ... }

La parenthèse gauche d'un appel de fonction doit suivre immédiatement le nom de la fonction, sans aucun espace blanc entre les deux, ceci dans le but d'éviter une ambiguïté syntaxique avec l'opérateur de concaténation. Cette restriction ne s'applique pas aux fonctions prédéfinies listées plus haut.

Les fonctions peuvent s'appeler l'une l'autre et peuvent être récursives. Les paramètres de fonction utilisés comme variables locales sont initialisés à la chaîne vide et au nombre zéro à l'invocation de la fonction.

Utilisez return expr pour renvoyer la valeur d'une fonction. La valeur de retour est indéfinie si aucune valeur n'est fournie, ou si la fonction se termine sans avoir rencontré d'instruction return , çàd à la fin du corps de la fonction.

Si --lint a été fourni, gawk avertira d'appels à des fonctions non définies au moment de l'analyse syntaxique, au lieu d'avertir au moment de l'exécution. Appeler une fonction non définie au moment de l'exécution provoque une erreur fatale.

Le mot func peut être utilisé en lieu et place de function.

Exemples

Afficher et trier les noms de connexion de tous les utilisateurs :
    BEGIN    { FS = ":" }
        { print $1 | "sort" }
Compter les lignes d'un fichier :
        { nlignes++ }
    END    { print nlignes }
Précéder chaque ligne par son numéro dans le fichier :
    { print FNR, $0 }
Concaténater et numéroter les lignes (une variation sur ce thème) :
    { print NR, $0 }

Voir Aussi

egrep(1) , getpid(2) , getppid(2) , getpgrp(2) , getuid(2) , geteuid(2) , getgid(2) , getegid(2) , getgroups(2)

The AWK Programming Language, Alfred V. Aho, Brian W. Kernighan, Peter J. Weinberger, Addison-Wesley, 1988. ISBN 0-201-07981-X.

AWK Language Programming, Edition 1.0, publié par la Free Software Foundation, 1995.

Compatibilite Posix

Un des objectifs principaux de gawk est la compatibilité avec le standard , aussi bien qu'avec la dernière version de awk pour . Pour y parvenir, gawk incorpore les caractéristiques visibles de l'utilisateur qui ne sont pas décrites dans le livre sur AWK, mais qui font partie de la version awk des Laboratoires Bell, et qui sont dans le standard .

L'option -v, destinée à effectuer une affectation de variables avant l'exécution du programme, est nouvelle. Le livre indique que l'affectation de variables en ligne de commandes peut être effectuée quand awk ouvrirait l'argument comme un fichier, çàd après que le bloc BEGIN ait été exécuté. Néanmoins, dans des implémentations plus anciennes, quand une telle affectation apparaît avant n'importe quel nom de fichier, l'affectation se produisait avant que le bloc BEGIN ne soit exécuté. Des applications en sont venues à dépendre de cette caractéristique. Quand awk a été modifié pour se conformer à sa documentation, cette option a été ajoutée pour s'accomoder d'applications qui dépendent de l'ancien comportement. (Cette caractéristique à été agréée à la fois par les développeurs de AT&T et ceux de GNU.)

L'option -W pour des caractéristiques spécifiques à l'implémentation provient du standard .

Quand il traite les arguments, gawk utilise l'option spéciale ``--'' pour signaler la fin des arguments. Dans le mode de compatibilité, il avertira des options non définies (sinon, il les ignorera). Lors d'une opération normale, de tels arguments sont passés au programme AWK pour qu'il les traite.

Le livre sur AWK ne définit pas la valeur de retour de srand(). Le standard lui fait renvoyer la semence qu'il utilisait, pour permettre de garder une trace des séquences de nombres aléatoires. Donc, le srand() de gawk renvoie également sa semence courante.

D'autres nouvelles caractéristiques sont : l'utilisation d'options -f multiples (de l' awk de MKS), le tableau ENVIRON , les séquences d'échappement \a, et \v (créées à l'origine dans gawk et ensuite intégrées dans celui de AT&T's), les fonctions prédéfinies tolower() et toupper() (de AT&T) et les spécifications de conversions de format du C dans printf (implémentées en premier lieu dans la version de AT&T).

Extensions GNU

Gawk possède un certain nombre d'extensions par rapport au awk . Elles sont décrites dans cette section. Toutes les extensions décrites ici peuvent être désactivées en invoquant gawk avec l'option --traditional .

Les caractéristiques suivantes de gawk ne sont pas disponibles dans l' awk .

• La séquence d'échappement \x (Désactivée avec --posix).
• La fonction fflush() (Désactivée avec --posix.)
• Les fonctions systime(), strftime(), et gensub().
• Les noms de fichiers spéciaux disponibles pour les redirections d'entrée/sortie ne sont pas reconnus.
• Les variables ARGIND, ERRNO, et RT ne sont pas spéciales.
• La variable IGNORECASE et ses effets de bord n'est pas disponible.
• La variable FIELDWIDTHS et le découpage en champs de largeurs fixées.
• L'utilisation de RS en tant qu'expression régulière.
• La faculté d'éclater des caractères individuels en utilisant la chaîne de caractères vide en tant que valeur pour FS, et en tant que troisième argument de split().
• Aucune recherche dans le chemin n'est effectuée pour les fichiers nommés par l'option -f. C'est pourquoi la variable d'environnement AWKPATH n'est pas spéciale.
• L'utilisation de nextfile pour abandonner le traitement du fichier d'entrée courant.
• L'utilisation de delete tableau pour effacer l'entièreté du contenu d'un tableau.

Le livre AWK ne définit pas la valeur de retour de la fonction close(). Le close() de Gawk renvoie la valeur de fclose(3) , ou de pclose(3) , en fermant un fichier ou un tube respectivement.

Quand gawk est invoqué avec l'option --traditional , si l'argument fs de l'option -F est ``t'', alors FS vaudra le caractère tabulation. Notez que taper gawk -F\t ... dit simplement au shell de citer ``t,'', et ne passe pas ``\t'' à l'option -F. Puisque cela est un cas spécial assez laid, ce n'est pas le comportement par défaut. Ce comportement ne se produit également pas si --posix a été spécifié. Pour avoir réellement une tabulation comme séparateur de champs, il vaut mieux utiliser des apostrophes : gawk -F'\t' ....

Caracteristiques Historiques

Il y a deux caractéristiques d'implémentations historiques d'AWK que supporte gawk. D'abord, il est possible d'appeler la fonction prédéfinie length() pas seulement sans arguments, mais même sans parenthèses ! Donc,

a = length    

est la même chose que

a = length()
a = length($0)

Cette caractéristique est marquée comme étant obsolète dans le standard , et gawk émettra un avertissement sur son utilisation si --lint est spécifié sur la ligne de commandes.

L'autre caractéristique est l'utilisation des instructions continue ou break à l'extérieur du corps d'une boucle while, for, ou do. Les implémentations traditionnelles d'AWK ont traité une telle utilisation comme étant équivalente à l'instruction next. Gawk supportera cette utilisation si --traditional a été spécifié.

Variables D'environnement

Si POSIXLY_CORRECT existe dans l'environnement, alors gawk se comporte exactement comme si --posix avait été spécifié sur la ligne de commandes. Si --lint a été spécifié, gawk émettra un avertissement à cet effet.

La variable d'environnement AWKPATH peut être utilisée pour fournir une liste de répertoires où gawk cherchera les fichiers nommés via les options -f et --file.

Bogues

L'option -F n'est pas nécessaire étant donné la caractéristique d'affectation de variables en ligne de commandes; elle n'est maintenue que pour assurer une compatibilité descendante.

Si votre système possède réellement le support des fichiers /dev/fd et des fichiers associés /dev/stdin, /dev/stdout, et /dev/stderr , vous pourriez obtenir des sorties différentes de gawk que celles que vous auriez sur un système sans ces fichiers. Quand gawk interprète ces fichiers en interne, il synchronise la sortie vers la sortie standard avec la sortie vers /dev/stdout, alors que sur un système avec ces fichiers, la sortie est effectuée réellement sur d'autres fichiers ouverts. Caveat Emptor.

Les programmes syntaxiquement invalides d'un seul caractère tendent à faire déborder la pile de l'analyseur syntaxique, générant ainsi un message pas très utile. De tels programmes sont contre toute attente difficiles à diagnostiquer dans le cas le plus général, et l'effort à faire pour le diagnostiquer n'en vaut pas vraiment la peine.

Information De Version

Cette page de manuel documente gawk, version 3.0.4.

Auteurs

La version originale de l' awk a été concue et implémentée par Alfred Aho, Peter Weinberger, et Brian Kernighan des Laboratoires Bell de AT&T. Brian Kernighan continue à le maintenir et à l'améliorer.

Paul Rubin et Jay Fenlason, de la Free Software Foundation, ont écrit gawk pour être compatible avec la version originale de awk distribuée dans la Septième Edition de . John Woods contribua a un certain nombre de corrections de bogues. David Trueman, avec la contribution d'Arnold Robbins, rendit gawk compatible avec la nouvelle version de l' awk . Arnold Robbins est le mainteneur actuel.

Le portage DOS initial a été réalisé par Conrad Kwok et Scott Garfinkle. Scott Deifik est le mainteneur DOS actuel. Rankin fit le portage sur VMS, et Michal Jaegermann celui sur l'Atari ST. Le portage sur OS/2 a été fait par Kai Uwe Rommel, avec la contribution et l'aide de Darrel Hankerson. Fred Fish a fourni le support pour l'Amiga.

Rapports De Bogues

Si vous trouvez un bogue dans gawk, envoyez svp un e-mail à bug-gnu-utils@gnu.org, avec une copie carbone à arnold@gnu.org. Incluez svp votre système d'exploitation et sa révision, la version de gawk, quel compilateur C vous avez utilisé pour le compiler, et un programme test et des données aussi petites que possible pour reproduire le problème.

Avant d'envoyer un rapport de bogue, faites deux choses s'il vous plaît. Premièrement, vérifiez que vous avez la dernière version de gawk. Beaucoup de bogues (en général assez subtils) sont corrigés à chaque nouvelle version, et si la vôtre n'est pas à jour, le problème peut déjà avoir été résolu. Deuxièmement, lisez attentivement cette page de manuel et le manuel de référence pour être sûr que ce que vous croyez être un bogue n'est pas une simple bizarrerie du langage.

Quoi que vous fassiez, n'envoyez PAS de rapport de bogue à comp.lang.awk. Bien que les développeurs gawk lisent occasionnellement ce groupe de discussions, y poster des rapports de bogues est une façon non fiable de rapporter des bogues. A la place, utilisez les adresses électroniques données ci-dessus.

Remerciements

Brian Kernighan des Laboratoires Bell a fourni une aide précieuse durant les phases de déboggages et de tests. Nous l'en remercions.

Permissions De Copies

Copyright ©) 1996,97,98,99 Free Software Foundation, Inc.

L'autorisation est donnée de créer et de distribuer des copies textuelles de ce manuel, à condition que la notice de copyright et la notice de permission soient préservées dans toutes les copies.

L'autorisation est donnée de copier et distribuer des versions modifiées de ce manuel sous les conditions de copie textuelle, à condition que l'entièreté du travail dérivé résultant soit distribuée sous les termes d'une autorisation identique à celle-ci.

L'autorisation est donnée de copier et distribuer des traductions de ce manuel dans n'importe quel autre langue, sous les conditions ci-dessus pour les versions modifiées, sauf que cette notice de permission peut être incluse dans des traductions approuvées par la Free Software Foundation au lieu de l'anglais originel.

Traduction

Frédéric Delanoy, 2000.

---

Table des matières

• Nom
• Synopsis
• Description
• Format Des Options
• Options
• Execution D'un Programme AWK
• Variables, Enregistrements Et Champs
• Enregistrements
• Champs
• Variables prédéfinies
• Tableaux
• Typage des Variables et Conversion
• Motifs Et Actions
• Motifs
• Expressions Régulières
• Actions
• Opérateurs
• Instruction de Contrôle
• Instructions d'E/S
• L'instruction printf
• Noms de Fichiers Spéciaux
• Fonctions Numériques
• Fonctions sur les Chaînes de Caractères
• Fonctions de Temps
• Constantes de type Chaîne de Caractères.
• Fonctions
• Exemples
• Voir Aussi
• Compatibilite Posix
• Extensions GNU
• Caracteristiques Historiques
• Variables D'environnement
• Bogues
• Information De Version
• Auteurs
• Rapports De Bogues
• Remerciements
• Permissions De Copies
• Traduction

---

© 1996-2000 Adaptation française "Christophe Blaess"