view release on metacpan or  search on metacpan

xs/Apache/DAV/Error/Error.xs  view on Meta::CPAN

        memcpy (obj, (void *)SvIVX(item), sizeof (*obj)) ;
    else if (SvTYPE(item) == SVt_PVHV) {
        if ((tmpsv = hv_fetch((HV *)item, "status", sizeof("status") - 1, 0)) || overwrite) {
            obj -> status = (int)davxs_sv2_IV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "error_id", sizeof("error_id") - 1, 0)) || overwrite) {
            obj -> error_id = (int)davxs_sv2_IV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "desc", sizeof("desc") - 1, 0)) || overwrite) {
            const char * tmpobj = ((const char *)davxs_sv2_PV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)));
            if (tmpobj)
                obj -> desc = (const char *)strdup(tmpobj);
            else
                obj -> desc = NULL ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "save_errno", sizeof("save_errno") - 1, 0)) || overwrite) {
            obj -> save_errno = (int)davxs_sv2_IV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "prev", sizeof("prev") - 1, 0)) || overwrite) {
            obj -> prev = (struct dav_error *)davxs_sv2_Apache__DAV__Error((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "ctx_i", sizeof("ctx_i") - 1, 0)) || overwrite) {
            obj -> ctx_i = (int)davxs_sv2_IV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "ctx_s", sizeof("ctx_s") - 1, 0)) || overwrite) {
            const char * tmpobj = ((const char *)davxs_sv2_PV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)));
            if (tmpobj)
                obj -> ctx_s = (const char *)strdup(tmpobj);
            else
                obj -> ctx_s = NULL ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "ctx_p", sizeof("ctx_p") - 1, 0)) || overwrite) {
            obj -> ctx_p = (void *)davxs_sv2_PTR((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
   ; }

    else
        croak ("initializer for Apache::DAV::Error::new is not a hash or object reference") ;

} ;



/* --- Apache::DAV::Error -> compute_desc --- */



static void davxs_cb_Apache__DAV__Error__compute_desc (SV * __cbdest,struct dav_error * err,pool * p)
    {

    int __cnt ;
    
    dSP ;
    ENTER ;
    SAVETMPS ;
    PUSHMARK(SP) ;
    PUSHs(__cbdest) ;
    PUSHs(davxs_Apache__DAV__Error_2obj(err)) ;
    PUSHs(davxs_Apache__Pool_2obj(p)) ;

    PUTBACK ;
    __cnt = perl_call_method("compute_desc", G_VOID) ;


    if (__cnt != 0)
        croak ("davxs_cb_Apache__DAV__Error__compute_desc expected 0 return values") ;

    SPAGAIN ;

    PUTBACK ;
    FREETMPS ;
    LEAVE ;
    
   

    }
   


static void davxs_cb_Apache__DAV__Error__compute_desc_obj0 (struct dav_error * err,pool * p)
    {
     davxs_cb_Apache__DAV__Error__compute_desc (davxs_Apache__DAV__Error_obj[0],err,p) ;
    }



static void davxs_cb_Apache__DAV__Error__compute_desc_obj1 (struct dav_error * err,pool * p)
    {
     davxs_cb_Apache__DAV__Error__compute_desc (davxs_Apache__DAV__Error_obj[1],err,p) ;
    }



static void davxs_cb_Apache__DAV__Error__compute_desc_obj2 (struct dav_error * err,pool * p)
    {
     davxs_cb_Apache__DAV__Error__compute_desc (davxs_Apache__DAV__Error_obj[2],err,p) ;
    }



static void davxs_cb_Apache__DAV__Error__compute_desc_obj3 (struct dav_error * err,pool * p)
    {
     davxs_cb_Apache__DAV__Error__compute_desc (davxs_Apache__DAV__Error_obj[3],err,p) ;
    }

typedef void (*tdavxs_cb_Apache__DAV__Error__compute_desc_func)(struct dav_error * err,pool * p)  ;
static tdavxs_cb_Apache__DAV__Error__compute_desc_func davxs_davxs_cb_Apache__DAV__Error__compute_desc_func [4] = {
    davxs_cb_Apache__DAV__Error__compute_desc_obj0,
    davxs_cb_Apache__DAV__Error__compute_desc_obj1,
    davxs_cb_Apache__DAV__Error__compute_desc_obj2,
    davxs_cb_Apache__DAV__Error__compute_desc_obj3
    } ;


MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 

int
status(obj, val=0)
    Apache::DAV::Error obj
    int val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (int)  obj->status;

    if (items > 1) {
        obj->status = (int) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 

int
error_id(obj, val=0)
    Apache::DAV::Error obj
    int val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (int)  obj->error_id;

    if (items > 1) {
        obj->error_id = (int) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 

const char *
desc(obj, val=NULL)
    Apache::DAV::Error obj
    const char * val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (const char *)  obj->desc;

    if (items > 1) {
        obj->desc = (const char *)strdup(val);
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 

int
save_errno(obj, val=0)
    Apache::DAV::Error obj
    int val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (int)  obj->save_errno;

    if (items > 1) {
        obj->save_errno = (int) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 

Apache::DAV::Error
prev(obj, val=NULL)
    Apache::DAV::Error obj
    Apache::DAV::Error val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (Apache__DAV__Error)  obj->prev;

    if (items > 1) {
        obj->prev = (Apache__DAV__Error) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 

void
compute_desc(__self, err, p)
    Apache::DAV::Error __self
    Apache::DAV::Error err
    Apache::Pool p
CODE:
    (*__self->compute_desc)(err, p);


MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 

int
ctx_i(obj, val=0)
    Apache::DAV::Error obj
    int val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (int)  obj->ctx_i;

    if (items > 1) {
        obj->ctx_i = (int) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 

const char *
ctx_s(obj, val=NULL)
    Apache::DAV::Error obj
    const char * val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (const char *)  obj->ctx_s;

    if (items > 1) {
        obj->ctx_s = (const char *)strdup(val);
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 

void *
ctx_p(obj, val=NULL)
    Apache::DAV::Error obj
    void * val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (void *)  obj->ctx_p;

    if (items > 1) {
        obj->ctx_p = (void *) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 



SV *
new (class,initializer=NULL)
    char * class
    SV * initializer 
PREINIT:
    SV * svobj ;
    Apache__DAV__Error  cobj ;
    SV * tmpsv ;
CODE:
    davxs_Apache__DAV__Error_create_obj(cobj,svobj,RETVAL,malloc(sizeof(*cobj))) ;

    if (initializer) {
        if (!SvROK(initializer) || !(tmpsv = SvRV(initializer))) 
            croak ("initializer for Apache::DAV::Error::new is not a reference") ;

        if (SvTYPE(tmpsv) == SVt_PVHV || SvTYPE(tmpsv) == SVt_PVMG)  
            Apache__DAV__Error_new_init (aTHX_ cobj, tmpsv, 0) ;
        else if (SvTYPE(tmpsv) == SVt_PVAV) {
            int i ;
            SvGROW(svobj, sizeof (*cobj) * av_len((AV *)tmpsv)) ;     
            for (i = 0; i <= av_len((AV *)tmpsv); i++) {
                SV * * itemrv = av_fetch((AV *)tmpsv, i, 0) ;
                SV * item ;
                if (!itemrv || !*itemrv || !SvROK(*itemrv) || !(item = SvRV(*itemrv))) 
                    croak ("array element of initializer for Apache::DAV::Error::new is not a reference") ;
                Apache__DAV__Error_new_init (aTHX_ &cobj[i], item, 1) ;
            }
        }
        else {
             croak ("initializer for Apache::DAV::Error::new is not a hash/array/object reference") ;
        }
    }
OUTPUT:
    RETVAL 

MODULE = Apache::DAV::Error    PACKAGE = Apache::DAV::Error 



void
init_callbacks (obj)
    SV *  obj
PREINIT:
    int  n = -1 ;
    int  i ;
    Apache__DAV__Error cobj = (Apache__DAV__Error)davxs_sv2_Apache__DAV__Error(obj) ;
    SV * ref ;
    SV * perl_obj ;
CODE:

    perl_obj = SvRV(obj) ;
    ref = newRV_noinc(perl_obj) ;

    for (i=0;i < 4;i++)
        {
        if (davxs_Apache__DAV__Error_obj[i] == ref)
            {
            n = i ;
            break ;
            }
        }

    if (n < 0)
        for (i=0;i < 4;i++)
            {
            if (davxs_Apache__DAV__Error_obj[i] == NULL)
                {
                n = i ;
                break ;
                }
            }
        
    if (n < 0)
        croak ("Limit for concurrent object callbacks reached for Apache::DAV::Error. Limit is 4") ;

    davxs_Apache__DAV__Error_obj[n] = ref ;
    cobj -> compute_desc = davxs_davxs_cb_Apache__DAV__Error__compute_desc_func[n] ;
    

PROTOTYPES: disabled

BOOT:
    items = items; /* -Wall */