\documentclass{report}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{textcomp}
\usepackage{geometry}
\geometry{top=15mm, bottom=15mm, left=1cm, right=1cm}
\usepackage[french]{babel}
\usepackage{pslatex}
\usepackage[colorlinks=true,urlcolor=black]{hyperref}
\usepackage{graphicx}
\usepackage{fancyhdr}
\pagestyle{fancy}
\renewcommand{\footrulewidth}{0.4pt}
\fancyfoot[L]{Uubu.fr}
\fancyfoot[R]{jeu. janv. 12 10:48:52 CET 2012}
\lfoot{\Large \textit{Uubu.fr}}
\hypersetup{pdfinfo={
Title={awk},
Author={Sylvain Girod},
Creator={Bash script from uubu.fr's format version 1},
Producer={Bash script and PDFLaTeX},
Subject={Interpréteur de langage AWK},
CreationDate={D:20120112104852},
ModDate={D:20120112104852},
Keywords={coreutils;GNU;scripts;programmation}
}}
\begin{document}
 
\begin{center}
{\Huge awk, mawk, nawk }
\end{center}
\vspace{1cm}
 
\begin{flushleft}
 
{\large Interpréteur de langage AWK}
 
\vspace{10mm}
 
\hspace{1mm}  \textbf{awk} est un interpréteur pour le langage de programmation awk. Ce langage est utile pour manipuler des fichiers de données, traitement et recherche de texte, et pour prototyper et expérimenter des algorithmes.
\vspace{5mm} \\
\hspace{1mm}  Un programme \textbf{awk} est une séquence de paires \textbf{pattern action} et de définitions de fonction. Les programmes cour sont entrés sur la ligne de commande entre \textbf{' '} pour éviter une interprétation par le shell. Les programmes plus longs peuvent être lus depuis un fichier. Les données sont lues depuis une liste de fichiers sur la ligne de commande ou depuis l'entrée standard quand la liste est vide. L'entrée est scindée en enregistrements comme déterminé par la variable de séparation d'enregistrement, \textbf{RS}. Initialement, \textbf{RS = "\textbackslash{}n"}. Chaque enregistrement est comparé avec chaque motif et s'il y'a correspondance, l'\textbf{action} est exécutée.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge OPTIONS }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} -F value]{Définis le séparateur de champ, \textbf{FS}}
\item[\hspace{1mm} -f file]{Lit depuis le fichier au lieu de la ligne de commande. Peut-être spécifié plusieurs fois.}
\item[\hspace{1mm} -v var=value]{Assigne une valeur à une variable}
\item[\hspace{1mm} --]{Indique la fin des options de manière non-ambiguë}
\item[\hspace{1mm} mawk fournis:]{}
\item[\hspace{1mm} -W version]{Version de mawk puis quitte}
\item[\hspace{1mm} -W dump]{Écrit en listing style assembleur la représentation interne du programme sur stdout puis quitte.}
\item[\hspace{1mm} -W interactive]{Définis les écritures sans mise en tampon sur stdout et les lignes mise en tampon lues depuis stdin. Les enregistrements depuis stdin sont lus sans regarder \textbf{RS}.}
\item[\hspace{1mm} -W exec file]{Le programme est lu depuis le fichier.}
\item[\hspace{1mm} -W sprintf=num]{Ajuste la taille du tampon sprintf de mawk au nombre d'octets spécifiés.}
\item[\hspace{1mm} -W posix\_space]{force mawk à ne pas considérer \textbf{'\textbackslash{}n'} comme étant un espace.}
\end{description}
 
\vspace{1cm}{\huge Le langage AWK }
 
\
 
\hspace{1mm}  Un programme awk est une séquence de paires \textbf{motif action} et de définitions de fonctions.
\vspace{5mm} \\
 
 
\hspace{6mm} Un motif peut être \\
\hspace{6mm} \textbf{BEGIN} \\
\hspace{6mm} \textbf{END} \\
\hspace{6mm} \textbf{expression} \\
\hspace{6mm} \textbf{expression, expression} \\
 
\hspace{1mm}  \textbf{motif} ou \textbf{action} peut être omis (mais pas les 2). Si \textbf{action} est omis, il est implicitement \textbf{print}. Si le \textbf{motif} est omis, il est simplement matché. \textbf{BEGIN} et \textbf{END} nécessitent une \textbf{action}.
\vspace{5mm} \\
\hspace{1mm}  Les déclarations sont terminées par une nouvelle ligne, \textbf{';'} ou les deux. Les groupes de déclarations tels que les actions ou les boucles sont délimité par \textbf{,} comme en C. La dernière déclaration dans un block ne nécessite pas de terminaison. Les lignes blanches ne signifient rien; une déclaration vide est terminée par un \textbf{';'}. Les déclarations longues peuvent continuer sur une ou plusieurs lignes avec \textbf{\textbackslash{}}. Une déclaration peut être scindée sans un \textbf{\textbackslash{}} après un \textbf{',', [, \&\&, ||, do, else}, la parenthèse droite d'un \textbf{if, while} ou \textbf{for}, ou d'une définition de fonction. Un commentaire commence avec \textbf{\#} et s'étend jusqu'à la fin de la ligne.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} ]{Les déclarations suivantes contrôlent le flux d'un programme dans les blocks:}
\item[\hspace{1mm} if ( expr ) statement]{}
\item[\hspace{1mm} if ( expr ) statement else statement]{}
\item[\hspace{1mm} while ( expr ) statement]{}
\item[\hspace{1mm} do statement while ( expr )]{}
\item[\hspace{1mm} for ( opt\_expr ; opt\_expr ; opt\_expr ) statement]{}
\item[\hspace{1mm} for ( var in array ) statement]{}
\item[\hspace{1mm} continue]{}
\item[\hspace{1mm} break]{}
\end{description}
 
\vspace{1cm}{\huge Types de données, conversions et comparaisons }
 
\
 
\hspace{1mm}  Il y'a 2 types de données de bases, les chaînes et les nombres. Les constantes numériques peuvent être entier, décimal, ou en notation scientifique. Tous les nombres sont représentés en interne et tous sont calculés en virgule flottante. Donc \textbf{0.2e2 == 20} est vrai, et \textbf{true} vaut \textbf{1.0}
\vspace{5mm} \\
\hspace{1mm}  Les chaînes sont placées entre guillemets. Elles peuvent être continuées sur une nouvelle ligne en échappant \textbf{newline}. Les caractères échappés suivant sont reconnus:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{6mm} \textbackslash{}\textbackslash{}]{\textbackslash{}}
\item[\hspace{6mm} \textbackslash{}"]{"}
\item[\hspace{6mm} \textbackslash{}a]{alert, ascii 7}
\item[\hspace{6mm} \textbackslash{}b]{backspace, ascii 8}
\item[\hspace{6mm} \textbackslash{}t]{tab, ascii 9}
\item[\hspace{6mm} \textbackslash{}n]{newline, ascii 10}
\item[\hspace{6mm} \textbackslash{}v]{vertical tab, ascii 11}
\item[\hspace{6mm} \textbackslash{}f]{formfeed, ascii 13}
\item[\hspace{6mm} \textbackslash{}r]{carriage return, ascii 13}
\item[\hspace{6mm} \textbackslash{}ddd]{1, 2, ou 3 chiffre octal pour le code ascii}
\item[\hspace{6mm} \textbackslash{}xhh]{1 ou 2 chiffres hexa pour le code ascii}
\end{description}
 
\hspace{1mm}  Il y'a réellement 3 types de données; le troisième est de type "nombre et chaîne" qui a des données numériques et des chaînes en même temps. Les variables utilisateur, lorsqu'elles sont créées, sont initialisées à null, un nombre ou une chaîne qui vaut \textbf{0} ou \textbf{""}.
\vspace{5mm} \\
 
 
\hspace{1mm} Le type d'une expression est déterminé par son contexte et une conversion de type se produit. Par exemple, pour évaluer:
 
{\ttfamily
y = x + 2 ; z = x "hello"\\
}
\vspace{8mm}
 
\hspace{1mm}  \textbf{y} est de type numérique. Si \textbf{x} est une chaîne, elle est convertie en numérique avant le calcul. \textbf{z} sera de type chaîne, et la valeur de \textbf{x} sera convertie en chaîne si nécessaire et concaténé avec \textbf{"hello"}. Une chaîne est convertie en numérique en utilisant le plus long préfixe numérique comme avec \textbf{atof(3)}. Une expression numérique est convertie en chaîne en remplaçant \textbf{expr} avec \textbf{sprintf(CONVFMT, expr)}, sauf si \textbf{expr} peut être représentée sur une machine comme un entier exact, alors il est convertit en \textbf{sprintf("\%d", expr)}. \textbf{sprintf} est embarqué dans awk et duplique la fonction \textbf{fprints(3)}, et \textbf{CONVFMT} est une variable intégrée utilisée pour les conversions interne des nombres en chaîne et initialisé à \textbf{"\%.6g"}. Les conversions peuvent être forcées, \textbf{expr ""} est une chaîne et \textbf{expr+0} est numérique.
\vspace{5mm} \\
 
 
\hspace{1mm}  Pour évaluer, \textbf{expr1 rel-op expr2}, s'ils sont de type numérique ou un nombre et une chaine, la conversion est numérique; s'ils sont de type chaîne la comparaison est de type chaine; si un opérande est de type chaîne, l'opérande non-chaîne est converti et la comparaison est de type chaîne. Le résultat numérique est 1 ou 0.
\vspace{5mm} \\
\hspace{1mm}  En booléen, tel que \textbf{if ( expr ) statement}, une expression chaîne est vrai si et seulement si elle n'est pas vide; une valeur numérique si et seulement si elle ne vaut pas 0.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Expressions régulières }
 
\
 
\hspace{1mm}  Dans le langage awk, les enregistrements, champs et chaînes sont souvent testés avec des expressions régulières. Elles sont délimitées par des \textbf{"/"}
\vspace{5mm} \\
\hspace{1mm}  \textbf{expr /r/}
\vspace{5mm} \\
\hspace{1mm}  Cette expression évalue à 1 si \textbf{expr} matche \textbf{r}, qui signifie qu'une sous-chaîne de \textbf{expr} est dans le jeu de chaîne définie par \textbf{r}.
\vspace{5mm} \\
\hspace{1mm}  \textbf{/r/ action et \$0 /r/ action}
\vspace{5mm} \\
\hspace{1mm}  Sont identiques, et pour chaque enregistrement en entrée qui match \textbf{r}, \textbf{action} est exécuté. en fait, \textbf{/r/} est une expression régulière awk qui est équivalent à \textbf{( \$0 /r/ )}.
\vspace{5mm} \\
\hspace{1mm}  awk utilise des expressions régulières étendues comme avec \textbf{egrep}. Les méta caractères, par exemple, ceux qui ont une signification spéciale dans les expressions régulières sont: \textbf{\textasciicircum \$ . [ ] | ( )} \textbf{*} \textbf{+ ?}
\vspace{5mm} \\
 
 
\hspace{1mm}  Les expressions régulières sont construites comme suit:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{6mm} c]{match le non méta caractères}
\item[\hspace{6mm} \textbackslash{}c]{match un caractère définis par la même séquence échappée utilisée dans les constantes chaînes ou le caractère littéral c if \textbackslash{}c n'est pas une séquence échappée.}
\item[\hspace{6mm} .]{Mach n'importe quel caractère (incluant newline)}
\item[\hspace{6mm} \textasciicircum]{Match le début d'une chaîne}
\item[\hspace{6mm} \$]{Match la fin d'une chaîne}
\item[\hspace{6mm} \texttt{[}c1c2c3...\texttt{]}]{Match un caractère dans la classe c1c2c3... un intervalle de caractères est noté c1-c2.}
\item[\hspace{6mm} \texttt{[}\textasciicircum c1c2c3...\texttt{]}]{Match tout caractère non listé dans la classe}
\end{description}
 
\hspace{1mm}  Les expressions régulières sont construites depuis d'autres expressions régulières comme suit:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{6mm} r1r2]{Match r1 suivi immédiatement par r2 (concaténation)}
\item[\hspace{6mm} r1 | r2]{Match r1 ou r2 (alternation)}
\item[\hspace{6mm} regen]{Match r répété 0 ou plusieurs fois}
\item[\hspace{6mm} r+]{Match r répété une ou plusieurs fois}
\item[\hspace{6mm} r?]{Match r 0 ou une fois}
\item[\hspace{6mm} (r)]{Match r, fournissant un groupage}
\end{description}
 
\hspace{1mm}  La précédence des opérateurs est: \textbf{*, +, ?}
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Exemple }
 
\
 
\hspace{1mm} \textbf{/\textasciicircum [\_a-zA-Z][\_a-zA-Z0-9]*\$/ et /\textasciicircum [-+] ?([0-9]+\textbackslash{}. ?|\textbackslash{}.[0-9])[0-9]*([eE][-+] ?[0-9]+) ?\$/} \\
\hspace{1mm} Sont matchés par les identifiants awk et les constantes numériques awk, respectivement. Noter que "." doit être échappé pour être reconnu comme point décimal, et que les méta caractères ne sont pas spéciaux dans les classes de caractères \\
\hspace{1mm} \textbf{BEGIN identifier = "[\_a-zA-Z][\_a-zA-Z0-9]*"} \\
\hspace{1mm} \textbf{\$0 "\textasciicircum " identifier} \\
\hspace{1mm} Affiche toutes les lignes qui commencent avec un identifier awk. \\
\hspace{1mm} mawk reconnait l'expression régulière vide //, qui match la chaîne vide et est matché par une chaîne avant, après et entre chaque caractère. Par exemple \\
\hspace{1mm} \textbf{echo abc | mawk ' gsub(//, "X") ; print '} \\
\hspace{1mm} \textbf{XaXbXcX} \\
 
\vspace{1cm}{\huge Enregistrement et champs }
 
\
 
\hspace{1mm}  Les enregistrements sont lus en une fois, et stockés dans la variable \textbf{\$0}. L'enregistrement est splité en champs qui sont stockés dans \textbf{\$1}, \textbf{\$2}, \textbf{...}, \textbf{NF}. La variable \textbf{NF} contient le nombre de champs et \textbf{NR} et \textbf{FNR} sont incrémentés de 1. Les champs derrière \textbf{\$NF} sont mis à "".
\vspace{5mm} \\
\hspace{1mm}  Assigner \textbf{\$0} recalcule les champs et \textbf{NF}. Assigner \textbf{NF} ou un champ reconstruit \textbf{\$0} en concaténant le \textbf{\$i} séparé par \textbf{OFS}. Assigner un champ avec un index plus grand que \textbf{NF} augmente \textbf{NF} et reconstruit \textbf{\$0}.
\vspace{5mm} \\
\hspace{1mm}  Les données en entrée stockés dans les champs est de type chaîne, à moins que tout le champ est sous la forme numérique, le champ est alors de type chaîne et nombre. Par exemple:
\vspace{5mm} \\
 
 
\hspace{1mm} \textbf{echo 24 24E | mawk ' print(\$1 > 100, \$1>"100", \$2 > 100, \$2>"100") '} \\
\hspace{1mm} \textbf{0 1 1 1} \\
 
\vspace{1cm}{\huge Expressions et opérateurs }
 
\
 
\hspace{1mm}  La syntaxe est similaire au C. Les expressions primaires sont des constantes numériques, variables, champs, tableaux et des appels de fonction. L'identifiant pour une variable, tableau ou fonction peut être une séquence de lettres, chiffres et '\_', qui ne commencent pas avec un chiffre. Les variables ne sont pas déclarées; elles existent quand elles sont référencées la première fois et sont initialisées à NULL.
\vspace{5mm} \\
\hspace{1mm}  Les nouvelles expressions sont composées avec les opérateurs suivant par ordre de priorité croissant:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} Assignement]{= += -= *= /= \%= \textasciicircum =}
\item[\hspace{1mm} Conditionnel]{? :}
\item[\hspace{1mm} Ou logique]{||}
\item[\hspace{1mm} Et logique]{\$\$}
\item[\hspace{1mm} Array membership in]{}
\item[\hspace{1mm} Matching]{!}
\item[\hspace{1mm} Relationnel]{< > <= >= == !=}
\item[\hspace{1mm} Concaténation (pas d’opérateur explicite)]{}
\item[\hspace{1mm} Ajout]{+ -}
\item[\hspace{1mm} Multiplication]{* / \%}
\item[\hspace{1mm} Unaire]{+ -}
\item[\hspace{1mm} Non logique]{!}
\item[\hspace{1mm} Exponentiel]{\textasciicircum}
\item[\hspace{1mm} Incrément et décrément]{++ —}
\item[\hspace{1mm} Champ]{\$}
\end{description}
 
\vspace{1cm}{\huge Tableaux }
 
\
 
\hspace{1mm}  \textbf{awk} fournis des tableaux à une dimension. Les éléments de tableau sont exprimé comme \textbf{array[expr]}. \textbf{expr} est convertit en interne en type chaîne, donc \textbf{A[1]} et \textbf{A["1"]} sont identique et l'index est "1". Les tableaux indexés par chaîne sont appelés des tableaux associatifs. Un tableau initialisé est vide; les éléments existent au premier accès. Une expression dans un tableau vaut 1 si \textbf{array[expr]} existe, sinon vaut 0.
\vspace{5mm} \\
 
 
\hspace{1mm} Il y'a une forme de \textbf{for} qui boucle chaque index d'un tableau:
 
{\ttfamily
for ( var in array ) statement\\
}
\vspace{8mm}
 
\hspace{1mm}  Définis \textbf{var} à chaque \textbf{index} de \textbf{array} et exécute \textbf{statement}. L'ordre dans lequel \textbf{var} traverse les indices n'est pas définis.
\vspace{5mm} \\
\hspace{1mm}  La déclaration \textbf{delete array[expr]}, cause \textbf{array[expr]} de ne pas exister. \textbf{mawk} supporte une extension, \textbf{delete array}, qui supprime tous les éléments d'un tableau.
\vspace{5mm} \\
\hspace{1mm}  Les tableaux multi-dimensionnels sont synthétisés avec concaténation en utilisant la variable intégrée \textbf{SUBSEP}. \textbf{array[expr1,expr2]} est équivalent à \textbf{array[expr1 SUBSEP expr2]}.
\vspace{5mm} \\
 
 
\hspace{1mm} Tester des éléments multi-dimensionnels utilise un index en parenthèse, tel que:
 
{\ttfamily
if ( (i, j) in A ) print A\texttt{[}i, j\texttt{]}\\
}
\vspace{8mm}
 
\vspace{1cm}{\huge Variables intégrées }
 
\
 
\hspace{1mm}  Les variables suivantes sont intégrées et initialisées avant l'exécution du programme.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} ARGC]{Nombre d’arguments sur la ligne de commande}
\item[\hspace{1mm} ARGV]{Tableau des arguments sur la ligne de commande, \textbf{0..ARGC-1}}
\item[\hspace{1mm} CONVFMT]{Format pour la conversion interne des nombres, chaînes, initialisé à \textbf{"\%.6g"}}
\item[\hspace{1mm} ENVIRON]{Tableau indexé par variable d’environnement. Une chaine d’environnement, \textbf{var=value} est stockée comme \textbf{ENVIRON[var] = value}}
\item[\hspace{1mm} FILENAME]{nom du fichier d’entrée}
\item[\hspace{1mm} FNR]{Nombre d’enregistrements dans \textbf{FILENAME}}
\item[\hspace{1mm} FS]{Split les enregistrements dans des champs en tant qu’expression régulière}
\item[\hspace{1mm} NF]{Nombre de champs dans l’enregistrement courant}
\item[\hspace{1mm} NR]{Nombre d’enregistrement courant total dans le flux d’entrée}
\item[\hspace{1mm} OFMT]{Format pour afficher les nombres; initialisé à \textbf{"\%.6g"}}
\item[\hspace{1mm} OFS]{Séparateur de champs en sortie, initialisé à \textbf{" "}}
\item[\hspace{1mm} ORS]{Termine chaque enregistrement en sortie, initialisé à \textbf{"\textbackslash{}n"}}
\item[\hspace{1mm} RLENGTH]{Longueur définis par le dernier appel de la fonction intégrée match()}
\item[\hspace{1mm} RS]{Séparateur d’enregistrement en entrée, initialisé à \textbf{"\textbackslash{}n"}}
\item[\hspace{1mm} RSTART]{Index définis par le dernier appel à match()}
\item[\hspace{1mm} SUBSET]{Utilisé pour construire des tableaux multiples, initialisé à \textbf{"\textbackslash{}034"}}
\end{description}
 
\vspace{1cm}{\huge Fonctions de chaînes intégrées }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} gsub(r,s,t) gsub(r,s)]{Substitutions globale, chaque match avec l’expression régulière r dans la variable t est remplacée par la chaîne s. Le nombre de remplacement est retourné. Si t est omis, \$0 est utilisé. un \& dans s est remplacé par la sous-chaîne matché de t.}
\item[\hspace{1mm} index(s,t)]{Si t est une sous-chaine de s, la position où t comment est retournée, sinon 0.}
\item[\hspace{1mm} length(s)]{Retourne la longueur de s}
\item[\hspace{1mm} match(s,r)]{Retourne l’index du plus long match de r dans s. sans match, retourne 0. RSTART contient la valeur de retour, RLENGTH la longueur du match ou 61 si aucun match. si une chaîne vide match, RLENGTH vaut 0 et 1 est retourné sur le match est au début, et length(s)+1 si le match est à la fin.}
\item[\hspace{1mm} split(s,A,r) split(s,A)]{s est splitté en champs par r et les champs sont chargés dans le tableau A. Le nombre de champs est retourné. si r est omis, FS est utilisé.}
\item[\hspace{1mm} sprintf(format, expr-list)]{Retourne un chaîne construite depuis expr-list en accord avec format.}
\item[\hspace{1mm} sub(r,s,t) sub(r,s)]{Simple substitution, identique à gsub except au moins une substitution.}
\item[\hspace{1mm} substring(s,i) substr(s,i)]{Retourne le sous-chaîne de s, commençant à l’index i de longueur n. Si n est omis, le suffix de s, commençant à i est retourné.}
\item[\hspace{1mm} tolower(s)]{retourne s en minuscule}
\item[\hspace{1mm} toupper(s)]{retourne s en majuscule}
\end{description}
 
