Changeset 8232

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:

• . (modified) (1 prop)
• .cvsignore (modified) (1 diff)
• Makefile.am (modified) (2 diffs)
• astro/psCoord.c (modified) (4 diffs)
• astro/psEarthOrientation.c (modified) (13 diffs)
• astro/psSphereOps.c (modified) (8 diffs)
• astro/psTime.c (modified) (43 diffs)
• db/psDB.c (modified) (17 diffs)
• fft/psImageFFT.c (modified) (13 diffs)
• fft/psVectorFFT.c (modified) (10 diffs)
• fits/psFits.c (modified) (31 diffs)
• fits/psFitsHeader.c (modified) (10 diffs)
• fits/psFitsImage.c (modified) (33 diffs)
• fits/psFitsTable.c (modified) (30 diffs)
• imageops/psImageConvolve.c (modified) (13 diffs)
• imageops/psImageGeomManip.c (modified) (30 diffs)
• imageops/psImageMaskOps.c (modified) (2 diffs)
• imageops/psImagePixelExtract.c (modified) (25 diffs)
• imageops/psImagePixelManip.c (modified) (21 diffs)
• imageops/psImageStats.c (modified) (5 diffs)
• imageops/psImageStructManip.c (modified) (12 diffs)
• math/psBinaryOp.c (modified) (23 diffs)
• math/psMathUtils.c (modified) (2 diffs)
• math/psMatrix.c (modified) (3 diffs)
• math/psPolynomial.c (modified) (6 diffs)
• math/psRandom.c (modified) (8 diffs)
• math/psRegion.c (modified) (4 diffs)
• math/psSpline.c (modified) (2 diffs)
• math/psStats.c (modified) (7 diffs)
• math/psUnaryOp.c (modified) (11 diffs)
• mathtypes/psImage.c (modified) (10 diffs)
• mathtypes/psScalar.c (modified) (5 diffs)
• mathtypes/psVector.c (modified) (18 diffs)
• psErrorText.h.in (deleted)
• psErrorText_en.dat (deleted)
• sys/psConfigure.c (modified) (6 diffs)
• sys/psErrorCodes.c.in (modified) (2 diffs)
• sys/psLogMsg.c (modified) (4 diffs)
• sys/psMemory.c (modified) (8 diffs)
• sys/psString.c (modified) (3 diffs)
• sys/psTrace.c (modified) (9 diffs)
• types/psArguments.c (modified) (2 diffs)
• types/psArray.c (modified) (7 diffs)
• types/psBitSet.c (modified) (13 diffs)
• types/psHash.c (modified) (3 diffs)
• types/psList.c (modified) (19 diffs)
• types/psLookupTable.c (modified) (6 diffs)
• types/psMetadata.c (modified) (18 diffs)
• types/psMetadataConfig.c (modified) (36 diffs)
• types/psPixels.c (modified) (13 diffs)
• xml/psXML.c (modified) (20 diffs)
• xml/psXML.h (modified) (2 diffs)

trunk/psLib/src

@@ -10 +10 @@
 libpslib.la.temp
 config.h.in
-psErrorText.h
 *.bb
 *.bbg

@@ -10 +10 @@
 libpslib.la.temp
 config.h.in
-psErrorText.h
 *.bb
 *.bbg

trunk/psLib/src/.cvsignore

@@ -10 +10 @@
 libpslib.la.temp
 config.h.in
-psErrorText.h
 *.bb
 *.bbg

trunk/psLib/src/Makefile.am

@@ -11 +11 @@
 
 
-EXTRA_DIST = mainpage.dox psErrorCodes_en.dat psTest.h psErrorText.h.in psErrorText_en.dat
-
-BUILT_SOURCES = psErrorText.h
-psErrorText.h: psErrorText_$(PS_LANG).dat
-        $(top_srcdir)/psParseErrorCodes --data=$? $(srcdir)/psErrorText.h
+EXTRA_DIST = mainpage.dox psErrorCodes_en.dat psTest.h 
 
 pslibincludedir = $(includedir)
@@ -21 +17 @@
         psTest.h \
         pslib.h \
-        pslib_strict.h \
-        psErrorText.h
+        pslib_strict.h
 
 install-exec-local: libpslib.la

trunk/psLib/src/astro/psCoord.c

@@ -10 +10 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.121 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-07-15 02:57:12 $
+*  @version $Revision: 1.122 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:22 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -26 +26 @@
 #include "psLogMsg.h"
 #include "psTrace.h"
-#include "psErrorText.h"
+
 #include "psMatrix.h"
 #include "psMinimizePolyFit.h"
@@ -435 +435 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psCoord_PROJECTION_TYPE_UNKNOWN,
+                _("The projection type, %d, is unknown."),
                 projection->type);
         psFree(out);
@@ -537 +537 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psCoord_PROJECTION_TYPE_UNKNOWN,
+                _("The projection type, %d, is unknown."),
                 projection->type);
         psFree(out);

trunk/psLib/src/astro/psEarthOrientation.c

@@ -8 +8 @@
  *  @author Robert Daniel DeSonia, MHPCC
  *
- *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-30 02:20:06 $
+ *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:22 $
  *
  *  Copyright 2005 Maui High Performance Computing Center, University of Hawaii
@@ -24 +24 @@
 #include "psMetadataConfig.h"
 #include "psError.h"
-#include "psErrorText.h"
+
 #include "psMemory.h"
 #include "psCoord.h"
@@ -103 +103 @@
                                             "psLib.eoc.precession.table.format");
     if(! success || tableFormat == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.table.format");
         return false;
@@ -112 +112 @@
     if(! success || xTableName == NULL) {
         psFree(tableFormat);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.x.file");
         return false;
@@ -122 +122 @@
         psFree(tableFormat);
         psFree(xTableName);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.y.file");
         return false;
@@ -133 +133 @@
         psFree(xTableName);
         psFree(yTableName);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.s.file");
         return false;
@@ -145 +145 @@
         psFree(yTableName);
         psFree(sTableName);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.iers.file");
         return false;
@@ -158 +158 @@
         psFree(sTableName);
         psFree(iersTableName);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.finals.file");
         return false;
@@ -172 +172 @@
         psFree(iersTableName);
         psFree(finalsTableName);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.iers.table.format");
         return false;
@@ -187 +187 @@
         psFree(finalsTableName);
         psFree(iersTableFormat);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.iers.table.format");
         return false;
@@ -214 +214 @@
     psVector* xCoeff = psMetadataLookupPtr(&success, eocMetadata, "psLib.eoc.precession.poly.x");
     if(! success || xCoeff == NULL || xCoeff->type.type != PS_TYPE_F64) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.poly.x");
         return false;
@@ -221 +221 @@
     if(! success || yCoeff == NULL || yCoeff->type.type != PS_TYPE_F64) {
         psFree(xCoeff);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.poly.y");
         return false;
@@ -229 +229 @@
         psFree(xCoeff);
         psFree(yCoeff);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.eoc.precession.poly.s");
         return false;

trunk/psLib/src/astro/psSphereOps.c

@@ -8 +8 @@
  *  @author Dave Robbins, MHPCC
  *
- *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:57:12 $
+ *  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:22 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -25 +25 @@
 #include "psError.h"
 #include "psLogMsg.h"
-#include "psErrorText.h"
+
 
 
@@ -225 +225 @@
     // Check the specified MJD is greater than 1900
     if ( MJD < MJD_1900 ) {
-        psError(PS_ERR_BAD_PARAMETER_TYPE,true,PS_ERRORTEXT_psCoord_INVALID_MJD);
+        psError(PS_ERR_BAD_PARAMETER_TYPE,true,_("Specified time is less than 1900."));
         return NULL;
     }
@@ -252 +252 @@
     // Check the specified MJD is greater than 1900
     if ( MJD < MJD_1900 ) {
-        psError(PS_ERR_BAD_PARAMETER_TYPE,true,PS_ERRORTEXT_psCoord_INVALID_MJD);
+        psError(PS_ERR_BAD_PARAMETER_TYPE,true,_("Specified time is less than 1900."));
         return NULL;
     }
@@ -361 +361 @@
         else {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psCoord_UNITS_UNKNOWN,
+                    _("Specified units, 0x%x, is not supported."),
                     unit);
             psFree(tmp);
@@ -370 +370 @@
     } else {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psCoord_OFFSET_MODE_UNKNOWN,
+                _("Specified offset mode, 0x%x, is not supported."),
                 mode);
         psFree(tmp);
@@ -432 +432 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psCoord_UNITS_UNKNOWN,
+                    _("Specified units, 0x%x, is not supported."),
                     unit);
             return NULL;
@@ -451 +451 @@
     } else {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psCoord_OFFSET_MODE_UNKNOWN,
+                _("Specified offset mode, 0x%x, is not supported."),
                 mode);
         return NULL;

trunk/psLib/src/astro/psTime.c

@@ -10 +10 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.92 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-25 01:16:04 $
+ *  @version $Revision: 1.93 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:22 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -33 +33 @@
 #include "psLookupTable.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 
 #include "config.h"
@@ -205 +205 @@
         // Check if table not a metadata item
         if(tableMetadataItem == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                     tableName);
             *status = PS_LOOKUP_ERROR;
@@ -282 +282 @@
     if(metadataItem == NULL) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.time.tables.n");
         return false;
@@ -292 +292 @@
     if(metadataItem == NULL) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.time.tables.from");
         return false;
@@ -299 +299 @@
     if(tablesFrom->n != numTables) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_BAD_VECTOR, tablesFrom->n, numTables);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Incorrect vector size. Size: %d, Expected %d."), tablesFrom->n, numTables);
         psFree(tablesFrom);
         return false;
@@ -308 +308 @@
     if(metadataItem == NULL) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.time.tables.to");
         psFree(tablesFrom);
@@ -316 +316 @@
     if(tablesTo->n != numTables) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_BAD_VECTOR, tablesTo->n, numTables);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Incorrect vector size. Size: %d, Expected %d."), tablesTo->n, numTables);
         psFree(tablesFrom);
         psFree(tablesTo);
@@ -326 +326 @@
     if(metadataItem == NULL) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Failed find '%s' in time metadata."),
                 "psLib.time.tables.index");
         psFree(tablesFrom);
@@ -335 +335 @@
     if(tablesIndex->n != numTables) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_BAD_VECTOR,tablesIndex->n,numTables);
+        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Incorrect vector size. Size: %d, Expected %d."),tablesIndex->n,numTables);
         psFree(tablesFrom);
         psFree(tablesTo);
@@ -346 +346 @@
     if(metadataItem == NULL) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.time.tables.dir");
         psFree(tablesFrom);
@@ -359 +359 @@
     if(metadataItem == NULL) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                 "psLib.time.tables.files");
 
@@ -374 +374 @@
     if(metadataItem == NULL) {
         p_psMemAllocatePersistent(initialPersistence);
-        psError(PS_ERR_BAD_PARAMETER_VALUE,true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+        psError(PS_ERR_BAD_PARAMETER_VALUE,true, _("Failed find '%s' in time metadata."),
                 "psLib.time.tables.format");
         psFree(tablesFrom);
@@ -404 +404 @@
         tableFormat = getToken(&formatPtr,",",&status);
         if(tableFormat == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE,no_problem,PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+            psError(PS_ERR_BAD_PARAMETER_VALUE,no_problem,_("Failed find '%s' in time metadata."),
                     "psLib.time.tables.format");
             no_problem = false;
@@ -415 +415 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_VALUE, no_problem,
-                    PS_ERRORTEXT_psTime_BAD_TABLE_COUNT, i+1, numTables);
+                    _("Incorrect number of table files entered. Found: %d. Expected: %d."), i+1, numTables);
             no_problem = false;
         }
@@ -429 +429 @@
             } else if(foundTable==false && j==numTables-1) {
                 psError(PS_ERR_BAD_PARAMETER_VALUE, no_problem,
-                        PS_ERRORTEXT_psTime_BAD_TABLE_COUNT, j, numTables);
+                        _("Incorrect number of table files entered. Found: %d. Expected: %d."), j, numTables);
                 no_problem = false;
             }
@@ -444 +444 @@
 
     if(numTables != i) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, no_problem, PS_ERRORTEXT_psTime_BAD_TABLE_COUNT, i, numTables);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, no_problem, _("Incorrect number of table files entered. Found: %d. Expected: %d."), i, numTables);
     }
 
@@ -480 +480 @@
             type!=PS_TIME_TT) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psTime_TYPE_UNKNOWN,
+                _("Specified type, %d, is not supported."),
                 type);
         return NULL;
@@ -521 +521 @@
     if (gettimeofday(&now, 0) == -1) {
         psError(PS_ERR_OS_CALL_FAILED, true,
-                PS_ERRORTEXT_psTime_GET_TOD_FAILED);
+                _("Failed to determine the current time from gettimeofday function."));
         return NULL;
     }
@@ -728 +728 @@
             // Convert from TAI to unknown time type
         } else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_UNKNOWN, type);
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is not supported."), type);
             return NULL;
         }
@@ -753 +753 @@
             // Convert from TT to unknown time type
         } else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_UNKNOWN, type);
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is not supported."), type);
             return NULL;
         }
@@ -772 +772 @@
             // Convert UTC to unknown time type
         } else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_UNKNOWN, type);
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is not supported."), type);
             return NULL;
         }
         // Convert unknown time type
     } else {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_UNKNOWN, time->type);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is not supported."), time->type);
         return NULL;
     }
@@ -810 +810 @@
     // Verify input time is not in UT1 seconds
     if(time->type == PS_TIME_UT1) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_TYPE_INCORRECT,time->type);
+        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Specified type, %d, is incorrect."),time->type);
         return NAN;
     }
@@ -897 +897 @@
 
         // Date too early for tables. Get default time delta value from metadata, and issue warning.
-        psLogMsg(__func__,PS_LOG_WARN,PS_ERRORTEXT_psTime_TIME_PREDATES_TABLES,mjd,"UT1-UTC");
+        psLogMsg(__func__,PS_LOG_WARN,_("Specified psTime predates (%g) all tables of %s information."),mjd,"UT1-UTC");
 
         // Lookup value from time metadata loaded from pslib.config
         tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.before.dut");
         if(tableMetadataItem == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                     "psLib.time.before.dut");
             return NAN;
@@ -917 +917 @@
         */
         // Generate warning of postdate information
-        psLogMsg(__func__,PS_LOG_WARN,PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLES, mjd, "UT1-UTC");
+        psLogMsg(__func__,PS_LOG_WARN,_("Specified psTime postdates (%g) all tables of %s information."), mjd, "UT1-UTC");
 
         // Lookup values to calculate prediction
         tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.predict.dut");
         if(tableMetadataItem == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                     "psLib.time.predict.dut");
             return NAN;
@@ -935 +935 @@
 
     } else if(status != PS_LOOKUP_SUCCESS) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_INTERPOLATION_FAILED);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed time table interpolation."));
         return NAN;
     }
@@ -1059 +1059 @@
 
     if(time->type != PS_TIME_TAI) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TYPE_INCORRECT, time->type);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified type, %d, is incorrect."), time->type);
         return NULL;
     }
@@ -1075 +1075 @@
         // Date too earlier for tables. Get default polar coodinate values from metadata, and issue warning.
         #if 0
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_TIME_PREDATES_TABLES, mjd, "polar motion");
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified psTime predates (%g) all tables of %s information."), mjd, "polar motion");
         return NULL;
         #else
 
-        psLogMsg(PS_FILE_LINE, PS_LOG_ERROR, PS_ERRORTEXT_psTime_TIME_PREDATES_TABLES, mjd, "polar motion");
+        psLogMsg(PS_FILE_LINE, PS_LOG_ERROR, _("Specified psTime predates (%g) all tables of %s information."), mjd, "polar motion");
         #endif
 
@@ -1085 +1085 @@
         if(tableMetadataItem == NULL) {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "psLib.time.before.xp");
