perlxstypemap - Dalam Talian di Awan

JADUAL:

NAMA

perlxstypemap - Pemetaan jenis Perl XS C/Perl

DESCRIPTION

Lebih banyak anda berfikir tentang antara muka antara dua bahasa, lebih banyak anda akan menyedarinya
majoriti usaha pengaturcara perlu menukar antara struktur data
yang berasal dari salah satu bahasa yang terlibat. Ini mengatasi perkara lain seperti
konvensyen panggilan yang berbeza kerana ruang masalah adalah jauh lebih besar. Disana ada
hanya lebih banyak cara untuk memasukkan data ke dalam ingatan daripada cara untuk melaksanakan fungsi
panggil.

Percubaan Perl XS untuk menyelesaikan masalah ini ialah konsep peta taip. Pada tahap abstrak,
peta taip Perl XS hanyalah resipi untuk menukar daripada data Perl tertentu
struktur kepada struktur data C tertentu dan sebaliknya. Oleh kerana boleh ada jenis C yang
adalah cukup serupa antara satu sama lain untuk menjamin penukaran dengan logik yang sama, XS
peta taip diwakili oleh pengecam unik, seterusnya dipanggil an XS jenis dalam hal ini
dokumen. Anda kemudian boleh memberitahu pengkompil XS bahawa pelbagai jenis C akan dipetakan
peta taip XS yang sama.

Dalam kod XS anda, apabila anda mentakrifkan hujah dengan jenis C atau apabila anda menggunakan "CODE:"
dan bahagian "OUTPUT:" bersama-sama dengan jenis pulangan C XSUB anda, ia akan menjadi
mekanisme pemetaan taip yang memudahkannya.

Anatomi of a peta taip
Dalam istilah yang lebih praktikal, peta taip ialah koleksi serpihan kod yang digunakan oleh
yang xsubpp pengkompil untuk memetakan parameter dan nilai fungsi C kepada nilai Perl. Peta taip
fail mungkin terdiri daripada tiga bahagian yang dilabel "MAP TAIP", "INPUT" dan "OUTPUT". An
bahagian awal yang tidak berlabel diandaikan sebagai bahagian "MAP TAIP". Bahagian INPUT memberitahu
pengkompil bagaimana untuk menterjemah nilai Perl kepada pembolehubah jenis C tertentu. OUTPUT
bahagian memberitahu pengkompil cara menterjemah nilai daripada jenis C tertentu kepada nilai
Perl boleh faham. Bahagian TYPEMAP memberitahu pengkompil yang mana antara INPUT dan OUTPUT
serpihan kod harus digunakan untuk memetakan jenis C yang diberikan kepada nilai Perl. Label bahagian
"MAP TAIP", "INPUT", atau "OUTPUT" mesti bermula dalam lajur pertama pada baris dengan sendirinya,
dan mestilah dalam huruf besar.

Setiap jenis bahagian boleh muncul beberapa kali sewenang-wenangnya dan tidak perlu muncul
sama sekali. Sebagai contoh, peta taip mungkin tidak mempunyai bahagian "INPUT" dan "OUTPUT" jika semuanya
yang perlu dilakukan ialah mengaitkan jenis C tambahan dengan jenis teras XS seperti T_PTROBJ. Garisan itu
bermula dengan cincang "#" dianggap sebagai ulasan dan diabaikan dalam bahagian "MAP TAIP", tetapi
dianggap penting dalam "INPUT" dan "OUTPUT". Garis kosong biasanya diabaikan.

Secara tradisinya, peta taip perlu ditulis pada fail berasingan, dipanggil secara konvensional
"peta taip" dalam pengedaran CPAN. Dengan ExtUtils::ParseXS (penyusun XS) versi 3.12
atau lebih baik yang disertakan dengan perl 5.16, peta taip juga boleh dibenamkan terus ke dalam kod XS
menggunakan sintaks seperti HERE-doc:

PETA JENIS: <
...
SINI

di mana "DI SINI" boleh digantikan dengan pengecam lain seperti Perl HERE-docs biasa. Semua
butiran di bawah tentang format teks peta taip kekal sah.

