typedef short shortOPQ; /* T_OPAQUE */
typedef int intOpq; /* T_OPAQUEPTR */
typedef unsigned intUnsigned; /* T_U_INT */
+typedef PerlIO * inputfh; /* T_IN */
+typedef PerlIO * outputfh; /* T_OUT */
-/* A structure to test T_OPAQUEPTR */
+/* A structure to test T_OPAQUEPTR and T_PACKED */
struct t_opaqueptr {
int a;
int b;
};
typedef struct t_opaqueptr astruct;
+typedef struct t_opaqueptr anotherstruct;
/* Some static memory for the tests */
static I32 xst_anint;
return array;
}
+/* test T_PACKED */
+STATIC void
+XS_pack_anotherstructPtr(SV *out, anotherstruct *in)
+{
+ dTHX;
+ HV *hash = newHV();
+ if (NULL == hv_stores(hash, "a", newSViv(in->a)))
+ croak("Failed to store data in hash");
+ if (NULL == hv_stores(hash, "b", newSViv(in->b)))
+ croak("Failed to store data in hash");
+ if (NULL == hv_stores(hash, "c", newSVnv(in->c)))
+ croak("Failed to store data in hash");
+ sv_setsv(out, sv_2mortal(newRV_noinc((SV*)hash)));
+}
+
+STATIC anotherstruct *
+XS_unpack_anotherstructPtr(SV *in)
+{
+ dTHX; /* rats, this is expensive */
+ /* this is similar to T_HVREF since we chose to use a hash */
+ HV *inhash;
+ SV **elem;
+ anotherstruct *out;
+ SV *const tmp = in;
+ SvGETMAGIC(tmp);
+ if (SvROK(tmp) && SvTYPE(SvRV(tmp)) == SVt_PVHV)
+ inhash = (HV*)SvRV(tmp);
+ else
+ Perl_croak(aTHX_ "Argument is not a HASH reference");
+
+ /* FIXME dunno if supposed to use perl mallocs here */
+ Newxz(out, 1, anotherstruct);
+
+ elem = hv_fetchs(inhash, "a", 0);
+ if (elem == NULL)
+ Perl_croak(aTHX_ "Shouldn't happen: hv_fetchs returns NULL");
+ out->a = SvIV(*elem);
+
+ elem = hv_fetchs(inhash, "b", 0);
+ if (elem == NULL)
+ Perl_croak(aTHX_ "Shouldn't happen: hv_fetchs returns NULL");
+ out->b = SvIV(*elem);
+
+ elem = hv_fetchs(inhash, "c", 0);
+ if (elem == NULL)
+ Perl_croak(aTHX_ "Shouldn't happen: hv_fetchs returns NULL");
+ out->c = SvNV(*elem);
+
+ return out;
+}
+
+/* test T_PACKEDARRAY */
+STATIC void
+XS_pack_anotherstructPtrPtr(SV *out, anotherstruct **in, UV cnt)
+{
+ dTHX;
+ UV i;
+ AV *ary = newAV();
+ for (i = 0; i < cnt; ++i) {
+ HV *hash = newHV();
+ if (NULL == hv_stores(hash, "a", newSViv(in[i]->a)))
+ croak("Failed to store data in hash");
+ if (NULL == hv_stores(hash, "b", newSViv(in[i]->b)))
+ croak("Failed to store data in hash");
+ if (NULL == hv_stores(hash, "c", newSVnv(in[i]->c)))
+ croak("Failed to store data in hash");
+ av_push(ary, newRV_noinc((SV*)hash));
+ }
+ sv_setsv(out, sv_2mortal(newRV_noinc((SV*)ary)));
+}
+
+STATIC anotherstruct **
+XS_unpack_anotherstructPtrPtr(SV *in)
+{
+ dTHX; /* rats, this is expensive */
+ /* this is similar to T_HVREF since we chose to use a hash */
+ HV *inhash;
+ AV *inary;
+ SV **elem;
+ anotherstruct **out;
+ UV nitems, i;
+ SV *tmp;
+
+ /* safely deref the input array ref */
+ tmp = in;
+ SvGETMAGIC(tmp);
+ if (SvROK(tmp) && SvTYPE(SvRV(tmp)) == SVt_PVAV)
+ inary = (AV*)SvRV(tmp);
+ else
+ Perl_croak(aTHX_ "Argument is not an ARRAY reference");
+
+ nitems = av_tindex(inary) + 1;
+
+ /* FIXME dunno if supposed to use perl mallocs here */
+ /* N+1 elements so we know the last one is NULL */
+ Newxz(out, nitems+1, anotherstruct*);
+
+ /* WARNING: in real code, we'd have to Safefree() on exception, but
+ * since we're testing perl, if we croak() here, stuff is
+ * rotten anyway! */
+ for (i = 0; i < nitems; ++i) {
+ Newxz(out[i], 1, anotherstruct);
+ elem = av_fetch(inary, i, 0);
+ if (elem == NULL)
+ Perl_croak(aTHX_ "Shouldn't happen: av_fetch returns NULL");
+ tmp = *elem;
+ SvGETMAGIC(tmp);
+ if (SvROK(tmp) && SvTYPE(SvRV(tmp)) == SVt_PVHV)
+ inhash = (HV*)SvRV(tmp);
+ else
+ Perl_croak(aTHX_ "Array element %"UVuf" is not a HASH reference", i);
+
+ elem = hv_fetchs(inhash, "a", 0);
+ if (elem == NULL)
+ Perl_croak(aTHX_ "Shouldn't happen: hv_fetchs returns NULL");
+ out[i]->a = SvIV(*elem);
+
+ elem = hv_fetchs(inhash, "b", 0);
+ if (elem == NULL)
+ Perl_croak(aTHX_ "Shouldn't happen: hv_fetchs returns NULL");
+ out[i]->b = SvIV(*elem);
+
+ elem = hv_fetchs(inhash, "c", 0);
+ if (elem == NULL)
+ Perl_croak(aTHX_ "Shouldn't happen: hv_fetchs returns NULL");
+ out[i]->c = SvNV(*elem);
+ }
+
+ return out;
+}
+
+/* no special meaning as far as typemaps are concerned,
+ * just for convenience */
+void
+XS_release_anotherstructPtrPtr(anotherstruct **in)
+{
+ unsigned int i = 0;
+ while (in[i] != NULL)
+ Safefree(in[i++]);
+ Safefree(in);
+}
+
MODULE = XS::Typemap PACKAGE = XS::Typemap
# there is not a corresponding type explicitly identified in the standard
# typemap
-svtype T_ENUM
-intRef * T_PTRREF
-intRef T_IV
-intObj * T_PTROBJ
-intObj T_IV
-intRefIv * T_REF_IV_PTR
-intRefIv T_IV
-intArray * T_ARRAY
-intOpq T_IV
-intOpq * T_OPAQUEPTR
-intUnsigned T_U_INT
-intTINT T_INT
-intTLONG T_LONG
-shortOPQ T_OPAQUE
-shortOPQ * T_OPAQUEPTR
-astruct * T_OPAQUEPTR
-AV_FIXED * T_AVREF_REFCOUNT_FIXED
-HV_FIXED * T_HVREF_REFCOUNT_FIXED
-CV_FIXED * T_CVREF_REFCOUNT_FIXED
-SVREF_FIXED T_SVREF_REFCOUNT_FIXED
+svtype T_ENUM
+intRef * T_PTRREF
+intRef T_IV
+intObj * T_PTROBJ
+intObj T_IV
+intRefIv * T_REF_IV_PTR
+intRefIv T_IV
+intArray * T_ARRAY
+intOpq T_IV
+intOpq * T_OPAQUEPTR
+intUnsigned T_U_INT
+intTINT T_INT
+intTLONG T_LONG
+shortOPQ T_OPAQUE
+shortOPQ * T_OPAQUEPTR
+astruct * T_OPAQUEPTR
+anotherstruct * T_PACKED
+anotherstruct ** T_PACKEDARRAY
+AV_FIXED * T_AVREF_REFCOUNT_FIXED
+HV_FIXED * T_HVREF_REFCOUNT_FIXED
+CV_FIXED * T_CVREF_REFCOUNT_FIXED
+SVREF_FIXED T_SVREF_REFCOUNT_FIXED
+inputfh T_IN
+outputfh T_OUT
END_OF_TYPEMAP
-=head1 TYPEMAPS
-
-The more you think about interfacing between two languages, the more
-you'll realize that the majority of programmer effort has to go into
-converting between the data structures that are native to either of
-the languages involved. This trumps other matter such as differing
-calling conventions because the problem space is so much greater.
-There are simply more ways to shove data into memory than there are
-ways to implement a function call.
-
-Perl XS' attempt at a solution to this is the concept of typemaps.
-At an abstract level, a Perl XS typemap is nothing but a recipe for
-converting from a certain Perl data structure to a certain C
-data structure and/or vice versa. Since there can be C types that
-are sufficiently similar to warrant converting with the same logic,
-XS typemaps are represented by a unique identifier, called XS type
-henceforth in this document. You can then tell the XS compiler that
-multiple C types are to be mapped with the same XS typemap.
-
-In your XS code, when you define an argument with a C type or when
-you are using a C<CODE:> and an C<OUTPUT:> section together with a
-C return type of your XSUB, it'll be the typemapping mechanism that
-makes this easy.
-
-=head2 Anatomy of a typemap File
-
-Traditionally, typemaps needed to be written to a separate file,
-conventionally called C<typemap>. With ExtUtils::ParseXS (the XS
-compiler) version 3.00 or better (comes with perl 5.16), typemaps
-can also be embedded directly into your XS code using a HERE-doc
-like syntax:
-
- TYPEMAP: <<HERE
- ...
- HERE
-
-where C<HERE> can be replaced by other identifiers like with normal
-Perl HERE-docs. All details below about the typemap textual format
-remain valid.
-
-A typemap file generally has three sections: The C<TYPEMAP>
-section is used to associate C types with XS type identifiers.
-The C<INPUT> section is used to define the typemaps for I<input>
-into the XSUB from Perl, and the C<OUTPUT> section has the opposite
-conversion logic for getting data out of an XSUB back into Perl.
-
-Each section is started by the section name in capital letters on a
-line of its own. A typemap file implicitly starts in the C<TYPEMAP>
-section. Each type of section can appear an arbitrary number of times
-and does not have to appear at all. For example, a typemap file may
-lack C<INPUT> and C<OUTPUT> sections if all it needs to do is
-associate additional C types with core XS types like T_PTROBJ.
-Lines that start with a hash C<#> are considered comments and ignored
-in the C<TYPEMAP> section, but are considered significant in C<INPUT>
-and C<OUTPUT>. Blank lines are generally ignored.
-
-The C<TYPEMAP> section should contain one pair of C type and
-XS type per line as follows. An example from the core typemap file:
-
- TYPEMAP
- # all variants of char* is handled by the T_PV typemap
- char * T_PV
- const char * T_PV
- unsigned char * T_PV
- ...
-
-The C<INPUT> and C<OUTPUT> sections have identical formats, that is,
-each unindented line starts a new in- or output map respectively.
-A new in- or output map must start with the name of the XS type to
-map on a line by itself, followed by the code that implements it
-indented on the following lines. Example:
-
- INPUT
- T_PV
- $var = ($type)SvPV_nolen($arg)
- T_PTR
- $var = INT2PTR($type,SvIV($arg))
-
-We'll get to the meaning of those Perlish-looking variables in a
-little bit.
-
-Finally, here's an example of the full typemap file for mapping C
-strings of the C<char *> type to Perl scalars/strings:
-
- TYPEMAP
- char * T_PV
-
- INPUT
- T_PV
- $var = ($type)SvPV_nolen($arg)
-
- OUTPUT
- T_PV
- sv_setpv((SV*)$arg, $var);
-
-=head2 The Role of the typemap File in Your Distribution
-
-For CPAN distributions, you can assume that the XS types defined by
-the perl core are already available. Additionally, the core typemap
-has default XS types for a large number of C types. For example, if
-you simply return a C<char *> from your XSUB, the core typemap will
-have this C type associated with the T_PV XS type. That means your
-C string will be copied into the PV (pointer value) slot of a new scalar
-that will be returned from your XSUB to to Perl.
-
-If you're developing a CPAN distribution using XS, you may add your own
-file called F<typemap> to the distribution. That file may contain
-typemaps that either map types that are specific to your code or that
-override the core typemap file's mappings for common C types.
-
-=head2 Full Listing of Core Typemaps
-
-Each C type is represented by an entry in the typemap file that
-is responsible for converting perl variables (SV, AV, HV, CV, etc.)
-to and from that type. The following sections list all XS types
-that come with perl by default.
-
-=over 4
-
-=item T_SV
-
-This simply passes the C representation of the Perl variable (an SV*)
-in and out of the XS layer. This can be used if the C code wants
-to deal directly with the Perl variable.
-
-=cut
+
+## T_SV
SV *
T_SV( sv )
OUTPUT:
RETVAL
-=item T_SVREF
-Used to pass in and return a reference to an SV.
-
-Note that this typemap does not decrement the reference count
-when returning the reference to an SV*.
-See also: T_SVREF_REFCOUNT_FIXED
-
-=cut
+## T_SVREF
SVREF
T_SVREF( svref )
OUTPUT:
RETVAL
-=item T_SVREF_FIXED
-
-Used to pass in and return a reference to an SV.
-This is a fixed
-variant of T_SVREF that decrements the refcount appropriately
-when returning a reference to an SV*. Introduced in perl 5.15.4.
-=cut
+## T_SVREF_FIXED
SVREF_FIXED
T_SVREF_REFCOUNT_FIXED( svref )
OUTPUT:
RETVAL
-=item T_AVREF
-From the perl level this is a reference to a perl array.
-From the C level this is a pointer to an AV.
-
-Note that this typemap does not decrement the reference count
-when returning an AV*. See also: T_AVREF_REFCOUNT_FIXED
-
-=cut
+## T_AVREF
AV *
T_AVREF( av )
OUTPUT:
RETVAL
-=item T_AVREF_REFCOUNT_FIXED
-From the perl level this is a reference to a perl array.
-From the C level this is a pointer to an AV. This is a fixed
-variant of T_AVREF that decrements the refcount appropriately
-when returning an AV*. Introduced in perl 5.15.4.
-
-=cut
+## T_AVREF_REFCOUNT_FIXED
AV_FIXED*
T_AVREF_REFCOUNT_FIXED( av )
OUTPUT:
RETVAL
-=item T_HVREF
-
-From the perl level this is a reference to a perl hash.
-From the C level this is a pointer to an HV.
-Note that this typemap does not decrement the reference count
-when returning an HV*. See also: T_HVREF_REFCOUNT_FIXED
-
-=cut
+## T_HVREF
HV *
T_HVREF( hv )
OUTPUT:
RETVAL
-=item T_HVREF_REFCOUNT_FIXED
-
-From the perl level this is a reference to a perl hash.
-From the C level this is a pointer to an HV. This is a fixed
-variant of T_HVREF that decrements the refcount appropriately
-when returning an HV*. Introduced in perl 5.15.4.
-=cut
+## T_HVREF_REFCOUNT_FIXED
HV_FIXED*
T_HVREF_REFCOUNT_FIXED( hv )
RETVAL
-=item T_CVREF
-
-From the perl level this is a reference to a perl subroutine
-(e.g. $sub = sub { 1 };). From the C level this is a pointer
-to a CV.
-
-Note that this typemap does not decrement the reference count
-when returning an HV*. See also: T_HVREF_REFCOUNT_FIXED
-
-=cut
+## T_CVREF
CV *
T_CVREF( cv )
OUTPUT:
RETVAL
-=item T_CVREF_REFCOUNT_FIXED
-
-From the perl level this is a reference to a perl subroutine
-(e.g. $sub = sub { 1 };). From the C level this is a pointer
-to a CV.
-
-This is a fixed
-variant of T_HVREF that decrements the refcount appropriately
-when returning an HV*. Introduced in perl 5.15.4.
-=cut
+## T_CVREF_REFCOUNT_FIXED
CV_FIXED *
T_CVREF_REFCOUNT_FIXED( cv )
OUTPUT:
RETVAL
-=item T_SYSRET
-
-The T_SYSRET typemap is used to process return values from system calls.
-It is only meaningful when passing values from C to perl (there is
-no concept of passing a system return value from Perl to C).
-
-System calls return -1 on error (setting ERRNO with the reason)
-and (usually) 0 on success. If the return value is -1 this typemap
-returns C<undef>. If the return value is not -1, this typemap
-translates a 0 (perl false) to "0 but true" (which
-is perl true) or returns the value itself, to indicate that the
-command succeeded.
-
-The L<POSIX|POSIX> module makes extensive use of this type.
-=cut
+## T_SYSRET
# Test a successful return
OUTPUT:
RETVAL
-=item T_UV
-
-An unsigned integer.
-
-=cut
+## T_UV
unsigned int
T_UV( uv )
OUTPUT:
RETVAL
-=item T_IV
-A signed integer. This is cast to the required integer type when
-passed to C and converted to an IV when passed back to Perl.
-
-=cut
+## T_IV
long
T_IV( iv )
OUTPUT:
RETVAL
-=item T_INT
-
-A signed integer. This typemap converts the Perl value to a native
-integer type (the C<int> type on the current platform). When returning
-the value to perl it is processed in the same way as for T_IV.
-Its behaviour is identical to using an C<int> type in XS with T_IV.
-
-=cut
+## T_INT
intTINT
T_INT( i )
OUTPUT:
RETVAL
-=item T_ENUM
-
-An enum value. Used to transfer an enum component
-from C. There is no reason to pass an enum value to C since
-it is stored as an IV inside perl.
-=cut
+## T_ENUM
# The test should return the value for SVt_PVHV.
# 11 at the present time but we can't not rely on this
OUTPUT:
RETVAL
-=item T_BOOL
-
-A boolean type. This can be used to pass true and false values to and
-from C.
-=cut
+## T_BOOL
bool
T_BOOL( in )
OUTPUT:
RETVAL
-=item T_U_INT
+bool
+T_BOOL_2( in )
+ bool in
+ CODE:
+ PERL_UNUSED_VAR(RETVAL);
+ OUTPUT:
+ in
-This is for unsigned integers. It is equivalent to using T_UV
-but explicitly casts the variable to type C<unsigned int>.
-The default type for C<unsigned int> is T_UV.
+void
+T_BOOL_OUT( out, in )
+ bool out
+ bool in
+ CODE:
+ out = in;
+ OUTPUT:
+ out
-=cut
+## T_U_INT
intUnsigned
T_U_INT( uint )
OUTPUT:
RETVAL
-=item T_SHORT
-
-Short integers. This is equivalent to T_IV but explicitly casts
-the return to type C<short>. The default typemap for C<short>
-is T_IV.
-=cut
+## T_SHORT
short
T_SHORT( s )
OUTPUT:
RETVAL
-=item T_U_SHORT
-
-Unsigned short integers. This is equivalent to T_UV but explicitly
-casts the return to type C<unsigned short>. The default typemap for
-C<unsigned short> is T_UV.
-
-T_U_SHORT is used for type C<U16> in the standard typemap.
-=cut
+## T_U_SHORT
U16
T_U_SHORT( in )
RETVAL
-=item T_LONG
-
-Long integers. This is equivalent to T_IV but explicitly casts
-the return to type C<long>. The default typemap for C<long>
-is T_IV.
-
-=cut
+## T_LONG
intTLONG
T_LONG( in )
OUTPUT:
RETVAL
-=item T_U_LONG
-
-Unsigned long integers. This is equivalent to T_UV but explicitly
-casts the return to type C<unsigned long>. The default typemap for
-C<unsigned long> is T_UV.
-
-T_U_LONG is used for type C<U32> in the standard typemap.
-
-=cut
+## T_U_LONG
U32
T_U_LONG( in )
OUTPUT:
RETVAL
-=item T_CHAR
-Single 8-bit characters.
-
-=cut
+## T_CHAR
char
T_CHAR( in );
RETVAL
-=item T_U_CHAR
-
-An unsigned byte.
-
-=cut
+## T_U_CHAR
unsigned char
T_U_CHAR( in );
RETVAL
-=item T_FLOAT
-
-A floating point number. This typemap guarantees to return a variable
-cast to a C<float>.
-
-=cut
+## T_FLOAT
float
T_FLOAT( in )
OUTPUT:
RETVAL
-=item T_NV
-A Perl floating point number. Similar to T_IV and T_UV in that the
-return type is cast to the requested numeric type rather than
-to a specific type.
-
-=cut
+## T_NV
NV
T_NV( in )
OUTPUT:
RETVAL
-=item T_DOUBLE
-
-A double precision floating point number. This typemap guarantees to
-return a variable cast to a C<double>.
-=cut
+## T_DOUBLE
double
T_DOUBLE( in )
OUTPUT:
RETVAL
-=item T_PV
-A string (char *).
-
-=cut
+## T_PV
char *
T_PV( in )
OUTPUT:
RETVAL
-=item T_PTR
+char *
+T_PV_null()
+ CODE:
+ RETVAL = NULL;
+ OUTPUT:
+ RETVAL
-A memory address (pointer). Typically associated with a C<void *>
-type.
-=cut
+## T_PTR
# Pass in a value. Store the value in some static memory and
# then return the pointer
OUTPUT:
RETVAL
-=item T_PTRREF
-Similar to T_PTR except that the pointer is stored in a scalar and the
-reference to that scalar is returned to the caller. This can be used
-to hide the actual pointer value from the programmer since it is usually
-not required directly from within perl.
-
-The typemap checks that a scalar reference is passed from perl to XS.
-
-=cut
+## T_PTRREF
# Similar test to T_PTR
# Pass in a value. Store the value in some static memory and
RETVAL
-
-=item T_PTROBJ
-
-Similar to T_PTRREF except that the reference is blessed into a class.
-This allows the pointer to be used as an object. Most commonly used to
-deal with C structs. The typemap checks that the perl object passed
-into the XS routine is of the correct class (or part of a subclass).
-
-The pointer is blessed into a class that is derived from the name
-of type of the pointer but with all '*' in the name replaced with
-'Ptr'.
-
-=cut
+## T_PTROBJ
# Similar test to T_PTRREF
# Pass in a value. Store the value in some static memory and
MODULE = XS::Typemap PACKAGE = XS::Typemap
-=item T_REF_IV_REF
-
-NOT YET
-=item T_REF_IV_PTR
+## T_REF_IV_REF
+## NOT YET
-Similar to T_PTROBJ in that the pointer is blessed into a scalar object.
-The difference is that when the object is passed back into XS it must be
-of the correct type (inheritance is not supported).
-The pointer is blessed into a class that is derived from the name
-of type of the pointer but with all '*' in the name replaced with
-'Ptr'.
-
-=cut
+## T_REF_IV_PTR
# Similar test to T_PTROBJ
# Pass in a value. Store the value in some static memory and
MODULE = XS::Typemap PACKAGE = XS::Typemap
-=item T_PTRDESC
-
-NOT YET
-
-=item T_REFREF
-
-Similar to T_PTRREF, except the pointer stored in the referenced scalar
-is dereferenced and copied to the output variable. This means that
-T_REFREF is to T_PTRREF as T_OPAQUE is to T_OPAQUEPTR. All clear?
-
-Only the INPUT part of this is implemented (Perl to XSUB) and there
-are no known users in core or on CPAN.
-
-=cut
-
-=item T_REFOBJ
+## T_PTRDESC
+## NOT YET
-NOT YET
-=item T_OPAQUEPTR
+## T_REFREF
+## NOT YET
-This can be used to store bytes in the string component of the
-SV. Here the representation of the data is irrelevant to perl and the
-bytes themselves are just stored in the SV. It is assumed that the C
-variable is a pointer (the bytes are copied from that memory
-location). If the pointer is pointing to something that is
-represented by 8 bytes then those 8 bytes are stored in the SV (and
-length() will report a value of 8). This entry is similar to T_OPAQUE.
-In principal the unpack() command can be used to convert the bytes
-back to a number (if the underlying type is known to be a number).
+## T_REFOBJ
+## NOT YET
-This entry can be used to store a C structure (the number
-of bytes to be copied is calculated using the C C<sizeof> function)
-and can be used as an alternative to T_PTRREF without having to worry
-about a memory leak (since Perl will clean up the SV).
-=cut
+## T_OPAQUEPTR
intOpq *
T_OPAQUEPTR_IN( val )
XPUSHs(sv_2mortal(newSVnv(test->c)));
-=item T_OPAQUE
-
-This can be used to store data from non-pointer types in the string
-part of an SV. It is similar to T_OPAQUEPTR except that the
-typemap retrieves the pointer directly rather than assuming it
-is being supplied. For example, if an integer is imported into
-Perl using T_OPAQUE rather than T_IV the underlying bytes representing
-the integer will be stored in the SV but the actual integer value will not
-be available. i.e. The data is opaque to perl.
-
-The data may be retrieved using the C<unpack> function if the
-underlying type of the byte stream is known.
-
-T_OPAQUE supports input and output of simple types.
-T_OPAQUEPTR can be used to pass these bytes back into C if a pointer
-is acceptable.
-
-=cut
+## T_OPAQUE
shortOPQ
T_OPAQUE_IN( val )
OUTPUT:
RETVAL
-=item Implicit array
-
-xsubpp supports a special syntax for returning
-packed C arrays to perl. If the XS return type is given as
-
- array(type, nelem)
-
-xsubpp will copy the contents of C<nelem * sizeof(type)> bytes from
-RETVAL to an SV and push it onto the stack. This is only really useful
-if the number of items to be returned is known at compile time and you
-don't mind having a string of bytes in your SV. Use T_ARRAY to push a
-variable number of arguments onto the return stack (they won't be
-packed as a single string though).
-
-This is similar to using T_OPAQUEPTR but can be used to process more than
-one element.
-
-=cut
-
array(int,3)
T_OPAQUE_array( a,b,c)
int a
RETVAL
-=item T_PACKED
-
-NOT YET
-
-=item T_PACKEDARRAY
-
-NOT YET
-
-=item T_DATAUNIT
+## T_PACKED
-NOT YET
-
-=item T_CALLBACK
-
-NOT YET
-
-=item T_ARRAY
+void
+T_PACKED_in(in)
+ anotherstruct *in;
+ PPCODE:
+ mXPUSHi(in->a);
+ mXPUSHi(in->b);
+ mXPUSHn(in->c);
+ Safefree(in);
+ XSRETURN(3);
+
+anotherstruct *
+T_PACKED_out(a, b ,c)
+ int a;
+ int b;
+ double c;
+ CODE:
+ Newxz(RETVAL, 1, anotherstruct);
+ RETVAL->a = a;
+ RETVAL->b = b;
+ RETVAL->c = c;
+ OUTPUT: RETVAL
+ CLEANUP:
+ Safefree(RETVAL);
-This is used to convert the perl argument list to a C array
-and for pushing the contents of a C array onto the perl
-argument stack.
+## T_PACKEDARRAY
-The usual calling signature is
+void
+T_PACKEDARRAY_in(in)
+ anotherstruct **in;
+ PREINIT:
+ unsigned int i = 0;
+ PPCODE:
+ while (in[i] != NULL) {
+ mXPUSHi(in[i]->a);
+ mXPUSHi(in[i]->b);
+ mXPUSHn(in[i]->c);
+ ++i;
+ }
+ XS_release_anotherstructPtrPtr(in);
+ XSRETURN(3*i);
+
+anotherstruct **
+T_PACKEDARRAY_out(...)
+ PREINIT:
+ unsigned int i, nstructs, count_anotherstructPtrPtr;
+ CODE:
+ if ((items % 3) != 0)
+ croak("Need nitems divisible by 3");
+ nstructs = (unsigned int)(items / 3);
+ count_anotherstructPtrPtr = nstructs;
+ Newxz(RETVAL, nstructs+1, anotherstruct *);
+ for (i = 0; i < nstructs; ++i) {
+ Newxz(RETVAL[i], 1, anotherstruct);
+ RETVAL[i]->a = SvIV(ST(3*i));
+ RETVAL[i]->b = SvIV(ST(3*i+1));
+ RETVAL[i]->c = SvNV(ST(3*i+2));
+ }
+ OUTPUT: RETVAL
+ CLEANUP:
+ XS_release_anotherstructPtrPtr(RETVAL);
- @out = array_func( @in );
-Any number of arguments can occur in the list before the array but
-the input and output arrays must be the last elements in the list.
+## T_DATAUNIT
+## NOT YET
-When used to pass a perl list to C the XS writer must provide a
-function (named after the array type but with 'Ptr' substituted for
-'*') to allocate the memory required to hold the list. A pointer
-should be returned. It is up to the XS writer to free the memory on
-exit from the function. The variable C<ix_$var> is set to the number
-of elements in the new array.
-When returning a C array to Perl the XS writer must provide an integer
-variable called C<size_$var> containing the number of elements in the
-array. This is used to determine how many elements should be pushed
-onto the return argument stack. This is not required on input since
-Perl knows how many arguments are on the stack when the routine is
-called. Ordinarily this variable would be called C<size_RETVAL>.
+## T_CALLBACK
+## NOT YET
-Additionally, the type of each element is determined from the type of
-the array. If the array uses type C<intArray *> xsubpp will
-automatically work out that it contains variables of type C<int> and
-use that typemap entry to perform the copy of each element. All
-pointer '*' and 'Array' tags are removed from the name to determine
-the subtype.
-=cut
+## T_ARRAY
# Test passes in an integer array and returns it along with
# the number of elements
XSRETURN(size_RETVAL);
-=item T_STDIO
-
-This is used for passing perl filehandles to and from C using
-C<FILE *> structures.
-
-=cut
+## T_STDIO
FILE *
T_STDIO_open( file )
RETVAL
-=item T_IN
-
-NOT YET
+## T_INOUT
-=item T_INOUT
+PerlIO *
+T_INOUT(in)
+ PerlIO *in;
+ CODE:
+ RETVAL = in; /* silly test but better than nothing */
+ OUTPUT: RETVAL
-This is used for passing perl filehandles to and from C using
-C<PerlIO *> structures. The file handle can used for reading and
-writing.
-See L<perliol> for more information on the Perl IO abstraction
-layer. Perl must have been built with C<-Duseperlio>.
+## T_IN
-=item T_OUT
+inputfh
+T_IN(in)
+ inputfh in;
+ CODE:
+ RETVAL = in; /* silly test but better than nothing */
+ OUTPUT: RETVAL
-NOT YET
-=back
+## T_OUT
-=cut
+outputfh
+T_OUT(in)
+ outputfh in;
+ CODE:
+ RETVAL = in; /* silly test but better than nothing */
+ OUTPUT: RETVAL