gawk

GAWK(1)                  Manuel de l'utilisateur Linux                 GAWK(1)



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
       ...


DESCRIPTION
       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, » « `, » ou « `. ». Dans ce cas, [[=e]] est une
              expression rationnelle qui correspond à n'importe lequel des e,
              ´, ou `.

       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       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.

       commande | getline [var]
                              Exécuter la commande en envoyant la sortie via
                              un tube soit vers $0 soit vers var, comme au-
                              dessus.

       commande |& getline [var]
                              Exécuter la commande en tant que co-processus
                              en envoyant la sortie via un tube soit vers $0
                              soit vers var, comme au-dessus. Les co-processus
                              sont une extension gawk.

       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.

       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
                              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.

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.

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.

TRADUCTION
       Frédéric Delanoy <delanoy_f@yahoo.com>, 2002.



Free Software Foundation         16 avril 2002                         GAWK(1)