Bahagian "MAP TAIP" hendaklah mengandungi sepasang jenis C dan jenis XS setiap baris seperti berikut.
Contoh daripada fail peta taip teras:

PETA TAIP
# semua varian char* dikendalikan oleh peta taip T_PV
aksara * T_PV
const char * T_PV
aksara yang tidak ditandatangani * T_PV
...

Bahagian "INPUT" dan "OUTPUT" mempunyai format yang sama, iaitu setiap baris yang tidak disentuh
memulakan peta masuk atau keluaran baharu masing-masing. Peta masuk atau keluaran baharu mesti bermula dengan
nama jenis XS untuk dipetakan pada baris dengan sendirinya, diikuti dengan kod yang melaksanakannya
inden pada baris berikut. Contoh:

INPUT
T_PV
$var = ($jenis)SvPV_nolen($arg)
T_PTR
$var = INT2PTR($jenis,SvIV($arg))

Kita akan sampai kepada maksud pembolehubah yang kelihatan bahasa Perlish itu sedikit masa lagi.

Akhir sekali, berikut ialah contoh fail peta taip penuh untuk memetakan rentetan C bagi "char *"
taip kepada skalar/rentetan Perl:

PETA TAIP
aksara * T_PV

INPUT
T_PV
$var = ($jenis)SvPV_nolen($arg)

OUTPUT
T_PV
sv_setpv((SV*)$arg, $var);

Berikut ialah contoh yang lebih rumit: katakan anda mahu "struct netconfig" menjadi
diberkati ke dalam kelas "Net::Config". Satu cara untuk melakukan ini ialah menggunakan garis bawah (_) untuk
nama pakej berasingan, seperti berikut:

typedef struct netconfig * Net_Config;

Dan kemudian sediakan entri peta taip "T_PTROBJ_SPECIAL" yang memetakan garis bawah kepada bertitik dua
(::), dan isytiharkan "Net_Config" daripada jenis itu:

PETA TAIP
Net_Config T_PTROBJ_SPECIAL

