Loading

NOM

       gawk - Langage d'examen et de traitement de motifs.

SYNOPSIS

       gawk [ options de style POSIX ou GNU ] -f fichier-programme [ -- ] fichier ...
       gawk [ options de style POSIX ou GNU ] [ -- ] texte-programme fichier ...

       pgawk [ options de style POSIX ou GNU ] -f fichier-programme [ -- ] fichier ...
       pgawk [ options de style POSIX ou GNU ] [ -- ] texte-programme fichier ...

gawk est l'implémentation du projet GNU du langage de programmation AWK. Elle est conforme à la définition du langage édictée par le Standard POSIX 1003.2 des Langages de Commandes et Utilitaires. Cette version est également basée sur la description donnée dans The AWK Programming Language, de Aho, Kernighan, et Weinberger, avec les fonctionnalités supplémentaires trouvées dans la version System V Release 4 du awk UNIX. gawk fournit également les extensions awk plus récentes des Laboratoires Bell, et quelques extensions spécifiques GNU.

pgawk est la version de profilage de gawk. Elle est identique en tout point à gawk, à l'exception près que les programmes s'exécutent plus lentement, et qu'elle produit automatiquement un profil d'exécution dans le fichier awkprof.out quand elle a fini. Voyez l'option --profile plus bas.

La ligne de commandes est constituée des options de gawk lui-même, du texte du programme AWK (s'il n'est pas fourni par une option -f ou --file), et des valeurs à rendre disponibles dans les variables AWK prédéfinies ARGC et ARGV.

FORMAT DES OPTIONS

Les options de gawk peuvent être soit les options traditionnelles d'une lettre POSIX, soit les options longues du type GNU. Les options POSIX commencent par un unique « - », alors que les options longues débutent par « -- ». Les options longues sont fournies à la fois pour des fonctionnalités spécifiques à GNU, et pour des fonctionnalités mandatées par POSIX.

