(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 |
|---|
"Fossies" - the Fresh Open Source Software Archive 