TYPEMAP
ne_status * ne_status__
const unsigned char T_PV
ne_content_range * ne_content_range__
const ne_server_capabilities * ne_server_capabilities__
CV * T_CVREF2
const ne_proppatch_operation * ne_proppatch_operation__
const ne_acl_entry * ne_acl_entry__
const ne_propname * ne_propname__
const ne_status * ne_status__
ne_lock_struct * ne_lock_struct__
struct ne_lock * struct_ne_lock__
const ne_content_range * ne_content_range__
nssl_certificate * nssl_certificate__
const dav_proppatch_operation * 
const dav_propname * 
off_t T_IV
const char * T_PV
const ne_lock_struct * ne_lock_struct__
const struct ne_lock * struct_ne_lock__
char ** T_mallocstr
const nssl_certificate * nssl_certificate__
enum T_ENUM
ne_content_type * ne_content_type__
xxxxx T_PTRNULL
unsigned short int T_IV
ne_server_capabilities * ne_server_capabilities__
ne_proppatch_operation * ne_proppatch_operation__
ne_acl_entry * ne_acl_entry__
ne_propname * ne_propname__
const ne_content_type * ne_content_type__
ne_session * ne_session__
const ne_session * ne_session__
struct in_addr * T_PTRNULL
const struct in_addr * T_PTRNULL
void * T_PTRNULL
const void * T_PTRNULL
sock_progress T_CVREF2
ne_207_start_response T_PTRNULL
const ne_207_start_response T_PTRNULL
struct uri * T_PTRNULL
const struct uri * T_PTRNULL
ne_lock_session * ne_lock_session__
const ne_lock_session * ne_lock_session__
ne_cookie_cache * T_PTRNULL
const ne_cookie_cache * T_PTRNULL
ne_prop_result_set * ne_prop_result_set__
const ne_prop_result_set * ne_prop_result_set__
ne_xml_validate_cb T_CVREF2
ne_lock_result T_CVREF2
struct ne_md5_ctx * struct_ne_md__ctx__
const struct ne_md5_ctx * struct_ne_md__ctx__
ne_207_parser * ne_____parser__
const ne_207_parser * ne_____parser__
ne_xml_cdata_cb T_CVREF2
ne_propset_iterator T_CVREF2
ne_207_end_response T_CVREF2
ne_accept_response T_CVREF2
ne_xml_startelm_cb T_CVREF2
struct ne_xml_elm * T_PTRNULL
const struct ne_xml_elm * T_PTRNULL
ne_buffer * ne_buffer__
const ne_buffer * ne_buffer__
ne_provide_body T_CVREF2
ne_use_proxy T_CVREF2
ne_request * ne_request__
const ne_request * ne_request__
time_t * T_PTRNULL
const time_t * T_PTRNULL
ne_request_auth T_CVREF2
nssl_context * nssl_context__
const nssl_context * nssl_context__
ne_props_create_complex T_PTRNULL
const ne_props_create_complex T_PTRNULL
ne_redirect_confirm T_CVREF2
void T_PTRNULL
const void T_PTRNULL
ne_207_start_propstat T_PTRNULL
const ne_207_start_propstat T_PTRNULL
ne_pre_send_fn T_CVREF2
ne_lock_walkfunc T_CVREF2
ne_header_handler T_CVREF2
ne_create_request_fn T_CVREF2
nsocket * nsocket__
const nsocket * nsocket__
ne_props_result T_CVREF2
nssl_key_prompt T_CVREF2
sock_block_reader T_CVREF2
ne_notify_status T_CVREF2
ne_destory_fn T_CVREF2
ne_block_reader T_CVREF2
ne_decompress * T_PTRNULL
const ne_decompress * T_PTRNULL
ne_post_send_fn T_CVREF2
ne_accessor_fn T_PTRNULL
const ne_accessor_fn T_PTRNULL
ne_xml_parser * ne_xml_parser__
const ne_xml_parser * ne_xml_parser__
ne_xml_endelm_cb T_CVREF2
ne_propfind_handler * ne_propfind_handler__
const ne_propfind_handler * ne_propfind_handler__
ne_redirect_notify T_CVREF2
ne_207_end_propstat T_CVREF2