Suivant le standard POSIX, les options spécifiques à gawk 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 soit liés à l'option via un = , sans espaces, soit peuvent être fournis comme argument suivant sur 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, listées alphabétiquement :

    -F sc 
    --field-separator sc Utiliser sc en tant que 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 que l'exécution du programme ne débute. De telles valeurs de variables sont accessibles au bloc BEGIN d'un programme AWK. 
    -f fichier-programme 
    --file fichier-programme Lire le source du programme 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 Spécifier 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 proviennent de la version de recherche des Laboratoires Bell du awk UNIX. Elles sont ignorées par gawk, car gawk n'a pas de limites prédéfinies. 
    -W compat 
    -W traditional 
    --compat 
    --traditional Exécuter en mode de compatibilité. En mode de compatibilité, gawk se comporte identiquement au awk UNIX ; aucune des extensions spécifiques GNU n'est reconnue. 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 Afficher la version courte du message d'information sur le copyright GNU sur la sortie standard, et se terminer avec succès. 
    -W dump-variables[=fichier] 
    --dump-variables[=fichier] Imprimer une liste triée des variables globales, de leur type et valeur finale dans fichier. Si aucun fichier n'est fourni, gawk utilise un fichier nommé awkvars.out dans le répertoire courant.

    Disposer d'une liste de toutes les variables globales est un bon moyen pour rechercher des erreurs typographiques dans vos programmes. Vous devriez également utiliser cette option si vous avez un gros programme avec un tas de fonctions, et que vous voulez vous assurer que vos fonctions n'utilisent pas par inadvertance des variables globales que vous pensiez être locales. (C'est une erreur particulièrement facile à commettre avec des noms de variables simples comme i, j, etc.) 
    -W help 
    -W usage 
    --help 
    --usage Afficher un résumé relativement court des options disponibles sur la sortie standard. (Selon les Standards de Codage GNU, ces options provoquent un arrêt immédiat, avec succès.) 
    -W lint[=fatal] 
    --lint[=fatal] Émettre des avertissements sur des constructions qui sont douteuses ou non portables sur d'autres implémentations AWK. Avec l'argument optionnel fatal, les avertissements de lint deviennent fatals. Cela peut sembler drastique, mais son utilisation encouragera certainement le développement de programmes AWK plus propres. 
    -W lint-old 
    --lint-old Émettre des avertissements sur des constructions qui ne sont pas portables sur la version originale de l'awk Unix. 
    -W gen-po 
    --gen-po Analyser lexicalement et syntaxiquement le programme AWK, et générer un fichier au format GNU .po sur la sortie standard contenant les entrées de toutes les chaînes locale-isables du programme. Le programme lui-même n'est pas exécuté. Voyez la distribution de GNU gettext pour plus d'informations sur les fichiers .po. 
    -W non-decimal-data 
    --non-decimal-data Reconnaître les valeurs octales et hexadécimales dans les données d'entrée. Utilisez cette option avec une extrême prudence ! 
    -W posix 
    --posix Ceci active le mode de compatibilité avec les restrictions additionnelles suivantes :

        *
            les séquences d'échappement \x ne sont pas reconnues. 
        *
            Seules les espaces et les tabulations peuvent servir de séparateurs de champs quand FS est fixé à une espace unique ; les retours à la ligne (\n) ne le peuvent pas. 
        *
            Vous ne pouvez continuer les lignes après ? ou :. 
        *
            Le synonyme func du mot-clé function n'est pas reconnu. 
        *
            Les opérateurs ** et **= ne peuvent être utilisés en remplacement de ^ et ^=. 
        *
            La fonction fflush() n'est pas disponible. 

    -W profile[=fichier_prof] 
    --profile[=fichier_prof] Envoyer des données de profilage dans fichier_prof. Le défaut est awkprof.out. Lorsqu'il est exécuté avec gawk, le profil est simplement une version « joliment affichée » du programme. Lorsqu'il est exécuté avec pgawk, le profil contient le nombre d'exécutions de chaque instruction du programme dans la marge gauche et le nombre d'appels de fonction pour chaque fonction définie par l'utilisateur. 
    -W re-interval 
    --re-interval Permettre l'utilisation d'expressions d'intervalles dans la reconnaissance des expressions rationnelles (voyez Expressions Rationnelles plus bas). Les expressions d'intervalle n'étaient pas traditionnellement disponibles dans le langage AWK. Le standard POSIX les y 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 fonctionner correctement, et gawk ne les fournit donc que si elles sont requises avec cette option ou si --posix est spécifié. 
    -W source texte-programme 
    --source texte-programme Utiliser texte-programme comme code source du programme AWK. Cette option permet le mélange de fonctions de bibliothèques (utilisées via les options -f et --file) avec le code source entré sur la ligne de commandes. C'est prévu principalement pour les programmes AWK moyens à grands utilisés dans les scripts shell. 
    -W version 
    --version Afficher des informations 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 distribuée par la Free Software Foundation. C'est également utile lorsque vous reportez des bogues. (Selon les Standards de Codage GNU, ces options provoquent un arrêt immédiat, 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 par un « - ». C'est utilisé principalement pour la cohérence avec la convention d'analyse syntaxique des arguments utilisée par la plupart des autres programmes POSIX. 

Dans le mode de compatibilité, toute autre option est marquée comme étant invalide, mais est ignorée dans les autres cas. En temps normal, 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.  

EXÉCUTION D'UN PROGRAMME AWK

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

    motif  { instructions d'action }

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

gawk lit d'abord le source du programme à partir du (des) fichier(s)-programme(s) éventuel(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 plusieurs fois sur la ligne de commandes. gawk lit le texte du programme comme si tous les fichiers-programmes avaient été concaténés ensemble. C'est utile pour la construction de bibliothèques de fonctions AWK, sans avoir à les inclure dans chaque nouveau programme AWK qui les utilise. Cela permet également de mélanger des fonctions de bibliothèques avec des programmes de ligne de commande.

La variable d'environnement AWKPATH spécifie un chemin de recherche à utiliser pour trouver les fichiers sources nommés 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, en fonction de 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 de chemin n'est effectuée.

gawk exécute les programmes AWK dans l'ordre suivant. D'abord, toutes les affectations de variables 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. (Cela se produit après l'exécution de l'entièreté des blocs BEGIN.) L'affectation de variables en ligne de commandes est principalement utile pour affecter dynamiquement des valeurs aux variables qu'utilise AWK pour contrôler la façon dont l'entrée est découpée en champs et en enregistrements. Elle est également 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 vérifie s'il correspond à un des motifs du programme AWK. Pour chaque motif convenant à 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 a é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, en fonction de la façon dont elles sont utilisées. AWK dispose également des tableaux à une dimension ; les tableaux à plus d'une dimension peuvent être simulés. Plusieurs variables prédéfinies sont réglé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 caractères de saut de ligne. Vous pouvez contrôler la façon dont les enregistrements sont séparés en affectant des valeurs à la variable prédéfinie RS. Si RS est un caractère unique quelconque, celui-ci séparera les enregistrements. Sinon, RS est une expression rationnelle. Le texte en entrée qui correspond à cette expression rationnelle découpera l'enregistrement. Néanmoins, dans le mode de compatibilité, seul le premier caractère de la chaîne 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 la valeur de RS est la chaîne vide, alors le caractère de saut de ligne agit toujours comme un séparateur de champ, en plus de la valeur de FS.  
Champs

Quand un enregistrement d'entrée 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 caractère unique, les champs sont séparés par celui-ci. Si FS est la chaîne vide, alors chaque caractère individuel devient un champ séparé. Sinon, FS est supposé être une expression rationnelle complète. Dans le cas spécial où FS est une espace unique, les champs sont séparés par des tas d'espaces et/ou de tabulations et/ou de sauts de ligne. (Mais voyez la discussion sur --posix, plus bas). Notez que la valeur de IGNORECASE (voir ci-dessous) affectera également la façon dont les champs sont découpés quand FS est une expression rationnelle, et la façon dont les enregistrements seront séparés quand RS est une expression rationnelle.

Si on affecte à la variable FIELDWIDTHS une liste de nombres séparés par des espaces, chaque champ est supposé avoir une longueur fixe, et gawk découpera l'enregistrement en utilisant les longueurs 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 de l'enregistrement d'entrée peut être référencé par sa position : $1, $2, etc. $0 est l'enregistrement complet. Les champs ne doivent pas forcément être référencés par des constantes :

    n = 5
    print $n 

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

Les références à des champs non existants (c.-à-d. les champs situés après $NF) produiront la chaîne vide. Néanmoins, affecter vers un champ non existant (p. ex. $(NF+2) = 5) augmente la valeur de NF, crée 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éro négatif provoquent une erreur fatale. Décrémenter NF force l'abandon des valeurs des champs suivant la nouvelle valeur, et le recalcul de la valeur de $0, les champs étant séparés par la valeur de OFS.

Affecter une valeur à un champ existant provoque la reconstruction de l'enregistrement complet quand $0 est référencé. De façon similaire, affecter une valeur à $0 provoque le redécoupage de l'enregistrement, en créant de nouvelles valeurs pour les champs.  
Variables prédéfinies

Les variables prédéfinies de gawk sont :

ARGC
    Le nombre d'arguments sur la ligne de commandes (n'inclut pas les options de gawk, ni le source du programme). 
ARGIND
    La position dans ARGV du fichier en cours de traitement. 
ARGV
    Tableau des arguments de la 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 les données. 
BINMODE
    Sur les systèmes non POSIX, spécifie l'utilisation du mode « binaire » pour toutes les E/S de fichier. Des valeurs numériques de 1, 2 ou 3 spécifient que les fichiers d'entrée, les fichiers de sortie ou tous les fichiers, respectivement, devraient utiliser les E/S binaires. Des valeurs de chaîne de "r" ou "w" spécifient que les fichiers d'entrée, ou les fichiers de sortie, respectivement, devraient utiliser les E/S binaires. Des valeurs de chaîne de "rw" ou "wr" spécifient que tous les fichiers devraient utiliser les E/S binaires. Toute autre chaîne est traitée comme "rw", mais génère un message d'avertissement. 
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 (p.ex. ENVIRON["HOME"] pourrait être /home/fred). Modifier ce tableau n'affecte pas l'environnement vu par les programmes qu'engendre gawk via une redirection ou via la fonction system(). 
ERRNO
    Si une erreur système se produit pendant une redirection pour getline, lors d'une lecture pour getline, or durant un close(), alors ERRNO contiendra une chaîne de caractères décrivant l'erreur. La valeur est sujette à traduction dans des localisations non anglaises. 
FIELDWIDTHS
    Une liste de largeurs de champs séparées chaque fois par des espaces. Quand elle est définie, gawk découpe l'entrée en champs de largeur fixe, au lieu d'utiliser la valeur de la variable FS comme séparateur de champs. 
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 (à moins qu'il ne soit défini par getline). 
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, une espace par défaut. Voyez Champs au-dessus. 
IGNORECASE
    Contrôle la sensibilité à la casse de toutes les expressions rationnelles 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 reconnaissance de motifs dans les règles, la découpe en champs avec FS, la séparation des enregistrements avec RS, la détection des expressions rationnelles correspondant à ~ et !~, et les fonctions prédéfinies gensub(), gsub(), index(), match(), split(), et sub() ignoreront la casse quand elles effectuent des opérations sur des expressions rationnelles. NOTE : L'indiçage de tableau n'est pas affecté, ni la fonction asort().

    Ainsi, si IGNORECASE n'est pas égal à zéro, /aB/ reconnaît chacune des chaînes "ab", "aB", "Ab" et "AB". Comme pour toutes les variables AWK, la valeur initiale de IGNORECASE est nulle, de sorte que toutes les opérations sur des expressions rationnelles ou des chaînes de caractères sont normalement sensibles à la casse. Sous Unix, l'entièreté du jeu de caractères ISO 8859-1 Latin-1 est utilisée quand on ignore la casse. 
LINT
    Fournit un contrôle dynamique de l'option --lint à partir de l'intérieur d'un programme AWK. Quand il vaut true (vrai), gawk affiche les avertissements de lint. Quand il vaut false (faux), il ne le fait pas. Quand on lui affecte pour valeur la chaîne "fatal", les avertissements de lint deviennent des erreurs fatales, exactement comme avec --lint=fatal. Toute autre valeur affiche juste des avertissements. 
NF
    Le nombre de champs dans l'enregistrement d'entrée courant. 
NR
    Le nombre total d'enregistrements d'entrée vus jusqu'ici. 
OFMT
    Le format de sortie pour les nombres, "%.6g" par défaut. 
OFS
    Le séparateur de champs en sortie, une espace par défaut. 
ORS
    Le séparateur d'enregistrements en sortie, un saut de ligne par défaut. 
PROCINFO
    Les éléments de ce tableau donnent accès à des informations sur le programme AWK en cours d'exécution. Sur certains systèmes, il peut y avoir des éléments dans le tableau, "groupe1" jusqu'à "groupen" pour un certain n, qui est le nombre de groupes supplémentaires dont le processus dispose. Utilisez l'opérateur in pour tester la présence de ces éléments. Les éléments suivants sont garantis être disponibles :

        PROCINFO["egid"]
            la valeur de l'appel système getegid(2). 
        PROCINFO["euid"]
            la valeur de l'appel système geteuid(2). 
        PROCINFO["FS"]
            "FS" si le découpage en champs avec FS est activé, ou "FIELDWIDTHS" si le découpage en champs avec FIELDWIDTHS est activé. 
        PROCINFO["gid"]
            la valeur de l'appel système getgid(2). 
        PROCINFO["pgrpid"]
            l'ID de groupe de processus du processus courant. 
        PROCINFO["pid"]
            l'ID de processus du processus courant. 
        PROCINFO["ppid"]
            l'ID du processus parent du processus courant. 
        PROCINFO["uid"]
            la valeur de l'appel système getuid(2). 

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 rationnelle 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. (Cela implique que les indices des caractères commencent à un.) 
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 d'un tableau, par défaut « \034 ». 
TEXTDOMAIN
    Le domaine de texte du programme AWK ; utilisé pour trouver les traductions locale-isées des chaînes de caractères du programme. 

 
Tableaux

Les tableaux sont indicés par une expression entre crochets ([ et ]). Si l'expression est une liste d'expressions (expr, expr ...), alors l'indice du tableau est une chaîne de caractères constituée de la concaténation de la valeur (chaîne de caractères) de chaque expression, séparées entre elles 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] = "bonjour, monde\n" 

affecte la chaîne de caractères "bonjour, monde\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, c.-à-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 déterminer si un tableau comporte un indice constitué d'une valeur particulière.

    if (val in tableau)
            print tableau[val]

Si le tableau comporte de multiples index, 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 aucun indice.  
Typage des Variables et Conversion

Les variables et les champs peuvent être des nombres (flottants), des chaînes de caractères, ou les deux. La façon dont 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 strtod(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 dans AWK sont des flottants, les valeurs intégrales sont toujours converties en entiers. Par conséquent, étant donné

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

la variable b a 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 également 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. Deux chaînes sont comparées, bien sûr, en tant que chaînes de caractères. Notez que le standard POSIX applique partout le concept de « chaîne de caractères numérique », même sur les constantes de type chaîne de caractères. Néanmoins, c'est clairement incorrect, et gawk ne fait pas cela. (Heureusement, cela est corrigé dans la prochaine version du standard.)

Notez que les constantes de type chaîne de caractères, comme "57", ne sont pas des chaînes de caractères numériques, elles sont des constantes de type chaîne de caractères. Le concept de « chaîne de caractères numériques » ne s'applique qu'aux champs, à l'entrée de getline, à FILENAME, aux éléments de ARGV, aux éléments de ENVIRON et à ceux 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 elle, 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 vide).  
Constantes Octales et Hexadécimales
À partir de la version 3.1 de gawk, vous pouvez utiliser des constantes octales et hexadécimales de style C dans le code source de vos programmes AWK. Par exemple, la valeur octale 011 est égale au 9 décimal, et la valeur hexadécimale 0x11 est égale au 17 décimal.  
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 dans des guillemets ("). À l'intérieur des chaînes, certaines séquences d'échappement sont reconnues, comme en C. Ce sont :

\\
    Un backslash littéral. 
\a
    Le caractère d'« alerte » ; habituellement le caractère ASCII BEL. 
\b
    Effacement arrière. 
\f
    saut de page. 
\n
    nouvelle ligne. 
\r
    retour chariot. 
\t
    tabulation horizontale. 
\v
    tabulation verticale. 
\xchiffres hexadécimaux
    Le caractère représenté par la chaîne de chiffres hexadécimaux suivant le \x. Comme en C ANSI, tous les chiffres hexadécimaux suivants sont considérés faire partie de la séquence d'échappement. (Cette fonctionnalité devrait nous apprendre quelque chose sur la conception du langage par le comité.) P.ex., "\x1B" est le caractère ASCII ESC (échappement). 
\ddd
    Le caractère représenté par la séquence d'un, deux ou trois chiffres octaux. P.ex., "\033" est le caractère ASCII ESC (échappement). 
\c
    Le caractère littéral c. 

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

En mode compatibilité, les caractères représentés par des séquences d'échappement octales et hexadécimales sont traités de façon littérale lorsqu'ils sont utilisés dans des constantes expression rationnelle. Par conséquent, /a\52b/ est équivalent à /a\*b/.  

MOTIFS ET ACTIONS

AWK est un langage orienté ligne. Le motif vient en premier lieu, et l'action vient ensuite. Les instructions d'action sont enfermées dans des accolades { et }. Le motif peut être absent, ou bien l'action, mais bien entendu pas les deux. Si le motif est manquant, l'action est 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 par le caractère « # » , et continuent jusqu'à la fin de la ligne. Les lignes blanches peuvent être utilisées pour séparer les 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 également leurs instructions automatiquement continuées sur la ligne suivante. Dans les autres cas, une ligne peut être continuée en la faisant terminer par un « \ », auquel cas le saut de ligne est ignoré.

Plusieurs 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 :

    BEGIN
    END
    /expression rationnelle/
    expression relationnelle
    motif && motif
    motif || motif
    motif ? motif : motif
    (motif)
    ! motif
    motif1, motif2

BEGIN et END sont deux types de motifs particuliers qui ne sont pas mis en correspondance avec l'entrée. Les parties action de tous les motifs BEGIN sont fusionnées 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, et exécutés quand l'entrée est épuisée (ou quand une instruction exit est exé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 rationnelle/ , l'instruction associée est exécutée pour chaque enregistrement d'entrée qui correspond à l'expression rationnelle. Les expressions rationnelles 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 rationnelles.

Les opérateurs &&, ||, et ! sont les ET, OU et NON logiques respectivement, comme en C. Ils effectuent une évaluation paresseuse, à nouveau 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 son homologue en C. Si le premier motif convient, alors le motif utilisé pour le test de correspondance sera le deuxième motif ; sinon, ce sera le troisième. Un seul d'entre les deuxième et troisième motifs est évalué.

La forme motif1, motif2 d'une expression est appelée un motif intervalle. Il correspond à tous les enregistrements d'entrée dont le début correspond à motif1, et continue jusqu'à ce qu'un enregistrement corresponde à motif2 inclusivement. Il ne se combine avec aucun autre type d'expression de motif.  
Expressions Rationnelles
Les expressions rationnelles utilisent la forme étendue trouvée dans egrep. Elles sont composées de caractères de la façon suivante :

c
    correspond au caractère (non méta) c. 
\c
    correspond au caractère littéral c. 
.
    correspond à n'importe quel caractère, y compris 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...]
    liste de caractères : correspond à n'importe lequel des caractères abc.... 
[^abc...]
    liste de caractères niée, correspond à tous les caractères sauf abc.... 
r1|r2
    alternative : correspond à r1 ou r2. 
r1r2
    concaténation : correspond à r1, puis r2. 
r+
    correspond à au moins un r. 
r*
    correspond à un nombre quelconque de r. 
r?
    correspond à zéro ou un r. 
(r)
    groupement : correspond à r. 
    r{n} 
    r{n,} 
    r{n,m} Un ou deux nombres à l'intérieur d'accolades dénote une expression d'intervalle. S'il y en a un, l'expression rationnelle précédente 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é entre n à m fois. S'il y a un 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 --re-interval a été 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 vide à l'intérieur d'un mot. 
\<
    correspond à la chaîne vide au début d'un mot. 
\>
    correspond à la chaîne vide à la fin d'un mot. 
\w
    correspond à n'importe caractère (lettre, chiffre ou caractère de soulignement) constitutif du mot. 
\W
    correspond à n'importe caractère ne faisant pas partie du mot. 
\`
    correspond à la chaîne 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 rationnelles.

Les classes de caractères sont une nouvelle fonctionnalité introduite par le standard POSIX. Une classe de caractères est une notation spéciale pour la description de listes de caractères qui ont un attribut spécifique, mais les caractères réels eux-mêmes peuvent varier de pays à pays et/ou de jeu de caractères à jeu 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 n'est valide dans une expression rationnelle qu'à 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 :]. Les classes de caractères définies par le standard POSIX sont :

[:alnum:]
    Caractères alphanumériques. 
[:alpha:]
    Caractères alphabétiques. 
[:blank:]
    Espaces et tabulations. 
[:cntrl:]
    Caractères de contrôle. 
[:digit:]
    Caractères numériques. 
[:graph:]
    Caractères qui sont à la fois imprimables et visibles. (Une espace est imprimable, mais pas visible, alors qu'un a est les deux à la fois.) 
[:lower:]
    Caractères alphabétiques en minuscule. 
[: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, ni des caractères d'espacement). 
[:space:]
    Caractères d'espacement (comme l'espace, la tabulation et le saut de page pour en nommer quelques uns). 
[:upper:]
    Caractères alphabétiques en majuscule. 
[: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 jeu de caractères contenait d'autres caractères alphanumériques, ceci ne les détecterait pas, et si votre jeu de caractères fusionnait (les accents avec les caractères) différemment de l'ASCII, cela pourrait ne même pas détecter les caractères alphanumériques ASCII . Avec les classes de caractères POSIX, vous pouvez écrire /[[:alnum:]]/, et ceci convient pour tous les caractères alphabétiques et alphanumériques de votre jeu de caractères.

Deux séquences additionnelles spéciales peuvent apparaître dans les listes de caractères. Elles s'appliquent aux jeux de caractères non ASCII, qui peuvent contenir des symboles uniques (appelés éléments assemblés (collating elements)) qui sont représentés par plus d'un caractère, ainsi que certains caractères qui sont équivalents dans les opérations d'assemblage ou de tri. (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 rationnelle qui correspond à cet élément, alors que [ch] est une expression rationnelle qui correspond à c ou à h. 
Classes d'Équivalence
    Une classe d'équivalence est un nom spécifique à une localisation représentant 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 « e, » « e`, » ou « e`. ». Dans ce cas, [[=e]] est une expression rationnelle qui correspond à n'importe lequel des e, e', ou e`. 

Ces fonctionnalités sont très précieuses pour les localisations non anglophones. Les fonctions de bibliothèque qu'utilise gawk pour effectuer la mise en correspondance des expressions rationnelles ne reconnaissent actuellement que les classes de caractères POSIX ; elles ne reconnaissent 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 bibliothèques d'expressions rationnelles GNU.

Les diverses options de la ligne de commandes contrôlent la façon dont gawk interprète les caractères dans les expressions rationnelles.

Pas d'option
    Dans le cas par défaut, gawk fournit toutes les facilités des expressions rationnelles POSIX et des opérateurs GNU sur les expressions rationnelles décrits au-dessus. Néanmoins, les expressions d'intervalle ne sont pas supportées. 
--posix
    Seules les expressions rationnelles 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 autorisées. 
--traditional
    Les expressions rationnelles 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és littéralement, même s'ils représentent des métacaractères d'expressions rationnelles. 
--re-interval
    Permet l'utilisation d'expressions d'intervalle dans les expressions rationnelles, même si --traditional a été fourni. 

 
Actions
Les instructions d'action sont enfermées entre accolades. Les instructions d'action sont constituées des instructions d'affectation, d'alternative et de bouclage habituelles trouvées dans la plupart des langages. Les opérateurs, instructions de contrôle et instructions d'entrée/sortie disponibles sont calqués sur ceux 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éfixe et postfixe. 
^
    Exponentiation (** peut également être utilisé, ainsi que **= 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 attitrés. 
~ !~
    Correspondance (négation) d'expressions rationnelles. NOTE : N'utilisez pas d'expression rationnelle constante (/foo/) du côté gauche d'un ~ ou un !~. N'en utilisez que du côté droit. L'expression /foo/ ~ exp a 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 entre expr2 et expr3 est évaluée. 
    = += -= 
    *= /= %= ^= Affectation. À la fois l'affectation (var = valeur) et l'affectation-opérateur (les autres formes) sont supportées. 

 
Instructions de Contrôle

Les instructions 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 [, comment])
    Fermer un fichier, tube ou co-processus. L'argument optionnel comment ne devrait être utilisé que lors de la fermeture d'un côté d'un tube bidirectionnel menant à un co-processus. Il doit être une chaîne de caractères, soit "to" (vers), soit "from" (en provenance de). 
getline
    Fixer $0 à partir du prochain enregistrement d'entrée ; fixer NF, NR, FNR. 
getline fichier
    Imprime 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
    Formater et afficher. 
printf fmt, liste-expr >fichier
    Formater et afficher dans fichier. 
system(ligne-commandes)
    Exécuter la commande ligne-commandes, et renvoyer la valeur de sortie (ceci peut ne pas être disponible sur des systèmes non POSIX). 
fflush([fichier])
    Vider tous les tampons associés au fichier de sortie 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. 

Des redirections d'entrée/sortie additionnelles sont permises pour print et printf.

print ... >> fichier
    concatène la sortie au fichier. 
print ... | commande
    écrit dans un tube. 
print ... |& commande
    envoie des données à un co-processus. 

La commande getline renvoie 0 à la fin du fichier et -1 en cas d'erreur. Si une erreur se produit, ERRNO contient une chaîne décrivant le problème.

NOTE : Si vous utilisez un tube ou un co-processus vers getline, ou depuis print ou printf à l'intérieur d'une boucle, vous devez utiliser close() pour créer de nouvelles instances de la commande. AWK ne ferme pas automatiquement les tubes et les co-processus quand ils renvoient EOF.  
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 suivants :

%c
    Un caractère ASCII. Si l'argument utilisé par %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 son premier caractère 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
    Utiliser la conversion %e ou %f (prendre 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é (également un entier). 
    %u Un nombre décimal non signé (également 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. 

Des paramètres supplémentaires optionnels peuvent être placés entre % et la lettre de contrôle :

numéro$
    Utiliser le numéro-ième argument à ce moment du formatage. Il est appelé un spécificateur positionnel et est principalement prévu pour être utilisé dans des versions traduites de chaînes de format, et pas dans le texte original d'un programme AWK. C'est une extension gawk. 
-
    L'expression devrait être justifiée à gauche à l'intérieur de son champ. 
espace
    Pour les conversions numériques, préfixe les valeurs positives par une espace, et les valeurs négatives par 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 à formater 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 contient toujours un point décimal. Pour %g, et %G, les zéros de queue ne sont pas supprimés du résultat. 
0
    Un 0 (zéro) de tête agit comme un attribut, 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 n'a d'effet que 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. 
.précision
    Un nombre 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 %s, il spécifie le nombre maximal de caractères de cette chaîne devant être affichés. 

Les aptitudes dynamiques (largeur et précision) des routines printf() du C ANSI sont supportées. Un * au lieu des spécifications de largeur ou de précision obligera à extraire leurs valeurs de la liste d'arguments de printf ou de sprintf(). Pour utiliser un spécificateur positionnel ayant une largeur ou une précision dynamique, fournissez le numéro$ après le * dans la chaîne de format. Par exemple, "%3$*2$.*1$s".  
Noms de Fichiers Spéciaux

Quand il effectue une redirection entrée/sortie à partir 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). Ces noms de fichiers peuvent également être utilisés sur la ligne de commandes pour nommer les fichiers de données. Il s'agit de :

/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 de fichier ouvert. n. 

Ils sont particulièrement utiles pour les messages d'erreur. Par exemple :

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

alors que vous auriez précédemment dû utiliser

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

Les noms de fichiers spéciaux suivants peuvent être utilisés avec l'opérateur de co-processus |& pour la création de connexions réseau TCP/IP.

/inet/tcp/lport/rhost/rport
    Fichier pour la connexion TCP/IP sur le port local lport vers l'hôte distant rhost sur le port distant rport. Utilisez un port de 0 pour que le système choisisse un port. 
/inet/udp/lport/rhost/rport
    Similaire, mais utiliser UDP/IP au lieu de TCP/IP. 
/inet/raw/lport/rhost/rport
    Réservé pour une utilisation future. 

D'autres noms de fichiers spéciaux offrent un accès à de l'information sur le processus gawk en cours d'exécution. Ces noms de fichiers sont maintenant obsolètes. Utilisez le tableau PROCINFO pour obtenir l'information qu'ils fournissent. Les noms de fichiers sont :

/dev/pid
    La lecture de ce fichier renvoie l'identificateur de processus du processus courant, en décimal, terminé par un saut de ligne. 
/dev/ppid
    La lecture de ce fichier renvoie l'identificateur de processus du processus parent du processus courant, en décimal, terminé par un saut de ligne. 
/dev/pgrpid
    La lecture de ce fichier renvoie l'identificateur de groupe de processus du processus courant, en décimal, terminé par un saut de ligne. 
/dev/user
    La lecture de ce fichier renvoie un unique enregistrement 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 IDs de groupe renvoyés par getgroups(2). Les groupes multiples peuvent ne pas être supportés sur tous les systèmes. 

 
Fonctions Numériques

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

atan2(y, x)
    Renvoie l'arctangente de y/x exprimée en radians. 
cos(expr)
    Renvoie le cosinus de expr, en radians. 
exp(expr)
    La fonction exponentielle. 
int(expr)
    Tronque en entier. 
log(expr)
    La fonction logarithmique naturelle (logarithme népérien). 
rand()
    Renvoie un nombre aléatoire compris 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 racine (seed) pour le générateur de nombres aléatoires. Si expr n'est pas fournie, l'heure courante sera utilisée. La valeur de retour est la racine précédente du générateur de nombres aléatoires. 

 
Fonctions sur les Chaînes de Caractères

gawk dispose des fonctions prédéfinies suivantes opérant sur les chaînes de caractères :

asort(s [, d])
    Retourne le nombre d'éléments du tableau source s. Le contenu de s est trié en utilisant les règles normales de gawk pour la comparaison des valeurs, et les indices des valeurs triées de s sont remplacés par des entiers d'une séquence débutant à 1. Si le tableau destination optionnel d est spécifié, alors s est d'abord dupliqué en d, et ensuite d est trié, en laissant les indices du tableau source s inchangés. 
gensub(r, s, h [, t])
    Rechercher dans la chaîne de caractères cible t des occurrences de l'expression rationnelle r. Si h est une chaîne de caractères commençant par g ou G, alors remplacer toutes les occurrences de r par s. Sinon, h est un nombre indiquant quelle occurrence de r remplacer. Si t n'est pas fourni, $0 est utilisé à la place. À 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 &. À 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 modifiée. 
gsub(r, s [, t])
    Remplacer chaque sous-chaîne correspondant à l'expression rationnelle r dans la chaîne t par 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 reconnu. Utilisez \& pour obtenir un & littéral. (Cela doit être tapé « \\& » ; voyez GAWK : Effective AWK Programming pour une discussion plus complète sur les règles concernant 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 s, ou 0 si t n'y est pas présente. (Cela implique que les indices des caractères commencent à un.) 
length([s])
    Renvoie la longueur de la chaîne de caractères s, ou la longueur de $0 si s n'est pas fournie. 
match(s, r [, a])
    Retourne l'endroit dans s où l'expression rationnelle r est trouvée, ou 0 si r n'est pas présente, et fixe les valeurs de RSTART et de RLENGTH. Notez que l'ordre des arguments est le même que pour l'opérateur ~  : chaîne ~ er. Si le tableau a est fourni, a est effacé et les éléments de 1 à n sont ensuite remplis par les parties de s qui conviennent à la sous-expression parenthésée correspondante dans r. Le 0-ième élément de a contient la partie de s correspondant à l'expression rationnelle r complète. 
split(s, a [, r])
    Découpe la chaîne de caractères s dans le tableau a sur base de l'expression rationnelle r, et renvoie le nombre de champs. Si r est omis, FS est utilisé à la place. Le tableau a est d'abord effacé. 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. 
strtonum(ch)
    Examine la chaîne ch, et renvoie sa valeur numérique. Si ch débute par un 0 de tête, strtonum() suppose que ch est un nombre octal. Si ch débute par un 0x ou un 0X de tête, strtonum() suppose que ch est un nombre hexadécimal. 
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 sous-chaîne de s d'au plus n caractères débutant à l'indice i. Si n est omis, le reste de s est utilisé. 
tolower(ch)
    Renvoie une copie de la chaîne de caractères ch, où tous les caractères de ch en majuscule sont convertis dans leur équivalent minuscule. Les caractères non alphabétiques demeurent inchangés. 
toupper(ch)
    Renvoie une copie de la chaîne de caractères ch, où tous les caractères de ch en minuscule sont traduits dans leur équivalent majuscule. Les caractères non alphabétiques demeurent inchangés. 

 
Fonctions de Temps

Puisqu'une des utilisations principales des programmes AWK est le traitement de fichiers journaux qui contiennent des informations d'horodate, gawk fournit les deux fonctions suivantes pour l'obtention des horodates et leur formatage.

mktime(spéc-date)
    Convertit spéc-date en une horodate de la même forme que celle retournée par systime(). La spéc-date est une chaîne de la forme AAAA MM JJ HH MM SS[ DST] (Daylight Saving Time). Le contenu de la chaîne est constitué de six ou sept nombres représentant respectivement l'année complète en incluant le siècle, le mois entre 1 et 12, le jour du mois entre 1 et 31, l'heure de la journée entre 0 et 23, la minute entre 0 et 59, la seconde entre 0 et 59, et un drapeau optionnel « daylight saving » (changement horaire lors du passage à l'heure d'été).

    Les valeurs de ces nombres ne doivent pas forcément se situer dans les intervalles spécifiés ; par exemple, une heure de -1 signifie 1 heure avant minuit. Le calendrier grégorien avec origine zéro est implicitement utilisé, avec l'année 0 précédant l'année 1, et l'année -1 précédant l'année 0. L'heure est supposé être exprimée dans le fuseau horaire local. Si le drapeau de changement horaire est positif, l'heure est supposée être l'heure d'été ; s'il est nul, l'heure est supposée être l'heure standard ; et, s'il est négatif (le défaut), mktime() essaiera de déterminer si l'heure d'été a cours pour l'heure spécifiée. Si spéc-date ne contient pas assez d'éléments ou si l'heure résultante est hors borne, mktime() renvoie -1. 
strftime([format [, horodate]])
    Formate l'horodate en fonction de la spécification de format. L'horodate devrait être de la même forme que celle renvoyée par systime(). Si horodate manque, l'heure du jour courante est utilisée. Si format n'est pas présent, un format par défaut équivalent à la sortie de date(1) est utilisé. Voyez la spécification de la fonction strftime() du C ANSI pour savoir quelles conversions de format sont garanties être disponibles. Une version du domaine public de strftime(3) et la page de manuel qui l'accompagne sont livrées avec gawk ; si cette version a été utilisée pour construire gawk, alors toutes les conversions décrites dans cette page de manuel sont disponibles pour gawk. 
systime()
    Renvoie l'heure actuelle sous forme du nombre de secondes écoulées depuis le début de l'Epoch (le 1er Janvier 1970 à minuit GMT sur les systèmes POSIX). 

 
Fonctions de Manipulation de Bits
À partir de la version 3.1 de gawk, les fonctions de manipulation de bits suivantes sont disponibles. Elles travaillent en convertissant des valeurs flottantes double précision en entiers unsigned long, en effectuant l'opération, et en reconvertissant le résultat en valeur flottante. Les fonctions sont :

and(v1, v2)
    Renvoie le ET bit à bit des valeurs fournies par v1 et v2. 
compl(val)
    Renvoie le complément bit à bit de val. 
lshift(val, nombre)
    Renvoie la valeur de val, décalée de nombre bits sur la gauche. 
or(v1, v2)
    Renvoie le OU bit à bit des valeurs fournies par v1 et v2. 
rshift(val, nombre)
    Renvoie la valeur de val, décalée de nombre bits sur la droite. 
xor(v1, v2)
    Renvoie le OU exclusif bit à bit des valeurs fournies par v1 et v2. 

 
Fonctions d'Internationalisation
À partir de la version 3.1 de gawk, les fonctions suivantes peuvent être utilisées à l'intérieur de votre programme AWK pour traduire des chaînes de caractères au moment de l'exécution. Pour les détails complets, voyez GAWK : Effective AWK Programming.

bindtextdomain(répertoire [, domaine])
    Spécifie le répertoire dans lequel gawk recherche les fichiers .mo au cas où ils ne seront ou ne pourront être placés dans les emplacements « standard » (p.ex. durant les tests). Cette fonction renvoie le répertoire auquel domaine est « lié ».

    Le domaine par défaut est la valeur de TEXTDOMAIN. Si répertoire est la chaîne vide (""), alors bindtextdomain() renvoie la liaison courante pour le domaine donné. 
dcgettext(chaîne [, domaine [, catégorie]])
    Renvoie la traduction de la chaîne du domaine de texte domaine pour la catégorie de localisation catégorie. La valeur par défaut pour domaine est la valeur courante de TEXTDOMAIN. La valeur par défaut pour catégorie est "LC_MESSAGES".

    Si vous fournissez une valeur pour catégorie, elle doit être une chaîne égale à une des catégories de localisation connues décrites dans GAWK : Effective AWK Programming. Vous devez également fournir un domaine de texte. Utilisez TEXTDOMAIN si vous voulez utiliser le domaine courant. 
dcngettext(chaîne1 , chaîne2 , nombre [, domaine [, catégorie]])
    Renvoie la forme plurielle utilisée pour nombre de la traduction de chaîne1 et chaîne2 dans le domaine de texte domaine pour la catégorie de localisation catégorie. La valeur par défaut pour domaine est la valeur courante de TEXTDOMAIN. La valeur par défaut pour catégorie est "LC_MESSAGES".

    Si vous fournissez une valeur pour catégorie, elle doit être une chaîne égale à l'une des catégories de localisation connues décrites dans GAWK : Effective AWK Programming. Vous devez également fournir un domaine de texte. Utilisez TEXTDOMAIN Si vous voulez utilisez le domaine actuel. 

FONCTIONS DÉFINIES PAR L'UTILISATEUR

Les fonctions dans AWK se définissent comme suit :

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

Les fonctions sont exécutées lorsqu'elles sont appelées à l'intérieur d'expressions dans les motifs ou les actions. Les paramètres réels fournis lors de 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 référence, 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. L'usage 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 et 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 caractère d'espacement entre les deux, afin 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 mutuellement et ê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 lors de l'invocation de la fonction.

Utilisez return expr pour retourner une valeur depuis 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 , c.-à-d. à la fin du corps de la fonction.

Si --lint a été fourni, gawk émettra des avertissements relatifs à des appels à des fonctions non définies au moment de l'analyse syntaxique, plutôt qu'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. 

CHARGEMENT DYNAMIQUE DE NOUVELLES FONCTIONS

 
À partir de la version 3.1 de gawk, vous pouvez ajouter dynamiquement de nouvelles fonctions à intégrer à l'interpréteur gawk au cours de l'exécution. Les détails complets sortent du cadre de cette page de manuel ; voyez GAWK : Effective AWK Programming pour les détails.

extension(objet, fonction)
    Charger dynamiquement le fichier objet partagé désigné par objet, et invoquer fonction sur cet objet, pour effectuer une initialisation. Ils devraient tous les deux être fournis sous forme de chaîne de caractères. Renvoie la valeur retournée par fonction. 

Cette fonction est fournie et documentée dans GAWK : Effective AWK Programming, mais tout ce qui concerne cette fonctionnalité est fortement susceptible de changer dans la prochaine version. Nous recommandons EXPRESSÉMENT de ne pas utiliser cette fonctionnalité pour quelque chose que vous n'avez pas envie de refaire.

SIGNAUX

 
pgawk accepte deux signaux. SIGUSR1 lui fait écrire un profil et la pile d'appel de fonctions dans le fichier de profil, qui est soit awkprof.out, soit un autre fichier nommé avec l'option --profile. Il continue ensuite son exécution. SIGHUP lui fait écrire un profil ainsi que la pile d'appel de fonctions et le force à se terminer.

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éner et numéroter les lignes (une variation sur ce thème) :

        { print NR, $0 }

INTERNATIONALISATION

 
Les constantes de type chaîne de caractères sont des séquences de caractères enfermées dans des guillemets. Dans les environnements non anglophones, il est possible de marquer les chaînes de caractères du programme AWK comme requérant une traduction vers la langue naturelle native. De telles chaînes sont marquées dans le programme AWK par un caractère de soulignement (« _ ») de tête. Par exemple,

    gawk 'BEGIN { print "hello, world" }' 

affiche toujours « hello, world », mais

    gawk 'BEGIN { print _"hello, world" }' 

pourrait afficher « bonjour, monde » en France.

Il y a de nombreuses étapes impliquées dans la production et l'exécution d'un programme AWK s'adaptant à la localisation.

1.
    Ajouter une action BEGIN pour affecter une valeur à la variable TEXTDOMAIN afin de fixer le domaine de texte à un nom associé à votre programme.


          BEGIN { TEXTDOMAIN = "monprog" }

    Cela permet à gawk de trouver le fichier .mo associé à votre programme. Sans cette étape, gawk utilise le domaine de texte messages, qui ne contient probablement pas les traductions de votre programme. 
2.
    Marquer toutes les chaînes qui devraient être traduites par des caractères de soulignement de tête. 
3.
    Si nécessaire, utiliser les fonctions dcgettext() et/ou bindtextdomain() dans votre programme, de façon appropriée. 
4.
    Exécuter gawk --gen-po -f monprog.awk > monprog.po pour générer un fichier .po pour votre programme. 
5.
    Fournir des traductions appropriées, et construire puis installer un fichier .mo correspondant. 

Les fonctionnalités d'internationalisation sont décrites dans le détail dans GAWK : Effective AWK Programming.  

COMPATIBILITÉ POSIX

Un objectif principal de gawk est la compatibilité avec le standard POSIX, ainsi qu'avec la dernière version de l'awk UNIX. À cette fin, gawk incorpore les fonctionnalités visibles de l'utilisateur suivantes qui ne sont pas décrites dans le livre AWK, mais qui font partie de la version awk des Laboratoires Bell, et qui sont dans le standard POSIX.

Le livre indique que l'affectation de variables en ligne de commandes se produit au moment où awk ouvrirait l'argument comme un fichier, c.-à-d. après que le bloc BEGIN soit exécuté. Néanmoins, dans des implémentations plus anciennes, quand une telle affectation apparaissait avant tous les noms de fichiers, l'affectation se produisait avant que le bloc BEGIN ait été exécuté. Les applications en vinrent à dépendre de cette « fonctionnalité ». Quand awk a été modifié pour correspondre à sa documentation, l'option -v d'affectation de variables avant l'exécution du programme a été ajoutée pour s'accomoder des applications qui dépendent de l'ancien comportement (cette fonctionnalité a été approuvée à la fois par les Laboratoires Bell et par les développeurs GNU).

L'option -W pour les fonctionnalités spécifiques à l'implémentation proviennent du standard POSIX.

Quand il manipule les arguments, gawk utilise l'option spéciale « -- » pour signaler la fin des arguments. Dans le mode de compatibilité, il avertit de l'existence d'options non définies, mais les ignore. Dans un mode d'opération normal, de tels arguments sont passés au programme AWK pour qu'il les traite.

Le livre AWK ne définit pas la valeur de retour de srand(). Le standard POSIX lui fait renvoyer la racine qu'elle utilisait, pour permettre de garder la trace des séquences de nombres aléatoires. Par conséquent, srand() dans gawk retourne également sa racine actuelle.

D'autres fonctionnalités nouvelles sont : l'utilisation de multiples options -f (provenant de l'awk MKS); le tableau ENVIRON ; les séquences d'échappement \a et \v (conçu à l'origine dans gawk et repris dans la version des Laboratoires Bell) ; les fonctions intégrées tolower() et toupper() (de la version des Laboratoires Bell), et les spécifications de conversion C ANSI dans printf (réalisé en premier lieu dans la version des Laboratoires Bell).  

FONCTIONNALITÉS HISTORIQUES

Il y deux fonctionnalités des implémentations historiques de AWK que gawk supporte. Primo, il est possible d'appeler la fonction intégrée length() non seulement sans argument, mais même sans parenthèses ! Par conséquent,

    a = length    # Saint Algol 60, Batman!

est identique aux deux affectations suivantes :

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

Cette fonctionnalité est marquée comme « caduque » (deprecated) dans le standard POSIX, et gawk émet un avertissement lors de son utilisation si --lint est spécifié sur la ligne de commandes.

L'autre fonctionnalité est l'utilisation d'une des instructions continue ou break à l'extérieur du corps d'une boucle while, for ou do. Les implémentations traditionnelles de AWK ont fait d'une telle utilisation l'équivalent de l'instruction next. gawk supporte cet utilisation si --traditional a été spécifié.

EXTENSIONS GNU

gawk possède un certain nombre d'extensions par rapport à l'awk POSIX. 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 fonctionnalités suivantes de gawk ne sont pas disponibles dans l'awk POSIX.

*
    Aucune recherche de chemin n'est effectuée pour les fichiers nommés via l'option -f. Par conséquent, la variable d'environnement AWKPATH n'est pas spéciale. 
*
    La séquence d'échappement \x. (Désactivée avec --posix) 
*
    La fonction fflush(). (Désactivée avec --posix.) 
*
    La possibilité de continuer des lignes après le ? et le :. (Désactivée avec --posix.) 
*
    Les constantes octales et hexadécimales dans les programmes AWK. 
*
    Les variables ARGIND, BINMODE, ERRNO, LINT, RT et TEXTDOMAIN ne sont pas spéciales. 
*
    La variable IGNORECASE et ses effets de bord ne sont pas disponibles. 
*
    La variable FIELDWIDTHS et le découpage en champs de largeur fixe. 
*
    Le tableau PROCINFO n'est pas disponible. 
*
    L'utilisation de RS comme expression rationnelle. 
*
    Les noms de fichiers spéciaux disponibles pour les redirections d'E/S ne sont pas reconnus. 
*
    L'opérateur |& pour la création de co-processus. 
*
    La possibilité d'éclater des caractères individuels en utilisant la chaîne vide comme valeur pour FS, et comme troisième argument pour split(). 
*
    Le second argument optionnel de la fonction close(). 
*
    Le troisième argument optionnel de la fonction match(). 
*
    La possibilité d'utiliser des spécificateurs positionnels avec printf et sprintf(). 
*
    L'utilisation de delete tableau pour effacer l'entièreté du contenu d'un tableau. 
*
    L'utilisation de nextfile pour abandonner le traitement du fichier d'entrée courant. 
*
    Les fonctions and(), asort(), bindtextdomain(), compl(), dcgettext(), gensub(), lshift(), mktime(), or(), rshift(), strftime(), strtonum(), systime() et xor(). 
*
    Les chaînes de caractères locale-isables. 
*
    L'ajout dynamique de nouvelles fonctions à intégrer avec la fonction extension(). 

Le livre AWK ne définit pas la valeur de retour de la fonction close(). La fonction close() de gawk retourne la valeur de fclose(3), ou de pclose(3), lors de la fermeture d'un fichier de sortie ou d'un tube respectivement. Elle renvoie la valeur de sortie du processus lors de la fermeture d'un tube d'entrée. La valeur de retour est -1 si le fichier nommé, le tube ou le co-processus n'a pas été ouvert avec une redirection.

Quand gawk est invoqué avec l'option --traditional, si l'argument sc de l'option -F est "t", alors la valeur de FS sera le caractère de tabulation. Noter que taper gawk -F\t ... conduit simplement le shell à protéger le "t,", et ne passe pas "\t" à l'option -F. Puisque c'est est un cas spécial plutôt incongru, ce n'est pas le comportement par défaut. Ce comportement ne se retrouve pas non plus si --posix a été spécifié. Pour que le caractère de tabulation soit réellement le séparateur de champs, il vaut mieux utiliser des apostrophes : gawk -F'\t' ....  

VARIABLES D'ENVIRONNEMENT

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

Si la variable POSIXLY_CORRECT est définie dans l'environnement, alors gawk se comporte exactement comme si --posix a été spécifié sur la ligne de commandes. Si --lint a été spécifié, gawk émet un message d'avertissement à cet effet.  

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.

GAWK : Effective AWK Programming, Édition 3.0, publié par la Free Software Foundation, 2001.  

BOGUES

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

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 plutôt inutile. De tels programmes sont contre toute attente difficiles à diagnostiquer dans le cas le plus général, et l'effort nécessaire pour les détecter n'en vaut pas vraiment la peine.  

AUTEURS

La version originale de l'awk UNIX a été conçue 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 qu'il soit compatible avec la version originale de awk distribuée dans la Septième Édition de UNIX. John Woods contribua à un grand nombre de corrections de bogues. David Trueman, avec des contributions d'Arnold Robbins, rendit gawk compatible avec la nouvelle version de l'awk UNIX. 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é effectué par Kai Uwe Rommel, avec la contribution et l'aide de Darrel Hankerson. Fred Fish a fourni le support de l'Amiga. Stephen Davies a fourni le portage Tandem, et Martin Brown a réalisé le portage BeOS.  

INFORMATION DE VERSION

Cette page de manuel documente gawk version 3.1.1  

RAPPORTS DE BOGUES

Si vous trouvez un bogue dans gawk, envoyez s.v.p. un courriel à bug-gawk@gnu.org. Incluez s.v.p. la version de votre système d'exploitation et sa révision, la version de gawk (grâce à gawk --version), le compilateur C utilisé pour le compiler, et un programme test et des données aussi petites que possible permettant de reproduire le problème.

Avant d'envoyer un rapport de bogue, veuillez faire deux choses. Primo, vérifiez que vous disposez de 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. Secundo, lisez attentivement cette page de manuel et le manuel de référence pour être sûr(e) que ce que vous pensez ê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 de gawk lisent occasionnellement ce groupe de discussion, y poster des rapports de bogues est une façon non fiable de rapporter des bogues. Au lieu de cela, utilisez les adresses électroniques données au-dessus.

REMERCIEMENTS

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

PERMISSIONS DE COPIE

Copyright © 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002 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 de distribuer des versions modifiées de cette page 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 de distribuer des traductions de ce manuel dans n'importe quel autre langue, sous les conditions ci-dessus pour les versions modifiées, mis à part 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 <delanoy_f@yahoo.com>, 2002. 

http://www.delafond.org/traducmanfr/man/man1/awk.1.html
http://manpages.ubuntu.com/manpages/maverick/en/man1/awk.1posix.html