Revise error codes to have a reduced set exposed in the public API.

Fixes #2482

And also add proj_context_errno_string()

Revise gie 'expect failure errno XXXX' strings

4 files changed, 57 insertions, 30 deletions

diff --git a/src/conversions/axisswap.cpp b/src/conversions/axisswap.cpp
index 1aa339c3..c02bd4e5 100644
--- a/src/conversions/axisswap.cpp
+++ b/src/conversions/axisswap.cpp
@@ -174,13 +174,16 @@ PJ *CONVERSION(axisswap,0) {
     unsigned int i, j, n = 0;
 
     if (nullptr==Q)
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     P->opaque = (void *) Q;
 
 
     /* +order and +axis are mutually exclusive */
     if ( !pj_param_exists(P->params, "order") == !pj_param_exists(P->params, "axis") )
-        return pj_default_destructor(P, PJD_ERR_AXIS);
+    {
+        proj_log_error(P, _("order and axis parameters are mutually exclusive."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MUTUALLY_EXCLUSIVE_ARGS);
+    }
 
     /* fill axis list with indices from 4-7 to simplify duplicate search further down */
     for (i=0; i<4; i++) {
@@ -196,8 +199,8 @@ PJ *CONVERSION(axisswap,0) {
         /* check that all characters are valid */
         for (i=0; i<strlen(order); i++)
             if (strchr("1234-,", order[i]) == nullptr) {
-                proj_log_error(P, "axisswap: unknown axis '%c'", order[i]);
-                return pj_default_destructor(P, PJD_ERR_AXIS);
+                proj_log_error(P, _("axisswap: unknown axis '%c'"), order[i]);
+                return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
             }
 
         /* read axes numbers and signs */
@@ -206,8 +209,8 @@ PJ *CONVERSION(axisswap,0) {
         while ( *s != '\0' && n < 4 ) {
             Q->axis[n] = abs(atoi(s))-1;
             if (Q->axis[n] > 3) {
-                proj_log_error(P, "axisswap: invalid axis '%d'", Q->axis[n]);
-                return pj_default_destructor(P, PJD_ERR_AXIS);
+                proj_log_error(P, _("axisswap: invalid axis '%d'"), Q->axis[n]);
+                return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
             }
             Q->sign[n++] = sign(atoi(s));
             while ( *s != '\0' && *s != ',' )
@@ -247,8 +250,8 @@ PJ *CONVERSION(axisswap,0) {
                     Q->axis[i] = 2;
                     break;
                 default:
-                    proj_log_error(P, "axisswap: unknown axis '%c'", P->axis[i]);
-                    return pj_default_destructor(P, PJD_ERR_AXIS);
+                    proj_log_error(P, _("axisswap: unknown axis '%c'"), P->axis[i]);
+                    return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
             }
         }
         n = 3;
@@ -260,8 +263,8 @@ PJ *CONVERSION(axisswap,0) {
             if (i==j)
                 continue;
             if (Q->axis[i] == Q->axis[j]) {
-                proj_log_error(P, "swapaxis: duplicate axes specified");
-                return pj_default_destructor(P, PJD_ERR_AXIS);
+                proj_log_error(P, _("swapaxis: duplicate axes specified"));
+                return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
             }
         }
 
@@ -282,8 +285,8 @@ PJ *CONVERSION(axisswap,0) {
 
 
     if (P->fwd4d == nullptr && P->fwd3d == nullptr && P->fwd == nullptr) {
-        proj_log_error(P, "swapaxis: bad axis order");
-        return pj_default_destructor(P, PJD_ERR_AXIS);
+        proj_log_error(P, _("swapaxis: bad axis order"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
 
     if (pj_param(P->ctx, P->params, "tangularunits").i) {
diff --git a/src/conversions/set.cpp b/src/conversions/set.cpp
index 2f30bda8..3db6db10 100644
--- a/src/conversions/set.cpp
+++ b/src/conversions/set.cpp
@@ -42,7 +42,7 @@ PJ *OPERATION(set, 0) {
     auto set = static_cast<struct Set*>(calloc (1, sizeof(struct Set)));
     P->opaque = set;
     if (nullptr==P->opaque)
-        return pj_default_destructor(P, ENOMEM);
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     if (pj_param_exists(P->params, "v_1"))
     {
diff --git a/src/conversions/topocentric.cpp b/src/conversions/topocentric.cpp
index f6f328ad..4f563d9f 100644
--- a/src/conversions/topocentric.cpp
+++ b/src/conversions/topocentric.cpp
@@ -78,7 +78,7 @@ PJ *CONVERSION(topocentric,1) {
 /*********************************************************************/
     struct pj_opaque *Q = static_cast<struct pj_opaque*>(calloc (1, sizeof (struct pj_opaque)));
     if (nullptr==Q)
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     P->opaque = static_cast<void *>(Q);
 
     // The topocentric origin can be specified either in geocentric coordinates
@@ -97,26 +97,30 @@ PJ *CONVERSION(topocentric,1) {
     const auto hash0 = pj_param_exists(P->params, "h_0");
     if( !hasX0 && !hasLon0 )
     {
-        return pj_default_destructor(P, PJD_ERR_MISSING_ARGS);
+        proj_log_error(P, _("topocentric: missing X_0 or lon_0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
     }
     if ( (hasX0 || hasY0 || hasZ0) &&
          (hasLon0 || hasLat0 || hash0) )
     {
-        return pj_default_destructor(P, PJD_ERR_MUTUALLY_EXCLUSIVE_ARGS);
+        proj_log_error(P, _("topocentric: (X_0,Y_0,Z_0) and (lon_0,lat_0,h_0) are mutually exclusive"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MUTUALLY_EXCLUSIVE_ARGS);
     }
     if( hasX0 && (!hasY0 || !hasZ0) )
     {
-        return pj_default_destructor(P, PJD_ERR_MISSING_ARGS);
+        proj_log_error(P, _("topocentric: missing Y_0 and/or Z_0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
     }
     if( hasLon0 && !hasLat0 ) // allow missing h_0
     {
-        return pj_default_destructor(P, PJD_ERR_MISSING_ARGS);
+        proj_log_error(P, _("topocentric: missing lat_0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
     }
 
     // Pass a dummy ellipsoid definition that will be overridden just afterwards
     PJ* cart = proj_create(P->ctx, "+proj=cart +a=1");
     if (cart == nullptr)
-        return pj_default_destructor(P, ENOMEM);
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     /* inherit ellipsoid definition from P to cart */
     pj_inherit_ellipsoid_def (P, cart);
 
diff --git a/src/conversions/unitconvert.cpp b/src/conversions/unitconvert.cpp
index 61bccbf1..fec8caac 100644
--- a/src/conversions/unitconvert.cpp
+++ b/src/conversions/unitconvert.cpp
@@ -443,7 +443,7 @@ PJ *CONVERSION(unitconvert,0) {
     int z_out_is_linear = -1; /* unknown */
 
     if (nullptr==Q)
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     P->opaque = (void *) Q;
 
     P->fwd4d  = forward_4d;
@@ -473,7 +473,10 @@ PJ *CONVERSION(unitconvert,0) {
         } else {
             f = pj_param (P->ctx, P->params, "dxy_in").f;
             if (f == 0.0 || 1.0 / f == 0.0)
-                return pj_default_destructor(P, PJD_ERR_UNKNOWN_UNIT_ID);
+            {
+                proj_log_error(P, _("unitconvert: unknown xy_in unit"));
+                return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+            }
         }
         Q->xy_factor = f;
         if (normalized_name != nullptr) {
@@ -492,7 +495,10 @@ PJ *CONVERSION(unitconvert,0) {
         } else {
             f = pj_param (P->ctx, P->params, "dxy_out").f;
             if (f == 0.0 || 1.0 / f == 0.0)
-                return pj_default_destructor(P, PJD_ERR_UNKNOWN_UNIT_ID);
+            {
+                proj_log_error(P, _("unitconvert: unknown xy_out unit"));
+                return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+            }
         }
         Q->xy_factor /= f;
         if (normalized_name != nullptr) {
@@ -505,8 +511,8 @@ PJ *CONVERSION(unitconvert,0) {
 
     if( xy_in_is_linear >= 0 && xy_out_is_linear >= 0 &&
         xy_in_is_linear != xy_out_is_linear ) {
-        proj_log_debug(P, "inconsistent unit type between xy_in and xy_out");
-        return pj_default_destructor(P, PJD_ERR_INCONSISTENT_UNIT);
+        proj_log_error(P, _("unitconvert: inconsistent unit type between xy_in and xy_out"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
 
     if ((name = pj_param (P->ctx, P->params, "sz_in").s) != nullptr) {
@@ -517,7 +523,10 @@ PJ *CONVERSION(unitconvert,0) {
         } else {
             f = pj_param (P->ctx, P->params, "dz_in").f;
             if (f == 0.0 || 1.0 / f == 0.0)
-                return pj_default_destructor(P, PJD_ERR_UNKNOWN_UNIT_ID);
+            {
+                proj_log_error(P, _("unitconvert: unknown z_in unit"));
+                return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+            }
         }
         Q->z_factor = f;
     }
@@ -530,21 +539,28 @@ PJ *CONVERSION(unitconvert,0) {
         } else {
             f = pj_param (P->ctx, P->params, "dz_out").f;
             if (f == 0.0 || 1.0 / f == 0.0)
-                return pj_default_destructor(P, PJD_ERR_UNKNOWN_UNIT_ID);
+            {
+                proj_log_error(P, _("unitconvert: unknown z_out unit"));
+                return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+            }
         }
         Q->z_factor /= f;
     }
 
     if( z_in_is_linear >= 0 && z_out_is_linear >= 0 &&
         z_in_is_linear != z_out_is_linear ) {
-        proj_log_debug(P, "inconsistent unit type between z_in and z_out");
-        return pj_default_destructor(P, PJD_ERR_INCONSISTENT_UNIT);
+        proj_log_error(P, _("unitconvert: inconsistent unit type between z_in and z_out"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
 
     if ((name = pj_param (P->ctx, P->params, "st_in").s) != nullptr) {
         for (i = 0; (s = time_units[i].id) && strcmp(name, s) ; ++i);
 
-        if (!s) return pj_default_destructor(P, PJD_ERR_UNKNOWN_UNIT_ID); /* unknown unit conversion id */
+        if (!s)
+        {
+            proj_log_error(P, _("unitconvert: unknown t_in unit"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
 
         Q->t_in_id = i;
         proj_log_trace(P, "t_in unit: %s", time_units[i].name);
@@ -554,7 +570,11 @@ PJ *CONVERSION(unitconvert,0) {
     if ((name = pj_param (P->ctx, P->params, "st_out").s) != nullptr) {
         for (i = 0; (s = time_units[i].id) && strcmp(name, s) ; ++i);
 
-        if (!s) return pj_default_destructor(P, PJD_ERR_UNKNOWN_UNIT_ID); /* unknown unit conversion id */
+        if (!s)
+        {
+            proj_log_error(P, _("unitconvert: unknown t_out unit"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
 
         Q->t_out_id = i;
         proj_log_trace(P, "t_out unit: %s", time_units[i].name);