+                    _("Failed find '%s' in time metadata."), "psLib.time.before.xp");
             return NULL;
         }
@@ -1092 +1092 @@
         tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.before.yp");
         if(tableMetadataItem == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "psLib.time.before.yp");
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."), "psLib.time.before.yp");
             return NULL;
         }
@@ -1110 +1110 @@
         #if 0
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLES, mjd, "polar motion");
+                _("Specified psTime postdates (%g) all tables of %s information."), mjd, "polar motion");
         return NULL;
         #else
 
         psLogMsg(PS_FILE_LINE, PS_LOG_ERROR,
-                 PS_ERRORTEXT_psTime_TIME_POSTDATES_TABLES, mjd, "polar motion");
+                 _("Specified psTime postdates (%g) all tables of %s information."), mjd, "polar motion");
         #endif
 
@@ -1121 +1121 @@
         tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.predict.mjd");
         if(tableMetadataItem == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED,
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."),
                     "psLib.time.predict.mjd");
             return NULL;
@@ -1130 +1130 @@
         tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.predict.xp");
         if(tableMetadataItem == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "psLib.time.predict.xp");
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."), "psLib.time.predict.xp");
             return NULL;
         }
@@ -1139 +1139 @@
         tableMetadataItem = psMetadataLookup(timeMetadata, "psLib.time.predict.yp");
         if(tableMetadataItem == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "psLib.time.predict.yp");
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."), "psLib.time.predict.yp");
             return NULL;
         }
@@ -1163 +1163 @@
 
     } else if(xStatus!=PS_LOOKUP_SUCCESS || yStatus!=PS_LOOKUP_SUCCESS) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_INTERPOLATION_FAILED);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed time table interpolation."));
         return NULL;
     }
@@ -1193 +1193 @@
     // Check if psTime tables are loaded/loadable
     if(!p_psTimeInit(p_psGetConfigFileName())) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_FILE_NOT_FOUND,
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed to open file %s."),
                 p_psGetConfigFileName());
         return NAN;
@@ -1201 +1201 @@
     tableMetadataItem = psMetadataLookup(timeMetadata, "taiTable");
     if(tableMetadataItem == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_LOOKUP_METADATA_FAILED, "taiTable");
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed find '%s' in time metadata."), "taiTable");
         return NAN;
     }
@@ -1228 +1228 @@
     // Check for successful interpolation
     if(results == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_INTERPOLATION_FAILED);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed time table interpolation."));
         return NAN;
     }
@@ -1273 +1273 @@
     // Verify time is UTC type
     if(utc->type != PS_TIME_UTC) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_TYPE_INCORRECT,utc->type);
+        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Specified type, %d, is incorrect."),utc->type);
         return false;
     }
@@ -1371 +1371 @@
     // Converts psTime to YYYY-MM-DDThh:mm:ss.sss in string form
     if (!strftime(tempString, MAX_TIME_STRING_LENGTH, "%Y-%m-%dT%H:%M:%S", tmTime)) {
-        psError(PS_ERR_OS_CALL_FAILED, true, PS_ERRORTEXT_psTime_CONVERT_TIME_TO_STRING_FAILED);
+        psError(PS_ERR_OS_CALL_FAILED, true, _("Failed to convert a time via strftime function."));
         return NULL;
     }
@@ -1385 +1385 @@
     // Create string with milliseconds
     if (snprintf(timeString, MAX_TIME_STRING_LENGTH, "%s.%1dZ", tempString, ds) < 0) {
-        psError(PS_ERR_OS_CALL_FAILED, true, PS_ERRORTEXT_psTime_APPEND_MSEC_FAILED);
+        psError(PS_ERR_OS_CALL_FAILED, true, _("Failed to append millisecond to time string with snprintf function."));
         return NULL;
     }
@@ -1501 +1501 @@
     if (sscanf(input, "%d-%d-%dT%d:%d:%d.%d", &tmTime.tm_year, &tmTime.tm_mon, &tmTime.tm_mday,
                &tmTime.tm_hour, &tmTime.tm_min, &tmTime.tm_sec,&millisecond) < 7) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psTime_ISOTIME_MALFORMED, input);
+        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);
         return NULL;
     }
@@ -1760 +1760 @@
     // Verify both times of the same type
     if(time1->type != time2->type) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE,true,PS_ERRORTEXT_psTime_TYPE_INCORRECT,time1->type);
+        psError(PS_ERR_BAD_PARAMETER_VALUE,true,_("Specified type, %d, is incorrect."),time1->type);
         return NAN;
     }

trunk/psLib/src/db/psDB.c

@@ -12 +12 @@
  *  @author Joshua Hoblitt
  *
- *  @version $Revision: 1.77 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-08-04 03:50:56 $
+ *  @version $Revision: 1.78 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:22 $
  *
  *  Copyright (C) 2005-2006  Joshua Hoblitt, University of Hawaii
@@ -37 +37 @@
 #include "psError.h"
 #include "psString.h"
-#include "psErrorText.h"
+
 
 // set the pointer to NULL if we are actually freeing the memory
@@ -142 +142 @@
     if (!mysql_real_connect(mysql, host, user, passwd, dbname, 0, NULL, 0)) {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psDB_FAILED_TO_CONNECT,mysql_error(mysql));
+                _("Failed to connect to database.  Error: %s"),mysql_error(mysql));
 
         mysql_close(mysql);
@@ -247 +247 @@
     // Attempt to select new database
     if (mysql_select_db(dbh->mysql, dbname) != 0) {
-        psError(PS_ERR_UNKNOWN, true, PS_ERRORTEXT_psDB_FAILED_TO_CHANGE,
+        psError(PS_ERR_UNKNOWN, true, _("Failed to change database.  Error: %s"),
                 mysql_error(dbh->mysql));
 
@@ -287 +287 @@
     char *query = psDBGenerateCreateTableSQL(tableName, md);
     if (!query) {
-        psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
+        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
         return false;
     }
@@ -294 +294 @@
     bool status = p_psDBRunQuery(dbh, query);
     if (!status) {
-        psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psDB_TABLE_CREATE_FAIL);
+        psError(PS_ERR_UNKNOWN, false, _("Failed to create table."));
     }
 
@@ -315 +315 @@
     bool status = p_psDBRunQuery(dbh, query);
     if (!status) {
-        psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psDB_TABLE_DROP_FAIL);
+        psError(PS_ERR_UNKNOWN, false, _("Failed to drop table."));
     }
 
@@ -343 +343 @@
     char *query = psDBGenerateSelectRowSQL(tableName, col, NULL, limit);
     if (!query) {
-        psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
+        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
         return NULL;
     }
@@ -349 +349 @@
     // Execut SQL query string
     if (!p_psDBRunQuery(dbh, query)) {
-        psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psDB_SEL_COL_FAIL);
+        psError(PS_ERR_UNKNOWN, false, _("Failed to select column."));
         psFree(query);
         return NULL;
@@ -365 +365 @@
         // then something bad has happened.
         if (fieldCount != 0) {
-            psError(PS_ERR_UNEXPECTED_NULL, true, PS_ERRORTEXT_psDB_QUERY_NO_DATA,
+            psError(PS_ERR_UNEXPECTED_NULL, true, _("Query returned no data.  Error: %s"),
                     mysql_error(dbh->mysql));
             return NULL;
@@ -561 +561 @@
     // Execute function to insert rows
     if (!psDBInsertRows(dbh, tableName, rowSet)) {
-        psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psDB_INSERT_ROW_FAIL);
+        psError(PS_ERR_UNKNOWN, false, _("Failed to insert row."));
         psFree(rowSet);
         return false;
@@ -586 +586 @@
     char *query = psDBGenerateInsertRowSQL(tableName, row);
     if (!query) {
-        psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
+        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
         return false;
     }
@@ -675 +675 @@
     char *query = psDBGenerateUpdateRowSQL(tableName, where, values);
     if (!query) {
-        psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_QUERY_GEN_FAIL);
+        psError(PS_ERR_UNEXPECTED_NULL, false, _("Query generation failed."));
         return -1;
     }
@@ -801 +801 @@
                 "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);
         if ( !strncmp(mysql_error(dbh->mysql), mysqlTemp, 145) ) {
-            psError(PS_ERR_UNKNOWN, true, PS_ERRORTEXT_psDB_SQL_QUERY_FAIL, mysqlTemp);
+            psError(PS_ERR_UNKNOWN, true, _("Failed to execute SQL query.  Error: %s"), mysqlTemp);
         } else {
-            psError(PS_ERR_UNKNOWN, true, PS_ERRORTEXT_psDB_SQL_QUERY_FAIL, mysql_error(dbh->mysql));
+            psError(PS_ERR_UNKNOWN, true, _("Failed to execute SQL query.  Error: %s"), mysql_error(dbh->mysql));
         }
         psFree(query);
@@ -1405 +1405 @@
     setSQL = psDBGenerateSetSQL(values);
     if (!setSQL) {
-        psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_SQL_SUBSTR_FAIL);
+        psError(PS_ERR_UNEXPECTED_NULL, false, _("SQL substring generation failed."));
         return NULL;
     }
@@ -1412 +1412 @@
     whereSQL = psDBGenerateWhereSQL(where);
     if (!whereSQL) {
-        psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_SQL_SUBSTR_FAIL);
+        psError(PS_ERR_UNEXPECTED_NULL, false, _("SQL substring generation failed."));
         return NULL;
     }
@@ -1443 +1443 @@
     whereSQL = psDBGenerateWhereSQL(where);
     if (!whereSQL) {
-        psError(PS_ERR_UNEXPECTED_NULL, false, PS_ERRORTEXT_psDB_SQL_SUBSTR_FAIL);
+        psError(PS_ERR_UNEXPECTED_NULL, false, _("SQL substring generation failed."));
         return NULL;
     }

trunk/psLib/src/fft/psImageFFT.c

@@ -5 +5 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-12 19:30:18 $
+ *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -21 +21 @@
 #include "psImageStructManip.h"
 
-#include "psErrorText.h"
+
 
 #define PS_FFTW_PLAN_RIGOR FFTW_ESTIMATE
@@ -43 +43 @@
         if ((direction & PS_FFT_REVERSE) != 0) {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psImageFFT_FORWARD_REVERSE);
+                    _("Can not specify both PS_FFT_FORWARD and PS_FFT_REVERSE options."));
             psFree(out);
             return NULL;
@@ -49 +49 @@
         if ((direction & PS_FFT_REAL_RESULT) != 0) {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psImageFFT_REAL_FORWARD_NOTSUPPORTED);
+                    _("The PS_FFT_FORWARD and PS_FFT_REAL_RESULT combinition is not supported."));
             psFree(out);
             return NULL;
@@ -55 +55 @@
     } else if ((direction & PS_FFT_REVERSE) == 0) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageFFT_NO_DIRECTION_OPTION);
+                _("Must specify either PS_FFT_FORWARD or PS_FFT_REVERSE option."));
         psFree(out);
         return NULL;
@@ -86 +86 @@
     if (plan == NULL) {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImageFFT_FFTW_PLAN_NULL);
+                _("Could not create a valid FFT plan to perform the transform."));
         psFree(out);
         return NULL;
@@ -179 +179 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                _("Specified psImage type, %s, is not supported."),
                 typeStr);
 
@@ -241 +241 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                _("Specified psImage type, %s, is not supported."),
                 typeStr);
         psFree(out);
@@ -271 +271 @@
         PS_TYPE_NAME(typeStrImag,imag->type.type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImageFFT_REAL_IMAG_TYPE_MISMATCH,
+                _("Real psImage type (%s) and imaginary psImage type (%s) must be the same."),
                 typeStrReal,typeStrImag);
         psFree(out);
@@ -279 +279 @@
     if (imag->numCols != numCols || imag->numRows != numRows) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageFFT_REAL_IMAG_SIZE_MISMATCH,
+                _("Real psImage size (%dx%d) and imaginary psImage size (%dx%d) must be the same."),
                 numCols, numRows, imag->numCols, imag->numRows);
         psFree(out);
@@ -320 +320 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImageFFT_NONREAL_NOTSUPPORTED,
+                _("Input psImage type, %s, is required to be either psF32 or psF64."),
                 typeStr);
         psFree(out);
@@ -380 +380 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED,
+                _("Input psImage type, %s, is required to be either psC32 or psC64."),
                 typeStr);
         psFree(out);
@@ -446 +446 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImageFFT_NONCOMPLEX_NOTSUPPORTED,
+                _("Input psImage type, %s, is required to be either psC32 or psC64."),
                 typeStr);
         psFree(out);

trunk/psLib/src/fft/psVectorFFT.c

@@ -5 +5 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-12 19:12:01 $
+ *  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -22 +22 @@
 #include "psLogMsg.h"
 
-#include "psErrorText.h"
+
 
 #define P_FFTW_PLAN_RIGOR FFTW_ESTIMATE
@@ -63 +63 @@
     } else {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psVectorFFT_DIRECTION_NOTSET);
+                _("Must specify the direction as either PS_FFT_FORWARD or PS_FFT_REVERSE."));
         psFree(out);
         return NULL;
@@ -71 +71 @@
     if (plan == NULL) {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVectorFFT_FFTW_PLAN_NULL);
+                _("Could not create a valid FFT plan to perform the transform."));
         psFree(out);
         return NULL;
@@ -142 +142 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED,
+                _("Specified psVector type, %s, is not supported."),
                 typeStr);
         psFree(out);
@@ -201 +201 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED,
+                _("Specified psVector type, %s, is not supported."),
                 typeStr);
         psFree(out);
@@ -233 +233 @@
         PS_TYPE_NAME(typeStrImag,imag->type.type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVectorFFT_REAL_IMAG_TYPE_MISMATCH,
+                _("Real psVector type, %s, and imaginary psVector type, %s, must be the same."),
                 typeStrReal,typeStrImag);
         psFree(out);
@@ -267 +267 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVectorFFT_NONREAL_NOTSUPPORTED,
+                _("Input psVector type, %s, is required to be either psF32 or psF64."),
                 typeStr);
         psFree(out);
@@ -327 +327 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED,
+                _("Input psVector type, %s, is required to be either psC32 or psC64."),
                 typeStr);
         psFree(out);
@@ -407 +407 @@
         PS_TYPE_NAME(typeStr,type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED,
+                _("Input psVector type, %s, is required to be either psC32 or psC64."),
                 typeStr);
         psFree(out);

trunk/psLib/src/fits/psFits.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.57 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:57:12 $
+ *  @version $Revision: 1.58 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -18 +18 @@
 #include "string.h"
 #include "psError.h"
-#include "psErrorText.h"
+
 #include "psImageStructManip.h"
 #include "psMemory.h"
@@ -73 +73 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -91 +91 @@
     if (name == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_FILENAME_NULL);
+                _("Specified filename can not be NULL."));
         return NULL;
     }
@@ -139 +139 @@
             fits_get_errstatus(status, fitsErr);
             psError(PS_ERR_IO, true,
-                    PS_ERRORTEXT_psFits_FILENAME_CREATE_FAILED,
+                    _("Could not create file,'%s'. CFITSIO Error: %s"),
                     name, fitsErr);
             return NULL;
@@ -158 +158 @@
             fits_get_errstatus(status, fitsErr);
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psFits_FILENAME_INVALID,
+                    _("Could not open file,'%s'. CFITSIO Error: %s"),
                     name, fitsErr);
             return NULL;
@@ -188 +188 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -194 +194 @@
     if (extname == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_EXTNAME_NULL);
+                _("Specified extension name can not be NULL."));
         return false;
     }
@@ -203 +203 @@
         fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_LOCATION_INVALID, true,
-                PS_ERRORTEXT_psFits_EXTNAME_INVALID,
+                _("Could not find HDU '%s'. CFITSIO Error: %s"),
                 extname, fitsErr);
         return false;
