Changeset 12442


Ignore:
Timestamp:
06/18/12 09:56:03 (13 years ago)
Author:
Mathieu Morlighem
Message:

changing xmalloc to xNew and xfree to xDelete

Location:
issm/trunk-jpl/src/c
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/modules/Exp2Kmlx/Exp2Kmlx.cpp

    r12098 r12442  
    1111#include "../modules.h"
    1212
    13 int Exp2Kmlx(char* filexp,char* filkml,
    14                          int sgn,
    15                          bool holes){
     13int Exp2Kmlx(char* filexp,char* filkml,int sgn,bool holes){
    1614
    1715        double  cm,sp;
    1816
    1917        Xy2lldef(&cm,&sp,sgn);
    20 
    21         return(Exp2Kmlx(filexp,filkml,
    22                                         sgn,cm,sp,
    23                                         holes));
     18        return(Exp2Kmlx(filexp,filkml,sgn,cm,sp,holes));
    2419}
    2520
    26 int Exp2Kmlx(char* filexp,char* filkml,
    27                          int sgn,double cm,double sp,
    28                          bool holes){
    29 
    30         int     i,j,iret=0;
    31         int     lwidth=1;
    32         double  popac=0.50;
    33         int     nprof;
    34         int     *pnvert=NULL;
    35         double  **pprofx=NULL,**pprofy=NULL;
    36         bool    *closed=NULL;
    37         double  *lat=NULL,*lon=NULL;
     21int Exp2Kmlx(char* filexp,char* filkml,int sgn,double cm,double sp,bool holes){
     22
     23        int      i        ,j,iret=0;
     24        int      lwidth = 1;
     25        double   popac  = 0.50;
     26        int      nprof;
     27        int     *pnvert = NULL;
     28        double **pprofx = NULL,**pprofy=NULL;
     29        bool    *closed = NULL;
     30        double  *lat    = NULL, *lon=NULL;
    3831
    3932        char    indent[81]="";
    … …  
    5952        _printf_(true,"\nExp2Kmlx Module -- %s",ctime(&time0));
    6053
    61 /*  read exp file  */
     54        /*read exp file  */
    6255
    6356        if (!DomainOutlineRead(&nprof,&pnvert,&pprofx,&pprofy,&closed,filexp))
    … …  
    143136
    144137                kring->ncoord    =pnvert[i]-1;
    145                 lat=(double *) xmalloc(kring->ncoord*sizeof(double));
    146                 lon=(double *) xmalloc(kring->ncoord*sizeof(double));
     138                lat=xNew<double>(kring->ncoord);
     139                lon=xNew<double>(kring->ncoord);
    147140                Xy2llx(lat,lon,pprofx[i],pprofy[i],kring->ncoord,sgn,cm,sp);
    148                 kring->coords    =(double (*)[3]) xmalloc(kring->ncoord*3*sizeof(double));
     141                kring->coords=xNew<double>(kring->ncoord*3);
    149142                for (j=0; j<kring->ncoord; j++) {
    150                         kring->coords[j][0]=lon[j];
    151                         kring->coords[j][1]=lat[j];
    152                         kring->coords[j][2]=0.;
     143                        kring->coords[3*j+0]=lon[j];
     144                        kring->coords[3*j+1]=lat[j];
     145                        kring->coords[3*j+2]=0.;
    153146                }
    154                 xfree((void**)&lon);
    155                 xfree((void**)&lat);
     147                xDelete<double>(lon);
     148                xDelete<double>(lat);
    156149
    157150                (kpoly ->outer     )->AddObject((Object*)kring);
    … …  
    167160
    168161                        kring->ncoord    =pnvert[i]-1;
    169                         lat=(double *) xmalloc(kring->ncoord*sizeof(double));
    170                         lon=(double *) xmalloc(kring->ncoord*sizeof(double));
     162                        lat=xNew<double>(kring->ncoord);
     163                        lon=xNew<double>(kring->ncoord);
    171164                        Xy2llx(lat,lon,pprofx[i],pprofy[i],kring->ncoord,sgn,cm,sp);
    172                         kring->coords    =(double (*)[3]) xmalloc(kring->ncoord*3*sizeof(double));
     165                        kring->coords    =xNew<double>(kring->ncoord*3);
    173166                        for (j=0; j<kring->ncoord; j++) {
    174                                 kring->coords[j][0]=lon[j];
    175                                 kring->coords[j][1]=lat[j];
    176                                 kring->coords[j][2]=0.;
    177                         }
    178                         xfree((void**)&lon);
    179                         xfree((void**)&lat);
     167                                kring->coords[3*j+0]=lon[j];
     168                                kring->coords[3*j+1]=lat[j];
     169                                kring->coords[3*j+2]=0.;
     170                        }
     171                        xDelete<double>(lon);
     172                        xDelete<double>(lat);
    180173
    181174                        (kpoly ->inner     )->AddObject((Object*)kring);
    … …  
    204197
    205198                                kring->ncoord    =pnvert[i]-1;
    206                                 lat=(double *) xmalloc(kring->ncoord*sizeof(double));
    207                                 lon=(double *) xmalloc(kring->ncoord*sizeof(double));
     199                                lat=xNew<double>(kring->ncoord);
     200                                lon=xNew<double>(kring->ncoord);
    208201                                Xy2llx(lat,lon,pprofx[i],pprofy[i],kring->ncoord,sgn,cm,sp);
    209                                 kring->coords    =(double (*)[3]) xmalloc(kring->ncoord*3*sizeof(double));
     202                                kring->coords    =xNew<double>(kring->ncoord*3);
    210203                                for (j=0; j<kring->ncoord; j++) {
    211                                         kring->coords[j][0]=lon[j];
    212                                         kring->coords[j][1]=lat[j];
    213                                         kring->coords[j][2]=0.;
     204                                        kring->coords[3*j+0]=lon[j];
     205                                        kring->coords[3*j+1]=lat[j];
     206                                        kring->coords[3*j+2]=0.;
    214207                                }
    215                                 xfree((void**)&lon);
    216                                 xfree((void**)&lat);
     208                                xDelete<double>(lon);
     209                                xDelete<double>(lat);
    217210
    218211                                (kpoly ->outer     )->AddObject((Object*)kring);
    … …  
    231224
    232225                                kline->ncoord    =pnvert[i];
    233                                 lat=(double *) xmalloc(kline->ncoord*sizeof(double));
    234                                 lon=(double *) xmalloc(kline->ncoord*sizeof(double));
     226                                lat=xNew<double>(kline->ncoord);
     227                                lon=xNew<double>(kline->ncoord);
    235228                                Xy2llx(lat,lon,pprofx[i],pprofy[i],kline->ncoord,sgn,cm,sp);
    236                                 kline->coords    =(double (*)[3]) xmalloc(kline->ncoord*3*sizeof(double));
     229                                kline->coords    =xNew<double>(kline->ncoord*3);
    237230                                for (j=0; j<kline->ncoord; j++) {
    238                                         kline->coords[j][0]=lon[j];
    239                                         kline->coords[j][1]=lat[j];
    240                                         kline->coords[j][2]=0.;
     231                                        kline->coords[3*j+0]=lon[j];
     232                                        kline->coords[3*j+1]=lat[j];
     233                                        kline->coords[3*j+2]=0.;
    241234                                }
    242                                 xfree((void**)&lon);
    243                                 xfree((void**)&lat);
     235                                xDelete<double>(lon);
     236                                xDelete<double>(lat);
    244237
    245238                                (kplace->geometry  )->AddObject((Object*)kline);
    … …  
    251244                                kplace->visibility=true;
    252245                                sprintf(kplace->styleurl  ,"#RandomLineEmptyPoly");
     246                                int one=1;
    253247
    254248                                kpoint=new KML_Point();
    255249
    256                                 lat=(double *) xmalloc(sizeof(double));
    257                                 lon=(double *) xmalloc(sizeof(double));
     250                                lat=xNew<double>(one);
     251                                lon=xNew<double>(one);
    258252                                Xy2llx(lat,lon,pprofx[i],pprofy[i],1,sgn,cm,sp);
    259253                                kpoint->coords[0]=lon[0];
    260254                                kpoint->coords[1]=lat[0];
    261255                                kpoint->coords[2]=0.;
    262                                 xfree((void**)&lon);
    263                                 xfree((void**)&lat);
     256                                xDelete<double>(lon);
     257                                xDelete<double>(lat);
    264258
    265259                                (kplace->geometry  )->AddObject((Object*)kpoint);
    … …  
    289283        delete kfile;
    290284        for (i=nprof-1; i>=0; i--) {
    291                 xfree((void**)&(pprofy[i]));
    292                 xfree((void**)&(pprofx[i]));
    293         }
    294         xfree((void**)&pnvert);
     285                xDelete<double>(pprofy[i]);
     286                xDelete<double>(pprofx[i]);
     287        }
     288        xDelete<int>(pnvert);
    295289
    296290        clock1=clock();

  • issm/trunk-jpl/src/c/modules/InterpFromMesh2dx/InterpFromMesh2dx.cpp

    r11695 r12442  
    8484        }
    8585        else{
    86                  incontour=(double*)xmalloc(nods_prime*sizeof(double));
    87                  for (i=0;i<nods_prime;i++) incontour[i]=1;
     86                 incontour=xNew<double>(nods_prime);
     87                 for (i=0;i<nods_prime;i++) incontour[i]=1.0;
    8888        }
    8989
    … …  
    112112
    113113        /*Assign output pointers:*/
    114          xfree((void**)&incontour);
     114         xDelete<double>(incontour);
    115115        *pdata_prime=data_prime;
    116116}

  • issm/trunk-jpl/src/c/modules/IoModelToConstraintsx/IoModelToConstraintsx.cpp

    r9725 r12442  
    6969
    7070                /*figure out times: */
    71                 times=(double*)xmalloc(N*sizeof(double));
     71                times=xNew<double>(N);
    7272                for(j=0;j<N;j++){
    7373                        times[j]=doublevector[(M-1)*N+j];
    … …  
    8383
    8484                                /*figure out times and values: */
    85                                 values=(double*)xmalloc(N*sizeof(double));
     85                                values=xNew<double>(N);
    8686                                spcpresent=false;
    8787                                for(j=0;j<N;j++){
    … …  
    9494                                        count++;
    9595                                }
    96                                 xfree((void**)&values);
     96                                xDelete<double>(values);
    9797                        }
    9898                }
    … …  
    103103
    104104        /*Free ressources:*/
    105         xfree((void**)&doublevector);
    106         xfree((void**)&times);
    107         xfree((void**)&values);
     105        xDelete<double>(doublevector);
     106        xDelete<double>(times);
     107        xDelete<double>(values);
    108108}

  • issm/trunk-jpl/src/c/modules/KMLMeshWritex/KMLMeshWritex.cpp

    r9761 r12442  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void KMLMeshWritex(int* ierror,
    12                                    char* name,
    13                                    char* notes,
    14                                    int* elem,int melem,int nelem,
    15                                    int* nodecon,int mncon,int nncon,
    16                                    double* lat, double* lng,
    17                                    int* part,
    18                                    double* data, int mdata, int ndata,
    19                                    double* cmap, int mcmap, int ncmap,
    20                                    FILE* fid){
    21 
    22         int     i,j,k,ipt=0,jpt=0,nnodes;
    23         int     mxepg=25;
    24         int     lwidth=1;
    25         double  popac=0.50;
    26         char    indent[81]="  ";
    27         char    cstr[81];
    28         double* edata=NULL;
    29         bool    ncfree=false,
    30                         edfree=false;
    31         KML_Document*  kdoc=NULL;
    32         KML_Style*     kstyle;
    33         KML_LineStyle* klsty;
    34         KML_PolyStyle* kpsty;
     11void KMLMeshWritex(int* ierror,char* name,char* notes,int* elem,int melem,int nelem,int* nodecon,int mncon,int nncon,double* lat, double* lng,int* part,double* data, int mdata, int ndata,double* cmap, int mcmap, int ncmap,FILE* fid){
     12
     13        int                 i,j,k,ipt=0,jpt=0,nnodes;
     14        int                 mxepg      = 25;
     15        int                 lwidth     = 1;
     16        double              popac      = 0.50;
     17        char                indent[81] = " ";
     18        char                cstr[81];
     19        double             *edata = NULL;
     20        bool ncfree=false, edfree=false;
     21        KML_Document       *kdoc = NULL;
     22        KML_Style          *kstyle;
     23        KML_LineStyle      *klsty;
     24        KML_PolyStyle      *kpsty;
    3525
    3626        clock_t clock0,clock1,clock0a,clock0b,clock0c;
    … …  
    130120                _printf_(true,"Creating the node connectivity table.\n");
    131121                nncon=mxepg+1;
    132                 nodecon=(int *) xcalloc(mncon*nncon,sizeof(int));
     122                nodecon=xNewInit<int>(mncon*nncon,0);
    133123                ncfree=true;
    134124
    … …  
    160150                else if (mdata == mncon) {
    161151                        _printf_(true,"Averaging nodal data to element data.\n");
    162                         edata=(double *) xcalloc(melem*ndata,sizeof(double));
     152                        edata=xNewInit<double>(melem*ndata,0);
    163153                        edfree=true;
    164154
    … …  
    194184                                                                                                                cmap,mcmap,ncmap));
    195185
    196         if (edfree) xfree((void**)&edata);
    197         if (ncfree) xfree((void**)&nodecon);
     186        if(edfree) xfree((void**)&edata);
     187        if(ncfree) xfree((void**)&nodecon);
    198188        clock0a=clock();
    199189        time0a =time(NULL);
    … …  
    344334                kring=new KML_LinearRing();
    345335                kring->ncoord    =nelem+1;
    346                 kring->coords    =(double (*)[3]) xmalloc((nelem+1)*3*sizeof(double));
     336                kring->coords =xNew<double>((nelem+1)*3);
    347337
    348338/*  write the nodal coordinates as a linear ring  */
    349339
    350340                for (j=0; j<nelem; j++) {
    351                         kring->coords[j][0]=lng[elem[ipt]-1];
    352                         kring->coords[j][1]=lat[elem[ipt]-1];
    353                         kring->coords[j][2]=alt;
     341                        kring->coords[3*j+0]=lng[elem[ipt]-1];
     342                        kring->coords[3*j+1]=lat[elem[ipt]-1];
     343                        kring->coords[3*j+2]=alt;
    354344                        ipt++;
    355345                }
    356                 kring->coords[nelem][0]=kring->coords[0][0];
    357                 kring->coords[nelem][1]=kring->coords[0][1];
    358                 kring->coords[nelem][2]=kring->coords[0][2];
     346                kring->coords[3*nelem+0]=kring->coords[3*0+0];
     347                kring->coords[3*nelem+1]=kring->coords[3*0+1];
     348                kring->coords[3*nelem+2]=kring->coords[3*0+2];
    359349//              kring->DeepEcho();
    360350
    361351/*  assemble the linear ring into polygon into placemark into folder  */
    362352
    363                 (kpoly ->outer     )->AddObject((Object*)kring);
    364                 (kplace->geometry  )->AddObject((Object*)kpoly);
    365                 (kfold ->feature   )->AddObject((Object*)kplace);
     353                (kpoly ->outer   )->AddObject((Object*)kring);
     354                (kplace->geometry)->AddObject((Object*)kpoly);
     355                (kfold ->feature )->AddObject((Object*)kplace);
    366356
    367357//              if (!(int)fmod((double)(i+1),1000))

  • issm/trunk-jpl/src/c/modules/Krigingx/pKrigingx.cpp

    r12422 r12442  
    3737
    3838        /*Allocate output*/
    39         predictions =(double*)xcalloc(n_interp,sizeof(double));
    40         error       =(double*)xcalloc(n_interp,sizeof(double));
     39        predictions =xNewInit<double>(n_interp,0.0);
     40        error       =xNewInit<double>(n_interp,0.0);
    4141
    4242        /*Get output*/
    … …  
    6262
    6363#ifdef _HAVE_MPI_
    64                 double *sumpredictions =(double*)xmalloc(n_interp*sizeof(double));
    65                 double *sumerror       =(double*)xmalloc(n_interp*sizeof(double));
     64                double *sumpredictions =xNew<double>(n_interp);
     65                double *sumerror       =xNew<double>(n_interp);
    6666                MPI_Allreduce(predictions,sumpredictions,n_interp,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
    6767                MPI_Allreduce(error,sumerror,n_interp,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
    68                 xfree((void**)&error); error=sumerror;
    69                 xfree((void**)&predictions); predictions=sumpredictions;
     68                xDelete<double>(error); error=sumerror;
     69                xDelete<double>(predictions); predictions=sumpredictions;
    7070#endif
    7171        }
    … …  
    8080
    8181#ifdef _HAVE_MPI_
    82                 double *sumpredictions =(double*)xmalloc(n_interp*sizeof(double));
     82                double *sumpredictions =xNew<double>(n_interp);
    8383                MPI_Allreduce(predictions,sumpredictions,n_interp,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
    84                 xfree((void**)&predictions); predictions=sumpredictions;
     84                xDelete<double>(predictions); predictions=sumpredictions;
    8585#endif
    8686        }
    … …  
    9797
    9898#ifdef _HAVE_MPI_
    99                 double *sumpredictions =(double*)xmalloc(n_interp*sizeof(double));
     99                double *sumpredictions =xNew<double>(n_interp);
    100100                MPI_Allreduce(predictions,sumpredictions,n_interp,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
    101                 xfree((void**)&predictions); predictions=sumpredictions;
     101                xDelete<double>(predictions); predictions=sumpredictions;
    102102#endif
    103103        }
    … …  
    109109        delete variogram;
    110110        delete observations;
    111         xfree((void**)&output);
     111        xDelete<char>(output);
    112112        *ppredictions = predictions;
    113113        *perror       = error;
    … …  
    131131
    132132        /*Assign output pointer*/
    133         xfree((void**)&model);
     133        xDelete<char>(model);
    134134        *pvariogram = variogram;
    135135}/*}}}*/

  • issm/trunk-jpl/src/c/modules/Shp2Kmlx/Shp2Kmlx.cpp

    r11401 r12442  
    3939        int     nshape,ncoord;
    4040        double  cpsum;
    41         int     *pstype=NULL,*pnpart=NULL,**ppstrt=NULL,**pptype=NULL,*pnvert=NULL;
    42         double  **pshapx=NULL,**pshapy=NULL,**pshapz=NULL,**pshapm=NULL;
    43         double  *lat=NULL,*lon=NULL;
     41        int     *pstype = NULL, *pnpart=NULL,**ppstrt=NULL,**pptype=NULL,*pnvert=NULL;
     42        double **pshapx = NULL,**pshapy=NULL,**pshapz=NULL,**pshapm=NULL;
     43        double  *lat    = NULL, *lon=NULL;
    4444
    4545        SHPHandle   hSHP;
    … …  
    4949
    5050        char    indent[81]="";
    51         KML_File*             kfile =NULL;
    52         KML_Document*         kdoc  =NULL;
    53         KML_Style*            kstyle=NULL;
    54         KML_LineStyle*        klsty =NULL;
    55         KML_PolyStyle*        kpsty =NULL;
    56         KML_Folder*           kfold =NULL;
    57         KML_Placemark*        kplace=NULL;
    58         KML_MultiGeometry*    kmulti=NULL;
    59         KML_Polygon*          kpoly =NULL;
    60         KML_LinearRing*       kring =NULL;
    61         KML_LineString*       kline =NULL;
    62         KML_Point*            kpoint=NULL;
    63 
    64         FILE*   fid=NULL;
     51        KML_File          *kfile  = NULL;
     52        KML_Document      *kdoc   = NULL;
     53        KML_Style         *kstyle = NULL;
     54        KML_LineStyle     *klsty  = NULL;
     55        KML_PolyStyle     *kpsty  = NULL;
     56        KML_Folder        *kfold  = NULL;
     57        KML_Placemark     *kplace = NULL;
     58        KML_MultiGeometry *kmulti = NULL;
     59        KML_Polygon       *kpoly  = NULL;
     60        KML_LinearRing    *kring  = NULL;
     61        KML_LineString    *kline  = NULL;
     62        KML_Point         *kpoint = NULL;
     63        FILE              *fid    = NULL;
    6564
    6665        clock_t clock0,clock1;
    … …  
    9796
    9897        nshape=nEntities;
    99         pstype=(int *) xmalloc(nshape*sizeof(int));
    100         pnpart=(int *) xmalloc(nshape*sizeof(int));
    101         ppstrt=(int **) xmalloc(nshape*sizeof(int *));
    102         pptype=(int **) xmalloc(nshape*sizeof(int *));
    103         pnvert=(int *) xmalloc(nshape*sizeof(int));
    104         pshapx=(double **) xmalloc(nshape*sizeof(double *));
    105         pshapy=(double **) xmalloc(nshape*sizeof(double *));
    106         pshapz=(double **) xmalloc(nshape*sizeof(double *));
    107         pshapm=(double **) xmalloc(nshape*sizeof(double *));
     98        pstype=xNew<int>(nshape);
     99        pnpart=xNew<int>(nshape);
     100        ppstrt=xNew<int*>(nshape);
     101        pptype=xNew<int*>(nshape);
     102        pnvert=xNew<int>(nshape);
     103        pshapx=xNew<double*>(nshape);
     104        pshapy=xNew<double*>(nshape);
     105        pshapz=xNew<double*>(nshape);
     106        pshapm=xNew<double*>(nshape);
    108107
    109108/*  loop over the list of shapes  */
    … …  
    129128        pnpart[i]=psShape->nParts;
    130129        if (pnpart[i]) {
    131                 ppstrt[i]=(int *) xmalloc(pnpart[i]*sizeof(int));
    132                 pptype[i]=(int *) xmalloc(pnpart[i]*sizeof(int));
     130                ppstrt[i]=xNew<int>(pnpart[i]);
     131                pptype[i]=xNew<int>(pnpart[i]);
    133132        }
    134133        else {
    … …  
    138137        pnvert[i]=psShape->nVertices;
    139138        if (pnvert[i]) {
    140                 pshapx[i]=(double *) xmalloc(pnvert[i]*sizeof(double));
    141                 pshapy[i]=(double *) xmalloc(pnvert[i]*sizeof(double));
    142                 pshapz[i]=(double *) xmalloc(pnvert[i]*sizeof(double));
    143                 pshapm[i]=(double *) xmalloc(pnvert[i]*sizeof(double));
     139                pshapx[i]=xNew<double>(pnvert[i]);
     140                pshapy[i]=xNew<double>(pnvert[i]);
     141                pshapz[i]=xNew<double>(pnvert[i]);
     142                pshapm[i]=xNew<double>(pnvert[i]);
    144143        }
    145144        else {
    … …  
    296295                        kpoint=new KML_Point();
    297296
    298                         lat=(double *) xmalloc(pnvert[i]*sizeof(double));
    299                         lon=(double *) xmalloc(pnvert[i]*sizeof(double));
     297                        lat=xNew<double>(pnvert[i]);
     298                        lon=xNew<double>(pnvert[i]);
    300299                        if (sgn) {
    301300                                Xy2llx(lat,lon,pshapx[i],pshapy[i],pnvert[i],sgn,cm,sp);
    … …  
    310309                        kpoint->coords[2]=pshapz[i][0];
    311310
    312                         xfree((void**)&lon);
    313                         xfree((void**)&lat);
     311                        xDelete<double>(lon);
     312                        xDelete<double>(lat);
    314313
    315314                        (kplace->geometry  )->AddObject((Object*)kpoint);
    … …  
    337336/*  convert to lat/lon, if necessary  */
    338337
    339                         lat=(double *) xmalloc(pnvert[i]*sizeof(double));
    340                         lon=(double *) xmalloc(pnvert[i]*sizeof(double));
     338                        lat=xNew<double>(pnvert[i]);
     339                        lon=xNew<double>(pnvert[i]);
    341340                        if (sgn) {
    342341                                Xy2llx(lat,lon,pshapx[i],pshapy[i],pnvert[i],sgn,cm,sp);
    … …  
    353352
    354353                                kline->ncoord    =(j<pnpart[i]-1 ? ppstrt[i][j+1]-ppstrt[i][j] : pnvert[i]-ppstrt[i][j]);
    355                                 kline->coords    =(double (*)[3]) xmalloc(kline->ncoord*3*sizeof(double));
     354                                kline->coords    =xNew<double>(kline->ncoord*3);
    356355                                for (k=0; k<kline->ncoord; k++) {
    357                                         kline->coords[k][0]=lon      [ppstrt[i][j]+k];
    358                                         kline->coords[k][1]=lat      [ppstrt[i][j]+k];
    359                                         kline->coords[k][2]=pshapz[i][ppstrt[i][j]+k];
     356                                        kline->coords[3*k+0]=lon      [ppstrt[i][j]+k];
     357                                        kline->coords[3*k+1]=lat      [ppstrt[i][j]+k];
     358                                        kline->coords[3*k+2]=pshapz[i][ppstrt[i][j]+k];
    360359                                }
    361 
    362360                                (kmulti->geometry  )->AddObject((Object*)kline);
    363                                 kline =NULL;
    364                         }
    365 
    366                         xfree((void**)&lon);
    367                         xfree((void**)&lat);
    368 
    369                         (kplace->geometry  )->AddObject((Object*)kmulti);
     361                                kline = NULL;
     362                        }
     363
     364                        xDelete<double>(lon);
     365                        xDelete<double>(lat);
     366
     367                        (kplace->geometry)->AddObject((Object*)kmulti);
    370368                        kmulti=NULL;
    371                         (kfold ->feature   )->AddObject((Object*)kplace);
     369                        (kfold ->feature )->AddObject((Object*)kplace);
    372370                        kplace=NULL;
    373371                }
    … …  
    401399/*  convert to lat/lon, if necessary  */
    402400
    403                         lat=(double *) xmalloc(pnvert[i]*sizeof(double));
    404                         lon=(double *) xmalloc(pnvert[i]*sizeof(double));
     401                        lat=xNew<double>(pnvert[i]);
     402                        lon=xNew<double>(pnvert[i]);
    405403                        if (sgn) {
    406404                                Xy2llx(lat,lon,pshapx[i],pshapy[i],pnvert[i],sgn,cm,sp);
    … …  
    438436
    439437                                        kring->ncoord    =(j<pnpart[i]-1 ? ppstrt[i][j+1]-ppstrt[i][j] : pnvert[i]-ppstrt[i][j]);
    440                                         kring->coords    =(double (*)[3]) xmalloc(kring->ncoord*3*sizeof(double));
     438                                        kring->coords    =xNew<double>(kring->ncoord*3);
    441439                                        if (cpsum < 0)
    442440                                                for (k=0; k<kring->ncoord; k++) {
    443                                                         kring->coords[kring->ncoord-1-k][0]=lon      [ppstrt[i][j]+k];
    444                                                         kring->coords[kring->ncoord-1-k][1]=lat      [ppstrt[i][j]+k];
    445                                                         kring->coords[kring->ncoord-1-k][2]=pshapz[i][ppstrt[i][j]+k];
     441                                                        kring->coords[3*(kring->ncoord-1-k)+0]=lon      [ppstrt[i][j]+k];
     442                                                        kring->coords[3*(kring->ncoord-1-k)+1]=lat      [ppstrt[i][j]+k];
     443                                                        kring->coords[3*(kring->ncoord-1-k)+2]=pshapz[i][ppstrt[i][j]+k];
    446444                                                }
    447445                                        else
    448446                                                for (k=0; k<kring->ncoord; k++) {
    449                                                         kring->coords[k                ][0]=lon      [ppstrt[i][j]+k];
    450                                                         kring->coords[k                ][1]=lat      [ppstrt[i][j]+k];
    451                                                         kring->coords[k                ][2]=pshapz[i][ppstrt[i][j]+k];
     447                                                        kring->coords[3*k+0]=lon      [ppstrt[i][j]+k];
     448                                                        kring->coords[3*k+1]=lat      [ppstrt[i][j]+k];
     449                                                        kring->coords[3*k+2]=pshapz[i][ppstrt[i][j]+k];
    452450                                                }
    453451
    … …  
    470468
    471469                                        kring->ncoord    =(j<pnpart[i]-1 ? ppstrt[i][j+1]-ppstrt[i][j] : pnvert[i]-ppstrt[i][j]);
    472                                         kring->coords    =(double (*)[3]) xmalloc(kring->ncoord*3*sizeof(double));
     470                                        kring->coords    =xNew<double>(kring->ncoord*3);
    473471                                        for (k=0; k<kring->ncoord; k++) {
    474                                                 kring->coords[k][0]=lon      [ppstrt[i][j]+k];
    475                                                 kring->coords[k][1]=lat      [ppstrt[i][j]+k];
    476                                                 kring->coords[k][2]=pshapz[i][ppstrt[i][j]+k];
     472                                                kring->coords[3*k+0]=lon      [ppstrt[i][j]+k];
     473                                                kring->coords[3*k+1]=lat      [ppstrt[i][j]+k];
     474                                                kring->coords[3*k+2]=pshapz[i][ppstrt[i][j]+k];
    477475                                        }
    478476
    … …  
    487485                        }
    488486
    489                         xfree((void**)&lon);
    490                         xfree((void**)&lat);
     487                        xDelete<double>(lon);
     488                        xDelete<double>(lat);
    491489
    492490                        (kplace->geometry  )->AddObject((Object*)kmulti);
    … …  
    518516/*  convert to lat/lon, if necessary  */
    519517
    520                         lat=(double *) xmalloc(pnvert[i]*sizeof(double));
    521                         lon=(double *) xmalloc(pnvert[i]*sizeof(double));
     518                        lat=xNew<double>(pnvert[i]);
     519                        lon=xNew<double>(pnvert[i]);
    522520                        if (sgn) {
    523521                                Xy2llx(lat,lon,pshapx[i],pshapy[i],pnvert[i],sgn,cm,sp);
    … …  
    541539                        }
    542540
    543                         xfree((void**)&lon);
    544                         xfree((void**)&lat);
     541                        xDelete<double>(lon);
     542                        xDelete<double>(lat);
    545543
    546544                        (kplace->geometry  )->AddObject((Object*)kmulti);
    … …  
    583581        delete kfile;
    584582        for (i=nshape-1; i>=0; i--) {
    585                 xfree((void**)&(pshapm[i]));
    586                 xfree((void**)&(pshapz[i]));
    587                 xfree((void**)&(pshapy[i]));
    588                 xfree((void**)&(pshapx[i]));
    589         }
    590         xfree((void**)&pshapm);
    591         xfree((void**)&pshapz);
    592         xfree((void**)&pshapy);
    593         xfree((void**)&pshapx);
    594         xfree((void**)&pnvert);
     583                xDelete<double>((pshapm[i]));
     584                xDelete<double>((pshapz[i]));
     585                xDelete<double>((pshapy[i]));
     586                xDelete<double>((pshapx[i]));
     587        }
     588        xDelete<double*>(pshapm);
     589        xDelete<double*>(pshapz);
     590        xDelete<double*>(pshapy);
     591        xDelete<double*>(pshapx);
     592        xDelete<int>(pnvert);
    595593        for (i=nshape-1; i>=0; i--) {
    596                 xfree((void**)&(pptype[i]));
    597                 xfree((void**)&(ppstrt[i]));
    598         }
    599         xfree((void**)&pptype);
    600         xfree((void**)&ppstrt);
    601         xfree((void**)&pnpart);
    602         xfree((void**)&pstype);
     594                xDelete<int>((pptype[i]));
     595                xDelete<int>((ppstrt[i]));
     596        }
     597        xDelete<int*>(pptype);
     598        xDelete<int*>(ppstrt);
     599        xDelete<int>(pnpart);
     600        xDelete<int>(pstype);
    603601
    604602        clock1=clock();

  • issm/trunk-jpl/src/c/modules/TriMeshx/TriMeshx.cpp

    r12098 r12442  
    5757
    5858        /*fill in the point list: */
    59         in.pointlist = (REAL *) xmalloc(in.numberofpoints * 2 * sizeof(REAL));
     59        in.pointlist = xNew<REAL>(in.numberofpoints*2);
    6060
    6161        counter=0;
    … …  
    7878       
    7979        /*fill in the point attribute list: */
    80         in.pointattributelist = (REAL*)xmalloc(in.numberofpoints*in.numberofpointattributes*sizeof(REAL));
     80        in.pointattributelist = xNew<REAL>(in.numberofpoints*in.numberofpointattributes);
    8181        for (i=0;i<in.numberofpoints;i++) in.pointattributelist[i] = 0.0;
    8282       
    8383        /*fill in the point marker list: */
    84         in.pointmarkerlist = (int *) xmalloc(in.numberofpoints * sizeof(int));
     84        in.pointmarkerlist = xNew<int>(in.numberofpoints);
    8585        for(i=0;i<in.numberofpoints;i++) in.pointmarkerlist[i] = 0;
    8686
    … …  
    9797        }
    9898       
    99         in.segmentlist = (int *) xmalloc(in.numberofsegments * 2 * sizeof(int));
    100         in.segmentmarkerlist = (int *) xcalloc(in.numberofsegments,sizeof(int));
     99        in.segmentlist = xNew<int>(in.numberofsegments*2);
     100        in.segmentmarkerlist = (int*)xcalloc(in.numberofsegments,sizeof(int));
    101101        counter=0;
    102102        backcounter=0;
    … …  
    135135        in.numberofholes = domain->Size()-1; /*everything is a hole, but for the first profile.*/
    136136        if(in.numberofholes){
    137                 in.holelist = (REAL *) xmalloc(in.numberofholes * 2 * sizeof(REAL));
     137                in.holelist = xNew<REAL>(in.numberofholes*2);
    138138                for (i=0;i<domain->Size()-1;i++){
    139139                        contour=(Contour*)domain->GetObjectByOffset(i+1);
    … …  
    164164
    165165        /*Allocate index, x and y: */
    166         index=(double*)xmalloc(3*out.numberoftriangles*sizeof(double));
    167         x=(double*)xmalloc(out.numberofpoints*sizeof(double));
    168         y=(double*)xmalloc(out.numberofpoints*sizeof(double));
    169         segments=(double*)xmalloc(3*out.numberofsegments*sizeof(double));
    170         segmentmarkerlist=(double*)xmalloc(out.numberofsegments*sizeof(double));
     166        index=xNew<double>(3*out.numberoftriangles);
     167        x=xNew<double>(out.numberofpoints);
     168        y=xNew<double>(out.numberofpoints);
     169        segments=xNew<double>(3*out.numberofsegments);
     170        segmentmarkerlist=xNew<double>(out.numberofsegments);
    171171
    172172        for (i = 0; i< out.numberoftriangles; i++) {

  • issm/trunk-jpl/src/c/objects/KML/KML_LineString.cpp

    r12365 r12442  
    3737KML_LineString::~KML_LineString(){
    3838
    39         if (coords) xfree((void**)&coords);
     39        if (coords) xDelete<double>(coords);
    4040
    4141        coords    =NULL;
    … …  
    8686        _printf_(flag,"%s        coords: (ncoord=%d)\n" ,indent,ncoord);
    8787        for (i=0; i<ncoord; i++)
    88                 _printf_(flag,"%s                (%g,%g,%g)\n" ,indent,
    89                                 coords[i][0],coords[i][1],coords[i][2]);
     88                _printf_(flag,"%s                (%g,%g,%g)\n" ,indent,coords[3*i+0],coords[3*i+1],coords[3*i+2]);
    9089
    9190        return;
    … …  
    112111
    113112        for (i=0; i<ncoord; i++)
    114                 fprintf(filout,"%s    %0.16g,%0.16g,%0.16g\n",indent,
    115                                 coords[i][0],coords[i][1],coords[i][2]);
     113                fprintf(filout,"%s    %0.16g,%0.16g,%0.16g\n",indent, coords[3*i+0],coords[3*i+1],coords[3*i+2]);
    116114
    117115        fprintf(filout,"%s  </coordinates>\n",indent);
    … …  
    191189        lon=(double *) xmalloc(ncoord*sizeof(double));
    192190        for (i=0; i<ncoord; i++) {
    193                 lon[i]=coords[i][0];
    194                 lat[i]=coords[i][1];
     191                lon[i]=coords[3*i+0];
     192                lat[i]=coords[3*i+1];
    195193        }
    196194

  • issm/trunk-jpl/src/c/objects/KML/KML_LineString.h

    r12365 r12442  
    2121        public:
    2222
    23                 bool  extrude;
    24                 bool  tessellate;
    25                 char  altmode[KML_LINESTRING_ALTMODE_LENGTH+1];
    26         int   ncoord;
    27                 double (*coords)[3];
     23                bool    extrude;
     24                bool    tessellate;
     25                char    altmode[KML_LINESTRING_ALTMODE_LENGTH+1];
     26                int     ncoord;
     27                double *coords;
    2828
    2929                /*KML_LineString constructors, destructors {{{*/

  • issm/trunk-jpl/src/c/objects/KML/KML_LinearRing.cpp

    r12365 r12442  
    3737KML_LinearRing::~KML_LinearRing(){
    3838
    39         if (coords) xfree((void**)&coords);
     39        if (coords) xDelete<double>(coords);
    4040
    4141        coords    =NULL;
    … …  
    6262}
    6363/*}}}*/
    64 
    6564/*FUNCTION KML_LinearRing::DeepEcho {{{*/
    6665void  KML_LinearRing::DeepEcho(){
    … …  
    7372}
    7473/*}}}*/
    75 
    7674/*FUNCTION KML_LinearRing::DeepEcho {{{*/
    7775void  KML_LinearRing::DeepEcho(const char* indent){
    … …  
    8987        for (i=0; i<ncoord; i++)
    9088                _printf_(flag,"%s                (%g,%g,%g)\n" ,indent,
    91                                 coords[i][0],coords[i][1],coords[i][2]);
    92 
    93         return;
    94 }
    95 /*}}}*/
    96 
     89                                coords[3*i+0],coords[3*i+1],coords[3*i+2]);
     90
     91        return;
     92}
     93/*}}}*/
    9794/*FUNCTION KML_LinearRing::Write {{{*/
    9895void  KML_LinearRing::Write(FILE* filout,const char* indent){
    … …  
    115112
    116113        for (i=0; i<ncoord; i++)
    117                 fprintf(filout,"%s    %0.16g,%0.16g,%0.16g\n",indent,
    118                                 coords[i][0],coords[i][1],coords[i][2]);
     114                fprintf(filout,"%s    %0.16g,%0.16g,%0.16g\n",indent,coords[3*i+0],coords[3*i+1],coords[3*i+2]);
    119115
    120116        fprintf(filout,"%s  </coordinates>\n",indent);
    … …  
    124120}
    125121/*}}}*/
    126 
    127122/*FUNCTION KML_LinearRing::Read {{{*/
    128123void  KML_LinearRing::Read(FILE* fid,char* kstr){
    129124
    130         char*        kstri;
    131         int          ncom=0;
    132         char**       pcom=NULL;
     125        char  *kstri = NULL;
     126        int    ncom  = 0;
     127        char **pcom  = NULL;
    133128
    134129/*  get object attributes and check for solo tag  */
    135130
    136         if (KMLFileTagAttrib(this,
    137                                                  kstr))
    138                 return;
     131        if (KMLFileTagAttrib(this,kstr)) return;
    139132
    140133/*  loop over and process fields within opening and closing tags  */
    141134
    142         while (kstri=KMLFileToken(fid,
    143                                                           &ncom,&pcom)) {
    144                 if      (!strncmp(kstri,"</LinearRing",12)) {
    145                         xfree((void**)&kstri);
     135        while (kstri=KMLFileToken(fid,&ncom,&pcom)){
     136                if (!strncmp(kstri,"</LinearRing",12)){
     137                        xDelete<char>(kstri);
    146138                        break;
    147139                }
    … …  
    152144
    153145                else if (!strcmp(kstri,"<extrude>"))
    154                         KMLFileTokenParse(&extrude   ,
    155                                                           kstri,
    156                                                           fid);
     146                        KMLFileTokenParse(&extrude,kstri,fid);
    157147                else if (!strcmp(kstri,"<tessellate>"))
    158                         KMLFileTokenParse(&tessellate,
    159                                                           kstri,
    160                                                           fid);
     148                        KMLFileTokenParse(&tessellate,kstri,fid);
    161149                else if (!strcmp(kstri,"<altitudeMode>"))
    162                         KMLFileTokenParse( altmode   ,NULL,KML_LINEARRING_ALTMODE_LENGTH,
    163                                                           kstri,
    164                                                           fid);
     150                        KMLFileTokenParse(altmode,NULL,KML_LINEARRING_ALTMODE_LENGTH,kstri,fid);
    165151                else if (!strcmp(kstri,"<coordinates>"))
    166                         KMLFileTokenParse(&coords    ,&ncoord    ,0,
    167                                                           kstri,
    168                                                           fid);
    169 
     152                        KMLFileTokenParse(&coords,&ncoord,0,kstri,fid);
    170153                else if (!strncmp(kstri,"<",1))
    171154                        KML_Geometry::Read(fid,kstri);
    172155
    173                 xfree((void**)&kstri);
     156                xDelete<char>(kstri);
    174157        }
    175158
    176159        this->AddCommnt(ncom,pcom);
    177160
    178         for (ncom; ncom>0; ncom--)
    179                 xfree((void**)&(pcom[ncom-1]));
    180         xfree((void**)&pcom);
    181 
    182         return;
    183 }
    184 /*}}}*/
    185 
     161        for(ncom;ncom>0;ncom--) xDelete<char>((pcom[ncom-1]));
     162        xDelete<char*>(pcom);
     163
     164        return;
     165}
     166/*}}}*/
    186167/*FUNCTION KML_LinearRing::WriteExp {{{*/
    187168void  KML_LinearRing::WriteExp(FILE* fid,const char* nstr,int sgn,double cm,double sp){
    … …  
    193174/*  extract latitude and longitude into vectors  */
    194175
    195         lat=(double *) xmalloc(ncoord*sizeof(double));
    196         lon=(double *) xmalloc(ncoord*sizeof(double));
     176        lat=xNew<double>(ncoord);
     177        lon=xNew<double>(ncoord);
    197178        for (i=0; i<ncoord; i++) {
    198                 lon[i]=coords[i][0];
    199                 lat[i]=coords[i][1];
     179                lon[i]=coords[3*i+0];
     180                lat[i]=coords[3*i+1];
    200181        }
    201182
    202183/*  convert latitude and longitude to x and y  */
    203184
    204         x  =(double *) xmalloc(ncoord*sizeof(double));
    205         y  =(double *) xmalloc(ncoord*sizeof(double));
     185        x  =xNew<double>(ncoord);
     186        y  =xNew<double>(ncoord);
    206187        Ll2xyx(x,y,lat,lon,ncoord,sgn,cm,sp);
    207188
    … …  
    233214        fprintf(fid,"\n");
    234215
    235         xfree((void**)&y);
    236         xfree((void**)&x);
    237         xfree((void**)&lon);
    238         xfree((void**)&lat);
    239 
    240         return;
    241 }
    242 /*}}}*/
    243 
     216        xDelete<double>(y);
     217        xDelete<double>(x);
     218        xDelete<double>(lon);
     219        xDelete<double>(lat);
     220
     221        return;
     222}
     223/*}}}*/

  • issm/trunk-jpl/src/c/objects/KML/KML_LinearRing.h

    r12365 r12442  
    2121        public:
    2222
    23                 bool  extrude;
    24                 bool  tessellate;
    25                 char  altmode[KML_LINEARRING_ALTMODE_LENGTH+1];
    26         int   ncoord;
    27                 double (*coords)[3];
     23                bool     extrude;
     24                bool     tessellate;
     25                char     altmode[KML_LINEARRING_ALTMODE_LENGTH+1];
     26                int      ncoord;
     27                double  *coords;
    2828
    2929                /*KML_LinearRing constructors, destructors {{{*/
Note: See TracChangeset for help on using the changeset viewer.