IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 8232 for trunk/psLib/src/fits


Ignore:
Timestamp:
Aug 8, 2006, 1:32:23 PM (20 years ago)
Author:
jhoblitt
Message:

bug #790 - remove psErrorText.h and inline all error codes. all newly inlined error codes are wrapped with the _() macro from future gettextification

Location:
trunk/psLib/src
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src

    • Property svn:ignore

      •  

        old new  
        1010libpslib.la.temp
        1111config.h.in
        12 psErrorText.h
        1312*.bb
        1413*.bbg

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

    r7914 r8232  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.57 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-07-15 02:57:12 $
     9 *  @version $Revision: 1.58 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-08-08 23:32:23 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1818#include "string.h"
    1919#include "psError.h"
    20 #include "psErrorText.h"
     20
    2121#include "psImageStructManip.h"
    2222#include "psMemory.h"
    … …  
    7373    if (fits == NULL) {
    7474        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    75                 PS_ERRORTEXT_psFits_NULL);
     75                _("The input psFits object can not NULL."));
    7676        return false;
    7777    }
    … …  
    9191    if (name == NULL) {
    9292        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    93                 PS_ERRORTEXT_psFits_FILENAME_NULL);
     93                _("Specified filename can not be NULL."));
    9494        return NULL;
    9595    }
    … …  
    139139            fits_get_errstatus(status, fitsErr);
    140140            psError(PS_ERR_IO, true,
    141                     PS_ERRORTEXT_psFits_FILENAME_CREATE_FAILED,
     141                    _("Could not create file,'%s'. CFITSIO Error: %s"),
    142142                    name, fitsErr);
    143143            return NULL;
    … …  
    158158            fits_get_errstatus(status, fitsErr);
    159159            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    160                     PS_ERRORTEXT_psFits_FILENAME_INVALID,
     160                    _("Could not open file,'%s'. CFITSIO Error: %s"),
    161161                    name, fitsErr);
    162162            return NULL;
    … …  
    188188    if (fits == NULL) {
    189189        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    190                 PS_ERRORTEXT_psFits_NULL);
     190                _("The input psFits object can not NULL."));
    191191        return false;
    192192    }
    … …  
    194194    if (extname == NULL) {
    195195        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    196                 PS_ERRORTEXT_psFits_EXTNAME_NULL);
     196                _("Specified extension name can not be NULL."));
    197197        return false;
    198198    }
    … …  
    203203        fits_get_errstatus(status, fitsErr);
    204204        psError(PS_ERR_LOCATION_INVALID, true,
    205                 PS_ERRORTEXT_psFits_EXTNAME_INVALID,
     205                _("Could not find HDU '%s'. CFITSIO Error: %s"),
    206206                extname, fitsErr);
    207207        return false;
    … …  
    217217    if (fits == NULL) {
    218218        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    219                 PS_ERRORTEXT_psFits_NULL);
     219                _("The input psFits object can not NULL."));
    220220        return false;
    221221    }
    … …  
    230230            fits_get_errstatus(status, fitsErr);
    231231            psError(PS_ERR_LOCATION_INVALID, true,
    232                     PS_ERRORTEXT_psFits_EXTNUM_REL_MOVE_FAILED,
     232                    _("Could not move %d HDUs from current position. CFITSIO Error: %s"),
    233233                    extnum, fitsErr);
    234234            return false;
    … …  
    240240            fits_get_errstatus(status, fitsErr);
    241241            psError(PS_ERR_LOCATION_INVALID, true,
    242                     PS_ERRORTEXT_psFits_EXTNUM_ABS_MOVE_FAILED,
     242                    _("Could not move to specified HDU #%d. CFITSIO Error: %s"),
    243243                    extnum, fitsErr);
    244244            return false;
    … …  
    253253    if (fits == NULL) {
    254254        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    255                 PS_ERRORTEXT_psFits_NULL);
     255                _("The input psFits object can not NULL."));
    256256        return false;
    257257    }
    … …  
    270270    if (fits == NULL) {
    271271        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    272                 PS_ERRORTEXT_psFits_NULL);
     272                _("The input psFits object can not NULL."));
    273273        return PS_FITS_TYPE_NONE;
    274274    }
    … …  
    282282    if (fits == NULL) {
    283283        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    284                 PS_ERRORTEXT_psFits_NULL);
     284                _("The input psFits object can not NULL."));
    285285        return NULL;
    286286    }
    … …  
    303303    if (fits == NULL) {
    304304        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    305                 PS_ERRORTEXT_psFits_NULL);
     305                _("The input psFits object can not NULL."));
    306306        return false;
    307307    }
    … …  
    309309    if (name == NULL) {
    310310        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    311                 PS_ERRORTEXT_psFits_EXTNAME_NULL);
     311                _("Specified extension name can not be NULL."));
    312312        return false;
    313313    }
    … …  
    319319        (void)fits_get_errstatus(status, fitsErr);
    320320        psError(PS_ERR_IO, true,
    321                 PS_ERRORTEXT_psFits_WRITE_FAILED,
     321                _("Could not write data to file. CFITSIO Error: %s"),
    322322                fitsErr);
    323323        return false;
    … …  
    333333    if (fits == NULL) {
    334334        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    335                 PS_ERRORTEXT_psFits_NULL);
     335                _("The input psFits object can not NULL."));
    336336        return false;
    337337    }
    … …  
    339339    if (! fits->writable) {
    340340        psError(PS_ERR_IO, true,
    341                 PS_ERRORTEXT_psFits_NOT_WRITABLE);
     341                _("The psFits object is not writable."));
    342342        return false;
    343343    }
    … …  
    358358        (void)fits_get_errstatus(status, fitsErr);
    359359        psError(PS_ERR_IO, true,
    360                 PS_ERRORTEXT_psFits_WRITE_FAILED,
     360                _("Could not write data to file. CFITSIO Error: %s"),
    361361                fitsErr);
    362362        return false;
    … …  
    371371    if (fits == NULL) {
    372372        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    373                 PS_ERRORTEXT_psFits_NULL);
     373                _("The input psFits object can not NULL."));
    374374        return false;
    375375    }
    … …  
    377377    if (! fits->writable) {
    378378        psError(PS_ERR_IO, true,
    379                 PS_ERRORTEXT_psFits_NOT_WRITABLE);
     379                _("The psFits object is not writable."));
    380380        return false;
    381381    }
    … …  
    397397        (void)fits_get_errstatus(status, fitsErr);
    398398        psError(PS_ERR_IO, true,
    399                 PS_ERRORTEXT_psFits_WRITE_FAILED,
     399                _("Could not write data to file. CFITSIO Error: %s"),
    400400                fitsErr);
    401401        return false;
    … …  
    409409    if (fits == NULL) {
    410410        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    411                 PS_ERRORTEXT_psFits_NULL);
     411                _("The input psFits object can not NULL."));
    412412        return 0;
    413413    }
    … …  
    420420        fits_get_errstatus(status, fitsErr);
    421421        psError(PS_ERR_LOCATION_INVALID, true,
    422                 PS_ERRORTEXT_psFits_GETNUMHDUS_FAILED,
     422                _("Failed to determine the number of HDUs. CFITSIO Error: %s"),
    423423                fitsErr);
    424424        return 0;
    … …  
    432432    if (fits == NULL) {
    433433        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    434                 PS_ERRORTEXT_psFits_NULL);
     434                _("The input psFits object can not NULL."));
    435435        return PS_FITS_TYPE_NONE;
    436436    }
    … …  
    443443        fits_get_errstatus(status, fitsErr);
    444444        psError(PS_ERR_LOCATION_INVALID, true,
    445                 PS_ERRORTEXT_psFits_GETHDUTYPE_FAILED,
     445                _("Failed to determine an HDU type. CFITSIO Error: %s"),
    446446                fitsErr);
    447447        return PS_FITS_TYPE_NONE;
    … …  
    461461    if (fits == NULL) {
    462462        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    463                 PS_ERRORTEXT_psFits_NULL);
     463                _("The input psFits object can not NULL."));
    464464        return PS_FITS_TYPE_NONE;
    465465    }
    … …  
    467467    if (! fits->writable) {
    468468        psError(PS_ERR_IO, true,
    469                 PS_ERRORTEXT_psFits_NOT_WRITABLE);
     469                _("The psFits object is not writable."));
    470470        return PS_FITS_TYPE_NONE;
    471471    }
    … …  
    601601            PS_TYPE_NAME(typeStr,type);
    602602            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    603                     PS_ERRORTEXT_psFits_TYPE_UNSUPPORTED,
     603                    _("Specified type, %s, is not supported."),
    604604                    typeStr);
    605605            return false;

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

    r7823 r8232  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-07-06 01:13:11 $
     9 *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-08-08 23:32:23 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1919#include "strings.h"
    2020#include "psError.h"
    21 #include "psErrorText.h"
     21
    2222#include "psImageStructManip.h"
    2323#include "psMemory.h"
    … …  
    4848    if (fits == NULL) {
    4949        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    50                 PS_ERRORTEXT_psFits_NULL);
     50                _("The input psFits object can not NULL."));
    5151        return NULL;
    5252    }
    … …  
    181181            }
    182182        default:
    183             psError(PS_ERR_IO, true, PS_ERRORTEXT_psFits_METATYPE_INVALID, keyType);
     183            psError(PS_ERR_IO, true, _("Specified FITS metadata type, %c, is not supported."), keyType);
    184184            return out;
    185185        }
    186186
    187187        if (!success) {
    188             psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_METADATA_ADD_FAILED, keyName);
     188            psError(PS_ERR_UNKNOWN, false, _("Failed to add metadata item, %s."), keyName);
    189189            return out;
    190190        }
    … …  
    195195        char fitsErr[MAX_STRING_LENGTH];
    196196        (void)fits_get_errstatus(status, fitsErr);
    197         psError(PS_ERR_IO, true, PS_ERRORTEXT_psFits_METADATA_ADD_FAILED, fitsErr);
     197        psError(PS_ERR_IO, true, _("Failed to add metadata item, %s."), fitsErr);
    198198        return false;
    199199    }
    … …  
    205205{
    206206    if (fits == NULL) {
    207         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_NULL);
     207        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
    208208        psFree(out);
    209209        return NULL;
    … …  
    385385            char fitsErr[MAX_STRING_LENGTH];
    386386            (void)fits_get_errstatus(status, fitsErr);
    387             psError(PS_ERR_IO, true, PS_ERRORTEXT_psFits_WRITE_FAILED, fitsErr);
     387            psError(PS_ERR_IO, true, _("Could not write data to file. CFITSIO Error: %s"), fitsErr);
    388388            return false;
    389389        }
    … …  
    400400{
    401401    if (!fits) {
    402         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_NULL);
     402        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
    403403        return false;
    404404    }
    405405
    406406    if (!output) {
    407         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_METADATA_NULL);
     407        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psMetadata was NULL.  Need a non-NULL psMetadata for operation to be performed."));
    408408        return false;
    409409    }
    … …  
    417417{
    418418    if (!fits) {
    419         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_NULL);
     419        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
    420420        return false;
    421421    }
    … …  
    443443{
    444444    if (header == NULL) {
    445         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_METADATA_NULL);
     445        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psMetadata was NULL.  Need a non-NULL psMetadata for operation to be performed."));
    446446        return false;
    447447    }

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

    r7846 r8232  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-07-08 03:06:40 $
     9 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-08-08 23:32:23 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1919#include "string.h"
    2020#include "psError.h"
    21 #include "psErrorText.h"
     21
    2222#include "psImageStructManip.h"
    2323#include "psMemory.h"
    … …  
    4949    if (fits == NULL) {
    5050        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    51                 PS_ERRORTEXT_psFits_NULL);
     51                _("The input psFits object can not NULL."));
    5252        return NULL;
    5353    }
    … …  
    5959        (void)fits_get_errstatus(status, fitsErr);
    6060        psError(PS_ERR_IO, true,
    61                 PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
     61                _("Could not determine the HDU type. CFITSIO Error: %s"),
    6262                fitsErr);
    6363        return NULL;
    … …  
    6565    if (hdutype != IMAGE_HDU) {
    6666        psError(PS_ERR_IO, true,
    67                 PS_ERRORTEXT_psFits_NOT_IMAGE_TYPE);
     67                _("Current FITS HDU type must be an image."));
    6868        return NULL;
    6969    }
    … …  
    7373        fits_get_errstatus(status, fitsErr);
    7474        psError(PS_ERR_IO, true,
    75                 PS_ERRORTEXT_psFits_DATATYPE_UNKNOWN,
     75                _("Could not determine image data type. CFITSIO Error: %s"),
    7676                fitsErr);
    7777        return NULL;
    … …  
    8282        (void)fits_get_errstatus(status, fitsErr);
    8383        psError(PS_ERR_IO, true,
    84                 PS_ERRORTEXT_psFits_IMAGE_DIM_UNKNOWN,
     84                _("Could not determine image dimensions. CFITSIO Error: %s"),
    8585                fitsErr);
    8686        return NULL;
    … …  
    9090    if ((nAxis < 2) || (nAxis > 3)) {
    9191        psError(PS_ERR_IO, true,
    92                 PS_ERRORTEXT_psFits_IMAGE_DIMENSION_UNSUPPORTED,
     92                _("Image number of dimensions, %d, is not valid.  Only two or three dimensions supported for FITS I/O."),
    9393                nAxis);
    9494        return NULL;
    … …  
    9999        (void)fits_get_errstatus(status, fitsErr);
    100100        psError(PS_ERR_IO, true,
    101                 PS_ERRORTEXT_psFits_IMAGE_SIZE_UNKNOWN,
     101                _("Could not determine image size. CFITSIO Error: %s"),
    102102                fitsErr);
    103103        return NULL;
    … …  
    163163    default:
    164164        psError(PS_ERR_IO, true,
    165                 PS_ERRORTEXT_psFits_FITS_TYPE_UNSUPPORTED,
     165                _("FITS image type, BITPIX=%d, is not supported."),
    166166                bitPix);
    167167        return NULL;
    … …  
    178178        (void)fits_get_errstatus(status, fitsErr);
    179179        psError(PS_ERR_IO, true,
    180                 PS_ERRORTEXT_psFits_READ_FAILED,
     180                _("Reading FITS file failed. CFITSIO Error: %s"),
    181181                fitsErr);
    182182        return NULL;
    … …  
    208208
    209209    if (!fits) {
    210         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_NULL);
     210        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
    211211        return false;
    212212    }
    213213
    214214    if (!input) {
    215         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_IMAGE_NULL);
     215        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
    216216        return false;
    217217    }
    … …  
    299299        (void)fits_get_errstatus(status, fitsErr);
    300300        psError(PS_ERR_IO, true,
    301                 PS_ERRORTEXT_psFits_WRITE_FAILED,
     301                _("Could not write data to file. CFITSIO Error: %s"),
    302302                fitsErr);
    303303        return false;
    … …  
    318318    if (fits == NULL) {
    319319        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    320                 PS_ERRORTEXT_psFits_NULL);
     320                _("The input psFits object can not NULL."));
    321321        return false;
    322322    }
    … …  
    324324    if (input == NULL) {
    325325        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    326                 PS_ERRORTEXT_psFits_IMAGE_NULL);
     326                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
    327327        return false;
    328328    }
    … …  
    334334        (void)fits_get_errstatus(status, fitsErr);
    335335        psError(PS_ERR_IO, true,
    336                 PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
     336                _("Could not determine the HDU type. CFITSIO Error: %s"),
    337337                fitsErr);
    338338        return NULL;
    … …  
    340340    if (hdutype != IMAGE_HDU) {
    341341        psError(PS_ERR_IO, true,
    342                 PS_ERRORTEXT_psFits_NOT_IMAGE_TYPE);
     342                _("Current FITS HDU type must be an image."));
    343343        return NULL;
    344344    }
    … …  
    369369        PS_TYPE_NAME(imageTypeStr,input->type.type);
    370370        psError(PS_ERR_IO, true,
    371                 PS_ERRORTEXT_psFits_IMAGE_UPDATE_TYPE_MISMATCH,
     371                _("Can not update a %s image given a %s image."),
    372372                fitsTypeStr, imageTypeStr);
    373373        return false;
    … …  
    377377    if (z >= nAxes[2]) {
    378378        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    379                 PS_ERRORTEXT_psFits_FITS_Z_SMALL,
     379                _("Current FITS HDU has %d z-planes, but z-plane %d was specified."),
    380380                nAxes[2],z);
    381381        return false;
    … …  
    412412        (void)fits_get_errstatus(status, fitsErr);
    413413        psError(PS_ERR_IO, true,
    414                 PS_ERRORTEXT_psFits_WRITE_FAILED,
     414                _("Could not write data to file. CFITSIO Error: %s"),
    415415                fitsErr);
    416416        return false;
    … …  
    429429    if (fits == NULL) {
    430430        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    431                 PS_ERRORTEXT_psFits_NULL);
     431                _("The input psFits object can not NULL."));
    432432        return NULL;
    433433    }
    … …  
    439439        (void)fits_get_errstatus(status, fitsErr);
    440440        psError(PS_ERR_IO, true,
    441                 PS_ERRORTEXT_psFits_IMAGE_DIM_UNKNOWN,
     441                _("Could not determine image dimensions. CFITSIO Error: %s"),
    442442                fitsErr);
    443443        return NULL;
    … …  
    454454            (void)fits_get_errstatus(status, fitsErr);
    455455            psError(PS_ERR_IO, true,
    456                     PS_ERRORTEXT_psFits_IMAGE_SIZE_UNKNOWN,
     456                    _("Could not determine image size. CFITSIO Error: %s"),
    457457                    fitsErr);
    458458            return NULL;
    … …  
    469469
    470470    // Bad dimensionality
    471     psError(PS_ERR_IO, true, PS_ERRORTEXT_psFits_IMAGE_DIMENSION_UNSUPPORTED, nAxis);
     471    psError(PS_ERR_IO, true, _("Image number of dimensions, %d, is not valid.  Only two or three dimensions supported for FITS I/O."), nAxis);
    472472    return NULL;
    473473}
    … …  
    477477    if (fits == NULL) {
    478478        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    479                 PS_ERRORTEXT_psFits_NULL);
     479                _("The input psFits object can not NULL."));
    480480        return false;
    481481    }
    … …  
    483483    if (input == NULL) {
    484484        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    485                 PS_ERRORTEXT_psFits_IMAGE_NULL);
     485                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
    486486        return false;
    487487    }
    488488
    489489    if (input->n == 0) {
    490         psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psFits_ARRAY_EMPTY);
     490        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("The input array was empty."));
    491491        return false;
    492492    }
    … …  
    504504        testImage = input->data[i];
    505505        if (testImage->numCols != numCols || testImage->numRows != numRows) {
    506             psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psFits_ARRAY_SIZE_DIFFER);
     506            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("The sizes of images in the array differ."));
    507507            return false;
    508508        }
    … …  
    522522                                   input->n);
    523523    if (! update) {
    524         psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_METADATA_ADD_FAILED,
     524        psError(PS_ERR_UNKNOWN, false, _("Failed to add metadata item, %s."),
    525525                "NAXIS, NAXIS1, NAXIS2, NAXIS3");
    526526        psFree(headerCopy);
    … …  
    532532    // The next are psFitsImageUpdate to write into the extension.
    533533    if (! psFitsWriteImage(fits, headerCopy, input->data[0], input->n, extname)) {
    534         psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_WRITE_PLANE_FAILED, 0);
     534        psError(PS_ERR_UNKNOWN, false, _("Could not write image plane %d."), 0);
    535535        psFree(headerCopy);
    536536        return false;
    … …  
    540540    for (int i = 1; i < input->n; i++) {
    541541        if (! psFitsUpdateImage(fits, input->data[i], 0, 0, i)) {
    542             psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_WRITE_PLANE_FAILED, i);
     542            psError(PS_ERR_UNKNOWN, false, _("Could not write image plane %d."), i);
    543543            return false;
    544544        }
    … …  
    552552    if (fits == NULL) {
    553553        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    554                 PS_ERRORTEXT_psFits_NULL);
     554                _("The input psFits object can not NULL."));
    555555        return false;
    556556    }
    … …  
    558558    if (input == NULL) {
    559559        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    560                 PS_ERRORTEXT_psFits_IMAGE_NULL);
     560                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
    561561        return false;
    562562    }
    563563
    564564    if (input->n == 0) {
    565         psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psFits_ARRAY_EMPTY);
     565        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("The input array was empty."));
    566566        return false;
    567567    }
    … …  
    569569    for (int i = 0; i < input->n; i++) {
    570570        if (! psFitsUpdateImage(fits, input->data[i], x0, y0, i)) {
    571             psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_UPDATE_PLANE_FAILED, i);
     571            psError(PS_ERR_UNKNOWN, false, _("Could not update image plane %d."), i);
    572572            return false;
    573573        }

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

    r7984 r8232  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-07-26 03:37:57 $
     9 *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2006-08-08 23:32:23 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1717#include "string.h"
    1818#include "psError.h"
    19 #include "psErrorText.h"
     19
    2020#include "psImageStructManip.h"
    2121#include "psMemory.h"
    … …  
    4141    if (fits == NULL) {
    4242        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    43                 PS_ERRORTEXT_psFits_NULL);
     43                _("The input psFits object can not NULL."));
    4444        return NULL;
    4545    }
    … …  
    5252        (void)fits_get_errstatus(status, fitsErr);
    5353        psError(PS_ERR_IO, true,
    54                 PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
     54                _("Could not determine the HDU type. CFITSIO Error: %s"),
    5555                fitsErr);
    5656        return NULL;
    … …  
    5858    if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
    5959        psError(PS_ERR_IO, true,
    60                 PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
     60                _("Current FITS HDU type must be a table."));
    6161        return NULL;
    6262    }
    … …  
    6969        (void)fits_get_errstatus(status, fitsErr);
    7070        psError(PS_ERR_IO, true,
    71                 PS_ERRORTEXT_psFits_GET_TABLE_SIZE_FAILED,
     71                _("Failed to determine the size of the current HDU table. CFITSIO Error: %s"),
    7272                fitsErr);
    7373        return NULL;
    … …  
    7878    if (row < 0 || row >= numRows) {
    7979        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    80                 PS_ERRORTEXT_psFits_ROW_INVALID,
     80                _("Specified row, %d, is not valid for current table of %d rows."),
    8181                row,numRows);
    8282        return NULL;
    … …  
    168168            (void)fits_get_errstatus(status, fitsErr);
    169169            psError(PS_ERR_IO, true,
    170                     PS_ERRORTEXT_psFits_GET_TABLE_ELEMENT,
     170                    _("Failed to retrieve table element (%d,%d). CFITSIO Error: %s"),
    171171                    col,row,fitsErr);
    172172            psFree(data);
    … …  
    187187    if (fits == NULL) {
    188188        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    189                 PS_ERRORTEXT_psFits_NULL);
     189                _("The input psFits object can not NULL."));
    190190        return NULL;
    191191    }
    … …  
    197197        (void)fits_get_errstatus(status, fitsErr);
    198198        psError(PS_ERR_IO, true,
    199                 PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
     199                _("Could not determine the HDU type. CFITSIO Error: %s"),
    200200                fitsErr);
    201201        return NULL;
    … …  
    203203    if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
    204204        psError(PS_ERR_IO, true,
    205                 PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
     205                _("Current FITS HDU type must be a table."));
    206206        return NULL;
    207207    }
    … …  
    212212        (void)fits_get_errstatus(status, fitsErr);
    213213        psError(PS_ERR_IO, true,
    214                 PS_ERRORTEXT_psFits_FIND_COLUMN,
     214                _("Specified column, %s, was not found. CFITSIO Error: %s"),
    215215                colname, fitsErr);
    216216        return NULL;
    … …  
    227227        (void)fits_get_errstatus(status, fitsErr);
    228228        psError(PS_ERR_IO, true,
    229                 PS_ERRORTEXT_psFits_GET_COLTYPE,
     229                _("Could not determine the datatype of the table column. CFITSIO Error: %s"),
    230230                fitsErr);
    231231        return NULL;
    … …  
    253253        (void)fits_get_errstatus(status, fitsErr);
    254254        psError(PS_ERR_IO, true,
    255                 PS_ERRORTEXT_psFits_TABLE_READ_COL,
     255                _("Failed to read table column. CFITSIO Error: %s"),
    256256                fitsErr);
    257257        return NULL;
    … …  
    269269    if (fits == NULL) {
    270270        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    271                 PS_ERRORTEXT_psFits_NULL);
     271                _("The input psFits object can not NULL."));
    272272        return NULL;
    273273    }
    … …  
    279279        (void)fits_get_errstatus(status, fitsErr);
    280280        psError(PS_ERR_IO, true,
    281                 PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
     281                _("Could not determine the HDU type. CFITSIO Error: %s"),
    282282                fitsErr);
    283283        return NULL;
    … …  
    285285    if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
    286286        psError(PS_ERR_IO, true,
    287                 PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
     287                _("Current FITS HDU type must be a table."));
    288288        return NULL;
    289289    }
    … …  
    294294        (void)fits_get_errstatus(status, fitsErr);
    295295        psError(PS_ERR_IO, true,
    296                 PS_ERRORTEXT_psFits_FIND_COLUMN,
     296                _("Specified column, %s, was not found. CFITSIO Error: %s"),
    297297                colname, fitsErr);
    298298        return NULL;
    … …  
    313313        (void)fits_get_errstatus(status, fitsErr);
    314314        psError(PS_ERR_IO, true,
    315                 PS_ERRORTEXT_psFits_GET_COLTYPE,
     315                _("Could not determine the datatype of the table column. CFITSIO Error: %s"),
    316316                fitsErr);
    317317        return NULL;
    … …  
    336336        (void)fits_get_errstatus(status, fitsErr);
    337337        psError(PS_ERR_IO, true,
    338                 PS_ERRORTEXT_psFits_TABLE_READ_COL,
     338                _("Failed to read table column. CFITSIO Error: %s"),
    339339                fitsErr);
    340340        return NULL;
    … …  
    351351    if (fits == NULL) {
    352352        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    353                 PS_ERRORTEXT_psFits_NULL);
     353                _("The input psFits object can not NULL."));
    354354        return NULL;
    355355    }
    … …  
    361361        (void)fits_get_errstatus(status, fitsErr);
    362362        psError(PS_ERR_IO, true,
    363                 PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
     363                _("Could not determine the HDU type. CFITSIO Error: %s"),
    364364                fitsErr);
    365365        return NULL;
    … …  
    367367    if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
    368368        psError(PS_ERR_IO, true,
    369                 PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
     369                _("Current FITS HDU type must be a table."));
    370370        return NULL;
    371371    }
    … …  
    378378        (void)fits_get_errstatus(status, fitsErr);
    379379        psError(PS_ERR_IO, true,
    380                 PS_ERRORTEXT_psFits_GET_TABLE_SIZE_FAILED,
     380                _("Failed to determine the size of the current HDU table. CFITSIO Error: %s"),
    381381                fitsErr);
    382382        return NULL;
    … …  
    488488        // no table data, what can I do?
    489489        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    490                 PS_ERRORTEXT_psFits_TABLE_EMPTY);
     490                _("Can't create a table without any rows."));
    491491        return false;
    492492    }
    … …  
    731731    if (fits == NULL) {
    732732        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    733                 PS_ERRORTEXT_psFits_NULL);
     733                _("The input psFits object can not NULL."));
    734734        return false;
    735735    }
    … …  
    737737    if (data == NULL) {
    738738        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    739                 PS_ERRORTEXT_psFits_IMAGE_NULL);
     739                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
    740740        return false;
    741741    }
    … …  
    747747        (void)fits_get_errstatus(status, fitsErr);
    748748        psError(PS_ERR_IO, true,
    749                 PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
     749                _("Could not determine the HDU type. CFITSIO Error: %s"),
    750750                fitsErr);
    751751        return false;
    … …  
    753753    if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
    754754        psError(PS_ERR_IO, true,
    755                 PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
     755                _("Current FITS HDU type must be a table."));
    756756        return false;
    757757    }
    … …  
    777777                    (void)fits_get_errstatus(status, fitsErr);
    778778                    psError(PS_ERR_IO, true,
    779                             PS_ERRORTEXT_psFits_WRITE_FAILED,
     779                            _("Could not write data to file. CFITSIO Error: %s"),
    780780                            fitsErr);
    781781                    psFree(iter);
Note: See TracChangeset for help on using the changeset viewer.