@@ -217 +217 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -230 +230 @@
             fits_get_errstatus(status, fitsErr);
             psError(PS_ERR_LOCATION_INVALID, true,
-                    PS_ERRORTEXT_psFits_EXTNUM_REL_MOVE_FAILED,
+                    _("Could not move %d HDUs from current position. CFITSIO Error: %s"),
                     extnum, fitsErr);
             return false;
@@ -240 +240 @@
             fits_get_errstatus(status, fitsErr);
             psError(PS_ERR_LOCATION_INVALID, true,
-                    PS_ERRORTEXT_psFits_EXTNUM_ABS_MOVE_FAILED,
+                    _("Could not move to specified HDU #%d. CFITSIO Error: %s"),
                     extnum, fitsErr);
             return false;
@@ -253 +253 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -270 +270 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return PS_FITS_TYPE_NONE;
     }
@@ -282 +282 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return NULL;
     }
@@ -303 +303 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -309 +309 @@
     if (name == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_EXTNAME_NULL);
+                _("Specified extension name can not be NULL."));
         return false;
     }
@@ -319 +319 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_WRITE_FAILED,
+                _("Could not write data to file. CFITSIO Error: %s"),
                 fitsErr);
         return false;
@@ -333 +333 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -339 +339 @@
     if (! fits->writable) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_WRITABLE);
+                _("The psFits object is not writable."));
         return false;
     }
@@ -358 +358 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_WRITE_FAILED,
+                _("Could not write data to file. CFITSIO Error: %s"),
                 fitsErr);
         return false;
@@ -371 +371 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -377 +377 @@
     if (! fits->writable) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_WRITABLE);
+                _("The psFits object is not writable."));
         return false;
     }
@@ -397 +397 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_WRITE_FAILED,
+                _("Could not write data to file. CFITSIO Error: %s"),
                 fitsErr);
         return false;
@@ -409 +409 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return 0;
     }
@@ -420 +420 @@
         fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_LOCATION_INVALID, true,
-                PS_ERRORTEXT_psFits_GETNUMHDUS_FAILED,
+                _("Failed to determine the number of HDUs. CFITSIO Error: %s"),
                 fitsErr);
         return 0;
@@ -432 +432 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return PS_FITS_TYPE_NONE;
     }
@@ -443 +443 @@
         fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_LOCATION_INVALID, true,
-                PS_ERRORTEXT_psFits_GETHDUTYPE_FAILED,
+                _("Failed to determine an HDU type. CFITSIO Error: %s"),
                 fitsErr);
         return PS_FITS_TYPE_NONE;
@@ -461 +461 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return PS_FITS_TYPE_NONE;
     }
@@ -467 +467 @@
     if (! fits->writable) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_WRITABLE);
+                _("The psFits object is not writable."));
         return PS_FITS_TYPE_NONE;
     }
@@ -601 +601 @@
             PS_TYPE_NAME(typeStr,type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psFits_TYPE_UNSUPPORTED,
+                    _("Specified type, %s, is not supported."),
                     typeStr);
             return false;

trunk/psLib/src/fits/psFitsHeader.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-06 01:13:11 $
+ *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -19 +19 @@
 #include "strings.h"
 #include "psError.h"
-#include "psErrorText.h"
+
 #include "psImageStructManip.h"
 #include "psMemory.h"
@@ -48 +48 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return NULL;
     }
@@ -181 +181 @@
             }
         default:
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psFits_METATYPE_INVALID, keyType);
+            psError(PS_ERR_IO, true, _("Specified FITS metadata type, %c, is not supported."), keyType);
             return out;
         }
 
         if (!success) {
-            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_METADATA_ADD_FAILED, keyName);
+            psError(PS_ERR_UNKNOWN, false, _("Failed to add metadata item, %s."), keyName);
             return out;
         }
@@ -195 +195 @@
         char fitsErr[MAX_STRING_LENGTH];
         (void)fits_get_errstatus(status, fitsErr);
-        psError(PS_ERR_IO, true, PS_ERRORTEXT_psFits_METADATA_ADD_FAILED, fitsErr);
+        psError(PS_ERR_IO, true, _("Failed to add metadata item, %s."), fitsErr);
         return false;
     }
@@ -205 +205 @@
 {
     if (fits == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
         psFree(out);
         return NULL;
@@ -385 +385 @@
             char fitsErr[MAX_STRING_LENGTH];
             (void)fits_get_errstatus(status, fitsErr);
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psFits_WRITE_FAILED, fitsErr);
+            psError(PS_ERR_IO, true, _("Could not write data to file. CFITSIO Error: %s"), fitsErr);
             return false;
         }
@@ -400 +400 @@
 {
     if (!fits) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
         return false;
     }
 
     if (!output) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_METADATA_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psMetadata was NULL.  Need a non-NULL psMetadata for operation to be performed."));
         return false;
     }
@@ -417 +417 @@
 {
     if (!fits) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
         return false;
     }
@@ -443 +443 @@
 {
     if (header == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_METADATA_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psMetadata was NULL.  Need a non-NULL psMetadata for operation to be performed."));
         return false;
     }

trunk/psLib/src/fits/psFitsImage.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-08 03:06:40 $
+ *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -19 +19 @@
 #include "string.h"
 #include "psError.h"
-#include "psErrorText.h"
+
 #include "psImageStructManip.h"
 #include "psMemory.h"
@@ -49 +49 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return NULL;
     }
@@ -59 +59 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
+                _("Could not determine the HDU type. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -65 +65 @@
     if (hdutype != IMAGE_HDU) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_IMAGE_TYPE);
+                _("Current FITS HDU type must be an image."));
         return NULL;
     }
@@ -73 +73 @@
         fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_DATATYPE_UNKNOWN,
+                _("Could not determine image data type. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -82 +82 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_IMAGE_DIM_UNKNOWN,
+                _("Could not determine image dimensions. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -90 +90 @@
     if ((nAxis < 2) || (nAxis > 3)) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_IMAGE_DIMENSION_UNSUPPORTED,
+                _("Image number of dimensions, %d, is not valid.  Only two or three dimensions supported for FITS I/O."),
                 nAxis);
         return NULL;
@@ -99 +99 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_IMAGE_SIZE_UNKNOWN,
+                _("Could not determine image size. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -163 +163 @@
     default:
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_FITS_TYPE_UNSUPPORTED,
+                _("FITS image type, BITPIX=%d, is not supported."),
                 bitPix);
         return NULL;
@@ -178 +178 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_READ_FAILED,
+                _("Reading FITS file failed. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -208 +208 @@
 
     if (!fits) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psFits object can not NULL."));
         return false;
     }
 
     if (!input) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psFits_IMAGE_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
         return false;
     }
@@ -299 +299 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_WRITE_FAILED,
+                _("Could not write data to file. CFITSIO Error: %s"),
                 fitsErr);
         return false;
@@ -318 +318 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -324 +324 @@
     if (input == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_IMAGE_NULL);
+                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
         return false;
     }
@@ -334 +334 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
+                _("Could not determine the HDU type. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -340 +340 @@
     if (hdutype != IMAGE_HDU) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_IMAGE_TYPE);
+                _("Current FITS HDU type must be an image."));
         return NULL;
     }
@@ -369 +369 @@
         PS_TYPE_NAME(imageTypeStr,input->type.type);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_IMAGE_UPDATE_TYPE_MISMATCH,
+                _("Can not update a %s image given a %s image."),
                 fitsTypeStr, imageTypeStr);
         return false;
@@ -377 +377 @@
     if (z >= nAxes[2]) {
         psError(PS_ERR_BAD_PARAMETER_SIZE, true,
-                PS_ERRORTEXT_psFits_FITS_Z_SMALL,
+                _("Current FITS HDU has %d z-planes, but z-plane %d was specified."),
                 nAxes[2],z);
         return false;
@@ -412 +412 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_WRITE_FAILED,
+                _("Could not write data to file. CFITSIO Error: %s"),
                 fitsErr);
         return false;
@@ -429 +429 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return NULL;
     }
@@ -439 +439 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_IMAGE_DIM_UNKNOWN,
+                _("Could not determine image dimensions. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -454 +454 @@
             (void)fits_get_errstatus(status, fitsErr);
             psError(PS_ERR_IO, true,
-                    PS_ERRORTEXT_psFits_IMAGE_SIZE_UNKNOWN,
+                    _("Could not determine image size. CFITSIO Error: %s"),
                     fitsErr);
             return NULL;
@@ -469 +469 @@
 
     // Bad dimensionality
-    psError(PS_ERR_IO, true, PS_ERRORTEXT_psFits_IMAGE_DIMENSION_UNSUPPORTED, nAxis);
+    psError(PS_ERR_IO, true, _("Image number of dimensions, %d, is not valid.  Only two or three dimensions supported for FITS I/O."), nAxis);
     return NULL;
 }
@@ -477 +477 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -483 +483 @@
     if (input == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_IMAGE_NULL);
+                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
         return false;
     }
 
     if (input->n == 0) {
-        psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psFits_ARRAY_EMPTY);
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("The input array was empty."));
         return false;
     }
@@ -504 +504 @@
         testImage = input->data[i];
         if (testImage->numCols != numCols || testImage->numRows != numRows) {
-            psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psFits_ARRAY_SIZE_DIFFER);
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("The sizes of images in the array differ."));
             return false;
         }
@@ -522 +522 @@
                                    input->n);
     if (! update) {
-        psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_METADATA_ADD_FAILED,
+        psError(PS_ERR_UNKNOWN, false, _("Failed to add metadata item, %s."),
                 "NAXIS, NAXIS1, NAXIS2, NAXIS3");
         psFree(headerCopy);
@@ -532 +532 @@
     // The next are psFitsImageUpdate to write into the extension.
     if (! psFitsWriteImage(fits, headerCopy, input->data[0], input->n, extname)) {
-        psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_WRITE_PLANE_FAILED, 0);
+        psError(PS_ERR_UNKNOWN, false, _("Could not write image plane %d."), 0);
         psFree(headerCopy);
         return false;
@@ -540 +540 @@
     for (int i = 1; i < input->n; i++) {
         if (! psFitsUpdateImage(fits, input->data[i], 0, 0, i)) {
-            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_WRITE_PLANE_FAILED, i);
+            psError(PS_ERR_UNKNOWN, false, _("Could not write image plane %d."), i);
             return false;
         }
@@ -552 +552 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -558 +558 @@
     if (input == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_IMAGE_NULL);
+                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
         return false;
     }
 
     if (input->n == 0) {
-        psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psFits_ARRAY_EMPTY);
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("The input array was empty."));
         return false;
     }
@@ -569 +569 @@
     for (int i = 0; i < input->n; i++) {
         if (! psFitsUpdateImage(fits, input->data[i], x0, y0, i)) {
-            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_UPDATE_PLANE_FAILED, i);
+            psError(PS_ERR_UNKNOWN, false, _("Could not update image plane %d."), i);
             return false;
         }

trunk/psLib/src/fits/psFitsTable.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-26 03:37:57 $
+ *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -17 +17 @@
 #include "string.h"
 #include "psError.h"
-#include "psErrorText.h"
+
 #include "psImageStructManip.h"
 #include "psMemory.h"
@@ -41 +41 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return NULL;
     }
@@ -52 +52 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
+                _("Could not determine the HDU type. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -58 +58 @@
     if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
+                _("Current FITS HDU type must be a table."));
         return NULL;
     }
@@ -69 +69 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_TABLE_SIZE_FAILED,
+                _("Failed to determine the size of the current HDU table. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -78 +78 @@
     if (row < 0 || row >= numRows) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psFits_ROW_INVALID,
+                _("Specified row, %d, is not valid for current table of %d rows."),
                 row,numRows);
         return NULL;
@@ -168 +168 @@
             (void)fits_get_errstatus(status, fitsErr);
             psError(PS_ERR_IO, true,
-                    PS_ERRORTEXT_psFits_GET_TABLE_ELEMENT,
+                    _("Failed to retrieve table element (%d,%d). CFITSIO Error: %s"),
                     col,row,fitsErr);
             psFree(data);
@@ -187 +187 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return NULL;
     }
@@ -197 +197 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
+                _("Could not determine the HDU type. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -203 +203 @@
     if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
+                _("Current FITS HDU type must be a table."));
         return NULL;
     }
@@ -212 +212 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_FIND_COLUMN,
+                _("Specified column, %s, was not found. CFITSIO Error: %s"),
                 colname, fitsErr);
         return NULL;
@@ -227 +227 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_COLTYPE,
+                _("Could not determine the datatype of the table column. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -253 +253 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_TABLE_READ_COL,
+                _("Failed to read table column. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -269 +269 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return NULL;
     }
@@ -279 +279 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
+                _("Could not determine the HDU type. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -285 +285 @@
     if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
+                _("Current FITS HDU type must be a table."));
         return NULL;
     }
@@ -294 +294 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_FIND_COLUMN,
+                _("Specified column, %s, was not found. CFITSIO Error: %s"),
                 colname, fitsErr);
         return NULL;
@@ -313 +313 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_COLTYPE,
+                _("Could not determine the datatype of the table column. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -336 +336 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_TABLE_READ_COL,
+                _("Failed to read table column. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -351 +351 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return NULL;
     }
@@ -361 +361 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
+                _("Could not determine the HDU type. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -367 +367 @@
     if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
+                _("Current FITS HDU type must be a table."));
         return NULL;
     }
@@ -378 +378 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_TABLE_SIZE_FAILED,
+                _("Failed to determine the size of the current HDU table. CFITSIO Error: %s"),
                 fitsErr);
         return NULL;
@@ -488 +488 @@
         // no table data, what can I do?
         psError(PS_ERR_BAD_PARAMETER_SIZE, true,
-                PS_ERRORTEXT_psFits_TABLE_EMPTY);
+                _("Can't create a table without any rows."));
         return false;
     }
@@ -731 +731 @@
     if (fits == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_NULL);
+                _("The input psFits object can not NULL."));
         return false;
     }
@@ -737 +737 @@
     if (data == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psFits_IMAGE_NULL);
+                _("The input psImage was NULL.  Need a non-NULL psImage for operation to be performed."));
         return false;
     }
@@ -747 +747 @@
         (void)fits_get_errstatus(status, fitsErr);
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_GET_HDU_TYPE_FAILED,
+                _("Could not determine the HDU type. CFITSIO Error: %s"),
                 fitsErr);
         return false;
@@ -753 +753 @@
     if (hdutype != ASCII_TBL && hdutype != BINARY_TBL) {
         psError(PS_ERR_IO, true,
-                PS_ERRORTEXT_psFits_NOT_TABLE_TYPE);
+                _("Current FITS HDU type must be a table."));
         return false;
     }
@@ -777 +777 @@
                     (void)fits_get_errstatus(status, fitsErr);
                     psError(PS_ERR_IO, true,
-                            PS_ERRORTEXT_psFits_WRITE_FAILED,
+                            _("Could not write data to file. CFITSIO Error: %s"),
                             fitsErr);
                     psFree(iter);

trunk/psLib/src/imageops/psImageConvolve.c

@@ -5 +5 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:57:12 $
+ *  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -21 +21 @@
 #include "psError.h"
 
-#include "psErrorText.h"
+
 
 #define FOURIER_PADDING 32 /* padding amount in every side of the image for fourier convolution */
@@ -120 +120 @@
     if (tShifts == NULL || xShifts == NULL || yShifts == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImageConvolve_SHIFT_NULL);
+                _("Specified shift vectors can not be NULL."));
         return NULL;
     }
@@ -134 +134 @@
         PS_TYPE_NAME(typeTStr,tShifts->type.type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImageConvolve_SHIFT_TYPE_MISMATCH,
+                _("Input t-, x-, and y-shift vector types (%s/%s/%s) must match."),
                 typeTStr, typeXStr, typeYStr);
         return NULL;