\vspace{1cm}{\huge Fonctions arithmétiques intégrées }
 
\
 
\begin{description} \normalsize
\item[\hspace{1mm} atan2(y,x)]{arctan de y/y entre -pi et pi}
\item[\hspace{1mm} cos(x)]{Cosinus, x en radian}
\item[\hspace{1mm} exp(x)]{Fonction exponentielle}
\item[\hspace{1mm} int(x)]{Retourne x tronqué à 0}
\item[\hspace{1mm} log(x)]{Logarithme naturel}
\item[\hspace{1mm} rand(x)]{Retourne un nombre aléatoire entre 0 et 1}
\item[\hspace{1mm} sin(x)]{fonction sinus, x en radian}
\item[\hspace{1mm} sqrt(x)]{Retourne la racine carré de x}
\item[\hspace{1mm} srand(expr) srand()]{Générateur de nombre aléatoire, utilisant l’horloge si expr est omis, et retourne la valeur. mawk génère un nombre aléatoire depuis l’horloge au démarrage donc il n’y a pas de réel besoin de srand(). srand(expr) est utile pour répéter des séquences pseudo-aléatoires.}
\end{description}
 
\vspace{1cm}{\huge Entrée et Sortie }
 
\
 
\hspace{1mm}  Il y'a 2 déclarations de sortie, \textbf{print} et \textbf{printf}.
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} print expr1, expr2, ..., exprn]{Écrit \textbf{\$0 ORS} sur la sortie standard, les expressions numériques sont converties en chaîne avec \textbf{OFMT}.}
\item[\hspace{1mm} printf format, expr-list]{Duplique la fonction C printf. Toutes les spécifications sont reconnues avec les conversions \textbf{\%c, \%d, \%e, \%E, \%f, \%g, \%G, \%i, \%o, \%s, \%u, \%x, \%X} et \textbf{\%\%}, et les qualifieur de conversion \textbf{h} et \textbf{l}.}
\end{description}
 
