PDL::Internalsp - Online w chmurze

PROGRAM:

IMIĘ

PDL::Internals - opis niektórych aspektów obecnych wnętrz

OPIS

Intro
W tym dokumencie wyjaśniono różne aspekty obecnej implementacji języka PDL. Jeśli tylko
chcesz do czegoś używać języka PDL, zdecydowanie nie musisz tego czytać. Nawet jeśli chcesz
aby połączyć procedury C z PDL lub utworzyć nowe funkcje PDL::PP, nie musisz tego robić
przeczytaj tę stronę podręcznika (choć może ona mieć charakter informacyjny). Niniejszy dokument jest przeznaczony przede wszystkim dla
osoby zainteresowane debugowaniem lub zmianą elementów wewnętrznych PDL. Dobrze to przeczytać
ogólne zrozumienie języka C oraz programowania i struktur danych
wymagane, a także znajomość języka Perl. Jeśli przeczytasz ten dokument i
rozumieją to wszystko i są w stanie wskazać, do czego odnosi się jakakolwiek część tego dokumentu w
Jeśli masz podstawowe źródła PDL i dodatkowo masz trudności ze zrozumieniem PDL::PP, otrzymasz nagrodę
tytuł „PDL Guru” (oczywiście aktualna wersja tego dokumentu jest na tyle niekompletna, że
na podstawie tych notatek jest to prawie niemożliwe).

Ostrzeżenie: Jeśli wydaje Ci się, że ten dokument stał się nieaktualny, prosimy o poinformowanie PDL
lista e-mailowa tragarzy ([email chroniony]). To może się zdarzyć.