@@ -257 +257 @@
                 PS_TYPE_NAME(typeStr,xShifts->type.type);
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                        _("Specified psImage type, %s, is not supported."),
                         typeStr);
             }
@@ -280 +280 @@
                 PS_TYPE_NAME(typeStr,xShifts->type.type);
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                        _("Specified psImage type, %s, is not supported."),
                         typeStr);
             }
@@ -301 +301 @@
     if (kernel == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImageConvolve_KERNEL_NULL);
+                _("Specified psKernel can not be NULL."));
         psFree(out);
         return NULL;
@@ -361 +361 @@
                 PS_TYPE_NAME(typeStr,in->type.type);
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                        _("Specified psImage type, %s, is not supported."),
                         typeStr);
                 psFree(out);
@@ -380 +380 @@
         if (kRows >= numRows || kCols >= numCols) {
             psError(PS_ERR_BAD_PARAMETER_SIZE, true,
-                    PS_ERRORTEXT_psImageConvolve_KERNEL_TOO_LARGE,
+                    _("Specified psKernel size, %dx%d, can not be larger than input psImage size, %dx%d."),
                     kCols,kRows,
                     numCols, numRows);
@@ -434 +434 @@
         if (kernelFourier == NULL) {
             psError(PS_ERR_UNKNOWN, false,
-                    PS_ERRORTEXT_psImageConvolve_KERNEL_FFT_FAILED);
+                    _("Failed to perform a fourier transform of kernel."));
             psFree(out);
             return NULL;
@@ -442 +442 @@
         if (inFourier == NULL) {
             psError(PS_ERR_UNKNOWN, false,
-                    PS_ERRORTEXT_psImageConvolve_FFT_FAILED);
+                    _("Failed to perform a fourier transform of input image."));
             psFree(out);
             return NULL;
@@ -460 +460 @@
         if (complexOut == NULL) {
             psError(PS_ERR_UNKNOWN, false,
-                    PS_ERRORTEXT_psImageConvolve_FFT_FAILED);
+                    _("Failed to perform a fourier transform of input image."));
             psFree(out);
             return NULL;
@@ -665 +665 @@
             PS_TYPE_NAME(typeStr,image->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
             return false;

trunk/psLib/src/imageops/psImageGeomManip.c

@@ -10 +10 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-28 00:44:05 $
+ *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -30 +30 @@
 #include "psMemory.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 #include "psCoord.h"
 
@@ -51 +51 @@
     if (in == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -58 +58 @@
     if (scale < 1) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE,
+                _("Specified scale value, %d, must be a positive value."),
                 scale);
         psFree(out);
@@ -66 +66 @@
     if (stats == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_STAT_NULL);
+                _("Specified statistic can not be NULL."));
         psFree(out);
         return NULL;
@@ -74 +74 @@
     if (statistic == 0) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_BAD_STAT,
+                _("Specified statistic option, %d, is not valid.  Must specify one and only one statistic type."),
                 stats->options);
         psFree(out);
@@ -87 +87 @@
             PS_TYPE_NAME(typeStr,mask->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
+                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
                     typeStr, PS_TYPE_MASK_NAME);
             psFree(out);
@@ -159 +159 @@
             PS_TYPE_NAME(typeStr,in->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
             psFree(out);
@@ -184 +184 @@
     if (in == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -191 +191 @@
     if (scale < 1) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageManip_SCALE_NOT_POSITIVE,
+                _("Specified scale value, %d, must be a positive value."),
                 scale);
         psFree(out);
@@ -199 +199 @@
     if (mode > PS_INTERPOLATE_LANCZOS4_VARIANCE ) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
+                _("Specified interpolation mode, %d, is unsupported."),
                 mode);
         psFree(out);
@@ -241 +241 @@
             PS_TYPE_NAME(typeStr,in->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
             psFree(out);
@@ -262 +262 @@
     if (input == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -311 +311 @@
     if (input == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -357 +357 @@
                 PS_TYPE_NAME(typeStr,type);
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                        _("Specified psImage type, %s, is not supported."),
                         typeStr);
                 psFree(out);
@@ -403 +403 @@
                 PS_TYPE_NAME(typeStr,type);
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                        _("Specified psImage type, %s, is not supported."),
                         typeStr);
                 psFree(out);
@@ -448 +448 @@
                 PS_TYPE_NAME(typeStr,type);
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                        _("Specified psImage type, %s, is not supported."),
                         typeStr);
                 psFree(out);
@@ -503 +503 @@
                     cimag(exposed) > PS_MAX_##TYPE) { \
                 psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                        PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
+                        _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
                         "exposed", \
                         creal(exposed),cimag(exposed), \
@@ -570 +570 @@
                 PS_TYPE_NAME(typeStr,type); \
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
-                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
+                        _("Specified psImage type, %s, is not supported."), \
                         typeStr); \
                 psFree(out); \
@@ -584 +584 @@
         default:
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
+                    _("Specified interpolation mode, %d, is unsupported."),
                     mode);
             psFree(out);
@@ -608 +608 @@
     if (input == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -627 +627 @@
             cimag(exposed) > PS_MAX_##TYPE) { \
         psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
+                _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
                 "exposed", \
                 creal(exposed),cimag(exposed), \
@@ -666 +666 @@
             PS_TYPE_NAME(typeStr,type); \
             psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
+                    _("Specified psImage type, %s, is not supported."), \
                     typeStr); \
             psFree(out); \
@@ -680 +680 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
+                _("Specified interpolation mode, %d, is unsupported."),
                 mode);
         psFree(out);
@@ -702 +702 @@
     if (input == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(output);
         return NULL;
@@ -715 +715 @@
         if (input->numRows != inputMask->numRows || input->numCols != inputMask->numCols) {
             psError(PS_ERR_BAD_PARAMETER_SIZE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
+                    _("Input psImage mask size, %dx%d, does not match psImage input size, %dx%d."),
                     input->numCols, input->numRows,
                     inputMask->numCols, inputMask->numRows );
@@ -725 +725 @@
             PS_TYPE_NAME(typeStr,inputMask->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
+                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
                     typeStr, PS_TYPE_MASK_NAME);
             psFree(output);
@@ -734 +734 @@
     if (outToIn == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImageManip_TRANSFORM_NULL);
+                _("Specified input transform can not be NULL."));
         return NULL;
     }
@@ -853 +853 @@
             PS_TYPE_NAME(typeStr,type); \
             psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED, \
+                    _("Specified psImage type, %s, is not supported."), \
                     typeStr); \
             psFree(output); \
@@ -867 +867 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
+                _("Specified interpolation mode, %d, is unsupported."),
                 mode);
         psFree(output);

trunk/psLib/src/imageops/psImageMaskOps.c

@@ -8 +8 @@
  *  @author David Robbins, MHPCC
  *
- *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-30 02:20:06 $
+ *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -26 +26 @@
 #include "psMemory.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 #include "psCoord.h"
 

trunk/psLib/src/imageops/psImagePixelExtract.c

@@ -8 +8 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-28 00:44:05 $
+ *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -21 +21 @@
 #include "psError.h"
 
-#include "psErrorText.h"
+
 
 #define VECTOR_STORE_ROW_CASE(TYPE) \
@@ -34 +34 @@
     if (input == NULL || input->data.V == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -124 +124 @@
     if (input == NULL || input->data.V == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -223 +223 @@
     if (input == NULL || input->data.V == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -350 +350 @@
         if (inRows != mask->numRows || inCols != mask->numCols) {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
+                    _("Input psImage mask size, %dx%d, does not match psImage input size, %dx%d."),
                     mask->numCols,mask->numRows,
                     inCols, inRows);
@@ -360 +360 @@
             PS_TYPE_NAME(typeStr,mask->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
+                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
                     typeStr, PS_TYPE_MASK_NAME);
             psFree(out);
@@ -369 +369 @@
     if (stats == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_STAT_NULL);
+                _("Specified statistic can not be NULL."));
         psFree(out);
         return NULL;
@@ -378 +378 @@
     if (statistic == 0) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                PS_ERRORTEXT_psImage_BAD_STAT,stats->options);
+                _("Specified statistic option, %d, is not valid.  Must specify one and only one statistic type."),stats->options);
         psFree(out);
         return NULL;
@@ -466 +466 @@
                 PS_TYPE_NAME(typeStr,type);
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                        PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                        _("Specified psImage type, %s, is not supported."),
                         typeStr);
                 psFree(out);
@@ -531 +531 @@
     } else { // don't know what the direction flag is
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_SLICE_DIRECTION_INVALID,
+                _("Specified slice direction, %d, is invalid."),
                 direction);
         psFree(out);
@@ -555 +555 @@
     if (input == NULL || input->data.V == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -588 +588 @@
     if (nSamples < 2) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_nSamples_TOOSMALL,
+                _("Specified number of samples, %d, must be greater than 1 to make a line."),
                 nSamples);
         psFree(out);
@@ -639 +639 @@
     if (mode < PS_INTERPOLATE_FLAT ) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageManip_INTERPOLATION_MODE_UNSUPPORTED,
+                _("Specified interpolation mode, %d, is unsupported."),
                 mode);
         psFree(out);
@@ -648 +648 @@
         if (numRows != mask->numRows || numCols != mask->numCols) {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
+                    _("Input psImage mask size, %dx%d, does not match psImage input size, %dx%d."),
                     mask->numCols,mask->numRows,
                     numCols-1, numRows);
@@ -658 +658 @@
             PS_TYPE_NAME(typeStr,mask->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
+                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
                     typeStr, PS_TYPE_MASK_NAME);
             psFree(out);
@@ -719 +719 @@
             PS_TYPE_NAME(typeStr,input->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
             psFree(out);
@@ -742 +742 @@
     if (input == NULL || input->data.V == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(out);
         return NULL;
@@ -752 +752 @@
         if (numRows != mask->numRows || numCols != mask->numCols) {
             psError(PS_ERR_BAD_PARAMETER_SIZE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_MASK_SIZE,
+                    _("Input psImage mask size, %dx%d, does not match psImage input size, %dx%d."),
                     mask->numCols,mask->numRows,
                     numCols, numRows);
@@ -762 +762 @@
             PS_TYPE_NAME(typeStr,mask->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE,
+                    _("Input psImage mask type, %s, is not the supported mask datatype of %s."),
                     typeStr, PS_TYPE_MASK_NAME);
             psFree(out);
@@ -774 +774 @@
             y < input->row0 || y >= (input->row0 + numRows) ) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_CENTER_NOT_IN_IMAGE,
+                _("Specified center, (%g,%g), is outside of the psImage boundaries, [0:%d,0:%d]."),
                 x, y,
                 numCols-1, numRows-1);
@@ -783 +783 @@
     if (radii == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_RADII_VECTOR_NULL);
+                _("Specified radii vector can not be NULL."));
         psFree(out);
         return NULL;
@@ -790 +790 @@
     if (radii->n < 2) {
         psError(PS_ERR_BAD_PARAMETER_SIZE, true,
-                PS_ERRORTEXT_psImage_RADII_VECTOR_TOOSMALL,
+                _("Input radii vector size, %d, can not be less than 2."),
                 radii->n);
         psFree(out);
@@ -798 +798 @@
     if (stats == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_STAT_NULL);
+                _("Specified statistic can not be NULL."));
         psFree(out);
         return NULL;
@@ -807 +807 @@
     if (statistic == 0) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, false,
-                PS_ERRORTEXT_psImage_BAD_STAT,
+                _("Specified statistic option, %d, is not valid.  Must specify one and only one statistic type."),
                 stats->options);
         psFree(out);

trunk/psLib/src/imageops/psImagePixelManip.c

@@ -10 +10 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-30 02:20:06 $
+ *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -28 +28 @@
 #include "psMemory.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 #include "psCoord.h"
 
@@ -47 +47 @@
     if (max < min) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageManip_MAXMIN,
+                _("Specified min value, %g, can not be greater than the specified max value, %g."),
                 (double)min,(double)max);
         return 0;
@@ -61 +61 @@
             if (vmin < PS_MIN_##type || vmin > PS_MAX_##type) { \
                 psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                        PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
+                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
                         "vmin",vmin, PS_TYPE_##type##_NAME, \
                         (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
@@ -67 +67 @@
             if (vmax > PS_MAX_##type || vmax < PS_MIN_##type) { \
                 psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                        PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
+                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
                         "vmax",vmax, PS_TYPE_##type##_NAME, \
                         (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
@@ -90 +90 @@
             if (vmin < PS_MIN_##type || vmin > PS_MAX_##type) { \
                 psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                        PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
+                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
                         "vmin",vmin, PS_TYPE_##type##_NAME, \
                         (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
@@ -96 +96 @@
             if (vmax > PS_MAX_##type || vmax < PS_MIN_##type) { \
                 psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                        PS_ERRORTEXT_psImage_PARAMETER_OUTOF_TYPERANGE, \
+                        _("Specified %s value, %g, is outside of psImage type's range (%s: %g to %g)."), \
                         "vmax",vmax, PS_TYPE_##type##_NAME, \
                         (psF64)PS_MIN_##type,(psF64)PS_MAX_##type); \
@@ -132 +132 @@
             PS_TYPE_NAME(typeStr,input->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
         }
@@ -177 +177 @@
             PS_TYPE_NAME(typeStr,input->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
         }
@@ -202 +202 @@
     if (image == NULL || overlay == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         return pixelsOverlaid;
     }
@@ -208 +208 @@
     if (op == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImageManip_OPERATION_NULL);
+                _("Operation can not be NULL."));
         return pixelsOverlaid;
     }
@@ -220 +220 @@
         PS_TYPE_NAME(typeStrOverlay,overlay->type.type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImageManip_OVERLAY_TYPE_MISMATCH,
+                _("Input overlay psImage type, %s, must match input psImage type, %s."),
                 typeStrOverlay, typeStr);
         return pixelsOverlaid;
@@ -239 +239 @@
 
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
+                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."),
                 x0, imageColLimit, y0, imageRowLimit,
                 imageNumCols, imageNumRows);
@@ -295 +295 @@
     default: \
         psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                PS_ERRORTEXT_psImageManip_OVERLAY_OPERATOR_INVALID, \
+                _("Specified operation, '%s', is not supported."), \
                 op); \
         return pixelsOverlaid; \
@@ -319 +319 @@
             PS_TYPE_NAME(typeStr,type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
             return pixelsOverlaid;
@@ -344 +344 @@
     if (input == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         return 0;
     }
@@ -350 +350 @@
     if (realMax < realMin) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageManip_MAXMIN_REAL,
+                _("Specified real-portion of min value, %g, can not be greater than the real-portion of max value, %g."),
                 (double)realMin, (double)realMax);
         return 0;
@@ -356 +356 @@
     if (imagMax < imagMin) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImageManip_MAXMIN_IMAG,
+                _("Specified imaginary-portion of min value, %g, can not be greater than the imaginary-portion of max value, %g."),
                 (double)imagMin, (double)imagMax);
         return 0;
@@ -369 +369 @@
                 realfcn(vmin) > PS_MAX_##type || imagfcn(vmin) > PS_MAX_##type ) { \
             psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                    PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
+                    _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
                     "vmin", creal(vmin), cimag(vmin), \
                     PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
@@ -377 +377 @@
                 realfcn(vmax) < PS_MIN_##type || imagfcn(vmax) < PS_MIN_##type ) { \
             psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
-                    PS_ERRORTEXT_psImageManip_CLIP_VALUE_INVALID, \
+                    _("Specified %s value, %g%+gi, is not the the range of input psImage's valid pixel values (%s), i.e. [%g:%g]."), \
                     "vmax", creal(vmax), cimag(vmax), \
                     PS_TYPE_##type##_NAME, PS_MIN_##type, PS_MAX_##type); \
@@ -406 +406 @@
             PS_TYPE_NAME(typeStr,input->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
         }

trunk/psLib/src/imageops/psImageStats.c

@@ -9 +9 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.98 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-30 02:20:06 $
+ *  @version $Revision: 1.99 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -30 +30 @@
 #include "psImageStats.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 #include "psRegion.h"
 #include "psRegionForImage.h"
@@ -497 +497 @@
         if (mask == NULL) {
             psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                    PS_ERRORTEXT_psImage_IMAGE_NULL);
+                    _("Can not operate on a NULL psImage."));
             return -1;
         }
