Provided by: manpages-pl_0.5-1_all bug

NAZWA

       mawk - język wyszukiwania wzorców i przetwarzania tekstu

SKŁADNIA

       mawk  [-W opcja] [-F wartość] [-v zmn=wartość]
             [--] 'tekst programu' [plik...]

       mawk  [-W opcja] [-F wartość] [-v zmn=wartość]
             [-f plik-programu] [--] [plik...]

OPIS

        Uwaga! To tłumaczenie może być nieaktualne!

       mawk  jest  interpreterem języka programowania AWK. Język AWK jest użyteczny w działaniach
       na plikach danych,  wyszukiwaniu  i  przetwarzaniu  tekstu  oraz  tworzeniu  prototypów  i
       eksperymentowaniu  z  algorytmami.   mawk implementuje język AWK, jak go zdefiniowali Aho,
       Kernighan i Weinberger w książce The AWK Programming Language, Addison-Wesley  Publishing,
       1988  (dalej  wzmiankowanej jako książka AWK).  mawk jest zgodny z definicją języka AWK ze
       standardu Posix 1003.2 (propozycja 11.3), zawierającą nowe cechy  nie  opisane  w  książce
       AWK.  Dodatkowo mawk zawiera nieco rozszerzeń.

       Program  AWK  jest  sekwencją  par  wzorzec {akcja} i definicji funkcji.  Krótkie programy
       wprowadzane są w wierszu poleceń, zwykle  ujęte  w  '  ',  by  uniknąć  interpretacji  ich
       składowych przez powłokę.  Dłuższe programy mogą być czytane z pliku przy pomocy opcji -f.
       dane wejściowe odczytywane  są z listy plików  z  wiersza  poleceń  lub  ze  standardowego
       wejścia,  gdy  lista  ta  jest  pusta.  Wejście rozbijane jest na rekordy określone według
       zmiennej opisującej separator  rekordów,  RS  (record  separator).  Początkowo  RS="\n"  a
       rekordy  są  tożsame z wierszami. Każdy z rekordów porównywany jest z każdym ze wzorców, a
       jeśli pasuje, wykonywany jest tekst programu dla {akcji}.

OPCJE

       -F wartość     ustawia separator pól, FS, na wartość.

       -f plik        Tekst programu jest czytany z pliku zamiast z wiersza  poleceń.   Dopuszcza
                      się wielokrotne użycie opcji -f.

       -v zmn=wartość przypisuje wartość zmiennej programu zmn.

       --             wskazuje jednoznaczny koniec opcji.

       Powyższe  opcje  będą  dostępne  w  każdej  zgodnej  z  Posix  implementacji  AWK.   Opcje
       specyficzne dla danej implementacji poprzedzane są przez -W.  mawk udostępnia sześć takich
       rozszerzeń:

       -W version     mawk  wypisuje  swą  wersję  i  prawa  autorskie  na  stdout  (standardowym
                      wyjściu), zaś wkompilowane ograniczenia  na  stderr  (standardowym  wyjściu
                      błędów).  Kończy pracę z kodem 0.

       -W dump        wypisuje  na  stdout  asembleropodobny  listing  wewnętrznej  reprezentacji
                      programu i kończy pracę z kodem 0 (przy pomyślnej kompilacji).

       -W interactive ustawia niebuforowane zapisy na stdout i  buforowane  wierszami  odczyty  z
                      stdin  (standardowego wejścia). Rekordy z stdin są wierszami niezależnie od
                      wartości RS.

       -W exec plik   Tekst programu czytany jest z pliku i jest to ostatnia opcja. Przydatne  na
                      systemach  obsługujących  konwencję  "liczb  magicznych"  #!   dla skryptów
                      wykonywalnych.

       -W sprintf=num ustawia rozmiar bufora wewnętrznego sprintf na  num  bajtów.  Częstsze  niż
                      sporadyczne   stosowanie  tej  opcji  wskazuje,  że  mawk  powinien  zostać
                      zrekompilowany.

       -W posix_space wymusza na mawk, by nie uważał '\n' za odstęp.

       Rozpoznawane  są  krótkie  postacie  -W[vdiesp],  zaś  w  niektórych  systemach  -We  jest
       obowiązkowe dla uniknięcia ograniczeń długości wiersza poleceń.