INPUT
T_PTROBJ_SPECIAL
jika (sv_derived_from($arg, \"${(my $ntt=$ntype)=~s/_/::/g;\$ntt}\")){
IV tmp = SvIV((SV*)SvRV($arg));
$var = INT2PTR($jenis, tmp);
}
lagi
croak(\"$var bukan jenis ${(my $ntt=$ntype)=~s/_/::/g;\$ntt}\")

OUTPUT
T_PTROBJ_SPECIAL
sv_setref_pv($arg, \"${(my $ntt=$ntype)=~s/_/::/g;\$ntt}\",
(kosong*)$var);

Bahagian INPUT dan OUTPUT menggantikan garis bawah untuk bertitik dua dengan cepat, memberi
kesan yang diingini. Contoh ini menunjukkan beberapa kuasa dan serba boleh
kemudahan peta taip.

Makro "INT2PTR" (ditakrifkan dalam perl.h) menghantar integer ke penunjuk jenis tertentu,
menjaga kemungkinan saiz integer dan penunjuk yang berbeza. Terdapat juga
Makro "PTR2IV", "PTR2UV", "PTR2NV", untuk memetakan cara lain, yang mungkin berguna dalam OUTPUT
bahagian.

. Peranan of yang peta taip File in pengedaran
Peta taip lalai dalam lib/ExtUtils direktori sumber Perl mengandungi banyak berguna
jenis yang boleh digunakan oleh sambungan Perl. Sesetengah sambungan mentakrifkan peta taip tambahan
yang mereka simpan dalam direktori mereka sendiri. Peta taip tambahan ini mungkin merujuk INPUT dan
Peta OUTPUT dalam peta taip utama. The xsubpp pengkompil akan membenarkan sambungan itu sendiri
peta taip untuk mengatasi sebarang pemetaan yang terdapat dalam peta taip lalai. Daripada menggunakan an
tambahan peta taip fail, peta taip mungkin dibenamkan kata kerja dalam XS dengan seperti heredoc
sintaks. Lihat dokumentasi pada kata kunci "TYPEMAP:" XS.

Untuk pengedaran CPAN, anda boleh menganggap bahawa jenis XS yang ditakrifkan oleh teras perl ialah
sudah tersedia. Selain itu, peta taip teras mempunyai jenis XS lalai untuk bilangan yang besar
daripada jenis C. Sebagai contoh, jika anda hanya mengembalikan "char *" daripada XSUB anda, peta taip teras
akan mempunyai jenis C ini dikaitkan dengan jenis T_PV XS. Ini bermakna rentetan C anda akan menjadi
disalin ke dalam slot PV (nilai penunjuk) skalar baharu yang akan dikembalikan daripada anda
XSUB kepada Perl.

Jika anda sedang membangunkan pengedaran CPAN menggunakan XS, anda boleh menambah fail anda sendiri yang dipanggil
peta taip kepada pengagihan. Fail itu mungkin mengandungi peta taip yang sama ada peta menaipnya
adalah khusus untuk kod anda atau yang mengatasi pemetaan fail peta taip teras untuk C biasa
jenis.

Berkongsi peta taip antara CPAN Pengagihan
Bermula dengan ExtUtils::ParseXS versi 3.13_01 (didatangkan dengan perl 5.16 dan lebih baik), ia adalah
agak mudah untuk berkongsi kod peta taip antara berbilang pengedaran CPAN. Idea umum ialah
untuk berkongsinya sebagai modul yang menawarkan API tertentu dan mempunyai modul bergantung yang diisytiharkan
itu sebagai keperluan masa terbina dan mengimport peta taip ke dalam XS. Contoh seperti a
modul perkongsian peta taip pada CPAN ialah "ExtUtils::Typemaps::Basic". Dua langkah untuk mendapatkannya
peta taip modul tersedia dalam kod anda:

· Isytiharkan "ExtUtils::Typemaps::Basic" sebagai kebergantungan masa binaan dalam "Makefile.PL" (gunakan
"BUILD_REQUIRES"), atau dalam "Build.PL" anda (gunakan "build_requires").

· Sertakan baris berikut dalam bahagian XS fail XS anda: (jangan putuskan baris)

INCLUDE_COMMAND: $^X -MExtUtils::Typemaps::Cmd
-e "print embeddable_typemap(q{Basic})"

Penulisan peta taip Penyertaan
Setiap entri peta taip INPUT atau OUTPUT ialah rentetan Perl petikan dua kali yang akan dinilai
dengan kehadiran pembolehubah tertentu untuk mendapatkan kod C akhir untuk memetakan jenis C tertentu.

Ini bermakna anda boleh membenamkan kod Perl dalam kod peta taip (C) anda menggunakan binaan seperti
"${ kod perl yang menilai kepada rujukan skalar di sini }". Kes penggunaan biasa adalah untuk menjana
mesej ralat yang merujuk kepada nama fungsi sebenar walaupun menggunakan ciri ALIAS XS:

${ $ALIAS ? \q[GvNAME(CvGV(cv))] : \qq[\"$pname\"] }

Untuk banyak contoh peta taip, rujuk fail peta taip teras yang boleh ditemui dalam perl
pokok sumber di lib/ExtUtils/typemap.

Pembolehubah Perl yang tersedia untuk interpolasi ke dalam peta taip adalah seperti berikut:

· $var - nama pembolehubah input atau output, cth. RETVAL untuk nilai pulangan.

· $jenis - jenis C mentah parameter, sebarang ":" digantikan dengan "_". cth untuk jenis
daripada "Foo::Bar", $jenis ialah "Foo__Bar"

· $ntype - jenis yang dibekalkan dengan "*" digantikan dengan "Ptr". cth untuk jenis "Foo*",
$ntype ialah "FooPtr"

· $arg - entri tindanan, bahawa parameter adalah input daripada atau output kepada, cth ST(0)

· $argoff - timbunan hujah mengimbangi hujah. iaitu. 0 untuk hujah pertama,
dan lain-lain.

· $pname - nama penuh XSUB, dengan memasukkan nama "PAKEJ", dengan mana-mana
"PREFIX" dilucutkan. Ini adalah nama bukan ALIAS.

· $Pakej - pakej yang ditentukan oleh kata kunci "PAKEJ" terbaharu.

· $ALIAS - bukan sifar jika XSUB semasa mempunyai sebarang alias yang diisytiharkan dengan "ALIAS".

Penuh penyenaraian of Teras Peta taip
Setiap jenis C diwakili oleh entri dalam fail peta taip yang bertanggungjawab
menukar pembolehubah perl (SV, AV, HV, CV, dll.) kepada dan dari jenis itu. Yang berikut
bahagian menyenaraikan semua jenis XS yang disertakan dengan perl secara lalai.

T_SV
Ini hanya melepasi perwakilan C pembolehubah Perl (SV*) masuk dan keluar
lapisan XS. Ini boleh digunakan jika kod C mahu berurusan terus dengan Perl
berubah-ubah.

T_SVREF
Digunakan untuk menghantar dan mengembalikan rujukan kepada SV.

Ambil perhatian bahawa peta taip ini tidak mengurangkan kiraan rujukan apabila mengembalikan
rujukan kepada SV*. Lihat juga: T_SVREF_REFCOUNT_FIXED

T_SVREF_FIXED
Digunakan untuk menghantar dan mengembalikan rujukan kepada SV. Ini ialah varian tetap T_SVREF
yang mengurangkan kiraan semula dengan sewajarnya apabila mengembalikan rujukan kepada SV*.
Diperkenalkan dalam perl 5.15.4.

T_AVREF
Dari peringkat perl ini adalah rujukan kepada tatasusunan perl. Dari peringkat C ini ialah a
penunjuk ke AV.

Ambil perhatian bahawa peta taip ini tidak mengurangkan kiraan rujukan apabila mengembalikan AV*.
Lihat juga: T_AVREF_REFCOUNT_FIXED

T_AVREF_REFCOUNT_FIXED
Dari peringkat perl ini adalah rujukan kepada tatasusunan perl. Dari peringkat C ini ialah a
penunjuk ke AV. Ini ialah varian tetap T_AVREF yang mengurangkan kiraan semula
sewajarnya apabila mengembalikan AV*. Diperkenalkan dalam perl 5.15.4.

T_HVREF
Dari peringkat perl ini adalah rujukan kepada cincangan perl. Dari peringkat C ini ialah a
penunjuk kepada HV.

Ambil perhatian bahawa peta taip ini tidak mengurangkan kiraan rujukan apabila mengembalikan HV*.
Lihat juga: T_HVREF_REFCOUNT_FIXED

T_HVREF_REFCOUNT_FIXED
Dari peringkat perl ini adalah rujukan kepada cincangan perl. Dari peringkat C ini ialah a
penunjuk kepada HV. Ini ialah varian tetap T_HVREF yang mengurangkan kiraan semula
sewajarnya apabila memulangkan HV*. Diperkenalkan dalam perl 5.15.4.

T_CVREF
Dari peringkat perl ini adalah rujukan kepada subrutin perl (cth $sub = sub { 1};).
Dari tahap C ini adalah penunjuk kepada CV.

Ambil perhatian bahawa peta taip ini tidak mengurangkan kiraan rujukan apabila mengembalikan HV*.
Lihat juga: T_HVREF_REFCOUNT_FIXED

T_CVREF_REFCOUNT_FIXED
Dari peringkat perl ini adalah rujukan kepada subrutin perl (cth $sub = sub { 1};).
Dari tahap C ini adalah penunjuk kepada CV.

Ini ialah varian tetap T_HVREF yang mengurangkan kiraan semula dengan sewajarnya apabila
memulangkan HV*. Diperkenalkan dalam perl 5.15.4.

T_SYSRET
Peta taip T_SYSRET digunakan untuk memproses nilai pulangan daripada panggilan sistem. Ia hanya
bermakna apabila menghantar nilai dari C ke perl (tiada konsep menghantar sistem
nilai pulangan dari Perl ke C).

Panggilan sistem kembali -1 pada ralat (menetapkan ERRNO dengan sebab) dan (biasanya) 0 pada
kejayaan. Jika nilai pulangan ialah -1 peta taip ini mengembalikan "undef". Jika nilai pulangan
bukan -1, peta taip ini menterjemah 0 (perl false) kepada "0 tetapi benar" (iaitu perl
benar) atau mengembalikan nilai itu sendiri, untuk menunjukkan bahawa arahan itu berjaya.

Modul POSIX menggunakan jenis ini secara meluas.

T_UV
Integer tidak bertanda.

T_IV
Integer yang ditandatangani. Ini dibuang ke jenis integer yang diperlukan apabila dihantar ke C dan
ditukar kepada IV apabila diserahkan semula kepada Perl.

T_INT
Integer yang ditandatangani. Peta taip ini menukar nilai Perl kepada jenis integer asli (the
taip "int" pada platform semasa). Apabila mengembalikan nilai kepada perl ia diproses
dengan cara yang sama seperti untuk T_IV.

Tingkah lakunya adalah sama dengan menggunakan jenis "int" dalam XS dengan T_IV.

T_ENUM
Nilai enum. Digunakan untuk memindahkan komponen enum dari C. Tiada sebab untuk lulus
nilai enum kepada C kerana ia disimpan sebagai perl dalam IV.

T_BOOL
Jenis boolean. Ini boleh digunakan untuk menghantar nilai benar dan salah kepada dan dari C.

T_U_INT
Ini adalah untuk integer tidak bertanda. Ia bersamaan dengan menggunakan T_UV tetapi secara eksplisit membuang
pembolehubah untuk menaip "unsigned int". Jenis lalai untuk "unsigned int" ialah T_UV.

T_SHORT
Integer pendek. Ini bersamaan dengan T_IV tetapi secara eksplisit menghantar pulangan untuk menaip
"pendek". Peta taip lalai untuk "pendek" ialah T_IV.

T_U_SHORT
Integer pendek tidak bertanda. Ini bersamaan dengan T_UV tetapi secara eksplisit menghantar pulangan ke
taip "unsigned short". Peta taip lalai untuk "unsigned short" ialah T_UV.

T_U_SHORT digunakan untuk jenis "U16" dalam peta taip standard.

T_LONG
Integer panjang. Ini bersamaan dengan T_IV tetapi secara eksplisit menghantar pulangan untuk menaip
"panjang". Peta taip lalai untuk "panjang" ialah T_IV.

T_U_LONG
Integer panjang yang tidak ditandatangani. Ini bersamaan dengan T_UV tetapi secara eksplisit menghantar pulangan ke
taip "unsigned long". Peta taip lalai untuk "unsigned long" ialah T_UV.

T_U_LONG digunakan untuk jenis "U32" dalam peta taip standard.

T_CHAR
Aksara tunggal 8-bit.

T_U_CHAR
Bait yang tidak ditandatangani.

T_FLOAT
Nombor titik terapung. Peta taip ini menjamin untuk mengembalikan cast pembolehubah kepada a
"terapung".

T_NV
Nombor titik terapung Perl. Sama seperti T_IV dan T_UV kerana jenis pemulangan dilemparkan
kepada jenis angka yang diminta dan bukannya kepada jenis tertentu.

T_DOUBLE
Nombor titik terapung berketepatan ganda. Peta taip ini menjamin untuk mengembalikan pembolehubah
melontarkan kepada "berganda".

T_PV
Rentetan (char *).

T_PTR
Alamat ingatan (penunjuk). Biasanya dikaitkan dengan jenis "void *".

T_PTRREF
Serupa dengan T_PTR kecuali penunjuk disimpan dalam skalar dan rujukan kepada
skalar itu dikembalikan kepada pemanggil. Ini boleh digunakan untuk menyembunyikan penunjuk sebenar
nilai daripada pengaturcara kerana ia biasanya tidak diperlukan secara langsung dari dalam perl.

Peta taip menyemak bahawa rujukan skalar dihantar dari perl ke XS.

T_PTROBJ
Sama seperti T_PTRREF kecuali rujukan itu diberkati ke dalam kelas. Ini membenarkan
penunjuk untuk digunakan sebagai objek. Paling biasa digunakan untuk menangani struktur C. The
peta taip menyemak bahawa objek perl yang dihantar ke dalam rutin XS adalah daripada kelas yang betul
(atau sebahagian daripada subkelas).

Penunjuk diberkati ke dalam kelas yang berasal daripada nama jenis
penunjuk tetapi dengan semua '*' dalam nama digantikan dengan 'Ptr'.

Untuk XSUB "DESTROY" sahaja, T_PTROBJ dioptimumkan kepada T_PTRREF. Ini bermakna kelas
cek dilangkau.

T_REF_IV_REF
BELUM LAGI

T_REF_IV_PTR
Sama seperti T_PTROBJ kerana penunjuk diberkati menjadi objek skalar. The
Perbezaannya ialah apabila objek itu dihantar semula ke XS ia mestilah betul
jenis (warisan tidak disokong) manakala T_PTROBJ menyokong warisan.

Penunjuk diberkati ke dalam kelas yang berasal daripada nama jenis
penunjuk tetapi dengan semua '*' dalam nama digantikan dengan 'Ptr'.

Untuk XSUB "DESTROY" sahaja, T_REF_IV_PTR dioptimumkan kepada T_PTRREF. Ini bermakna
pemeriksaan kelas dilangkau.

T_PTRDESC
BELUM LAGI

T_REFREF
Sama dengan T_PTRREF, kecuali penunjuk yang disimpan dalam skalar yang dirujuk ialah
dinyahrujuk dan disalin ke pembolehubah keluaran. Ini bermakna T_REFREF adalah untuk
T_PTRREF kerana T_OPAQUE adalah kepada T_OPAQUEPTR. Semua siap?

Hanya bahagian INPUT ini dilaksanakan (Perl hingga XSUB) dan tiada pengguna yang diketahui
dalam teras atau pada CPAN.

T_REFOBJ
Seperti T_REFREF, kecuali ia melakukan pemeriksaan jenis yang ketat (warisan tidak disokong).

Untuk XSUB "DESTROY" sahaja, T_REFOBJ dioptimumkan kepada T_REFREF. Ini bermakna kelas
cek dilangkau.

T_OPAQUEPTR
Ini boleh digunakan untuk menyimpan bait dalam komponen rentetan SV. Di sini
perwakilan data adalah tidak berkaitan dengan perl dan bait itu sendiri adalah adil
disimpan dalam SV. Diandaikan bahawa pembolehubah C adalah penunjuk (bait disalin
dari lokasi ingatan itu). Jika penunjuk menunjuk kepada sesuatu yang
diwakili oleh 8 bait maka 8 bait tersebut disimpan dalam SV (dan panjang () akan
laporkan nilai 8). Entri ini serupa dengan T_OPAQUE.

Pada prinsipnya buka bungkusan() arahan boleh digunakan untuk menukar bait kembali kepada nombor
(jika jenis asas diketahui sebagai nombor).

Entri ini boleh digunakan untuk menyimpan struktur C (bilangan bait untuk disalin ialah
dikira menggunakan fungsi "sizeof" C) dan boleh digunakan sebagai alternatif kepada
T_PTRREF tanpa perlu risau tentang kebocoran memori (memandangkan Perl akan membersihkan
SV).

T_OPAQUE
Ini boleh digunakan untuk menyimpan data daripada jenis bukan penuding dalam bahagian rentetan SV. Ia
adalah serupa dengan T_OPAQUEPTR kecuali peta taip mendapatkan kembali penunjuk secara langsung
daripada menganggap ia sedang dibekalkan. Contohnya, jika integer diimport ke dalam
Perl menggunakan T_OPAQUE dan bukannya T_IV bait asas yang mewakili integer
akan disimpan dalam SV tetapi nilai integer sebenar tidak akan tersedia. iaitu The
data adalah legap kepada perl.

Data boleh diambil menggunakan fungsi "buka bungkusan" jika jenis asasnya
aliran bait diketahui.

T_OPAQUE menyokong input dan output jenis mudah. T_OPAQUEPTR boleh digunakan untuk lulus
bait ini kembali ke C jika penunjuk boleh diterima.

Tatasusunan tersirat
xsubpp menyokong sintaks khas untuk mengembalikan tatasusunan C yang dibungkus ke perl. Jika XS
jenis pulangan diberikan sebagai

tatasusunan(jenis, nelem)

xsubpp akan menyalin kandungan "nelem * sizeof(type)" bait daripada RETVAL ke SV dan
tolak ke atas timbunan. Ini hanya benar-benar berguna jika bilangan item yang akan
dikembalikan diketahui pada masa penyusunan dan anda tidak keberatan mempunyai rentetan bait dalam anda
SV. Gunakan T_ARRAY untuk menolak bilangan argumen yang berubah-ubah ke timbunan kembali (mereka
tidak akan dibungkus sebagai satu rentetan sekalipun).

Ini sama seperti menggunakan T_OPAQUEPTR tetapi boleh digunakan untuk memproses lebih daripada satu elemen.

T_PACKED
Memanggil fungsi yang dibekalkan pengguna untuk penukaran. Untuk "OUTPUT" (XSUB ke Perl), satu fungsi
bernama "XS_pack_$ntype" dipanggil dengan keluaran skalar Perl dan pembolehubah C kepada
menukar daripada. $ntype ialah jenis C ternormal yang akan dipetakan ke Perl.
Dinormalkan bermakna semua "*" digantikan dengan rentetan "Ptr". Nilai pulangan bagi
fungsi diabaikan.

Sebaliknya untuk pemetaan "INPUT" (Perl ke XSUB), fungsi dinamakan "XS_unpack_$ntype"
dipanggil dengan input skalar Perl sebagai hujah dan nilai pulangan dibuang ke
jenis C dipetakan dan diberikan kepada pembolehubah output C.

Contoh fungsi penukaran untuk struct bertaip "foo_t *" mungkin:

kekosongan statik
XS_pack_foo_tPtr(SV *keluar, foo_t *in)
{
dTHX; /* sayangnya, tandatangan tidak termasuk pTHX_ */
HV* hash = newHV();
hv_stores(hash, "int_member", newSViv(in->int_member));
hv_stores(cincang, "ahli_terapung", newSVnv(dalam->ahli_terapung));
/* ... */

/* matikan kerana timbunan anda tidak dikira semula */
sv_setsv(keluar, sv_2mortal(newRV_noinc((SV*)cincang)));
}

Penukaran dari Perl ke C dibiarkan sebagai latihan kepada pembaca, tetapi prototaip
akan menjadi:

statik foo_t *
XS_unpack_foo_tPtr(SV *in);

Daripada fungsi C sebenar yang perlu mengambil konteks benang menggunakan "dTHX", anda
boleh menentukan makro dengan nama yang sama dan mengelakkan overhed. Juga, ingat untuk
mungkin membebaskan memori yang diperuntukkan oleh "XS_unpack_foo_tPtr".

T_PACKEDARRAY
T_PACKEDARRAY adalah serupa dengan T_PACKED. Sebenarnya, peta taip "INPUT" (Perl to XSUB) ialah
sama, tetapi peta taip "OUTPUT" memberikan hujah tambahan kepada
Fungsi "XS_pack_$ntype". Parameter ketiga ini menunjukkan bilangan elemen dalam
output supaya fungsi boleh mengendalikan tatasusunan C dengan waras. Pembolehubah perlu
diisytiharkan oleh pengguna dan mesti mempunyai nama "count_$ntype" di mana $ntype ialah
nama jenis C yang dinormalkan seperti yang dijelaskan di atas. Tandatangan fungsi itu adalah untuk
contoh di atas dan "foo_t **":

kekosongan statik
XS_pack_foo_tPtrPtr(SV *out, foo_t *in, UV count_foo_tPtrPtr);

Jenis parameter ketiga adalah sewenang-wenangnya sejauh peta taip berkenaan. Ia
hanya perlu selaras dengan pembolehubah yang diisytiharkan.

Sudah tentu, melainkan anda mengetahui bilangan elemen dalam tatasusunan "sometype **" C, dalam
XSUB anda, nilai pulangan daripada "foo_t ** XS_unpack_foo_tPtrPtr(...)" sukar untuk
mentafsir. Memandangkan butiran semuanya terpulang kepada pengarang XS (pengguna peta taip), ada
beberapa penyelesaian, tiada satu pun yang sangat elegan. Yang paling biasa dilihat
penyelesaiannya ialah memperuntukkan memori untuk penunjuk N+1 dan memberikan "NULL" kepada (N+1) ke
untuk memudahkan lelaran.

Sebagai alternatif, menggunakan peta taip tersuai untuk tujuan anda pada mulanya ialah
mungkin lebih baik.

T_DATAUNIT
BELUM LAGI

T_CALLBACK
BELUM LAGI

T_ARRAY
Ini digunakan untuk menukar senarai hujah perl kepada tatasusunan C dan untuk menolak
kandungan tatasusunan C pada timbunan argumen perl.

Tandatangan panggilan biasa ialah

@out = array_func( @in );

Sebarang bilangan argumen boleh berlaku dalam senarai sebelum tatasusunan tetapi input dan
tatasusunan output mestilah elemen terakhir dalam senarai.

Apabila digunakan untuk menghantar senarai perl kepada C, penulis XS mesti menyediakan fungsi (dinamakan selepas
jenis tatasusunan tetapi dengan 'Ptr' digantikan dengan '*') untuk memperuntukkan memori yang diperlukan
pegang senarai. Penunjuk harus dikembalikan. Terpulang kepada penulis XS untuk membebaskannya
memori semasa keluar daripada fungsi. Pembolehubah "ix_$var" ditetapkan kepada bilangan
elemen dalam tatasusunan baharu.

Apabila mengembalikan tatasusunan C ke Perl, penulis XS mesti menyediakan pembolehubah integer dipanggil
"size_$var" yang mengandungi bilangan elemen dalam tatasusunan. Ini digunakan untuk menentukan
berapa banyak elemen yang perlu ditolak ke timbunan hujah pulangan. Ini bukan
diperlukan pada input kerana Perl tahu berapa banyak hujah dalam timbunan apabila
rutin dipanggil. Biasanya pembolehubah ini akan dipanggil "size_RETVAL".

Selain itu, jenis setiap elemen ditentukan daripada jenis tatasusunan. Jika
tatasusunan menggunakan jenis "intArray *" xsubpp secara automatik akan mengetahui bahawa ia mengandungi
pembolehubah jenis "int" dan gunakan entri peta taip itu untuk melaksanakan salinan setiap satu
unsur. Semua teg penunjuk '*' dan 'Array' dialih keluar daripada nama untuk menentukan
subjenis.

T_STDIO
Ini digunakan untuk menghantar failhandle perl ke dan dari C menggunakan struktur "FILE *".

T_INOUT
Ini digunakan untuk menghantar pemegang fail perl ke dan dari C menggunakan struktur "PerlIO *".
Pemegang fail boleh digunakan untuk membaca dan menulis. Ini sepadan dengan mod "+<",
lihat juga T_IN dan T_OUT.

Lihat perliol untuk mendapatkan maklumat lanjut tentang lapisan abstraksi Perl IO. Perl pasti begitu
dibina dengan "-Duseperlio".

Tiada semakan untuk menegaskan bahawa pemegang fail yang dihantar dari Perl ke C telah dicipta dengan
mod "open()" yang betul.

Petunjuk: Tutorial perlxstut merangkumi jenis T_INOUT, T_IN dan T_OUT XS dengan baik.

T_IN
Sama seperti T_INOUT, tetapi pemegang fail yang dikembalikan dari C ke Perl hanya boleh digunakan
untuk membaca (mod "<").

T_OUT
Sama seperti T_INOUT, tetapi pemegang fail yang dikembalikan dari C ke Perl ditetapkan untuk menggunakan
buka mod "+>".

Gunakan perlxstypemap dalam talian menggunakan perkhidmatan onworks.net