@@ -592 +592 @@
         return -1;
     }/* else if (col0 == col1 && row0 == row1) {
-                                        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                                                "Invalid psRegion specified.  Region contains only 1 pixel.\n");
-                                        return -1;
-                                    }
-                                */
+                                            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
+                                                    "Invalid psRegion specified.  Region contains only 1 pixel.\n");
+                                            return -1;
+                                        }
+                                    */
     x0 = col0;
     x1 = col1;
@@ -632 +632 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImage_IMAGE_MASK_TYPE, type, PS_TYPE_U8);
+                _("Input psImage mask type, %s, is not the supported mask datatype of %s."), type, PS_TYPE_U8);
         return -1;
     }

trunk/psLib/src/imageops/psImageStructManip.c

@@ -8 +8 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-12 20:44:04 $
+ *  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -21 +21 @@
 #include "psError.h"
 
-#include "psErrorText.h"
+
 
 static psImage* imageSubset(psImage* out,
@@ -35 +35 @@
     if (image == NULL || image->data.V == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         return NULL;
     }
@@ -41 +41 @@
     if ( col0 < image->col0 || row0 < image->row0 ) {
         //        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-        //                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID);
+        //                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."));
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
+                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."),
                 col0, col1-1, row0, row1-1,
                 image->numCols-1, image->numRows-1);
@@ -51 +51 @@
     if (image->type.dimen != PS_DIMEN_IMAGE) {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
+                _("The input psImage must have a PS_DIMEN_IMAGE dimension type."));
         return NULL;
     }
@@ -69 +69 @@
             row1 > image->row0 + image->numRows ) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
+                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."),
                 col0, col1-1, row0, row1-1,
                 image->numCols-1, image->numRows-1);
@@ -153 +153 @@
     if (input == NULL || input->data.V == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         psFree(output);
         return NULL;
@@ -160 +160 @@
     if (input == output) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
+                _("Specified input and output psImage can not reference the same psImage."));
         psFree(output);
         return NULL;
@@ -167 +167 @@
     if (input->type.dimen != PS_DIMEN_IMAGE) {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
+                _("The input psImage must have a PS_DIMEN_IMAGE dimension type."));
         psFree(output);
         return NULL;
@@ -287 +287 @@
             PS_TYPE_NAME(typeStr,type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
             psFree(output);
@@ -302 +302 @@
     if (image == NULL || image->data.V == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         return NULL;
     }
@@ -335 +335 @@
             row0 >= row1 ) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_SUBSET_RANGE_INVALID,
+                _("Specified subset range, [%d:%d,%d:%d], is invalid or outside input psImage's boundaries, [0:%d,0:%d]."),
                 col0, col1-1, row0, row1-1,
                 image->numCols-1, image->numRows-1);

trunk/psLib/src/math/psBinaryOp.c

@@ -30 +30 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-30 02:20:06 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -50 +50 @@
 #include "psLogMsg.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 
 /*****************************************************************************
@@ -107 +107 @@
     long n2 = ((psVector*)IN2)->n; \
     if (n1 != n2) { \
-        psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n1, n2); \
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n1, n2); \
         if (OUT != IN1 && OUT != IN2) { \
             psFree(OUT); \
@@ -129 +129 @@
     if (((psVector*)IN1)->type.dimen == PS_DIMEN_VECTOR) { /* Regular vectors */ \
         if (n1 != numRows2) { \
-            psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n1, numRows2); \
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n1, numRows2); \
             if (OUT != IN1 && OUT != IN2) { \
                 psFree(OUT); \
@@ -146 +146 @@
     } else {  /* Transposed vectors */ \
         if (n1 != numCols2) { \
-            psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n1, numCols2); \
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n1, numCols2); \
             if (OUT != IN1 && OUT != IN2) { \
                 psFree(OUT); \
@@ -187 +187 @@
     if (((psVector*)IN2)->type.dimen == PS_DIMEN_VECTOR) { /* Regular vectors */ \
         if (n2 != numRows1) { \
-            psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n2, numRows1); \
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n2, numRows1); \
             if (OUT != IN1 && OUT != IN2) { \
                 psFree(OUT); \
@@ -204 +204 @@
     } else {  /* Transposed vectors */ \
         if (n2 != numCols1) { \
-            psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, n2, numCols1); \
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), n2, numCols1); \
             if (OUT != IN1) { \
                 psFree(OUT); \
@@ -229 +229 @@
     long numCols2 = ((psImage*)IN2)->numCols; \
     if (numRows1 != numRows2 || numCols1 != numCols2) { \
-        psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_IMAGE_SIZE_DIFFERS, \
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Specified psImage dimensions differed, %dx%d vs %dx%d."), \
                 numCols1, numRows1, numCols2, numRows2); \
         if (OUT != IN1 && OUT != IN2) { \
@@ -278 +278 @@
     PS_TYPE_NAME(strType,IN1->type);                                                                         \
     psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                                 \
-            PS_ERRORTEXT_psMatrix_TYPE_MISMATCH,                                                             \
+            _("Specified data type, %s, is not supported."),                                                             \
             strType);  */                                                                                    \
     if (OUT != IN1 && OUT != IN2) {                                                                          \
@@ -329 +329 @@
     PS_TYPE_NAME(strType,IN1->type);                                                                         \
     psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                                 \
-            PS_ERRORTEXT_psMatrix_TYPE_MISMATCH,                                                             \
+            _("Specified data type, %s, is not supported."),                                                             \
             strType);  */                                                                                    \
     if (OUT != IN1 && OUT != IN2) {                                                                          \
@@ -372 +372 @@
     if (PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) {                                                               \
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                            \
-                PS_ERRORTEXT_psMatrix_MIN_COMPLEX_SUPPORT);                                                  \
+                _("The minimum operation is not supported with complex data."));                                                  \
         if (OUT != IN1 && OUT != IN2) {                                                                      \
             psFree(OUT);                                                                                     \
@@ -383 +383 @@
     if (PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) {                                                               \
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                            \
-                PS_ERRORTEXT_psMatrix_MAX_COMPLEX_SUPPORT);                                                  \
+                _("The maximum operation is not supported with complex data."));                                                  \
         if (OUT != IN1 && OUT != IN2) {                                                                      \
             psFree(OUT);                                                                                     \
@@ -393 +393 @@
 } else {                                                                                                     \
     psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                                \
-            PS_ERRORTEXT_psMatrix_OPERATION_UNSUPPORTED,                                                     \
+            _("Specified operation, %s, is not supported."),                                                     \
             OP);                                                                                             \
     if (OUT != IN1 && OUT != IN2) {                                                                          \
@@ -469 +469 @@
             if (out == NULL) {
                 psError(PS_ERR_UNKNOWN, false,
-                        PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
+                        _("Couldn't create a proper output psVector."));
                 return NULL;
             }
@@ -478 +478 @@
             if (out == NULL) {
                 psError(PS_ERR_UNKNOWN, false,
-                        PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
+                        _("Couldn't create a proper output psImage."));
                 return NULL;
             }
@@ -484 +484 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
+                    _("Specified parameter, %s, has invalid dimensionality, %d."),
                     "in2",dim2);
             psBinaryOp_EXIT;
@@ -493 +493 @@
             if (out == NULL) {
                 psError(PS_ERR_UNKNOWN, false,
-                        PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
+                        _("Couldn't create a proper output psVector."));
                 return NULL;
             }
@@ -502 +502 @@
             if (out == NULL) {
                 psError(PS_ERR_UNKNOWN, false,
-                        PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
+                        _("Couldn't create a proper output psVector."));
                 return NULL;
             }
@@ -511 +511 @@
             if (out == NULL) {
                 psError(PS_ERR_UNKNOWN, false,
-                        PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
+                        _("Couldn't create a proper output psImage."));
                 return NULL;
             }
@@ -517 +517 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
+                    _("Specified parameter, %s, has invalid dimensionality, %d."),
                     "in2",dim2);
             psBinaryOp_EXIT;
@@ -525 +525 @@
         if (out == NULL) {
             psError(PS_ERR_UNKNOWN, false,
-                    PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
+                    _("Couldn't create a proper output psImage."));
             return NULL;
         }
@@ -536 +536 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
+                    _("Specified parameter, %s, has invalid dimensionality, %d."),
                     "in2",dim2);
             psBinaryOp_EXIT;
@@ -542 +542 @@
     } else {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
+                _("Specified parameter, %s, has invalid dimensionality, %d."),
                 "in1",dim1);
         psBinaryOp_EXIT;

trunk/psLib/src/math/psMathUtils.c

@@ -3 +3 @@
  *  This file contains standard math routines.
  *
- *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-30 02:20:06 $
+ *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -26 +26 @@
 #include "psAssert.h"
 #include "psConstants.h"
-#include "psErrorText.h"
+
 
 /*****************************************************************************/

trunk/psLib/src/math/psMatrix.c

@@ -21 +21 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-30 02:20:06 $
+ *  @version $Revision: 1.41 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -43 +43 @@
 #include "psMatrix.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 #include "psTrace.h"
 
@@ -568 +568 @@
 
     if(numRowsIn!=numColsOut && numRowsOut!=numColsIn) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMatrix_TRANSPOSE_MISMATCH);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Number of rows do not match number of columns."));
         TRANSPOSE_CLEANUP;
     }

trunk/psLib/src/math/psPolynomial.c

@@ -7 +7 @@
 *  polynomials.  It also contains a Gaussian functions.
 *
-*  @version $Revision: 1.147 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-07-15 02:57:12 $
+*  @version $Revision: 1.148 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:23 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -32 +32 @@
 #include "psPolynomial.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 
 /*****************************************************************************/
@@ -795 +795 @@
     } else {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psPolynomial_INVALID_POLYNOMIAL_TYPE,
+                _("Unknown polynomial type 0x%x found.  Evaluation failed."),
                 poly->type);
     }
@@ -845 +845 @@
     } else {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psPolynomial_INVALID_POLYNOMIAL_TYPE,
+                _("Unknown polynomial type 0x%x found.  Evaluation failed."),
                 poly->type);
     }
@@ -924 +924 @@
     } else {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psPolynomial_INVALID_POLYNOMIAL_TYPE,
+                _("Unknown polynomial type 0x%x found.  Evaluation failed."),
                 poly->type);
     }
@@ -1040 +1040 @@
     } else {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psPolynomial_INVALID_POLYNOMIAL_TYPE,
+                _("Unknown polynomial type 0x%x found.  Evaluation failed."),
                 poly->type);
     }

trunk/psLib/src/math/psRandom.c

@@ -10 +10 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-06-30 02:20:06 $
+*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:23 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -31 +31 @@
 #include "psLogMsg.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 
 psU64 p_psRandomGetSystemSeed()
@@ -78 +78 @@
         psError(PS_ERR_UNEXPECTED_NULL,
                 true,
-                PS_ERRORTEXT_psRandom_UNKNOWN_RANDFOM_NUMBER_GENERATOR_TYPE);
+                _("Unknown Random Number Generator Type"));
         break;
     }
@@ -92 +92 @@
         psError(PS_ERR_UNEXPECTED_NULL,
                 true,
-                PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
+                _("Random variable is NULL."));
     } else {
         // Check seed value to see if system seed should be used
@@ -109 +109 @@
         psError(PS_ERR_UNEXPECTED_NULL,
                 true,
-                PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
+                _("Random variable is NULL."));
         return(0);
     } else {
@@ -122 +122 @@
         psError(PS_ERR_UNEXPECTED_NULL,
                 true,
-                PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
+                _("Random variable is NULL."));
         return(0);
     } else {
@@ -136 +136 @@
         psError(PS_ERR_UNEXPECTED_NULL,
                 true,
-                PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
+                _("Random variable is NULL."));
         return(0);
     } else {
@@ -149 +149 @@
         psError(PS_ERR_UNEXPECTED_NULL,
                 true,
-                PS_ERRORTEXT_psRandom_NULL_RANDOM_VAR);
+                _("Random variable is NULL."));
         return(0);
     } else {

trunk/psLib/src/math/psRegion.c

@@ -3 +3 @@
 #include "psMemory.h"
 #include "psError.h"
-#include "psErrorText.h"
+
 #include "psRegion.h"
 
@@ -52 +52 @@
     if (sscanf(region,"[%d:%d,%d:%d]",&col0,&col1,&row0,&row1) < 4) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_SUBSECTION_INVALID,
+                _("Specified subsection string, '%s', can not be parsed.  Must be in the form '[x1:x2,y1:y2]'."),
                 region);
         return psRegionSet(NAN,NAN,NAN,NAN);
@@ -64 +64 @@
     if ((col1 > 0) && (col0 > col1)) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_SUBSET_RANGE_MALFORMED,
+                _("Specified subset range, [%d:%d,%d:%d], is invalid.  Ranges must be incremental."),
                 col0,col1,row0,row1);
         return psRegionSet(NAN,NAN,NAN,NAN);
@@ -71 +71 @@
     if ((row1 > 0) && (row0 > row1)) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_SUBSET_RANGE_MALFORMED,
+                _("Specified subset range, [%d:%d,%d:%d], is invalid.  Ranges must be incremental."),
                 col0,col1,row0,row1);
         return psRegionSet(NAN,NAN,NAN,NAN);

trunk/psLib/src/math/psSpline.c

@@ -6 +6 @@
 *  This file contains the routines that allocate, free, and evaluate splines.
 *
-*  @version $Revision: 1.150 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-07-15 02:57:12 $
+*  @version $Revision: 1.151 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:23 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -28 +28 @@
 #include "psSpline.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 #include "psMathUtils.h"
 

trunk/psLib/src/math/psStats.c

@@ -16 +16 @@
  * use ->min and ->max (PS_STAT_USE_RANGE)
  *
- *  @version $Revision: 1.182 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-28 00:44:05 $
+ *  @version $Revision: 1.183 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -49 +49 @@
 #include "psString.h"
 
-#include "psErrorText.h"
+
 
 /*****************************************************************************/
@@ -440 +440 @@
         psError(PS_ERR_UNEXPECTED_NULL,
                 false,
-                PS_ERRORTEXT_psStats_STATS_SAMPLE_MEDIAN_SORT_PROBLEM);
+                _("Failed to sort input data."));
         psTrace(__func__, 4, "---- %s(false) end ----\n", __func__);
         psFree(vector);
@@ -924 +924 @@
                 ((y->data.F64[2] <= yVal) && (yVal <= y->data.F64[0]))) ) {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psStats_YVAL_OUT_OF_RANGE,
+                    _("Specified yVal, %g, is not within y-range, %g to %g."),
                     (psF64)yVal, y->data.F64[0], y->data.F64[2]);
         }
@@ -946 +946 @@
         if (myPoly == NULL) {
             psError(PS_ERR_UNEXPECTED_NULL, false,
-                    PS_ERRORTEXT_psStats_STATS_FIT_QUADRATIC_POLYNOMIAL_1D_FIT);
+                    _("Failed to fit a 1-dimensional polynomial to the three specified data points.  Returning NAN."));
             psFree(x);
             psFree(y);
@@ -967 +967 @@
         if (isnan(tmpFloat)) {
             psError(PS_ERR_UNEXPECTED_NULL,
-                    false, PS_ERRORTEXT_psStats_STATS_FIT_QUADRATIC_POLY_MEDIAN);
+                    false, _("Failed to determine the median of the fitted polynomial.  Returning NAN."));
             psFree(x);
             psFree(y);