JĘZYK AWK

   1. Struktura programu
       Program  w  języku AWK jest składa się z sekwencji par wzorzec {akcja} i definicji funkcji
       użytkownika.

       Wzorcem może być:
              BEGIN
              END
              wyrażenie
              wyrażenie, wyrażenie

       Można pominąc jeden z elementów z pary wzorzec {akcja}, ale  nie  oba.   Jeżeli  pominięto
       {akcję}, to jest nią domniemane { print }.  Jeżeli pominięto wzorzec, to jest on niejawnie
       dopasowany.  Wzorce BEGIN i END wymagają akcji.

       Instrukcje zakończone są znakami nowej linii, średnikami lub oboma  tymi  znakami.   Grupy
       instrukcji,  jak akcje czy ciała pętli, łączone są w bloki za pośrednictwem { ... }, jak w
       C.  Ostatnia instrukcja w bloku nie wymaga  znaku  kończącego.   Puste  wiersza  nie  mają
       znaczenia;   pusta   instrukcja   zakończona  jest  średnikiem.  Długie  instrukcje  można
       kontynuować przy pomocy odwrotnego ukośnika \.  Instrukcję można podzielić między  wiersze
       bez  użycia  odwrotnego  ukośnika  po  przecinku, nawiasie otwierającym, &&, ||, do, else,
       nawiasie zamykającym instrukcji if, while lub  for  oraz  nawiasie  zamykającym  definicji
       funkcji.   Komentarze zaczynają się od # i rozciągają się do aż końca wiersza, choć go nie
       obejmują.

       Poniższe instrukcje sterują przepływem programu wewnątrz bloków.

              if ( wyraż ) instrukcja

              if ( wyraż ) instrukcja else instrukcja

              while ( wyraż ) instrukcja

              do instrukcja while ( wyraż )

              for ( wyr_opc ; wyr_opc ; wyr_opc ) instrukcja

              for ( zmn in tablica ) instrukcja

              continue

              break

   2. Typy danych, konwersja i porównywanie
       Istnieją dwa podstawowe typy danych, numeryczny i łańcuch znakowy.   Stałe  liczbowe  mogą
       być  całkowite,  jak -2, dziesiętne jak 1.08, lub podane w notacji naukowej jak -1.1e4 czy
       .28E-3. Wszystkie liczby są reprezentowane wewnętrznie w  arytmetyce  zmiennoprzecinkowej.
       Wszystkie  obliczenia  również  są  zmiennoprzecinkowe.   Tak więc, na przykład, wyrażenie
       0.2e2 == 20 jest prawdą. Prawda reprezentowana jest jako 1.0.

       Stałe łańcuchowe ujęte są w cudzysłowy.

                          "To jest łańcuch ze znakiem nowej linii na końcu.\n"

       Łańcuchy znakowe mogą być kontynuowane w kolejnych  wierszach  dzięki  poprzedzeniu  znaku
       nowej linii odwrotnym ukośnikiem (\).  Rozpoznawane są następujące sekwencje specjalne:

           \\        \
           \"        "
           \a        dzwonek, ascii 7
           \b        backspace, ascii 8
           \t        tabulacja, ascii 9
           \n        znak nowej linii, newline , ascii 10
           \v        tabulacja pionowa, ascii 11
           \f        wysuw strony, formfeed, ascii 12
           \r        powrót karetki, carriage return, ascii 13
           \ddd      1, 2 lub 3 cyfry ósemkowe dla ascii ddd
           \xhh      1 lub 2 cyfry szesnastkowe dla ascii hh

       Jeżeli  odwrotnym  ukośnikiem  zostanie  poprzedzony  inny  znak,  np. \c, wynikiem będzie
       sekwencja źródłowa: \c, tzn.  mawk zignoruje specjalne właściwości odwrotnego ukośnika.

       Naprawdę istnieją trzy podstawowe typy danych; trzecim jest liczba i łańcuch,  posiadający
       równocześnie wartość liczbową i wartość łańcuchową.  Zmienne definiowane przez użytkownika
       pojawiają się przy pierwszym ich użyciu i są inicjowane na null, typu "liczba i  łańcuch",
       mające wartość numeryczną 0 a łańcuchową "".  Nietrywialne dane typu liczbowo-łańcuchowego
       pochodzą z wejścia i zwykle przechowywane są w polach (zobacz sekcja 4).

       Typ wyrażenia określany jest  przez  jego  kontekst.  W  razie  potrzeby  wykonywana  jest
       automatyczna konwersja typów. Na przykład, wyznaczenie wartości instrukcji

            y = x + 2  ;  z = x  "hello"

       Wartość  przechowywana w zmiennej y otrzyma typ numeryczny.  Jeżeli x nie jest numeryczne,
       to wartość odczytana  z  x  zostanie  skonwertowana  na  liczbę  przed  dodaniem  do  2  i
       zachowaniem  w  y.  Wartość przechowywana w zmiennej z będzie typu łańcuchowego: wartość x
       zostanie przekształcona na łańcuch, jeśli będzie  to  niezbędne,  i  złączona  z  "hello".
       Oczywiście,  wartość  i typ przechowywane w x nie zmieniają się w żadnej z tych konwersji.
       Wyrażenie łańcuchowe przekształcane jest  na  numeryczne  przy  zastosowaniu  najdłuższego
       swego  przedrostka  numerycznego jak w atof(3).  Wyrażenie numeryczne konwertowane jest na
       łańcuch poprzez zastąpienie wyraż przez sprintf(CONVFMT, wyraż), chyba że wyraż  może  być
       reprezentowane  w  danym komputerze jako dokładna liczba całkowita, wówczas przekształcane
       jest na sprintf("%d", wyraż).  Sprintf() jest funkcją wbudowaną AWK,  dublującą  działanie
       sprintf(3),  zaś  CONVFMT jest wbudowaną zmienną używaną do wewnętrznej konwersji z liczby
       na łańcuch i inicjowaną na "%.6g".  Można wymusić jawną konwersję  typów:  wyraż  ""  jest
       łańcuchowe, a wyraż+0 jest numeryczne.

       Przy   wyliczaniu,   wyraż1   op-rel   wyraż2,  jeżeli  oba  operandy  są  numeryczne  lub
       numeryczno-łańcuchowe, to porównywanie jest numeryczne; jeżeli oba operandy są  łańcuchami
       to  porównywanie  jest  łańcuchowe;  jeśli  jeden  z  operandów jest łańcuchem, to operand
       nie-łańcuchowy jest przekształcany i porównywanie jest łańcuchowe.  Wynik jest numeryczny,
       1 lub 0.

       W  kontekstach  logicznych,  jak if ( wyraż ) instrukcja, wartością wyrażenia łańcuchowego
       jest prawda wtedy i tylko wtedy, gdy nie jest ono łańcuchem pustym ""; wyrażeń  liczbowych
       wtedy i tylko wtedy gdy nie są numerycznie zerem.

   3. Wyrażenia regularne
       W  języku  AWK  rekordy,  pola i łańcuchy są często sprawdzane na dopasowanie do wyrażenia
       regularnego.  Wyrażenia regularne umieszczone są między ukośnikami, a

            wyraż ~ /r/

       jest wyrażeniem AWK o wartości 1  jeśli  wyraż  "pasuje  do"  r,  co  oznacza,  że  pewien
       podłańcuch  wyraż  jest  w zestawie łańcuchów zdefiniowanych przez r.  Jeśli nie występuje
       dopasowanie, to wyrażenie otrzymuje wartość 0; zastąpienie ~ operatorem "nie pasuje",  !~,
       odwraca znaczenia.  Pary wzorzec-akcja

               /r/ { akcja }   i   $0 ~ /r/ { akcja }

       są  takie same, zaś dla każdego rekordu wejściowego pasującego do r wykonywana jest akcja.
       Faktycznie,  /r/  jest  wyrażeniem  AWK  równoważnym  ($0  ~  /r/)  wszędzie  z  wyjątkiem
       wystąpienia   po  prawej  stronie  operatora  dopasowania  lub  przekazywania  do  funkcji
       wbudowanej oczekującej jako argumentu wyrażenia regularnego.

       AWK  stosuje  rozszerzone  wyrażenia  regularne   jak   egrep(1).    Metaznakami   wyrażeń
       regularnych, tj. znakami o specjalnym znaczeniu w wyrażeniach regularnych są

             ^ $ . [ ] | ( ) * + ?

       Wyrażenia regularne konstruowane są ze znaków jak niżej:

              c            dopasowuje dowolny znak nie będący metaznakiem c.

              \c           dopasowuje znak zdefiniowany przez tę samą sekwencję specjalną używaną
                           w stałych łańcuchowych lub dosłowny znak c jeśli \c nie jest sekwencją
                           specjalną.

              .            dopasowuje dowolny znak (łącznie ze znakiem nowej linii).

              ^            dopasowuje początek łańcucha.

              $            dopasowuje koniec łańcucha.

              [c1c2c3...]  dopasowuje  dowolny  znak z klasy c1c2c3... .  Zakres znaków oznaczany
                           jest przez c1-c2 wewnątrz klasy [...].

              [^c1c2c3...] dopasowuje dowolny znak nie należący do klasy c1c2c3...

       Wyrażenia regularne konstruowane są z innych wyrażeń regularnych w następujący sposób:

              r1r2         dopasowuje r1, bezpośrednio po którym następuje r2 (konkatenacja).

              r1 | r2      dopasowuje r1 lub r2 (alternatywa).

              r*           dopasowuje zero lub więcej wystąpień r .

              r+           dopasowuje jedno lub więcej r.

              r?           dopasowuje zero lub jedno r.

              (r)          dopasowuje r, umożliwiając grupowanie.

       Operatory według rosnącego priorytetu: alternatywa, konkatenacja (złączenie)  i  operatory
       jednoargumentowe (*, + lub ?).

       Na przykład,

           /^[_a-zA-Z][_a-zA-Z0-9]*$/  i
           /^[-+]?([0-9]+\.?|\.[0-9])[0-9]*([eE][-+]?[0-9]+)?$/

       dopasowują  odpowiednio identyfikatory AWK i stałe liczbowe AWK.  Zauważ, że kropka . musi
       być chroniona odwrotnym ukośnikiem, by została rozpoznana jako kropka  dziesiętna,  a  nie
       dopasowanie  dowolnego  znaku,  a  metaznaki  wewnątrz  klas  znaków  tracą  swe specjalne
       znaczenie.

       Po prawej stronie operatorów ~ lub !~ może  zostać  użyte  dowolne  wyrażenie.   Podobnie,
       dowolne wyrażenie można przekazać do funkcji wbudowanej oczekującej wyrażenia regularnego.
       W razie potrzeby zostanie ono przekształcone na łańcuch, a następnie zinterpretowane  jako
       wyrażenie regularne. Na przykład,

            BEGIN { identifier = "[_a-zA-Z][_a-zA-Z0-9]*" }

            $0 ~ "^" identifier

       wypisuje wszystkie wiersze zaczynające się od jakiegoś identyfikatora AWK.

       mawk  rozpoznaje  puste wyrażenie regularne, //, dopasowujące łańcuch pusty.  Zatem pasuje
       do niego dowolny łańcuch na początku, końcu i pomiędzy dowolnym znakiem. Na przykład,

            echo  abc | mawk '{ gsub(//, "X") ; print }'
            XaXbXcX

   4. Rekordy i pola
       Rekordy czytane są po jednym na raz, i przechowywane w zmiennej $0.  Rekord rozbijany jest
       na  pola, przechowywane w $1, $2, ..., $NF.  Wbudowana zmienna NF ustawiana jest na liczbę
       pól, a NR i FNR są zwiększane o 1.  Pola powyżej $NF ustawiane są na "".

       Przypisanie do $0 powoduje, że pola i NF są obliczane ponownie.  Przypisanie do NF lub  do
       pola  powoduje,  że  $0  jest ponownie tworzone przez złączenie kolejnych pól separowanych
       przez OFS.  Przypisanie do pola o indeksie większym od NF, powiększa NF i powoduje ponowne
       utworzenie $0.

       Dane  wejściowe  przechowywane  w  polach  są  łańcuchami,  chyba  że  całe pole ma postać
       numeryczną a wówczas typ jest liczbowo-łańcuchowy.  Na przykład,

            echo 24 24E |
            mawk '{ print($1>100, $1>"100", $2>100, $2>"100") }'
            0 1 1 1

       $0 i $2 są łańcuchami a $1 jest liczbowo-łańcuchowe. Pierwsze porównanie jest  numeryczne,
       drugie  łańcuchowe,  trzecie  łańcuchowe  (100  jest  konwertowane  na  "100"), i ostatnie
       łańcuchowe.

   5. Wyrażenia i operatory
       Składnia wyrażeń jest podobna jak w C. Wyrażeniami pierwotnymi są  stałe  liczbowe,  stałe
       łańcuchowe,  zmienne,  pola, tablice i wywołania funkcji.  Identyfikator zmiennej, tablicy
       bądź funkcji może być ciągiem liter, cyfr i znaków podkreślenia, nie  rozpoczynającym  się
       od  cyfry.   Zmienne  nie  są  deklarowane; zaistnieją przy pierwszym do nich odwołaniu, a
       inicjowane są na null.

       Nowe  wyrażenia  tworzone  są  z  użyciem  poniższych,  podanych  w  kolejności  rosnącego
       priorytetu, operatorów:

              przypisanie                =  +=  -=  *=  /=  %=  ^=
              warunkowe                 ?  :
              logiczne or               ||
              logiczne and              &&
              przynależność do tablicy  in
              dopasowanie               ~   !~
              relacyjne                 <  >   <=  >=  ==  !=
              konkatenacja              (bez specjalnego operatora)
              dodawanie/odejmowanie     +  -
              mnożenie/dzielenie        *  /  %
              jednoargumentowe          +  -
              logiczne not              !
              potęgowanie               ^
              inkrementacja/dekr.       ++ -- (zarówno post jak i pre)
              pole                      $

       Przypisanie,  operatory  warunkowe  i  potęgowanie wiążą od prawej do lewej; pozostałe  od
       lewej do prawej. Każde wyrażenie może być umieszczone w nawiasach.

   6. Tablice
       Awk obsługuje tablice jednowymiarowe. Elementy tablic wskazuje  się  jako  tablica[wyraż].
       Wyraż  jest przekształcane wewnętrznie na typ łańcuchowy, więc, na przykład, A[1] i A["1"]
       są tym samym elementem, a faktycznym indeksem jest "1".   Tablice  indeksowane  łańcuchami
       zwane  są  tablicami  asocjacyjnymi  (tablicami przyporządkowującymi).  Pierwotnie tablica
       jest pusta; elementy zaistnieją przy pierwszym do  nich  odwołaniu.   Wyrażenie  wyraż  in
       tablica daje w wyniku 1 jeżeli istnieje tablica[wyraż], w przeciwnym razie 0.

       Istnieje postać instrukcji for wykonująca pętlę po wszystkich indeksach tablicy.

               for ( zmn in tablica ) instrukcja

       ustawia  zmn  na  każdy z indeksów tablicy i wykonuje instrukcję.  Kolejność, w jakiej zmn
       przechodzi przez indeksy tablicy nie jest zdefiniowana.

       Instrukcja delete  tablica[wyraż],  powoduje  usunięcie  tablica[wyraż].   mawk  obsługuje
       rozszerzenie, delete tablica, które usuwa wszystkie elementy tablicy.

       Tablice wielowymiarowe tworzone są sztucznie przez konkatenację z zastosowaniem wbudowanej
       zmiennej  SUBSEP.   tablica[wyraż1,wyraż2]  jest  równoważnikiem   tablica[wyraż1   SUBSEP
       wyraż2].  Sprawdzanie elementu tablicy wielowymiarowej używa indeksu w nawiasach, jak w

            if ( (i, j) in A )  print A[i, j]

   7. Zmienne wbudowane
       Poniższe zmienne są zmiennymi wbudowanymi. Są one inicjowane przed wykonaniem programu.

              ARGC      liczba argumentów wiersza poleceń.

              ARGV      tablica argumentów wiersza poleceń, 0..ARGC-1.

              CONVFMT   format do wewnętrznej konwersji liczb na łańcuchy, początkowo = "%.6g".

              ENVIRON   tablica   zaindeksowana   zmiennymi   środowiska.   Łańcuch   środowiska,
                        zmn=wartość przechowywany jest jako ENVIRON[zmn] = wartość.

              FILENAME  nazwa bieżącego pliku wejściowego.

              FNR       numer bieżącego rekordu w FILENAME.

              FS        dzieli rekordy na pola jako wyrażenie regularne.

              NF        liczba pól bieżącego rekordu.

              NR        numer bieżącego rekordu w całkowitym strumieniu wejściowym.

              OFMT      format do wydruku liczb; początkowo = "%.6g".

              OFS       wstawiane pomiędzy polami w wyjściu, początkowo = " ".

              ORS       kończy każdy z rekordów wyjściowych, początkowo = "\n".

              RLENGTH   długość ustawiona przez ostatnie wywołanie wbudowanej funkcji match().

              RS        separator rekordów wejściowych, początkowo = "\n".

              RSTART    indeks ustawiony przez ostatnie wywołanie match().

              SUBSEP    używany do budowy indeksów tablic wielowymiarowych, początkowo = "\034".

   8. Funkcje wbudowane
       Funkcje łańcuchowe

              gsub(r,s,t)  gsub(r,s)
                     Zastępowanie globalne (global  substitution),  każde  dopasowanie  wyrażenia
                     regularnego  r  w  zmiennej  t  zastępowane jest łańcuchem s.  Zwracana jest
                     liczba wykonanych zastąpień.  Jeżeli pominięto t, to używane jest $0.   Znak
                     &  w  łańcuchu  zastępującym  s  zastępowany  jest  dopasowanym podłańcuchem
                     łańcucha t.  \& oraz \\  dają,  odpowiednio,  dosłowne  &  i  \  w  łańcuchu
                     zastępującym.

              index(s,t)
                     Jeżeli t jest podłańcuchem s, to zwracana jest pozycja, na której rozpoczyna
                     się t, w przeciwnym razie zwracane jest 0.  Pierwszy znak s jest na  pozycji
                     1.

              length(s)
                     Zwraca długość łańcucha s.

              match(s,r)
                     Zwraca  indeks pierwszego najdłuższego dopasowania wyrażenia regularnego r w
                     łańcuchu s.  Zwraca 0 jeśli nie występuje dopasowanie.  Jako skutek uboczny,
                     następuje  ustawienie RSTART na zwracaną wartość.  RLENGTH ustawiane jest na
                     długość dopasowania  lub  -1  jeśli  brak  dopasowania.   Jeżeli  dopasowano
                     łańcuch  pusty,  to  RLENGTH  ustawiane  jest  na 0, a zwracane jest 1 jeśli
                     dopasowanie było na początku, zaś length(s)+1, gdy na końcu łańcucha.

              split(s,A,r)  split(s,A)
                     Łańcuch s rozbijany  jest  na  pola  przez  wyrażenie  regularne  r  a  pola
                     wpisywane  są do tablicy A.  Zwracana jest liczba pól. Szczegóły w sekcji 11
                     poniżej.  Jeżeli pominięto r, używane jest FS.

              sprintf(format,lista-wyraż)
                     Zwraca łańcuch utworzony z listy-wyrażeń zgodnie z  formatem.   Zobacz  opis
                     printf() poniżej.

              sub(r,s,t)  sub(r,s)
                     Pojedyncze  zastąpienie.  Takie  samo,  jak  gsub(),  z  wyjątkiem  tego, że
                     wykonywane jest co najwyżej jedno zastąpienie.

              substr(s,i,n)  substr(s,i)
                     Zwraca podłańcuch łańcucha s, poczynając od indeksu i, o długości n.   Jeśli
                     pominięto n, zwracana jest końcówka s, poczynając od pozycji i.

              tolower(s)
                     Zwraca kopię s ze wszystkimi dużymi literami przekształconymi na małe.

              toupper(s)
                     Zwraca kopię s ze wszystkimi małymi literami przekształconymi na duże.

       Funkcje arytmetyczne

              atan2(y,x)     arcus tangens z y/x pomiędzy -PI i PI.

              cos(x)         funkcja cosinus, x w radianach.

              exp(x)         funkcja wykładnicza.

              int(x)         zwraca x obcięte w stronę zera.

              log(x)         logarytm naturalny.

              rand()         zwraca liczbę losową między zero a jeden.

              sin(x)         funkcja sinus, x w radianach.

              sqrt(x)        zwraca pierwiastek kwadratowy z x.

              srand(wyraż)  srand()
                     Inicjuje ziarenko generatora liczb losowych, używając zegara jeśli pominięto
                     wyraż, i zwraca  wartość  poprzedniego  ziarenka  losowego.   mawk  inicjuje
                     generator  liczb  losowych  według  zegara  przy  uruchomieniu,  więc nie ma
                     faktycznej  potrzeby  wywoływania  srand().  Srand(wyraż)  przydaje  się  do
                     powtarzania ciągów pseudolosowych.

   9. Wejście i wyjście
       Istnieją dwie instrukcje wyjścia: print i printf.

              print  zapisuje na standardowe wyjście $0  ORS.

              print wyraż1, wyraż2, ..., wyrażn
                     zapisuje  na  standardowe  wyjście  wyraż1  OFS  wyraż2  OFS ... wyrażn ORS.
                     Wyrażenia numeryczne są konwertowane na łańcuchy zgodnie z OFMT.

              printf format, lista-wyraż
                     powiela funkcję biblioteczną printf z  C,  pisząc  na  standardowe  wyjście.
                     Rozpoznawany  jest  komplet specyfikacji formatów z ANSI C z konwersjami %c,
                     %d, %e, %E, %f, %g, %G, %i, %o, %s, %u, %x, %X i  %%,  oraz  kwalifikatorami
                     konwersji h i l.

       Lista  argumentów  print lub printf może być opcjonalnie ujęta w nawiasy.  Print formatuje
       liczby przy pomocy OFMT lub "%d" dla dokładnie całkowitych.  "%c" z argumentem numerycznym
       wypisuje  odpowiedni  znak  8-bitowy,  z  argumentem  łańcuchowym  wypisuje  pierwszy znak
       łańcucha.  Wyjście print i printf można przekierować do pliku lub polecenia  dołączając  >
       plik, >> plik lub | polecenie na końcu instrukcji drukowania.  Przekierowanie otwiera plik
       lub polecenie tylko raz, kolejne przekierowania dołączane są do już otwartego  strumienia.
       Zgodnie  z  konwencją,  mawk  łączy  nazwę  pliku  "/dev/stderr"  z  stderr, co pozwala na
       przekierowanie wyników print i printf na standardowe wyjście  diagnostyczne.   mawk  wiąże
       również,  odpowiednio, "-" i "/dev/stdout" z stdin i stdout, co umożliwia przysyłanie tych
       strumieni do funkcji.

       Funkcja wejścia getline ma następujące warianty:

              getline
                     czyta do $0, aktualizuje pola, NF, NR i FNR.

              getline < plik
                     czyta do $0 z pliku, aktualizuje pola i NF.

              getline zmn
                     czyta następny rekord do zmiennej zmn, aktualizuje NR i FNR.

              getline zmn < plik
                     czyta następny rekord pliku do zmiennej zmn.

              polecenie | getline
                     przesyła potokiem rekord z polecenia do $0 i aktualizuje pola i NF.

              polecenie | getline zmn
                     przesyła potokiem rekord z polecenia do zmiennej zmn.

       Getline zwraca 0 na końcu pliku, -1 przy błędzie, w pozostałych przypadkach 1.

       Polecenia na końcu potoków wykonywane są przez /bin/sh.

       Funkcja close(wyraż) zamyka plik lub potok skojarzony z  wyraż.   Close  zwraca  0  jeżeli
       wyraż  jest  otwartym  plikiem, kod zakończenia jeśli wyraż jest poleceniem potoku, a -1 w
       pozostałych przypadkach.  Close stosowane jest do ponownego odczytu pliku  lub  polecenia,
       upewnienia  się,  że  drugi  koniec  potoku  wyjściowego jest zakończony lub do zachowania
       zasobów plikowych.

       Funkcja fflush(wyraż) wymiata plik wyjściowy lub potok skojarzony z wyraż.  Fflush  zwraca
       0  jeśli  wyraż  jest  otwartym strumieniem wyjściowym, w przeciwnym razie -1.  Fflush bez
       argumentu opróżnia stdout.  Fflush z pustym argumentem  ("")  opróżnia  wszystkie  otwarte
       wyjścia.

       Funkcja  system(wyraż)  wykorzystuje  /bin/sh  do wykonania wyraż i zwraca kod zakończenia
       polecenia wyraż.  Zmiany tablicy ENVIRON nie są przekazywane poleceniom wykonywanym  przez
       system lub potoki.

   10. Funkcje definiowane przez użytkownika
       Funkcja definiowana przez użytkownika ma następującą składnię:

           function nazwa( argumenty ) { instrukcje }

       Ciało funkcji może zawierać instrukcję zwrócenia wartości (return)

            return opcjonalne-wyraż

       Instrukcja  return  nie  jest  wymagana.   Wywołania  funkcji  mogą  być  zagnieżdżane lub
       rekurencyjne.  Wyrażenia przekazywane są funkcjom przez wartość a tablice przez wskazanie.
       Dodatkowe  argumenty  służą  jako  zmienne  lokalne i są inicjowane na null.  Na przykład,
       csplit(s,A) wstawia każdy znak s do tablicy A i zwraca długość s.

            function csplit(s, A,    n, i)
            {
              n = length(s)
              for( i = 1 ; i <= n ; i++ ) A[i] = substr(s, i, 1)
              return n
            }

       Wstawienie dodatkowych odstępów pomiędzy przekazywanymi parametrami a zmiennymi  lokalnymi
       wynika  z  konwencji.   Do funkcji można odwoływać się przed ich zdefiniowaniem, ale nazwa
       funkcji i nawias '(' rozpoczynający listę argumentów muszą się stykać, by uniknąć  pomyłki
       z konkatenacją.

   11. Podział łańcuchów, rekordów i plików
       Programy  awk  używają  tego samego algorytmu do rozbicia łańcuchów na tablice przy pomocy
       split() i rekordów na pola według FS.  mawk  stosuje  zasadniczo  ten  sam  algorytm  przy
       podziale plików na rekordy według RS.

       Split(wyraż,A,sep) działa następująco:

              (1)    Jeżeli  pominięto  sep,  to  jest  on  zastępowany  przez  FS.  Sep może być
                     wyrażeniem  lub  wyrażeniem  regularnym.   Jeżeli   jest   wyrażeniem   typu
                     nie-łańcuchowego, to jest przekształcane na łańcuch.

              (2)    Jeśli  sep = " " (pojedyncza spacja), to <ODSTĘP> jest obcinana z początku i
                     końca wyraż, a sep staje  się  <ODSTĘPEM>.   mawk  definiuje  <ODSTĘP>  jako
                     wyrażenie  regularne  /[ \t\n]+/.   W przeciwnym wypadku sep traktowany jest
                     jako wyrażenie regularne, z wyjątkiem tego,  że  metaznaki  dla  łańcucha  o
                     długości  1  są ignorowane, np.  split(x, A, "*") i split(x, A, /\*/) są tym
                     samym.

              (3)    Jeżeli wyraż nie jest łańcuchem, jest  przekształcane  na  łańcuch.   Jeżeli
                     wyraż  jest  wówczas  łańcuchem  pustym  "",  to  split()  zwraca 0 a A jest
                     ustawiane jako puste.  W przeciwnym  razie,  wszystkie  nienakładające  się,
                     niepuste  i  najdłuższe dopasowania sep w wyraż, dzielą wyraż na pola, które
                     wpisywane są do A.  Pola są umieszczane w A[1], A[2], ...,  A[n]  a  split()
                     zwraca  n, liczbę pól, równą liczbie dopasowań plus jeden.  Dane umieszczone
                     w A wyglądające na numeryczne otrzymują typ liczbowo-łańcuchowy.

       Podział rekordów na pola działa tak samo, z wyjątkiem tego, iż części wpisywane są do  $1,
       $2,..., $NF.  Jeżeli $0 jest puste, NF jest ustawiane na 0 a wszystkie $i na "".

       mawk  dzieli  pliki  na  rekordy  przy  pomocy  tego  samego algorytmu, ale z tą niewielką
       różnicą, iż RS jest faktycznie  ciągiem  kończącym  a  nie  separatorem.   (ORS  też  jest
       faktycznie ciągiem kończącym).

              Np.,  jeżeli  FS  = ":+" a $0 = "a::b:" , to NF = 3 a $1 = "a", $2 = "b" i $3 = "",
              ale jeżeli zawartością pliku wejściowego jest "a::b:", zaś RS = ":+",  to  istnieją
              dwa rekordy "a" i "b".

       RS = " " nie ma specjalnego znaczenia.

       Jeżeli  FS  =  "",  to  mawk rozbija rekord na pojedyncze znaki, i, podobnie split(s,A,"")
       umieszcza poszczególne znaki s w A.

   12. Rekordy wielowierszowe
       Ponieważ mawk interpretuje RS jako wyrażenie regularne, obsługa rekordów  wielowierszowych
       jest  łatwa.   Ustawienie  RS  =  "\n\n+", powoduje, że rekordy rozdzielane są co najmniej
       jednym pustym wierszem. Jeżeli FS = " " (domyślnie),  to  pojedyncze  znaki  nowej  linii,
       według  zasad  <ODSTĘPU>  powyżej,  stają  się odstępami a pojedyncze znaki nowej linii są
       separatorami pól.

              Na przykład, jeśli w pliku jest "a b\nc\n\n", RS = "\n\n+" a  FS  =  " ",  to  mamy
              jeden  rekord  "a b\nc" z trzema polami "a", "b" i "c".  Zmiana FS = "\n", daje dwa
              pola "a b" i "c"; zmieniając FS = "", otrzymujemy jedno pole identyczne jak rekord.

       Traktowanie wierszy ze spacjami lub tabulacjami jako pustych można uzyskać ustawiając RS =
       "\n([ \t]*\n)+".   W celu utrzymania zgodności z innymi implementacjami awk, ustawienie RS
       = "" daje te same wyniki, co  usunięcie  pustych  wierszy  z  początku  i  końca  pliku  i
       określanie  rekordów  tak,  jakby  RS  = "\n\n+".  Posix wymaga, by "\n" zawsze separowało
       rekordy gdy RS = "" niezależnie od wartości FS.  mawk nie obsługuje  tej  konwencji,  gdyż
       zdefiniowanie "\n" jako <ODSTĘPU> czyni ją zbędną.

       W  większości  przypadków  zmieniając RS w celu obsługi rekordów wielowierszowych, stosuje
       się też zmienione na "\n\n" ORS, aby na wyjściu zachować odstępy między rekordami.

   13. Wykonywanie programu
       Ta sekcja opisuje kolejność wykonywania programu.  Po pierwsze,  ARGC  ustawiane  jest  na
       całkowitą  liczbę  argumentów  wiersza  poleceń  przekazanych  do fazy wykonania programu.
       ARGV[0] ustawiane jest na nazwę interpretera AWK a ARGV[1] ...   ARGV[ARGC-1]  przechowuje
       pozostałe argumenty wiersza poleceń z wyjątkiem opcji i źródła programu.  Na przykład, dla

            mawk  -f  prog  v=1  A  t=hello  B

       ARGC  =  5  oraz  ARGV[0]  = "mawk", ARGV[1] = "v=1", ARGV[2] = "A", ARGV[3] = "t=hello" i
       ARGV[4] = "B".

       Następnie wykonywany jest kolejno  każdy  z  bloków  BEGIN.   Jeżeli  program  składa  się
       wyłącznie  z  bloków BEGIN, to na tym wykonywanie się kończy, w przeciwnym razie otwierany
       jest strumień wejściowy i  wykonywanie  jest  kontynuowane.   Jeżeli  ARGC  równa  się  1,
       strumień  wejściowy  ustawiany  jest  na  stdin,  w  przypadku  przeciwnym  w poszukiwaniu
       argumentu plikowego sprawdzane są argumenty wiersza poleceń ARGV[1] ...  ARGV[ARGC-1].

       Argumenty wiersza poleceń dzielą się na trzy grupy: argumenty plikowe, argumenty przypisań
       i łańcuchy puste "".  Przypisanie ma postać zmn=łańcuch.  Podczas sprawdzania ARGV[i] jako
       możliwego argumentu  plikowego,  jeśli  jest  ono  puste  to  jest  pomijane;  jeśli  jest
       argumentem  typu przypisania, odbywa się przypisanie wartości zmiennej zmn a i zmienia się
       na następny argument; w pozostałych  przypadkach  ARGV[i]  jest  otwierane  jako  wejście.
       Jeżeli  otwarcie  nie powiedzie się, wykonywanie programu jest kończone z kodem 2.  Jeżeli
       żaden z argumentów wiersza poleceń nie jest argumentem plikowym,  to  wejście  pochodzi  z
       stdin.  Getline w akcji BEGIN otwiera wejście.  "-" jako argument plikowy oznacza stdin.

       Po  otwarciu  strumienia  wejściowego każdy z rekordów wejścia sprawdzany jest z każdym ze
       wzorców, a jeśli pasuje, to wykonywana jest akcja skojarzona z danym wzorcem.   Wzorzec  w
       postaci  wyrażenia  pasuje jeśli jego wartością logiczną jest prawda (zobacz koniec sekcji
       2).  Wzorzec BEGIN zestawiany jest przed rozpoczęciem odczytu wejścia, zaś wzorzec END  po
       przeczytaniu  całego  wejścia.   Wzorzec  zakresu,  wyraż1,wyraż2, dopasowuje każdy rekord
       pomiędzy rekordem pasującym do wyraż1 a rekordem pasującym do wyraż2 łącznie z nimi.

       Po napotkaniu końca pliku w  strumieniu  wejściowym,  sprawdzane  są  pozostałe  argumenty
       wiersza  poleceń  w  poszukiwaniu  kolejnego argumentu plikowego.  Jeśli taki istnieje, to
       jest otwierany, w przeciwnym wypadku przyjmuje się, że został  dopasowany  wzorzec  END  i
       wykonywane są wszystkie akcje END.

       W  rozważanym  przykładzie,  przypisanie  v=1  ma miejsce po wykonaniu akcji BEGIN, a dana
       umieszczona w v otrzymuje typ liczbowo-łańcuchowy.   Następnie  z  pliku  A  jest  czytane
       wejście.   Po  końcu  pliku  A,  zmienna  t  jest  ustawiana  na łańcuch "hello", a B jest
       otwierany jako wejście.  Po osiągnięciu końca pliku B są wykonywane akcje wzorca END.

       Przebieg programu na poziomie wzorzec {akcja} można zmienić przy pomocy instrukcji

            next
            exit  wyraż-opcjonalne.

       Instrukcja next powoduje, że odczyt następnego rekordu wejściowego i  ponowne  sprawdzanie
       wzorców,   od   pierwszej   pary   wzorzec  {akcja}  programu.   Polecenie  exit  powoduje
       natychmiastowe wykonanie akcji END lub zakończenie programu, jeśli nie ma takich akcji lub
       jeżeli  exit  wystąpiło  w  akcji  END.  wyraż-opcjonalne ustawia wartość kodu zakończenia
       programu, chyba że zostanie ona przesłonięta przez późniejszy  exit  lub  ujawniony  potem
       błąd.