\hspace{1mm}  La liste des arguments de \textbf{print} et \textbf{printf} peuvent optionnellement être entre parenthèses. Les nombres sont affichés en utilisant \textbf{OFMT} ou \textbf{"\%u"} pour les entiers exacts. \textbf{\%c} avec un argument numérique affiche le caractère 8-bits correspondant. Avec un argument chaîne, affiche le premier caractère de la chaîne. La sortie de \textbf{print} et \textbf{printf} peuvent être redirigés avec \textbf{>} ou \textbf{>>} vers un fichier ou \textbf{|} vers une commande à la fin de la déclaration \textbf{print}. Les redirections accolées sont toujours de type flux ouvert. Par convention \textbf{mawk} associe le nom du fichier \textbf{/dev/stderr} avec \textbf{stderr}. \textbf{mawk} associe également \textbf{"-"} et \textbf{/dev/sdtout} avec \textbf{stdin} et \textbf{stdout} qui permet à ces flux d’être passés en fonctions.
\vspace{5mm} \\
\hspace{1mm}  La fonction d’entrée \textbf{getline} a les variations suivantes:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} getline]{Lit dans \textbf{\$0}, met à jours les champs, \textbf{NF}, \textbf{NR} et \textbf{FNR}.}
\item[\hspace{1mm} getline < file]{Lit dans \textbf{\$0} depuis \textbf{file}, met à jours les champs et \textbf{NF}.}
\item[\hspace{1mm} getline var]{Lit l’enregistrement suivant dans \textbf{var}, met à jours \textbf{NR} et \textbf{FNR}.}
\item[\hspace{1mm} getline var < file]{Lit le prochain enregistrement de file dans \textbf{var}}
\item[\hspace{1mm} command | getline]{Pipe un enregistrement depuis \textbf{command} dans \textbf{\$0} et met à jours les champs et \textbf{NF}}
\item[\hspace{1mm} command | getline var]{Pipe un enregistrement depuis \textbf{command} dans \textbf{var}}
\item[\hspace{1mm} getline]{retourne 0 sur end-of-file, -1 sur erreur, sinon 1.}
\end{description}
 