@@ -2035 +2035 @@
                           PS_STAT_FITTED_MEAN | PS_STAT_FITTED_STDEV)) {
         if (!vectorRobustStats(inF32, errorsF32, maskU8, maskVal, stats)) {
-            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psStats_STATS_FAILED);
+            psError(PS_ERR_UNKNOWN, false, _("Failed to calculate the specified statistic."));
             psFree(stats);
             psFree(inF32);

trunk/psLib/src/math/psUnaryOp.c

@@ -30 +30 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-30 02:20:06 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -51 +51 @@
 #include "psLogMsg.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 
 /*****************************************************************************
@@ -78 +78 @@
     long nOut = ((psVector*)OUT)->n; \
     if (nIn != nOut) { \
-        psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_COUNT_DIFFERS, nIn, nOut); \
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Number of elements inconsistent, %d vs %d.  Number of elements must match."), nIn, nOut); \
         if (OUT != IN) { \
             psFree(OUT); \
@@ -99 +99 @@
     long numColsOut = ((psImage*)OUT)->numCols; \
     if(numRowsIn!=numRowsOut || numColsIn!=numColsOut) { \
-        psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_IMAGE_SIZE_DIFFERS, \
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Specified psImage dimensions differed, %dx%d vs %dx%d."), \
                 numColsIn, numRowsIn, numColsOut, numRowsOut); \
         if (OUT != IN) { \
@@ -157 +157 @@
         char* strType; \
         PS_TYPE_NAME(strType, IN->type); \
-        psError(PS_ERR_BAD_PARAMETER_TYPE, true, PS_ERRORTEXT_psMatrix_TYPE_MISMATCH, strType); \
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true, _("Specified data type, %s, is not supported."), strType); \
         if (OUT != IN) { \
             psFree(OUT); \
@@ -275 +275 @@
     } \
 } else { \
-    psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMatrix_OPERATION_UNSUPPORTED, OP); \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified operation, %s, is not supported."), OP); \
     if (OUT != IN) { \
         psFree(OUT); \
@@ -309 +309 @@
     case PS_DIMEN_TRANSV:
         if (((psVector*)in)->n == 0) {
-            psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_VECTOR_EMPTY);
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Input psVector contains no elements.  No data to perform operation with."));
             psUnaryOp_EXIT;
         }
@@ -315 +315 @@
         out = psVectorRecycle(out, ((psVector*)in)->n, psTypeIn->type);
         if (out == NULL) {
-            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
+            psError(PS_ERR_UNKNOWN, false, _("Couldn't create a proper output psVector."));
             psUnaryOp_EXIT;
         }
@@ -324 +324 @@
     case PS_DIMEN_IMAGE:
         if (((psImage* ) in)->numCols == 0 || ((psImage* ) in)->numRows == 0) {
-            psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_IMAGE_EMPTY);
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Input psImage contains no pixels.  No data to perform operation with."));
             psUnaryOp_EXIT;
         }
@@ -330 +330 @@
         out = psImageRecycle(out, ((psImage*)in)->numCols, ((psImage*)in)->numRows, psTypeIn->type);
         if (out == NULL) {
-            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
+            psError(PS_ERR_UNKNOWN, false, _("Couldn't create a proper output psImage."));
             psUnaryOp_EXIT;
         }
@@ -340 +340 @@
             psFree(out);
         }
-        psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psMatrix_DIMEN_INVALID, "in", psTypeIn->dimen);
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true, _("Specified parameter, %s, has invalid dimensionality, %d."), "in", psTypeIn->dimen);
         psUnaryOp_EXIT;
     }

trunk/psLib/src/mathtypes/psImage.c

@@ -9 +9 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.112 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:57:12 $
+ *  @version $Revision: 1.113 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -27 +27 @@
 #include "psString.h"
 
-#include "psErrorText.h"
+
 
 #define SQUARE(x) ((x)*(x))
@@ -64 +64 @@
     if (numRows < 1) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_AREA_NEGATIVE,
+                _("Specified number of rows (%d) or columns (%d) is invalid."),
                 numRows, numCols);
         return NULL;
@@ -70 +70 @@
     if (numCols < 1) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psImage_AREA_NEGATIVE,
+                _("Specified number of rows (%d) or columns (%d) is invalid."),
                 numRows, numCols);
         return NULL;
@@ -380 +380 @@
         psFree(old);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
+                _("The input psImage must have a PS_DIMEN_IMAGE dimension type."));
         return NULL;
     }
@@ -417 +417 @@
     if (input == NULL || input->data.V == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
+                _("Can not operate on a NULL psImage."));
         return false;
     }
@@ -423 +423 @@
     if (input->type.dimen != PS_DIMEN_IMAGE) {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
+                _("The input psImage must have a PS_DIMEN_IMAGE dimension type."));
         return false;
     }
@@ -536 +536 @@
             PS_TYPE_NAME(typeStr,type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
             break;
@@ -634 +634 @@
     default:                                                         \
         psError(PS_ERR_BAD_PARAMETER_VALUE,true,                     \
-                PS_ERRORTEXT_psImage_INTERPOLATE_METHOD_INVALID,     \
+                _("Specified interpolation method (%d) is not supported."),     \
                 mode);                                               \
     }                                                                \
@@ -656 +656 @@
             PS_TYPE_NAME(typeStr,input->type.type);
             psError(PS_ERR_BAD_PARAMETER_TYPE,true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                    _("Specified psImage type, %s, is not supported."),
                     typeStr);
         }

trunk/psLib/src/mathtypes/psScalar.c

@@ -8 +8 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.23 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:57:12 $
+ *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -20 +20 @@
 #include "psAbort.h"
 
-#include "psErrorText.h"
+
 
 static void scalarFree(psScalar *scalar)
@@ -76 +76 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psScalar_UNSUPPORTED_TYPE,
+                _("Specified datatype (%d) is unsupported by psScalar."),
                 type);
         psFree(scalar);
@@ -103 +103 @@
     if (value == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psScalar_COPY_NULL);
+                _("Can not copy a NULL psScalar."));
         return NULL;
     }
@@ -147 +147 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psScalar_UNSUPPORTED_TYPE,
+                _("Specified datatype (%d) is unsupported by psScalar."),
                 dataType);
         return NULL;

trunk/psLib/src/mathtypes/psVector.c

@@ -9 +9 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.79 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-07-26 02:19:32 $
+*  @version $Revision: 1.80 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:23 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -27 +27 @@
 #include "psCompare.h"
 
-#include "psErrorText.h"
+
 
 typedef struct
@@ -79 +79 @@
     if (elementSize < 1) {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE, type);
+                _("Input psVector is an unsupported type (0x%x)."), type);
         return NULL;
     }
@@ -108 +108 @@
     if (vector == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psVector_REALLOC_NULL);
+                _("psVectorRealloc must a given a non-NULL psVector to resize.  Desired datatype unknown."));
         return NULL;
     } else if (vector->nalloc != nalloc) {     // No need to realloc to same size
@@ -138 +138 @@
         psFree(vector);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVector_NOT_A_VECTOR);
+                _("The input psVector must have a vector dimension type."));
         return NULL;
     }
@@ -163 +163 @@
     if (vector == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psVector_NULL);
+                _("The input psVector can not be NULL."));
         return NULL;
     }
@@ -201 +201 @@
     if (input == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psVector_NULL);
+                _("The input psVector can not be NULL."));
         psFree(output);
         return NULL;
@@ -241 +241 @@
                 PS_TYPE_NAME(typeStr,type);
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                        //                        PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE, typeStr);
+                        //                        _("Input psVector is an unsupported type (0x%x)."), typeStr);
                         "Input psVector is an unsupported type.\n");
                 psFree(output);
@@ -301 +301 @@
                 PS_TYPE_NAME(typeStr,type); \
                 psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
-                        PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE, \
+                        _("Input psVector is an unsupported type (0x%x)."), \
                         typeStr); \
                 psFree(output); \
@@ -326 +326 @@
             PS_TYPE_NAME(typeStr,type);
             psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE,
+                    _("Input psVector is an unsupported type (0x%x)."),
                     typeStr);
             psFree(output);
@@ -378 +378 @@
     if (!inVector) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psVector_SORT_NULL);
+                _("psVectorSort can not sort a NULL psVector."));
         psFree(outVector);
         return NULL;
@@ -408 +408 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE,
+                _("Input psVector is an unsupported type (0x%x)."),
                 inVector->type.type);
         psFree(outVector);
@@ -455 +455 @@
     if (inVector == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psVector_SORT_NULL);
+                _("psVectorSort can not sort a NULL psVector."));
         psFree(outVector);
         return NULL;
@@ -481 +481 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE,
+                _("Input psVector is an unsupported type (0x%x)."),
                 inVector->type.type);
         psFree(outVector);
@@ -896 +896 @@
 {
     if (input == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psVector_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psVector can not be NULL."));
         return false;
     }
@@ -969 +969 @@
 {
     if (input == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psVector_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psVector can not be NULL."));
         return NAN;
     }
@@ -1032 +1032 @@
     long Npixels = 0;
     if (mask == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psVector_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("The input psVector can not be NULL."));
         Npixels = -1;
         return Npixels;
@@ -1067 +1067 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psVector_UNSUPPORTED_TYPE, type);
+                _("Input psVector is an unsupported type (0x%x)."), type);
         return -1;
     }

trunk/psLib/src/sys/psConfigure.c

@@ -13 +13 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-23 01:59:15 $
+ *  @version $Revision: 1.14 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -28 +28 @@
 #include "psError.h"
 #include "psConfigure.h"
-#include "psErrorText.h"
+
 #include "config.h"
 
@@ -98 +98 @@
         if (!p_psTimeInit(timeConfig)) {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psConfigure_INITIALIZATION_FAILED, "psTime");
+                    _("Failed to initialize %s."), "psTime");
             return;
         }
@@ -104 +104 @@
     if (!p_psEOCInit()) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psConfigure_INITIALIZATION_FAILED, "psEOC");
+                _("Failed to initialize %s."), "psEOC");
         return;
     }
@@ -125 +125 @@
     if (!p_psTimeFinalize()) {
         psError(PS_ERR_UNKNOWN, false,
-                PS_ERRORTEXT_psConfigure_FINALIZATION_FAILED, "psTime");
+                _("Failed to finalize %s."), "psTime");
         return;
     }
@@ -132 +132 @@
     if (!p_psEOCFinalize()) {
         psError(PS_ERR_UNKNOWN, false,
-                PS_ERRORTEXT_psConfigure_FINALIZATION_FAILED, "psEOC");
+                _("Failed to finalize %s."), "psEOC");
         return;
     }

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

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-25 01:27:48 $
+ *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -20 +20 @@
 #include "psMemory.h"
 
-#include "psErrorText.h"
+
 
 static psErrorDescription staticErrorCodes[] = {

trunk/psLib/src/sys/psLogMsg.c

@@ -11 +11 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.59 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-08-03 03:26:28 $
+ *  @version $Revision: 1.60 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -36 +36 @@
 #include "psString.h"
 
-#include "psErrorText.h"
+
 
 #define MIN_LOG_LEVEL 0
@@ -165 +165 @@
         default:
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psLogMsg_UNKNOWN_KEY, *ptr);
+                    _("Unknown logging keyword %c."), *ptr);
             return false;
         }
@@ -210 +210 @@
 
         if (fileD == 0) {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psLogMsg_OPEN_FILE_FAILED,
+            psError(PS_ERR_IO, true, _("Could not open file '%s' for output."),
                     location);
             psFree(protocolLocation);

trunk/psLib/src/sys/psMemory.c

@@ -8 +8 @@
 *  @author Robert Lupton, Princeton University
 *
-*  @version $Revision: 1.74 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-07-14 02:26:25 $
+*  @version $Revision: 1.75 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:23 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -33 +33 @@
 #include "psLine.h"
 #include "psRegion.h"
-#include "psErrorText.h"
+
 
 #define P_PS_MEMMAGIC (psPtr )0xdeadbeef   // Magic number in psMemBlock header
@@ -126 +126 @@
     if (ptr->refCounter < 1) {
         psError(PS_ERR_MEMORY_CORRUPTION, false,
-                PS_ERRORTEXT_psMemory_MULTIPLE_FREE,
+                _("Block %lu, allocated at %s:%d, freed multiple times at %s:%d."),
                 (unsigned long)ptr->id, ptr->file, ptr->lineno, file, lineno);
     }
@@ -148 +148 @@
     if (m == NULL) {
         psError(PS_ERR_MEMORY_CORRUPTION, true,
-                PS_ERRORTEXT_psMemory_NULL_BLOCK);
+                _("NULL memory block found."));
         return 1;
     }
@@ -155 +155 @@
         // using an unreferenced block of memory, are you?
         psError(PS_ERR_MEMORY_CORRUPTION, true,
-                PS_ERRORTEXT_psMemory_DEREF_BLOCK_USE,
+                _("Memory block %lu was freed but still being used."),
                 (unsigned long)m->id);
         return 1;
@@ -162 +162 @@
     if (m->startblock != P_PS_MEMMAGIC || m->endblock != P_PS_MEMMAGIC) {
         psError(PS_ERR_MEMORY_CORRUPTION, true,
-                PS_ERRORTEXT_psMemory_UNDERFLOW,
+                _("Memory block %lu is corrupted; buffer underflow detected."),
                 (unsigned long)m->id);
         return 1;
@@ -168 +168 @@
     if (*(psPtr *)((int8_t *) (m + 1) + m->userMemorySize) != P_PS_MEMMAGIC) {
         psError(PS_ERR_MEMORY_CORRUPTION, true,
-                PS_ERRORTEXT_psMemory_OVERFLOW,
+                _("Memory block %lu is corrupted; buffer overflow detected."),
                 (unsigned long)m->id);
         return 1;
@@ -506 +506 @@
         psMemBlock* ptr = ((psMemBlock* ) vptr) - 1;
 
-        psAbort(__func__,PS_ERRORTEXT_psMemory_MULTIPLE_FREE,
+        psAbort(__func__,_("Block %lu, allocated at %s:%d, freed multiple times at %s:%d."),
                 (unsigned long)ptr->id, ptr->file, ptr->lineno, filename, lineno);
     }

trunk/psLib/src/sys/psString.c

@@ -13 +13 @@
  *  @author David Robbins, MHPCC
  *
- *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:50:51 $
+ *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -28 +28 @@
 #include "psAbort.h"
 
-#include "psErrorText.h"
+
 
 static void stringFree(psString string)
@@ -78 +78 @@
         // Log error message and return NULL
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psString_NCHAR_NEGATIVE,
+                _("Can not copy a negative number of characters (%d)."),
                 nChar);
         return NULL;

trunk/psLib/src/sys/psTrace.c

@@ -9 +9 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.64 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-06-15 00:22:54 $
+ *  @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -51 +51 @@
 #include "psLogMsg.h"
 
-#include "psErrorText.h"
+
 
 static p_psComponent* cRoot = NULL; // The root of the trace component
@@ -132 +132 @@
         if (NULL == currentNode->subcomp[i]) {
             psLogMsg("p_psTraceReset", PS_LOG_WARN,
-                     PS_ERRORTEXT_psTrace_NULL_SUBCOMPONENT,
+                     _("Sub-component %d of node %s in trace tree is NULL."),
                      i, currentNode->name);
         } else {
@@ -165 +165 @@
     if (strcmp("", addNodeName) == 0) {
         psError(PS_ERR_BAD_PARAMETER_NULL,true,
-                PS_ERRORTEXT_psTrace_ADD_NULL_COMPONENT);
+                _("Failed to add null component to trace tree."));
         return false;
     }
@@ -177 +177 @@
     if (addNodeName[0] != '.') {
         psError(PS_ERR_BAD_PARAMETER_VALUE,true,
-                PS_ERRORTEXT_psTrace_MALFORMED_COMPONENT_NAME,
+                _("Failed to add '%s' to the root component tree; component must start with '.'."),
                 addNodeName);
         return false;
@@ -274 +274 @@
     if ( !componentAdd(compName, level) ) {
         psError(PS_ERR_UNKNOWN, false,
-                PS_ERRORTEXT_psTrace_FAILED_TO_ADD_COMPONENT,
+                _("Failed to set trace level (%d) to '%s'."),
                 level,
                 compName);
@@ -346 +346 @@
             if (NULL == currentNode->subcomp[i]) {
                 psLogMsg("p_psTraceReset", PS_LOG_WARN,
-                         PS_ERRORTEXT_psTrace_NULL_SUBCOMPONENT,
+                         _("Sub-component %d of node %s in trace tree is NULL."),
                          i, currentNode->name);
             }
@@ -504 +504 @@
     if (NULL == comp) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psTrace_NULL_TRACETREE,
+                _("Function %s called on a NULL trace level tree."),
                 __func__);
         return;
@@ -705 +705 @@
         default:
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psLogMsg_UNKNOWN_KEY, *ptr);
+                    _("Unknown logging keyword %c."), *ptr);
             return false;
         }

trunk/psLib/src/types/psArguments.c

@@ -7 +7 @@
  *  @author David Robbins, MHPCC
  *
- *  @version $Revision: 1.8 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-08-02 02:28:04 $
+ *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -21 +21 @@
 #include "psError.h"
 #include "psAbort.h"
-#include "psErrorText.h"
+
 #include "psLogMsg.h"
 #include "psTrace.h"

trunk/psLib/src/types/psArray.c

@@ -9 +9 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:57:12 $
+ *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -28 +28 @@
 #include "psLogMsg.h"
 
-#include "psErrorText.h"
+
 
 /*****************************************************************************
@@ -79 +79 @@
 {
     if (in == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL,true,PS_ERRORTEXT_psArray_REALLOC_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL,true,_("psArrayRealloc must be given a non-NULL psArray to resize."));
         return NULL;
     } else if (in->nalloc != nalloc) {     // No need to realloc to same size
@@ -132 +132 @@
     if (array == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psArray_ARRAY_NULL);
+                _("Specified psArray can not be NULL."));
         return false;
     }
@@ -184 +184 @@
     {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psArray_ARRAY_NULL);
+                _("Specified psArray can not be NULL."));
         return false;
     }
@@ -208 +208 @@
         if (position >= array->nalloc) {
             psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                    PS_ERRORTEXT_psArray_POSITION_BEYOND_NALLOC,
+                    _("Specified position, %d, is greater than the allocated size of the array, %d."),
                     position, array->nalloc);
             return false;
@@ -226 +226 @@
     if (array == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psArray_ARRAY_NULL);
+                _("Specified psArray can not be NULL."));
         return NULL;
     }

trunk/psLib/src/types/psBitSet.c

@@ -11 +11 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.32 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:57:12 $
+ *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -28 +28 @@
 #include "psString.h"
 
-#include "psErrorText.h"
+
 
 enum {
@@ -82 +82 @@
     if (nalloc < 0) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psBitSet_ALLOC_NEG_SIZE,
+                _("The number of bit in a psBitSet (%d) must be greater than zero."),
                 nalloc);
         return NULL;
@@ -108 +108 @@
     if (bitSet == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psBitSet_SET_NULL);
+                _("Can not operate on a NULL psBitSet."));
         return bitSet;
     } else if ( (bit < 0) ||
                 (bit > bitSet->n * 8 - 1) ) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE,
+                _("The specified bit position (%d) is invalid.  Position must be between 0 and %d."),
                 bit,bitSet->n * 8 - 1);
         return bitSet;
@@ -131 +131 @@
     if (bitSet == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psBitSet_SET_NULL);
+                _("Can not operate on a NULL psBitSet."));
         return bitSet;
     } else if ( (bit < 0) ||
                 (bit > bitSet->n * 8 - 1) ) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE,
+                _("The specified bit position (%d) is invalid.  Position must be between 0 and %d."),
                 bit,bitSet->n * 8 - 1);
         return bitSet;
@@ -154 +154 @@
     if (bitSet == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psBitSet_SET_NULL);
+                _("Can not operate on a NULL psBitSet."));
         return false;
     } else if ( (bit < 0) ||
                 (bit > bitSet->n * 8 - 1) ) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psBitSet_BIT_OUTOFRANGE,
+                _("The specified bit position (%d) is invalid.  Position must be between 0 and %d."),
                 bit,bitSet->n * 8 - 1);
         return false;
@@ -183 +183 @@
     if (inBitSet1 == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psBitSet_FIRST_OPERAND_NULL);
+                _("First psBitSet operand can not be NULL."));
         psFree(outBitSet);
         return NULL;
@@ -191 +191 @@
     if (operator == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psBitSet_OPERATOR_NULL);
+                _("Specified operator is NULL.  Must specify desired operator."));
         psFree(outBitSet);
         return NULL;
@@ -208 +208 @@
         psFree(outBitSet);
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psBitSet_OPERATOR_INVALID,
+                _("Specified operator, %s, is invalid.  Valid operators are AND, OR, and XOR."),
                 operator);
         return NULL;
@@ -216 +216 @@
         if (inBitSet2 == NULL) {
             psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                    PS_ERRORTEXT_psBitSet_SECOND_OPERAND_NULL);
+                    _("Second psBitSet operand can not be NULL."));
             psFree(outBitSet);
             return NULL;
@@ -223 +223 @@
         if (inBitSet1->n != inBitSet2->n) {
             psError(PS_ERR_BAD_PARAMETER_SIZE, true,
-                    PS_ERRORTEXT_psBitSet_OPERANDS_SIZE_DIFFER);
+                    _("The psBitSet operand must be the same size."));
             psFree(outBitSet);
             return NULL;
@@ -274 +274 @@
     if (inBitSet == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psBitSet_OPERAND_NULL);
+                _("Operand can not be NULL."));
         psFree(outBitSet);
         return NULL;
@@ -283 +283 @@
     if (outBitSet == NULL) {
         psError(PS_ERR_UNKNOWN, false,
-                PS_ERRORTEXT_psBitSet_NOT_OP_FAILED);
+                _("Could not perform NOT operation."));
     }
 

trunk/psLib/src/types/psHash.c

@@ -12 +12 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-07-15 02:57:12 $
+*  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:23 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -27 +27 @@
 #include "psAssert.h"
 
-#include "psErrorText.h"
+
 
 static psHashBucket* hashBucketAlloc(const char *key, psPtr data, psHashBucket* next);
@@ -240 +240 @@
     if ((table == NULL) || (key == NULL)) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psHash_KEY_NULL);
+                _("Input key can not be NULL."));
         return NULL;
     }

trunk/psLib/src/types/psList.c

@@ -6 +6 @@
  *  @author Robert Daniel DeSonia, MHPCC
  *
- *  @version $Revision: 1.50 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:57:12 $
+ *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -21 +21 @@
 #include "psLogMsg.h"
 
-#include "psErrorText.h"
+
 
 #define ITER_INIT_HEAD ((psPtr )1)         // next iteration should return head
@@ -206 +206 @@
     if (location < 0 || location >= (int)list->n) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psList_LOCATION_INVALID,
+                _("Specified location, %d, is invalid."),
                 location);
         return false;
@@ -248 +248 @@
     if (list == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_LIST_NULL);
+                _("Specified psList reference is NULL."));
         return false;
     }
@@ -254 +254 @@
     if (data == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_DATA_NULL);
+                _("Specified data item is NULL."));
         return false;
     }
@@ -283 +283 @@
     if (data == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_DATA_NULL);
+                _("Specified data item is NULL."));
         return false;
     }
@@ -289 +289 @@
     if (iterator == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_ITERATOR_NULL);
+                _("Specified iterator is NULL."));
         return false;
     }
@@ -296 +296 @@
     if (!iterator->mutable) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_ITERATOR_NONMUTABLE);
+                _("Specified iterator indicates list is non-mutable."));
         return false;
     }
@@ -305 +305 @@
     if (cursor == NULL && list->head != NULL) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psList_ITERATOR_INVALID);
+                _("Specified iterator is not valid."));
         return false;
     }
@@ -352 +352 @@
     if (data == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_DATA_NULL);
+                _("Specified data item is NULL."));
         return false;
     }
@@ -358 +358 @@
     if (iterator == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_ITERATOR_NULL);
+                _("Specified iterator is NULL."));
         return false;
     }
@@ -365 +365 @@
     if (!iterator->mutable) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_ITERATOR_NONMUTABLE);
+                _("Specified iterator indicates list is non-mutable."));
         return false;
     }
@@ -374 +374 @@
     if (cursor == NULL && list->head != NULL) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psList_ITERATOR_INVALID);
+                _("Specified iterator is not valid."));
         return false;
     }
@@ -422 +422 @@
     if (list == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_LIST_NULL);
+                _("Specified psList reference is NULL."));
         return false;
     }
@@ -440 +440 @@
     if (list == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_LIST_NULL);
+                _("Specified psList reference is NULL."));
         return false;
     }
@@ -446 +446 @@
     if (data == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_DATA_NULL);
+                _("Specified data item is NULL."));
         return false;
     }
@@ -458 +458 @@
     if (elem == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_DATA_NOT_FOUND);
+                _("Specified data item is not found in the psList."));
         return false;
     }
@@ -473 +473 @@
     if (list == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psList_LIST_NULL);
+                _("Specified psList reference is NULL."));
         return NULL;
     }
@@ -485 +485 @@
     if (! psListIteratorSet(iterator,location)) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psList_LOCATION_INVALID,
+                _("Specified location, %d, is invalid."),
                 location);
         return NULL;

trunk/psLib/src/types/psLookupTable.c

@@ -7 +7 @@
 *  @author Ross Harman, MHPCC
 *
-*  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-07-20 13:00:10 $
+*  @version $Revision: 1.35 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:23 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -25 +25 @@
 #include "psError.h"
 #include "psLookupTable.h"
-#include "psErrorText.h"
+
 #include "psAssert.h"
 
@@ -487 +487 @@
         // Open specified file
         if((fp=fopen(filename, "r")) == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psLookupTable_FILE_NOT_FOUND,
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed to open file %s."),
                     filename);
             psFree(outputArray);
@@ -813 +813 @@
         if(hiIdx >= numRows) {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psLookupTable_INTERPOLATE_HIGH, hiIdx);
+                    _("High index too big, %d."), hiIdx);
             return NAN;
         }
@@ -823 +823 @@
     if(loIdx < 0) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psLookupTable_INTERPOLATE_LOW, loIdx);
+                _("Low index too small, %d."), loIdx);
         return NAN;
     }
@@ -832 +832 @@
     denom -= convertVal;
     if(fabs(denom) < FLT_EPSILON) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psLookupTable_DIVIDE_BY_ZERO);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Divide by zero error during interpolation."));
         return NAN;
     } else {

trunk/psLib/src/types/psMetadata.c

@@ -12 +12 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.120 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-19 03:43:14 $
+ *  @version $Revision: 1.121 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -36 +36 @@
 #include "psLookupTable.h"
 #include "psString.h"
-#include "psErrorText.h"
+
 #include "psAssert.h"
 #include "psLogMsg.h"
@@ -319 +319 @@
         break;
     default:
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, type);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified psDataType, %d, is not supported."), type);
         psFree(metadataItem);
         metadataItem = NULL;
@@ -554 +554 @@
             // add to the hash's list of duplicate entries
             if (! psListAdd(existingEntry->data.list, PS_LIST_TAIL, (psPtr)item) ) {
-                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED,key);
+                psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to metadata collection list."),key);
                 return false;
             }
@@ -565 +565 @@
             // treat as if new (added to list below)
             if(!psHashAdd(mdTable, key, (psPtr)item)) {
-                psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
+                psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to items table."),key);
                 return false;
             }
@@ -578 +578 @@
             }
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psMetadata_DUPLICATE_NOT_ALLOWED);
+                    _("Duplicate metadata item name is not allowed.  Use a psMetadataFlags option to allow such action."));
             return false;
         }
@@ -586 +586 @@
         // Node doesn't exist - Add new metadata item to metadata collection's hash
         if(!psHashAdd(mdTable, key, (psPtr)item)) {
-            psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_TABLE_FAILED,key);
+            psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to items table."),key);
             return false;
         }
@@ -597 +597 @@
 
     if(!psListAdd(mdList, location, (psPtr)item)) {
-        psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_COLLECTION_FAILED,key);
+        psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item, %s, to metadata collection list."),key);
         return false;
     }
@@ -635 +635 @@
 
     if (!psMetadataAddItem(md, metadataItem, location, format & PS_METADATA_FLAGS_MASK)) {
-        psError(PS_ERR_UNKNOWN,false,PS_ERRORTEXT_psMetadata_ADD_FAILED);
+        psError(PS_ERR_UNKNOWN,false,_("Failed to add metadata item to metadata collection list."));
         psFree(metadataItem);
         return false;
@@ -717 +717 @@
         psMetadataItem* entry = psHashLookup(mdTable,key);
         if (entry == NULL) {
-            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED, key);
+            psError(PS_ERR_UNKNOWN, false, _("Failed to remove metadata item, %s, from metadata table."), key);
             return false;
         }
@@ -739 +739 @@
         psMetadataItem* entry = psListGet(mdList, where);
         if (entry == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED, where);
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Could not find metadata item at index %d."), where);
             return false;
         }
@@ -745 +745 @@
 
         if (key == NULL) {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_REMOVE_LIST_INDEX_FAILED, where);
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed to remove metadata item, at index %d, from metadata list."), where);
             return false;
         }
@@ -751 +751 @@
         psMetadataItem* tableItem = psHashLookup(mdTable, key);
         if (tableItem == NULL) {
-            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED, key);
+            psError(PS_ERR_UNKNOWN, false, _("Failed to remove metadata item, %s, from metadata table."), key);
             return false;
         }
@@ -760 +760 @@
         } else {
             if (!psHashRemove(mdTable, key)) {
-                psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psMetadata_REMOVE_TABLE_FAILED, key);
+                psError(PS_ERR_UNKNOWN, false, _("Failed to remove metadata item, %s, from metadata table."), key);
                 return false;
             }
@@ -828 +828 @@
         }
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psMetadata_METATYPE_INVALID,
+                _("Specified psDataType, %d, is not supported."),
                 metadataItem->type);
         return NULL;
@@ -928 +928 @@
     entry = (psMetadataItem*) psListGet(md->list, location);
     if (entry == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_FIND_INDEX_FAILED, location);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Could not find metadata item at index %d."), location);
         return NULL;
     }
@@ -954 +954 @@
             regerror(regRtn, newIter->regex, errMsg, 256);
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psMetadata_REGEX_INVALID,
+                    _("Specified regular expression is invalid.  %s."),
                     errMsg);
             psFree(newIter);
@@ -1333 +1333 @@
                 default:
                     psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                            PS_ERRORTEXT_psMetadata_METATYPE_INVALID, vector->type.type);
+                            _("Specified psDataType, %d, is not supported."), vector->type.type);
                     return false;
                 }

trunk/psLib/src/types/psMetadataConfig.c

@@ -10 +10 @@
 *  @author Eric Van Alst, MHPCC
 *
-*  @version $Revision: 1.69 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-08-04 22:58:58 $
+*  @version $Revision: 1.70 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:23 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -32 +32 @@
 #include "psMetadataConfig.h"
 #include "psAssert.h"
-#include "psErrorText.h"
+
 
 /******************************************************************************/
@@ -399 +399 @@
                 *status = 1;
                 psError(PS_ERR_BAD_PARAMETER_VALUE,true,
-                        PS_ERRORTEXT_psMetadataIO_TYPE_INVALID,
+                        _("Specified type, %d, is not supported."),
                         elemType);
             }
