IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 25, 2006, 1:53:07 PM (20 years ago)
Author:
Paul Price
Message:

Getting rid of extraneous parenthesis that caused formatting problems.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/fits/psFits.c

    r6767 r7222  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.53 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-04-04 19:52:42 $
     9 *  @version $Revision: 1.54 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-05-25 23:53:07 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    127127
    128128        #if ( CFITSIO_DISKFILE == 1 )
    129         (void)fits_create_diskfile(
    130             #else
    131             (void)fits_create_file(
    132                 #endif
    133                 &fptr,
    134                 name,
    135                 &status);
    136             if (fptr == NULL || status != 0) {
     129        (void)fits_create_diskfile
     130        #else
     131        (void)fits_create_file
     132        #endif
     133        (&fptr,
     134         name,
     135         &status);
     136        if (fptr == NULL || status != 0) {
    137137            char fitsErr[MAX_STRING_LENGTH]
    138                 ;
    139                 fits_get_errstatus(status, fitsErr);
    140                 psError(PS_ERR_IO, true,
    141                         PS_ERRORTEXT_psFits_FILENAME_CREATE_FAILED,
    142                         name, fitsErr);
    143                 return NULL;
    144             }
    145         } else {
    146             #if ( CFITSIO_DISKFILE == 1 )
    147             (void)fits_open_diskfile(
    148                 #else
    149                 (void)fits_open_file(
    150                     #endif
    151                     &fptr,
    152                     name,
    153                     iomode,
    154                     &status);
    155                 if (fptr == NULL || status != 0) {
    156                 char fitsErr[MAX_STRING_LENGTH]
    157                     ;
    158                     fits_get_errstatus(status, fitsErr);
    159                     psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    160                             PS_ERRORTEXT_psFits_FILENAME_INVALID,
    161                             name, fitsErr);
    162                     return NULL;
    163                 }
    164             }
    165 
    166             psFits* fits = psAlloc(sizeof(psFits));
    167         fits->fd = fptr;
    168         fits->writable = (iomode == READWRITE);
    169         psMemSetDeallocator(fits,(psFreeFunc)fitsFree);
    170 
    171         return fits;
    172     }
    173 
    174     bool psMemCheckFits(psPtr ptr)
    175     {
    176         return ( psMemGetDeallocator(ptr) == (psFreeFunc)fitsFree );
    177     }
    178 
    179 
    180     bool psFitsMoveExtName(const psFits* fits,
    181                            const char* extname)
    182     {
    183         int status = 0;
    184 
    185         if (fits == NULL) {
    186             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    187                     PS_ERRORTEXT_psFits_NULL);
    188             return false;
    189         }
    190 
    191         if (extname == NULL) {
    192             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    193                     PS_ERRORTEXT_psFits_EXTNAME_NULL);
    194             return false;
    195         }
    196 
    197 
    198         if (fits_movnam_hdu(fits->fd, ANY_HDU, (char*)extname, 0, &status) != 0) {
     138            ;
     139            fits_get_errstatus(status, fitsErr);
     140            psError(PS_ERR_IO, true,
     141                    PS_ERRORTEXT_psFits_FILENAME_CREATE_FAILED,
     142                    name, fitsErr);
     143            return NULL;
     144        }
     145    } else {
     146        #if ( CFITSIO_DISKFILE == 1 )
     147        (void)fits_open_diskfile
     148        #else
     149        (void)fits_open_file
     150        #endif
     151        (&fptr,
     152         name,
     153         iomode,
     154         &status);
     155        if (fptr == NULL || status != 0) {
     156            char fitsErr[MAX_STRING_LENGTH]
     157            ;
     158            fits_get_errstatus(status, fitsErr);
     159            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     160                    PS_ERRORTEXT_psFits_FILENAME_INVALID,
     161                    name, fitsErr);
     162            return NULL;
     163        }
     164    }
     165
     166    psFits* fits = psAlloc(sizeof(psFits));
     167    fits->fd = fptr;
     168    fits->writable = (iomode == READWRITE);
     169    psMemSetDeallocator(fits,(psFreeFunc)fitsFree);
     170
     171    return fits;
     172}
     173
     174bool psMemCheckFits(psPtr ptr)
     175{
     176    return ( psMemGetDeallocator(ptr) == (psFreeFunc)fitsFree );
     177}
     178
     179
     180bool psFitsMoveExtName(const psFits* fits,
     181                       const char* extname)
     182{
     183    int status = 0;
     184
     185    if (fits == NULL) {
     186        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     187                PS_ERRORTEXT_psFits_NULL);
     188        return false;
     189    }
     190
     191    if (extname == NULL) {
     192        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     193                PS_ERRORTEXT_psFits_EXTNAME_NULL);
     194        return false;
     195    }
     196
     197
     198    if (fits_movnam_hdu(fits->fd, ANY_HDU, (char*)extname, 0, &status) != 0) {
     199        char fitsErr[MAX_STRING_LENGTH];
     200        fits_get_errstatus(status, fitsErr);
     201        psError(PS_ERR_LOCATION_INVALID, true,
     202                PS_ERRORTEXT_psFits_EXTNAME_INVALID,
     203                extname, fitsErr);
     204        return false;
     205    }
     206
     207    return true;
     208}
     209
     210bool psFitsMoveExtNum(const psFits* fits,
     211                      int extnum,
     212                      bool relative)
     213{
     214    if (fits == NULL) {
     215        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     216                PS_ERRORTEXT_psFits_NULL);
     217        return false;
     218    }
     219
     220    int status = 0;
     221    int hdutype = 0;
     222
     223    if (relative) {
     224        fits_movrel_hdu(fits->fd, extnum, &hdutype, &status);
     225        if (status != 0) {
    199226            char fitsErr[MAX_STRING_LENGTH];
    200227            fits_get_errstatus(status, fitsErr);
    201228            psError(PS_ERR_LOCATION_INVALID, true,
    202                     PS_ERRORTEXT_psFits_EXTNAME_INVALID,
    203                     extname, fitsErr);
     229                    PS_ERRORTEXT_psFits_EXTNUM_REL_MOVE_FAILED,
     230                    extnum, fitsErr);
    204231            return false;
    205232        }
    206 
    207         return true;
    208     }
    209 
    210     bool psFitsMoveExtNum(const psFits* fits,
    211                           int extnum,
    212                           bool relative)
    213     {
    214         if (fits == NULL) {
    215             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    216                     PS_ERRORTEXT_psFits_NULL);
    217             return false;
    218         }
    219 
    220         int status = 0;
    221         int hdutype = 0;
    222 
    223         if (relative) {
    224             fits_movrel_hdu(fits->fd, extnum, &hdutype, &status);
    225             if (status != 0) {
    226                 char fitsErr[MAX_STRING_LENGTH];
    227                 fits_get_errstatus(status, fitsErr);
    228                 psError(PS_ERR_LOCATION_INVALID, true,
    229                         PS_ERRORTEXT_psFits_EXTNUM_REL_MOVE_FAILED,
    230                         extnum, fitsErr);
    231                 return false;
    232             }
    233         } else {
    234             fits_movabs_hdu(fits->fd, extnum+1, &hdutype, &status);
    235             if (status != 0) {
    236                 char fitsErr[MAX_STRING_LENGTH];
    237                 fits_get_errstatus(status, fitsErr);
    238                 psError(PS_ERR_LOCATION_INVALID, true,
    239                         PS_ERRORTEXT_psFits_EXTNUM_ABS_MOVE_FAILED,
    240                         extnum, fitsErr);
    241                 return false;
    242             }
    243         }
    244 
    245         return true;
    246     }
    247 
    248     bool psFitsMoveLast(psFits* fits)
    249     {
    250         if (fits == NULL) {
    251             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    252                     PS_ERRORTEXT_psFits_NULL);
    253             return false;
    254         }
    255         int size = psFitsGetSize(fits);
    256         if (size == 0) { // empty file -- no action needed
    257             return true;
    258         } else {
    259             return psFitsMoveExtNum(fits,size-1,false);
    260         }
    261     }
    262 
    263     int psFitsGetExtNum(const psFits* fits)
    264     {
    265         int hdunum;
    266 
    267         if (fits == NULL) {
    268             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    269                     PS_ERRORTEXT_psFits_NULL);
    270             return PS_FITS_TYPE_NONE;
    271         }
    272 
    273 
    274         return fits_get_hdu_num(fits->fd,&hdunum) - 1;
    275     }
    276 
    277     psString psFitsGetExtName(const psFits* fits)
    278     {
    279         if (fits == NULL) {
    280             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    281                     PS_ERRORTEXT_psFits_NULL);
    282             return NULL;
    283         }
    284 
    285         int status = 0;
    286         char name[MAX_STRING_LENGTH];
    287 
    288         if (fits_read_key_str(fits->fd, "EXTNAME", name, NULL, &status) != 0) {
    289             status = 0;
    290             if (fits_read_key_str(fits->fd, "HDUNAME", name, NULL, &status) != 0) {
    291                 int num = psFitsGetExtNum(fits);
    292                 snprintf(name, MAX_STRING_LENGTH, "EXT-%3d",num);
    293             }
    294         }
    295         return psStringCopy(name);
    296     }
    297 
    298     bool psFitsSetExtName(psFits* fits, const char* name)
    299     {
    300         if (fits == NULL) {
    301             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    302                     PS_ERRORTEXT_psFits_NULL);
    303             return false;
    304         }
    305 
    306         if (name == NULL) {
    307             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    308                     PS_ERRORTEXT_psFits_EXTNAME_NULL);
    309             return false;
    310         }
    311 
    312         int status = 0;
    313 
    314         if (fits_update_key_str(fits->fd, "EXTNAME", (char*)name, NULL, &status) != 0) {
    315             char fitsErr[MAX_STRING_LENGTH];
    316             (void)fits_get_errstatus(status, fitsErr);
    317             psError(PS_ERR_IO, true,
    318                     PS_ERRORTEXT_psFits_WRITE_FAILED,
    319                     fitsErr);
    320             return false;
    321         }
    322 
    323         return true;
    324     }
    325 
    326     bool psFitsDeleteExtNum(psFits* fits,
    327                             int extnum,
    328                             bool relative)
    329     {
    330         if (fits == NULL) {
    331             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    332                     PS_ERRORTEXT_psFits_NULL);
    333             return false;
    334         }
    335 
    336         if (! fits->writable) {
    337             psError(PS_ERR_IO, true,
    338                     PS_ERRORTEXT_psFits_NOT_WRITABLE);
    339             return false;
    340         }
    341 
    342         // move to the specified HDU
    343         if (! psFitsMoveExtNum(fits,extnum,relative) ) {
    344             psError(PS_ERR_BAD_PARAMETER_VALUE, false,
    345                     "Failed to delete HDU #%d",
    346                     extnum);
    347             return false;
    348         }
    349 
    350         int status = 0;
    351 
    352         // OK, now let's delete the HDU
    353         if (fits_delete_hdu(fits->fd, NULL, &status) != 0) {
    354             char fitsErr[MAX_STRING_LENGTH];
    355             (void)fits_get_errstatus(status, fitsErr);
    356             psError(PS_ERR_IO, true,
    357                     PS_ERRORTEXT_psFits_WRITE_FAILED,
    358                     fitsErr);
    359             return false;
    360         }
    361 
    362         return true;
    363     }
    364 
    365     bool psFitsDeleteExtName(psFits* fits,
    366                              const char* extname)
    367     {
    368         if (fits == NULL) {
    369             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    370                     PS_ERRORTEXT_psFits_NULL);
    371             return false;
    372         }
    373 
    374         if (! fits->writable) {
    375             psError(PS_ERR_IO, true,
    376                     PS_ERRORTEXT_psFits_NOT_WRITABLE);
    377             return false;
    378         }
    379 
    380         // move to the specified HDU
    381         if (! psFitsMoveExtName(fits,extname) ) {
    382             psError(PS_ERR_BAD_PARAMETER_VALUE, false,
    383                     "Failed to delete HDU with the name '%s'",
    384                     extname);
    385             return false;
    386         }
    387 
    388 
    389         int status = 0;
    390 
    391         // OK, now let's delete the HDU
    392         if (fits_delete_hdu(fits->fd, NULL, &status) != 0) {
    393             char fitsErr[MAX_STRING_LENGTH];
    394             (void)fits_get_errstatus(status, fitsErr);
    395             psError(PS_ERR_IO, true,
    396                     PS_ERRORTEXT_psFits_WRITE_FAILED,
    397                     fitsErr);
    398             return false;
    399         }
    400 
    401         return true;
    402     }
    403 
    404     int psFitsGetSize(const psFits* fits)
    405     {
    406         if (fits == NULL) {
    407             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    408                     PS_ERRORTEXT_psFits_NULL);
    409             return 0;
    410         }
    411 
    412         int num = 0;
    413         int status = 0;
    414 
    415         if (fits_get_num_hdus(fits->fd, &num, &status) != 0) {
     233    } else {
     234        fits_movabs_hdu(fits->fd, extnum+1, &hdutype, &status);
     235        if (status != 0) {
    416236            char fitsErr[MAX_STRING_LENGTH];
    417237            fits_get_errstatus(status, fitsErr);
    418238            psError(PS_ERR_LOCATION_INVALID, true,
    419                     PS_ERRORTEXT_psFits_GETNUMHDUS_FAILED,
    420                     fitsErr);
    421             return 0;
    422         }
    423 
    424         return num;
    425     }
    426 
    427     psFitsType psFitsGetExtType(const psFits* fits)
    428     {
    429         if (fits == NULL) {
    430             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    431                     PS_ERRORTEXT_psFits_NULL);
    432             return PS_FITS_TYPE_NONE;
    433         }
    434 
    435         int status = 0;
    436         int hdutype = PS_FITS_TYPE_NONE;
    437 
    438         if (fits_get_hdu_type(fits->fd, &hdutype, &status) != 0) {
    439             char fitsErr[MAX_STRING_LENGTH];
    440             fits_get_errstatus(status, fitsErr);
    441             psError(PS_ERR_LOCATION_INVALID, true,
    442                     PS_ERRORTEXT_psFits_GETHDUTYPE_FAILED,
    443                     fitsErr);
    444             return PS_FITS_TYPE_NONE;
    445         }
    446 
    447         if (hdutype == PS_FITS_TYPE_IMAGE &&
    448                 psFitsGetExtNum(fits) > 0 &&
    449                 isHDUEmpty(fits)) {
    450             return PS_FITS_TYPE_ANY;
    451         }
    452 
    453         return hdutype;
    454     }
    455 
    456     bool psFitsTruncate(psFits* fits)
    457     {
    458         if (fits == NULL) {
    459             psError(PS_ERR_BAD_PARAMETER_NULL, true,
    460                     PS_ERRORTEXT_psFits_NULL);
    461             return PS_FITS_TYPE_NONE;
    462         }
    463 
    464         if (! fits->writable) {
    465             psError(PS_ERR_IO, true,
    466                     PS_ERRORTEXT_psFits_NOT_WRITABLE);
    467             return PS_FITS_TYPE_NONE;
    468         }
    469 
    470         int newEnd = psFitsGetExtNum(fits);
    471 
    472         psFitsMoveLast(fits);
    473         int end = psFitsGetExtNum(fits);
    474 
    475         // delete HDUs from end to beginning position + 1;
    476         for (int lcv=end;lcv > newEnd; lcv--) {
    477             if (! psFitsDeleteExtNum(fits,lcv,false)) {
    478                 // failed to delete an HDU!?
    479                 psError(PS_ERR_UNKNOWN, false,
    480                         "Failed to truncate file.  HDU #%d out of %d could not be deleted.",
    481                         lcv,end);
    482                 return false;
    483             }
    484         }
    485 
     239                    PS_ERRORTEXT_psFits_EXTNUM_ABS_MOVE_FAILED,
     240                    extnum, fitsErr);
     241            return false;
     242        }
     243    }
     244
     245    return true;
     246}
     247
     248bool psFitsMoveLast(psFits* fits)
     249{
     250    if (fits == NULL) {
     251        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     252                PS_ERRORTEXT_psFits_NULL);
     253        return false;
     254    }
     255    int size = psFitsGetSize(fits);
     256    if (size == 0) { // empty file -- no action needed
    486257        return true;
    487     }
     258    } else {
     259        return psFitsMoveExtNum(fits,size-1,false);
     260    }
     261}
     262
     263int psFitsGetExtNum(const psFits* fits)
     264{
     265    int hdunum;
     266
     267    if (fits == NULL) {
     268        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     269                PS_ERRORTEXT_psFits_NULL);
     270        return PS_FITS_TYPE_NONE;
     271    }
     272
     273
     274    return fits_get_hdu_num(fits->fd,&hdunum) - 1;
     275}
     276
     277psString psFitsGetExtName(const psFits* fits)
     278{
     279    if (fits == NULL) {
     280        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     281                PS_ERRORTEXT_psFits_NULL);
     282        return NULL;
     283    }
     284
     285    int status = 0;
     286    char name[MAX_STRING_LENGTH];
     287
     288    if (fits_read_key_str(fits->fd, "EXTNAME", name, NULL, &status) != 0) {
     289        status = 0;
     290        if (fits_read_key_str(fits->fd, "HDUNAME", name, NULL, &status) != 0) {
     291            int num = psFitsGetExtNum(fits);
     292            snprintf(name, MAX_STRING_LENGTH, "EXT-%3d",num);
     293        }
     294    }
     295    return psStringCopy(name);
     296}
     297
     298bool psFitsSetExtName(psFits* fits, const char* name)
     299{
     300    if (fits == NULL) {
     301        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     302                PS_ERRORTEXT_psFits_NULL);
     303        return false;
     304    }
     305
     306    if (name == NULL) {
     307        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     308                PS_ERRORTEXT_psFits_EXTNAME_NULL);
     309        return false;
     310    }
     311
     312    int status = 0;
     313
     314    if (fits_update_key_str(fits->fd, "EXTNAME", (char*)name, NULL, &status) != 0) {
     315        char fitsErr[MAX_STRING_LENGTH];
     316        (void)fits_get_errstatus(status, fitsErr);
     317        psError(PS_ERR_IO, true,
     318                PS_ERRORTEXT_psFits_WRITE_FAILED,
     319                fitsErr);
     320        return false;
     321    }
     322
     323    return true;
     324}
     325
     326bool psFitsDeleteExtNum(psFits* fits,
     327                        int extnum,
     328                        bool relative)
     329{
     330    if (fits == NULL) {
     331        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     332                PS_ERRORTEXT_psFits_NULL);
     333        return false;
     334    }
     335
     336    if (! fits->writable) {
     337        psError(PS_ERR_IO, true,
     338                PS_ERRORTEXT_psFits_NOT_WRITABLE);
     339        return false;
     340    }
     341
     342    // move to the specified HDU
     343    if (! psFitsMoveExtNum(fits,extnum,relative) ) {
     344        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     345                "Failed to delete HDU #%d",
     346                extnum);
     347        return false;
     348    }
     349
     350    int status = 0;
     351
     352    // OK, now let's delete the HDU
     353    if (fits_delete_hdu(fits->fd, NULL, &status) != 0) {
     354        char fitsErr[MAX_STRING_LENGTH];
     355        (void)fits_get_errstatus(status, fitsErr);
     356        psError(PS_ERR_IO, true,
     357                PS_ERRORTEXT_psFits_WRITE_FAILED,
     358                fitsErr);
     359        return false;
     360    }
     361
     362    return true;
     363}
     364
     365bool psFitsDeleteExtName(psFits* fits,
     366                         const char* extname)
     367{
     368    if (fits == NULL) {
     369        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     370                PS_ERRORTEXT_psFits_NULL);
     371        return false;
     372    }
     373
     374    if (! fits->writable) {
     375        psError(PS_ERR_IO, true,
     376                PS_ERRORTEXT_psFits_NOT_WRITABLE);
     377        return false;
     378    }
     379
     380    // move to the specified HDU
     381    if (! psFitsMoveExtName(fits,extname) ) {
     382        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
     383                "Failed to delete HDU with the name '%s'",
     384                extname);
     385        return false;
     386    }
     387
     388
     389    int status = 0;
     390
     391    // OK, now let's delete the HDU
     392    if (fits_delete_hdu(fits->fd, NULL, &status) != 0) {
     393        char fitsErr[MAX_STRING_LENGTH];
     394        (void)fits_get_errstatus(status, fitsErr);
     395        psError(PS_ERR_IO, true,
     396                PS_ERRORTEXT_psFits_WRITE_FAILED,
     397                fitsErr);
     398        return false;
     399    }
     400
     401    return true;
     402}
     403
     404int psFitsGetSize(const psFits* fits)
     405{
     406    if (fits == NULL) {
     407        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     408                PS_ERRORTEXT_psFits_NULL);
     409        return 0;
     410    }
     411
     412    int num = 0;
     413    int status = 0;
     414
     415    if (fits_get_num_hdus(fits->fd, &num, &status) != 0) {
     416        char fitsErr[MAX_STRING_LENGTH];
     417        fits_get_errstatus(status, fitsErr);
     418        psError(PS_ERR_LOCATION_INVALID, true,
     419                PS_ERRORTEXT_psFits_GETNUMHDUS_FAILED,
     420                fitsErr);
     421        return 0;
     422    }
     423
     424    return num;
     425}
     426
     427psFitsType psFitsGetExtType(const psFits* fits)
     428{
     429    if (fits == NULL) {
     430        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     431                PS_ERRORTEXT_psFits_NULL);
     432        return PS_FITS_TYPE_NONE;
     433    }
     434
     435    int status = 0;
     436    int hdutype = PS_FITS_TYPE_NONE;
     437
     438    if (fits_get_hdu_type(fits->fd, &hdutype, &status) != 0) {
     439        char fitsErr[MAX_STRING_LENGTH];
     440        fits_get_errstatus(status, fitsErr);
     441        psError(PS_ERR_LOCATION_INVALID, true,
     442                PS_ERRORTEXT_psFits_GETHDUTYPE_FAILED,
     443                fitsErr);
     444        return PS_FITS_TYPE_NONE;
     445    }
     446
     447    if (hdutype == PS_FITS_TYPE_IMAGE &&
     448            psFitsGetExtNum(fits) > 0 &&
     449            isHDUEmpty(fits)) {
     450        return PS_FITS_TYPE_ANY;
     451    }
     452
     453    return hdutype;
     454}
     455
     456bool psFitsTruncate(psFits* fits)
     457{
     458    if (fits == NULL) {
     459        psError(PS_ERR_BAD_PARAMETER_NULL, true,
     460                PS_ERRORTEXT_psFits_NULL);
     461        return PS_FITS_TYPE_NONE;
     462    }
     463
     464    if (! fits->writable) {
     465        psError(PS_ERR_IO, true,
     466                PS_ERRORTEXT_psFits_NOT_WRITABLE);
     467        return PS_FITS_TYPE_NONE;
     468    }
     469
     470    int newEnd = psFitsGetExtNum(fits);
     471
     472    psFitsMoveLast(fits);
     473    int end = psFitsGetExtNum(fits);
     474
     475    // delete HDUs from end to beginning position + 1;
     476    for (int lcv=end;lcv > newEnd; lcv--) {
     477        if (! psFitsDeleteExtNum(fits,lcv,false)) {
     478            // failed to delete an HDU!?
     479            psError(PS_ERR_UNKNOWN, false,
     480                    "Failed to truncate file.  HDU #%d out of %d could not be deleted.",
     481                    lcv,end);
     482            return false;
     483        }
     484    }
     485
     486    return true;
     487}
Note: See TracChangeset for help on using the changeset viewer.