\hspace{1mm}  La fonction \textbf{close(expr)} ferme le fichier ou le pipe associé avec \textbf{expr}. close retourne \textbf{0} si \textbf{expr} est un fichier ouvert ou une commande en pipe, \textbf{-1} sinon. \textbf{close} est utilisé pour relire un fichier ou une commande.
\vspace{5mm} \\
\hspace{1mm}  La fonction \textbf{fflush(expr)} vide le fichier de sortie ou le pipe associé avec \textbf{expr}. \textbf{fflush} retourne \textbf{0} si \textbf{expr} est un flux de sortie ouvert, sinon \textbf{-1}. \textbf{fflush} sans argument vide \textbf{stdout}. \textbf{fflush} avec un argument vide ("") vide toutes les sorties ouvertes.
\vspace{5mm} \\
\hspace{1mm}  \textbf{system(expr)} utilise \textbf{/bin/sh} pour exécuter \textbf{expr} et retourner le code de sortie de la commande \textbf{expr}. Les changements sont fait dans le tableau \textbf{ENVIRON} ne sont pas passé à la commande exécutée avec system ou les pipes.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Fonctions utilisateurs }
 
\
 
\hspace{1mm} La syntaxe pour une fonction utilisateur est la suivante \\
\hspace{1mm} \textbf{function name( args ) statements} \\
\hspace{1mm} Le corps de la fonction peut contenir une déclaration de retour \\
\hspace{1mm} \textbf{return opt\_expr} \\
\hspace{1mm} Une déclaration de retour n’est pas requise. Les appels de fonction peuvent être imbriqués ou récursifs. Les fonctions sont passées en expressions par valeur et les tableaux par référence. Les arguments supplémentaires servent de variables locales et sont initialisés à null. Par exemple, \\
\hspace{1mm} \textbf{csplit(s,A)} \\
\hspace{1mm} place chaque caractère de s dans le tableau A et retourne la longueur de s \\
 