PRZYKŁADY

       1. emulacja cat.

            { print }

       2. emulacja wc.

            { chars += length($0) + 1  # dodaje jeden dla \n
              words += NF
            }

            END{ print NR, words, chars }

       3. zliczanie niepowtarzających się "faktycznych słów".

            BEGIN { FS = "[^A-Za-z]+" }

            { for(i = 1 ; i <= NF ; i++)  word[$i] = "" }

            END { delete word[""]
                  for ( i in word )  cnt++
                  print cnt
            }

       4. sumowanie drugiego pola każdego rekordu w oparciu o pierwsze pole.

            $1 ~ /credit|gain/ { sum += $2 }
            $1 ~ /debit|loss/  { sum -= $2 }

            END { print sum }

       5. sortowanie pliku, porównywanie łańcuchowe

            { line[NR] = $0 "" }  # wymusza typ porównywania: gdyby
                                  # jakieś wiersze wyglądały
                                  # na numeryczne

            END {  isort(line, NR)
              for(i = 1 ; i <= NR ; i++) print line[i]
            }

            #sortowanie A[1..n] metodą wstawiania
            function isort( A, n,   i, j, hold)
            {
              for( i = 2 ; i <= n ; i++)
              {
                hold = A[j = i]
                while ( A[j-1] > hold )
                { j-- ; A[j+1] = A[j] }
                A[j] = hold
              }
              # w razie potrzeby będzie utworzony wartownik A[0] = ""
            }

