"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "Basic/Core/pdlapi.c" between
PDL-2.077.tar.gz and PDL-2.078.tar.gz

About: PDL (Perl Data Language) aims to turn perl into an efficient numerical language for scientific computing (similar to IDL and MatLab).

pdlapi.c  (PDL-2.077):pdlapi.c  (PDL-2.078)
skipping to change at line 134 skipping to change at line 134
PDLDEBUG_f(printf("pdl_allocdata %p, %"IND_FLAG", %d\n",(void*)it, it->nvals, PDLDEBUG_f(printf("pdl_allocdata %p, %"IND_FLAG", %d\n",(void*)it, it->nvals,
it->datatype)); it->datatype));
if(it->nvals < 0) if(it->nvals < 0)
return pdl_make_error(PDL_EUSERERROR, "Tried to allocdata with %"IND_FLAG" v alues", it->nvals); return pdl_make_error(PDL_EUSERERROR, "Tried to allocdata with %"IND_FLAG" v alues", it->nvals);
PDL_Indx nbytes = it->nvals * pdl_howbig(it->datatype); PDL_Indx nbytes = it->nvals * pdl_howbig(it->datatype);
PDL_Indx ncurr = it->nbytes; PDL_Indx ncurr = it->nbytes;
if (ncurr == nbytes) if (ncurr == nbytes)
return PDL_err; /* Nothing to be done */ return PDL_err; /* Nothing to be done */
if(it->state & PDL_DONTTOUCHDATA) if(it->state & PDL_DONTTOUCHDATA)
return pdl_make_error_simple(PDL_EUSERERROR, "Trying to touch data of an unt ouchable (mmapped?) pdl"); return pdl_make_error_simple(PDL_EUSERERROR, "Trying to touch data of an unt ouchable (mmapped?) pdl");
if(it->datasv == NULL) char was_useheap = (ncurr > sizeof(it->value)),
it->datasv = newSVpv("",0); will_useheap = (nbytes > sizeof(it->value));
SV* foo = it->datasv; if (!was_useheap && !will_useheap) {
(void)SvGROW ( foo, nbytes ); it->data = &it->value;
SvCUR_set( foo, (STRLEN) nbytes ); } else if (!will_useheap) {
it->data = (void *) SvPV_nolen( foo ); /* was heap, now not */
void *data_old = it->data;
memmove(it->data = &it->value, data_old, PDLMIN(ncurr, nbytes));
SvREFCNT_dec((SV*)it->datasv);
it->datasv = NULL;
} else {
/* now change to be heap */
if (it->datasv == NULL)
it->datasv = newSVpvn("", 0);
(void)SvGROW((SV*)it->datasv, nbytes);
SvCUR_set((SV*)it->datasv, nbytes);
if (it->data && !was_useheap)
memmove(SvPV_nolen((SV*)it->datasv), it->data, PDLMIN(ncurr, nbytes));
it->data = SvPV_nolen((SV*)it->datasv);
}
if (nbytes > ncurr) memset(it->data + ncurr, 0, nbytes - ncurr); if (nbytes > ncurr) memset(it->data + ncurr, 0, nbytes - ncurr);
it->nbytes = nbytes; it->nbytes = nbytes;
it->state |= PDL_ALLOCATED; it->state |= PDL_ALLOCATED;
PDLDEBUG_f(pdl_dump(it)); PDLDEBUG_f(pdl_dump(it));
return PDL_err; return PDL_err;
} }
pdl* pdl_pdlnew() { pdl* pdl_pdlnew() {
pdl* it; pdl* it;
it = (pdl*) malloc(sizeof(pdl)); it = (pdl*) malloc(sizeof(pdl));
skipping to change at line 253 skipping to change at line 267
} }
/* Call special freeing magic, if exists */ /* Call special freeing magic, if exists */
if(PDL_ISMAGIC(it)) { if(PDL_ISMAGIC(it)) {
pdl__call_magic(it, PDL_MAGIC_DELETEDATA); pdl__call_magic(it, PDL_MAGIC_DELETEDATA);
pdl__magic_free(it); pdl__magic_free(it);
} }
if(it->datasv) { if(it->datasv) {
PDLDEBUG_f(printf("SvREFCNT_dec datasv=%p\n",it->datasv);) PDLDEBUG_f(printf("SvREFCNT_dec datasv=%p\n",it->datasv);)
SvREFCNT_dec(it->datasv); SvREFCNT_dec(it->datasv);
it->data=0; it->data=0;
} else if(it->data) { } else if(it->data && it->data != &it->value) {
pdl_pdl_warn("Warning: special data without datasv is not freed curre ntly!!"); pdl_pdl_warn("Warning: special data without datasv is not freed curre ntly!!");
} }
if(it->hdrsv) { if(it->hdrsv) {
PDLDEBUG_f(printf("SvREFCNT_dec hdrsv=%p\n",it->hdrsv);) PDLDEBUG_f(printf("SvREFCNT_dec hdrsv=%p\n",it->hdrsv);)
SvREFCNT_dec(it->hdrsv); SvREFCNT_dec(it->hdrsv);
it->hdrsv = 0; it->hdrsv = 0;
} }
free(it); free(it);
PDLDEBUG_f(printf("pdl__free end %p\n",(void*)it)); PDLDEBUG_f(printf("pdl__free end %p\n",(void*)it));
return PDL_err; return PDL_err;
} }
void pdl__removechildtrans(pdl *it,pdl_trans *trans) void pdl__removetrans_children(pdl *it,pdl_trans *trans)
{ {
PDLDEBUG_f(printf("pdl__removechildtrans(%s=%p): %p\n", PDLDEBUG_f(printf("pdl__removetrans_children(%s=%p): %p\n",
trans->vtable->name, trans, it)); trans->vtable->name, trans, it));
PDL_Indx i; int flag = 0; PDL_Indx i; int flag = 0;
for(i=0; i<trans->vtable->nparents; i++) for(i=0; i<trans->vtable->nparents; i++)
if(trans->pdls[i] == it) if(trans->pdls[i] == it)
trans->pdls[i] = NULL; trans->pdls[i] = NULL;
PDL_DECL_CHILDLOOP(it); PDL_DECL_CHILDLOOP(it);
PDL_START_CHILDLOOP(it) PDL_START_CHILDLOOP(it)
if (PDL_CHILDLOOP_THISCHILD(it) != trans) continue; if (PDL_CHILDLOOP_THISCHILD(it) != trans) continue;
PDL_CHILDLOOP_THISCHILD(it) = NULL; PDL_CHILDLOOP_THISCHILD(it) = NULL;
flag = 1; flag = 1;
/* Can't return; might be many times (e.g. $x+$x) */ /* Can't return; might be many times (e.g. $x+$x) */
PDL_END_CHILDLOOP(it) PDL_END_CHILDLOOP(it)
/* this might be due to a croak when performing the trans; so /* this might be due to a croak when performing the trans; so
warn only for now, otherwise we leave trans undestructed ! */ warn only for now, otherwise we leave trans undestructed ! */
if(!flag) if(!flag)
pdl_pdl_warn("Child not found for pdl %p, trans %p\n",it, trans); pdl_pdl_warn("Child not found for pdl %p, trans %p\n",it, trans);
} }
void pdl__removeparenttrans(pdl *it, pdl_trans *trans, PDL_Indx nth) void pdl__removetrans_parent(pdl *it, pdl_trans *trans, PDL_Indx nth)
{ {
PDLDEBUG_f(printf("pdl__removeparenttrans(%s=%p): %p %"IND_FLAG"\n", PDLDEBUG_f(printf("pdl__removetrans_parent(%s=%p): %p %"IND_FLAG"\n",
trans->vtable->name, (void*)trans, (void*)(it), nth)); trans->vtable->name, (void*)trans, (void*)(it), nth));
trans->pdls[nth] = 0; trans->pdls[nth] = 0;
it->trans_parent = 0; if (it->trans_parent == trans) it->trans_parent = 0;
it->state &= ~PDL_MYDIMS_TRANS;
} }
pdl_error pdl_trans_finaldestroy(pdl_trans *trans) pdl_error pdl_trans_finaldestroy(pdl_trans *trans)
{ {
pdl_error PDL_err = {0, NULL, 0}; pdl_error PDL_err = {0, NULL, 0};
PDLDEBUG_f(printf("pdl_trans_finaldestroy %p\n", trans)); PDLDEBUG_f(printf("pdl_trans_finaldestroy %p\n", trans));
FREETRANS(trans, 1); FREETRANS(trans, 1);
if(trans->vtable->flags & PDL_TRANS_DO_BROADCAST) if(trans->vtable->flags & PDL_TRANS_DO_BROADCAST)
pdl_freebroadcaststruct(&trans->broadcast); pdl_freebroadcaststruct(&trans->broadcast);
trans->vtable = 0; /* Make sure no-one uses this */ trans->vtable = 0; /* Make sure no-one uses this */
skipping to change at line 328 skipping to change at line 343
return pdl_make_error(PDL_EFATAL, "ZERO VTABLE DESTTRAN 0x%p %d\n ",trans,ensure); return pdl_make_error(PDL_EFATAL, "ZERO VTABLE DESTTRAN 0x%p %d\n ",trans,ensure);
if (!ismutual) for(j=0; j<trans->vtable->nparents; j++) if (!ismutual) for(j=0; j<trans->vtable->nparents; j++)
if (trans->pdls[j]->state & PDL_DATAFLOW_ANY) { ismutual=1; break; } if (trans->pdls[j]->state & PDL_DATAFLOW_ANY) { ismutual=1; break; }
PDLDEBUG_f(printf("pdl_destroytransform %s=%p (ensure=%d ismutual=%d)\n", PDLDEBUG_f(printf("pdl_destroytransform %s=%p (ensure=%d ismutual=%d)\n",
trans->vtable ? trans->vtable->name : "NULL", trans->vtable ? trans->vtable->name : "NULL",
(void*)trans,ensure,ismutual)); (void*)trans,ensure,ismutual));
if(ensure) if(ensure)
PDL_ACCUMERROR(PDL_err, pdl__ensure_trans(trans,ismutual ? 0 : PD L_PARENTDIMSCHANGED,wd)); PDL_ACCUMERROR(PDL_err, pdl__ensure_trans(trans,ismutual ? 0 : PD L_PARENTDIMSCHANGED,wd));
pdl *destbuffer[trans->vtable->npdls]; pdl *destbuffer[trans->vtable->npdls];
int ndest = 0; int ndest = 0;
if (ismutual) { for(j=0; j<trans->vtable->nparents; j++) {
for(j=0; j<trans->vtable->nparents; j++) { pdl *parent = trans->pdls[j];
pdl *parent = trans->pdls[j]; if(!parent) continue;
if(!parent) continue; PDL_CHKMAGIC(parent);
PDL_CHKMAGIC(parent); pdl__removetrans_children(parent,trans);
pdl__removechildtrans(parent,trans); if (!(parent->state & PDL_DESTROYING) && !parent->sv) {
if(!(parent->state & PDL_DESTROYING) && !parent->sv) parent->state |= PDL_DESTROYING; /* so no mark twice */
destbuffer[ndest++] = parent; destbuffer[ndest++] = parent;
}
for(; j<trans->vtable->npdls; j++) {
pdl *child = trans->pdls[j];
PDL_CHKMAGIC(child);
pdl__removeparenttrans(child,trans,j);
if(child->vafftrans) pdl_vafftrans_remove(child);
if ((!(child->state & PDL_DESTROYING) && !child->sv) ||
(trans->vtable->par_flags[j] & PDL_PARAM_ISTEMP))
destbuffer[ndest++] = child;
} }
} else { }
for(j=trans->vtable->nparents; j<trans->vtable->npdls; j++) { for(j=trans->vtable->nparents; j<trans->vtable->npdls; j++) {
pdl *child = trans->pdls[j]; pdl *child = trans->pdls[j];
if(child->trans_parent == trans) PDL_CHKMAGIC(child);
child->trans_parent = 0; pdl__removetrans_parent(child,trans,j);
if (trans->vtable->par_flags[j] & PDL_PARAM_ISTEMP) if (ismutual && child->vafftrans) pdl_vafftrans_remove(child);
destbuffer[ndest++] = child; if ((!(child->state & PDL_DESTROYING) && !child->sv) ||
(trans->vtable->par_flags[j] & PDL_PARAM_ISTEMP)) {
child->state |= PDL_DESTROYING; /* so no mark twice */
destbuffer[ndest++] = child;
} }
} }
PDL_ACCUMERROR(PDL_err, pdl_trans_finaldestroy(trans)); PDL_ACCUMERROR(PDL_err, pdl_trans_finaldestroy(trans));
for(j=0; j<ndest; j++) for(j=0; j<ndest; j++) {
destbuffer[j]->state &= ~PDL_DESTROYING; /* safe, set by us */
PDL_ACCUMERROR(PDL_err, pdl_destroy(destbuffer[j])); PDL_ACCUMERROR(PDL_err, pdl_destroy(destbuffer[j]));
}
PDLDEBUG_f(printf("pdl_destroytransform leaving %p\n", (void*)trans)); PDLDEBUG_f(printf("pdl_destroytransform leaving %p\n", (void*)trans));
return PDL_err; return PDL_err;
} }
/* /*
A ndarray may be A ndarray may be
- a parent of something - just ensure & destroy - a parent of something - just ensure & destroy
- a child of something - just ensure & destroy - a child of something - just ensure & destroy
- parent of two pdls which both propagate backwards - mustn't destroy. - parent of two pdls which both propagate backwards - mustn't destroy.
- both parent and child at same time, to something that propagates. - both parent and child at same time, to something that propagates.
skipping to change at line 382 skipping to change at line 393
When an ndarray is destroyed, it must tell its trans_children and/or When an ndarray is destroyed, it must tell its trans_children and/or
parent. parent.
*/ */
pdl_error pdl_destroy(pdl *it) { pdl_error pdl_destroy(pdl *it) {
pdl_error PDL_err = {0, NULL, 0}; pdl_error PDL_err = {0, NULL, 0};
int nback=0,nback2=0,nforw=0; int nback=0,nback2=0,nforw=0;
int nafn=0; int nafn=0;
PDL_DECL_CHILDLOOP(it); PDL_DECL_CHILDLOOP(it);
PDL_CHKMAGIC(it); PDL_CHKMAGIC(it);
PDLDEBUG_f(printf("pdl_destroy %p\n",(void*)it)); PDLDEBUG_f(printf("pdl_destroy: ");pdl_dump(it));
if(it->state & PDL_DESTROYING) { if(it->state & PDL_DESTROYING) {
PDLDEBUG_f(printf(" already destroying, returning\n")); PDLDEBUG_f(printf(" already destroying, returning\n"));
return PDL_err; return PDL_err;
} }
it->state |= PDL_DESTROYING; it->state |= PDL_DESTROYING;
/* Clear the sv field so that there will be no dangling ptrs */ /* Clear the sv field so that there will be no dangling ptrs */
if(it->sv) { if(it->sv) {
mg_free((SV *)it->sv); mg_free((SV *)it->sv);
sv_setiv(it->sv,0x4242); sv_setiv(it->sv,0x4242);
it->sv = NULL; it->sv = NULL;
skipping to change at line 682 skipping to change at line 693
pdl_transvtable *vtable = trans->vtable; pdl_transvtable *vtable = trans->vtable;
PDL_Indx i, npdls=vtable->npdls, nparents=vtable->nparents; PDL_Indx i, npdls=vtable->npdls, nparents=vtable->nparents;
PDL_TR_CHKMAGIC(trans); PDL_TR_CHKMAGIC(trans);
int pfflag=0; int pfflag=0;
PDL_err = pdl_trans_flow_null_checks(trans, &pfflag); PDL_err = pdl_trans_flow_null_checks(trans, &pfflag);
if (PDL_err.error) { if (PDL_err.error) {
PDL_ACCUMERROR(PDL_err, pdl_trans_finaldestroy(trans)); PDL_ACCUMERROR(PDL_err, pdl_trans_finaldestroy(trans));
return PDL_err; return PDL_err;
} }
char dataflow = !!(pfflag || (trans->flags & PDL_ITRANS_DO_DATAFLOW_ANY)); char dataflow = !!(pfflag || (trans->flags & PDL_ITRANS_DO_DATAFLOW_ANY));
if (dataflow) for(i=0; i<nparents; i++) {
for(i=0; i<nparents; i++) { pdl *parent = trans->pdls[i];
pdl *parent = trans->pdls[i]; PDL_RETERROR(PDL_err, pdl__addchildtrans(parent,trans));
PDL_RETERROR(PDL_err, pdl__addchildtrans(parent,trans)); if (parent->state & PDL_DATAFLOW_F) trans->flags |= PDL_ITRANS_DO_DATAFLOW_F
if (parent->state & PDL_DATAFLOW_F) trans->flags |= PDL_ITRANS_DO_DATAFLOW ;
_F; }
}
int wd[npdls]; int wd[npdls];
for(i=nparents; i<npdls; i++) { for(i=nparents; i<npdls; i++) {
pdl *child = trans->pdls[i]; pdl *child = trans->pdls[i];
char isnull = !!(child->state & PDL_NOMYDIMS); char isnull = !!(child->state & PDL_NOMYDIMS);
wd[i]=(isnull ? PDL_PARENTDIMSCHANGED : PDL_PARENTDATACHANGED); wd[i]=(isnull ? PDL_PARENTDIMSCHANGED : PDL_PARENTDATACHANGED);
if (dataflow) { if (dataflow) {
/* This is because for "+=" (a = a + b) we must check for /* This is because for "+=" (a = a + b) we must check for
previous parent transformations and mutate if they exist previous parent transformations and mutate if they exist
if no dataflow. */ if no dataflow. */
child->state |= PDL_PARENTDIMSCHANGED | PDL_PARENTDATACHANGED; child->state |= PDL_PARENTDIMSCHANGED | PDL_PARENTDATACHANGED;
skipping to change at line 829 skipping to change at line 839
? pdl->vafftrans->from ? pdl->vafftrans->from
: pdl, : pdl,
what,0); what,0);
} }
} }
} else { } else {
PDL_DECL_CHILDLOOP(it); PDL_DECL_CHILDLOOP(it);
PDL_START_CHILDLOOP(it) PDL_START_CHILDLOOP(it)
pdl_trans *trans = PDL_CHILDLOOP_THISCHILD(it); pdl_trans *trans = PDL_CHILDLOOP_THISCHILD(it);
for(j=trans->vtable->nparents; j<trans->vtable->npdls; j++) for(j=trans->vtable->nparents; j<trans->vtable->npdls; j++)
CHANGED(trans->pdls[j],what,1); if (trans->pdls[j] != it && (trans->pdls[j]->state & what) != wha
t)
CHANGED(trans->pdls[j],what,1);
PDL_END_CHILDLOOP(it) PDL_END_CHILDLOOP(it)
} }
PDLDEBUG_f(printf("pdl_changed: exiting for pdl %p\n",(void*)it)); PDLDEBUG_f(printf("pdl_changed: exiting for pdl %p\n",(void*)it));
return PDL_err; return PDL_err;
} }
/* Current assumptions: only /* Current assumptions: only
* "slice" and "diagonal"-type things supported. * "slice" and "diagonal"-type things supported.
* *
* We need to do careful testing for clump-type things. * We need to do careful testing for clump-type things.
skipping to change at line 1000 skipping to change at line 1011
if (!src->trans_parent) return PDL_err; if (!src->trans_parent) return PDL_err;
PDL_RETERROR(PDL_err, pdl_make_physvaffine(src)); PDL_RETERROR(PDL_err, pdl_make_physvaffine(src));
PDL_RETERROR(PDL_err, pdl_destroytransform(src->trans_parent,1,NULL)); PDL_RETERROR(PDL_err, pdl_destroytransform(src->trans_parent,1,NULL));
return PDL_err; return PDL_err;
} }
/* newval = 1 means set flag, 0 means clear it */ /* newval = 1 means set flag, 0 means clear it */
void pdl_propagate_badflag( pdl *it, int newval ) { void pdl_propagate_badflag( pdl *it, int newval ) {
PDL_DECL_CHILDLOOP(it) PDL_DECL_CHILDLOOP(it)
PDL_START_CHILDLOOP(it) PDL_START_CHILDLOOP(it)
{
pdl_trans *trans = PDL_CHILDLOOP_THISCHILD(it); pdl_trans *trans = PDL_CHILDLOOP_THISCHILD(it);
int i; PDL_Indx i;
for( i = trans->vtable->nparents; for( i = trans->vtable->nparents; i < trans->vtable->npdls; i++ ) {
i < trans->vtable->npdls; i++ ) {
pdl *child = trans->pdls[i]; pdl *child = trans->pdls[i];
char need_recurse = (!!newval != !!(child->state & PDL_BADVAL)); char need_recurse = (!!newval != !!(child->state & PDL_BADVAL));
if ( newval ) { if ( newval ) {
child->state |= PDL_BADVAL; child->state |= PDL_BADVAL;
} else { } else {
child->state &= ~PDL_BADVAL; child->state &= ~PDL_BADVAL;
} }
/* make sure we propagate to grandchildren, etc if changed */ /* make sure we propagate to grandchildren, etc if changed */
if (need_recurse) if (need_recurse)
pdl_propagate_badflag( child, newval ); pdl_propagate_badflag( child, newval );
} /* for: i */ } /* for: i */
}
PDL_END_CHILDLOOP(it) PDL_END_CHILDLOOP(it)
} /* pdl_propagate_badflag */ } /* pdl_propagate_badflag */
void pdl_propagate_badvalue( pdl *it ) { void pdl_propagate_badvalue( pdl *it ) {
PDL_DECL_CHILDLOOP(it) PDL_DECL_CHILDLOOP(it)
PDL_START_CHILDLOOP(it) PDL_START_CHILDLOOP(it)
{
pdl_trans *trans = PDL_CHILDLOOP_THISCHILD(it); pdl_trans *trans = PDL_CHILDLOOP_THISCHILD(it);
int i; PDL_Indx i;
for( i = trans->vtable->nparents; for( i = trans->vtable->nparents; i < trans->vtable->npdls; i++ ) {
i < trans->vtable->npdls; i++ ) {
pdl *child = trans->pdls[i]; pdl *child = trans->pdls[i];
child->has_badvalue = 1; child->has_badvalue = 1;
child->badvalue = it->badvalue; child->badvalue = it->badvalue;
/* make sure we propagate to grandchildren, etc */ /* make sure we propagate to grandchildren, etc */
pdl_propagate_badvalue( child ); pdl_propagate_badvalue( child );
} /* for: i */ } /* for: i */
}
PDL_END_CHILDLOOP(it) PDL_END_CHILDLOOP(it)
} /* pdl_propagate_badvalue */ } /* pdl_propagate_badvalue */
PDL_Anyval pdl_get_badvalue( int datatype ) { PDL_Anyval pdl_get_badvalue( int datatype ) {
PDL_Anyval retval = { PDL_INVALID, {0} }; PDL_Anyval retval = { PDL_INVALID, {0} };
#define X(datatype, ctype, ppsym, shortctype, ...) \ #define X(datatype, ctype, ppsym, shortctype, ...) \
retval.type = datatype; retval.value.ppsym = PDL.bvals.shortctype; retval.type = datatype; retval.value.ppsym = PDL.bvals.shortctype;
PDL_GENERICSWITCH(PDL_TYPELIST2_ALL, datatype, X, return retval) PDL_GENERICSWITCH(PDL_TYPELIST2_ALL, datatype, X, return retval)
#undef X #undef X
return retval; return retval;
skipping to change at line 1068 skipping to change at line 1073
it->params = malloc(vtable->structsize); it->params = malloc(vtable->structsize);
if (!it->params) return NULL; if (!it->params) return NULL;
memset(it->params, 0, vtable->structsize); memset(it->params, 0, vtable->structsize);
} }
it->flags = vtable->iflags; it->flags = vtable->iflags;
it->dims_redone = 0; it->dims_redone = 0;
it->bvalflag = 0; it->bvalflag = 0;
it->vtable = vtable; it->vtable = vtable;
PDL_CLRMAGIC(&it->broadcast); PDL_CLRMAGIC(&it->broadcast);
it->broadcast.inds = 0; it->broadcast.inds = 0;
it->broadcast.gflags = 0;
it->ind_sizes = (PDL_Indx *)malloc(sizeof(PDL_Indx) * vtable->ninds); it->ind_sizes = (PDL_Indx *)malloc(sizeof(PDL_Indx) * vtable->ninds);
if (!it->ind_sizes) return NULL; if (!it->ind_sizes) return NULL;
int i; for (i=0; i<vtable->ninds; i++) it->ind_sizes[i] = -1; int i; for (i=0; i<vtable->ninds; i++) it->ind_sizes[i] = -1;
it->inc_sizes = (PDL_Indx *)malloc(sizeof(PDL_Indx) * vtable->nind_ids); it->inc_sizes = (PDL_Indx *)malloc(sizeof(PDL_Indx) * vtable->nind_ids);
if (!it->inc_sizes) return NULL; if (!it->inc_sizes) return NULL;
for (i=0; i<vtable->nind_ids; i++) it->inc_sizes[i] = -1; for (i=0; i<vtable->nind_ids; i++) it->inc_sizes[i] = -1;
it->offs = -1; it->offs = -1;
it->incs = NULL; it->incs = NULL;
it->__datatype = PDL_INVALID; it->__datatype = PDL_INVALID;
return it; return it;
 End of changes. 21 change blocks. 
56 lines changed or deleted 63 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)