{\ttfamily
function csplit(s, A, n, i)\\ \hspace{2mm}\\ \hspace{2mm}n = length(s)\\ \hspace{2mm}for( i = 1 ; i <= n ; i++ ) A\texttt{[}i\texttt{]} = substr(s, i, 1)\\ \hspace{2mm}return n\\
}
\vspace{8mm}
 
\hspace{1mm}  Placer des espaces supplémentaires entre les arguments passés et les variables locales est conventionnel. Les fonctions peuvent être référencés avant qu’elles soient définies, mais le nom de la fonction et le ’(’ des arguments doivent se toucher pour éviter les confusions avec les concaténations.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Splittes les chaînes, enregistrements et fichiers }
 
\
 
\hspace{1mm}  \textbf{awk} utilise le même algorithme pour splitter les chaînes dans les tableaux avec \textbf{split()}, et les enregistrements dans les champs dans \textbf{FS}. \textbf{mawk} utilise essentiellement le même algorithme pour splitter les fichiers en enregistrement dans \textbf{RS}. \textbf{split(expr,A,sep)} fonctionne comme suit:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} (1)]{si \textbf{sep} est omis, il est remplacé par \textbf{FS}. \textbf{sep} peut être une expressions régulière ou une expressions. Si c’est une expression de type non-chaîne, il est convertit en chaîne.}
\item[\hspace{1mm} (2)]{si \textbf{sep = " "} (un simple espace), alors il est recherché du début à la fin de \textbf{expr}, et \textbf{sep} devient "". \textbf{mawk} définie en tant qu’expression régulière \textbf{/[ \textbackslash{}t\textbackslash{}n]+/}. Sinon \textbf{sep} est traité comme expression régulière, excepté que les méta-caractères sont ignorés pour les chaînes de longueur 1, par exemple, \textbf{split(x, A, "$\mu$")} et \textbf{split(x, A, /\textbackslash{}*/)} sont équivalents.}
\item[\hspace{1mm} (3)]{Si \textbf{expr} n’est pas une chaîne, il est convertit en chaîne. si \textbf{expr} vaut \textbf{""}, \textbf{split()} retourne 0 et 1 est vide. Sinon, les matches de \textbf{sep} dans \textbf{expr}, sépare \textbf{expr} dans des champs qui sont stockés dans \textbf{A} et \textbf{split()} retourne le nombre de champs dans \textbf{A}.}
\end{description}
 
