#include "EXTERN.h"
		#include "perl.h"
		#include "XSUB.h"
		
		/* from exception.c */
		int exception(int);
		
		MODULE = XS::APItest:Hash		PACKAGE = XS::APItest::Hash
		
		#define UTF8KLEN(sv, len)   (SvUTF8(sv) ? -(I32)len : (I32)len)
		
		bool
		exists(hash, key_sv)
			PREINIT:
          68    	STRLEN len;
          68    	const char *key;
			INPUT:
			HV *hash
			SV *key_sv
			CODE:
          68    	key = SvPV(key_sv, len);
          68    	RETVAL = hv_exists(hash, key, UTF8KLEN(key_sv, len));
		        OUTPUT:
		        RETVAL
		
		SV *
		delete(hash, key_sv)
			PREINIT:
          68    	STRLEN len;
          68    	const char *key;
			INPUT:
			HV *hash
			SV *key_sv
			CODE:
          68    	key = SvPV(key_sv, len);
			/* It's already mortal, so need to increase reference count.  */
          68    	RETVAL = SvREFCNT_inc(hv_delete(hash, key, UTF8KLEN(key_sv, len), 0));
		        OUTPUT:
		        RETVAL
		
		SV *
		store_ent(hash, key, value)
			PREINIT:
          48    	SV *copy;
          48    	HE *result;
			INPUT:
			HV *hash
			SV *key
			SV *value
			CODE:
          48    	copy = newSV(0);
          48    	result = hv_store_ent(hash, key, copy, 0);
          48    	SvSetMagicSV(copy, value);
          48    	if (!result) {
      ######    	    SvREFCNT_dec(copy);
      ######    	    XSRETURN_EMPTY;
			}
			/* It's about to become mortal, so need to increase reference count.
			 */
          48    	RETVAL = SvREFCNT_inc(HeVAL(result));
		        OUTPUT:
		        RETVAL
		
		
		SV *
		store(hash, key_sv, value)
			PREINIT:
          50    	STRLEN len;
          50    	const char *key;
          50    	SV *copy;
          50    	SV **result;
			INPUT:
			HV *hash
			SV *key_sv
			SV *value
			CODE:
          50    	key = SvPV(key_sv, len);
          50    	copy = newSV(0);
          50    	result = hv_store(hash, key, UTF8KLEN(key_sv, len), copy, 0);
          49    	SvSetMagicSV(copy, value);
          49    	if (!result) {
          12    	    SvREFCNT_dec(copy);
          12    	    XSRETURN_EMPTY;
			}
			/* It's about to become mortal, so need to increase reference count.
			 */
          37    	RETVAL = SvREFCNT_inc(*result);
		        OUTPUT:
		        RETVAL
		
		
		SV *
		fetch(hash, key_sv)
			PREINIT:
          68    	STRLEN len;
          68    	const char *key;
          68    	SV **result;
			INPUT:
			HV *hash
			SV *key_sv
			CODE:
          68    	key = SvPV(key_sv, len);
          68    	result = hv_fetch(hash, key, UTF8KLEN(key_sv, len), 0);
          68    	if (!result) {
          22    	    XSRETURN_EMPTY;
			}
			/* Force mg_get  */
          46    	RETVAL = newSVsv(*result);
		        OUTPUT:
		        RETVAL
		=pod
		
		sub TIEHASH  { bless {}, $_[0] }
		sub STORE    { $_[0]->{$_[1]} = $_[2] }
		sub FETCH    { $_[0]->{$_[1]} }
		sub FIRSTKEY { my $a = scalar keys %{$_[0]}; each %{$_[0]} }
		sub NEXTKEY  { each %{$_[0]} }
		sub EXISTS   { exists $_[0]->{$_[1]} }
		sub DELETE   { delete $_[0]->{$_[1]} }
		sub CLEAR    { %{$_[0]} = () }
		
		=cut
		
		MODULE = XS::APItest		PACKAGE = XS::APItest
		
		PROTOTYPES: DISABLE
		
		void
		print_double(val)
		        double val
		        CODE:
           1            printf("%5.3f\n",val);
		
		int
		have_long_double()
		        CODE:
		#ifdef HAS_LONG_DOUBLE
           1            RETVAL = 1;
		#else
		        RETVAL = 0;
		#endif
		        OUTPUT:
		        RETVAL
		
		void
		print_long_double()
		        CODE:
		#ifdef HAS_LONG_DOUBLE
		#   if defined(PERL_PRIfldbl) && (LONG_DOUBLESIZE > DOUBLESIZE)
           1            long double val = 7.0;
           1            printf("%5.3" PERL_PRIfldbl "\n",val);
		#   else
		        double val = 7.0;
		        printf("%5.3f\n",val);
		#   endif
		#endif
		
		void
		print_int(val)
		        int val
		        CODE:
           1            printf("%d\n",val);
		
		void
		print_long(val)
		        long val
		        CODE:
           1            printf("%ld\n",val);
		
		void
		print_float(val)
		        float val
		        CODE:
           1            printf("%5.3f\n",val);
			
		void
		print_flush()
		    	CODE:
           1    	fflush(stdout);
		
		void
		mpushp()
			PPCODE:
           1    	EXTEND(SP, 3);
           1    	mPUSHp("one", 3);
           1    	mPUSHp("two", 3);
           1    	mPUSHp("three", 5);
           1    	XSRETURN(3);
		
		void
		mpushn()
			PPCODE:
           1    	EXTEND(SP, 3);
           1    	mPUSHn(0.5);
           1    	mPUSHn(-0.25);
           1    	mPUSHn(0.125);
           1    	XSRETURN(3);
		
		void
		mpushi()
			PPCODE:
           1    	EXTEND(SP, 3);
           1    	mPUSHi(-1);
           1    	mPUSHi(2);
           1    	mPUSHi(-3);
           1    	XSRETURN(3);
		
		void
		mpushu()
			PPCODE:
           1    	EXTEND(SP, 3);
           1    	mPUSHu(1);
           1    	mPUSHu(2);
           1    	mPUSHu(3);
           1    	XSRETURN(3);
		
		void
		mxpushp()
			PPCODE:
           1    	mXPUSHp("one", 3);
           1    	mXPUSHp("two", 3);
           1    	mXPUSHp("three", 5);
           1    	XSRETURN(3);
		
		void
		mxpushn()
			PPCODE:
           1    	mXPUSHn(0.5);
           1    	mXPUSHn(-0.25);
           1    	mXPUSHn(0.125);
           1    	XSRETURN(3);
		
		void
		mxpushi()
			PPCODE:
           1    	mXPUSHi(-1);
           1    	mXPUSHi(2);
           1    	mXPUSHi(-3);
           1    	XSRETURN(3);
		
		void
		mxpushu()
			PPCODE:
           1    	mXPUSHu(1);
           1    	mXPUSHu(2);
           1    	mXPUSHu(3);
           1    	XSRETURN(3);
		
		
		void
		call_sv(sv, flags, ...)
		    SV* sv
		    I32 flags
		    PREINIT:
          56    	I32 i;
		    PPCODE:
         136    	for (i=0; i<items-2; i++)
          80    	    ST(i) = ST(i+2); /* pop first two args */
          56    	PUSHMARK(SP);
          56    	SP += items - 2;
          56    	PUTBACK;
          56    	i = call_sv(sv, flags);
          48    	SPAGAIN;
          48    	EXTEND(SP, 1);
          48    	PUSHs(sv_2mortal(newSViv(i)));
		
		void
		call_pv(subname, flags, ...)
		    char* subname
		    I32 flags
		    PREINIT:
          40    	I32 i;
		    PPCODE:
          96    	for (i=0; i<items-2; i++)
          56    	    ST(i) = ST(i+2); /* pop first two args */
          40    	PUSHMARK(SP);
          40    	SP += items - 2;
          40    	PUTBACK;
          40    	i = call_pv(subname, flags);
          32    	SPAGAIN;
          32    	EXTEND(SP, 1);
          32    	PUSHs(sv_2mortal(newSViv(i)));
		
		void
		call_method(methname, flags, ...)
		    char* methname
		    I32 flags
		    PREINIT:
          32    	I32 i;
		    PPCODE:
         112    	for (i=0; i<items-2; i++)
          80    	    ST(i) = ST(i+2); /* pop first two args */
          32    	PUSHMARK(SP);
          32    	SP += items - 2;
          32    	PUTBACK;
          32    	i = call_method(methname, flags);
          24    	SPAGAIN;
          24    	EXTEND(SP, 1);
          24    	PUSHs(sv_2mortal(newSViv(i)));
		
		void
		eval_sv(sv, flags)
		    SV* sv
		    I32 flags
		    PREINIT:
          41        	I32 i;
		    PPCODE:
          41    	PUTBACK;
          41    	i = eval_sv(sv, flags);
          40    	SPAGAIN;
          40    	EXTEND(SP, 1);
          40    	PUSHs(sv_2mortal(newSViv(i)));
		
		void
		eval_pv(p, croak_on_error)
		    const char* p
		    I32 croak_on_error
		    PPCODE:
           4    	PUTBACK;
           4    	EXTEND(SP, 1);
           4    	PUSHs(eval_pv(p, croak_on_error));
		
		void
		require_pv(pv)
		    const char* pv
		    PPCODE:
      ######    	PUTBACK;
      ######    	require_pv(pv);
		
		int
		exception(throw_e)
		    int throw_e
		    OUTPUT:
		        RETVAL
		
		void
		mycroak(pv)
		    const char* pv
		    CODE:
           5        Perl_croak(aTHX_ "%s", pv);
		
		SV*
		strtab()
		   CODE:
           1       RETVAL = newRV_inc((SV*)PL_strtab);
		   OUTPUT:
		   RETVAL