KWESTIE ZGODNOŚCI

       Posix-owa  1003.2 (propozycja 11.3) definicja języka AWK jest AWK opisanym w książce AWK z
       kilkoma rozszerzeniami, jakie pojawiły się w nawk z SystemVR4. Rozszerzeniami tymi są:

              Nowe funkcje: toupper() i tolower().

              Nowe zmienne: ENVIRON[] i CONVFMT.

              Specyfikacje konwersji w printf() i sprintf() wzięte z ANSI C.

              Nowe  opcje  polecenia:    -v   zmn=wartość,   wielokrotne   opcje   -f   i   opcje
              charakterystyczne dla implementacji jako argumenty -W.

       Posix-owy  AWK  przetwarza  pojedyncze  wiersze  plików.   RS można zmienić z "\n" na inny
       pojedynczy znak, ale trudno jest znaleźć jakieś tego zastosowanie —  w  książce  AWK  brak
       odpowiednich  przykładów.   Zgodnie  z  konwencją,  RS = "", powoduje, że jeden lub więcej
       pustych wierszy rozdziela rekordy, umożliwiając obsługę rekordów wielowierszowych.  Gdy RS
       = "", "\n" jest zawsze separatorem pól, niezależnie od wartości FS.

       mawk, z kolei, pozwala by RS było wyrażeniem regularnym.  Pojawiające się w rekordach "\n"
       jest traktowane jak odstęp, a FS zawsze określa pola.

       Pozbycie się paradygmatu operowania pojedynczym wierszem może uprościć niektóre programy i
       często poprawić wydajność. Na przykład, zmienieniony przykład 3 (zobacz powyżej),

            BEGIN { RS = "[^A-Za-z]+" }

            { word[ $0 ] = "" }

            END { delete  word[ "" ]
              for( i in word )  cnt++
              print cnt
            }

       zlicza  ilość  niepowtarzających  się  słów  przez traktowanie każdego słowa jako rekordu.
       Przy plikach średnich rozmiarów mawk wykonuje go dwukrotnie szybciej, dzięki  uproszczonej
       pętli wewnętrznej.

       Poniższy program zastępuje każdy z komentarzy w pliku programu C pojedynczą spacją,

            BEGIN {
              RS = "/\*([^*]|\*+[^/*])*\*+/"
                       # komentarz jest separatorem rekordów
              ORS = " "
              getline  hold
              }

              { print hold ; hold = $0 }

              END { printf "%s" , hold }

       Buforowanie rekordu jest niezbędne, by uniknąć zakończenia ostatniego z rekordów spacją.

       W mawk poniższe wyrażenia są równoważne,

            x ~ /a\+b/    x ~ "a\+b"     x ~ "a\\+b"

       Powyższe  łańcuchy  będą  analizowane  dwukrotnie:  raz  jako łańcuch i raz jako wyrażenie
       regularne. Przy analizie łańcucha mawk ignoruje stosowanie cytowania odwrotnym  ukośnikiem
       do  znaków  nie  będących  znakami  specjalnymi, zatem \c interpretuje jako \c.  Natomiast
       książka AWK przychyla się do tego, by \c było rozpoznawane jako c, co  wymaga  podwojonego
       cytowania   metaznaków  w  łańcuchach.   Posix  wprost  odmawia  zdefiniowania  pożądanego
       zachowania, przez co pośrednio wymusza na programach muszących działać z różnymi  wersjami
       awk stosowanie bardziej przenośnego, lecz mniej czytelnego, cytowania z użyciem podwójnych
       odwrotnych ukośników.

       Posix-owy AWK nie  rozpoznaje  "/dev/std{out,err}"  ani  sekwencji  specjalnej  \x  hex  w
       łańcuchach. W przeciwieństwie do ANSI C, mawk ogranicza liczbę cyfr, jakie mogą występować
       po \x do dwóch, gdyż obecna  implementacja  obsługuje  tylko  znaki  8-bitowe.   Wbudowane
       fflush  pojawiło  się po raz pierwszy w ostatnim (1993) awk AT&T wydanym dla netlib, i nie
       jest częścią standardu Posix. Całościowe usuwanie tablicy przez delete  tablica  nie  jest
       częścią standardu Posix.

       Posix  jawnie  zostawia  niezdefiniowane  zachowanie  się  FS  =  "" i wspomina o podziale
       rekordów na znaki jako możliwej interpretacji, ale obecnie  takie  zastosowanie  nie  jest
       przenośne między implementacjami.

       Na  koniec, sposób w jaki mawk obsługuje przypadki wyjątkowe nie opisane w książce AWK ani
       w propozycji Posix. Niebezpiecznie jest zakładanie spójności pomiędzy implementacjami awk,
       a bezpiecznie przejść do następnej sekcji.

              substr(s,  i,  n)  zwraca znaki łańcucha s o pozycjach z części wspólnej przedziału
              zamkniętego [1, length(s)] i półotwartego [i, i+n).  Gdy część wspólna jest  pusta,
              zwracany  jest łańcuch pusty; zatem substr("ABC", 1, 0) = "" a substr("ABC", -4, 6)
              = "A".

              Każdy łańcuch, nawet pusty, pasuje początkiem do łańcucha pustego, więc s ~ // i  s
              ~  "",  są  zawsze  równe  1,  tak  jak  match(s,  //) i match(s, "").  Ostanie dwa
              ustawiają RLENGTH na 0.

              index(s, t) jest zawsze tym samym, co match(s, t1), gdzie t1, to to samo,  co  t  z
              cytowanymi  metaznakami.  Stąd  spójność  z  match  wymaga,  by index(s, "") zawsze
              zwracało 1.  Również warunek: index(s,t) != 0 wtedy  i  tylko  wtedy,  gdy  t  jest
              podłańcuchem łańcucha s, wymusza by index("","") = 1.

              Jeżeli  getline napotka koniec pliku, getline zmn pozostawia zmienną zmn bez zmian.
              Podobnie, w momencie rozpoczęcia  akcji  END,  wartości  $0,  pól  i  NF  pozostają
              niezmienione od ostatniego rekordu.

ZOBACZ TAKŻE

       egrep(1)

       Aho,  Kernighan  and  Weinberger, The AWK Programming Language, Addison-Wesley Publishing,
       1988, (książka AWK), definiuje język, rozpoczynając się samouczkiem a dochodząc  do  wielu
       interesujących  programów  i  wchodząc głęboko w kwestie projektowania i analizy programów
       istotne przy programowaniu w każdym języku.

       The GAWK Manual, The Free Software Foundation, 1991, stanowi podręcznik i opis języka  nie
       usiłujący  sięgnąć  głębi  książki  AWK.  Zakłada,  że  czytelnik  może  być początkującym
       programistą. Sekcja poświęcona tablicom w  AWK  jest  doskonała.  Omawia  także  wymagania
       stawiane AWK przez Posix.

BŁĘDY

       mawk  nie  obsługuje  znaku  ascii  NUL \0 w plikach źródłowych czy plikach danych.  Można
       wypisać NUL przy pomocy printf z %c, a w wejściu  są  dopuszczalne  wszystkie  inne  znaki
       8-bitowe.

       mawk  implementuje  printf()  i  sprintf()  przy pomocy funkcji bibliotecznych C, printf i
       sprintf, więc pełna zgodność z ANSI wymaga biblioteki ANSI C.  W praktyce oznacza  to,  że
       kwalifikator  konwersji  h  może nie być dostępny.  mawk przejmuje też wszystkie błędy czy
       ograniczenia tych funkcji.

       Twórcy implementacji języka AWK ukazali zgodny brak wyobraźni w nazywaniu swych programów.

AUTOR

       Mike Brennan (brennan@whidbey.com).

INFORMACJE O TŁUMACZENIU

       Powyższe tłumaczenie pochodzi z nieistniejącego już Projektu Tłumaczenia  Manuali  i  może
       nie  być  aktualne.  W  razie  zauważenia  różnic  między  powyższym opisem a rzeczywistym
       zachowaniem opisywanego programu lub  funkcji,  prosimy  o  zapoznanie  się  z  oryginalną
       (angielską) wersją strony podręcznika za pomocą polecenia:

              man --locale=C 1 mawk

       Prosimy  o  pomoc  w  aktualizacji stron man - więcej informacji można znaleźć pod adresem
       http://sourceforge.net/projects/manpages-pl/.