Many changes
[perl-ctypes:shlomifs-perl-ctypes.git] / lib / Ctypes / Function.pm
1 package Ctypes::Function;
2
3 use strict;
4 use warnings;
5 use Ctypes qw|_make_arrayref _check_invalid_types|;
6 use overload '&{}' => \&_call_overload;
7 use Scalar::Util qw|blessed looks_like_number|;
8 use Carp;
9
10 # Public functions defined in POD order
11 sub new;
12 sub update;
13 sub sig;
14 sub abi_default;
15
16 =head1 NAME
17
18 Ctypes::Function - Object-oriented access to C function calls
19
20 =head1 VERSION
21
22 Version 0.002
23
24 =head1 SYNOPSIS
25
26     use Ctypes::Function;
27
28     $toupper = Ctypes::Function->new( "-lc", "toupper", "cii" );
29     $result = $func->(ord("y"));
30
31     # or
32     $toupper = Ctypes::Function->new({ lib    => 'c',
33                                        name   => 'toupper',
34                                        abi    => 'c',
35                                        argtypes => 'i',
36                                        restype  => 'i' } );
37     $result = $toupper->(ord("y"));
38
39 =head1 DESCRIPTION
40
41 Ctypes::Function objects abstracts the raw Ctypes::call() API.
42
43 Functions are also created as methods of DLL objects, such as
44 C<< CDLL->c->toupper({sig=>"cii"})->(ord "Y") >>, but with DLL's 
45 the abi is not needed, as it is taken from the library definition.
46 See L<Ctypes::DLL>.
47
48 =cut
49
50 # TODO:
51 # - namespace install feature from P5NCI
52
53 ################################
54 #   PRIVATE FUNCTIONS & DATA   #
55 ################################
56
57 # Private functions defined alphabetically
58 sub AUTOLOAD;
59 sub _call;             # XS
60 sub _call_overload;
61 sub _form_sig;
62 sub _get_args;
63
64 BEGIN {
65 sub PF_IN () { 1; }
66 sub PF_OUT () { 2; }
67 sub PF_INDEF0 () { 4; }
68 }
69
70 # For which members will AUTOLOAD provide mutators?
71 my $_setable = { name => 1, sig => 1, abi => 1, 
72                  restype => 1, argtypes => 1, lib => 1,
73                  errcheck => 1, callable => 1, ArgumentError => 1};
74 # For abi_default():
75 my $_default_abi = ($^O eq 'MSWin32' ? 's' : 'c' );
76
77 sub AUTOLOAD {
78   our $AUTOLOAD;
79   if( $AUTOLOAD =~  /.*::(.*)/ ) {
80     return if $1 eq 'DESTROY';
81     my $mem = $1; # member
82     no strict 'refs';
83     *$AUTOLOAD = sub { 
84       my $self = shift;
85       if($_setable->{$mem}) {
86         if(@_) {
87           return $self->{$mem} = $_[0];
88         }
89         if( defined $self->{$mem} ) {
90           return $self->{$mem};
91         } else { return undef; }
92       } else {
93         if(@_) {
94           warn("$mem not setable"); }
95         if( defined $self->{$mem} ) {
96           return $self->{$mem}; 
97         } else { return undef; }
98       }
99     };
100     goto &$AUTOLOAD;
101   }
102 }
103
104 sub _build_callargs ($\@\$\$\$) {
105   my $self = shift;
106   my $inargs = shift;
107   my $outmask = shift;
108   my $inoutmask = shift;
109   my $numretvals = shift;
110   my( $actual_args );
111   if( !defined $self->{argtypes} or !defined $self->{paramflags} or
112       $#{$self->{argtypes}} == 0 ) {
113     return @$inargs;
114   }
115   my $inargs_index = 0;
116   my $len = $#{$self->{argtypes}} + 1;
117
118   my @callargs;
119   for(my $i = 0; $i < $len; $i++) {
120     my $item = $self->{paramflags}->[$i];
121     my( $ob, $flag, $name, $defval );
122
123     $flag = $item->[0];
124     $name = $item->[1] ? $item->[1] : '';
125     $defval = $item->[2] ? $item->[2] : '';
126 # "i|zO" is in _validate_paramflags - need to do this, but when?"w
127 # paramflags flag values:
128 # 1 = input param
129 # 2 = output param
130 # 4 = input param defaulting to 0
131     SWITCH: {
132       if( $flag & (PF_IN | PF_INDEF0) ) { 
133 # /* ['in', 'lcid'] parameter.  Always taken from defval,
134 #    if given, else the integer 0. */
135         if( !$defval ) {
136           $defval = Ctypes::Type::c_int(0);
137         }
138         $callargs[$i] = $defval;
139         last SWITCH;
140       }
141       if( $flag & (PF_IN | PF_OUT) ) {
142         $inoutmask |= ( 1 << $i ); # mark as inout arg
143         $numretvals++;
144       } # fall through ...
145       if( $flag == 0 or $flag & PF_IN ) {
146       # Py calls out to a _get_arg func here, but it's only used once
147       # and we'd have less logic in ours (no kwds), so just inlined it
148         if($inargs_index <= scalar @$inargs) {
149           ++$inargs_index;
150           $ob = @$inargs[$inargs_index]; 
151         } elsif( $defval ) {
152           $ob = $defval;
153         } elsif( $name ) {
154           croak("Required argument '", $name, "' is missing");
155         } else {
156           croak("Not enough arguments");
157         }
158         $callargs[$i] = $ob;
159         last SWITCH;
160       }
161       if( $flag & PF_OUT ) {
162         if( $defval ) {
163           $callargs[$i] = $defval;
164           $outmask |= ( 1 << $i ); # mark as out arg
165           $numretvals++;
166           last SWITCH; 
167         }
168         $ob = $self->{argtypes}[$i];
169         if( $ob->{proto} ) {
170           # XXX don't understand this logic yet..
171           # Means $ob is a Pointer/Array type? So what?
172           croak( ref($ob) .
173             " 'out' parameter must be passed as default value");
174         }
175         # XXX This probably needs changed when Array objects worked out
176         if( ref($ob) =~ /Ctypes::Type::Array/ ) {
177           # Calling the array itself? Wonder what this returns...
178           # Will be annoying to do in C space.
179           $ob = $ob->();
180         } else {
181           # /* Create an instance of the pointed-to type */
182           # ob = PyObject_CallObject(dict->proto, NULL);
183           $ob = $ob->proto->();
184         }
185         unless( $ob ) {
186           croak("Could not create type of Array / Pointer object (I think...)");
187         }
188         $callargs[$i] = $ob;
189         $outmask |= ( 1 << $i ); # mark as out arg
190         $numretvals++;
191         last SWITCH;
192       }
193       croak("paramflag ", $flag, " not yet implemented");
194     }
195   }
196   $actual_args = scalar @$inargs; # already added in %kwds
197   if( $actual_args != $inargs_index) {
198     # /* When we have default values or named parameters, this error
199     # message is misleading.  See unittests/test_paramflags.py
200     # ^ The above might not apply to us, since we add in %kwds early?
201     croak("call takes ", $inargs_index, "arguments (", $actual_args, " given)... or maybe a different error");
202   }
203   return @callargs;
204 }
205
206 sub _build_result (\$\@\$\$\$) {
207   my($result, $callargs, $outmask, $inoutmask, $numretvals)
208     = @_;
209   my( $i, $index, $bit, @ret );
210
211   if( scalar @$callargs == 0 ) {
212     return $$result;
213   }
214
215   # XXX This looks like a fishy translation from C...
216   if( !$$result || $$numretvals == 0 ) {
217     @$callargs = ();
218     undef @$callargs;
219     return $$result;
220   }
221
222   my @results if $$numretvals > 1;
223
224   $index = 0;
225   for( $bit = 1, $i = 0; $i < 32; $i++, $bit <<= 1) {
226     my $v;
227     if( $bit & $inoutmask ) {
228       $v = $$callargs[$i];
229       return $v if $numretvals == 1;
230       $results[$i] = $v;
231       $index++;
232     } elsif( $bit & $outmask ) {
233       $v = $callargs->[$i];
234       $v->__ctypes_from_outparam__ if $v->can("__ctypes_from_outparam__");
235     # XXX Why return v if NULL? This could happen at any point in the
236     # @results building process
237       if( !$v || $numretvals == 1 ) {
238         return $v;
239       }
240       $results[$i] = $v;
241       $index++;
242     }
243     last if $index == $$numretvals;
244   }
245   return @results;
246 }
247
248 sub call {
249   my $self = shift;
250   my @inargs = @_;
251   my %kwds = (); # 'keywords': hash of named arguments
252   if( ref($inargs[$#inargs]) eq 'HASH' )
253     { %kwds = %{pop @inargs}; }
254   my( $outmask, $inoutmask );
255   my $numretvals = 0;
256
257   # If paramflags mark an arg as OUT or INOUT, they should be taken
258   # as a reference rather than by value
259   if( $self->{paramflags} && defined $self->{paramflags}[0] ) {
260     for(my $i = 0; $i <= $#inargs; $i++){
261       next if $inargs[$i] == undef;
262       next if $self->{paramflags}[$i] == undef;
263       if( $self->{paramflags}[$i][0] & PF_OUT ) {
264         $inargs[$i] = \$_[$i];
265       }
266     }
267   }
268
269   # Put keyword arguments where they ought to be in @inargs...
270   if( keys(%kwds) ) {
271     if( !$self->{paramflags} ) {
272       croak("Keywords used without specification; set your paramflags!");
273     } else {
274       KEYLOOP:
275       for(keys(%kwds)) {
276         my $key = $_;
277         for(my $i=0; $i<=$#{$self->{paramflags}}; $i++) {
278           if($self->{paramflags}[$i] = $key) {
279             if(exists $inargs[$i]) {
280               croak("Argument supplied both named and by position");
281             } else {
282               if( $self->{paramflags}[$i][0] & PF_OUT ) {
283                 $inargs[$i] = \$kwds{$key};
284               } else {
285                 $inargs[$i] = $kwds{$key};
286               }
287               next KEYLOOP;
288         } } }
289         croak("Named argument not found in paramflags: $key");
290       }
291     }
292   }
293
294   my @callargs = _build_callargs( $self,
295                                   @inargs,
296                                   $outmask,
297                                   $inoutmask,
298                                   $numretvals);
299
300 # /* For cdecl functions, we allow more actual arguments
301 #    than the length of the argtypes tuple.               */
302 # XXX Not sure yet if above logic allows this behaviour
303 # Py checks it by number of converters? (_ctypes.c:3334-3360) 
304
305 #ctypes-1.0.2/source/ctypes.h:238
306 # Currently, CFuncPtr types have 'converters' and 'checker'
307 # entries in their type dict.  They are only used to cache
308 # attributes from other entries, which is wrong.
309
310 # Do conversions of args we can't understand...
311   for(@callargs) {
312     my $converted;
313     if( ref($_) and blessed($_) and ref($_) !~ /Ctypes::Type/ ) {
314       if( $_->can("_as_param_") ) {
315         $converted = $_->_as_param_();
316         if( ref($converted) and ref($converted) !~ /Ctypes::Type/ ) {
317           croak("_as_param_() must return a Ctypes::Type or simple scalar");
318         }
319       } elsif( $_->{_as_param_} ) {
320         $converted = $_->{_as_param_};
321         if( ref($converted) and ref($converted) !~ /Ctypes::Type/ ) {
322           croak("_as_param_() must be a Ctypes::Type or simple scalar");
323         }
324       } else {
325         croak("_as_param function or property needed for non-Ctypes::Type " .
326               "object argument");
327       }
328     }
329   }
330
331 # Py's StgDictObject's int 'flags' field holds ABI info and
332 # FUNCFLAG_PYTHONAPI
333
334 # callargs should be changed in place?
335   my $result = _call($self, @callargs);
336
337 # XXX <insert 'errcheck protocol' here>
338
339   return _build_result($result, @callargs, $outmask,
340                        $inoutmask, $numretvals);
341 }
342
343 sub _call_overload {
344   my $self = shift;
345   return sub { call($self, @_) };
346 }
347
348 # Put Ctypes::_call style sig string together from $self's attributes
349 # Takes Ctypes::Function ($self), returns string scalar
350 sub _form_sig {
351   my $self = shift;
352   my @sig_parts;
353   $sig_parts[0] = $self->{abi} or abi_default();
354   if( ref($self->{restype}) ) {
355     if( ref($self->{restype}) =~ /Ctypes::Type/ ) {
356       $sig_parts[1] = $self->{restype}->{_typecode};
357     } else {
358       return undef; # Can't take typecodes for non Type objects
359     }
360   } else {
361     $sig_parts[1] = $self->{restype} or 
362       die("Return type not defined (even void must be defined with '_')");
363   }
364   if(defined $self->{argtypes}) {
365     for(my $i = 0; $i<=$#{$self->{argtypes}} ; $i++) {
366       if( ref($self->{argtypes}[$i]) ) {
367         if( ref($self->{argtypes}[$i]) ) {
368           $sig_parts[$i+2] = $self->{argtypes}[$i]->{_typecode};
369         }
370         # Can't represent non-Type objects as typecodes!
371         return undef;
372       }
373       # Don't know how this would happen, but...
374       return undef if length $self->{argtypes}[$i] > 1;
375       $sig_parts[$i+2] = $self->{argtypes}[$i];
376     }
377   }
378   return join('',@sig_parts);
379 }
380
381 # Dealing with either named or positional parameters
382 # Takes 1) arrayref of params received, 2) positional list of vals wanted
383 # Returns hashref
384 sub _get_args (\@\@) {
385   my $args = shift;
386   my $want = shift;
387   my $ret = {};
388
389   if (ref($args->[0]) eq 'HASH') {
390      # Using named parameters.
391     for(@{$want}) {
392       $ret->{$_} = $args->[0]->{$_} }
393   } else {
394     # Using positional parameters.
395     for(my $i=0; $i <= $#{$args}; $i++ ) {
396       $ret->{$want->[$i]} = $args->[$i] }
397   }
398   return $ret;
399 }
400
401 ################################
402 #       PUBLIC FUNCTIONS       #
403 ################################
404
405 =head1 METHODS
406
407 Ctypes::Function's methods are designed for flexibility.
408
409 =head2 new ( lib, name, [ sig, [ restype, [ abi, [ argtypes, [ func ]]]]] )
410
411 or hash-style: new ( { param => value, ... } )
412
413 Ctypes is happy to leave as much as possible until later, where it makes
414 sense. The only thing on which a Function object insists is knowing
415 where to find the C function it represents. This means that upon
416 instantiation, you must supply B<either> both the library and the name
417 of the function, B<or> a reference to the function itself. Further, to
418 avoid confusion, the C<func> reference is immutible after instantiation:
419 if you want a new function, make a new Function object.
420
421 Most of a Function's attributes can be accessed with a getter like this:
422 C<$obj->attr>, and set with a setter like this C<$obj->attr('value')> 
423 (apart from C<func>, which only has the getter). Each attribute's precise
424 meanings are explained below.
425
426 =over
427
428 =item lib
429
430 Describes the library in which the target function resides. It can
431 be one of three things:
432
433 =over
434
435 =item A linker argument style string, e.g. '-lc' for libc.
436  
437 For Win32, mingw and cygwin special rules are used:
438 "c" resolves on Win32 to msvcrt<ver>.dll.
439 -llib will probably find an import lib ending with F<.a> or F<.dll.a>), 
440 so C<dllimport> is called to find the DLL behind. 
441 DLL are usually versioned, import libs not, 
442 so specifying the unversioned library name will find the most recent DLL.
443
444 =item A path to a shared library.
445
446 =item A L<Ctypes::Library> object.
447
448 =item A library handle as returned by DynaLoader, or the C<_handle> 
449 property of a Ctypes::Library object, such as C<CDLL>.
450
451 C<< $lib = CDLL->c; $lib->{_handle} >>
452
453 =back
454
455 B<N.B.> Although the L<DynaLoader> docs explicitly say that the
456 handles ("references") it returns are to be considered 'opaque', we
457 check with a regex to make sure they look like a string of
458 numbers - what a DL handle normally looks like. This means that
459 yes, you could do yourself a mischief by passing any string of numbers
460 as a library reference, even though that would be a Silly Thing To Do.
461 Thankfully there are no dll's consisting only of numbers, but if so, 
462 add the extension.
463
464 =item name
465
466 The name of the function. On initialising, it's used internally by
467 L<DynaLoader> as the function symbol to look for in the library given
468 by C<lib>. It can also be useful for remembering what an object does
469 if you've assigned it to a non-intuitively named reference. In theory
470 though it's never looked at after initialization (and not even then if
471 you supply a C<func> reference) so you could store any information you
472 want in there.
473
474 =item sig
475
476 This can be one of two things: First, like with the L<FFI> module and
477 L<P5NCI>, it can be a string of letters representing the function
478 signature, in the same format as L<Ctypes::call>, i.e. first character
479 denotes the abi, second character denotes return type, and the remaining
480 characters denote argument types: <abi><restype><argtypes>. B<Note> that a
481 'void' return type should be indicated with an underscore '_'.
482
483 Alternatively, more in the style of L<C::DynaLib> and Python's ctypes,
484 it can be an (anonymous) list reference of the functions argument types.
485 Types can be specified using single-letter codes, similar (but different)
486 to Perl's L<pack> notation ('i', 'd', etc.) or with Ctypes's Type objects
487 (c_uint, c_double, etc.).
488
489 This is a convenience for positional parameter passing (as they're simply
490 assigned to the C<argtypes> attribute internally). These alternatives
491 mean that you can use positional parameters to create a function like
492 this:
493
494     $to_upper = Ctypes::Function->new( '-lc', 'toupper', 'cii' );
495
496 or like this:
497
498     $to_upper = Ctypes::Function->new( '-lc', 'toupper', [ c_int ], 'i' );
499
500 where C<[ c_int ]> is an anonymous array reference with one element, and
501 with the return type given the fourth positional argument C<'i'>. For
502 functions with many arguments, the latter syntax may be much more readable.
503 In these cases the ABI can be given as the fifth positional argument, or
504 omitted and the system default will be used (which will be what you want
505 in the vast majority of cases).
506
507 =item restype
508
509 The result type is often defined as default if the function 
510 is defined as library method.
511
512 The return type of the function can be represented as
513
514 =over
515
516 =item a single character type-code, using the same notation as L<Ctypes::call>,
517
518 =item a Ctype::Type definition, or
519
520 =item undef for void,
521
522 =back
523
524 =item abi
525
526 This is a single character representing the desired Application Binary
527 Interface for the call, here used to mean the calling convention. It can
528 be 'c' for C<cdecl> or 's' for C<stdcall>. Other values will fail.
529 'f' for C<fastcall> is for now used implicitly with 'c' on WIN64 
530 and UNIX64 architectures, not yet on 64bit libraries.
531
532 =item argtypes
533
534 A string of the type-code characters, or a list reference of the types
535 of arguments the function takes. These can be specified as type-codes 
536 ('i', 'd', etc.)  or with L<Ctypes>'s Type objects (c_int, c_double,
537 etc.).
538
539 =item func
540
541 An opaque reference to the function which the object represents. Can be
542 accessed after initialisation, but cannot be changed.
543
544 =item errcheck
545
546 Assign a reference of a perl sub or another callable to this attribute. The
547 callable will be called with three or more arguments.
548
549 =item callable (result, func, arguments)
550
551 result is what the foreign function returns, as specified by the
552 restype attribute.
553
554 func is the foreign function object itself, this allows to reuse the
555 same callable object to check or postprocess the results of several
556 functions.
557
558 arguments is a tuple containing the parameters originally passed to
559 the function call, this allows to specialize the behaviour on the
560 arguments used.
561
562 The object that this function returns will be returned from the
563 foreign function call, but it can also check the result value and
564 raise an exception if the foreign function call failed.
565
566 =item ArgumentError
567
568 This function is called when a foreign function call cannot convert
569 one of the passed arguments.
570
571 =back
572
573 =cut
574
575 sub new {
576   my ($class, @args) = @_;
577   # default positional args are library, function name, function signature.
578   # will never make sense to pass func address or lib address positionally
579   my @attrs = qw(lib name sig restype abi argtypes func);
580   our $ret  =  _get_args(@args, @attrs);
581
582   # Just so we don't have to continually dereference $ret
583   my ($lib, $name, $sig, $restype, $abi, $argtypes, $func)
584       = (map { \$ret->{$_}; } @attrs );
585
586   if (!$$func && !$$name) { die( "Need function ref or name" ); }
587
588   if(defined $$sig and ref($$sig) ne 'ARRAY' ) {
589       $$abi = substr($$sig, 0, 1) unless $$abi;
590       $$restype = substr($$sig, 1, 1) unless $$restype;
591       $$argtypes = [ split(//, substr($$sig, 2)) ]  unless $$argtypes;
592   }
593   $$restype = 'i' unless defined $$restype;
594   $$argtypes = Ctypes::_make_arrayref($$argtypes) if defined($$argtypes);
595   my $errpos = Ctypes::_check_invalid_types($$argtypes);
596   croak("Invalid argtype at position $errpos: " . $$argtypes->[$errpos] )
597     if $errpos;
598
599   if (!$$func) {
600     $$lib = '-lc' unless $$lib; #default libc
601     if (ref $lib ne 'SCALAR' and $$lib->isa("Ctypes::Library")) {
602       $$lib = $$lib->{_handle};
603       $$abi = $$lib->{_abi} unless $$abi;
604     }
605     if ($$lib and $$lib !~ /^[0-9]+$/) { # need a number, a dl_load_file handle
606       my $newlib = Ctypes::load_library( $$lib );
607       die "No library $$lib found" unless $newlib;
608       $$lib = $newlib;
609     }
610     $$func = Ctypes::find_function( $$lib, $$name );
611     die "No function $$name found" unless $$func;
612   }
613   if (!$$abi) { # hash-style: depends on the lib, default: 'c'
614     $$abi = 'c';
615     $$abi = 's' if $^O eq 'MSWin32' and $$name =~ /(user32|kernel32|gdi)/;
616   } else {
617     $$abi =~ /^(cdecl|stdcall|fastcall|c|s|f)$/
618       or die "invalid abi $$abi";
619     $$abi = 'c' if $$abi eq 'cdecl';
620     $$abi = 's' if $$abi eq 'stdcall';
621     $$abi = 'f' if $$abi eq 'fastcall';
622   }
623   $$sig = _form_sig($ret); # arrayref -> usual string
624   return bless $ret, $class;
625 }
626
627 =head2 update(name, sig, restype, abi, argtypes)
628
629 Also hash-style: update({ param => value, [...] })
630
631 C<update> provides a quick way of changing many attributes of a function
632 all at once. Only the function's C<lib> and C<func> references cannot
633 be updated (because that wouldn't make any sense).
634
635 =cut
636
637 sub update {
638   my $self = shift;
639   my @args = @_;
640   my @want = qw(name sig restype abi argtypes);
641   my $update_self = _get_args(@args, @want);
642   for(@want) {
643     if(defined $update_self->{$_}) {
644       $self->{$_} = $update_self->{$_};
645     }
646   }
647   return $self;
648 }
649
650 =head2 sig('cii')
651
652 A self-explanatory get/set method, only listed here to point out that
653 it will also change the C<abi>, C<restype> and C<argtypes> attributes,
654 depending on what you give it.
655
656 Don't try to set the argtypes with it by passing an array ref, like
657 you can in new(). Use argtypes() instead.
658
659 =cut
660  
661 sub sig {
662   my $self = shift;
663   my $arg = shift;
664   die("Too many arguments") if @_;
665   die("Object method") if ref($self) ne 'Ctypes::Function';
666   if(defined $arg) {
667     $self->{abi} = substr($arg, 0, 1);
668     $self->{restype} = substr($arg, 1, 1);
669     $self->{argtypes} = [ split(//, substr($arg, 2)) ];
670     $self->{sig} = $arg;
671   }
672   if(!$self->{sig}) {
673     $self->{sig} = $self->{abi} . $self->{restype} .
674       (defined $self->{argtypes} ? join('',@{$self->{argtypes}}) : '');
675   }
676   return $self->{sig};
677 }
678
679 =head2 argtypes( I<LIST> )
680
681 Or: argtypes( $arrayref [ offset ] )
682
683 # $obj->argtypes returns qw()'able string of arg types
684 # argtypes (\$;@) works like substr;
685
686 =cut
687
688 sub argtypes : lvalue method {
689   my $self = shift;
690   croak("Usage: \$funcobj->argtypes") if ref($self) ne 'Ctypes::Function';
691   my $new_argtypes;
692   if(@_) {
693     # if we got an offset...
694     if(looks_like_number($_[1])) {
695       croak("Usage: argtypes( \$arrayref, <offset> )") if exists $_[2];
696       croak("Usage: argtypes( \$arrayref, <offset> )")
697         if ref($_[0]) ne 'HASH';
698       $new_argtypes = shift;
699       my $offset = shift;
700       if($self->{argtypes}) {
701         splice(@{$self->{argtypes}},$offset,$#$new_argtypes,@$new_argtypes);
702       } else {
703         carp("Offset received but there were no pre-existing argtypes");
704         $self->{argtypes} = $new_argtypes; 
705       }
706     } else {
707       $self->{argtypes} = Ctypes::_make_arrayref( @_ );
708     }
709   }
710   return $self->{argtypes};
711 }
712
713
714
715 =head2 abi_default( [ 'c' | $^O ] )
716
717 Also hash-style: abi_default( [ { abi => <char> | os => $^O } ] )
718
719 This class method is used to return the default ABI (calling convention)
720 for the current system. It can also be used to change the 'default' for
721 your script, either through passing a specific ABI code ( 'c' for C<cdecl>
722 or 's' for C<stdcall> ) or by specifying an operating system type.
723 Everything but 'MSWin32' yields the 'c' (cdecl) ABI type.
724
725 =cut
726
727 sub abi_default {
728   my $arg = shift;
729   if( !defined $arg ) {
730     return $_default_abi;
731   }
732   if( ($arg eq 's') or ($arg->{os} eq 'MSWin32') ) {
733     $_default_abi = 's'; return 's';
734   } else {
735     $_default_abi = 'c'; return 'c';
736   }
737 }
738
739 1;