IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 12, 2008, 12:54:53 PM (18 years ago)
Author:
eugene
Message:

created psFitsDumpErors to dump all CFITSIO errors in the stack; also added this concept to psFitsErrors; replaced fits_get_errstatus with psFitsDumpErrors

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r17656 r19035  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.80 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2008-05-13 22:03:21 $
     9 *  @version $Revision: 1.81 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2008-08-12 22:54:53 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1919#include <unistd.h>
    2020#include <string.h>
     21#include <errno.h>
    2122
    2223#include "psFits.h"
    … …  
    3637static char *defaultExtword = "EXTNAME";
    3738
     39bool p_psFitsDumpErrors (const char* filename, unsigned int lineno, const char* func,
     40                         psErrorCode code, const char *message, ...) {
     41
     42    char fitsErr[MAX_STRING_LENGTH];
     43
     44    va_list ap;
     45    va_start(ap, message);
     46    p_psErrorV (filename, lineno, func, PS_ERR_BAD_FITS, true, message, ap);
     47    va_end(ap);
     48
     49    while (fits_read_errmsg(fitsErr)) {
     50        p_psError(filename, lineno, func, PS_ERR_BAD_FITS, false, "CFITSIO error: %s", fitsErr);
     51    }
     52
     53    return true;
     54}
     55
     56psErrorCode p_psFitsError(const char* filename, unsigned int lineno, const char* func,
     57                          int status, bool new, const char *errorMsg, ...)
     58{
     59    char fitsErr[MAX_STRING_LENGTH];
     60
     61    if (status == 0) return PS_ERR_NONE;
     62
     63    va_list ap;                         // Variable arguments
     64    va_start(ap, errorMsg);
     65    psErrorV (PS_ERR_IO, new, errorMsg, ap);
     66    va_end(ap);
     67
     68    while (fits_read_errmsg(fitsErr)) {
     69        psError(PS_ERR_IO, false, "[CFITSIO error: %s]", fitsErr);
     70    }
     71    return PS_ERR_IO;
     72}
     73
    3874static bool isHDUEmpty(const psFits* fits)
    3975{
    … …  
    6096    if (fits != NULL) {
    6197        if (fits_close_file(fits->fd, &status)) {
    62             char fitsErr[MAX_STRING_LENGTH];
    63             fits_get_errstatus(status, fitsErr);
    64             psError(PS_ERR_BAD_FITS, true,
    65                     "Error while closing psFits object. CFITSIO error: %s",
    66                     fitsErr);
     98            psFitsDumpErrors (PS_ERR_IO, "Error while closing psFits object");
    6799            return false;
    68100        }
    … …  
    125157        if (access(name, F_OK) == 0) {
    126158            // file exists, delete old one first
    127             remove(name);
    128         }
     159            if (remove(name)) {
     160                int thisErrno = errno;
     161                char errorBuf[64], *errorMsg;
     162# if ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! _GNU_SOURCE)
     163                errorMsg = strerror_r (errno, errorBuf, 64);
     164# else
     165                strerror_r (errno, errorBuf, 64);
     166                errorMsg = errorBuf;           
     167# endif
     168                psError (PS_ERR_IO, true, "Failed to delete a previously-existing file: %s", errorMsg);
     169                fprintf (stderr, "errno: %d, %s, %s : %lx, %lx\n", thisErrno, errorMsg, errorBuf, (long int) errorMsg, (long int) errorBuf);
     170                return NULL;
     171            }
     172        }
     173        if (!access(name, F_OK)) {
     174            psError (PS_ERR_IO, true, "deleted file still exists!");
     175            return NULL;
     176        }
    129177
    130178        #if ( CFITSIO_DISKFILE == 1 )
    … …  
    135183        (&fptr, name, &status);
    136184        if (fptr == NULL || status != 0) {
    137             char fitsErr[MAX_STRING_LENGTH];
    138             fits_get_errstatus(status, fitsErr);
    139             psError(PS_ERR_IO, true,
    140                     _("Could not create file,'%s'. CFITSIO Error: %s"),
    141                     name, fitsErr);
     185            psFitsDumpErrors (PS_ERR_IO, _("Could not create file,'%s'"), name);
    142186            return NULL;
    143187        }
    … …  
    150194        (&fptr, name, iomode, &status);
    151195        if (fptr == NULL || status != 0) {
    152             char fitsErr[MAX_STRING_LENGTH];
    153             fits_get_errstatus(status, fitsErr);
    154             psError(PS_ERR_IO, true,
    155                     _("Could not open file,'%s'. CFITSIO Error: %s"),
    156                     name, fitsErr);
     196            psFitsDumpErrors(PS_ERR_IO, _("Could not open file,'%s'"), name);
    157197            return NULL;
    158198        }
    … …  
    203243}
    204244
    205 psErrorCode p_psFitsError(const char* filename, unsigned int lineno, const char* func, int status,
    206                           bool new, const char *errorMsg, ...)
    207 {
    208     if (status == 0) {
    209         return PS_ERR_NONE;
    210     }
    211 
    212     va_list ap;                         // Variable arguments
    213     va_start(ap, errorMsg);
    214     psString msg = NULL;                // Message to pass to psError
    215     psStringAppendV(&msg, errorMsg, ap);
    216     va_end(ap);
    217 
    218     char cfitsioMsg[MAX_STRING_LENGTH];   // Error message from cfitsio
    219     (void)fits_get_errstatus(status, cfitsioMsg);
    220 
    221     psStringAppend(&msg, "[CFITSIO error: %s]", cfitsioMsg);
    222 
    223     psErrorCode code = p_psError(filename, lineno, func, PS_ERR_IO, new, msg); // Error code
    224     psFree(msg);
    225     return code;
    226 }
    227 
    228245static void psFitsCompressionFree(psFitsCompression *comp)
    229246{
    … …  
    354371        fits_movrel_hdu(fits->fd, extnum, &hdutype, &status);
    355372        if (status != 0) {
    356             char fitsErr[MAX_STRING_LENGTH];
    357             fits_get_errstatus(status, fitsErr);
    358             psError(PS_ERR_LOCATION_INVALID, true,
    359                     _("Could not move %d HDUs from current position. CFITSIO Error: %s"),
    360                     extnum, fitsErr);
     373            psFitsDumpErrors (PS_ERR_LOCATION_INVALID, _("Could not move %d HDUs from current position"), extnum);
    361374            return false;
    362375        }
    … …  
    364377        fits_movabs_hdu(fits->fd, extnum+1, &hdutype, &status);
    365378        if (status != 0) {
    366             char fitsErr[MAX_STRING_LENGTH];
    367             fits_get_errstatus(status, fitsErr);
    368             psError(PS_ERR_LOCATION_INVALID, true,
    369                     _("Could not move to specified HDU #%d. CFITSIO Error: %s"),
    370                     extnum, fitsErr);
     379            psFitsDumpErrors (PS_ERR_LOCATION_INVALID, _("Could not move to specified HDU #%d."), extnum);
    371380            return false;
    372381        }
    … …  
    423432
    424433    if (fits_update_key_str(fits->fd, extword, (char*)name, NULL, &status) != 0) {
    425         char fitsErr[MAX_STRING_LENGTH];
    426         (void)fits_get_errstatus(status, fitsErr);
    427         psError(PS_ERR_IO, true, _("Could not write data to file. CFITSIO Error: %s"), fitsErr);
     434        psFitsDumpErrors (PS_ERR_IO, _("Could not write data to file %s"), name);
    428435        return false;
    429436    }
    … …  
    449456    // OK, now let's delete the HDU
    450457    if (fits_delete_hdu(fits->fd, NULL, &status) != 0) {
    451         char fitsErr[MAX_STRING_LENGTH];
    452         (void)fits_get_errstatus(status, fitsErr);
    453         psError(PS_ERR_IO, true, _("Could not write data to file. CFITSIO Error: %s"), fitsErr);
     458        psFitsDumpErrors(PS_ERR_IO, _("Could not write data to file extnum %d"), extnum);
    454459        return false;
    455460    }
    … …  
    478483    // OK, now let's delete the HDU
    479484    if (fits_delete_hdu(fits->fd, NULL, &status) != 0) {
    480         char fitsErr[MAX_STRING_LENGTH];
    481         (void)fits_get_errstatus(status, fitsErr);
    482         psError(PS_ERR_IO, true,
    483                 _("Could not write data to file. CFITSIO Error: %s"),
    484                 fitsErr);
     485        psFitsDumpErrors(PS_ERR_IO, _("Could not write data to file extname %s"), extname);
    485486        return false;
    486487    }
    … …  
    497498
    498499    if (fits_get_num_hdus(fits->fd, &num, &status) != 0) {
    499         char fitsErr[MAX_STRING_LENGTH];
    500         fits_get_errstatus(status, fitsErr);
    501         psError(PS_ERR_LOCATION_INVALID, true,
    502                 _("Failed to determine the number of HDUs. CFITSIO Error: %s"),
    503                 fitsErr);
     500        psFitsDumpErrors(PS_ERR_LOCATION_INVALID, _("Failed to determine the number of HDUs"));
    504501        return 0;
    505502    }
    … …  
    516513
    517514    if (fits_get_hdu_type(fits->fd, &hdutype, &status) != 0) {
    518         char fitsErr[MAX_STRING_LENGTH];
    519         fits_get_errstatus(status, fitsErr);
    520         psError(PS_ERR_LOCATION_INVALID, true,
    521                 _("Failed to determine an HDU type. CFITSIO Error: %s"),
    522                 fitsErr);
     515        psFitsDumpErrors(PS_ERR_LOCATION_INVALID, _("Failed to determine an HDU type"));
    523516        return PS_FITS_TYPE_NONE;
    524517    }
    … …  
    595588    int status = 0;
    596589    if (fits_set_compression_type(fits->fd, comptype, &status)) {
    597         char fitsErr[MAX_STRING_LENGTH];
    598         fits_get_errstatus(status, fitsErr);
    599         psError(PS_ERR_BAD_FITS, true,
    600             "Error while configuring compression. CFITSIO error: %s", fitsErr);
     590        psFitsDumpErrors(PS_ERR_BAD_FITS, "Error while configuring compression");
    601591        return false;
    602592    }
    … …  
    624614    if (status) {
    625615        fits_set_compression_type(fits->fd, 0x0, &status);
    626         char fitsErr[MAX_STRING_LENGTH];
    627         fits_get_errstatus(status, fitsErr);
    628         psError(PS_ERR_BAD_FITS, true,
    629             "Error while configuring compression. CFITSIO error: %s", fitsErr);
     616        psFitsDumpErrors(PS_ERR_BAD_FITS, "Error while configuring compression");
    630617        return false;
    631618    }
    … …  
    636623        if (fits_set_noise_bits(fits->fd, noisebits, &status)) {
    637624            fits_set_compression_type(fits->fd, 0x0, &status);
    638             char fitsErr[MAX_STRING_LENGTH];
    639             fits_get_errstatus(status, fitsErr);
    640             psError(PS_ERR_BAD_FITS, true,
    641                     "Error while configuring compression. CFITSIO error: %s", fitsErr);
     625            psFitsDumpErrors(PS_ERR_BAD_FITS, "Error while configuring compression");
    642626            return false;
    643627        }
    … …  
    647631    if (fits_set_hcomp_scale(fits->fd, scale, &status)) {
    648632        fits_set_compression_type(fits->fd, 0x0, &status);
    649         char fitsErr[MAX_STRING_LENGTH];
    650         fits_get_errstatus(status, fitsErr);
    651         psError(PS_ERR_BAD_FITS, true,
    652             "Error while configuring compression. CFITSIO error: %s", fitsErr);
     633        psError(PS_ERR_BAD_FITS, status, "Error while configuring compression");
    653634        return false;
    654635    }
    655636    if (fits_set_hcomp_smooth(fits->fd, smooth, &status)) {
    656637        fits_set_compression_type(fits->fd, 0x0, &status);
    657         char fitsErr[MAX_STRING_LENGTH];
    658         fits_get_errstatus(status, fitsErr);
    659         psError(PS_ERR_BAD_FITS, true,
    660             "Error while configuring compression. CFITSIO error: %s", fitsErr);
     638        psError(PS_ERR_BAD_FITS, status, "Error while configuring compression");
    661639        return false;
    662640    }
Note: See TracChangeset for help on using the changeset viewer.