Provided by: manpages-pl_20060617-3_all bug

NAZWA

       perlsyn - Skladnia perla

OPIS

       Skrypt perla sklada si z sekwencji deklaracji i instrukcji. Jedynymi
       rzeczami, ktore musz by zadeklarowane w perlu, to formatki raportowe i
       procedury. Wicej informacji o tych deklaracji znajdziesz w sekcjach
       poniej. Wszystkie niezainicjalizowane, stworzone przez uytkownika
       obiekty, uznawane s za posiadajce pocztkow warto null lub 0, dopoki nie
       zostan zdefiniowane w jakiej jawnej operacji, jak np. przypisanie. (Cho
       jeli chcesz, moesz dostawa ostrzeenia o uywaniu wartoci
       niezdefiniowanych.) Sekwencja instrukcji jest wykonywana tylko
       jednokrotnie, w przeciwiestwie do skryptow sed(1) czy awk(1), gdzie
       sekwencja taka jest wykonywana dla kadej linii wejciowej. Oznacza to, e
       musisz jawnie przetwarza w ptli linie swojego pliku wejciowego (lub
       plikow), oznacza to te, e masz duo wiksz kontrol nad tym, ktorymi
       plikami i liniami si zajmujesz.  (Wlaciwie to klami--mona zrobi niejawn
       ptl za pomoc przelcznika -n lub -p. Nie jest to po prostu domylne i
       zarazem obowizkowe jak w sed(1) czy awk(1).)

       Deklaracje

       Perl jest w ogolnoci jzykiem wolnej postaci (free-form). (Jedynym
       wyjtkiem s deklaracj formatek--z oczywistych przyczyn.) Komentarze s
       rozpoczynane znakiem "#" i cign si do koca linii.  Jeli sprobujesz uy
       komentarzy /* */ w stylu C, to zostan one zinterpretowane albo jako
       dzielenie, albo jako porownywanie wzorca. Z kolei komentarz // z C++
       wyglda dokladnie jak puste wyraenie regularne.  Nie kombinuj wic z tymi
       konstrukcjami.

       Deklaracja moe by wstawiona gdziekolwiek, gdzie mona wstawi instrukcj,
       lecz nie ma wplywu na wykonywanie podstawowej sekwencji
       instrukcji--deklaracje maj znaczenie tylko podczas kompilacji.
       Zazwyczaj wszystkie deklaracje wstawiane s na pocztku lub na kocu
       skryptu. Jeli jednak uywasz zmiennych prywatnych zawonych leksykalnie,
       utworzonych przez my(), bdziesz musial si upewni, czy twoja definicja
       formatki lub procedury, uywajcej tych deklaracji ley wewntrz tego
       samego zakresu.

       Deklarowanie procedury zezwala na uywanie jej nazwy tak, jakby byla
       operatorem listowym, liczc od tego miejsca, a do koca programu. Moesz
       zadeklarowa procedur bez jej definiowania, piszc sub name, wic:

           sub myname;
           $me = myname $0             or die "can't get myname";

       Zauwa, e dziala to jak operator listowy, a nie jak jednoargumentowy;
       uwaaj wic i uywaj or zamiast ||. Jednak jeli zadeklarowalby procedur
       jako sub myname ($), to myname funkcjonowaloby jak operator
       jednoargumentowy, wic dzialalyby zarowno or jak i ||.

       Deklaracje procedur mog by rownie ladowane instrukcj require, lub
       jednoczenie ladowane jak i importowane do przestrzeni nazw dziki
       instrukcji use. Dla szczegolow polecam podrcznik perlmod(1).

       Sekwencja instrukcji moe zawiera deklaracje zmiennych zawonych
       leksykalnie, lecz poza deklarowaniem nazwy zmiennej, deklaracja dziala
       jak zwykla instrukcja i jest wykonywana w sekwencji instrukcji jak
       zwyczajna instrukcja. Znaczy to, e ma ona zarowno skutki podczas
       kompilacji, jak w czasie dzialania.

       Instrukcje proste

       Jedynym rodzajem instrukcji prostej jest wyraenie, analizowane dla
       swoich efektow ubocznych. Kada instrukcja prosta musi si koczy
       rednikiem, chyba e jest ostatni instrukcj bloku, wtedy rednik nie jest
       obowizujcy. (Jednak wci jest zalecany jeli blok zajmuje wicej ni jedn
       lini, gdy moliwe e dodasz jeszcze kolejne linie.)  Zauwa, e istniej
       operatory takie, jak eval {} i do {}, ktore wygldaj jak instrukcje
       zloone, lecz nimi nie s i wymagaj jawnego zakoczenia jeli s uyte jako
       ostatni element instrukcji.

       Za kad prost instrukcj, tu przed rednikiem (lub kocem bloku) moe
       znajdowa si POJEDYNCZY modyfikator. Dopuszczalne modyfikatory to:

           if WYRA
           unless WYRA
           while WYRA
           until WYRA
           foreach WYRA

       Modyfikatory if i unless maj semantyk zgodn z oczekiwaniami (jeeli i
       chyba e). Modyfikator foreach jest iteratorem: dla kadej wartoci w WYRA
       przypisuje jej nazw zastpcz $_ i wykonuje instrukcj. Modyfikatory while
       i until rownie maj typow semantyk ptli while (warunek jest analizowany
       najpierw). Wyjtkiem jest poprzedzenie tych modyfikatorow konstrukcj do-
       BLOK - wowczas blok jest wykonywany raz przed sprawdzeniem warunku.
       Dziki temu moesz tworzy ptle w rodzaju:

           do {
               $line = <STDIN>;
               ...
           } until $line  eq ".\n";

       Zobacz opis do w podrczniku perlfunc. Zauwa te, e opisane poniej
       instrukcje kontroli ptli NIE bd dzialaly w tej konstrukcji, gdy
       modyfikatory nie pobieraj etykiet ptli. Przykro mi.  Moesz zawsze
       umieci wewntrz inny blok (dla WnextfR) lub te umieci swoj instrukcj
       wewntrz bloku (dla last), aby zrobi co takiego.  W przypadku next po
       prostu podwoj nawiasy:

          do {{
             next if $x == $y;
             # co tu robi
          }} until $x++ > $z;

       Dla next musisz si bardziej rozpisa:

          LOOP: {
                  do {
                     last if $x = $y**2;
                     # co tu robi
                  } while $x++ <= $z;
          }

       Instrukcje z/l/loone

       W perlu, sekwencja instrukcji definiujca zakres nazywana jest blokiem.
       Czasami ograniczeniem bloku stanowi zawierajcy go plik (w wypadku
       wymaganego (required) pliku lub programu jako caloci), a czasami zasig
       lacucha znakowego (w wypadku eval).

       Lecz ogolnie, blok jest ograniczony nawiasami klamrowymi. Tak
       konstrukcj syntaktyczn nazwiemy BLOKIEM.

       Do kontroli przeplywu mona uywa nastpujcych instrukcji zloonych:

           if (WYRA) BLOK
           if (WYRA) BLOK else BLOK
           if (WYRA) BLOK elsif (WYRA) BLOK ... else BLOK
           ETYKIETA while (WYRA) BLOK
           ETYKIETA while (WYRA) BLOK continue BLOK
           ETYKIETA for (WYRA; WYRA; WYRA) BLOK
           ETYKIETA foreach VAR (LISTA) BLOK
           ETYKIETA BLOK continue BLOK

       Zauwa, e w przeciwiestwie do C i Pacala, s one zdefiniowane w
       kategoriach BLOKOW, a nie instrukcji. Znaczy to, e nawiasy klamrowe s
       niezbdne--wiszce instrukcje nie s dozwolone. Jeli chcesz pisa warunki
       bez nawiasow, to s na to inne sposoby. Nastpujce przyklady robi
       wszystkie to samo:

           if (!open(FOO)) { die "Can't open $FOO: $!"; }
           die "Can't open $FOO: $!" unless open(FOO);
           open(FOO) or die "Can't open $FOO: $!";     # FOO lub gi!
           open(FOO) ? 'hi mom' : die "Can't open $FOO: $!";
                               # to ostatnie troch egzotyczne

       Instrukcja if jest nieskomplikowana. Poniewa BLOKI s zawsze ograniczone
       nawiasami klamrowymi, nigdy nie ma niejednoznacznoci co do tego, do
       ktorego if przynaley dany else.  Jeli zamiast if uywasz unless, sens
       testu jest odwrocony.

       Instrukcja while wykonuje swoj blok tak dlugo, jak wyraenie jest
       prawdziwe (jego wartoci nie jest lacuch pusty, 0 czy "0").  ETYKIETA
       jest opcjonalna, a jeli jest obecna, sklada si z identyfikatora, za
       ktorym nastpuje dwukropek. ETYKIETA identyfikuje ptl dla instrukcji
       kontroli ptli, czyli next, last i redo.  Jeli pominito ETYKIET,
       instrukcje kontroli ptli odnosz si do najbardziej wewntrznej otaczajcej
       ptli. Moe to wymaga dynamicznego przegldania wstecz stosu wywola w
       czasie wykonania, aby znale odpowiedni ETYKIET.  Takie desperackie
       zachowania daj zwykle ostrzeenia przy wlczonej fladze -w.

       Jeli istnieje BLOK continue, to jest on zawsze wykonywany tu przed
       kolejn analiz warunku, podobnie jak trzeci element ptli for w C. Mona
       tego uywa do zwikszania zmiennej sterujcej ptli, nawet gdy ptla jest
       wlanie kontynuowana instrukcj next (ktora jest z kolei podobna do
       instrukcji continue z C).

       Kontrola ptli

       Polecenie next jest podobne do instrukcji continue z C; rozpoczyna now
       iteracj ptli:

           LINE: while (<STDIN>) {
               next LINE if /^#/;      # wykasuj komentarze
               ...
           }

       Polecenie last jest podobne do instrukcji break z C (uywanej w ptlach);
       natychmiastowo opuszcza ptl. Blok continue nie jest wykonywany:

           LINE: while (<STDIN>) {
               last LINE if /^$/;      # zakocz po obslueniu naglowka
               ...
           }

       Polecenie redo restartuje ptl bez ponownego analizowania warunku.  Blok
       continue nie jest wykonywany. Polecenie to jest zazwyczaj uywane w
       programach, ktore chc si oklamywa co do tego, co wlanie pobraly z
       wejcia.

       Na przyklad, podczas przetwarzania pliku takiego, jak /etc/termcap.
       Jeli twoje wiersze wejciowe mog si koczy lewymi ukonikami, wskazujcymi
       kontynuacj, moesz chcie z wyprzedzeniem pobra nastpny rekord.

           while (<>) {
               chomp;
               if (s/\\$//) {
                   $_ .= <>;
                   redo unless eof();
               }
               # teraz przetworz $_
           }

       co w perlu jest skrotem dla wersji napisanej bardziej doslownie:

           LINE: while (defined($line = <ARGV>)) {
               chomp($line);
               if ($line =~ s/\\$//) {
                   $line .= <ARGV>;
                   redo LINE unless eof(); # nie eof(ARGV)!
               }
               # teraz przetworz $line
           }

       A tu mamy prosty striptizer komentarzy Pascalowych (uwaga: zaklada brak
       { lub } w lacuchach).

           LINE: while (<STDIN>) {
               while (s|({.*}.*){.*}|$1 |) {}
               s|{.*}| |;
               if (s|{.*| |) {
                   $front = $_;
                   while (<STDIN>) {
                       if (/}/) {      # koniec komentarza?
                           s|^|$front{|;
                           redo LINE;
                       }
                   }
               }
               print;
           }

       Zauwa, e jeli w powyszym kodzie istnialby blok continue, zostal by on
       wywolany nawet dla usunitych wierszy. Blok ten jest czsto uywany do
       resetowania licznikow wierszy czy jednokrotnych dopasowa ?wzorcow?.

           # zainspirowane przez :1,$g/fred/s//WILMA/
           while (<>) {
              ?(fred)?     && s//WILMA $1 WILMA/;
              ?(barney)?   && s//BETTY $1 BETTY/;
              ?(homer)?    && s//MARGE $1 MARGE/;
           } continue {
              print "$ARGV $.: $_";
              close ARGV   if eof();    # reset $. (nr wiersza)
              reset        if eof();    # reset ?wzorca?
           }

       Jeli slowo while jest zamieniane slowem until, to sens testu jest
       odwrocony, lecz warunek jest wci testowany w pierwszej iteracji.

       Instrukcje sterujce ptli nie wspolpracuj z if ani unless, gdy nie s one
       ptlami. Moesz jednak podwoi nawiasy by je nimi uczyni.

           if (/wzorzec/) {{
              next if /fred/;
              next if /barney/;
              # co tu robi
           }}

       Posta while/if BLOCK BLOCK, ktora byla dostpna w Perl 4 nie jest ju
       prawidlowa. Zmie wszystkie wystpienia if BLOCK na if (do BLOCK).

       Ptle for

       Perlowa ptla for w stylu C, dziala dokladnie jak odpowiadajca jej ptla
       while, co znaczy, e to:

           for ($i = 1; $i < 10; $i++) {
               ...
           }

       jest tym samym, co to:

           $i = 1;
           while ($i < 10) {
               ...
           } continue {
               $i++;
           }

       (Jest jedna drobna ronica: pierwsza posta wymusza zawenie leksykalne
       dla zmiennych zadeklarowanych przez my w wyraeniu inicjalizacji.)

       Poza zwyklymi ptlami po indeksach tablic, for daje wiele innych
       zastosowa. Oto przyklad, zapobiegajcy problemowi, ktory napotyka si
       testujc jawnie EOF na interaktywnym deskryptorze pliku, co powoduje, e
       program wyglda jakby si zawiesil.

           $on_a_tty = -t STDIN && -t STDOUT;
           sub prompt { print "yes? " if $on_a_tty }
           for ( prompt(); <STDIN>; prompt() ) {
               # zrob co
           }

       Ptle foreach

       Ptla foreach iteruje poprzez normaln warto listow i przypisuje zmiennej
       VAR warto kadego kolejnego elementu listy. Jeli zmienna jest
       poprzedzona slowem kluczowym my, to jest ona leksykalnie zawona i
       widzialna tylko wewntrz ptli. W przeciwnym wypadku, zmienna jest
       niejawnie lokalna w ptli i, po wyjciu z niej, odzyskuje pierwotn warto.
       Jeli zmienna byla poprzednio zadeklarowana przez my, to ptla uywa tej
       zmiennej, zamiast zmiennej globalnej, lecz wci jest ona lokalna w
       obrbie ptli. (Zauwa, e zmienne o zasigu leksykalnym mog by przyczyn
       klopotow, jeli wewntrz ptli masz odwolujce si do nich procedury lub
       deklaracje formatow.)

       Slowo kluczowe foreach jest w rzeczywistoci synonimem slowa for, wic
       foreach moesz uywa dla czytelnoci, a for dla skrocenia. (Albo te
       powloka Bourne'a jest Ci milsza ni csh, wic pisanie for jest
       naturalniejsze.)  Jeli VAR jest pominite, na kolejne wartoci ustawiane
       bdzie $_.  Jeli dowolny element LISTY jest lwartoci, to moesz latwo
       modyfikowa jego warto, modyfikujc VAR wewntrz ptli. Jest tak dlatego, e
       zmienna indeksu ptli foreach jest niejawnym synonimem kadego
       iterowanego elementu.  W szczegolnoci moliwa jest zmiana tym sposobem
       wartoci elementow tablicy LISTA (ale nie wyraenia zwracajcego LIST).

       Jeli dowolna cz LISTY jest tablic, to foreach bardzo si zmiesza, jeli
       wewntrz ptli dodasz lub usuniesz elementy, na przyklad przy pomocy
       splice. Nie rob wic tego.

       foreach prawdopodobnie nie zrobi tego, czego oczekujesz, jeli VAR jest
       zmienn specjaln. Tego te nie rob.

       Przyklady:

           for (@ary) { s/foo/bar/ }

           foreach my $elem (@elements) {
               $elem *= 2;
           }

           for $count (10,9,8,7,6,5,4,3,2,1,'BOOM') {
               print $count, "\n"; sleep(1);
           }

           for (1..15) { print "Merry Christmas\n"; }

           foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) {
               print "Item: $item\n";
           }

       Oto, jak programista C moglby zakodowa szczegolny algorytm w perlu:

           for (my $i = 0; $i < @ary1; $i++) {
               for (my $j = 0; $j < @ary2; $j++) {
                   if ($ary1[$i] > $ary2[$j]) {
                       last; # nie mog wyj do zewntrznej :-(
                   }
                   $ary1[$i] += $ary2[$j];
               }
               # tu zabiera mnie last
           }

       Podczas gdy programista perla moglby zrobi to wygodniej:

           OUTER: foreach my $wid (@ary1) {
           INNER:   foreach my $jet (@ary2) {
                       next OUTER if $wid > $jet;
                       $wid += $jet;
                    }
                 }

       Widzisz jakie to proste? Czystsze, bezpieczniejsze i szybsze. Jest
       czystsze, bo mniej tu zamieszania. Jest bezpieczniejsze, bo jeli midzy
       wewntrzn, a zewntrzn ptl zostanie poniej dodany kod, to nie bdzie on
       przypadkiem wykonywany. next jawnie iteruje inn ptl zamiast przerywania
       wewntrznej. Jest to szybsze, gdy perl wywoluje instrukcje foreach
       szybciej ni rownowanik z ptl for.

       Podstawowe instrukcje BLOKOWE i switch

       BLOK (z etykiet lub bez) jest rownowany ptli, ktora jest wykonywana
       jeden raz. Tak wic moesz wewntrz uywa instrukcji kontroli ptli by wyj z
       bloku lub ponowi jego wykonanie.  (Zauwa, e nie jest to prawd wewntrz
       eval{}, sub{} czy, przeciwnie do rozpowszchnionych przekona, blokow
       do{}, ktore nie zaliczaj si do ptli.) Blok continue jest opcjonalny.

       Konstrukcja BLOKU jest szczegolnie wygodna do tworzenia struktur wyboru
       (case).

           SWITCH: {
               if (/^abc/) { $abc = 1; last SWITCH; }
               if (/^def/) { $def = 1; last SWITCH; }
               if (/^xyz/) { $xyz = 1; last SWITCH; }
               $nothing = 1;
           }

       W perlu nie ma oficjalnej instrukcji switch, gdy istnieje ju kilka
       sposobow na wykonanie jej rownowanika. Oprocz, moglby napisa

           SWITCH: {
               $abc = 1, last SWITCH  if /^abc/;
               $def = 1, last SWITCH  if /^def/;
               $xyz = 1, last SWITCH  if /^xyz/;
               $nothing = 1;
           }

       (W rzeczywistoci nie jest to tak dziwne jak wyglda. Musisz sobie
       uwiadomi, e moesz  korzysta z "operatorow" kontroli ptli wewntrz wyrae.
       Jest to zwyczajny operator przecinka z C.)

       lub

           SWITCH: {
               /^abc/ && do { $abc = 1; last SWITCH; };
               /^def/ && do { $def = 1; last SWITCH; };
               /^xyz/ && do { $xyz = 1; last SWITCH; };
               $nothing = 1;
           }

       lub sformatowane w taki sposob, e wyglda bardziej na "poprawn"
       instrukcj switch:

           SWITCH: {
               /^abc/      && do {
                                   $abc = 1;
                                   last SWITCH;
                              };

               /^def/      && do {
                                   $def = 1;
                                   last SWITCH;
                              };

               /^xyz/      && do {
                                   $xyz = 1;
                                   last SWITCH;
                               };
               $nothing = 1;
           }

       lub

           SWITCH: {
               /^abc/ and $abc = 1, last SWITCH;
               /^def/ and $def = 1, last SWITCH;
               /^xyz/ and $xyz = 1, last SWITCH;
               $nothing = 1;
           }

       lub nawet straszliwe

           if (/^abc/)
               { $abc = 1 }
           elsif (/^def/)
               { $def = 1 }
           elsif (/^xyz/)
               { $xyz = 1 }
           else
               { $nothing = 1 }

       Popularnym idiomem instrukcji switch jest wykorzystanie tworzonego
       przez foreach synonimu. Uzyskane tymczasowe przypisanie do zmiennej $_
       umoliwia wygodne dopasowywanie:

           SWITCH: for ($where) {
                       /In Card Names/     && do { push @flags, '-e'; last; };
                       /Anywhere/          && do { push @flags, '-h'; last; };
                       /In Rulings/        && do {                    last; };
                       die "unknown value for form variable where: `$where'";
                   }

       Innym interesujcym podejciem do instrukcji switch jest rozplanowanie
       bloku do tak, by zwracal wlaciw warto:

           $amode = do {
               if     ($flag & O_RDONLY) { "r" }
               elsif  ($flag & O_WRONLY) { ($flag & O_APPEND) ? "a" : "w" }
               elsif  ($flag & O_RDWR)   {
                   if ($flag & O_CREAT)  { "w+" }
                   else                  { ($flag & O_APPEND) ? "a+" : "r+" }
               }
           };

       lub te

               print do {
                   ($flags & O_WRONLY) ? "write-only"          :
                   ($flags & O_RDWR)   ? "read-write"          :
                                         "read-only";
               };

       albo, jeli jeste pewien, e wszystkie klauzule && s prawdziwe, moesz
       posluy si czym podobnym, co "przelcza" w zalenoci od wartoci zmiennej
       rodowiska HTTP_USER_AGENT.

           #!/usr/bin/perl
           # dobierz plik ze stron argonu wedlug przegldarki
           $dir = 'http://www.wins.uva.nl/~mes/jargon';
           for ($ENV{HTTP_USER_AGENT}) {
               $page  =    /Mac/            && 'm/Macintrash.html'
                        || /Win(dows )?NT/  && 'e/evilandrude.html'
                        || /Win|MSIE|WebTV/ && 'm/MicroslothWindows.html'
                        || /Linux/          && 'l/Linux.html'
                        || /HP-UX/          && 'h/HP-SUX.html'
                        || /SunOS/          && 's/ScumOS.html'
                        ||                     'a/AppendixB.html';
           }
           print "Location: $dir/$page\015\012\015\012";

       Ten rodzaj instrukcji switch dziala tylko, gdy wiesz, e klauzule && bd
       prawdziwe. Jeli nie, to powinien by uyty poprzedni przyklad z ?:.

       Moesz take rozway napisanie hasza (tablicy asocjacyjnej) zamiast
       syntezowania instrukcji switch.

       Goto

       Perl obsluguje instrukcj goto. ETYKIETA ptli nie jest w rzeczywistoci
       prawidlowym celem goto; jest tylko nazw ptli.  Istniej trzy postacie:
       goto-ETYKIETA, goto-WYRA i goto-&NAZWA.

       Posta goto-ETYKIETA szuka instrukcji oznaczonej ETYKIET i kontynuuje
       wykonywanie w tym miejscu. Nie moe by uywana do wchodzenia do wntrza
       konstrukcji, ktore wymagaj inicjalizacji, takich jak procedury lub ptle
       foreach. Nie moe te by uywana do wchodzenia do konstrukcji, ktore s w
       jaki sposob optymalizowane. Moe by uywane do wchodzenia prawie we
       wszystkie inne miejsca w zakresie dynamicznym, lcznie z wychodzeniem z
       procedur, lecz zwykle lepiej jest uy konstrukcji takiej jak last lub
       die. Autor Perla nigdy nie czul potrzeby uywania tej postaci goto (w
       Perlu--C to inna sprawa).

       Posta goto-WYRA oczekuje nazwy etykiety, ktorej zakres zostanie
       rozwizany dynamicznie. Umoliwia to stosowanie wyliczanych goto jak w
       FORTRANie, lecz nie jest zbyt zalecane jeli optymalizujesz z uwagi na
       konserwacj programu:

           goto ("FOO", "BAR", "GLARCH")[$i];

       Posta goto-&NAZWA jest bardzo magiczna i podstawia wywolanie do
       nazwanej procedury za biec procedur. Jest to uywane przez procedury
       AUTOLOAD(), ktore chc ladowa inne procedury, a potem udawa, e inna
       procedura zostala wywolana jako pierwsza (poza tym, e wszelkie
       modyfikacje @_ w biecej procedurrze s przenoszone do tej innej
       procedury.) Po takim goto, nawet caller() nie bdzie w stanie powiedzie,
       e ta procedura zostala wywolana pierwsza.

       W wikszoci tego typu przypadkow, zazwyczaj duo, duo lepszym pomyslem
       jest uywanie strukturalnych mechanizmow kontroli przeplywu next, last
       lub redo, zamiast zwraca si ku goto.  Dla niektorych zastosowa, para
       eval{} i die(), sluca do przetwarzania wyjtkow moe by te rozsdnym
       wyjciem.

       POD: Osadzona dokumentacja

       Perl posiada mechanizm lczenia dokumentacji z kodem rodlowym.  Podczas
       oczekiwania pocztku nowej instrukcji, jeli kompilator natrafi na lini,
       rozpoczynajc si od znaku rownoci i slowa, jak

           =head1 Here There Be Pods!

       To ten tekst, oraz reszta napisow, a do linii, rozpoczynajcej si od
       =cut wlcznie zostan zignorowane. Format tekstu wtrconego jest opisany w
       podrczniku perlpod(1).

       Umoliwia ci to lczenie kodu rodlowego i dokumentacji, jak w

           =item snazzle($)

           Funkcja snazzle() bdzie zachowywa si w najbardziej spektakularny
           sposob, jaki moesz sobie wyobrazi, przecigajc nawet cyber
           pirotechnik.

           =cut powrot do kompilatora, fora z tego pod-fora!

           sub snazzle($) {
               my $thingie = shift;
               .........
           }

       Zauwa, e translatory pod powinny patrze tylko na akapity, rozpoczynajce
       si od dyrektywy pod (ulatwia to przetwarzanie), podczas gdy kompilator
       wie, e ma szuka sekwencji specjalnych pod nawet w rodku akapitu. Znaczy
       to, e nastpujcy tajny tekst bdzie ignorowany zarowno przez kompilator,
       jak i przez translatory.

           $a=3;
           =tajne rzeczy
            warn "Ani POD ani KOD!?"
           =cut powrot
           print "got $a\n";

       Prawdopodobnie nie powiniene opiera si na warn(), "wypodowanym" na
       zawsze. Nie wszystkie translatory zachowuj si w tym momencie dobrze i
       by moe kompilator stanie si wybredniejszy.

       Dyrektyw pod mona te uywa do szybkiego wykomentowania sekcji kodu.

       Plain Old Comments (Nie!)

       Podobnie jak preprocesor C, perl moe przetwarza dyrektywy liniowe. Przy
       ich uyciu, mona kontrolowa perlowe pojcie nazw plikow i numerow linii w
       komunikatach o bldach/ostrzeeniach (szczegolnie dla lacuchow, ktore s
       przetwarzane z eval()). Skladnia tego mechanizmu jest taka sama dla jak
       dla wikszoci preprocesorow C: dopasowuje wyraenie regularne
       /^#\s*line\s+(\d+)\s*(?:\s"([^"]*)")?/ do $1, bdcego numerem linii i
       $2, bdcego opcjonaln nazw pliku (podan w cudzyslowach).

       Oto niektore przyklady, ktore moesz sprawdzi w swojej powloce:

           % perl
           # line 200 "bzzzt"
           # znak `#' w poprzedniej linii musi by pierwszym znakiem linii
           die 'foo';
           __END__
           foo at bzzzt line 201.

           % perl
           # line 200 "bzzzt"
           eval qq[\n#line 2001 ""\ndie 'foo']; print $@;
           __END__
           foo at - line 2001.

           % perl
           eval qq[\n#line 200 "foo bar"\ndie 'foo']; print $@;
           __END__
           foo at foo bar line 200.

           % perl
           # line 345 "goop"
           eval "\n#line " . __LINE__ . ' "' . __FILE__ ."\"\ndie 'foo'";
           print $@;
           __END__
           foo at goop line 345.

INFORMACJE O T/L/LUMACZENIU

       Powysze tlumaczenie pochodzi z nieistniejcego ju Projektu Tlumaczenia
       Manuali i moe nie by aktualne. W razie zauwaenia ronic midzy powyszym
       opisem a rzeczywistym zachowaniem opisywanego programu lub funkcji,
       prosimy o zapoznanie si z oryginaln (angielsk) wersj strony podrcznika.