Piddles
Obiekt danych pdl jest ogólnie nieprzezroczystym odwołaniem skalarnym do struktury pdl w
pamięć. Alternatywnie może to być odwołanie do skrótu z polem „PDL” zawierającym
odwołanie skalarne (dzięki temu przeciążanie piddle'ów jest łatwe, zobacz PDL::Objects). Możesz z łatwością
dowiedz się na poziomie Perla, z jakim typem piddle'a masz do czynienia. Przykładowy kod
poniżej pokazuje, jak to zrobić:

# sprawdź, czy to kałuża
umrzyj „nie piddle”, chyba że UNIVERSAL::isa($pdl, 'PDL');
# czy jest to ref skalarny czy hash ref?
if (UNIVERSAL::isa($pdl, "HASH")) {
umrzyj „nieprawidłowy PDL”, chyba że istnieje $pdl->{PDL} &&
UNIWERSALNY::isa($pdl->{PDL},'PDL');
print „To jest odwołanie do skrótu”,
" pole PDL zawiera odnośnik skalarny\n";
} Else {
print "To jest odwołanie skalarne wskazujące adres $$pdl w pamięci\n";
}

Odniesienie skalarne wskazuje na adres numeryczny struktury C typu „pdl”, czyli
zdefiniowane w pdl.h. Mapowanie pomiędzy obiektem na poziomie Perla i strukturą C
zawierający rzeczywiste dane i strukturę tworzącą piddle jest wykonywany przez PDL
mapa maszynowa. Funkcje używane w mapie typów PDL są zdefiniowane w zasadzie na górze pliku
filet pdlcore.h. Jak zatem wygląda struktura:

struktura pdl {
bez znaku długi magicno; /* Zawsze przechowuje PDL_MAGICNO jako kontrolę poprawności */
/* To jest pierwsze, dlatego przechwytywana jest większość dostępów do wskaźników do niewłaściwego typu */
stan int; /* Co jest w tym pdl */

pdl_trans *trans; /* Nieprzezroczysty wskaźnik do elementów wewnętrznych transformacji z
rodzic */

pdl_vaffine *vafftrans;

nieważne* sv; /* (opcjonalnie) wskaźnik z powrotem do oryginalnego sv.
ZAWSZE przed użyciem sprawdź, czy nie ma wartości null.
Nie możemy się nad tym zastanowić, bo inaczej to zrobimy
nigdy nie daj się zniszczyć */

nieważne *datasv; /* Wskaźnik do SV zawierającego dane. Refleksja ze wzruszeniem */
puste *dane; /* Null: brak przydzielonych danych dla tego */
PDL_Indx nvals; /* Ile przydzielonych wartości */
int typ danych;
PDL_Indx *przyciemnia; /* Tablica wymiarów danych */
PDL_Indx *diminki; /* Tablica domyślnych przyrostów danych */
krótkie przyciemnienia; /* Liczba wymiarów danych */

unsigned char *threadids; /* Indeks początkowy zestawu indeksów wątku n */
niepodpisane char nthreadids;

pdl *progenitor; /* Jestem w zmutowanej rodzinie. make_physical_now musi
skopiuj mnie do nowego pokolenia. */
pdl *przyszły_ja; /* Jestem pdl „wtedy”, a to jest mój „teraz” (lub bardziej nowoczesny
wersja, w każdym razie */

pdl_children dzieci;

krótkie życie_dla; /* Brak odniesienia do strony Perla; usuń mnie kiedy */

PDL_Indx def_dims[PDL_NDIMS]; /* Wstępnie przydzielona przestrzeń zapewniająca wydajność */
PDL_Indx def_dimincs[PDL_NDIMS]; /* Wstępnie przydzielona przestrzeń zapewniająca wydajność */
unsigned char def_threadids[PDL_NTHREADIDS];

struktura pdl_magic *magia;

nieważne *hdrsv; /* „nagłówek”, ustawiany z zewnątrz */
};

Jest to dość struktura przeznaczona do przechowywania niektórych danych. Co się dzieje?

Przechowywanie danych
Zaczniemy od prostszych elementów: po pierwsze, jest to
członek

nieważne *datasv;

który tak naprawdę jest wskaźnikiem do struktury SV Perla („SV *”). Oczekuje się, że SV będzie
reprezentujący ciąg znaków, w którym dane piddle'a są przechowywane w szczelnie upakowanym miejscu
formularz. Ten wskaźnik liczy się jako odniesienie do SV, więc liczba odniesień została wyliczona
zwiększany po umieszczeniu tutaj „SV *” (musi to być związane z liczbą referencji
z mechanizmem zbierania śmieci w Perlu — nie martw się, jeśli to nie ma większego znaczenia
Ty). Wskaźnik ten może mieć wartość „NULL”, co oznacza, że ​​nie istnieje
rzeczywisty Perl SV dla tych danych - na przykład dane mogą być przydzielane przez „mmap”
operacja. Należy pamiętać, że użycie SV* miało wyłącznie na celu wygodę, umożliwiało to łatwe
transformacja spakowanych danych z plików na piddle. Inne implementacje nie
wyłączony.

Rzeczywisty wskaźnik do danych jest przechowywany w elemencie członkowskim

puste *dane;

który zawiera wskaźnik do obszaru pamięci z miejscem na

PDL_Indx nvals;

elementy danych typu danych tego piddle'a. PDL_Indx jest albo „długi”, albo „długi, długi”
w zależności od tego, czy twój Perl jest 64-bitowy, czy nie.

Typ danych jest przechowywany w zmiennej

int typ danych;

wartości tego elementu są podane w wyliczeniu „pdl_datatypes” (patrz pdl.h).
Obecnie mamy typy bajtowe, krótkie, bez znaku krótkie, długie, zmiennoprzecinkowe i podwójne, zobacz także
PDL::Typy.

Wymiary
Liczba wymiarów w piddle jest podana przez pręt

int ndim;

co pokazuje, ile wpisów znajduje się w tablicach

PDL_Indx *przyciemnia;
PDL_Indx *diminki;

Tablice te są ze sobą ściśle powiązane: „dims” podaje rozmiary wymiarów i
„dimincs” jest zawsze obliczane na podstawie kodu

PDL_Indx przyr. = 1;
dla (i=0; tj przyciemnia; ja++) {
it->dimincs[i] = inc; inc *= to->przyciemnia[i];
}

w procedurze „pdl_resize_defaultincs” w „pdlapi.c”. Oznacza to, że
dimincs można wykorzystać do obliczenia przesunięcia za pomocą kodu takiego jak

Wyłączenia PDL_Indx = 0;
dla (i=0; tj przyciemnia; ja++) {
offs += it->dimincs[i] * indeks[i];
}

ale nie zawsze jest to właściwe postępowanie, przynajmniej bez sprawdzenia
najpierw rzeczy.

Domyślna pamięć
Ponieważ zdecydowana większość piddle'ów nie ma więcej niż 6 wymiarów, jest ich więcej
efektywne jest posiadanie domyślnej pamięci dla wymiarów i wymiarów wewnątrz PDL
struktura.

PDL_Indx def_dims[PDL_NDIMS];
PDL_Indx def_dimincs[PDL_NDIMS];

Elementy „dims” i „dimincs” można ustawić tak, aby wskazywały początek tych tablic if
„ndims” jest mniejsze lub równe stałej czasowej kompilacji „PDL_NDIMS”. To jest
należy o tym pamiętać podczas uwalniania struktury piddle. To samo dotyczy wątków:

unsigned char def_threadids[PDL_NTHREADIDS];

magia
Możliwe jest dołączenie magii do piddle'ów, podobnie jak w przypadku magicznego mechanizmu Perla. Jeśli
wskaźnik elementu członkowskiego

struktura pdl_magic *magia;

jest różna od zera, z PDL wiąże się pewna magia. Wdrożenie magii może być
wyczytane z pliku pdlmagic.c w dystrybucji.

Miasto
Jednym z pierwszych członków tej struktury jest

stan int;

Możliwe flagi i ich znaczenie są podane w "pdl.h". Do nich się głównie przyzwyczaja
zaimplementuj leniwy mechanizm oceny i śledź w nich zagadki
operacje.

Transformacje i wirtualne transformacje afiniczne
Jak już zapewne wiesz, piddle często niesie ze sobą informację o tym skąd pochodzą
z. Na przykład kod

$b = $a->plasterek("2:5");
$b.= 1;

zmieni $a. Zatem $b i $a wiedzieć że są one połączone poprzez
„kawałek” – transformacja. Informacje te są przechowywane w elementach członkowskich

pdl_trans *trans;
pdl_vaffine *vafftrans;

Zarówno $a ( roślina mateczna) i $b (dziecko) przechowują te informacje o
transformacja w odpowiednich slotach struktury "pdl".

„pdl_trans” i „pdl_vaffine” to struktury, którym przyjrzymy się bardziej szczegółowo
poniżej.

Perl SV
Kiedy piddles są odwoływane poprzez SV Perla, przechowujemy dodatkowe odniesienie do nich
w członku

nieważne* sv;

aby móc zwrócić użytkownikowi referencję, gdy ten będzie chciał sprawdzić
struktura transformacji po stronie Perla.

Przechowujemy również nieprzezroczysty

nieważne *hdrsv;

który jest przeznaczony wyłącznie do użytku przez użytkownika w celu podłączenia dowolnych danych do tego sv. Ten
jest zazwyczaj manipulowany poprzez wywołania sethdr i gethdr.

Smart referencje i przekształcenia: Odcinanie i gra w kości
Zaimplementowano inteligentne referencje i większość innych podstawowych funkcji działających na piddle'ach
przez przemiany (Jak wspomniano powyżej), które są reprezentowane przez typ „pdl_trans” w
PDL.

Transformacja łączy kanały wejściowe i wyjściowe oraz zawiera całą infrastrukturę, która
określa jak

· Piddle wyjściowe otrzymuje się z piddle'ów wejściowych

· zmiany w inteligentnie połączonych modułach wyjściowych (np dziecko pokrojonego roślina mateczna siusiać)
są kierowane z powrotem do piddle wejściowego w transformacjach, gdzie jest to obsługiwane (the
najczęściej używanym przykładem jest tutaj „kawałek”).

· Pobierany jest typ danych i rozmiar piddle'ów wyjściowych, które należy utworzyć

Ogólnie rzecz biorąc, wykonanie funkcji PDL na grupie piddle'ów skutkuje utworzeniem pliku a
transformacja żądanego typu, która łączy wszystkie argumenty wejściowe i wyjściowe (co najmniej
te, które są piddles). W funkcjach PDL obsługujących przepływ danych pomiędzy wejściem i wyjściem
argumenty (np. „kawałek”, „indeks”) łączy tę transformację roślina mateczna (wejście) i dziecko (wyjście)
piddle trwale, dopóki łącze nie zostanie wyraźnie zerwane na żądanie użytkownika („sever” w
poziom Perla) lub wszyscy rodzice i dzieci zostali zniszczeni. W takich przypadkach
transformacja jest oceniana z opóźnieniem, np. wykonywana tylko wtedy, gdy faktycznie występują wartości piddle
dostępny.

In niepłynący funkcje, na przykład dodawanie („+”) i iloczyny wewnętrzne („wewnętrzne”), the
transformacja jest instalowana tak samo jak w funkcjach płynących, ale wtedy transformacja jest
natychmiast wykonane i zniszczone (przerwanie połączenia między argumentami wejściowymi i wyjściowymi)
zanim funkcja powróci.

Należy zauważyć, że ścisłe powiązanie między argumentami wejściowymi i wyjściowymi funkcji płynącej
(jak plasterek) wymaga, aby połączone w ten sposób obiekty były utrzymywane przy życiu
poza punkt, w którym wyszły poza zakres z punktu widzenia Perla:

$a = zera(20);
$b = $a->plasterek('2:4');
undf $a; # ostatnie odniesienie do $a zostało zniszczone

Chociaż $a powinno teraz zostać zniszczone zgodnie z zasadami Perla, bazowy „pdl”
struktura musi zostać zwolniona tylko wtedy, gdy $b również wyjdzie poza zakres (ponieważ nadal
odwołuje się wewnętrznie do niektórych danych $a). Ten przykład pokazuje, że taki przepływ danych
paradygmat między obiektami PDL wymaga specjalnego algorytmu niszczenia, który uwzględnia
uwzględnia powiązania pomiędzy piddle'ami i łączy żywotność tych obiektów. Nie-
trywialny algorytm jest zaimplementowany w funkcji „pdl_destroy” w pdlapi.c. Właściwie większość
kodu w pdlapi.c i pdlrodzina.c zajmuje się upewnieniem się, że piddle („pdl
*” są tworzone, aktualizowane i uwalniane we właściwym czasie, w zależności od interakcji z
inne piddle poprzez transformacje PDL (pamiętaj, „pdl_trans”).

dostępu dzieci i rodzice of a siusiać
Kiedy piddle są dynamicznie łączone poprzez transformacje, jak zasugerowano powyżej, input and
Piddle wyjściowe nazywane są odpowiednio rodzicami i dziećmi.

Przykład przetwarzania dzieci piddle'a dostarcza metoda "baddata".
PDL::Bad (dostępne tylko jeśli skompilowałeś PDL z opcją "WITH_BADVAL" ustawioną na 1,
ale nadal przydatny jako przykład!).

Rozważ następującą sytuację:

pdl> $a = rvals(7,7,Centrum=>[3,4]);
pdl> $b = $a->plasterek('2:4,3:5');
pdl>? Vars
Zmienne PDL w pakiecie main::

Nazwa Typ Wymiar Stan przepływu Mem
-------------------------------------------------- --------------
$a Podwójne D [7,7] P 0.38Kb
$b Podwójne D [3,3] VC 0.00Kb

Teraz, jeśli nagle zdecyduję, że $a powinien zostać oznaczony jako prawdopodobnie zawierający złe wartości,
za pomocą

pdl> $a->złe dane(1)

wtedy chcę stanu $b - jest dziecko - również zostać zmienione (ponieważ tak będzie
udostępnij lub odziedzicz część danych $a i tak też będzie zły), więc dostaję literę „B” w Miasto
pole:

pdl>? Vars
Zmienne PDL w pakiecie main::

Nazwa Typ Wymiar Stan przepływu Mem
-------------------------------------------------- --------------
$a Double D [7,7] PB 0.38 Kb
$b Podwójne D [3,3] VCB 0.00Kb

Tę magię wykonuje funkcja „propogate_badflag”, której lista znajduje się poniżej:

/* newval = 1 oznacza ustawienie flagi, 0 oznacza jej wyczyszczenie */
/* dziękuję za to Christianowi Soellerowi */

void propogate_badflag( pdl *it, int nowa wartość ) {
PDL_DECL_CHILDLOOP(it)
PDL_START_CHILDLOOP(to)
{
pdl_trans *trans = PDL_CHILDLOOP_THISCHILD(it);
wew;
for( i = trans->vtable->nparents;
i < trans->vtable->npdls;
ja++) {
pdl *dziecko = trans->pdls[i];

if ( newval ) dziecko->stan |= PDL_BADVAL;
w przeciwnym razie dziecko->stan &= ~PDL_BADVAL;

/* upewnij się, że propagujemy wnuki itp. */
propogate_badflag(dziecko, nowa wartość );

} /* dla: i */
}
PDL_END_CHILDLOOP(it)
} /* propogate_badflag */

Biorąc pod uwagę piddle („pdl *it”), procedura wykonuje pętlę przez każdą strukturę „pdl_trans”, gdzie
dostęp do tej struktury zapewnia makro „PDL_CHILDLOOP_THISCHILD”. The dzieci
piddle są przechowywane w tablicy „pdls”, po rodzice, stąd pętla z „i =
...nparents" na "i = ...nparents - 1". Kiedy już mamy wskaźnik do dziecka, możemy
możemy z nim zrobić, co chcemy; tutaj zmieniamy wartość zmiennej „stan”, ale
szczegóły są nieistotne). Co is ważne jest, abyśmy wywołali w tej sprawie „propogate_badflag”.
piddle, aby mieć pewność, że przejdziemy przez jego dzieci. Dzięki tej rekurencji dotrzemy do wszystkich
potomstwo konkretnego łba.

Dostęp do rodzice jest podobny, z pętlą „for” zastąpioną przez:

dla( i = 0;
i < trans->vtable->nparents;
ja++) {
/* wykonaj czynności z rodzicem #i: trans->pdls[i] */
}

Co znajduje się w in a transformacja („pdl_trans”)
Wszystkie transformacje są realizowane jako struktury

struktura XXX_trans {
int magicno; /* aby wykryć nadpisanie pamięci */
krótkie flagi; /* stan trans */
pdl_transvtable *vtable; /* wszystkie ważne tabele */
void (*freeproc)(struct pdl_trans *); /* Zadzwoń, aby uwolnić ten trans
(na wypadek, gdybyśmy musieli mallocować jakieś rzeczy w tym transie) */
pdl *pdls[NP]; /* Pdl biorące udział w transformacji */
int __typ danych; /* typ transformacji */
/* ogólnie więcej członków
/* w zależności od aktualnej transformacji (pokrój, dodaj itp.)
*/
};

Transformacja identyfikuje wszystkie „pdl” zaangażowane w trans

pdl *pdls[NP];

z „NP” w zależności od liczby argumentów piddle'a konkretnego trans. Rejestruje A
były

krótkie flagi;

i typ danych

int __typ danych;

trans (na który wszystkie piddle muszą zostać przekonwertowane, chyba że są jawnie wpisane, PDL
funkcje utworzone za pomocą PDL::PP upewnij się, że te konwersje zostały wykonane w razie potrzeby).
Najważniejszy jest wskaźnik do vtable (tabeli wirtualnej), która zawiera aktualną
Funkcjonalność

pdl_transvtable *vtable;

Z kolei struktura vtable wygląda mniej więcej tak (nieco uproszczona z pdl.h dla
przejrzystość)

typedef struktura pdl_transvtable {
transtyp pdl_transtype;
flagi int;
int rodzice; /* liczba nadrzędnych pdls (wejście) */
int npdls; /* liczba podrzędnych pdls (wyjście) */
char *per_pdl_flags; /* flagi optymalizacji */
void (*redodims)(pdl_trans *tr); /* oblicz wymiary dzieci */
void (*readdata)(pdl_trans *tr); /* przepływ rodziców do dzieci */
void (*writebackdata)(pdl_trans *tr); /* przepływ wstecz */
void (*freetrans)(pdl_trans *tr); /* Uwolnij zarówno zawartość, jak i ją
członek trans */
pdl_trans *(*kopia)(pdl_trans *tr); /* Pełna kopia */
int rozmiar struktury;
znak *nazwa; /* Głównie dla debugerów */
} pdl_transvtable;

Skupiamy się na funkcjach wywołania zwrotnego:

void (*redodims)(pdl_trans *tr);

„redodims” obliczy wymiary piddles, które należy utworzyć i nazywa się to
z poziomu funkcji API, którą należy wywołać, aby upewnić się, że wymiary a
Piddle są dostępne (pdlapi.c):

void pdl_make_physdims(pdl *it)

„readdata” i „writebackdata” odpowiadają za faktyczne obliczenia dziecka
odpowiednio dane od rodziców lub dane rodziców od dzieci (tzw
aspekt przepływu danych). Rdzeń PDL dba o to, aby były one wywoływane w razie potrzeby podczas piddle
uzyskuje się dostęp do danych (leniwa ocena). Ogólna funkcja API zapewniająca, że ​​piddle jest
aktualne jest

void pdl_make_physvaffine(pdl *it)

które należy wywołać przed uzyskaniem dostępu do danych piddle z XS/C (patrz Rdzeń.xs dla niektórych
przykłady).

„freetrans” zwalnia dynamicznie przydzieloną pamięć związaną z transem w razie potrzeby i
„kopiuj” może skopiować transformację. Ponownie, funkcje zbudowane za pomocą PDL::PP zapewniają to
kopiowanie i zwalnianie za pomocą tych wywołań zwrotnych odbywa się we właściwym czasie. (Jeśli tego nie zrobią
że mamy wyciek pamięci – zdarzało się to w przeszłości ;).

Kod transformacji i vtable prawie nigdy nie jest pisany ręcznie, ale raczej generowany przez
PDL::PP ze zwięzłych opisów.

Niektóre typy transformacji można bardzo skutecznie optymalizować, eliminując potrzebę
jawne metody „readdata” i „writebackdata”. Transformacje te nazywane są
pdl_vaffine. Większość funkcji manipulujących wymiarami (np. „slice”, „xchg”) należy do tej funkcji
class.

Podstawowa sztuczka polega na tym, że rodzic i dziecko takiej transformacji pracują nad tym samym
(wspólny) blok danych, który po prostu decydują się na odmienną interpretację (używając Different
„dims”, „dimincs” i „offs” na tych samych danych, porównaj powyższą strukturę „pdl”). Każdy
operacja na piddle, udostępnianie danych innemu w ten sposób odbywa się zatem automatycznie
latają od dziecka do rodzica i z powrotem – w końcu czytają i piszą to samo
blok pamięci. Obecnie nie jest to bezpieczne dla wątków Perla — nie ma dużej straty od czasu całego PDL
rdzeń nie jest współbieżny (wątki Perla "!=" Wątki PDL!).

Podpisy: gwintowanie koniec elementarny operacje
Większość tej funkcjonalności wątków PDL (automatyczna iteracja elementarnych operacji
over multi-dim piddles) jest zaimplementowany w pliku pdlthread.c.

Funkcje generowane przez PDL::PP (w szczególności „readdata” i „writebackdata”
wywołania zwrotne) korzystają z tej infrastruktury, aby upewnić się, że podstawowa operacja została wdrożona
przez trans jest wykonywane zgodnie z semantyką wątków PDL.

Definiowanie nowa PDL Funkcje -- Klej kod generacja
Proszę zapoznać się z PDL::PP i przykładami w dystrybucji PDL. Implementacja i składnia są
obecnie daleko mu do ideału, ale radzi sobie nieźle!

Kurs rdzeń struct
Jak omówiono w PDL::API, PDL używa wskaźnika do struktury, do której moduły PDL mają dostęp
jego podstawowe procedury. Definicja tej struktury (struktura „Core”) znajduje się w pdlcore.h
(stworzone przez pdlcore.h.PL in Podstawowy/rdzeń) i wygląda mniej więcej tak

/* Struktura przechowująca wskaźniki, podstawowe procedury PDL, z których mogą korzystać
* wiele modułów
*/
rdzeń struktury {
Wersja I32;
pdl* (*SvPDLV) (SV*);
void (*SetSV_PDL) ( SV *sv, pdl *it );
#jeśli zdefiniowano (przestrzeń nazw PDL_clean_) || zdefiniowano (PDL_OLD_API)
pdl* (*nowy) ( ); /* spraw, by działało z gimp-perlem */
#else
pdl* (*pdlnew) ( ); /* zmieniono nazwę z powodu konfliktu C++ */
#endif
pdl* (*tmp) ( );
pdl* (*utwórz) (typ int);
void (*zniszcz) (pdl *it);
...
}
typedef struct Rdzeń Rdzeń;

Pierwsze pole struktury („Wersja”) służy zapewnieniu spójności pomiędzy modułami
W czasie wykonywania; następujący kod zostaje umieszczony w sekcji BOOT wygenerowanego kodu xs:

jeśli (PDL->Wersja != PDL_CORE_VERSION)
Perl_croak(aTHX_ "Foo wymaga ponownej kompilacji z nowo zainstalowanym PDL");

Jeśli dodasz nowe pole do pliku rdzeń strukturę powinieneś:

· omów to na liście e-mailowej porterów pdl ([email chroniony]) [z
możliwość wprowadzenia zmian w osobnej gałęzi drzewa CVS, jeśli jest to a
zmiana, której ukończenie zajmie trochę czasu]

· zwiększyć o 1 wartość zmiennej $pdl_core_version w pdlcore.h.PL. To ustawia
wartość makra C „PDL_CORE_VERSION” użytego do wypełnienia pola Wersja

· dodać dokumentację (np. do PDL::API) jeśli jest to "użyteczna" funkcja dla modułu zewnętrznego
pisarzy (a także zapewnienie, że kod jest tak dobrze udokumentowany, jak reszta PDL;)

Użyj PDL::Internalsp online, korzystając z usług onworks.net