\hspace{1mm}  Splitter les enregistrements en champs fonctionne de la même manière excepté que les pièces sont chargées dans \textbf{\$1, \$2, ..., \$NF}. Si \textbf{\$0} est vide, \textbf{NF} vaut 0 et tous les \textbf{\$i} sont à "".
\vspace{5mm} \\
\hspace{1mm}  \textbf{mawk} split les fichiers en enregistrements par le même algorithme, mais à la différence que \textbf{RS} est réellement un terminateur au lieu d’un séparateur.
\vspace{5mm} \\
\hspace{1mm}  exemple, si \textbf{FS = " :+"} et \textbf{\$0 = "a ::b :"} , alors \textbf{NF = 3} et \textbf{\$1 = "a", \$2 = "b"} et \textbf{\$3 = ""}, mis si \textbf{"a ::b :"} est le contenu d’un fichier d’entrée et \textbf{RS = " :+"}, alors il y’a 2 enregistrements "a" et "b".
\vspace{5mm} \\
\hspace{1mm}  \textbf{RS = " "} n’est pas spécial
\vspace{5mm} \\
\hspace{1mm}  si \textbf{FS = ""}, \textbf{mawk} casse l’enregistrement en caractères individuels, et, similairement, \textbf{split(s,A,"")} place les caractères individuels de s dans A.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Enregistrements multi-lignes }
 
\
 