@@ -510 +510 @@
         default: \
             psError(PS_ERR_BAD_PARAMETER_TYPE,true, \
-                    PS_ERRORTEXT_psMetadata_METATYPE_INVALID, (int)type); \
+                    _("Specified psDataType, %d, is not supported."), (int)type); \
             success = false; \
         } \
@@ -542 +542 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_TYPE,true,
-                    PS_ERRORTEXT_psMetadata_METATYPE_INVALID, (int)type);
+                    _("Specified psDataType, %d, is not supported."), (int)type);
             success = false;
         }
@@ -551 +551 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psMetadata_FORMAT_INVALID, *fType);
+                _("Specified print format, %%%c, is not supported."), *fType);
         break;
     }
@@ -709 +709 @@
     // Check for no type
     if(strType==NULL) {
-        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "type",lineCount,
+        psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "type",lineCount,
                 fileName);
         returnValue = false;
@@ -741 +741 @@
                 vectorType = PS_TYPE_F64;
             } else {
-                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, "", keyName,
+                psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), "", keyName,
                         strType, lineCount, fileName);
                 psFree(strType);
@@ -786 +786 @@
                         // Check for add failure
                         if (! addStatus) {
-                            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_OVERWRITE_ITEM,
+                            psError(PS_ERR_IO, true, _("Duplicate Metadata item, %s, found on line %u of %s.  Overwrite not allowed."),
                                     keyName, lineCount, fileName);
                             psFree(strType);
@@ -795 +795 @@
                     } else {
                         // Metadata type read error
-                        psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,
+                        psError(PS_ERR_IO,true,_("Failed to read a metadata %s on line %u of %s."),
                                 keyName,lineCount,fileName);
                         psFree(strType);
@@ -805 +805 @@
             }
             if(!typeFound) {
-                psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
+                psError(PS_ERR_IO, true, _("Metadata type '%s', found on line %u of %s, is invalid."),
                         strType, lineCount,fileName);
                 psFree(strType);
@@ -822 +822 @@
         strValue = getToken(&linePtr, "#", &status,true);
         if(status) {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "value", lineCount,
+            psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "value", lineCount,
                     fileName);
             psFree(strType);
@@ -829 +829 @@
         }
         if(strValue==NULL) {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "value", lineCount,
+            psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "value", lineCount,
                     fileName);
             psFree(strType);
