IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 8232 for trunk/psLib/src


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:
2 deleted
50 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/.cvsignore

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

  • trunk/psLib/src/Makefile.am

    r7985 r8232  
    1111
    1212
    13 EXTRA_DIST = mainpage.dox psErrorCodes_en.dat psTest.h psErrorText.h.in psErrorText_en.dat
    14 
    15 BUILT_SOURCES = psErrorText.h
    16 psErrorText.h: psErrorText_$(PS_LANG).dat
    17         $(top_srcdir)/psParseErrorCodes --data=$? $(srcdir)/psErrorText.h
     13EXTRA_DIST = mainpage.dox psErrorCodes_en.dat psTest.h
    1814
    1915pslibincludedir = $(includedir)
    … …  
    2117        psTest.h \
    2218        pslib.h \
    23         pslib_strict.h \
    24         psErrorText.h
     19        pslib_strict.h
    2520
    2621install-exec-local: libpslib.la

  • trunk/psLib/src/astro/psCoord.c

    r7914 r8232  
    1010*  @author GLG, MHPCC
    1111*
    12 *  @version $Revision: 1.121 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-07-15 02:57:12 $
     12*  @version $Revision: 1.122 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-08-08 23:32:22 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2626#include "psLogMsg.h"
    2727#include "psTrace.h"
    28 #include "psErrorText.h"
     28
    2929#include "psMatrix.h"
    3030#include "psMinimizePolyFit.h"
    … …  
    435435    default:
    436436        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    437                 PS_ERRORTEXT_psCoord_PROJECTION_TYPE_UNKNOWN,
     437                _("The projection type, %d, is unknown."),
    438438                projection->type);
    439439        psFree(out);
    … …  
    537537    default:
    538538        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    539                 PS_ERRORTEXT_psCoord_PROJECTION_TYPE_UNKNOWN,
     539                _("The projection type, %d, is unknown."),
    540540                projection->type);
    541541        psFree(out);

  • trunk/psLib/src/astro/psEarthOrientation.c

    r7766 r8232  
    88 *  @author Robert Daniel DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-06-30 02:20:06 $
     10 *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-08-08 23:32:22 $
    1212 *
    1313 *  Copyright 2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424#include "psMetadataConfig.h"
    2525#include "psError.h"
    26 #include "psErrorText.h"
     26
    2727#include "psMemory.h"
    2828#include "psCoord.h"
    … …  
    103103                                            "psLib.eoc.precession.table.format");
    104104    if(! success || tableFormat == NULL) {
    105         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     105        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    106106                "psLib.eoc.precession.table.format");
    107107        return false;
    … …  
    112112    if(! success || xTableName == NULL) {
    113113        psFree(tableFormat);
    114         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     114        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    115115                "psLib.eoc.precession.x.file");
    116116        return false;
    … …  
    122122        psFree(tableFormat);
    123123        psFree(xTableName);
    124         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     124        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    125125                "psLib.eoc.precession.y.file");
    126126        return false;
    … …  
    133133        psFree(xTableName);
    134134        psFree(yTableName);
    135         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     135        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    136136                "psLib.eoc.precession.s.file");
    137137        return false;
    … …  
    145145        psFree(yTableName);
    146146        psFree(sTableName);
    147         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     147        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    148148                "psLib.eoc.precession.iers.file");
    149149        return false;
    … …  
    158158        psFree(sTableName);
    159159        psFree(iersTableName);
    160         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     160        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    161161                "psLib.eoc.precession.finals.file");
    162162        return false;
    … …  
    172172        psFree(iersTableName);
    173173        psFree(finalsTableName);
    174         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     174        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    175175                "psLib.eoc.precession.iers.table.format");
    176176        return false;
    … …  
    187187        psFree(finalsTableName);
    188188        psFree(iersTableFormat);
    189         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     189        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    190190                "psLib.eoc.precession.iers.table.format");
    191191        return false;
    … …  
    214214    psVector* xCoeff = psMetadataLookupPtr(&success, eocMetadata, "psLib.eoc.precession.poly.x");
    215215    if(! success || xCoeff == NULL || xCoeff->type.type != PS_TYPE_F64) {
    216         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     216        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    217217                "psLib.eoc.precession.poly.x");
    218218        return false;
    … …  
    221221    if(! success || yCoeff == NULL || yCoeff->type.type != PS_TYPE_F64) {
    222222        psFree(xCoeff);
    223         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     223        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    224224                "psLib.eoc.precession.poly.y");
    225225        return false;
    … …  
    229229        psFree(xCoeff);
    230230        psFree(yCoeff);
    231         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     231        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    232232                "psLib.eoc.precession.poly.s");
    233233        return false;

  • trunk/psLib/src/astro/psSphereOps.c

    r7914 r8232  
    88 *  @author Dave Robbins, MHPCC
    99 *
    10  *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-07-15 02:57:12 $
     10 *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-08-08 23:32:22 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2525#include "psError.h"
    2626#include "psLogMsg.h"
    27 #include "psErrorText.h"
     27
    2828
    2929
    … …  
    225225    // Check the specified MJD is greater than 1900
    226226    if ( MJD < MJD_1900 ) {
    227         psError(PS_ERR_BAD_PARAMETER_TYPE,true,PS_ERRORTEXT_psCoord_INVALID_MJD);
     227        psError(PS_ERR_BAD_PARAMETER_TYPE,true,_("Specified time is less than 1900."));
    228228        return NULL;
    229229    }
    … …  
    252252    // Check the specified MJD is greater than 1900
    253253    if ( MJD < MJD_1900 ) {
    254         psError(PS_ERR_BAD_PARAMETER_TYPE,true,PS_ERRORTEXT_psCoord_INVALID_MJD);
     254        psError(PS_ERR_BAD_PARAMETER_TYPE,true,_("Specified time is less than 1900."));
    255255        return NULL;
    256256    }
    … …  
    361361        else {
    362362            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    363                     PS_ERRORTEXT_psCoord_UNITS_UNKNOWN,
     363                    _("Specified units, 0x%x, is not supported."),
    364364                    unit);
    365365            psFree(tmp);
    … …  
    370370    } else {
    371371        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    372                 PS_ERRORTEXT_psCoord_OFFSET_MODE_UNKNOWN,
     372                _("Specified offset mode, 0x%x, is not supported."),
    373373                mode);
    374374        psFree(tmp);
    … …  
    432432        } else {
    433433            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    434                     PS_ERRORTEXT_psCoord_UNITS_UNKNOWN,
     434                    _("Specified units, 0x%x, is not supported."),
    435435                    unit);
    436436            return NULL;
    … …  
    451451    } else {
    452452        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    453                 PS_ERRORTEXT_psCoord_OFFSET_MODE_UNKNOWN,
     453                _("Specified offset mode, 0x%x, is not supported."),
    454454                mode);
    455455        return NULL;

  • trunk/psLib/src/astro/psTime.c

    r7961 r8232  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.92 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-07-25 01:16:04 $
     12 *  @version $Revision: 1.93 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-08-08 23:32:22 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3333#include "psLookupTable.h"
    3434#include "psAssert.h"
    35 #include "psErrorText.h"
     35
    3636
    3737#include "config.h"
    … …  
    205205        // Check if table not a metadata item
    206206        if(tableMetadataItem == NULL) {
    207             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     207            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    208208                    tableName);
    209209            *status = PS_LOOKUP_ERROR;
    … …  
    282282    if(metadataItem == NULL) {
    283283        p_psMemAllocatePersistent(initialPersistence);
    284         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     284        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    285285                "psLib.time.tables.n");
    286286        return false;
    … …  
    292292    if(metadataItem == NULL) {
    293293        p_psMemAllocatePersistent(initialPersistence);
    294         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     294        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    295295                "psLib.time.tables.from");
    296296        return false;
    … …  
    299299    if(tablesFrom->n != numTables) {
    300300        p_psMemAllocatePersistent(initialPersistence);
    301         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_BAD_VECTOR, tablesFrom->n, numTables);
     301        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Incorrect vector size. Size: %d, Expected %d."), tablesFrom->n, numTables);
    302302        psFree(tablesFrom);
    303303        return false;
    … …  
    308308    if(metadataItem == NULL) {
    309309        p_psMemAllocatePersistent(initialPersistence);
    310         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     310        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    311311                "psLib.time.tables.to");
    312312        psFree(tablesFrom);
    … …  
    316316    if(tablesTo->n != numTables) {
    317317        p_psMemAllocatePersistent(initialPersistence);
    318         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_BAD_VECTOR, tablesTo->n, numTables);
     318        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Incorrect vector size. Size: %d, Expected %d."), tablesTo->n, numTables);
    319319        psFree(tablesFrom);
    320320        psFree(tablesTo);
    … …  
    326326    if(metadataItem == NULL) {
    327327        p_psMemAllocatePersistent(initialPersistence);
    328         psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     328        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Failed find '%s' in time metadata."),
    329329                "psLib.time.tables.index");
    330330        psFree(tablesFrom);
    … …  
    335335    if(tablesIndex->n != numTables) {
    336336        p_psMemAllocatePersistent(initialPersistence);
    337         psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_BAD_VECTOR,tablesIndex->n,numTables);
     337        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Incorrect vector size. Size: %d, Expected %d."),tablesIndex->n,numTables);
    338338        psFree(tablesFrom);
    339339        psFree(tablesTo);
    … …  
    346346    if(metadataItem == NULL) {
    347347        p_psMemAllocatePersistent(initialPersistence);
    348         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     348        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    349349                "psLib.time.tables.dir");
    350350        psFree(tablesFrom);
    … …  
    359359    if(metadataItem == NULL) {
    360360        p_psMemAllocatePersistent(initialPersistence);
    361         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     361        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    362362                "psLib.time.tables.files");
    363363
    … …  
    374374    if(metadataItem == NULL) {
    375375        p_psMemAllocatePersistent(initialPersistence);
    376         psError(PS_ERR_BAD_PARAMETER_VALUE,true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     376        psError(PS_ERR_BAD_PARAMETER_VALUE,true, _("Failed find '%s' in time metadata."),
    377377                "psLib.time.tables.format");
    378378        psFree(tablesFrom);
    … …  
    404404        tableFormat = getToken(&formatPtr,",",&status);
    405405        if(tableFormat == NULL) {
    406             psError(PS_ERR_BAD_PARAMETER_VALUE,no_problem,PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     406            psError(PS_ERR_BAD_PARAMETER_VALUE,no_problem,_("Failed find '%s' in time metadata."),
    407407                    "psLib.time.tables.format");
    408408            no_problem = false;
    … …  
    415415        } else {
    416416            psError(PS_ERR_BAD_PARAMETER_VALUE, no_problem,
    417                     PS_ERRORTEXT_psTime_BAD_TABLE_COUNT, i+1, numTables);
     417                    _("Incorrect number of table files entered. Found: %d. Expected: %d."), i+1, numTables);
    418418            no_problem = false;
    419419        }
    … …  
    429429            } else if(foundTable==false && j==numTables-1) {
    430430                psError(PS_ERR_BAD_PARAMETER_VALUE, no_problem,
    431                         PS_ERRORTEXT_psTime_BAD_TABLE_COUNT, j, numTables);
     431                        _("Incorrect number of table files entered. Found: %d. Expected: %d."), j, numTables);
    432432                no_problem = false;
    433433            }
    … …  
    444444
    445445    if(numTables != i) {
    446         psError(PS_ERR_BAD_PARAMETER_VALUE, no_problem, PS_ERRORTEXT_psTime_BAD_TABLE_COUNT, i, numTables);
     446        psError(PS_ERR_BAD_PARAMETER_VALUE, no_problem, _("Incorrect number of table files entered. Found: %d. Expected: %d."), i, numTables);
    447447    }
    448448
    … …  
    480480            type!=PS_TIME_TT) {
    481481        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    482                 PS_ERRORTEXT_psTime_TYPE_UNKNOWN,
     482                _("Specified type, %d, is not supported."),
    483483                type);
    484484        return NULL;
    … …  
    521521    if (gettimeofday(&now, 0) == -1) {
    522522        psError(PS_ERR_OS_CALL_FAILED, true,
    523                 PS_ERRORTEXT_psTime_GET_TOD_FAILED);
     523                _("Failed to determine the current time from gettimeofday function."));
    524524        return NULL;
    525525    }
    … …  
    728728            // Convert from TAI to unknown time type
    729729        } else {
    730             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_UNKNOWN, type);
     730            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is not supported."), type);
    731731            return NULL;
    732732        }
    … …  
    753753            // Convert from TT to unknown time type
    754754        } else {
    755             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_UNKNOWN, type);
     755            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is not supported."), type);
    756756            return NULL;
    757757        }
    … …  
    772772            // Convert UTC to unknown time type
    773773        } else {
    774             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_UNKNOWN, type);
     774            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is not supported."), type);
    775775            return NULL;
    776776        }
    777777        // Convert unknown time type
    778778    } else {
    779         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_UNKNOWN, time->type);
     779        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is not supported."), time->type);
    780780        return NULL;
    781781    }
    … …  
    810810    // Verify input time is not in UT1 seconds
    811811    if(time->type == PS_TIME_UT1) {
    812         psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_TYPE_INCORRECT,time->type);
     812        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Specified type, %d, is incorrect."),time->type);
    813813        return NAN;
    814814    }
    … …  
    897897
    898898        // Date too early for tables. Get default time delta value from metadata, and issue warning.
    899         psLogMsg(__func__,PS_LOG_WARN,PS_ERRORTEXT_psTime_TIME_PREDATES_TABLES,mjd,"UT1-UTC");
     899        psLogMsg(__func__,PS_LOG_WARN,_("Specified psTime predates (%g) all tables of %s information."),mjd,"UT1-UTC");
    900900
    901901        // Lookup value from time metadata loaded from pslib.config
    902902        tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.before.dut");
    903903        if(tableMetadataItem == NULL) {
    904             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     904            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    905905                    "psLib.time.before.dut");
    906906            return NAN;
    … …  
    917917        */
    918918        // Generate warning of postdate information
    919         psLogMsg(__func__,PS_LOG_WARN,PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLES, mjd, "UT1-UTC");
     919        psLogMsg(__func__,PS_LOG_WARN,_("Specified psTime postdates (%g) all tables of %s information."), mjd, "UT1-UTC");
    920920
    921921        // Lookup values to calculate prediction
    922922        tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.predict.dut");
    923923        if(tableMetadataItem == NULL) {
    924             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     924            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    925925                    "psLib.time.predict.dut");
    926926            return NAN;
    … …  
    935935
    936936    } else if(status != PS_LOOKUP_SUCCESS) {
    937         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_INTERPOLATION_FAILED);
     937        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed time table interpolation."));
    938938        return NAN;
    939939    }
    … …  
    10591059
    10601060    if(time->type != PS_TIME_TAI) {
    1061         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_INCORRECT, time->type);
     1061        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is incorrect."), time->type);
    10621062        return NULL;
    10631063    }
    … …  
    10751075        // Date too earlier for tables. Get default polar coodinate values from metadata, and issue warning.
    10761076        #if 0
    1077         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TIME_PREDATES_TABLES, mjd, "polar motion");
     1077        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified psTime predates (%g) all tables of %s information."), mjd, "polar motion");
    10781078        return NULL;
    10791079        #else
    10801080
    1081         psLogMsg(PS_FILE_LINE, PS_LOG_ERROR, PS_ERRORTEXT_psTime_TIME_PREDATES_TABLES, mjd, "polar motion");
     1081        psLogMsg(PS_FILE_LINE, PS_LOG_ERROR, _("Specified psTime predates (%g) all tables of %s information."), mjd, "polar motion");
    10821082        #endif
    10831083
    … …  
    10851085        if(tableMetadataItem == NULL) {
    10861086            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    1087                     PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "psLib.time.before.xp");
     1087                    _("Failed find '%s' in time metadata."), "psLib.time.before.xp");
    10881088            return NULL;
    10891089        }
    … …  
    10921092        tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.before.yp");
    10931093        if(tableMetadataItem == NULL) {
    1094             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "psLib.time.before.yp");
     1094            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."), "psLib.time.before.yp");
    10951095            return NULL;
    10961096        }
    … …  
    11101110        #if 0
    11111111        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    1112                 PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLES, mjd, "polar motion");
     1112                _("Specified psTime postdates (%g) all tables of %s information."), mjd, "polar motion");
    11131113        return NULL;
    11141114        #else
    11151115
    11161116        psLogMsg(PS_FILE_LINE, PS_LOG_ERROR,
    1117                  PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLES, mjd, "polar motion");
     1117                 _("Specified psTime postdates (%g) all tables of %s information."), mjd, "polar motion");
    11181118        #endif
    11191119
    … …  
    11211121        tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.predict.mjd");
    11221122        if(tableMetadataItem == NULL) {
    1123             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
     1123            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
    11241124                    "psLib.time.predict.mjd");
    11251125            return NULL;
    … …  
    11301130        tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.predict.xp");
    11311131        if(tableMetadataItem == NULL) {
    1132             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "psLib.time.predict.xp");
     1132            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."), "psLib.time.predict.xp");
    11331133            return NULL;
    11341134        }
    … …  
    11391139        tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.predict.yp");
    11401140        if(tableMetadataItem == NULL) {
    1141             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "psLib.time.predict.yp");
     1141            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."), "psLib.time.predict.yp");
    11421142            return NULL;
    11431143        }
    … …  
    11631163
    11641164    } else if(xStatus!=PS_LOOKUP_SUCCESS || yStatus!=PS_LOOKUP_SUCCESS) {
    1165         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_INTERPOLATION_FAILED);
     1165        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed time table interpolation."));
    11661166        return NULL;
    11671167    }
    … …  
    11931193    // Check if psTime tables are loaded/loadable
    11941194    if(!p_psTimeInit(p_psGetConfigFileName())) {
    1195         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_FILE_NOT_FOUND,
     1195        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed to open file %s."),
    11961196                p_psGetConfigFileName());
    11971197        return NAN;
    … …  
    12011201    tableMetadataItem = psMetadataLookup(timeMetadata, "taiTable");
    12021202    if(tableMetadataItem == NULL) {
    1203         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "taiTable");
     1203        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."), "taiTable");
    12041204        return NAN;
    12051205    }
    … …  
    12281228    // Check for successful interpolation
    12291229    if(results == NULL) {
    1230         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_INTERPOLATION_FAILED);
     1230        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed time table interpolation."));
    12311231        return NAN;
    12321232    }
    … …  
    12731273    // Verify time is UTC type
    12741274    if(utc->type != PS_TIME_UTC) {
    1275         psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_TYPE_INCORRECT,utc->type);
     1275        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Specified type, %d, is incorrect."),utc->type);
    12761276        return false;
    12771277    }
    … …  
    13711371    // Converts psTime to YYYY-MM-DDThh:mm:ss.sss in string form
    13721372    if (!strftime(tempString, MAX_TIME_STRING_LENGTH, "%Y-%m-%dT%H:%M:%S", tmTime)) {
    1373         psError(PS_ERR_OS_CALL_FAILED, true, PS_ERRORTEXT_psTime_CONVERT_TIME_TO_STRING_FAILED);
     1373        psError(PS_ERR_OS_CALL_FAILED, true, _("Failed to convert a time via strftime function."));
    13741374        return NULL;
    13751375    }
    … …  
    13851385    // Create string with milliseconds
    13861386    if (snprintf(timeString, MAX_TIME_STRING_LENGTH, "%s.%1dZ", tempString, ds) < 0) {
    1387         psError(PS_ERR_OS_CALL_FAILED, true, PS_ERRORTEXT_psTime_APPEND_MSEC_FAILED);
     1387        psError(PS_ERR_OS_CALL_FAILED, true, _("Failed to append millisecond to time string with snprintf function."));
    13881388        return NULL;
    13891389    }
    … …  
    15011501    if (sscanf(input, "%d-%d-%dT%d:%d:%d.%d", &tmTime.tm_year, &tmTime.tm_mon, &tmTime.tm_mday,
    15021502               &tmTime.tm_hour, &tmTime.tm_min, &tmTime.tm_sec,&millisecond) < 7) {
    1503         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_ISOTIME_MALFORMED, input);
     1503        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified ISO Time string, '%s', is malformed.  Must be in 'YYYY-MM-DDThh:mm:ss.sss' format."), input);
    15041504        return NULL;
    15051505    }
    … …  
    17601760    // Verify both times of the same type
    17611761    if(time1->type != time2->type) {
    1762         psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_TYPE_INCORRECT,time1->type);
     1762        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Specified type, %d, is incorrect."),time1->type);
    17631763        return NAN;
    17641764    }

  • trunk/psLib/src/db/psDB.c

    r8116 r8232  
    1212 *  @author Joshua Hoblitt
    1313 *
    14  *  @version $Revision: 1.77 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-08-04 03:50:56 $
     14 *  @version $Revision: 1.78 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-08-08 23:32:22 $
    1616 *
    1717 *  Copyright (C) 2005-2006  Joshua Hoblitt, University of Hawaii
    … …  
    3737#include "psError.h"
    3838#include "psString.h"
    39 #include "psErrorText.h"
     39
    4040
    4141// set the pointer to NULL if we are actually freeing the memory
    … …  
    142142    if (!mysql_real_connect(mysql, host, user, passwd, dbname, 0, NULL, 0)) {
    143143        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    144                 PS_ERRORTEXT_psDB_FAILED_TO_CONNECT,mysql_error(mysql));
     144                _("Failed to connect to database.  Error: %s"),mysql_error(mysql));
    145145
    146146        mysql_close(mysql);
    … …  
    247247    // Attempt to select new database
    248248    if (mysql_select_db(dbh->mysql, dbname) != 0) {
    249         psError(PS_ERR_UNKNOWN, true, PS_ERRORTEXT_psDB_FAILED_TO_CHANGE,
     249        psError(PS_ERR_UNKNOWN, true, _("Failed to change database.  Error: %s"),
    250250                mysql_error(dbh->mysql));
    251251
    … …  
    287287    char *query = psDBGenerateCreateTableSQL(tableName, md);
    288288    if (!query) {
    289         psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
     289        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
    290290        return false;
    291291    }
    … …  
    294294    bool status = p_psDBRunQuery(dbh, query);
    295295    if (!status) {
    296         psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psDB_TABLE_CREATE_FAIL);
     296        psError(PS_ERR_UNKNOWN, false, _("Failed to create table."));
    297297    }
    298298
    … …  
    315315    bool status = p_psDBRunQuery(dbh, query);
    316316    if (!status) {
    317         psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psDB_TABLE_DROP_FAIL);
     317        psError(PS_ERR_UNKNOWN, false, _("Failed to drop table."));
    318318    }
    319319
    … …  
    343343    char *query = psDBGenerateSelectRowSQL(tableName, col, NULL, limit);
    344344    if (!query) {
    345         psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
     345        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
    346346        return NULL;
    347347    }
    … …  
    349349    // Execut SQL query string
    350350    if (!p_psDBRunQuery(dbh, query)) {
    351         psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psDB_SEL_COL_FAIL);
     351        psError(PS_ERR_UNKNOWN, false, _("Failed to select column."));
    352352        psFree(query);
    353353        return NULL;
    … …  
    365365        // then something bad has happened.
    366366        if (fieldCount != 0) {
    367             psError(PS_ERR_UNEXPECTED_NULL, true, PS_ERRORTEXT_psDB_QUERY_NO_DATA,
     367            psError(PS_ERR_UNEXPECTED_NULL, true, _("Query returned no data.  Error: %s"),
    368368                    mysql_error(dbh->mysql));
    369369            return NULL;
    … …  
    561561    // Execute function to insert rows
    562562    if (!psDBInsertRows(dbh, tableName, rowSet)) {
    563         psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psDB_INSERT_ROW_FAIL);
     563        psError(PS_ERR_UNKNOWN, false, _("Failed to insert row."));
    564564        psFree(rowSet);
    565565        return false;
    … …  
    586586    char *query = psDBGenerateInsertRowSQL(tableName, row);
    587587    if (!query) {
    588         psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
     588        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
    589589        return false;
    590590    }
    … …  
    675675    char *query = psDBGenerateUpdateRowSQL(tableName, where, values);
    676676    if (!query) {
    677         psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
     677        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
    678678        return -1;
    679679    }
    … …  
    801801                "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'null) WHERE' at line 1", 165);
    802802        if ( !strncmp(mysql_error(dbh->mysql), mysqlTemp, 145) ) {
    803             psError(PS_ERR_UNKNOWN, true, PS_ERRORTEXT_psDB_SQL_QUERY_FAIL, mysqlTemp);
     803            psError(PS_ERR_UNKNOWN, true, _("Failed to execute SQL query.  Error: %s"), mysqlTemp);
    804804        } else {
    805             psError(PS_ERR_UNKNOWN, true, PS_ERRORTEXT_psDB_SQL_QUERY_FAIL, mysql_error(dbh->mysql));
     805            psError(PS_ERR_UNKNOWN, true, _("Failed to execute SQL query.  Error: %s"), mysql_error(dbh->mysql));
    806806        }
    807807        psFree(query);
    … …  
    14051405    setSQL = psDBGenerateSetSQL(values);
    14061406    if (!setSQL) {
    1407         psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_SQL_SUBSTR_FAIL);
     1407        psError(PS_ERR_UNEXPECTED_NULL, false, _("SQL substring generation failed."));
    14081408        return NULL;
    14091409    }
    … …  
    14121412    whereSQL = psDBGenerateWhereSQL(where);
    14131413    if (!whereSQL) {
    1414         psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_SQL_SUBSTR_FAIL);
     1414        psError(PS_ERR_UNEXPECTED_NULL, false, _("SQL substring generation failed."));
    14151415        return NULL;
    14161416    }
    … …  
    14431443    whereSQL = psDBGenerateWhereSQL(where);
    14441444    if (!whereSQL) {
    1445         psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_SQL_SUBSTR_FAIL);
     1445        psError(PS_ERR_UNEXPECTED_NULL, false, _("SQL substring generation failed."));
    14461446        return NULL;
    14471447    }

  • trunk/psLib/src/fft/psImageFFT.c

    r4543 r8232  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2005-07-12 19:30:18 $
     7 *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2006-08-08 23:32:23 $
    99 *
    1010 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2121#include "psImageStructManip.h"
    2222
    23 #include "psErrorText.h"
     23
    2424
    2525#define PS_FFTW_PLAN_RIGOR FFTW_ESTIMATE
    … …  
    4343        if ((direction & PS_FFT_REVERSE) != 0) {
    4444            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    45                     PS_ERRORTEXT_psImageFFT_FORWARD_REVERSE);
     45                    _("Can not specify both PS_FFT_FORWARD and PS_FFT_REVERSE options."));
    4646            psFree(out);
    4747            return NULL;
    … …  
    4949        if ((direction & PS_FFT_REAL_RESULT) != 0) {
    5050            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    51                     PS_ERRORTEXT_psImageFFT_REAL_FORWARD_NOTSUPPORTED);
     51                    _("The PS_FFT_FORWARD and PS_FFT_REAL_RESULT combinition is not supported."));
    5252            psFree(out);
    5353            return NULL;
    … …  
    5555    } else if ((direction & PS_FFT_REVERSE) == 0) {
    5656        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    57                 PS_ERRORTEXT_psImageFFT_NO_DIRECTION_OPTION);
     57                _("Must specify either PS_FFT_FORWARD or PS_FFT_REVERSE option."));
    5858        psFree(out);
    5959        return NULL;
    … …  
    8686    if (plan == NULL) {
    8787        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    88                 PS_ERRORTEXT_psImageFFT_FFTW_PLAN_NULL);
     88                _("Could not create a valid FFT plan to perform the transform."));
    8989        psFree(out);
    9090        return NULL;
    … …  
    179179        PS_TYPE_NAME(typeStr,type);
    180180        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    181                 PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     181                _("Specified psImage type, %s, is not supported."),
    182182                typeStr);
    183183
    … …  
    241241        PS_TYPE_NAME(typeStr,type);
    242242        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    243                 PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     243                _("Specified psImage type, %s, is not supported."),
    244244                typeStr);
    245245        psFree(out);
    … …  
    271271        PS_TYPE_NAME(typeStrImag,imag->type.type);
    272272        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    273                 PS_ERRORTEXT_psImageFFT_REAL_IMAG_TYPE_MISMATCH,
     273                _("Real psImage type (%s) and imaginary psImage type (%s) must be the same."),
    274274                typeStrReal,typeStrImag);
    275275        psFree(out);
    … …  
    279279    if (imag->numCols != numCols || imag->numRows != numRows) {
    280280        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    281                 PS_ERRORTEXT_psImageFFT_REAL_IMAG_SIZE_MISMATCH,
     281                _("Real psImage size (%dx%d) and imaginary psImage size (%dx%d) must be the same."),
    282282                numCols, numRows, imag->numCols, imag->numRows);
    283283        psFree(out);
    … …  
    320320        PS_TYPE_NAME(typeStr,type);
    321321        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    322                 PS_ERRORTEXT_psImageFFT_NONREAL_NOTSUPPORTED,
     322                _("Input psImage type, %s, is required to be either psF32 or psF64."),
    323323                typeStr);
    324324        psFree(out);
    … …  
    380380        PS_TYPE_NAME(typeStr,type);
    381381        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    382                 PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED,
     382                _("Input psImage type, %s, is required to be either psC32 or psC64."),
    383383                typeStr);
    384384        psFree(out);
    … …  
    446446        PS_TYPE_NAME(typeStr,type);
    447447        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    448                 PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED,
     448                _("Input psImage type, %s, is required to be either psC32 or psC64."),
    449449                typeStr);
    450450        psFree(out);

  • trunk/psLib/src/fft/psVectorFFT.c

    r4540 r8232  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2005-07-12 19:12:01 $
     7 *  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2006-08-08 23:32:23 $
    99 *
    1010 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2222#include "psLogMsg.h"
    2323
    24 #include "psErrorText.h"
     24
    2525
    2626#define P_FFTW_PLAN_RIGOR FFTW_ESTIMATE
    … …  
    6363    } else {
    6464        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    65                 PS_ERRORTEXT_psVectorFFT_DIRECTION_NOTSET);
     65                _("Must specify the direction as either PS_FFT_FORWARD or PS_FFT_REVERSE."));
    6666        psFree(out);
    6767        return NULL;
    … …  
    7171    if (plan == NULL) {
    7272        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    73                 PS_ERRORTEXT_psVectorFFT_FFTW_PLAN_NULL);
     73                _("Could not create a valid FFT plan to perform the transform."));
    7474        psFree(out);
    7575        return NULL;
    … …  
    142142        PS_TYPE_NAME(typeStr,type);
    143143        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    144                 PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED,
     144                _("Specified psVector type, %s, is not supported."),
    145145                typeStr);
    146146        psFree(out);
    … …  
    201201        PS_TYPE_NAME(typeStr,type);
    202202        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    203                 PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED,
     203                _("Specified psVector type, %s, is not supported."),
    204204                typeStr);
    205205        psFree(out);
    … …  
    233233        PS_TYPE_NAME(typeStrImag,imag->type.type);
    234234        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    235                 PS_ERRORTEXT_psVectorFFT_REAL_IMAG_TYPE_MISMATCH,
     235                _("Real psVector type, %s, and imaginary psVector type, %s, must be the same."),
    236236                typeStrReal,typeStrImag);
    237237        psFree(out);
    … …  
    267267        PS_TYPE_NAME(typeStr,type);
    268268        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    269                 PS_ERRORTEXT_psVectorFFT_NONREAL_NOTSUPPORTED,
     269                _("Input psVector type, %s, is required to be either psF32 or psF64."),
    270270                typeStr);
    271271        psFree(out);
    … …  
    327327        PS_TYPE_NAME(typeStr,type);
    328328        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    329                 PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED,
     329                _("Input psVector type, %s, is required to be either psC32 or psC64."),
    330330                typeStr);
    331331        psFree(out);
    … …  
    407407        PS_TYPE_NAME(typeStr,type);
    408408        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    409                 PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED,
     409                _("Input psVector type, %s, is required to be either psC32 or psC64."),
    410410                typeStr);
    411411        psFree(out);

  • 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);

  • trunk/psLib/src/imageops/psImageConvolve.c

    r7914 r8232  
    55 *  @author Robert DeSonia, MHPCC
    66 *
    7  *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
    8  *  @date $Date: 2006-07-15 02:57:12 $
     7 *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
     8 *  @date $Date: 2006-08-08 23:32:23 $
    99 *
    1010 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2121#include "psError.h"
    2222
    23 #include "psErrorText.h"
     23
    2424
    2525#define FOURIER_PADDING 32 /* padding amount in every side of the image for fourier convolution */
    … …  
    120120    if (tShifts == NULL || xShifts == NULL || yShifts == NULL) {
    121121        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    122                 PS_ERRORTEXT_psImageConvolve_SHIFT_NULL);
     122                _("Specified shift vectors can not be NULL."));
    123123        return NULL;
    124124    }
    … …  
    134134        PS_TYPE_NAME(typeTStr,tShifts->type.type);
    135135        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    136                 PS_ERRORTEXT_psImageConvolve_SHIFT_TYPE_MISMATCH,
     136                _("Input t-, x-, and y-shift vector types (%s/%s/%s) must match."),
    137137                typeTStr, typeXStr, typeYStr);
    138138        return NULL;
    … …  
    257257                PS_TYPE_NAME(typeStr,xShifts->type.type);
    258258                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    259                         PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     259                        _("Specified psImage type, %s, is not supported."),
    260260                        typeStr);
    261261            }
    … …  
    280280                PS_TYPE_NAME(typeStr,xShifts->type.type);
    281281                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    282                         PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     282                        _("Specified psImage type, %s, is not supported."),
    283283                        typeStr);
    284284            }
    … …  
    301301    if (kernel == NULL) {
    302302        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    303                 PS_ERRORTEXT_psImageConvolve_KERNEL_NULL);
     303                _("Specified psKernel can not be NULL."));
    304304        psFree(out);
    305305        return NULL;
    … …  
    361361                PS_TYPE_NAME(typeStr,in->type.type);
    362362                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    363                         PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     363                        _("Specified psImage type, %s, is not supported."),
    364364                        typeStr);
    365365                psFree(out);
    … …  
    380380        if (kRows >= numRows || kCols >= numCols) {
    381381            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    382                     PS_ERRORTEXT_psImageConvolve_KERNEL_TOO_LARGE,
     382                    _("Specified psKernel size, %dx%d, can not be larger than input psImage size, %dx%d."),
    383383                    kCols,kRows,
    384384                    numCols, numRows);
    … …  
    434434        if (kernelFourier == NULL) {
    435435            psError(PS_ERR_UNKNOWN, false,
    436                     PS_ERRORTEXT_psImageConvolve_KERNEL_FFT_FAILED);
     436                    _("Failed to perform a fourier transform of kernel."));
    437437            psFree(out);
    438438            return NULL;
    … …  
    442442        if (inFourier == NULL) {
    443443            psError(PS_ERR_UNKNOWN, false,
    444                     PS_ERRORTEXT_psImageConvolve_FFT_FAILED);
     444                    _("Failed to perform a fourier transform of input image."));
    445445            psFree(out);
    446446            return NULL;
    … …  
    460460        if (complexOut == NULL) {
    461461            psError(PS_ERR_UNKNOWN, false,
    462                     PS_ERRORTEXT_psImageConvolve_FFT_FAILED);
     462                    _("Failed to perform a fourier transform of input image."));
    463463            psFree(out);
    464464            return NULL;
    … …  
    665665            PS_TYPE_NAME(typeStr,image->type.type);
    666666            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    667                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     667                    _("Specified psImage type, %s, is not supported."),
    668668                    typeStr);
    669669            return false;

  • trunk/psLib/src/imageops/psImageGeomManip.c

    r7999 r8232  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-07-28 00:44:05 $
     12 *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-08-08 23:32:23 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3030#include "psMemory.h"
    3131#include "psAssert.h"
    32 #include "psErrorText.h"
     32
    3333#include "psCoord.h"
    3434
    … …  
    5151    if (in == NULL) {
    5252        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    53                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     53                _("Can not operate on a NULL psImage."));
    5454        psFree(out);
    5555        return NULL;
    … …  
    5858    if (scale < 1) {
    5959        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    60                 PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE,
     60                _("Specified scale value, %d, must be a positive value."),
    6161                scale);
    6262        psFree(out);
    … …  
    6666    if (stats == NULL) {
    6767        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    68                 PS_ERRORTEXT_psImage_STAT_NULL);
     68                _("Specified statistic can not be NULL."));
    6969        psFree(out);
    7070        return NULL;
    … …  
    7474    if (statistic == 0) {
    7575        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    76                 PS_ERRORTEXT_psImage_BAD_STAT,
     76                _("Specified statistic option, %d, is not valid.  Must specify one and only one statistic type."),
    7777                stats->options);
    7878        psFree(out);
    … …  
    8787            PS_TYPE_NAME(typeStr,mask->type.type);
    8888            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    89                     PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     89                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    9090                    typeStr, PS_TYPE_MASK_NAME);
    9191            psFree(out);
    … …  
    159159            PS_TYPE_NAME(typeStr,in->type.type);
    160160            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    161                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     161                    _("Specified psImage type, %s, is not supported."),
    162162                    typeStr);
    163163            psFree(out);
    … …  
    184184    if (in == NULL) {
    185185        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    186                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     186                _("Can not operate on a NULL psImage."));
    187187        psFree(out);
    188188        return NULL;
    … …  
    191191    if (scale < 1) {
    192192        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    193                 PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE,
     193                _("Specified scale value, %d, must be a positive value."),
    194194                scale);
    195195        psFree(out);
    … …  
    199199    if (mode > PS_INTERPOLATE_LANCZOS4_VARIANCE ) {
    200200        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    201                 PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
     201                _("Specified interpolation mode, %d, is unsupported."),
    202202                mode);
    203203        psFree(out);
    … …  
    241241            PS_TYPE_NAME(typeStr,in->type.type);
    242242            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    243                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     243                    _("Specified psImage type, %s, is not supported."),
    244244                    typeStr);
    245245            psFree(out);
    … …  
    262262    if (input == NULL) {
    263263        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    264                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     264                _("Can not operate on a NULL psImage."));
    265265        psFree(out);
    266266        return NULL;
    … …  
    311311    if (input == NULL) {
    312312        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    313                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     313                _("Can not operate on a NULL psImage."));
    314314        psFree(out);
    315315        return NULL;
    … …  
    357357                PS_TYPE_NAME(typeStr,type);
    358358                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    359                         PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     359                        _("Specified psImage type, %s, is not supported."),
    360360                        typeStr);
    361361                psFree(out);
    … …  
    403403                PS_TYPE_NAME(typeStr,type);
    404404                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    405                         PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     405                        _("Specified psImage type, %s, is not supported."),
    406406                        typeStr);
    407407                psFree(out);
    … …  
    448448                PS_TYPE_NAME(typeStr,type);
    449449                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    450                         PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     450                        _("Specified psImage type, %s, is not supported."),
    451451                        typeStr);
    452452                psFree(out);
    … …  
    503503                    cimag(exposed) > PS_MAX_##TYPE) { \
    504504                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    505                         PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
     505                        _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
    506506                        "exposed", \
    507507                        creal(exposed),cimag(exposed), \
    … …  
    570570                PS_TYPE_NAME(typeStr,type); \
    571571                psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    572                         PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
     572                        _("Specified psImage type, %s, is not supported."), \
    573573                        typeStr); \
    574574                psFree(out); \
    … …  
    584584        default:
    585585            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    586                     PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
     586                    _("Specified interpolation mode, %d, is unsupported."),
    587587                    mode);
    588588            psFree(out);
    … …  
    608608    if (input == NULL) {
    609609        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    610                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     610                _("Can not operate on a NULL psImage."));
    611611        psFree(out);
    612612        return NULL;
    … …  
    627627            cimag(exposed) > PS_MAX_##TYPE) { \
    628628        psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    629                 PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
     629                _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
    630630                "exposed", \
    631631                creal(exposed),cimag(exposed), \
    … …  
    666666            PS_TYPE_NAME(typeStr,type); \
    667667            psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    668                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
     668                    _("Specified psImage type, %s, is not supported."), \
    669669                    typeStr); \
    670670            psFree(out); \
    … …  
    680680    default:
    681681        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    682                 PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
     682                _("Specified interpolation mode, %d, is unsupported."),
    683683                mode);
    684684        psFree(out);
    … …  
    702702    if (input == NULL) {
    703703        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    704                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     704                _("Can not operate on a NULL psImage."));
    705705        psFree(output);
    706706        return NULL;
    … …  
    715715        if (input->numRows != inputMask->numRows || input->numCols != inputMask->numCols) {
    716716            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    717                     PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
     717                    _("Input psImage mask size, %dx%d, does not match psImage input size, %dx%d."),
    718718                    input->numCols, input->numRows,
    719719                    inputMask->numCols, inputMask->numRows );
    … …  
    725725            PS_TYPE_NAME(typeStr,inputMask->type.type);
    726726            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    727                     PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     727                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    728728                    typeStr, PS_TYPE_MASK_NAME);
    729729            psFree(output);
    … …  
    734734    if (outToIn == NULL) {
    735735        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    736                 PS_ERRORTEXT_psImageManip_TRANSFORM_NULL);
     736                _("Specified input transform can not be NULL."));
    737737        return NULL;
    738738    }
    … …  
    853853            PS_TYPE_NAME(typeStr,type); \
    854854            psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    855                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
     855                    _("Specified psImage type, %s, is not supported."), \
    856856                    typeStr); \
    857857            psFree(output); \
    … …  
    867867    default:
    868868        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    869                 PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
     869                _("Specified interpolation mode, %d, is unsupported."),
    870870                mode);
    871871        psFree(output);

  • trunk/psLib/src/imageops/psImageMaskOps.c

    r7766 r8232  
    88 *  @author David Robbins, MHPCC
    99 *
    10  *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-06-30 02:20:06 $
     10 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-08-08 23:32:23 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2626#include "psMemory.h"
    2727#include "psAssert.h"
    28 #include "psErrorText.h"
     28
    2929#include "psCoord.h"
    3030

  • trunk/psLib/src/imageops/psImagePixelExtract.c

    r7999 r8232  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-07-28 00:44:05 $
     10 *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-08-08 23:32:23 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2121#include "psError.h"
    2222
    23 #include "psErrorText.h"
     23
    2424
    2525#define VECTOR_STORE_ROW_CASE(TYPE) \
    … …  
    3434    if (input == NULL || input->data.V == NULL) {
    3535        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    36                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     36                _("Can not operate on a NULL psImage."));
    3737        psFree(out);
    3838        return NULL;
    … …  
    124124    if (input == NULL || input->data.V == NULL) {
    125125        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    126                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     126                _("Can not operate on a NULL psImage."));
    127127        psFree(out);
    128128        return NULL;
    … …  
    223223    if (input == NULL || input->data.V == NULL) {
    224224        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    225                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     225                _("Can not operate on a NULL psImage."));
    226226        psFree(out);
    227227        return NULL;
    … …  
    350350        if (inRows != mask->numRows || inCols != mask->numCols) {
    351351            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    352                     PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
     352                    _("Input psImage mask size, %dx%d, does not match psImage input size, %dx%d."),
    353353                    mask->numCols,mask->numRows,
    354354                    inCols, inRows);
    … …  
    360360            PS_TYPE_NAME(typeStr,mask->type.type);
    361361            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    362                     PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     362                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    363363                    typeStr, PS_TYPE_MASK_NAME);
    364364            psFree(out);
    … …  
    369369    if (stats == NULL) {
    370370        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    371                 PS_ERRORTEXT_psImage_STAT_NULL);
     371                _("Specified statistic can not be NULL."));
    372372        psFree(out);
    373373        return NULL;
    … …  
    378378    if (statistic == 0) {
    379379        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
    380                 PS_ERRORTEXT_psImage_BAD_STAT,stats->options);
     380                _("Specified statistic option, %d, is not valid.  Must specify one and only one statistic type."),stats->options);
    381381        psFree(out);
    382382        return NULL;
    … …  
    466466                PS_TYPE_NAME(typeStr,type);
    467467                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    468                         PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     468                        _("Specified psImage type, %s, is not supported."),
    469469                        typeStr);
    470470                psFree(out);
    … …  
    531531    } else { // don't know what the direction flag is
    532532        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    533                 PS_ERRORTEXT_psImage_SLICE_DIRECTION_INVALID,
     533                _("Specified slice direction, %d, is invalid."),
    534534                direction);
    535535        psFree(out);
    … …  
    555555    if (input == NULL || input->data.V == NULL) {
    556556        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    557                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     557                _("Can not operate on a NULL psImage."));
    558558        psFree(out);
    559559        return NULL;
    … …  
    588588    if (nSamples < 2) {
    589589        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    590                 PS_ERRORTEXT_psImage_nSamples_TOOSMALL,
     590                _("Specified number of samples, %d, must be greater than 1 to make a line."),
    591591                nSamples);
    592592        psFree(out);
    … …  
    639639    if (mode < PS_INTERPOLATE_FLAT ) {
    640640        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    641                 PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
     641                _("Specified interpolation mode, %d, is unsupported."),
    642642                mode);
    643643        psFree(out);
    … …  
    648648        if (numRows != mask->numRows || numCols != mask->numCols) {
    649649            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    650                     PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
     650                    _("Input psImage mask size, %dx%d, does not match psImage input size, %dx%d."),
    651651                    mask->numCols,mask->numRows,
    652652                    numCols-1, numRows);
    … …  
    658658            PS_TYPE_NAME(typeStr,mask->type.type);
    659659            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    660                     PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     660                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    661661                    typeStr, PS_TYPE_MASK_NAME);
    662662            psFree(out);
    … …  
    719719            PS_TYPE_NAME(typeStr,input->type.type);
    720720            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    721                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     721                    _("Specified psImage type, %s, is not supported."),
    722722                    typeStr);
    723723            psFree(out);
    … …  
    742742    if (input == NULL || input->data.V == NULL) {
    743743        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    744                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     744                _("Can not operate on a NULL psImage."));
    745745        psFree(out);
    746746        return NULL;
    … …  
    752752        if (numRows != mask->numRows || numCols != mask->numCols) {
    753753            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    754                     PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
     754                    _("Input psImage mask size, %dx%d, does not match psImage input size, %dx%d."),
    755755                    mask->numCols,mask->numRows,
    756756                    numCols, numRows);
    … …  
    762762            PS_TYPE_NAME(typeStr,mask->type.type);
    763763            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    764                     PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
     764                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
    765765                    typeStr, PS_TYPE_MASK_NAME);
    766766            psFree(out);
    … …  
    774774            y < input->row0 || y >= (input->row0 + numRows) ) {
    775775        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    776                 PS_ERRORTEXT_psImage_CENTER_NOT_IN_IMAGE,
     776                _("Specified center, (%g,%g), is outside of the psImage boundaries, [0:%d,0:%d]."),
    777777                x, y,
    778778                numCols-1, numRows-1);
    … …  
    783783    if (radii == NULL) {
    784784        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    785                 PS_ERRORTEXT_psImage_RADII_VECTOR_NULL);
     785                _("Specified radii vector can not be NULL."));
    786786        psFree(out);
    787787        return NULL;
    … …  
    790790    if (radii->n < 2) {
    791791        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    792                 PS_ERRORTEXT_psImage_RADII_VECTOR_TOOSMALL,
     792                _("Input radii vector size, %d, can not be less than 2."),
    793793                radii->n);
    794794        psFree(out);
    … …  
    798798    if (stats == NULL) {
    799799        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    800                 PS_ERRORTEXT_psImage_STAT_NULL);
     800                _("Specified statistic can not be NULL."));
    801801        psFree(out);
    802802        return NULL;
    … …  
    807807    if (statistic == 0) {
    808808        psError(PS_ERR_BAD_PARAMETER_VALUE, false,
    809                 PS_ERRORTEXT_psImage_BAD_STAT,
     809                _("Specified statistic option, %d, is not valid.  Must specify one and only one statistic type."),
    810810                stats->options);
    811811        psFree(out);

  • trunk/psLib/src/imageops/psImagePixelManip.c

    r7766 r8232  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-06-30 02:20:06 $
     12 *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-08-08 23:32:23 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828#include "psMemory.h"
    2929#include "psAssert.h"
    30 #include "psErrorText.h"
     30
    3131#include "psCoord.h"
    3232
    … …  
    4747    if (max < min) {
    4848        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    49                 PS_ERRORTEXT_psImageManip_MAXMIN,
     49                _("Specified min value, %g, can not be greater than the specified max value, %g."),
    5050                (double)min,(double)max);
    5151        return 0;
    … …  
    6161            if (vmin < PS_MIN_##type || vmin > PS_MAX_##type) { \
    6262                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    63                         PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
     63                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
    6464                        "vmin",vmin, PS_TYPE_##type##_NAME, \
    6565                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
    … …  
    6767            if (vmax > PS_MAX_##type || vmax < PS_MIN_##type) { \
    6868                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    69                         PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
     69                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
    7070                        "vmax",vmax, PS_TYPE_##type##_NAME, \
    7171                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
    … …  
    9090            if (vmin < PS_MIN_##type || vmin > PS_MAX_##type) { \
    9191                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    92                         PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
     92                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
    9393                        "vmin",vmin, PS_TYPE_##type##_NAME, \
    9494                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
    … …  
    9696            if (vmax > PS_MAX_##type || vmax < PS_MIN_##type) { \
    9797                psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    98                         PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
     98                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
    9999                        "vmax",vmax, PS_TYPE_##type##_NAME, \
    100100                        (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
    … …  
    132132            PS_TYPE_NAME(typeStr,input->type.type);
    133133            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    134                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     134                    _("Specified psImage type, %s, is not supported."),
    135135                    typeStr);
    136136        }
    … …  
    177177            PS_TYPE_NAME(typeStr,input->type.type);
    178178            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    179                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     179                    _("Specified psImage type, %s, is not supported."),
    180180                    typeStr);
    181181        }
    … …  
    202202    if (image == NULL || overlay == NULL) {
    203203        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    204                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     204                _("Can not operate on a NULL psImage."));
    205205        return pixelsOverlaid;
    206206    }
    … …  
    208208    if (op == NULL) {
    209209        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    210                 PS_ERRORTEXT_psImageManip_OPERATION_NULL);
     210                _("Operation can not be NULL."));
    211211        return pixelsOverlaid;
    212212    }
    … …  
    220220        PS_TYPE_NAME(typeStrOverlay,overlay->type.type);
    221221        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    222                 PS_ERRORTEXT_psImageManip_OVERLAY_TYPE_MISMATCH,
     222                _("Input overlay psImage type, %s, must match input psImage type, %s."),
    223223                typeStrOverlay, typeStr);
    224224        return pixelsOverlaid;
    … …  
    239239
    240240        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    241                 PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
     241                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."),
    242242                x0, imageColLimit, y0, imageRowLimit,
    243243                imageNumCols, imageNumRows);
    … …  
    295295    default: \
    296296        psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    297                 PS_ERRORTEXT_psImageManip_OVERLAY_OPERATOR_INVALID, \
     297                _("Specified operation, '%s', is not supported."), \
    298298                op); \
    299299        return pixelsOverlaid; \
    … …  
    319319            PS_TYPE_NAME(typeStr,type);
    320320            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    321                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     321                    _("Specified psImage type, %s, is not supported."),
    322322                    typeStr);
    323323            return pixelsOverlaid;
    … …  
    344344    if (input == NULL) {
    345345        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    346                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     346                _("Can not operate on a NULL psImage."));
    347347        return 0;
    348348    }
    … …  
    350350    if (realMax < realMin) {
    351351        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    352                 PS_ERRORTEXT_psImageManip_MAXMIN_REAL,
     352                _("Specified real-portion of min value, %g, can not be greater than the real-portion of max value, %g."),
    353353                (double)realMin, (double)realMax);
    354354        return 0;
    … …  
    356356    if (imagMax < imagMin) {
    357357        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    358                 PS_ERRORTEXT_psImageManip_MAXMIN_IMAG,
     358                _("Specified imaginary-portion of min value, %g, can not be greater than the imaginary-portion of max value, %g."),
    359359                (double)imagMin, (double)imagMax);
    360360        return 0;
    … …  
    369369                realfcn(vmin) > PS_MAX_##type || imagfcn(vmin) > PS_MAX_##type ) { \
    370370            psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    371                     PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
     371                    _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
    372372                    "vmin", creal(vmin), cimag(vmin), \
    373373                    PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
    … …  
    377377                realfcn(vmax) < PS_MIN_##type || imagfcn(vmax) < PS_MIN_##type ) { \
    378378            psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
    379                     PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
     379                    _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
    380380                    "vmax", creal(vmax), cimag(vmax), \
    381381                    PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
    … …  
    406406            PS_TYPE_NAME(typeStr,input->type.type);
    407407            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    408                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     408                    _("Specified psImage type, %s, is not supported."),
    409409                    typeStr);
    410410        }

  • trunk/psLib/src/imageops/psImageStats.c

    r7766 r8232  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.98 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2006-06-30 02:20:06 $
     11 *  @version $Revision: 1.99 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2006-08-08 23:32:23 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3030#include "psImageStats.h"
    3131#include "psAssert.h"
    32 #include "psErrorText.h"
     32
    3333#include "psRegion.h"
    3434#include "psRegionForImage.h"
    … …  
    497497        if (mask == NULL) {
    498498            psError(PS_ERR_BAD_PARAMETER_NULL, true,
    499                     PS_ERRORTEXT_psImage_IMAGE_NULL);
     499                    _("Can not operate on a NULL psImage."));
    500500            return -1;
    501501        }
    … …  
    592592        return -1;
    593593    }/* else if (col0 == col1 && row0 == row1) {
    594                                         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    595                                                 "Invalid psRegion specified.  Region contains only 1 pixel.\n");
    596                                         return -1;
    597                                     }
    598                                 */
     594                                            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     595                                                    "Invalid psRegion specified.  Region contains only 1 pixel.\n");
     596                                            return -1;
     597                                        }
     598                                    */
    599599    x0 = col0;
    600600    x1 = col1;
    … …  
    632632    default:
    633633        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    634                 PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE, type, PS_TYPE_U8);
     634                _("Input psImage mask type, %s, is not the supported mask datatype of %s."), type, PS_TYPE_U8);
    635635        return -1;
    636636    }

  • trunk/psLib/src/imageops/psImageStructManip.c

    r7524 r8232  
    88 *  @author Robert DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-06-12 20:44:04 $
     10 *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-08-08 23:32:23 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2121#include "psError.h"
    2222
    23 #include "psErrorText.h"
     23
    2424
    2525static psImage* imageSubset(psImage* out,
    … …  
    3535    if (image == NULL || image->data.V == NULL) {
    3636        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    37                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     37                _("Can not operate on a NULL psImage."));
    3838        return NULL;
    3939    }
    … …  
    4141    if ( col0 < image->col0 || row0 < image->row0 ) {
    4242        //        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    43         //                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID);
     43        //                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."));
    4444        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    45                 PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
     45                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."),
    4646                col0, col1-1, row0, row1-1,
    4747                image->numCols-1, image->numRows-1);
    … …  
    5151    if (image->type.dimen != PS_DIMEN_IMAGE) {
    5252        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    53                 PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
     53                _("The input psImage must have a PS_DIMEN_IMAGE dimension type."));
    5454        return NULL;
    5555    }
    … …  
    6969            row1 > image->row0 + image->numRows ) {
    7070        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    71                 PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
     71                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."),
    7272                col0, col1-1, row0, row1-1,
    7373                image->numCols-1, image->numRows-1);
    … …  
    153153    if (input == NULL || input->data.V == NULL) {
    154154        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    155                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     155                _("Can not operate on a NULL psImage."));
    156156        psFree(output);
    157157        return NULL;
    … …  
    160160    if (input == output) {
    161161        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    162                 PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
     162                _("Specified input and output psImage can not reference the same psImage."));
    163163        psFree(output);
    164164        return NULL;
    … …  
    167167    if (input->type.dimen != PS_DIMEN_IMAGE) {
    168168        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    169                 PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
     169                _("The input psImage must have a PS_DIMEN_IMAGE dimension type."));
    170170        psFree(output);
    171171        return NULL;
    … …  
    287287            PS_TYPE_NAME(typeStr,type);
    288288            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    289                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     289                    _("Specified psImage type, %s, is not supported."),
    290290                    typeStr);
    291291            psFree(output);
    … …  
    302302    if (image == NULL || image->data.V == NULL) {
    303303        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    304                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     304                _("Can not operate on a NULL psImage."));
    305305        return NULL;
    306306    }
    … …  
    335335            row0 >= row1 ) {
    336336        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    337                 PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
     337                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."),
    338338                col0, col1-1, row0, row1-1,
    339339                image->numCols-1, image->numRows-1);

  • trunk/psLib/src/math/psBinaryOp.c

    r7766 r8232  
    3030 *  @author Robert DeSonia, MHPCC
    3131 *
    32  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    33  *  @date $Date: 2006-06-30 02:20:06 $
     32 *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
     33 *  @date $Date: 2006-08-08 23:32:23 $
    3434 *
    3535 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5050#include "psLogMsg.h"
    5151#include "psAssert.h"
    52 #include "psErrorText.h"
     52
    5353
    5454/*****************************************************************************
    … …  
    107107    long n2 = ((psVector*)IN2)->n; \
    108108    if (n1 != n2) { \
    109         psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n1, n2); \
     109        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n1, n2); \
    110110        if (OUT != IN1 && OUT != IN2) { \
    111111            psFree(OUT); \
    … …  
    129129    if (((psVector*)IN1)->type.dimen == PS_DIMEN_VECTOR) { /* Regular vectors */ \
    130130        if (n1 != numRows2) { \
    131             psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n1, numRows2); \
     131            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n1, numRows2); \
    132132            if (OUT != IN1 && OUT != IN2) { \
    133133                psFree(OUT); \
    … …  
    146146    } else {  /* Transposed vectors */ \
    147147        if (n1 != numCols2) { \
    148             psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n1, numCols2); \
     148            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n1, numCols2); \
    149149            if (OUT != IN1 && OUT != IN2) { \
    150150                psFree(OUT); \
    … …  
    187187    if (((psVector*)IN2)->type.dimen == PS_DIMEN_VECTOR) { /* Regular vectors */ \
    188188        if (n2 != numRows1) { \
    189             psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n2, numRows1); \
     189            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n2, numRows1); \
    190190            if (OUT != IN1 && OUT != IN2) { \
    191191                psFree(OUT); \
    … …  
    204204    } else {  /* Transposed vectors */ \
    205205        if (n2 != numCols1) { \
    206             psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n2, numCols1); \
     206            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n2, numCols1); \
    207207            if (OUT != IN1) { \
    208208                psFree(OUT); \
    … …  
    229229    long numCols2 = ((psImage*)IN2)->numCols; \
    230230    if (numRows1 != numRows2 || numCols1 != numCols2) { \
    231         psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_IMAGE_SIZE_DIFFERS, \
     231        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Specified psImage dimensions differed, %dx%d vs %dx%d."), \
    232232                numCols1, numRows1, numCols2, numRows2); \
    233233        if (OUT != IN1 && OUT != IN2) { \
    … …  
    278278    PS_TYPE_NAME(strType,IN1->type);                                                                         \
    279279    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                                 \
    280             PS_ERRORTEXT_psMatrix_TYPE_MISMATCH,                                                             \
     280            _("Specified data type, %s, is not supported."),                                                             \
    281281            strType);  */                                                                                    \
    282282    if (OUT != IN1 && OUT != IN2) {                                                                          \
    … …  
    329329    PS_TYPE_NAME(strType,IN1->type);                                                                         \
    330330    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                                 \
    331             PS_ERRORTEXT_psMatrix_TYPE_MISMATCH,                                                             \
     331            _("Specified data type, %s, is not supported."),                                                             \
    332332            strType);  */                                                                                    \
    333333    if (OUT != IN1 && OUT != IN2) {                                                                          \
    … …  
    372372    if (PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) {                                                               \
    373373        psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                            \
    374                 PS_ERRORTEXT_psMatrix_MIN_COMPLEX_SUPPORT);                                                  \
     374                _("The minimum operation is not supported with complex data."));                                                  \
    375375        if (OUT != IN1 && OUT != IN2) {                                                                      \
    376376            psFree(OUT);                                                                                     \
    … …  
    383383    if (PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) {                                                               \
    384384        psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                            \
    385                 PS_ERRORTEXT_psMatrix_MAX_COMPLEX_SUPPORT);                                                  \
     385                _("The maximum operation is not supported with complex data."));                                                  \
    386386        if (OUT != IN1 && OUT != IN2) {                                                                      \
    387387            psFree(OUT);                                                                                     \
    … …  
    393393} else {                                                                                                     \
    394394    psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                                \
    395             PS_ERRORTEXT_psMatrix_OPERATION_UNSUPPORTED,                                                     \
     395            _("Specified operation, %s, is not supported."),                                                     \
    396396            OP);                                                                                             \
    397397    if (OUT != IN1 && OUT != IN2) {                                                                          \
    … …  
    469469            if (out == NULL) {
    470470                psError(PS_ERR_UNKNOWN, false,
    471                         PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
     471                        _("Couldn't create a proper output psVector."));
    472472                return NULL;
    473473            }
    … …  
    478478            if (out == NULL) {
    479479                psError(PS_ERR_UNKNOWN, false,
    480                         PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
     480                        _("Couldn't create a proper output psImage."));
    481481                return NULL;
    482482            }
    … …  
    484484        } else {
    485485            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    486                     PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
     486                    _("Specified parameter, %s, has invalid dimensionality, %d."),
    487487                    "in2",dim2);
    488488            psBinaryOp_EXIT;
    … …  
    493493            if (out == NULL) {
    494494                psError(PS_ERR_UNKNOWN, false,
    495                         PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
     495                        _("Couldn't create a proper output psVector."));
    496496                return NULL;
    497497            }
    … …  
    502502            if (out == NULL) {
    503503                psError(PS_ERR_UNKNOWN, false,
    504                         PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
     504                        _("Couldn't create a proper output psVector."));
    505505                return NULL;
    506506            }
    … …  
    511511            if (out == NULL) {
    512512                psError(PS_ERR_UNKNOWN, false,
    513                         PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
     513                        _("Couldn't create a proper output psImage."));
    514514                return NULL;
    515515            }
    … …  
    517517        } else {
    518518            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    519                     PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
     519                    _("Specified parameter, %s, has invalid dimensionality, %d."),
    520520                    "in2",dim2);
    521521            psBinaryOp_EXIT;
    … …  
    525525        if (out == NULL) {
    526526            psError(PS_ERR_UNKNOWN, false,
    527                     PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
     527                    _("Couldn't create a proper output psImage."));
    528528            return NULL;
    529529        }
    … …  
    536536        } else {
    537537            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    538                     PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
     538                    _("Specified parameter, %s, has invalid dimensionality, %d."),
    539539                    "in2",dim2);
    540540            psBinaryOp_EXIT;
    … …  
    542542    } else {
    543543        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    544                 PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
     544                _("Specified parameter, %s, has invalid dimensionality, %d."),
    545545                "in1",dim1);
    546546        psBinaryOp_EXIT;

  • trunk/psLib/src/math/psMathUtils.c

    r7766 r8232  
    33 *  This file contains standard math routines.
    44 *
    5  *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    6  *  @date $Date: 2006-06-30 02:20:06 $
     5 *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     6 *  @date $Date: 2006-08-08 23:32:23 $
    77 *
    88 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2626#include "psAssert.h"
    2727#include "psConstants.h"
    28 #include "psErrorText.h"
     28
    2929
    3030/*****************************************************************************/

  • trunk/psLib/src/math/psMatrix.c

    r7766 r8232  
    2121 *  @author Robert DeSonia, MHPCC
    2222 *
    23  *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
    24  *  @date $Date: 2006-06-30 02:20:06 $
     23 *  @version $Revision: 1.41 $ $Name: not supported by cvs2svn $
     24 *  @date $Date: 2006-08-08 23:32:23 $
    2525 *
    2626 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    4343#include "psMatrix.h"
    4444#include "psAssert.h"
    45 #include "psErrorText.h"
     45
    4646#include "psTrace.h"
    4747
    … …  
    568568
    569569    if(numRowsIn!=numColsOut && numRowsOut!=numColsIn) {
    570         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMatrix_TRANSPOSE_MISMATCH);
     570        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Number of rows do not match number of columns."));
    571571        TRANSPOSE_CLEANUP;
    572572    }

  • trunk/psLib/src/math/psPolynomial.c

    r7914 r8232  
    77*  polynomials.  It also contains a Gaussian functions.
    88*
    9 *  @version $Revision: 1.147 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2006-07-15 02:57:12 $
     9*  @version $Revision: 1.148 $ $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
    … …  
    3232#include "psPolynomial.h"
    3333#include "psAssert.h"
    34 #include "psErrorText.h"
     34
    3535
    3636/*****************************************************************************/
    … …  
    795795    } else {
    796796        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    797                 PS_ERRORTEXT_psPolynomial_INVALID_POLYNOMIAL_TYPE,
     797                _("Unknown polynomial type 0x%x found.  Evaluation failed."),
    798798                poly->type);
    799799    }
    … …  
    845845    } else {
    846846        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    847                 PS_ERRORTEXT_psPolynomial_INVALID_POLYNOMIAL_TYPE,
     847                _("Unknown polynomial type 0x%x found.  Evaluation failed."),
    848848                poly->type);
    849849    }
    … …  
    924924    } else {
    925925        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    926                 PS_ERRORTEXT_psPolynomial_INVALID_POLYNOMIAL_TYPE,
     926                _("Unknown polynomial type 0x%x found.  Evaluation failed."),
    927927                poly->type);
    928928    }
    … …  
    10401040    } else {
    10411041        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    1042                 PS_ERRORTEXT_psPolynomial_INVALID_POLYNOMIAL_TYPE,
     1042                _("Unknown polynomial type 0x%x found.  Evaluation failed."),
    10431043                poly->type);
    10441044    }

  • trunk/psLib/src/math/psRandom.c

    r7766 r8232  
    1010*  @author GLG, MHPCC
    1111*
    12 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-06-30 02:20:06 $
     12*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-08-08 23:32:23 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3131#include "psLogMsg.h"
    3232#include "psAssert.h"
    33 #include "psErrorText.h"
     33
    3434
    3535psU64 p_psRandomGetSystemSeed()
    … …  
    7878        psError(PS_ERR_UNEXPECTED_NULL,
    7979                true,
    80                 PS_ERRORTEXT_psRandom_UNKNOWN_RANDFOM_NUMBER_GENERATOR_TYPE);
     80                _("Unknown Random Number Generator Type"));
    8181        break;
    8282    }
    … …  
    9292        psError(PS_ERR_UNEXPECTED_NULL,
    9393                true,
    94                 PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
     94                _("Random variable is NULL."));
    9595    } else {
    9696        // Check seed value to see if system seed should be used
    … …  
    109109        psError(PS_ERR_UNEXPECTED_NULL,
    110110                true,
    111                 PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
     111                _("Random variable is NULL."));
    112112        return(0);
    113113    } else {
    … …  
    122122        psError(PS_ERR_UNEXPECTED_NULL,
    123123                true,
    124                 PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
     124                _("Random variable is NULL."));
    125125        return(0);
    126126    } else {
    … …  
    136136        psError(PS_ERR_UNEXPECTED_NULL,
    137137                true,
    138                 PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
     138                _("Random variable is NULL."));
    139139        return(0);
    140140    } else {
    … …  
    149149        psError(PS_ERR_UNEXPECTED_NULL,
    150150                true,
    151                 PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
     151                _("Random variable is NULL."));
    152152        return(0);
    153153    } else {

  • trunk/psLib/src/math/psRegion.c

    r7901 r8232  
    33#include "psMemory.h"
    44#include "psError.h"
    5 #include "psErrorText.h"
     5
    66#include "psRegion.h"
    77
    … …  
    5252    if (sscanf(region,"[%d:%d,%d:%d]",&col0,&col1,&row0,&row1) < 4) {
    5353        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    54                 PS_ERRORTEXT_psImage_SUBSECTION_INVALID,
     54                _("Specified subsection string, '%s', can not be parsed.  Must be in the form '[x1:x2,y1:y2]'."),
    5555                region);
    5656        return psRegionSet(NAN,NAN,NAN,NAN);
    … …  
    6464    if ((col1 > 0) && (col0 > col1)) {
    6565        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    66                 PS_ERRORTEXT_psImage_SUBSET_RANGE_MALFORMED,
     66                _("Specified subset range, [%d:%d,%d:%d], is invalid.  Ranges must be incremental."),
    6767                col0,col1,row0,row1);
    6868        return psRegionSet(NAN,NAN,NAN,NAN);
    … …  
    7171    if ((row1 > 0) && (row0 > row1)) {
    7272        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    73                 PS_ERRORTEXT_psImage_SUBSET_RANGE_MALFORMED,
     73                _("Specified subset range, [%d:%d,%d:%d], is invalid.  Ranges must be incremental."),
    7474                col0,col1,row0,row1);
    7575        return psRegionSet(NAN,NAN,NAN,NAN);

  • trunk/psLib/src/math/psSpline.c

    r7914 r8232  
    66*  This file contains the routines that allocate, free, and evaluate splines.
    77*
    8 *  @version $Revision: 1.150 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2006-07-15 02:57:12 $
     8*  @version $Revision: 1.151 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2006-08-08 23:32:23 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828#include "psSpline.h"
    2929#include "psAssert.h"
    30 #include "psErrorText.h"
     30
    3131#include "psMathUtils.h"
    3232

  • trunk/psLib/src/math/psStats.c

    r7999 r8232  
    1616 * use ->min and ->max (PS_STAT_USE_RANGE)
    1717 *
    18  *  @version $Revision: 1.182 $ $Name: not supported by cvs2svn $
    19  *  @date $Date: 2006-07-28 00:44:05 $
     18 *  @version $Revision: 1.183 $ $Name: not supported by cvs2svn $
     19 *  @date $Date: 2006-08-08 23:32:23 $
    2020 *
    2121 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    4949#include "psString.h"
    5050
    51 #include "psErrorText.h"
     51
    5252
    5353/*****************************************************************************/
    … …  
    440440        psError(PS_ERR_UNEXPECTED_NULL,
    441441                false,
    442                 PS_ERRORTEXT_psStats_STATS_SAMPLE_MEDIAN_SORT_PROBLEM);
     442                _("Failed to sort input data."));
    443443        psTrace(__func__, 4, "---- %s(false) end ----\n", __func__);
    444444        psFree(vector);
    … …  
    924924                ((y->data.F64[2] <= yVal) && (yVal <= y->data.F64[0]))) ) {
    925925            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    926                     PS_ERRORTEXT_psStats_YVAL_OUT_OF_RANGE,
     926                    _("Specified yVal, %g, is not within y-range, %g to %g."),
    927927                    (psF64)yVal, y->data.F64[0], y->data.F64[2]);
    928928        }
    … …  
    946946        if (myPoly == NULL) {
    947947            psError(PS_ERR_UNEXPECTED_NULL, false,
    948                     PS_ERRORTEXT_psStats_STATS_FIT_QUADRATIC_POLYNOMIAL_1D_FIT);
     948                    _("Failed to fit a 1-dimensional polynomial to the three specified data points.  Returning NAN."));
    949949            psFree(x);
    950950            psFree(y);
    … …  
    967967        if (isnan(tmpFloat)) {
    968968            psError(PS_ERR_UNEXPECTED_NULL,
    969                     false, PS_ERRORTEXT_psStats_STATS_FIT_QUADRATIC_POLY_MEDIAN);
     969                    false, _("Failed to determine the median of the fitted polynomial.  Returning NAN."));
    970970            psFree(x);
    971971            psFree(y);
    … …  
    20352035                          PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV)) {
    20362036        if (!vectorRobustStats(inF32, errorsF32, maskU8, maskVal, stats)) {
    2037             psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psStats_STATS_FAILED);
     2037            psError(PS_ERR_UNKNOWN, false, _("Failed to calculate the specified statistic."));
    20382038            psFree(stats);
    20392039            psFree(inF32);

  • trunk/psLib/src/math/psUnaryOp.c

    r7766 r8232  
    3030 *  @author Robert DeSonia, MHPCC
    3131 *
    32  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    33  *  @date $Date: 2006-06-30 02:20:06 $
     32 *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
     33 *  @date $Date: 2006-08-08 23:32:23 $
    3434 *
    3535 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5151#include "psLogMsg.h"
    5252#include "psAssert.h"
    53 #include "psErrorText.h"
     53
    5454
    5555/*****************************************************************************
    … …  
    7878    long nOut = ((psVector*)OUT)->n; \
    7979    if (nIn != nOut) { \
    80         psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, nIn, nOut); \
     80        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), nIn, nOut); \
    8181        if (OUT != IN) { \
    8282            psFree(OUT); \
    … …  
    9999    long numColsOut = ((psImage*)OUT)->numCols; \
    100100    if(numRowsIn!=numRowsOut || numColsIn!=numColsOut) { \
    101         psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_IMAGE_SIZE_DIFFERS, \
     101        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Specified psImage dimensions differed, %dx%d vs %dx%d."), \
    102102                numColsIn, numRowsIn, numColsOut, numRowsOut); \
    103103        if (OUT != IN) { \
    … …  
    157157        char* strType; \
    158158        PS_TYPE_NAME(strType, IN->type); \
    159         psError(PS_ERR_BAD_PARAMETER_TYPE, true, PS_ERRORTEXT_psMatrix_TYPE_MISMATCH, strType); \
     159        psError(PS_ERR_BAD_PARAMETER_TYPE, true, _("Specified data type, %s, is not supported."), strType); \
    160160        if (OUT != IN) { \
    161161            psFree(OUT); \
    … …  
    275275    } \
    276276} else { \
    277     psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMatrix_OPERATION_UNSUPPORTED, OP); \
     277    psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified operation, %s, is not supported."), OP); \
    278278    if (OUT != IN) { \
    279279        psFree(OUT); \
    … …  
    309309    case PS_DIMEN_TRANSV:
    310310        if (((psVector*)in)->n == 0) {
    311             psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_VECTOR_EMPTY);
     311            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Input psVector contains no elements.  No data to perform operation with."));
    312312            psUnaryOp_EXIT;
    313313        }
    … …  
    315315        out = psVectorRecycle(out, ((psVector*)in)->n, psTypeIn->type);
    316316        if (out == NULL) {
    317             psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
     317            psError(PS_ERR_UNKNOWN, false, _("Couldn't create a proper output psVector."));
    318318            psUnaryOp_EXIT;
    319319        }
    … …  
    324324    case PS_DIMEN_IMAGE:
    325325        if (((psImage* ) in)->numCols == 0 || ((psImage* ) in)->numRows == 0) {
    326             psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_IMAGE_EMPTY);
     326            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Input psImage contains no pixels.  No data to perform operation with."));
    327327            psUnaryOp_EXIT;
    328328        }
    … …  
    330330        out = psImageRecycle(out, ((psImage*)in)->numCols, ((psImage*)in)->numRows, psTypeIn->type);
    331331        if (out == NULL) {
    332             psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
     332            psError(PS_ERR_UNKNOWN, false, _("Couldn't create a proper output psImage."));
    333333            psUnaryOp_EXIT;
    334334        }
    … …  
    340340            psFree(out);
    341341        }
    342         psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_DIMEN_INVALID, "in", psTypeIn->dimen);
     342        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Specified parameter, %s, has invalid dimensionality, %d."), "in", psTypeIn->dimen);
    343343        psUnaryOp_EXIT;
    344344    }

  • trunk/psLib/src/mathtypes/psImage.c

    r7914 r8232  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.112 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2006-07-15 02:57:12 $
     11 *  @version $Revision: 1.113 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2006-08-08 23:32:23 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2727#include "psString.h"
    2828
    29 #include "psErrorText.h"
     29
    3030
    3131#define SQUARE(x) ((x)*(x))
    … …  
    6464    if (numRows < 1) {
    6565        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    66                 PS_ERRORTEXT_psImage_AREA_NEGATIVE,
     66                _("Specified number of rows (%d) or columns (%d) is invalid."),
    6767                numRows, numCols);
    6868        return NULL;
    … …  
    7070    if (numCols < 1) {
    7171        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    72                 PS_ERRORTEXT_psImage_AREA_NEGATIVE,
     72                _("Specified number of rows (%d) or columns (%d) is invalid."),
    7373                numRows, numCols);
    7474        return NULL;
    … …  
    380380        psFree(old);
    381381        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    382                 PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
     382                _("The input psImage must have a PS_DIMEN_IMAGE dimension type."));
    383383        return NULL;
    384384    }
    … …  
    417417    if (input == NULL || input->data.V == NULL) {
    418418        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    419                 PS_ERRORTEXT_psImage_IMAGE_NULL);
     419                _("Can not operate on a NULL psImage."));
    420420        return false;
    421421    }
    … …  
    423423    if (input->type.dimen != PS_DIMEN_IMAGE) {
    424424        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    425                 PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
     425                _("The input psImage must have a PS_DIMEN_IMAGE dimension type."));
    426426        return false;
    427427    }
    … …  
    536536            PS_TYPE_NAME(typeStr,type);
    537537            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    538                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     538                    _("Specified psImage type, %s, is not supported."),
    539539                    typeStr);
    540540            break;
    … …  
    634634    default:                                                         \
    635635        psError(PS_ERR_BAD_PARAMETER_VALUE,true,                     \
    636                 PS_ERRORTEXT_psImage_INTERPOLATE_METHOD_INVALID,     \
     636                _("Specified interpolation method (%d) is not supported."),     \
    637637                mode);                                               \
    638638    }                                                                \
    … …  
    656656            PS_TYPE_NAME(typeStr,input->type.type);
    657657            psError(PS_ERR_BAD_PARAMETER_TYPE,true,
    658                     PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
     658                    _("Specified psImage type, %s, is not supported."),
    659659                    typeStr);
    660660        }

  • trunk/psLib/src/mathtypes/psScalar.c

    r7914 r8232  
    88 *  @author Ross Harman, MHPCC
    99 *
    10  *  @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-07-15 02:57:12 $
     10 *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-08-08 23:32:23 $
    1212 *
    1313 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2020#include "psAbort.h"
    2121
    22 #include "psErrorText.h"
     22
    2323
    2424static void scalarFree(psScalar *scalar)
    … …  
    7676    default:
    7777        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    78                 PS_ERRORTEXT_psScalar_UNSUPPORTED_TYPE,
     78                _("Specified datatype (%d) is unsupported by psScalar."),
    7979                type);
    8080        psFree(scalar);
    … …  
    103103    if (value == NULL) {
    104104        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    105                 PS_ERRORTEXT_psScalar_COPY_NULL);
     105                _("Can not copy a NULL psScalar."));
    106106        return NULL;
    107107    }
    … …  
    147147    default:
    148148        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    149                 PS_ERRORTEXT_psScalar_UNSUPPORTED_TYPE,
     149                _("Specified datatype (%d) is unsupported by psScalar."),
    150150                dataType);
    151151        return NULL;

  • trunk/psLib/src/mathtypes/psVector.c

    r7979 r8232  
    99*  @author Robert DeSonia, MHPCC
    1010*
    11 *  @version $Revision: 1.79 $ $Name: not supported by cvs2svn $
    12 *  @date $Date: 2006-07-26 02:19:32 $
     11*  @version $Revision: 1.80 $ $Name: not supported by cvs2svn $
     12*  @date $Date: 2006-08-08 23:32:23 $
    1313*
    1414*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2727#include "psCompare.h"
    2828
    29 #include "psErrorText.h"
     29
    3030
    3131typedef struct
    … …  
    7979    if (elementSize < 1) {
    8080        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    81                 PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE, type);
     81                _("Input psVector is an unsupported type (0x%x)."), type);
    8282        return NULL;
    8383    }
    … …  
    108108    if (vector == NULL) {
    109109        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    110                 PS_ERRORTEXT_psVector_REALLOC_NULL);
     110                _("psVectorRealloc must a given a non-NULL psVector to resize.  Desired datatype unknown."));
    111111        return NULL;
    112112    } else if (vector->nalloc != nalloc) {     // No need to realloc to same size
    … …  
    138138        psFree(vector);
    139139        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    140                 PS_ERRORTEXT_psVector_NOT_A_VECTOR);
     140                _("The input psVector must have a vector dimension type."));
    141141        return NULL;
    142142    }
    … …  
    163163    if (vector == NULL) {
    164164        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    165                 PS_ERRORTEXT_psVector_NULL);
     165                _("The input psVector can not be NULL."));
    166166        return NULL;
    167167    }
    … …  
    201201    if (input == NULL) {
    202202        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    203                 PS_ERRORTEXT_psVector_NULL);
     203                _("The input psVector can not be NULL."));
    204204        psFree(output);
    205205        return NULL;
    … …  
    241241                PS_TYPE_NAME(typeStr,type);
    242242                psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    243                         //                        PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE, typeStr);
     243                        //                        _("Input psVector is an unsupported type (0x%x)."), typeStr);
    244244                        "Input psVector is an unsupported type.\n");
    245245                psFree(output);
    … …  
    301301                PS_TYPE_NAME(typeStr,type); \
    302302                psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
    303                         PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE, \
     303                        _("Input psVector is an unsupported type (0x%x)."), \
    304304                        typeStr); \
    305305                psFree(output); \
    … …  
    326326            PS_TYPE_NAME(typeStr,type);
    327327            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    328                     PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE,
     328                    _("Input psVector is an unsupported type (0x%x)."),
    329329                    typeStr);
    330330            psFree(output);
    … …  
    378378    if (!inVector) {
    379379        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    380                 PS_ERRORTEXT_psVector_SORT_NULL);
     380                _("psVectorSort can not sort a NULL psVector."));
    381381        psFree(outVector);
    382382        return NULL;
    … …  
    408408    default:
    409409        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    410                 PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE,
     410                _("Input psVector is an unsupported type (0x%x)."),
    411411                inVector->type.type);
    412412        psFree(outVector);
    … …  
    455455    if (inVector == NULL) {
    456456        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    457                 PS_ERRORTEXT_psVector_SORT_NULL);
     457                _("psVectorSort can not sort a NULL psVector."));
    458458        psFree(outVector);
    459459        return NULL;
    … …  
    481481    default:
    482482        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    483                 PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE,
     483                _("Input psVector is an unsupported type (0x%x)."),
    484484                inVector->type.type);
    485485        psFree(outVector);
    … …  
    896896{
    897897    if (input == NULL) {
    898         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psVector_NULL);
     898        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psVector can not be NULL."));
    899899        return false;
    900900    }
    … …  
    969969{
    970970    if (input == NULL) {
    971         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psVector_NULL);
     971        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psVector can not be NULL."));
    972972        return NAN;
    973973    }
    … …  
    10321032    long Npixels = 0;
    10331033    if (mask == NULL) {
    1034         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psVector_NULL);
     1034        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psVector can not be NULL."));
    10351035        Npixels = -1;
    10361036        return Npixels;
    … …  
    10671067    default:
    10681068        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    1069                 PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE, type);
     1069                _("Input psVector is an unsupported type (0x%x)."), type);
    10701070        return -1;
    10711071    }

  • trunk/psLib/src/sys/psConfigure.c

    r7646 r8232  
    1313 *  @author Robert DeSonia, MHPCC
    1414 *
    15  *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2006-06-23 01:59:15 $
     15 *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2006-08-08 23:32:23 $
    1717 *
    1818 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828#include "psError.h"
    2929#include "psConfigure.h"
    30 #include "psErrorText.h"
     30
    3131#include "config.h"
    3232
    … …  
    9898        if (!p_psTimeInit(timeConfig)) {
    9999            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    100                     PS_ERRORTEXT_psConfigure_INITIALIZATION_FAILED, "psTime");
     100                    _("Failed to initialize %s."), "psTime");
    101101            return;
    102102        }
    … …  
    104104    if (!p_psEOCInit()) {
    105105        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    106                 PS_ERRORTEXT_psConfigure_INITIALIZATION_FAILED, "psEOC");
     106                _("Failed to initialize %s."), "psEOC");
    107107        return;
    108108    }
    … …  
    125125    if (!p_psTimeFinalize()) {
    126126        psError(PS_ERR_UNKNOWN, false,
    127                 PS_ERRORTEXT_psConfigure_FINALIZATION_FAILED, "psTime");
     127                _("Failed to finalize %s."), "psTime");
    128128        return;
    129129    }
    … …  
    132132    if (!p_psEOCFinalize()) {
    133133        psError(PS_ERR_UNKNOWN, false,
    134                 PS_ERRORTEXT_psConfigure_FINALIZATION_FAILED, "psEOC");
     134                _("Failed to finalize %s."), "psEOC");
    135135        return;
    136136    }

  • trunk/psLib/src/sys/psErrorCodes.c.in

    r7967 r8232  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-07-25 01:27:48 $
     9 *  @version $Revision: 1.5 $ $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
    … …  
    2020#include "psMemory.h"
    2121
    22 #include "psErrorText.h"
     22
    2323
    2424static psErrorDescription staticErrorCodes[] = {

  • trunk/psLib/src/sys/psLogMsg.c

    r8098 r8232  
    1111 *  @author GLG, MHPCC
    1212 *
    13  *  @version $Revision: 1.59 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2006-08-03 03:26:28 $
     13 *  @version $Revision: 1.60 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2006-08-08 23:32:23 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3636#include "psString.h"
    3737
    38 #include "psErrorText.h"
     38
    3939
    4040#define MIN_LOG_LEVEL 0
    … …  
    165165        default:
    166166            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    167                     PS_ERRORTEXT_psLogMsg_UNKNOWN_KEY, *ptr);
     167                    _("Unknown logging keyword %c."), *ptr);
    168168            return false;
    169169        }
    … …  
    210210
    211211        if (fileD == 0) {
    212             psError(PS_ERR_IO, true, PS_ERRORTEXT_psLogMsg_OPEN_FILE_FAILED,
     212            psError(PS_ERR_IO, true, _("Could not open file '%s' for output."),
    213213                    location);
    214214            psFree(protocolLocation);

  • trunk/psLib/src/sys/psMemory.c

    r7901 r8232  
    88*  @author Robert Lupton, Princeton University
    99*
    10 *  @version $Revision: 1.74 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2006-07-14 02:26:25 $
     10*  @version $Revision: 1.75 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2006-08-08 23:32:23 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3333#include "psLine.h"
    3434#include "psRegion.h"
    35 #include "psErrorText.h"
     35
    3636
    3737#define P_PS_MEMMAGIC (psPtr )0xdeadbeef   // Magic number in psMemBlock header
    … …  
    126126    if (ptr->refCounter < 1) {
    127127        psError(PS_ERR_MEMORY_CORRUPTION, false,
    128                 PS_ERRORTEXT_psMemory_MULTIPLE_FREE,
     128                _("Block %lu, allocated at %s:%d, freed multiple times at %s:%d."),
    129129                (unsigned long)ptr->id, ptr->file, ptr->lineno, file, lineno);
    130130    }
    … …  
    148148    if (m == NULL) {
    149149        psError(PS_ERR_MEMORY_CORRUPTION, true,
    150                 PS_ERRORTEXT_psMemory_NULL_BLOCK);
     150                _("NULL memory block found."));
    151151        return 1;
    152152    }
    … …  
    155155        // using an unreferenced block of memory, are you?
    156156        psError(PS_ERR_MEMORY_CORRUPTION, true,
    157                 PS_ERRORTEXT_psMemory_DEREF_BLOCK_USE,
     157                _("Memory block %lu was freed but still being used."),
    158158                (unsigned long)m->id);
    159159        return 1;
    … …  
    162162    if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC) {
    163163        psError(PS_ERR_MEMORY_CORRUPTION, true,
    164                 PS_ERRORTEXT_psMemory_UNDERFLOW,
     164                _("Memory block %lu is corrupted; buffer underflow detected."),
    165165                (unsigned long)m->id);
    166166        return 1;
    … …  
    168168    if (*(psPtr *)((int8_t *) (m + 1) + m->userMemorySize) != P_PS_MEMMAGIC) {
    169169        psError(PS_ERR_MEMORY_CORRUPTION, true,
    170                 PS_ERRORTEXT_psMemory_OVERFLOW,
     170                _("Memory block %lu is corrupted; buffer overflow detected."),
    171171                (unsigned long)m->id);
    172172        return 1;
    … …  
    506506        psMemBlock* ptr = ((psMemBlock* ) vptr) - 1;
    507507
    508         psAbort(__func__,PS_ERRORTEXT_psMemory_MULTIPLE_FREE,
     508        psAbort(__func__,_("Block %lu, allocated at %s:%d, freed multiple times at %s:%d."),
    509509                (unsigned long)ptr->id, ptr->file, ptr->lineno, filename, lineno);
    510510    }

  • trunk/psLib/src/sys/psString.c

    r7912 r8232  
    1313 *  @author David Robbins, MHPCC
    1414 *
    15  *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
    16  *  @date $Date: 2006-07-15 02:50:51 $
     15 *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
     16 *  @date $Date: 2006-08-08 23:32:23 $
    1717 *
    1818 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828#include "psAbort.h"
    2929
    30 #include "psErrorText.h"
     30
    3131
    3232static void stringFree(psString string)
    … …  
    7878        // Log error message and return NULL
    7979        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    80                 PS_ERRORTEXT_psString_NCHAR_NEGATIVE,
     80                _("Can not copy a negative number of characters (%d)."),
    8181                nChar);
    8282        return NULL;

  • trunk/psLib/src/sys/psTrace.c

    r7571 r8232  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.64 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2006-06-15 00:22:54 $
     11 *  @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2006-08-08 23:32:23 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5151#include "psLogMsg.h"
    5252
    53 #include "psErrorText.h"
     53
    5454
    5555static p_psComponent* cRoot = NULL; // The root of the trace component
    … …  
    132132        if (NULL == currentNode->subcomp[i]) {
    133133            psLogMsg("p_psTraceReset", PS_LOG_WARN,
    134                      PS_ERRORTEXT_psTrace_NULL_SUBCOMPONENT,
     134                     _("Sub-component %d of node %s in trace tree is NULL."),
    135135                     i, currentNode->name);
    136136        } else {
    … …  
    165165    if (strcmp("", addNodeName) == 0) {
    166166        psError(PS_ERR_BAD_PARAMETER_NULL,true,
    167                 PS_ERRORTEXT_psTrace_ADD_NULL_COMPONENT);
     167                _("Failed to add null component to trace tree."));
    168168        return false;
    169169    }
    … …  
    177177    if (addNodeName[0] != '.') {
    178178        psError(PS_ERR_BAD_PARAMETER_VALUE,true,
    179                 PS_ERRORTEXT_psTrace_MALFORMED_COMPONENT_NAME,
     179                _("Failed to add '%s' to the root component tree; component must start with '.'."),
    180180                addNodeName);
    181181        return false;
    … …  
    274274    if ( !componentAdd(compName, level) ) {
    275275        psError(PS_ERR_UNKNOWN, false,
    276                 PS_ERRORTEXT_psTrace_FAILED_TO_ADD_COMPONENT,
     276                _("Failed to set trace level (%d) to '%s'."),
    277277                level,
    278278                compName);
    … …  
    346346            if (NULL == currentNode->subcomp[i]) {
    347347                psLogMsg("p_psTraceReset", PS_LOG_WARN,
    348                          PS_ERRORTEXT_psTrace_NULL_SUBCOMPONENT,
     348                         _("Sub-component %d of node %s in trace tree is NULL."),
    349349                         i, currentNode->name);
    350350            }
    … …  
    504504    if (NULL == comp) {
    505505        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    506                 PS_ERRORTEXT_psTrace_NULL_TRACETREE,
     506                _("Function %s called on a NULL trace level tree."),
    507507                __func__);
    508508        return;
    … …  
    705705        default:
    706706            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    707                     PS_ERRORTEXT_psLogMsg_UNKNOWN_KEY, *ptr);
     707                    _("Unknown logging keyword %c."), *ptr);
    708708            return false;
    709709        }

  • trunk/psLib/src/types/psArguments.c

    r8049 r8232  
    77 *  @author David Robbins, MHPCC
    88 *
    9  *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-08-02 02:28:04 $
     9 *  @version $Revision: 1.9 $ $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
    … …  
    2121#include "psError.h"
    2222#include "psAbort.h"
    23 #include "psErrorText.h"
     23
    2424#include "psLogMsg.h"
    2525#include "psTrace.h"

  • trunk/psLib/src/types/psArray.c

    r7914 r8232  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2006-07-15 02:57:12 $
     11 *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2006-08-08 23:32:23 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828#include "psLogMsg.h"
    2929
    30 #include "psErrorText.h"
     30
    3131
    3232/*****************************************************************************
    … …  
    7979{
    8080    if (in == NULL) {
    81         psError(PS_ERR_BAD_PARAMETER_NULL,true,PS_ERRORTEXT_psArray_REALLOC_NULL);
     81        psError(PS_ERR_BAD_PARAMETER_NULL,true,_("psArrayRealloc must be given a non-NULL psArray to resize."));
    8282        return NULL;
    8383    } else if (in->nalloc != nalloc) {     // No need to realloc to same size
    … …  
    132132    if (array == NULL) {
    133133        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    134                 PS_ERRORTEXT_psArray_ARRAY_NULL);
     134                _("Specified psArray can not be NULL."));
    135135        return false;
    136136    }
    … …  
    184184    {
    185185        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    186                 PS_ERRORTEXT_psArray_ARRAY_NULL);
     186                _("Specified psArray can not be NULL."));
    187187        return false;
    188188    }
    … …  
    208208        if (position >= array->nalloc) {
    209209            psError(PS_ERR_BAD_PARAMETER_NULL, true,
    210                     PS_ERRORTEXT_psArray_POSITION_BEYOND_NALLOC,
     210                    _("Specified position, %d, is greater than the allocated size of the array, %d."),
    211211                    position, array->nalloc);
    212212            return false;
    … …  
    226226    if (array == NULL) {
    227227        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    228                 PS_ERRORTEXT_psArray_ARRAY_NULL);
     228                _("Specified psArray can not be NULL."));
    229229        return NULL;
    230230    }

  • trunk/psLib/src/types/psBitSet.c

    r7914 r8232  
    1111 *  @author Robert DeSonia, MHPCC
    1212 *
    13  *  @version $Revision: 1.32 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2006-07-15 02:57:12 $
     13 *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2006-08-08 23:32:23 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828#include "psString.h"
    2929
    30 #include "psErrorText.h"
     30
    3131
    3232enum {
    … …  
    8282    if (nalloc < 0) {
    8383        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    84                 PS_ERRORTEXT_psBitSet_ALLOC_NEG_SIZE,
     84                _("The number of bit in a psBitSet (%d) must be greater than zero."),
    8585                nalloc);
    8686        return NULL;
    … …  
    108108    if (bitSet == NULL) {
    109109        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    110                 PS_ERRORTEXT_psBitSet_SET_NULL);
     110                _("Can not operate on a NULL psBitSet."));
    111111        return bitSet;
    112112    } else if ( (bit < 0) ||
    113113                (bit > bitSet->n * 8 - 1) ) {
    114114        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    115                 PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE,
     115                _("The specified bit position (%d) is invalid.  Position must be between 0 and %d."),
    116116                bit,bitSet->n * 8 - 1);
    117117        return bitSet;
    … …  
    131131    if (bitSet == NULL) {
    132132        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    133                 PS_ERRORTEXT_psBitSet_SET_NULL);
     133                _("Can not operate on a NULL psBitSet."));
    134134        return bitSet;
    135135    } else if ( (bit < 0) ||
    136136                (bit > bitSet->n * 8 - 1) ) {
    137137        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    138                 PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE,
     138                _("The specified bit position (%d) is invalid.  Position must be between 0 and %d."),
    139139                bit,bitSet->n * 8 - 1);
    140140        return bitSet;
    … …  
    154154    if (bitSet == NULL) {
    155155        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    156                 PS_ERRORTEXT_psBitSet_SET_NULL);
     156                _("Can not operate on a NULL psBitSet."));
    157157        return false;
    158158    } else if ( (bit < 0) ||
    159159                (bit > bitSet->n * 8 - 1) ) {
    160160        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    161                 PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE,
     161                _("The specified bit position (%d) is invalid.  Position must be between 0 and %d."),
    162162                bit,bitSet->n * 8 - 1);
    163163        return false;
    … …  
    183183    if (inBitSet1 == NULL) {
    184184        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    185                 PS_ERRORTEXT_psBitSet_FIRST_OPERAND_NULL);
     185                _("First psBitSet operand can not be NULL."));
    186186        psFree(outBitSet);
    187187        return NULL;
    … …  
    191191    if (operator == NULL) {
    192192        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    193                 PS_ERRORTEXT_psBitSet_OPERATOR_NULL);
     193                _("Specified operator is NULL.  Must specify desired operator."));
    194194        psFree(outBitSet);
    195195        return NULL;
    … …  
    208208        psFree(outBitSet);
    209209        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    210                 PS_ERRORTEXT_psBitSet_OPERATOR_INVALID,
     210                _("Specified operator, %s, is invalid.  Valid operators are AND, OR, and XOR."),
    211211                operator);
    212212        return NULL;
    … …  
    216216        if (inBitSet2 == NULL) {
    217217            psError(PS_ERR_BAD_PARAMETER_NULL, true,
    218                     PS_ERRORTEXT_psBitSet_SECOND_OPERAND_NULL);
     218                    _("Second psBitSet operand can not be NULL."));
    219219            psFree(outBitSet);
    220220            return NULL;
    … …  
    223223        if (inBitSet1->n != inBitSet2->n) {
    224224            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    225                     PS_ERRORTEXT_psBitSet_OPERANDS_SIZE_DIFFER);
     225                    _("The psBitSet operand must be the same size."));
    226226            psFree(outBitSet);
    227227            return NULL;
    … …  
    274274    if (inBitSet == NULL) {
    275275        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    276                 PS_ERRORTEXT_psBitSet_OPERAND_NULL);
     276                _("Operand can not be NULL."));
    277277        psFree(outBitSet);
    278278        return NULL;
    … …  
    283283    if (outBitSet == NULL) {
    284284        psError(PS_ERR_UNKNOWN, false,
    285                 PS_ERRORTEXT_psBitSet_NOT_OP_FAILED);
     285                _("Could not perform NOT operation."));
    286286    }
    287287

  • trunk/psLib/src/types/psHash.c

    r7914 r8232  
    1212*  @author GLG, MHPCC
    1313*
    14 *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
    15 *  @date $Date: 2006-07-15 02:57:12 $
     14*  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
     15*  @date $Date: 2006-08-08 23:32:23 $
    1616*
    1717*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2727#include "psAssert.h"
    2828
    29 #include "psErrorText.h"
     29
    3030
    3131static psHashBucket* hashBucketAlloc(const char *key, psPtr data, psHashBucket* next);
    … …  
    240240    if ((table == NULL) || (key == NULL)) {
    241241        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    242                 PS_ERRORTEXT_psHash_KEY_NULL);
     242                _("Input key can not be NULL."));
    243243        return NULL;
    244244    }

  • trunk/psLib/src/types/psList.c

    r7914 r8232  
    66 *  @author Robert Daniel DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.50 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-07-15 02:57:12 $
     8 *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-08-08 23:32:23 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2121#include "psLogMsg.h"
    2222
    23 #include "psErrorText.h"
     23
    2424
    2525#define ITER_INIT_HEAD ((psPtr )1)         // next iteration should return head
    … …  
    206206    if (location < 0 || location >= (int)list->n) {
    207207        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    208                 PS_ERRORTEXT_psList_LOCATION_INVALID,
     208                _("Specified location, %d, is invalid."),
    209209                location);
    210210        return false;
    … …  
    248248    if (list == NULL) {
    249249        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    250                 PS_ERRORTEXT_psList_LIST_NULL);
     250                _("Specified psList reference is NULL."));
    251251        return false;
    252252    }
    … …  
    254254    if (data == NULL) {
    255255        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    256                 PS_ERRORTEXT_psList_DATA_NULL);
     256                _("Specified data item is NULL."));
    257257        return false;
    258258    }
    … …  
    283283    if (data == NULL) {
    284284        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    285                 PS_ERRORTEXT_psList_DATA_NULL);
     285                _("Specified data item is NULL."));
    286286        return false;
    287287    }
    … …  
    289289    if (iterator == NULL) {
    290290        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    291                 PS_ERRORTEXT_psList_ITERATOR_NULL);
     291                _("Specified iterator is NULL."));
    292292        return false;
    293293    }
    … …  
    296296    if (!iterator->mutable) {
    297297        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    298                 PS_ERRORTEXT_psList_ITERATOR_NONMUTABLE);
     298                _("Specified iterator indicates list is non-mutable."));
    299299        return false;
    300300    }
    … …  
    305305    if (cursor == NULL && list->head != NULL) {
    306306        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    307                 PS_ERRORTEXT_psList_ITERATOR_INVALID);
     307                _("Specified iterator is not valid."));
    308308        return false;
    309309    }
    … …  
    352352    if (data == NULL) {
    353353        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    354                 PS_ERRORTEXT_psList_DATA_NULL);
     354                _("Specified data item is NULL."));
    355355        return false;
    356356    }
    … …  
    358358    if (iterator == NULL) {
    359359        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    360                 PS_ERRORTEXT_psList_ITERATOR_NULL);
     360                _("Specified iterator is NULL."));
    361361        return false;
    362362    }
    … …  
    365365    if (!iterator->mutable) {
    366366        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    367                 PS_ERRORTEXT_psList_ITERATOR_NONMUTABLE);
     367                _("Specified iterator indicates list is non-mutable."));
    368368        return false;
    369369    }
    … …  
    374374    if (cursor == NULL && list->head != NULL) {
    375375        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    376                 PS_ERRORTEXT_psList_ITERATOR_INVALID);
     376                _("Specified iterator is not valid."));
    377377        return false;
    378378    }
    … …  
    422422    if (list == NULL) {
    423423        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    424                 PS_ERRORTEXT_psList_LIST_NULL);
     424                _("Specified psList reference is NULL."));
    425425        return false;
    426426    }
    … …  
    440440    if (list == NULL) {
    441441        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    442                 PS_ERRORTEXT_psList_LIST_NULL);
     442                _("Specified psList reference is NULL."));
    443443        return false;
    444444    }
    … …  
    446446    if (data == NULL) {
    447447        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    448                 PS_ERRORTEXT_psList_DATA_NULL);
     448                _("Specified data item is NULL."));
    449449        return false;
    450450    }
    … …  
    458458    if (elem == NULL) {
    459459        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    460                 PS_ERRORTEXT_psList_DATA_NOT_FOUND);
     460                _("Specified data item is not found in the psList."));
    461461        return false;
    462462    }
    … …  
    473473    if (list == NULL) {
    474474        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    475                 PS_ERRORTEXT_psList_LIST_NULL);
     475                _("Specified psList reference is NULL."));
    476476        return NULL;
    477477    }
    … …  
    485485    if (! psListIteratorSet(iterator,location)) {
    486486        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    487                 PS_ERRORTEXT_psList_LOCATION_INVALID,
     487                _("Specified location, %d, is invalid."),
    488488                location);
    489489        return NULL;

  • trunk/psLib/src/types/psLookupTable.c

    r7943 r8232  
    77*  @author Ross Harman, MHPCC
    88*
    9 *  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2006-07-20 13:00:10 $
     9*  @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-08-08 23:32:23 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    2525#include "psError.h"
    2626#include "psLookupTable.h"
    27 #include "psErrorText.h"
     27
    2828#include "psAssert.h"
    2929
    … …  
    487487        // Open specified file
    488488        if((fp=fopen(filename, "r")) == NULL) {
    489             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psLookupTable_FILE_NOT_FOUND,
     489            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed to open file %s."),
    490490                    filename);
    491491            psFree(outputArray);
    … …  
    813813        if(hiIdx >= numRows) {
    814814            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    815                     PS_ERRORTEXT_psLookupTable_INTERPOLATE_HIGH, hiIdx);
     815                    _("High index too big, %d."), hiIdx);
    816816            return NAN;
    817817        }
    … …  
    823823    if(loIdx < 0) {
    824824        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    825                 PS_ERRORTEXT_psLookupTable_INTERPOLATE_LOW, loIdx);
     825                _("Low index too small, %d."), loIdx);
    826826        return NAN;
    827827    }
    … …  
    832832    denom -= convertVal;
    833833    if(fabs(denom) < FLT_EPSILON) {
    834         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psLookupTable_DIVIDE_BY_ZERO);
     834        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Divide by zero error during interpolation."));
    835835        return NAN;
    836836    } else {

  • trunk/psLib/src/types/psMetadata.c

    r7937 r8232  
    1212 *  @author Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.120 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-07-19 03:43:14 $
     14 *  @version $Revision: 1.121 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-08-08 23:32:23 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3636#include "psLookupTable.h"
    3737#include "psString.h"
    38 #include "psErrorText.h"
     38
    3939#include "psAssert.h"
    4040#include "psLogMsg.h"
    … …  
    319319        break;
    320320    default:
    321         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, type);
     321        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified psDataType, %d, is not supported."), type);
    322322        psFree(metadataItem);
    323323        metadataItem = NULL;
    … …  
    554554            // add to the hash's list of duplicate entries
    555555            if (! psListAdd(existingEntry->data.list, PS_LIST_TAIL, (psPtr)item) ) {
    556                 psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED,key);
     556                psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to metadata collection list."),key);
    557557                return false;
    558558            }
    … …  
    565565            // treat as if new (added to list below)
    566566            if(!psHashAdd(mdTable, key, (psPtr)item)) {
    567                 psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
     567                psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to items table."),key);
    568568                return false;
    569569            }
    … …  
    578578            }
    579579            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    580                     PS_ERRORTEXT_psMetadata_DUPLICATE_NOT_ALLOWED);
     580                    _("Duplicate metadata item name is not allowed.  Use a psMetadataFlags option to allow such action."));
    581581            return false;
    582582        }
    … …  
    586586        // Node doesn't exist - Add new metadata item to metadata collection's hash
    587587        if(!psHashAdd(mdTable, key, (psPtr)item)) {
    588             psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
     588            psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to items table."),key);
    589589            return false;
    590590        }
    … …  
    597597
    598598    if(!psListAdd(mdList, location, (psPtr)item)) {
    599         psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED,key);
     599        psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to metadata collection list."),key);
    600600        return false;
    601601    }
    … …  
    635635
    636636    if (!psMetadataAddItem(md, metadataItem, location, format & PS_METADATA_FLAGS_MASK)) {
    637         psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_FAILED);
     637        psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item to metadata collection list."));
    638638        psFree(metadataItem);
    639639        return false;
    … …  
    717717        psMetadataItem* entry = psHashLookup(mdTable,key);
    718718        if (entry == NULL) {
    719             psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED, key);
     719            psError(PS_ERR_UNKNOWN, false, _("Failed to remove metadata item, %s, from metadata table."), key);
    720720            return false;
    721721        }
    … …  
    739739        psMetadataItem* entry = psListGet(mdList, where);
    740740        if (entry == NULL) {
    741             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED, where);
     741            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Could not find metadata item at index %d."), where);
    742742            return false;
    743743        }
    … …  
    745745
    746746        if (key == NULL) {
    747             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_REMOVE_LIST_INDEX_FAILED, where);
     747            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed to remove metadata item, at index %d, from metadata list."), where);
    748748            return false;
    749749        }
    … …  
    751751        psMetadataItem* tableItem = psHashLookup(mdTable, key);
    752752        if (tableItem == NULL) {
    753             psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED, key);
     753            psError(PS_ERR_UNKNOWN, false, _("Failed to remove metadata item, %s, from metadata table."), key);
    754754            return false;
    755755        }
    … …  
    760760        } else {
    761761            if (!psHashRemove(mdTable, key)) {
    762                 psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED, key);
     762                psError(PS_ERR_UNKNOWN, false, _("Failed to remove metadata item, %s, from metadata table."), key);
    763763                return false;
    764764            }
    … …  
    828828        }
    829829        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    830                 PS_ERRORTEXT_psMetadata_METATYPE_INVALID,
     830                _("Specified psDataType, %d, is not supported."),
    831831                metadataItem->type);
    832832        return NULL;
    … …  
    928928    entry = (psMetadataItem*) psListGet(md->list, location);
    929929    if (entry == NULL) {
    930         psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED, location);
     930        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Could not find metadata item at index %d."), location);
    931931        return NULL;
    932932    }
    … …  
    954954            regerror(regRtn, newIter->regex, errMsg, 256);
    955955            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    956                     PS_ERRORTEXT_psMetadata_REGEX_INVALID,
     956                    _("Specified regular expression is invalid.  %s."),
    957957                    errMsg);
    958958            psFree(newIter);
    … …  
    13331333                default:
    13341334                    psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    1335                             PS_ERRORTEXT_psMetadata_METATYPE_INVALID, vector->type.type);
     1335                            _("Specified psDataType, %d, is not supported."), vector->type.type);
    13361336                    return false;
    13371337                }

  • trunk/psLib/src/types/psMetadataConfig.c

    r8146 r8232  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-08-04 22:58:58 $
     12*  @version $Revision: 1.70 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-08-08 23:32:23 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3232#include "psMetadataConfig.h"
    3333#include "psAssert.h"
    34 #include "psErrorText.h"
     34
    3535
    3636/******************************************************************************/
    … …  
    399399                *status = 1;
    400400                psError(PS_ERR_BAD_PARAMETER_VALUE,true,
    401                         PS_ERRORTEXT_psMetadataIO_TYPE_INVALID,
     401                        _("Specified type, %d, is not supported."),
    402402                        elemType);
    403403            }
    … …  
    510510        default: \
    511511            psError(PS_ERR_BAD_PARAMETER_TYPE,true, \
    512                     PS_ERRORTEXT_psMetadata_METATYPE_INVALID, (int)type); \
     512                    _("Specified psDataType, %d, is not supported."), (int)type); \
    513513            success = false; \
    514514        } \
    … …  
    542542        } else {
    543543            psError(PS_ERR_BAD_PARAMETER_TYPE,true,
    544                     PS_ERRORTEXT_psMetadata_METATYPE_INVALID, (int)type);
     544                    _("Specified psDataType, %d, is not supported."), (int)type);
    545545            success = false;
    546546        }
    … …  
    551551    default:
    552552        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    553                 PS_ERRORTEXT_psMetadata_FORMAT_INVALID, *fType);
     553                _("Specified print format, %%%c, is not supported."), *fType);
    554554        break;
    555555    }
    … …  
    709709    // Check for no type
    710710    if(strType==NULL) {
    711         psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "type",lineCount,
     711        psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "type",lineCount,
    712712                fileName);
    713713        returnValue = false;
    … …  
    741741                vectorType = PS_TYPE_F64;
    742742            } else {
    743                 psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, "", keyName,
     743                psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), "", keyName,
    744744                        strType, lineCount, fileName);
    745745                psFree(strType);
    … …  
    786786                        // Check for add failure
    787787                        if (! addStatus) {
    788                             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_OVERWRITE_ITEM,
     788                            psError(PS_ERR_IO, true, _("Duplicate Metadata item, %s, found on line %u of %s.  Overwrite not allowed."),
    789789                                    keyName, lineCount, fileName);
    790790                            psFree(strType);
    … …  
    795795                    } else {
    796796                        // Metadata type read error
    797                         psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
     797                        psError(PS_ERR_IO,true,_("Failed to read a metadata %s on line %u of %s."),
    798798                                keyName,lineCount,fileName);
    799799                        psFree(strType);
    … …  
    805805            }
    806806            if(!typeFound) {
    807                 psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
     807                psError(PS_ERR_IO, true, _("Metadata type '%s', found on line %u of %s, is invalid."),
    808808                        strType, lineCount,fileName);
    809809                psFree(strType);
    … …  
    822822        strValue = getToken(&linePtr, "#", &status,true);
    823823        if(status) {
    824             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "value", lineCount,
     824            psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "value", lineCount,
    825825                    fileName);
    826826            psFree(strType);
    … …  
    829829        }
    830830        if(strValue==NULL) {
    831             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "value", lineCount,
     831            psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "value", lineCount,
    832832                    fileName);
    833833            psFree(strType);
    … …  
    839839        strComment = getToken(&linePtr,"~", &status,true);
    840840        if(status) {
    841             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "comment", lineCount,
     841            psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "comment", lineCount,
    842842                    fileName);
    843843            psFree(strType);
    … …  
    864864                                      strComment, tempBool);
    865865        } else {
    866             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
     866            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    867867                    strType, lineCount, fileName);
    868868            returnValue = false;
    … …  
    878878        } else {
    879879            psError(PS_ERR_IO, true,
    880                     PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName, strType, lineCount,
     880                    _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName, strType, lineCount,
    881881                    fileName);
    882882            returnValue = false;
    … …  
    888888            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempInt);
    889889        } else {
    890             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
     890            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    891891                    strType, lineCount, fileName);
    892892            returnValue = false;
    … …  
    898898            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempInt);
    899899        } else {
    900             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
     900            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    901901                    strType, lineCount, fileName);
    902902            returnValue = false;
    … …  
    908908            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempInt);
    909909        } else {
    910             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
     910            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    911911                    strType, lineCount, fileName);
    912912            returnValue = false;
    … …  
    918918            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempUint);
    919919        } else {
    920             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
     920            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    921921                    strType, lineCount, fileName);
    922922            returnValue = false;
    … …  
    928928            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempUint);
    929929        } else {
    930             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
     930            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    931931                    strType, lineCount, fileName);
    932932            returnValue = false;
    … …  
    938938            addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempUint);
    939939        } else {
    940             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
     940            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    941941                    strType, lineCount, fileName);
    942942            returnValue = false;
    … …  
    958958                                      strComment, mTime);
    959959        } else {
    960             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
     960            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    961961                    strType, lineCount, fileName);
    962962            returnValue = false;
    … …  
    971971                                      strComment, tempVec);
    972972        } else {
    973             psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
     973            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
    974974                    strType, lineCount, fileName);
    975975            returnValue = false;
    … …  
    983983        for(psS32 k=0; k < nonUniqueKeys->n; k++) {
    984984            if(strcmp(keyName,(char*)nonUniqueKeys->data[k]) == 0) {
    985                 psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_DUPLICATE_MULTI,
     985                psError(PS_ERR_IO,true,_("Duplicate MULTI specifier on line %u of %s."),
    986986                        lineCount,fileName);
    987987                psFree(strType);
    … …  
    10091009        break;
    10101010    default:
    1011         psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
     1011        psError(PS_ERR_IO,true,_("Metadata type '%s', found on line %u of %s, is invalid."),
    10121012                lineCount,fileName);
    10131013        break;
    … …  
    10571057        if(repeatedChars(linePtr, '@') > 1) {
    10581058            psError(PS_ERR_IO, true,
    1059                     PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR, '@', lineCount, fileName);
     1059                    _("More than one '%c' character not allowed.  Found on line %u of %s."), '@', lineCount, fileName);
    10601060            return false;
    10611061        }
    … …  
    10651065        if(status) {
    10661066            psError(PS_ERR_IO, true,
    1067                     PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "keyName", lineCount, fileName);
     1067                    _("Failed to read a metadata %s on line %u of %s."), "keyName", lineCount, fileName);
    10681068            psFree(keyName);
    10691069            return false;
    … …  
    10751075            strType = getToken(&linePtr," ",&status,true);
    10761076            if(strType == NULL) {
    1077                 psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,"type",lineCount,
     1077                psError(PS_ERR_IO,true,_("Failed to read a metadata %s on line %u of %s."),"type",lineCount,
    10781078                        fileName);
    10791079                psFree(keyName);
    … …  
    10891089                    // Compare type name with the list of current types
    10901090                    if(strcmp(strType,(char*)typeArray->data[k]) == 0) {
    1091                         psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_TYPE_DUPLICATE,
     1091                        psError(PS_ERR_IO,true,_("Specified type, %s, on line %u of %s is already defined."),
    10921092                                strType,lineCount,fileName);
    10931093                        psFree(tempTemplate);
    … …  
    11041104                psFree(tempTemplate);
    11051105            } else {
    1106                 psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
     1106                psError(PS_ERR_IO,true,_("Metadata type '%s', found on line %u of %s, is invalid."),
    11071107                        strType,lineCount,fileName);
    11081108                psFree(keyName);
    … …  
    11871187    // Attempt to open specified file
    11881188    if((fp=fopen(filename, "r")) == NULL) {
    1189         psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED, filename);
     1189        psError(PS_ERR_IO, true, _("Failed to open file '%s'. Check if it exists and it has the proper permissions."), filename);
    11901190        return NULL;
    11911191    }
    … …  
    12461246            // XXX : this is probably not the right error value
    12471247            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    1248                     PS_ERRORTEXT_psMetadata_METATYPE_INVALID, PS_DATA_UNKNOWN);
     1248                    _("Specified psDataType, %d, is not supported."), PS_DATA_UNKNOWN);
    12491249            psFree(keys);
    12501250            psFree(format);
    … …  
    13851385            psStringAppend(&content, "PS_TIME_TT  ");
    13861386        else {
    1387             psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, time->type);
     1387            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified psDataType, %d, is not supported."), time->type);
    13881388            psFree(content);
    13891389            return NULL;
    … …  
    14691469        default:
    14701470            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    1471                     PS_ERRORTEXT_psMetadata_METATYPE_INVALID, vector->type.type);
     1471                    _("Specified psDataType, %d, is not supported."), vector->type.type);
    14721472            psFree(content);
    14731473            return NULL;
    … …  
    14811481    default:
    14821482        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    1483                 PS_ERRORTEXT_psMetadata_METATYPE_INVALID, item->type);
     1483                _("Specified psDataType, %d, is not supported."), item->type);
    14841484        psFree(content);
    14851485        return NULL;

  • trunk/psLib/src/types/psPixels.c

    r7914 r8232  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2006-07-15 02:57:12 $
     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
    … …  
    2020
    2121#include "psError.h"
    22 #include "psErrorText.h"
     22
    2323
    2424typedef int(*qsortCompareFcn)(const void *, const void *);
    … …  
    133133{
    134134    if (pixels == NULL) {
    135         psError(PS_ERR_BAD_PARAMETER_NULL,true,PS_ERRORTEXT_psPixels_NULL);
     135        psError(PS_ERR_BAD_PARAMETER_NULL,true,_("Input psPixels can not be NULL."));
    136136        psFree(out);
    137137        return NULL;
    … …  
    154154    if (pixels == NULL) {
    155155        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    156                 PS_ERRORTEXT_psPixels_NULL);
     156                _("Input psPixels can not be NULL."));
    157157        psFree(out);
    158158        return NULL;
    … …  
    161161    if (data == NULL) {
    162162        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    163                 PS_ERRORTEXT_psPixels_DATA_NULL);
     163                _("Input psPixels contains no data."));
    164164        psFree(out);
    165165        return NULL;
    … …  
    173173    if ( (x0 < 0 || x1 < 0) || (y0 < 0 || y1 < 0) ) {
    174174        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    175                 PS_ERRORTEXT_psPixels_REGION_INVALID,
     175                _("Specified psRegion, [%d:%d,%d:%d], does not specify a valid region."),
    176176                (int)y0,(int)y1,(int)x0,(int)x1);
    177177        psFree(out);
    … …  
    186186    if (numRows < 1 || numCols < 1) {
    187187        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    188                 PS_ERRORTEXT_psPixels_REGION_INVALID,
     188                _("Specified psRegion, [%d:%d,%d:%d], does not specify a valid region."),
    189189                (int)y0,(int)y1,(int)x0,(int)x1);
    190190        psFree(out);
    … …  
    196196    if (out == NULL) {
    197197        psError(PS_ERR_UNKNOWN, false,
    198                 PS_ERRORTEXT_psPixels_FAILED_IMAGE_CREATE,
     198                _("Failed to create image of size %dx%d."),
    199199                numCols, numRows);
    200200        return NULL;
    … …  
    232232    if (mask == NULL) {
    233233        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    234                 PS_ERRORTEXT_psPixels_MASK_NULL);
     234                _("Specified mask can not be NULL."));
    235235        psFree(out);
    236236        return NULL;
    … …  
    240240        PS_TYPE_NAME(typeStr,mask->type.type);
    241241        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
    242                 PS_ERRORTEXT_psPixels_MASK_TYPE,
     242                _("Specified mask's type, %s, is invalid.  Should be PS_TYPE_MASK."),
    243243                typeStr);
    244244        psFree(out);
    … …  
    295295    if (pixels == NULL) {
    296296        psError(PS_ERR_BAD_PARAMETER_NULL, true,
    297                 PS_ERRORTEXT_psPixels_NULL);
     297                _("Input psPixels can not be NULL."));
    298298        return NULL;
    299299    }
    … …  
    363363{
    364364    if (pixels == NULL) {
    365         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psPixels_NULL);
     365        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("Input psPixels can not be NULL."));
    366366        return false;
    367367    }
    … …  
    397397    psPixelCoord out;
    398398    if (pixels == NULL) {
    399         psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psPixels_NULL);
     399        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("Input psPixels can not be NULL."));
    400400        out.x = 0; //XXX: should be NAN when changed to float
    401401        out.y = 0; //XXX: should be NAN when changed to float

  • trunk/psLib/src/xml/psXML.c

    r7766 r8232  
    1010*  @author David Robbins, MHPCC
    1111*
    12 *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-06-30 02:20:06 $
     12*  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-08-08 23:32:23 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    133133            else {
    134134                psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    135                         PS_ERRORTEXT_psXML_INVALID_CONTENT);
     135                        _("Failed to recognize XML content.  Invalid syntax."));
    136136                return NULL;
    137137            }
    … …  
    188188            default:
    189189                psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    190                         PS_ERRORTEXT_psXML_INVALID_DATATYPE);
     190                        _("Failed to recognize datatype from/for XML file."));
    191191                psFree(XML);
    192192                psFree(iter);
    … …  
    198198        default:
    199199            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    200                     PS_ERRORTEXT_psXML_INVALID_DATATYPE);
     200                    _("Failed to recognize datatype from/for XML file."));
    201201            psFree(XML);
    202202            psFree(iter);
    … …  
    283283    default:
    284284        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    285                 PS_ERRORTEXT_psXML_INVALID_DATATYPE);
     285                _("Failed to recognize datatype from/for XML file."));
    286286    }
    287287}
    … …  
    299299    else
    300300        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    301                 PS_ERRORTEXT_psXML_INVALID_CONTENT);
     301                _("Failed to recognize XML content.  Invalid syntax."));
    302302    in = endp;
    303303    nsec = (unsigned int)strtol(in, &endp, 10);
    … …  
    307307    else
    308308        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    309                 PS_ERRORTEXT_psXML_INVALID_CONTENT);
     309                _("Failed to recognize XML content.  Invalid syntax."));
    310310    in = endp;
    311311    if ( !strncmp(in, "false", 10) || !strncmp(in, "f", 10) ||
    … …  
    317317    else {
    318318        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    319                 PS_ERRORTEXT_psXML_INVALID_CONTENT);
     319                _("Failed to recognize XML content.  Invalid syntax."));
    320320    }
    321321}
    … …  
    335335        } else {
    336336            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    337                     PS_ERRORTEXT_psXML_INVALID_CONTENT);
     337                    _("Failed to recognize XML content.  Invalid syntax."));
    338338            return(PS_DATA_UNKNOWN);
    339339        }
    … …  
    348348        } else {
    349349            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    350                     PS_ERRORTEXT_psXML_INVALID_CONTENT);
     350                    _("Failed to recognize XML content.  Invalid syntax."));
    351351            return(PS_DATA_UNKNOWN);
    352352        }
    … …  
    360360        } else {
    361361            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    362                     PS_ERRORTEXT_psXML_INVALID_CONTENT);
     362                    _("Failed to recognize XML content.  Invalid syntax."));
    363363            return(PS_DATA_UNKNOWN);
    364364        }
    … …  
    370370        } else {
    371371            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    372                     PS_ERRORTEXT_psXML_INVALID_CONTENT);
     372                    _("Failed to recognize XML content.  Invalid syntax."));
    373373            return(PS_DATA_UNKNOWN);
    374374        }
    … …  
    398398            if ( nodeNum == 0 && strncmp((const char*)cur_node->name, "metadata", MAXSTR) ) {
    399399                psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    400                         PS_ERRORTEXT_psXML_INVALID_CONTENT);
     400                        _("Failed to recognize XML content.  Invalid syntax."));
    401401                psFree(meta);
    402402                return NULL;
    … …  
    440440                            || elemType == PS_DATA_BOOL) {
    441441                        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    442                                 PS_ERRORTEXT_psXML_INVALID_DATATYPE);
     442                                _("Failed to recognize datatype from/for XML file."));
    443443                        psFree(meta);
    444444                        return NULL;
    … …  
    467467                    else {
    468468                        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    469                                 PS_ERRORTEXT_psXML_INVALID_CONTENT);
     469                                _("Failed to recognize XML content.  Invalid syntax."));
    470470                        psFree(meta);
    471471                        return NULL;
    … …  
    501501                    } else {
    502502                        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    503                                 PS_ERRORTEXT_psXML_INVALID_CONTENT);
     503                                _("Failed to recognize XML content.  Invalid syntax."));
    504504                        psFree(meta);
    505505                        return NULL;
    … …  
    509509                default:
    510510                    psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    511                             PS_ERRORTEXT_psXML_INVALID_DATATYPE);
     511                            _("Failed to recognize datatype from/for XML file."));
    512512                    psFree(meta);   //XXX: Do I really need this?
    513513                    return NULL;
    … …  
    558558    FILE *file;
    559559    if( (file = fopen(filename, "w")) == NULL ) {
    560         psError(PS_ERR_IO, true, PS_ERRORTEXT_psXML_IO_FILE_OPEN_FAILED, filename);
     560        psError(PS_ERR_IO, true, _("Failed to open file '%s'. Check if it exists and it has the proper permissions."), filename);
    561561        return false;
    562562    }
    … …  
    592592    xmlDocDumpMemory(*doc, &buff, &bufferSize);
    593593    if ( MAXVEC < strlen((char *)buff) ) {
    594         psError(PS_ERR_LOCATION_INVALID, true, PS_ERRORTEXT_psXML_BUFFER_TOO_SMALL);
     594        psError(PS_ERR_LOCATION_INVALID, true, _("Buffer to small to store XML doc."));
    595595        //        xmlFree(buff);
    596596        return false;
    … …  
    628628        write(fd, buf, n);
    629629    } else {
    630         psError(PS_ERR_LOCATION_INVALID, true, PS_ERRORTEXT_psXML_BUFFER_TOO_SMALL);
     630        psError(PS_ERR_LOCATION_INVALID, true, _("Buffer to small to store XML doc."));
    631631        return false;
    632632    }

  • trunk/psLib/src/xml/psXML.h

    r5000 r8232  
    1010 *  @author David Robbins, MHPCC
    1111 *
    12  *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-09-12 21:36:54 $
     12 *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-08-08 23:32:23 $
    1414 *
    1515 *  Copyright 2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3232#include "psConstants.h"
    3333#include "psTime.h"
    34 #include "psErrorText.h"
     34
    3535
    3636
Note: See TracChangeset for help on using the changeset viewer.