\hspace{1mm}  Vu que \textbf{mawk} interprète \textbf{RS} comme expression régulière, les enregistrements multi-ligne sont facile. Définir \textbf{RS = "\textbackslash{}n\textbackslash{}n+"}, créé une ou plusieurs lignes blanches pour séparer les enregistrements. Si \textbf{FS = " "} (le défaut), alors un simple newline, via les règles plus haut, devient un espace et les simples newline sont des séparateurs de champs.
\vspace{5mm} \\
\hspace{1mm}  Par exemple, si un fichier est \textbf{"a b\textbackslash{}nc\textbackslash{}n\textbackslash{}n", RS = "\textbackslash{}n\textbackslash{}n+"} et \textbf{FS = " "}, alors il y’a un enregistrement \textbf{"a b\textbackslash{}nc"} avec 3 champs "a", "b" et "c", changer \textbf{FS = "\textbackslash{}n"}, donne 2 champs "a b" et "c". Changer \textbf{FS = ""}, donne un champ identique à l’enregistrement.
\vspace{5mm} \\
 
 
\hspace{1mm}  Si vous voulez que les lignes avec des espaces ou tabulation soient considérés blanc, définir \textbf{RS = "\textbackslash{}n([ \textbackslash{}t]*\textbackslash{}n)+"}. Pour la compatibilité avec d’autres awk, définir \textbf{RS = ""} a le même effet que si les lignes blanches sont enlevées du début à la fin des fichiers et les enregistrements sont déterminé comme si \textbf{RS = "\textbackslash{}n\textbackslash{}n+"}. Posix nécessite que \textbf{"\textbackslash{}n"} sépare toujours les enregistrements quand \textbf{RS = ""} sans regarder la valeur de FS. \textbf{mawk} ne supporte pas cette convention, parce que définir \textbf{"\textbackslash{}n"} n’est pas nécessaire.
\vspace{5mm} \\
\hspace{1mm}  La plupart du temps quand vous changez \textbf{RS} pour les enregistrements multi-ligne, vous voulez également changer \textbf{ORS} à \textbf{"\textbackslash{}n\textbackslash{}n"} pour que l’espacement des enregistrements soit préservé en sortie.
\vspace{5mm} \\
 
 
\vspace{1cm}{\huge Exécution de programme }
 
\
 
\hspace{1mm}  Cette section décrit l’ordre d’exécution des programmes. D’abord \textbf{ARGC} est définit au nombre total d’arguments passé sur la ligne de commande. \textbf{ARGV[0]} a le nom de l’interpréteur awk et \textbf{ARGV[1] ... ARGV[ARGC-1]} contiennent les arguments de la ligne de commande.
\vspace{5mm} \\
 
 
\hspace{1mm} Par exemple avec \\
\hspace{1mm} \textbf{mawk -f prog v=1 A t=hello B} \\
\hspace{1mm} \textbf{ARGC = 5} \\
\hspace{1mm} avec \\
\hspace{1mm} \textbf{ARGV[0] = "mawk", ARGV[1] = "v=1", ARGV[2] = "A", ARGV[3] = "t=hello" et ARGV[4] = "B".} \\
 
\hspace{1mm}  Ensuite, chaque block \textbf{BEGIN} est exécuté dans l’ordre. Si le programme consiste entièrement de blocks \textbf{BEGINS}, alors l’exécution se termine, sinon un flux d’entrée est ouvert et l’exécution continue. Si \textbf{ARGC} vaut 1, le flux d’entrée et mis à stdin, sinon les arguments de la ligne de commande sont examinés à la recherche d’un fichier.
\vspace{5mm} \\
 
 
\hspace{1mm}  Les arguments se divisent en 3 ensembles: fichiers, arguments et chaînes vide "". Un assignement a le format \textbf{var=string}. Quand \textbf{ARGV[1]} est examiné comme un argument fichier possible, s’il est vide, il est ignoré ; si c’est un assignement, l’assignement à \textbf{var} est fait et \textbf{i} saute au suivant; sinon \textbf{ARGV[i]} est ouvert en entrée. S’il échoue à l’ouverture, l’exécution se termine avec le code d’erreur 2. Sans argument fichier, l’entrée devient stdin. \textbf{getline} dans une action \textbf{BEGIN} ouvre l’entrée. "-" comme argument fichier dénote stdin.
\vspace{5mm} \\
 
 
\hspace{1mm}  Une fois un flux d’entrée ouvert, chaque enregistrement entrant est testé avec chaque \textbf{pattern}, et si çà matche, l’action associée est exécutée. Une expression mach si elle vaut true. Un \textbf{BEGIN} match avant qu’une entrée soit lue, et un \textbf{END} match après que toutes les entrées aient été lues. Une plage de motif, \textbf{expr1,expr2,} match chaque enregistrement entre le match de \textbf{expr1} et le match de \textbf{expr2}, inclus.
\vspace{5mm} \\
 
 
\hspace{1mm}  Quand la fin d’un fichier sur produit sur un flux d’entrée, les arguments restants sur la ligne de commande sont examinés à la recherche d’un fichier, et s’il y’en a un, il est ouvert, sinon le pattern END est considéré matché et toutes les actions END sont exécutées.
\vspace{5mm} \\
 
 
\hspace{1mm}  Dans l’exemple, l’assignement \textbf{v=1} prend place après que \textbf{BEGIN} ait été exécutée, et la donnée placée dans \textbf{v} est de type nombre et chaîne. L’entrée est ainsi lue depuis le fichier A. à la fin du fichier A, \textbf{t} est définis à \textbf{"hello"}, et B est ouvert en entrée. À la fin du fichier B, les actions \textbf{END} sont exécutées. Le flux de programme au niveau pattern \textbf{action} peut être changé avec:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} next]{Le prochain enregistrement en entrée est lu et le motif est testé pour redémarrer avec le premier pattern action}
\item[\hspace{1mm} exit opt\_expr]{Force l’exécution immédiate des actions END ou la fin du programme s’il n’y en a pas ou si exit se produit à la fin d’une action END. opt\_expr définie la valeur de sortie.}
\end{description}
 
\vspace{1cm}{\huge Exemples }
 
\
 
\hspace{1mm} Émuler cat
 
{\ttfamily
print\\
}
\vspace{8mm}
 
\hspace{1mm} Émuler wc
 
{\ttfamily
chars += length(\$0) +1\\ words += NF\\ END print NR, words, chars\\
}
\vspace{8mm}
 
\hspace{1mm} Compter le nombre de mots uniques
 