@@ -839 +839 @@
         strComment = getToken(&linePtr,"~", &status,true);
         if(status) {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "comment", lineCount,
+            psError(PS_ERR_IO, true, _("Failed to read a metadata %s on line %u of %s."), "comment", lineCount,
                     fileName);
             psFree(strType);
@@ -864 +864 @@
                                       strComment, tempBool);
         } else {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
+            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
                     strType, lineCount, fileName);
             returnValue = false;
@@ -878 +878 @@
         } else {
             psError(PS_ERR_IO, true,
-                    PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName, strType, lineCount,
+                    _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName, strType, lineCount,
                     fileName);
             returnValue = false;
@@ -888 +888 @@
             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempInt);
         } else {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
+            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
                     strType, lineCount, fileName);
             returnValue = false;
@@ -898 +898 @@
             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempInt);
         } else {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
+            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
                     strType, lineCount, fileName);
             returnValue = false;
@@ -908 +908 @@
             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempInt);
         } else {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
+            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
                     strType, lineCount, fileName);
             returnValue = false;
@@ -918 +918 @@
             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempUint);
         } else {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
+            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
                     strType, lineCount, fileName);
             returnValue = false;
@@ -928 +928 @@
             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempUint);
         } else {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
+            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
                     strType, lineCount, fileName);
             returnValue = false;
@@ -938 +938 @@
             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags, strComment, tempUint);
         } else {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
+            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
                     strType, lineCount, fileName);
             returnValue = false;
@@ -958 +958 @@
                                       strComment, mTime);
         } else {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
+            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
                     strType, lineCount, fileName);
             returnValue = false;
@@ -971 +971 @@
                                       strComment, tempVec);
         } else {
-            psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_PARSE_FAILED, strValue, keyName,
+            psError(PS_ERR_IO, true, _("Failed to parse the value '%s' of metadata item %s, type %s, on line %u of %s."), strValue, keyName,
                     strType, lineCount, fileName);
             returnValue = false;
@@ -983 +983 @@
         for(psS32 k=0; k < nonUniqueKeys->n; k++) {
             if(strcmp(keyName,(char*)nonUniqueKeys->data[k]) == 0) {
-                psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_DUPLICATE_MULTI,
+                psError(PS_ERR_IO,true,_("Duplicate MULTI specifier on line %u of %s."),
                         lineCount,fileName);
                 psFree(strType);
@@ -1009 +1009 @@
         break;
     default:
-        psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
+        psError(PS_ERR_IO,true,_("Metadata type '%s', found on line %u of %s, is invalid."),
                 lineCount,fileName);
         break;
@@ -1057 +1057 @@
         if(repeatedChars(linePtr, '@') > 1) {
             psError(PS_ERR_IO, true,
-                    PS_ERRORTEXT_psMetadataIO_FILE_MULTIPLE_CHAR, '@', lineCount, fileName);
+                    _("More than one '%c' character not allowed.  Found on line %u of %s."), '@', lineCount, fileName);
             return false;
         }
@@ -1065 +1065 @@
         if(status) {
             psError(PS_ERR_IO, true,
-                    PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL, "keyName", lineCount, fileName);
+                    _("Failed to read a metadata %s on line %u of %s."), "keyName", lineCount, fileName);
             psFree(keyName);
             return false;
@@ -1075 +1075 @@
             strType = getToken(&linePtr," ",&status,true);
             if(strType == NULL) {
-                psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_FILE_ELEMENT_NULL,"type",lineCount,
+                psError(PS_ERR_IO,true,_("Failed to read a metadata %s on line %u of %s."),"type",lineCount,
                         fileName);
                 psFree(keyName);
@@ -1089 +1089 @@
                     // Compare type name with the list of current types
                     if(strcmp(strType,(char*)typeArray->data[k]) == 0) {
-                        psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_TYPE_DUPLICATE,
+                        psError(PS_ERR_IO,true,_("Specified type, %s, on line %u of %s is already defined."),
                                 strType,lineCount,fileName);
                         psFree(tempTemplate);
@@ -1104 +1104 @@
                 psFree(tempTemplate);
             } else {
-                psError(PS_ERR_IO,true,PS_ERRORTEXT_psMetadataIO_FILE_TYPE_INVALID,
+                psError(PS_ERR_IO,true,_("Metadata type '%s', found on line %u of %s, is invalid."),
                         strType,lineCount,fileName);
                 psFree(keyName);
@@ -1187 +1187 @@
     // Attempt to open specified file
     if((fp=fopen(filename, "r")) == NULL) {
-        psError(PS_ERR_IO, true, PS_ERRORTEXT_psMetadataIO_FILE_OPEN_FAILED, filename);
+        psError(PS_ERR_IO, true, _("Failed to open file '%s'. Check if it exists and it has the proper permissions."), filename);
         return NULL;
     }
@@ -1246 +1246 @@
             // XXX : this is probably not the right error value
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psMetadata_METATYPE_INVALID, PS_DATA_UNKNOWN);
+                    _("Specified psDataType, %d, is not supported."), PS_DATA_UNKNOWN);
             psFree(keys);
             psFree(format);
@@ -1385 +1385 @@
             psStringAppend(&content, "PS_TIME_TT  ");
         else {
-            psError(PS_ERR_BAD_PARAMETER_VALUE, true, PS_ERRORTEXT_psMetadata_METATYPE_INVALID, time->type);
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Specified psDataType, %d, is not supported."), time->type);
             psFree(content);
             return NULL;
@@ -1469 +1469 @@
         default:
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psMetadata_METATYPE_INVALID, vector->type.type);
+                    _("Specified psDataType, %d, is not supported."), vector->type.type);
             psFree(content);
             return NULL;
@@ -1481 +1481 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psMetadata_METATYPE_INVALID, item->type);
+                _("Specified psDataType, %d, is not supported."), item->type);
         psFree(content);
         return NULL;

trunk/psLib/src/types/psPixels.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-07-15 02:57:12 $
+ *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -20 +20 @@
 
 #include "psError.h"
-#include "psErrorText.h"
+
 
 typedef int(*qsortCompareFcn)(const void *, const void *);
@@ -133 +133 @@
 {
     if (pixels == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL,true,PS_ERRORTEXT_psPixels_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL,true,_("Input psPixels can not be NULL."));
         psFree(out);
         return NULL;
@@ -154 +154 @@
     if (pixels == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psPixels_NULL);
+                _("Input psPixels can not be NULL."));
         psFree(out);
         return NULL;
@@ -161 +161 @@
     if (data == NULL) {
         psError(PS_ERR_BAD_PARAMETER_SIZE, true,
-                PS_ERRORTEXT_psPixels_DATA_NULL);
+                _("Input psPixels contains no data."));
         psFree(out);
         return NULL;
@@ -173 +173 @@
     if ( (x0 < 0 || x1 < 0) || (y0 < 0 || y1 < 0) ) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psPixels_REGION_INVALID,
+                _("Specified psRegion, [%d:%d,%d:%d], does not specify a valid region."),
                 (int)y0,(int)y1,(int)x0,(int)x1);
         psFree(out);
@@ -186 +186 @@
     if (numRows < 1 || numCols < 1) {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psPixels_REGION_INVALID,
+                _("Specified psRegion, [%d:%d,%d:%d], does not specify a valid region."),
                 (int)y0,(int)y1,(int)x0,(int)x1);
         psFree(out);
@@ -196 +196 @@
     if (out == NULL) {
         psError(PS_ERR_UNKNOWN, false,
-                PS_ERRORTEXT_psPixels_FAILED_IMAGE_CREATE,
+                _("Failed to create image of size %dx%d."),
                 numCols, numRows);
         return NULL;
@@ -232 +232 @@
     if (mask == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psPixels_MASK_NULL);
+                _("Specified mask can not be NULL."));
         psFree(out);
         return NULL;
@@ -240 +240 @@
         PS_TYPE_NAME(typeStr,mask->type.type);
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psPixels_MASK_TYPE,
+                _("Specified mask's type, %s, is invalid.  Should be PS_TYPE_MASK."),
                 typeStr);
         psFree(out);
@@ -295 +295 @@
     if (pixels == NULL) {
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psPixels_NULL);
+                _("Input psPixels can not be NULL."));
         return NULL;
     }
@@ -363 +363 @@
 {
     if (pixels == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psPixels_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("Input psPixels can not be NULL."));
         return false;
     }
@@ -397 +397 @@
     psPixelCoord out;
     if (pixels == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true, PS_ERRORTEXT_psPixels_NULL);
+        psError(PS_ERR_BAD_PARAMETER_NULL, true, _("Input psPixels can not be NULL."));
         out.x = 0; //XXX: should be NAN when changed to float
         out.y = 0; //XXX: should be NAN when changed to float

trunk/psLib/src/xml/psXML.c

@@ -10 +10 @@
 *  @author David Robbins, MHPCC
 *
-*  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-06-30 02:20:06 $
+*  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-08-08 23:32:23 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -133 +133 @@
             else {
                 psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                        PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                        _("Failed to recognize XML content.  Invalid syntax."));
                 return NULL;
             }
@@ -188 +188 @@
             default:
                 psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                        PS_ERRORTEXT_psXML_INVALID_DATATYPE);
+                        _("Failed to recognize datatype from/for XML file."));
                 psFree(XML);
                 psFree(iter);
@@ -198 +198 @@
         default:
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psXML_INVALID_DATATYPE);
+                    _("Failed to recognize datatype from/for XML file."));
             psFree(XML);
             psFree(iter);
@@ -283 +283 @@
     default:
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psXML_INVALID_DATATYPE);
+                _("Failed to recognize datatype from/for XML file."));
     }
 }
@@ -299 +299 @@
     else
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                _("Failed to recognize XML content.  Invalid syntax."));
     in = endp;
     nsec = (unsigned int)strtol(in, &endp, 10);
@@ -307 +307 @@
     else
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                _("Failed to recognize XML content.  Invalid syntax."));
     in = endp;
     if ( !strncmp(in, "false", 10) || !strncmp(in, "f", 10) ||
@@ -317 +317 @@
     else {
         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                _("Failed to recognize XML content.  Invalid syntax."));
     }
 }
@@ -335 +335 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                    _("Failed to recognize XML content.  Invalid syntax."));
             return(PS_DATA_UNKNOWN);
         }
@@ -348 +348 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                    _("Failed to recognize XML content.  Invalid syntax."));
             return(PS_DATA_UNKNOWN);
         }
@@ -360 +360 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                    _("Failed to recognize XML content.  Invalid syntax."));
             return(PS_DATA_UNKNOWN);
         }
@@ -370 +370 @@
         } else {
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                    PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                    _("Failed to recognize XML content.  Invalid syntax."));
             return(PS_DATA_UNKNOWN);
         }
@@ -398 +398 @@
             if ( nodeNum == 0 && strncmp((const char*)cur_node->name, "metadata", MAXSTR) ) {
                 psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                        PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                        _("Failed to recognize XML content.  Invalid syntax."));
                 psFree(meta);
                 return NULL;
@@ -440 +440 @@
                             || elemType == PS_DATA_BOOL) {
                         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                                PS_ERRORTEXT_psXML_INVALID_DATATYPE);
+                                _("Failed to recognize datatype from/for XML file."));
                         psFree(meta);
                         return NULL;
@@ -467 +467 @@
                     else {
                         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                                PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                                _("Failed to recognize XML content.  Invalid syntax."));
                         psFree(meta);
                         return NULL;
@@ -501 +501 @@
                     } else {
                         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                                PS_ERRORTEXT_psXML_INVALID_CONTENT);
+                                _("Failed to recognize XML content.  Invalid syntax."));
                         psFree(meta);
                         return NULL;
@@ -509 +509 @@
                 default:
                     psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                            PS_ERRORTEXT_psXML_INVALID_DATATYPE);
+                            _("Failed to recognize datatype from/for XML file."));
                     psFree(meta);   //XXX: Do I really need this?
                     return NULL;
@@ -558 +558 @@
     FILE *file;
     if( (file = fopen(filename, "w")) == NULL ) {
-        psError(PS_ERR_IO, true, PS_ERRORTEXT_psXML_IO_FILE_OPEN_FAILED, filename);
+        psError(PS_ERR_IO, true, _("Failed to open file '%s'. Check if it exists and it has the proper permissions."), filename);
         return false;
     }
@@ -592 +592 @@
     xmlDocDumpMemory(*doc, &buff, &bufferSize);
     if ( MAXVEC < strlen((char *)buff) ) {
-        psError(PS_ERR_LOCATION_INVALID, true, PS_ERRORTEXT_psXML_BUFFER_TOO_SMALL);
+        psError(PS_ERR_LOCATION_INVALID, true, _("Buffer to small to store XML doc."));
         //        xmlFree(buff);
         return false;
@@ -628 +628 @@
         write(fd, buf, n);
     } else {
-        psError(PS_ERR_LOCATION_INVALID, true, PS_ERRORTEXT_psXML_BUFFER_TOO_SMALL);
+        psError(PS_ERR_LOCATION_INVALID, true, _("Buffer to small to store XML doc."));
         return false;
     }

trunk/psLib/src/xml/psXML.h

@@ -10 +10 @@
  *  @author David Robbins, MHPCC
  *
- *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-09-12 21:36:54 $
+ *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-08-08 23:32:23 $
  *
  *  Copyright 2005 Maui High Performance Computing Center, University of Hawaii
@@ -32 +32 @@
 #include "psConstants.h"
 #include "psTime.h"
-#include "psErrorText.h"
+
 
 

@@ -10 +10 @@
 libpslib.la.temp
 config.h.in
-psErrorText.h
 *.bb
 *.bbg