INPUT
ne_session__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

ne_content_range__

        {
        HV * _pHV_ ;
        if (SvOK($arg))
            {
            SV * p ;
            if (!SvROK ($arg) || SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	        croak(\"$var must be a hash reference\") ;

            p = newSVpv (\"\", sizeof (\*$var)) ;
            sv_2mortal (p) ;
            $var = ($type)SvPVX (p) ;
	(($type)$var)->start = (off_t)SvIV(__fetchmember(_pHV_,\"start\"))	;
	(($type)$var)->end = (off_t)SvIV(__fetchmember(_pHV_,\"end\"))	;
	(($type)$var)->total = (off_t)SvIV(__fetchmember(_pHV_,\"total\"))	;

            }
        else
            {
            $var = NULL ;
            }
        }

T_CVREF2

	if (SvROK ($arg))
	    $var = (CV*)SvRV($arg);
	else
	    $var = NULL ;  /* croak(\"$var is not a reference to a sub\") */
        
ne_propname__

        {
        AV * _pAV_ ;
        if (SvOK($arg))
            {
            int  i ;
            SV * p ;
            SV * pa ;
            $type tmp ;
            if (!SvROK ($arg) || SvTYPE(_pAV_ = (AV *)SvRV($arg)) != SVt_PVAV)
	        {
                _pAV_ = newAV () ;
                sv_2mortal ((SV *)_pAV_) ;
                SvREFCNT_inc ($arg) ;
                av_push (_pAV_, $arg) ;
                }

            pa = newSVpv (\"\", sizeof (\*$var) * (av_len (_pAV_) + 2)) ;
            sv_2mortal (pa) ;
            tmp = $var = ($type)SvPVX (pa) ;
            for (i = 0; i <= av_len (_pAV_); i++)
                {
                HV * _pHV_ ;
                SV * * ppArg ;

                ppArg = av_fetch (_pAV_, i, 1) ;
                if (!ppArg || !*ppArg)
                    croak (\"bad array\") ;
                
                if (!SvOK(*ppArg) || !SvROK (*ppArg) || SvTYPE(_pHV_ = (HV *)SvRV(*ppArg)) != SVt_PVHV)
	            croak(\"$var must be an array of hash reference\") ;

	(($type)$var)->nspace = (char *)SvPV(__fetchmember(_pHV_,\"nspace\"),PL_na)	;
	(($type)$var)->name = (char *)SvPV(__fetchmember(_pHV_,\"name\"),PL_na)	;

                $var++ ;
                }
            memset ((void *)$var, 0, sizeof (\*$var)) ;
            $var = tmp ;
            }
        else
            {
            $var = NULL ;
            }
        }

ne_lock_session__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::LockSession\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

ne_prop_result_set__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::Propset\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

struct_ne_lock__

        {
        HV * _pHV_ ;
        if (SvOK($arg))
            {
            SV * p ;
            if (!SvROK ($arg) || SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	        croak(\"$var must be a hash reference\") ;

            p = newSVpv (\"\", sizeof (\*$var)) ;
            sv_2mortal (p) ;
            $var = ($type)SvPVX (p) ;
	(($type)$var)->uri = (char *)SvPV(__fetchmember(_pHV_,\"uri\"),PL_na)	;
	(($type)$var)->depth = (int)SvIV(__fetchmember(_pHV_,\"depth\"))	;
	(($type)$var)->type = (int)SvIV(__fetchmember(_pHV_,\"type\"))	;
	(($type)$var)->scope = (int)SvIV(__fetchmember(_pHV_,\"scope\"))	;
	(($type)$var)->token = (char *)SvPV(__fetchmember(_pHV_,\"token\"),PL_na)	;
	(($type)$var)->owner = (char *)SvPV(__fetchmember(_pHV_,\"owner\"),PL_na)	;
	(($type)$var)->timeout = (long)SvIV(__fetchmember(_pHV_,\"timeout\"))	;
	(($type)$var)->prev = (void *)SvIV(__fetchmember(_pHV_,\"prev\"))	;
	(($type)$var)->next = (void *)SvIV(__fetchmember(_pHV_,\"next\"))	;

            }
        else
            {
            $var = NULL ;
            }
        }

nssl_certificate__

        {
        HV * _pHV_ ;
        if (SvOK($arg))
            {
            SV * p ;
            if (!SvROK ($arg) || SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	        croak(\"$var must be a hash reference\") ;

            p = newSVpv (\"\", sizeof (\*$var)) ;
            sv_2mortal (p) ;
            $var = ($type)SvPVX (p) ;
	(($type)$var)->owner = (char *)SvPV(__fetchmember(_pHV_,\"owner\"),PL_na)	;
	(($type)$var)->issuer = (char *)SvPV(__fetchmember(_pHV_,\"issuer\"),PL_na)	;
	(($type)$var)->valid_from = (char *)SvPV(__fetchmember(_pHV_,\"valid_from\"),PL_na)	;
	(($type)$var)->valid_till = (char *)SvPV(__fetchmember(_pHV_,\"valid_till\"),PL_na)	;
	(($type)$var)->fingerprint = (char *)SvPV(__fetchmember(_pHV_,\"fingerprint\"),PL_na)	;

            }
        else
            {
            $var = NULL ;
            }
        }

struct_ne_md__ctx__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::MD5\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

ne_server_capabilities__

        {
        HV * _pHV_ ;
        if (SvOK($arg))
            {
            SV * p ;
            if (!SvROK ($arg) || SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	        croak(\"$var must be a hash reference\") ;

            p = newSVpv (\"\", sizeof (\*$var)) ;
            sv_2mortal (p) ;
            $var = ($type)SvPVX (p) ;
	(($type)$var)->dav_class1 = (unsigned int)SvUV(__fetchmember(_pHV_,\"dav_class1\"))	;
	(($type)$var)->dav_class2 = (unsigned int)SvUV(__fetchmember(_pHV_,\"dav_class2\"))	;
	(($type)$var)->dav_executable = (unsigned int)SvUV(__fetchmember(_pHV_,\"dav_executable\"))	;

            }
        else
            {
            $var = NULL ;
            }
        }

ne_proppatch_operation__

        {
        AV * _pAV_ ;
        if (SvOK($arg))
            {
            int  i ;
            SV * p ;
            SV * pa ;
            $type tmp ;
            if (!SvROK ($arg) || SvTYPE(_pAV_ = (AV *)SvRV($arg)) != SVt_PVAV)
	        {
                _pAV_ = newAV () ;
                sv_2mortal ((SV *)_pAV_) ;
                SvREFCNT_inc ($arg) ;
                av_push (_pAV_, $arg) ;
                }

            pa = newSVpv (\"\", sizeof (\*$var) * (av_len (_pAV_) + 2)) ;
            sv_2mortal (pa) ;
            tmp = $var = ($type)SvPVX (pa) ;
            for (i = 0; i <= av_len (_pAV_); i++)
                {
                HV * _pHV_ ;
                SV * * ppArg ;

                ppArg = av_fetch (_pAV_, i, 1) ;
                if (!ppArg || !*ppArg)
                    croak (\"bad array\") ;
                
                if (!SvOK(*ppArg) || !SvROK (*ppArg) || SvTYPE(_pHV_ = (HV *)SvRV(*ppArg)) != SVt_PVHV)
	            croak(\"$var must be an array of hash reference\") ;


        {
        AV * _pAV_ ;
        if (SvOK(__fetchmember(_pHV_,\"name\")))
            {
            int  i ;
            SV * p ;
            SV * pa ;
            ne_propname * tmp ;
            if (!SvROK (__fetchmember(_pHV_,\"name\")) || SvTYPE(_pAV_ = (AV *)SvRV(__fetchmember(_pHV_,\"name\"))) != SVt_PVAV)
	        {
                _pAV_ = newAV () ;
                sv_2mortal ((SV *)_pAV_) ;
                SvREFCNT_inc (__fetchmember(_pHV_,\"name\")) ;
                av_push (_pAV_, __fetchmember(_pHV_,\"name\")) ;
                }

            pa = newSVpv (\"\", sizeof (*(($type)$var)->name) * (av_len (_pAV_) + 2)) ;
            sv_2mortal (pa) ;
            tmp = (($type)$var)->name = (ne_propname *)SvPVX (pa) ;
            for (i = 0; i <= av_len (_pAV_); i++)
                {
                HV * _pHV_x_ ;
                SV * * ppArg ;

                ppArg = av_fetch (_pAV_, i, 1) ;
                if (!ppArg || !*ppArg)
                    croak (\"bad array\") ;
                
                if (!SvOK(*ppArg) || !SvROK (*ppArg) || SvTYPE(_pHV_x_ = (HV *)SvRV(*ppArg)) != SVt_PVHV)
	            croak(\"(($type)$var)->name must be an array of hash reference\") ;

	((ne_propname *)(($type)$var)->name)->nspace = (char *)SvPV(__fetchmember(_pHV_x_,\"nspace\"),PL_na)	;
	((ne_propname *)(($type)$var)->name)->name = (char *)SvPV(__fetchmember(_pHV_x_,\"name\"),PL_na)	;

                (($type)$var)->name++ ;
                }
            memset ((void *)(($type)$var)->name, 0, sizeof (*(($type)$var)->name)) ;
            (($type)$var)->name = tmp ;
            }
        else
            {
            (($type)$var)->name = NULL ;
            }
        }
	;
	(($type)$var)->type = (int)SvIV(__fetchmember(_pHV_,\"type\"))	;
	(($type)$var)->value = (char *)SvPV(__fetchmember(_pHV_,\"value\"),PL_na)	;

                $var++ ;
                }
            memset ((void *)$var, 0, sizeof (\*$var)) ;
            $var = tmp ;
            }
        else
            {
            $var = NULL ;
            }
        }

ne_status__

        {
        HV * _pHV_ ;
        if (SvOK($arg))
            {
            SV * p ;
            if (!SvROK ($arg) || SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	        croak(\"$var must be a hash reference\") ;

            p = newSVpv (\"\", sizeof (\*$var)) ;
            sv_2mortal (p) ;
            $var = ($type)SvPVX (p) ;
	(($type)$var)->major_version = (int)SvIV(__fetchmember(_pHV_,\"major_version\"))	;
	(($type)$var)->minor_version = (int)SvIV(__fetchmember(_pHV_,\"minor_version\"))	;
	(($type)$var)->code = (int)SvIV(__fetchmember(_pHV_,\"code\"))	;
	(($type)$var)->klass = (int)SvIV(__fetchmember(_pHV_,\"klass\"))	;
	(($type)$var)->reason_phrase = (char *)SvPV(__fetchmember(_pHV_,\"reason_phrase\"),PL_na)	;

            }
        else
            {
            $var = NULL ;
            }
        }

ne_____parser__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::MultiStatus\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

T_ENUM
	$var = (int)SvIV($arg)
ne_buffer__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::Buffer\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

ne_acl_entry__

        {
        HV * _pHV_ ;
        if (SvOK($arg))
            {
            SV * p ;
            if (!SvROK ($arg) || SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	        croak(\"$var must be a hash reference\") ;

            p = newSVpv (\"\", sizeof (\*$var)) ;
            sv_2mortal (p) ;
            $var = ($type)SvPVX (p) ;
	(($type)$var)->apply = (int)SvIV(__fetchmember(_pHV_,\"apply\"))	;
	(($type)$var)->type = (int)SvIV(__fetchmember(_pHV_,\"type\"))	;
	(($type)$var)->principal = (char *)SvPV(__fetchmember(_pHV_,\"principal\"),PL_na)	;
	(($type)$var)->read = (int)SvIV(__fetchmember(_pHV_,\"read\"))	;
	(($type)$var)->read_acl = (int)SvIV(__fetchmember(_pHV_,\"read_acl\"))	;
	(($type)$var)->write = (int)SvIV(__fetchmember(_pHV_,\"write\"))	;
	(($type)$var)->write_acl = (int)SvIV(__fetchmember(_pHV_,\"write_acl\"))	;
	(($type)$var)->read_cuprivset = (int)SvIV(__fetchmember(_pHV_,\"read_cuprivset\"))	;

            }
        else
            {
            $var = NULL ;
            }
        }

ne_request__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::Request\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

ne_lock_struct__

        {
        HV * _pHV_ ;
        if (SvOK($arg))
            {
            SV * p ;
            if (!SvROK ($arg) || SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	        croak(\"$var must be a hash reference\") ;

            p = newSVpv (\"\", sizeof (\*$var)) ;
            sv_2mortal (p) ;
            $var = ($type)SvPVX (p) ;
	(($type)$var)->uri = (char *)SvPV(__fetchmember(_pHV_,\"uri\"),PL_na)	;
	(($type)$var)->depth = (int)SvIV(__fetchmember(_pHV_,\"depth\"))	;
	(($type)$var)->type = (int)SvIV(__fetchmember(_pHV_,\"type\"))	;
	(($type)$var)->scope = (int)SvIV(__fetchmember(_pHV_,\"scope\"))	;
	(($type)$var)->token = (char *)SvPV(__fetchmember(_pHV_,\"token\"),PL_na)	;
	(($type)$var)->owner = (char *)SvPV(__fetchmember(_pHV_,\"owner\"),PL_na)	;
	(($type)$var)->timeout = (long)SvIV(__fetchmember(_pHV_,\"timeout\"))	;
	(($type)$var)->prev = (void *)SvIV(__fetchmember(_pHV_,\"prev\"))	;
	(($type)$var)->next = (void *)SvIV(__fetchmember(_pHV_,\"next\"))	;

            }
        else
            {
            $var = NULL ;
            }
        }

nssl_context__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::SSL\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

T_mallocstr

        if (SvROK ($arg))
	    {
            char * s ;
            IV     l ;
            s = SVpv (SvRV($arg), l) ;
            \*$var = malloc (l + 1) ;
            strcpy (\*$var, s) ;
            }
	else
	    croak(\"$var is not a reference to a sub\")
        
T_PTRNULL

        if (SvIOK ($arg))
            $var = ($type)SvIV($arg) ;
        else
            $var = NULL ;
        
nsocket__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::Socket\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

ne_content_type__

        {
        HV * _pHV_ ;
        if (SvOK($arg))
            {
            SV * p ;
            if (!SvROK ($arg) || SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	        croak(\"$var must be a hash reference\") ;

            p = newSVpv (\"\", sizeof (\*$var)) ;
            sv_2mortal (p) ;
            $var = ($type)SvPVX (p) ;
	(($type)$var)->type = (char *)SvPV(__fetchmember(_pHV_,\"type\"),PL_na)	;
	(($type)$var)->subtype = (char *)SvPV(__fetchmember(_pHV_,\"subtype\"),PL_na)	;
	(($type)$var)->charset = (char *)SvPV(__fetchmember(_pHV_,\"charset\"),PL_na)	;
	(($type)$var)->value = (char *)SvPV(__fetchmember(_pHV_,\"value\"),PL_na)	;

            }
        else
            {
            $var = NULL ;
            }
        }

ne_xml_parser__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::XML\") ;

        $var = ($type)SvIV (*ppObj) ;
        }

ne_propfind_handler__

        {
        SV ** ppObj = NULL ;
        ppObj = hv_fetch (pPerl2C, (char *)(SvRV($arg)), sizeof (void *), 0) ;

        if (!ppObj || !*ppObj)
            croak (\"\$var is not of type HTTP::Webdav::Propfind\") ;

        $var = ($type)SvIV (*ppObj) ;
        }




OUTPUT
ne_session__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

ne_content_range__

        {
        HV * _pHV_ ;
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {
	sv_setiv(__fetchmember(_pHV_,\"start\"), (IV)(($type)$var)->start);
	;
	sv_setiv(__fetchmember(_pHV_,\"end\"), (IV)(($type)$var)->end);
	;
	sv_setiv(__fetchmember(_pHV_,\"total\"), (IV)(($type)$var)->total);
	;

            }
        }

T_CVREF2
;
ne_propname__

        {
        HV * _pHV_ ;

        /* croak (\"$var unsupported\") ; */
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {
	sv_setpv((SV*)__fetchmember(_pHV_,\"nspace\"), (($type)$var)->nspace);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"name\"), (($type)$var)->name);
	;

            }
        }

ne_lock_session__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::LockSession\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

ne_prop_result_set__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::Propset\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

struct_ne_lock__

        {
        HV * _pHV_ ;
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {
	sv_setpv((SV*)__fetchmember(_pHV_,\"uri\"), (($type)$var)->uri);
	;
	sv_setiv(__fetchmember(_pHV_,\"depth\"), (IV)(($type)$var)->depth);
	;
	sv_setiv(__fetchmember(_pHV_,\"type\"), (IV)(($type)$var)->type);
	;
	sv_setiv(__fetchmember(_pHV_,\"scope\"), (IV)(($type)$var)->scope);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"token\"), (($type)$var)->token);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"owner\"), (($type)$var)->owner);
	;
	sv_setiv(__fetchmember(_pHV_,\"timeout\"), (IV)(($type)$var)->timeout);
	;
	sv_setiv(__fetchmember(_pHV_,\"prev\"), (IV)(($type)$var)->prev);
	;
	sv_setiv(__fetchmember(_pHV_,\"next\"), (IV)(($type)$var)->next);
	;

            }
        }

nssl_certificate__

        {
        HV * _pHV_ ;
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {
	sv_setpv((SV*)__fetchmember(_pHV_,\"owner\"), (($type)$var)->owner);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"issuer\"), (($type)$var)->issuer);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"valid_from\"), (($type)$var)->valid_from);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"valid_till\"), (($type)$var)->valid_till);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"fingerprint\"), (($type)$var)->fingerprint);
	;

            }
        }

struct_ne_md__ctx__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::MD5\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

ne_server_capabilities__

        {
        HV * _pHV_ ;
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {
	sv_setuv(__fetchmember(_pHV_,\"dav_class1\"), (UV)(($type)$var)->dav_class1);
	;
	sv_setuv(__fetchmember(_pHV_,\"dav_class2\"), (UV)(($type)$var)->dav_class2);
	;
	sv_setuv(__fetchmember(_pHV_,\"dav_executable\"), (UV)(($type)$var)->dav_executable);
	;

            }
        }

ne_proppatch_operation__

        {
        HV * _pHV_ ;

        /* croak (\"$var unsupported\") ; */
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {

        {
        HV * _pHV_x_ ;

        /* croak (\"(($type)$var)->name unsupported\") ; */
        if (!SvOK(__fetchmember(_pHV_,\"name\")))
            {
            __fetchmember(_pHV_,\"name\") = newRV_noinc((SV *)(_pHV_x_ = newHV())) ;
            sv_2mortal (__fetchmember(_pHV_,\"name\")) ;
            }
        else if (!SvROK (__fetchmember(_pHV_,\"name\")))
            {
            croak (\"(($type)$var)->name must be a reference\") ;
            }
        else if (SvTYPE(_pHV_x_ = (HV *)SvRV(__fetchmember(_pHV_,\"name\"))) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_x_, SVt_PVHV) ;
        if ((($type)$var)->name)
            {
	sv_setpv((SV*)__fetchmember(_pHV_x_,\"nspace\"), ((ne_propname *)(($type)$var)->name)->nspace);
	;
	sv_setpv((SV*)__fetchmember(_pHV_x_,\"name\"), ((ne_propname *)(($type)$var)->name)->name);
	;

            }
        }
	;
	sv_setiv(__fetchmember(_pHV_,\"type\"), (IV)(($type)$var)->type);	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"value\"), (($type)$var)->value);
	;

            }
        }

ne_status__

        {
        HV * _pHV_ ;
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {
	sv_setiv(__fetchmember(_pHV_,\"major_version\"), (IV)(($type)$var)->major_version);
	;
	sv_setiv(__fetchmember(_pHV_,\"minor_version\"), (IV)(($type)$var)->minor_version);
	;
	sv_setiv(__fetchmember(_pHV_,\"code\"), (IV)(($type)$var)->code);
	;
	sv_setiv(__fetchmember(_pHV_,\"klass\"), (IV)(($type)$var)->klass);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"reason_phrase\"), (($type)$var)->reason_phrase);
	;

            }
        }

ne_____parser__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::MultiStatus\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

T_ENUM
	sv_setiv($arg, (IV)$var);
ne_buffer__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::Buffer\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

ne_acl_entry__

        {
        HV * _pHV_ ;
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {
	sv_setiv(__fetchmember(_pHV_,\"apply\"), (IV)(($type)$var)->apply);	;
	sv_setiv(__fetchmember(_pHV_,\"type\"), (IV)(($type)$var)->type);	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"principal\"), (($type)$var)->principal);
	;
	sv_setiv(__fetchmember(_pHV_,\"read\"), (IV)(($type)$var)->read);
	;
	sv_setiv(__fetchmember(_pHV_,\"read_acl\"), (IV)(($type)$var)->read_acl);
	;
	sv_setiv(__fetchmember(_pHV_,\"write\"), (IV)(($type)$var)->write);
	;
	sv_setiv(__fetchmember(_pHV_,\"write_acl\"), (IV)(($type)$var)->write_acl);
	;
	sv_setiv(__fetchmember(_pHV_,\"read_cuprivset\"), (IV)(($type)$var)->read_cuprivset);
	;

            }
        }

ne_request__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::Request\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

ne_lock_struct__

        {
        HV * _pHV_ ;
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {
	sv_setpv((SV*)__fetchmember(_pHV_,\"uri\"), (($type)$var)->uri);
	;
	sv_setiv(__fetchmember(_pHV_,\"depth\"), (IV)(($type)$var)->depth);
	;
	sv_setiv(__fetchmember(_pHV_,\"type\"), (IV)(($type)$var)->type);
	;
	sv_setiv(__fetchmember(_pHV_,\"scope\"), (IV)(($type)$var)->scope);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"token\"), (($type)$var)->token);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"owner\"), (($type)$var)->owner);
	;
	sv_setiv(__fetchmember(_pHV_,\"timeout\"), (IV)(($type)$var)->timeout);
	;
	sv_setiv(__fetchmember(_pHV_,\"prev\"), (IV)(($type)$var)->prev);
	;
	sv_setiv(__fetchmember(_pHV_,\"next\"), (IV)(($type)$var)->next);
	;

            }
        }

nssl_context__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::SSL\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

T_PTRNULL
sv_setiv($arg, (IV)$var);
nsocket__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::Socket\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

ne_content_type__

        {
        HV * _pHV_ ;
        if (!SvOK($arg))
            {
            $arg = newRV_noinc((SV *)(_pHV_ = newHV())) ;
            sv_2mortal ($arg) ;
            }
        else if (!SvROK ($arg))
            {
            croak (\"$var must be a reference\") ;
            }
        else if (SvTYPE(_pHV_ = (HV *)SvRV($arg)) != SVt_PVHV)
	    SvUPGRADE ((SV *)_pHV_, SVt_PVHV) ;
        if ($var)
            {
	sv_setpv((SV*)__fetchmember(_pHV_,\"type\"), (($type)$var)->type);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"subtype\"), (($type)$var)->subtype);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"charset\"), (($type)$var)->charset);
	;
	sv_setpv((SV*)__fetchmember(_pHV_,\"value\"), (($type)$var)->value);
	;

            }
        }

ne_xml_parser__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::XML\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }

ne_propfind_handler__

        {
        SV ** ppArg ;
        ppArg = hv_fetch (pC2Perl, (char *)(\&$var), sizeof($var), 1) ;
        if (!SvOK(*ppArg))
            {
            SV * pObj ;
            *ppArg = newRV_noinc ((SV *)newHV()) ;
            sv_2mortal(*ppArg) ;
	    sv_bless (*ppArg, gv_stashpv (\"HTTP::Webdav::Propfind\", 0)) ;
            hv_store (pPerl2C, (char *)(SvRV (*ppArg)), sizeof (void *), newSViv ((IV)$var), 0) ;
            }
        $arg = *ppArg ;
        }