{\ttfamily
BEGIN FS = "\texttt{[}\textasciicircum A-Za-z\texttt{]}+"\\ \hspace{2mm}for(i = 1 ; i <= NF ; i++) word\texttt{[}\$i\texttt{]} = ""\\ END delete word\texttt{[}""\texttt{]}\\ \hspace{2mm}for ( i in word ) cnt++\\ \hspace{2mm}print cnt\\
}
\vspace{8mm}
 
\hspace{1mm} Ajoute le second champs de tous les enregistrements basés sur le premier champ
 
{\ttfamily
\$1 /credit|gain/ sum += \$2\\ \$1 /debit|loss/ sum -= \$2\\
}
\vspace{8mm}
 
\hspace{1mm} Trie un fichier, comparer les chaînes :
 
{\ttfamily
line\texttt{[}NR\texttt{]} = \$0 ""\\ END isort(line, NR)\\ \hspace{2mm}for(i = 1 ; i <= NR ; i++) print line\texttt{[}i\texttt{]}\\ \hspace{2mm}\\ function isort( A, n, i, j, hold)\\ \hspace{2mm}for( i = 2 ; i <= n ; i++)\\ \hspace{2mm}hold = A\texttt{[}j = i\texttt{]}\\ \hspace{2mm}while ( A\texttt{[}j-1\texttt{]} > hold )\\ \hspace{2mm}\hspace{2mm}j— ; A\texttt{[}j+1 = A\texttt{[}j\texttt{]}\\ \hspace{2mm}A\texttt{[}j\texttt{]} = hold\\
}
\vspace{8mm}
 
\vspace{1cm}{\huge Problèmes de compatibilité }
 
\
 
\hspace{1mm}  nawk apporte ces extensions:
\vspace{5mm} \\
 
 
\begin{description} \normalsize
\item[\hspace{1mm} nouvelles fonctions:]{toupper() et tolower()}
\item[\hspace{1mm} nouvelles variables:]{ENVIRON[] et CONVFMT}
\item[\hspace{1mm} Spécifications de conversion ANSI C pour]{printf() et sprintf()}
\item[\hspace{1mm} Options de ligne de commande:]{-v var=value, plusieurs fois -f et l’implémentation des options en tant qu’argument de -W.}
\end{description}
 
\hspace{1mm}  Posix AWK est orienté pour opérer sur les fichiers une ligne à la fois. \textbf{RS} peut être changé de \textbf{"\textbackslash{}n"} à un autre caractère, mais c’est difficile de trouver une utilisation pour ça. Par convention, \textbf{RS = ""}, créé une ou plusieurs lignes blanches séparant les enregistrements, permettant les enregistrements multi-lignes. Quand \textbf{RS = ""}, \textbf{"\textbackslash{}n"} est toujours un champ séparateur sans regarder \textbf{FS}.
\vspace{5mm} \\
 
 
\hspace{1mm}  \textbf{mawk} permet à RS d’être une expression régulière. Quand \textbf{"\textbackslash{}n"} apparait dans l’enregistrement, il est traité comme espace, et FS détermine toujours les champs.
\vspace{5mm} \\
 
 
\hspace{1mm} Supprimer la ligne à un certain moment peut simplifier les programmes et peut souvent améliorer les performances. Par exemple, en réécrivant les 3 exemples plus haut:
 
{\ttfamily
BEGIN RS = "\texttt{[}\textasciicircum A-Za-z\texttt{]}+"\\ word\texttt{[} \$0 \texttt{]} = ""\\ END delete word\texttt{[} "" \texttt{]}\\ \hspace{2mm}for(i in word ) cnt++\\ \hspace{2mm}print cnt\\
}
\vspace{8mm}
 
\hspace{1mm}  Compte le nombre de mots uniques en faisant de chaque mot un enregistrement. Sur des fichiers de taille modérée, mawk s’exécute 2 fois plus vite.
\vspace{5mm} \\
 
 
\hspace{1mm} Le programme suivant remplace chaque commentaire par un simple espace dans un fichier C
 
{\ttfamily
BEGIN\\ \hspace{2mm}RS = "/\textbackslash{}*(\texttt{[}\textasciicircum *\texttt{]}|\textbackslash{}*+\texttt{[}\textasciicircum /*\texttt{]})*\textbackslash{}*+/"\\ \hspace{2mm}ORS = " "\\ \hspace{2mm}getline hold\\ \hspace{2mm}\\ \hspace{2mm}\hspace{2mm}print hold ; hold = \$0\\ \hspace{2mm}END printf "\%s" , hold\\
}
\vspace{8mm}
 
\begin{description} \normalsize
\item[\hspace{1mm} avec mawk, les déclarations suivantes sont équivalentes:]{x /a\textbackslash{}+b/ x "a\textbackslash{}+b" x "a\textbackslash{}\textbackslash{}+b"}
\end{description}
 
\hspace{1mm}  Les chaînes sont scanées 2 fois, une fois en tant que chaîne, et une fois en tant qu’expression régulière. Au premier scan, \textbf{mawk} ignore les caractères d’échappement alors que \textbf{awk} reconnait \textbf{\textbackslash{}c}.
\vspace{5mm} \\
\hspace{1mm}  Posix awk ne reconnait pas \textbf{"/dev/stdout,err"} ou la séquence \textbf{hexa \textbackslash{}x} dans les chaînes. À la différence de l’ANSI C, \textbf{mawk} limite le nombre de chiffres qui suivent \textbf{\textbackslash{}x} de 2 vu que l’implémentation actuelle supporte uniquement les caractères 8 bits.
\vspace{5mm} \\
 
\end{flushleft}
\end{document}
