Changeset 12456


Ignore:
Timestamp:
06/18/12 16:01:24 (13 years ago)
Author:
Mathieu Morlighem
Message:

changing xmalloc to xNew and xfree to xDelete

Location:
issm/trunk-jpl/src/c/objects
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/objects/Bamg/BamgGeom.cpp

    r12365 r12456  
    2222BamgGeom::~BamgGeom(){
    2323
    24         xfree((void**)&this->Vertices);
    25         xfree((void**)&this->Edges);
    26         xfree((void**)&this->TangentAtEdges);
    27         xfree((void**)&this->Corners);
    28         xfree((void**)&this->RequiredVertices);
    29         xfree((void**)&this->RequiredEdges);
    30         xfree((void**)&this->CrackedEdges);
    31         xfree((void**)&this->SubDomains);
     24        xDelete<double>(this->Vertices);
     25        xDelete<double>(this->Edges);
     26        xDelete<double>(this->TangentAtEdges);
     27        xDelete<double>(this->Corners);
     28        xDelete<double>(this->RequiredVertices);
     29        xDelete<double>(this->RequiredEdges);
     30        xDelete<double>(this->CrackedEdges);
     31        xDelete<double>(this->SubDomains);
    3232
    3333}

  • issm/trunk-jpl/src/c/objects/Bamg/BamgMesh.cpp

    r12365 r12456  
    3333BamgMesh::~BamgMesh(){
    3434
    35         xfree((void**)&this->Vertices);
    36         xfree((void**)&this->Edges);
    37         xfree((void**)&this->Triangles);
    38         xfree((void**)&this->Quadrilaterals);
     35        xDelete<double>(this->Vertices);
     36        xDelete<double>(this->Edges);
     37        xDelete<double>(this->Triangles);
     38        xDelete<double>(this->Quadrilaterals);
    3939
    40         xfree((void**)&this->SubDomains);
    41         xfree((void**)&this->SubDomainsFromGeom);
    42         xfree((void**)&this->CrackedVertices);
    43         xfree((void**)&this->CrackedEdges);
     40        xDelete<double>(this->SubDomains);
     41        xDelete<double>(this->SubDomainsFromGeom);
     42        xDelete<double>(this->CrackedVertices);
     43        xDelete<double>(this->CrackedEdges);
    4444
    45         xfree((void**)&this->VerticesOnGeomVertex);
    46         xfree((void**)&this->VerticesOnGeomEdge);
    47         xfree((void**)&this->EdgesOnGeomEdge);
     45        xDelete<double>(this->VerticesOnGeomVertex);
     46        xDelete<double>(this->VerticesOnGeomEdge);
     47        xDelete<double>(this->EdgesOnGeomEdge);
    4848
    49         xfree((void**)&this->IssmEdges);
    50         xfree((void**)&this->IssmSegments);
     49        xDelete<double>(this->IssmEdges);
     50        xDelete<double>(this->IssmSegments);
    5151
    52         xfree((void**)&this->ElementConnectivity);
    53         xfree((void**)&this->NodalConnectivity);
    54         xfree((void**)&this->NodalElementConnectivity);
    55 
    56 
     52        xDelete<double>(this->ElementConnectivity);
     53        xDelete<double>(this->NodalConnectivity);
     54        xDelete<double>(this->NodalElementConnectivity);
    5755}
    5856/*}}}*/

  • issm/trunk-jpl/src/c/objects/Bamg/BamgOpts.cpp

    r12365 r12456  
    4444BamgOpts::~BamgOpts(){
    4545
    46         xfree((void**)&this->hminVertices);
    47         xfree((void**)&this->hmaxVertices);
    48         xfree((void**)&this->hVertices);
    49         xfree((void**)&this->metric);
    50         xfree((void**)&this->field);
    51         xfree((void**)&this->err);
     46        xDelete<double>(this->hminVertices);
     47        xDelete<double>(this->hmaxVertices);
     48        xDelete<double>(this->hVertices);
     49        xDelete<double>(this->metric);
     50        xDelete<double>(this->field);
     51        xDelete<double>(this->err);
    5252
    5353}

  • issm/trunk-jpl/src/c/objects/Bamg/Geometry.cpp

    r12365 r12456  
    298298                bamggeom->VerticesSize[1]=3;
    299299                if (nbv){
    300                         bamggeom->Vertices=(double*)xmalloc(3*nbv*sizeof(double));
     300                        bamggeom->Vertices=xNew<double>(3*nbv);
    301301                        for (i=0;i<nbv;i++){
    302302                                bamggeom->Vertices[i*3+0]=vertices[i].r.x;
    … …  
    314314                bamggeom->EdgesSize[1]=3;
    315315                if (nbe){
    316                         bamggeom->Edges=(double*)xmalloc(3*nbe*sizeof(double));
     316                        bamggeom->Edges=xNew<double>(3*nbe);
    317317                        for (i=0;i<nbe;i++){
    318318                                bamggeom->Edges[i*3+0]=GetId(edges[i][0])+1; //back to Matlab indexing
    … …  
    332332                bamggeom->RequiredEdgesSize[1]=1;
    333333                if (nbreq){
    334                         bamggeom->RequiredEdges=(double*)xmalloc(1*nbreq*sizeof(double));
     334                        bamggeom->RequiredEdges=xNew<double>(1*nbreq);
    335335                        count=0;
    336336                        for (i=0;i<nbe;i++){
    … …  
    349349                bamggeom->RequiredVerticesSize[1]=1;
    350350                if (nbreqv){
    351                         bamggeom->RequiredVertices=(double*)xmalloc(1*nbreqv*sizeof(double));
     351                        bamggeom->RequiredVertices=xNew<double>(1*nbreqv);
    352352                        count=0;
    353353                        for (i=0;i<nbv;i++){
    … …  
    364364                bamggeom->SubDomainsSize[1]=4;
    365365                if (nbsubdomains){
    366                         bamggeom->SubDomains=(double*)xmalloc(4*nbsubdomains*sizeof(double));
     366                        bamggeom->SubDomains=xNew<double>(4*nbsubdomains);
    367367                        for (i=0;i<nbsubdomains;i++){
    368368                                bamggeom->SubDomains[4*i+0]=2;
    … …  
    378378                bamggeom->TangentAtEdgesSize[1]=4;
    379379                if (nbtan){
    380                         bamggeom->TangentAtEdges=(double*)xmalloc(4*nbtan*sizeof(double));
     380                        bamggeom->TangentAtEdges=xNew<double>(4*nbtan);
    381381                        count=0;
    382382                        for (i=0;i<nbe;i++){

  • issm/trunk-jpl/src/c/objects/Bamg/Mesh.cpp

    r12408 r12456  
    281281                //Vertices
    282282                if (verbose) printf("Reading vertices (%i)\n",nbv);
    283                 vertices=(BamgVertex*)xmalloc(nbv*sizeof(BamgVertex));
    284                 orderedvertices=(BamgVertex**)xmalloc(nbv*sizeof(BamgVertex*));
     283                vertices=xNew<BamgVertex>(nbv);
     284                orderedvertices=xNew<BamgVertex*>(nbv);
    285285                for (i=0;i<nbv;i++){
    286286                        vertices[i].r.x=x[i];
    … …  
    296296                if (verbose) printf("Reading triangles (%i)\n",nbt);
    297297                triangles =new Triangle[maxnbt]; //we cannot allocate only nbt triangles since
    298                 nodeflags=(bool*)xmalloc(nbv*sizeof(bool));
     298                nodeflags=xNew<bool>(nbv);
    299299                for(i=0;i<nbv;i++) nodeflags[i]=false;
    300300                //other triangles will be added for each edge
    … …  
    326326
    327327                /*Clean up*/
    328                 xfree((void**)&nodeflags);
     328                xDelete<bool>(nodeflags);
    329329        }
    330330        /*}}}*/
    … …  
    348348                        if(verbose>5) printf("      processing Vertices\n");
    349349
    350                         vertices=(BamgVertex*)xmalloc(nbv*sizeof(BamgVertex));
    351                         orderedvertices=(BamgVertex**)xmalloc(nbv*sizeof(BamgVertex*));
     350                        vertices=xNew<BamgVertex>(nbv);
     351                        orderedvertices=xNew<BamgVertex*>(nbv);
    352352
    353353                        for (i=0;i<nbv;i++){
    … …  
    553553
    554554                //Memory Allocation
    555                 head_1=(int*)xmalloc(nbv*sizeof(int));
    556                 next_1=(int*)xmalloc(3*nbt*sizeof(int));
    557                 connectivitysize_1=(int*)xmalloc(nbv*sizeof(int));
     555                head_1=xNew<int>(nbv);
     556                next_1=xNew<int>(3*nbt);
     557                connectivitysize_1=xNew<int>(nbv);
    558558
    559559                //Initialization
    … …  
    588588                bamgmesh->VerticesSize[1]=3;
    589589                if (nbv){
    590                         bamgmesh->Vertices=(double*)xmalloc(3*nbv*sizeof(double));
     590                        bamgmesh->Vertices=xNew<double>(3*nbv);
    591591                        for (i=0;i<nbv;i++){
    592592                                bamgmesh->Vertices[i*3+0]=vertices[i].r.x;
    … …  
    602602                int NumIssmSegments=0;
    603603                if (nbe){
    604                         bamgmesh->Edges=(double*)xmalloc(3*nbe*sizeof(double));
     604                        bamgmesh->Edges=xNew<double>(3*nbe);
    605605                        for (i=0;i<nbe;i++){
    606606                                bamgmesh->Edges[i*3+0]=GetId(edges[i][0])+1; //back to M indexing
    … …  
    617617                SetOfEdges4* edge4=new SetOfEdges4(nbt*3,nbv);
    618618                double* elemedge=NULL;
    619                 elemedge=(double*)xmalloc(3*nbt*sizeof(double));
     619                elemedge=xNew<double>(3*nbt);
    620620                for (i=0;i<3*nbt;i++) elemedge[i]=NAN;
    621621                k=0;
    … …  
    642642                bamgmesh->IssmEdgesSize[0]=edge4->nb();
    643643                bamgmesh->IssmEdgesSize[1]=4;
    644                 bamgmesh->IssmEdges=(double*)xmalloc(4*edge4->nb()*sizeof(double));
     644                bamgmesh->IssmEdges=xNew<double>(4*edge4->nb());
    645645                for (i=0;i<edge4->nb();i++){
    646646                        /*Invert first two vertices if necessary*/
    … …  
    667667                //clean up
    668668                delete edge4;
    669                 xfree((void**)&elemedge);
     669                xDelete<double>(elemedge);
    670670
    671671                /*IssmSegments*/
    … …  
    673673                bamgmesh->IssmSegmentsSize[0]=NumIssmSegments;
    674674                bamgmesh->IssmSegmentsSize[1]=4;
    675                 bamgmesh->IssmSegments=(double*)xmalloc(4*NumIssmSegments*sizeof(double));
     675                bamgmesh->IssmSegments=xNew<double>(4*NumIssmSegments);
    676676                num=0;
    677677                for (i=0;i<nbe;i++){
    … …  
    719719                bamgmesh->TrianglesSize[1]=4;
    720720                if (k){
    721                         bamgmesh->Triangles=(double*)xmalloc(4*k*sizeof(double));
     721                        bamgmesh->Triangles=xNew<double>(4*k);
    722722                        for (i=0;i<nbt;i++){
    723723                                Triangle &t=triangles[i];
    … …  
    738738                bamgmesh->QuadrilateralsSize[1]=5;
    739739                if (nbq){
    740                         bamgmesh->Quadrilaterals=(double*)xmalloc(5*nbq*sizeof(double));
     740                        bamgmesh->Quadrilaterals=xNew<double>(5*nbq);
    741741                        for (i=0;i<nbt;i++){
    742742                                Triangle &t =triangles[i];
    … …  
    759759                bamgmesh->SubDomainsSize[1]=4;
    760760                if (nbsubdomains){
    761                         bamgmesh->SubDomains=(double*)xmalloc(4*nbsubdomains*sizeof(double));
     761                        bamgmesh->SubDomains=xNew<double>(4*nbsubdomains);
    762762                        for (i=0;i<nbsubdomains;i++){
    763763                                bamgmesh->SubDomains[i*4+0]=3;
    … …  
    773773                bamgmesh->SubDomainsFromGeomSize[1]=4;
    774774                if (Gh.nbsubdomains){
    775                         bamgmesh->SubDomainsFromGeom=(double*)xmalloc(4*Gh.nbsubdomains*sizeof(double));
     775                        bamgmesh->SubDomainsFromGeom=xNew<double>(4*Gh.nbsubdomains);
    776776                        for (i=0;i<Gh.nbsubdomains;i++){
    777777                                bamgmesh->SubDomainsFromGeom[i*4+0]=2;
    … …  
    787787                bamgmesh->VerticesOnGeomVertexSize[1]=2;
    788788                if (NbVerticesOnGeomVertex){
    789                         bamgmesh->VerticesOnGeomVertex=(double*)xmalloc(2*NbVerticesOnGeomVertex*sizeof(double));
     789                        bamgmesh->VerticesOnGeomVertex=xNew<double>(2*NbVerticesOnGeomVertex);
    790790                        for (i=0;i<NbVerticesOnGeomVertex;i++){
    791791                                VertexOnGeom &v=VerticesOnGeomVertex[i];
    … …  
    801801                bamgmesh->VerticesOnGeomEdgeSize[1]=3;
    802802                if (NbVerticesOnGeomEdge){
    803                         bamgmesh->VerticesOnGeomEdge=(double*)xmalloc(3*NbVerticesOnGeomEdge*sizeof(double));
     803                        bamgmesh->VerticesOnGeomEdge=xNew<double>(3*NbVerticesOnGeomEdge);
    804804                        for (i=0;i<NbVerticesOnGeomEdge;i++){
    805805                                const VertexOnGeom &v=VerticesOnGeomEdge[i];
    … …  
    822822                bamgmesh->EdgesOnGeomEdgeSize[1]=2;
    823823                if (k){
    824                         bamgmesh->EdgesOnGeomEdge=(double*)xmalloc(2*(int)k*sizeof(double));
     824                        bamgmesh->EdgesOnGeomEdge=xNew<double>(2*(int)k);
    825825                        int count=0;
    826826                        for (i=0;i<nbe;i++){
    … …  
    837837                bamgmesh->ElementConnectivitySize[0]=nbt-nbtout;
    838838                bamgmesh->ElementConnectivitySize[1]=3;
    839                 bamgmesh->ElementConnectivity=(double*)xmalloc(3*(nbt-nbtout)*sizeof(double));
     839                bamgmesh->ElementConnectivity=xNew<double>(3*(nbt-nbtout));
    840840                for (i=0;i<3*(nbt-nbtout);i++) bamgmesh->ElementConnectivity[i]=NAN;
    841841                num=0;
    … …  
    857857                bamgmesh->NodalElementConnectivitySize[0]=nbv;
    858858                bamgmesh->NodalElementConnectivitySize[1]=connectivitymax_1;
    859                 bamgmesh->NodalElementConnectivity=(double*)xmalloc(connectivitymax_1*nbv*sizeof(double));
     859                bamgmesh->NodalElementConnectivity=xNew<double>(connectivitymax_1*nbv);
    860860                for (i=0;i<connectivitymax_1*nbv;i++) bamgmesh->NodalElementConnectivity[i]=NAN;
    861861                for (i=0;i<nbv;i++){
    … …  
    877877                i1=bamgmesh->IssmEdgesSize[0];
    878878                i2=bamgmesh->IssmEdgesSize[1];
    879                 head_2=(int*)xmalloc(nbv*sizeof(int));
    880                 next_2=(int*)xmalloc(2*i1*sizeof(int));
    881                 connectivitysize_2=(int*)xmalloc(nbv*sizeof(int));
     879                head_2=xNew<int>(nbv);
     880                next_2=xNew<int>(2*i1);
     881                connectivitysize_2=xNew<int>(nbv);
    882882                //Initialization
    883883                for (i=0;i<nbv;i++) head_2[i]=-1;
    … …  
    902902                bamgmesh->NodalConnectivitySize[0]=nbv;
    903903                bamgmesh->NodalConnectivitySize[1]=connectivitymax_2;
    904                 bamgmesh->NodalConnectivity=(double*)xmalloc(connectivitymax_2*nbv*sizeof(double));
     904                bamgmesh->NodalConnectivity=xNew<double>(connectivitymax_2*nbv);
    905905                for (i=0;i<connectivitymax_2*nbv;i++) bamgmesh->NodalConnectivity[i]=NAN;
    906906                for (i=0;i<nbv;i++){
    … …  
    925925                bamgmesh->CrackedVerticesSize[1]=2;
    926926                if (NbCrackedVertices){
    927                         bamgmesh->CrackedVertices=(double*)xmalloc(2*NbCrackedVertices*sizeof(double));
     927                        bamgmesh->CrackedVertices=xNew<double>(2*NbCrackedVertices);
    928928                        for (i=0;i<NbCrackedVertices;i++){
    929929                                bamgmesh->CrackedVertices[i*2+0]=CrackedVertices[i*2+0]+1; //M indexing
    … …  
    937937                bamgmesh->CrackedEdgesSize[1]=4;
    938938                if (NbCrackedEdges){
    939                         bamgmesh->CrackedEdges=(double*)xmalloc(2*NbCrackedEdges*sizeof(double));
     939                        bamgmesh->CrackedEdges=xNew<double>(2*NbCrackedEdges);
    940940                        for (i=0;i<NbCrackedEdges;i++){
    941941                                bamgmesh->CrackedEdges[i*2+0]=0;//CrackedEdges[i]->+1; //M indexing
    … …  
    945945
    946946                //clean up
    947                 xfree((void**)&connectivitysize_1);
    948                 xfree((void**)&head_1);
    949                 xfree((void**)&next_1);
    950                 xfree((void**)&connectivitysize_2);
    951                 xfree((void**)&head_2);
    952                 xfree((void**)&next_2);
     947                xDelete<int>(connectivitysize_1);
     948                xDelete<int>(head_1);
     949                xDelete<int>(next_1);
     950                xDelete<int>(connectivitysize_2);
     951                xDelete<int>(head_2);
     952                xDelete<int>(next_2);
    953953                delete [] reft;
    954954                delete [] numt;
    … …  
    996996        void Mesh::WriteMetric(BamgOpts* bamgopts) {
    997997                int i;
    998                 xfree((void**)&bamgopts->metric);
    999                 bamgopts->metric=(double*)xmalloc(3*nbv*sizeof(double));
     998                xDelete<double>(bamgopts->metric);
     999                bamgopts->metric=xNew<double>(3*nbv);
    10001000                for (i=0;i<nbv;i++){
    10011001                        bamgopts->metric[i*3+0]=vertices[i].m.a11;
    … …  
    10231023
    10241024                if (k){
    1025                         index=(int*)xmalloc(3*k*sizeof(double));
     1025                        index=xNew<int>(3*k);
    10261026                        num=0;
    10271027                        for (i=0;i<nbt;i++){
    … …  
    17951795                //first, build the chains that will be used for the Hessian computation, as weel as the area of each element
    17961796                int* head_s=NULL;
    1797                 head_s=(int*)xmalloc(nbv*sizeof(int));
     1797                head_s=xNew<int>(nbv);
    17981798                int* next_p=NULL;
    1799                 next_p=(int*)xmalloc(3*nbt*sizeof(int));
     1799                next_p=xNew<int>(3*nbt);
    18001800                int  p=0;
    18011801                //initialization
    … …  
    19361936
    19371937                //clean up
    1938                 xfree((void**)&head_s);
    1939                 xfree((void**)&next_p);
     1938                xDelete<int>(head_s);
     1939                xDelete<int>(next_p);
    19401940                delete [] detT;
    19411941                delete [] alpha;
    … …  
    23072307                if (verbose>4) printf("      number of Cracked Vertices = %i\n",NbCrackedVertices);
    23082308                if (NbCrackedVertices){
    2309                         CrackedVertices=(long*)xmalloc(2*NbCrackedVertices*sizeof(double));
     2309                        CrackedVertices=xNew<long>(2*NbCrackedVertices);
    23102310                        num=0;
    23112311                        for (i=0;i<nbv;i++){

  • issm/trunk-jpl/src/c/objects/Constraints/SpcTransient.cpp

    r12365 r12456  
    3838        nsteps=spc_nsteps;
    3939        if(spc_nsteps){
    40                 values=(double*)xmalloc(spc_nsteps*sizeof(double));
    41                 times=(double*)xmalloc(spc_nsteps*sizeof(double));
     40                values=xNew<double>(spc_nsteps);
     41                times=xNew<double>(spc_nsteps);
    4242                memcpy(values,spc_values,nsteps*sizeof(double));
    4343                memcpy(times,spc_times,nsteps*sizeof(double));
    … …  
    4949/*FUNCTION SpcTransient::~SpcTransient{{{*/
    5050SpcTransient::~SpcTransient(){
    51         xfree((void**)&times);
    52         xfree((void**)&values);
     51        xDelete<double>(times);
     52        xDelete<double>(values);
    5353        return;
    5454}

  • issm/trunk-jpl/src/c/objects/ExternalResults/BoolExternalResult.cpp

    r12365 r12456  
    102102        fwrite(&length,sizeof(int),1,fid);
    103103        fwrite(name,length,1,fid);
    104         xfree((void**)&name);
     104        xDelete<char>(name);
    105105
    106106        /*Now write time and step: */

  • issm/trunk-jpl/src/c/objects/ExternalResults/DoubleExternalResult.cpp

    r12365 r12456  
    101101        fwrite(&length,sizeof(int),1,fid);
    102102        fwrite(name,length,1,fid);
    103         xfree((void**)&name);
     103        xDelete<char>(name);
    104104
    105105        /*Now write time and step: */

  • issm/trunk-jpl/src/c/objects/ExternalResults/DoubleMatExternalResult.cpp

    r12365 r12456  
    3636        /*Copy result in values*/
    3737        if(M*N){
    38                 values=(double*)xmalloc(M*N*sizeof(double));
     38                values=xNew<double>(M*N);
    3939                memcpy(values,in_values,M*N*sizeof(double));
    4040        }
    … …  
    4848DoubleMatExternalResult::~DoubleMatExternalResult(){
    4949
    50         xfree((void**)&this->values);
     50        xDelete<double>(this->values);
    5151        return;
    5252}
    … …  
    131131        fwrite(&length,sizeof(int),1,fid);
    132132        fwrite(name,length,1,fid);
    133         xfree((void**)&name);
     133        xDelete<char>(name);
    134134
    135135        /*Now write time and step: */

  • issm/trunk-jpl/src/c/objects/ExternalResults/DoubleVecExternalResult.cpp

    r12365 r12456  
    3434
    3535        if(M){
    36                 values=(double*)xmalloc(M*sizeof(double));
     36                values=xNew<double>(M);
    3737                memcpy(values,in_values,M*sizeof(double));
    3838        }
    … …  
    4545/*FUNCTION DoubleVecExternalResult::~DoubleVecExternalResult(){{{*/
    4646DoubleVecExternalResult::~DoubleVecExternalResult(){
    47         xfree((void**)&values);
     47        xDelete<double>(values);
    4848        return;
    4949}
    … …  
    120120        fwrite(&length,sizeof(int),1,fid);
    121121        fwrite(name,length,1,fid);
    122         xfree((void**)&name);
     122        xDelete<char>(name);
    123123
    124124        /*Now write time and step: */

  • issm/trunk-jpl/src/c/objects/ExternalResults/IntExternalResult.cpp

    r12365 r12456  
    102102        fwrite(&length,sizeof(int),1,fid);
    103103        fwrite(name,length,1,fid);
    104         xfree((void**)&name);
     104        xDelete<char>(name);
    105105
    106106        /*Now write time and step: */

  • issm/trunk-jpl/src/c/objects/ExternalResults/PetscVecExternalResult.cpp

    r12365 r12456  
    118118        fwrite(&length,sizeof(int),1,fid);
    119119        fwrite(name,length,1,fid);
    120         xfree((void**)&name);
     120        xDelete<char>(name);
    121121
    122122        /*Now write time and step: */
    … …  
    132132
    133133        /*Free ressources:*/
    134         xfree((void**)&serialvec);
     134        xDelete<char>(serialvec);
    135135}
    136136/*}}}*/

  • issm/trunk-jpl/src/c/objects/ExternalResults/StringExternalResult.cpp

    r12365 r12456  
    3131        id=in_id;
    3232        enum_type=in_enum_type;
    33         value=(char*)xmalloc((strlen(in_value)+1)*sizeof(char));
     33        value=xNew<char>(strlen(in_value)+1);
    3434        memcpy(value,in_value,(strlen(in_value)+1)*sizeof(char));
    3535
    … …  
    4141/*FUNCTION StringExternalResult::~StringExternalResult(){{{*/
    4242StringExternalResult::~StringExternalResult(){
    43         xfree((void**)&value);
     43        xDelete<char>(value);
    4444}
    4545/*}}}*/
    … …  
    103103        fwrite(&length,sizeof(int),1,fid);
    104104        fwrite(name,length,1,fid);
    105         xfree((void**)&name);
     105        xDelete<char>(name);
    106106
    107107        /*Now write time and step: */
Note: See TracChangeset for help on using the changeset viewer.