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

85 files changed, 599 insertions, 361 deletions

diff --git a/src/projections/adams.cpp b/src/projections/adams.cpp
index d1217ff1..44e98a2c 100644
--- a/src/projections/adams.cpp
+++ b/src/projections/adams.cpp
@@ -99,7 +99,7 @@ static PJ_XY adams_forward(PJ_LP lp, PJ *P) {
     switch (Q->mode) {
     case GUYOU:
         if ((fabs(lp.lam) - TOL) > M_PI_2) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return proj_coord_error().xy;
         }
 
@@ -119,7 +119,7 @@ static PJ_XY adams_forward(PJ_LP lp, PJ *P) {
         break;
     case PEIRCE_Q: {
             if( lp.phi < -TOL ) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return proj_coord_error().xy;
             }
             const double sl = sin(lp.lam);
@@ -134,7 +134,7 @@ static PJ_XY adams_forward(PJ_LP lp, PJ *P) {
     case ADAMS_HEMI: {
             const double sp = sin(lp.phi);
             if ((fabs(lp.lam) - TOL) > M_PI_2) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return proj_coord_error().xy;
             }
             a = cos(lp.phi) * sin(lp.lam);
@@ -208,7 +208,7 @@ static PJ *setup(PJ *P, projection_type mode) {
             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 = Q;
 
     P->es = 0;
diff --git a/src/projections/aea.cpp b/src/projections/aea.cpp
index af0f292d..c5b03158 100644
--- a/src/projections/aea.cpp
+++ b/src/projections/aea.cpp
@@ -107,7 +107,7 @@ static PJ_XY aea_e_forward (PJ_LP lp, PJ *P) {   /* Ellipsoid/spheroid, forward
     struct pj_opaque *Q = static_cast<struct pj_opaque*>(P->opaque);
     Q->rho = Q->c - (Q->ellips ? Q->n * pj_qsfn(sin(lp.phi), P->e, P->one_es) : Q->n2 * sin(lp.phi));;
     if (Q->rho < 0.) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     Q->rho = Q->dd * sqrt(Q->rho);
@@ -134,12 +134,12 @@ static PJ_LP aea_e_inverse (PJ_XY xy, PJ *P) {   /* Ellipsoid/spheroid, inverse
             lp.phi = (Q->c - lp.phi * lp.phi) / Q->n;
             if (fabs(Q->ec - fabs(lp.phi)) > TOL7) {
                 if (fabs(lp.phi) > 2 ) {
-                    proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                    proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                     return lp;
                 }
                 lp.phi = phi1_(lp.phi, P->e, P->one_es);
                 if (lp.phi == HUGE_VAL) {
-                    proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                    proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                     return lp;
                 }
             } else
@@ -167,10 +167,21 @@ static PJ *setup(PJ *P) {
     P->inv = aea_e_inverse;
     P->fwd = aea_e_forward;
 
-    if (fabs(Q->phi1) > M_HALFPI || fabs(Q->phi2) > M_HALFPI)
-        return destructor(P, PJD_ERR_LAT_LARGER_THAN_90);
+    if (fabs(Q->phi1) > M_HALFPI)
+    {
+        proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be <= 90°"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
+    if (fabs(Q->phi2) > M_HALFPI)
+    {
+        proj_log_error(P, _("Invalid value for lat_2: |lat_2| should be <= 90°"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     if (fabs(Q->phi1 + Q->phi2) < EPS10)
-        return destructor(P, PJD_ERR_CONIC_LAT_EQUAL);
+    {
+        proj_log_error(P, _("Invalid value for lat_1 and lat_2: |lat_1 + lat_2| should be > 0"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     double sinphi = sin(Q->phi1);
     Q->n = sinphi;
     double cosphi = cos(Q->phi1);
@@ -197,7 +208,8 @@ static PJ *setup(PJ *P) {
             Q->n = (m1 * m1 - m2 * m2) / (ml2 - ml1);
             if (Q->n == 0) {
                 // Not quite, but es is very close to 1...
-                return destructor(P, PJD_ERR_INVALID_ECCENTRICITY);
+                proj_log_error(P, _("Invalid value for eccentricity"));
+                return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
             }
         }
         Q->ec = 1. - .5 * P->one_es * log((1. - P->e) /
@@ -221,7 +233,7 @@ static PJ *setup(PJ *P) {
 PJ *PROJECTION(aea) {
     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 = Q;
     P->destructor = destructor;
 
@@ -234,7 +246,7 @@ PJ *PROJECTION(aea) {
 PJ *PROJECTION(leac) {
     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 = Q;
     P->destructor = destructor;
 
diff --git a/src/projections/aeqd.cpp b/src/projections/aeqd.cpp
index d5d90b62..2a42f379 100644
--- a/src/projections/aeqd.cpp
+++ b/src/projections/aeqd.cpp
@@ -149,7 +149,7 @@ static PJ_XY aeqd_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
 oblcon:
         if (fabs(fabs(xy.y) - 1.) < TOL)
             if (xy.y < 0.) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return xy;
             }
             else
@@ -168,7 +168,7 @@ oblcon:
         /*-fallthrough*/
     case S_POLE:
         if (fabs(lp.phi - M_HALFPI) < EPS10) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         xy.y = (M_HALFPI + lp.phi);
@@ -239,7 +239,7 @@ static PJ_LP aeqd_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
     c_rh = hypot(xy.x, xy.y);
     if (c_rh > M_PI) {
         if (c_rh - EPS10 > M_PI) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         }
         c_rh = M_PI;
@@ -276,7 +276,7 @@ static PJ_LP aeqd_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
 PJ *PROJECTION(aeqd) {
     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 = Q;
     P->destructor = destructor;
 
diff --git a/src/projections/airy.cpp b/src/projections/airy.cpp
index 15ff60d8..d162aba6 100644
--- a/src/projections/airy.cpp
+++ b/src/projections/airy.cpp
@@ -74,14 +74,14 @@ static PJ_XY airy_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
         if (Q->mode == OBLIQ)
             cosz = Q->sinph0 * sinphi + Q->cosph0 * cosz;
         if (!Q->no_cut && cosz < -EPS) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         s = 1. - cosz;
         if (fabs(s) > EPS) {
             t = 0.5 * (1. + cosz);
             if(t == 0) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return xy;
             }
             Krho = -log(t)/s - Q->Cb / t;
@@ -97,7 +97,7 @@ static PJ_XY airy_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
     case N_POLE:
         lp.phi = fabs(Q->p_halfpi - lp.phi);
         if (!Q->no_cut && (lp.phi - EPS) > M_HALFPI) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         lp.phi *= 0.5;
@@ -122,7 +122,7 @@ PJ *PROJECTION(airy) {
 
     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 = Q;
 
diff --git a/src/projections/aitoff.cpp b/src/projections/aitoff.cpp
index 857ebb80..1051c711 100644
--- a/src/projections/aitoff.cpp
+++ b/src/projections/aitoff.cpp
@@ -123,7 +123,7 @@ static PJ_LP aitoff_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
             C = 1. - D * D;
             const double denom = pow(C, 1.5);
             if( denom == 0 ) {
-                proj_errno_set(P, PJD_ERR_NON_CONVERGENT);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return lp;
             }
             D = acos(D) / denom;
@@ -170,7 +170,7 @@ static PJ_LP aitoff_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
 
     if (iter == MAXITER && round == MAXROUND)
     {
-        proj_context_errno_set( P->ctx, PJD_ERR_NON_CONVERGENT );
+        proj_context_errno_set( P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN );
         /* fprintf(stderr, "Warning: Accuracy of 1e-12 not reached. Last increments: dlat=%e and dlon=%e\n", dp, dl); */
     }
 
@@ -189,7 +189,7 @@ static PJ *setup(PJ *P) {
 PJ *PROJECTION(aitoff) {
     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 = Q;
 
     Q->mode = AITOFF;
@@ -200,13 +200,16 @@ PJ *PROJECTION(aitoff) {
 PJ *PROJECTION(wintri) {
     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 = Q;
 
     Q->mode = WINKEL_TRIPEL;
     if (pj_param(P->ctx, P->params, "tlat_1").i) {
         if ((Q->cosphi1 = cos(pj_param(P->ctx, P->params, "rlat_1").f)) == 0.)
-            return pj_default_destructor (P, PJD_ERR_LAT_LARGER_THAN_90);
+        {
+            proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be < 90°"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
     }
     else /* 50d28' or acos(2/pi) */
         Q->cosphi1 = 0.636619772367581343;
diff --git a/src/projections/bacon.cpp b/src/projections/bacon.cpp
index 7ff2a7ac..c236e943 100644
--- a/src/projections/bacon.cpp
+++ b/src/projections/bacon.cpp
@@ -45,7 +45,7 @@ static PJ_XY bacon_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwar
 PJ *PROJECTION(bacon) {
     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 = Q;
 
 	Q->bacn = 1;
@@ -59,7 +59,7 @@ PJ *PROJECTION(bacon) {
 PJ *PROJECTION(apian) {
     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 = Q;
 
 	Q->bacn = Q->ortl = 0;
@@ -72,7 +72,7 @@ PJ *PROJECTION(apian) {
 PJ *PROJECTION(ortel) {
     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 = Q;
 
 	Q->bacn = 0;
diff --git a/src/projections/bertin1953.cpp b/src/projections/bertin1953.cpp
index 58509e16..db7aa7c8 100644
--- a/src/projections/bertin1953.cpp
+++ b/src/projections/bertin1953.cpp
@@ -77,7 +77,7 @@ static PJ_XY bertin1953_s_forward (PJ_LP lp, PJ *P) {
 PJ *PROJECTION(bertin1953) {
     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 = Q;
 
     P->lam0 = 0;
diff --git a/src/projections/bipc.cpp b/src/projections/bipc.cpp
index 743acd1c..e89e189a 100644
--- a/src/projections/bipc.cpp
+++ b/src/projections/bipc.cpp
@@ -60,7 +60,7 @@ static PJ_XY bipc_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
         z = S20 * sphi + C20 * cphi * cdlam;
         if (fabs(z) > 1.) {
             if (fabs(z) > ONEEPS) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return xy;
             }
             else z = z < 0. ? -1. : 1.;
@@ -74,7 +74,7 @@ static PJ_XY bipc_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
         z = S45 * (sphi + cphi * cdlam);
         if (fabs(z) > 1.) {
             if (fabs(z) > ONEEPS) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return xy;
             }
             else z = z < 0. ? -1. : 1.;
@@ -84,19 +84,19 @@ static PJ_XY bipc_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
         xy.y = -rhoc;
     }
     if (z < 0.) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     t = pow(tan(.5 * z), n);
     r = F * t;
     if ((al = .5 * (R104 - z)) < 0.) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     al = (t + pow(al, n)) / T;
     if (fabs(al) > 1.) {
         if (fabs(al) > ONEEPS) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         else al = al < 0. ? -1. : 1.;
@@ -153,7 +153,7 @@ static PJ_LP bipc_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
         rl = r;
     }
     if (! i) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     Az = Av - Az / n;
@@ -170,7 +170,7 @@ static PJ_LP bipc_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
 PJ *PROJECTION(bipc) {
     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 = Q;
 
     Q->noskew = pj_param(P->ctx, P->params, "bns").i;
diff --git a/src/projections/bonne.cpp b/src/projections/bonne.cpp
index 7817e968..1728a477 100644
--- a/src/projections/bonne.cpp
+++ b/src/projections/bonne.cpp
@@ -65,7 +65,7 @@ static PJ_LP bonne_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
     rh = hypot(xy.x, xy.y);
     lp.phi = Q->cphi1 + Q->phi1 - rh;
     if (fabs(lp.phi) > M_HALFPI) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     if (fabs(fabs(lp.phi) - M_HALFPI) <= EPS10)
@@ -91,7 +91,7 @@ static PJ_LP bonne_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, invers
     } else if (fabs(s - M_HALFPI) <= EPS10)
         lp.lam = 0.;
     else {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     return lp;
@@ -115,18 +115,21 @@ PJ *PROJECTION(bonne) {
     double c;
     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 = Q;
     P->destructor = destructor;
 
     Q->phi1 = pj_param(P->ctx, P->params, "rlat_1").f;
     if (fabs(Q->phi1) < EPS10)
-        return destructor (P, PJD_ERR_LAT1_IS_ZERO);
+    {
+        proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be > 0"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     if (P->es != 0.0) {
         Q->en = pj_enfn(P->es);
         if (nullptr==Q->en)
-            return destructor(P, ENOMEM);
+            return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
         Q->am1 = sin(Q->phi1);
         c = cos(Q->phi1);
         Q->m1 = pj_mlfn(Q->phi1, Q->am1, c, Q->en);
diff --git a/src/projections/calcofi.cpp b/src/projections/calcofi.cpp
index d1e96de8..b9528ab9 100644
--- a/src/projections/calcofi.cpp
+++ b/src/projections/calcofi.cpp
@@ -44,7 +44,7 @@ static PJ_XY calcofi_e_forward (PJ_LP lp, PJ *P) {          /* Ellipsoidal, forw
                line as xy xy, r, o form a right triangle */
 
     if (fabs(fabs(lp.phi) - M_HALFPI) <= EPS10) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
 
@@ -73,7 +73,7 @@ static PJ_XY calcofi_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forw
     double l2;
     double ry;
     if (fabs(fabs(lp.phi) - M_HALFPI) <= EPS10) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     xy.x = lp.lam;
diff --git a/src/projections/cass.cpp b/src/projections/cass.cpp
index f5531f6a..9902f9d7 100644
--- a/src/projections/cass.cpp
+++ b/src/projections/cass.cpp
@@ -113,12 +113,12 @@ PJ *PROJECTION(cass) {
     /* otherwise it's ellipsoidal */
     P->opaque = static_cast<struct pj_opaque*>(calloc (1, sizeof (struct pj_opaque)));
     if (nullptr==P->opaque)
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     P->destructor = destructor;
 
     static_cast<struct pj_opaque*>(P->opaque)->en = pj_enfn (P->es);
     if (nullptr==static_cast<struct pj_opaque*>(P->opaque)->en)
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     static_cast<struct pj_opaque*>(P->opaque)->m0 = pj_mlfn (P->phi0,  sin (P->phi0),  cos (P->phi0),  static_cast<struct pj_opaque*>(P->opaque)->en);
     P->inv = cass_e_inverse;
diff --git a/src/projections/cc.cpp b/src/projections/cc.cpp
index 244e185d..f15a95bd 100644
--- a/src/projections/cc.cpp
+++ b/src/projections/cc.cpp
@@ -12,7 +12,7 @@ PROJ_HEAD(cc, "Central Cylindrical") "\n\tCyl, Sph";
 static PJ_XY cc_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward */
     PJ_XY xy = {0.0,0.0};
     if (fabs (fabs(lp.phi) - M_HALFPI) <= EPS10) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     xy.x = lp.lam;
diff --git a/src/projections/ccon.cpp b/src/projections/ccon.cpp
index 7b3b7105..5f58d536 100644
--- a/src/projections/ccon.cpp
+++ b/src/projections/ccon.cpp
@@ -84,16 +84,18 @@ PJ *PROJECTION(ccon) {
 
     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 = Q;
     P->destructor = destructor;
 
     Q->phi1 = pj_param(P->ctx, P->params, "rlat_1").f;
     if (fabs(Q->phi1) < EPS10)
-        return destructor (P, PJD_ERR_LAT1_IS_ZERO);
-
+    {
+        proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be > 0"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     if (!(Q->en = pj_enfn(P->es)))
-        return destructor(P, ENOMEM);
+        return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     Q->sinphi1 = sin(Q->phi1);
     Q->cosphi1 = cos(Q->phi1);
diff --git a/src/projections/cea.cpp b/src/projections/cea.cpp
index b7874b90..0d850b49 100644
--- a/src/projections/cea.cpp
+++ b/src/projections/cea.cpp
@@ -53,7 +53,7 @@ static PJ_LP cea_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
             lp.phi = asin(xy.y);
         lp.lam = xy.x / P->k0;
     } else {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     return (lp);
@@ -75,15 +75,19 @@ PJ *PROJECTION(cea) {
     double t = 0.0;
     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 = Q;
     P->destructor = destructor;
 
 
     if (pj_param(P->ctx, P->params, "tlat_ts").i) {
-        P->k0 = cos(t = pj_param(P->ctx, P->params, "rlat_ts").f);
+        t = pj_param(P->ctx, P->params, "rlat_ts").f;
+        P->k0 = cos(t);
         if (P->k0 < 0.)
-            return pj_default_destructor (P, PJD_ERR_LAT_TS_LARGER_THAN_90);
+        {
+            proj_log_error(P, _("Invalid value for lat_ts: |lat_ts| should be <= 90°"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
     }
     if (P->es != 0.0) {
         t = sin(t);
@@ -91,7 +95,7 @@ PJ *PROJECTION(cea) {
         P->e = sqrt(P->es);
         Q->apa = pj_authset(P->es);
         if (!(Q->apa))
-            return pj_default_destructor(P, ENOMEM);
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
         Q->qp = pj_qsfn(1., P->e, P->one_es);
         P->inv = cea_e_inverse;
diff --git a/src/projections/chamb.cpp b/src/projections/chamb.cpp
index b315832a..ca5d6d82 100644
--- a/src/projections/chamb.cpp
+++ b/src/projections/chamb.cpp
@@ -105,7 +105,7 @@ PJ *PROJECTION(chamb) {
     char line[10];
     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 = Q;
 
 
@@ -123,7 +123,10 @@ PJ *PROJECTION(chamb) {
         Q->c[i].v = vect(P->ctx,Q->c[j].phi - Q->c[i].phi, Q->c[i].cosphi, Q->c[i].sinphi,
             Q->c[j].cosphi, Q->c[j].sinphi, Q->c[j].lam - Q->c[i].lam);
         if (Q->c[i].v.r == 0.0)
-            return pj_default_destructor (P, PJD_ERR_CONTROL_POINT_NO_DIST);
+        {
+            proj_log_error(P, _("Invalid value for control points: they should be distinct"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
         /* co-linearity problem ignored for now */
     }
     Q->beta_0 = lc(P->ctx,Q->c[0].v.r, Q->c[2].v.r, Q->c[1].v.r);
diff --git a/src/projections/col_urban.cpp b/src/projections/col_urban.cpp
index de0c178f..6d8157b6 100644
--- a/src/projections/col_urban.cpp
+++ b/src/projections/col_urban.cpp
@@ -56,7 +56,7 @@ static PJ_LP col_urban_inverse (PJ_XY xy, PJ *P) {
 PJ *PROJECTION(col_urban) {
     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 = Q;
 
     const double h0_unscaled = pj_param(P->ctx, P->params, "dh_0").f;
diff --git a/src/projections/collg.cpp b/src/projections/collg.cpp
index 1b9d2da7..958dfddb 100644
--- a/src/projections/collg.cpp
+++ b/src/projections/collg.cpp
@@ -32,7 +32,7 @@ static PJ_LP collg_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
     if (fabs(lp.phi) < 1.)
         lp.phi = asin(lp.phi);
     else if (fabs(lp.phi) > ONEEPS) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     } else {
         lp.phi = lp.phi < 0. ? -M_HALFPI : M_HALFPI;
diff --git a/src/projections/comill.cpp b/src/projections/comill.cpp
index 44524990..910d8aa7 100644
--- a/src/projections/comill.cpp
+++ b/src/projections/comill.cpp
@@ -66,7 +66,7 @@ static PJ_LP comill_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
         }
     }
     if( i == 0 )
-        proj_context_errno_set( P->ctx, PJD_ERR_NON_CONVERGENT );
+        proj_context_errno_set( P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN );
     lp.phi = yc;
 
     /* longitude */
diff --git a/src/projections/eck2.cpp b/src/projections/eck2.cpp
index 0d9fd5fa..891ad30e 100644
--- a/src/projections/eck2.cpp
+++ b/src/projections/eck2.cpp
@@ -34,7 +34,7 @@ static PJ_LP eck2_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
     lp.phi = (4. - lp.phi * lp.phi) * C13;
     if (fabs(lp.phi) >= 1.) {
         if (fabs(lp.phi) > ONEEPS) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         } else {
             lp.phi = lp.phi < 0. ? -M_HALFPI : M_HALFPI;
diff --git a/src/projections/eck3.cpp b/src/projections/eck3.cpp
index 2563053f..cd0ccdf9 100644
--- a/src/projections/eck3.cpp
+++ b/src/projections/eck3.cpp
@@ -54,7 +54,7 @@ static PJ *setup(PJ *P) {
 PJ *PROJECTION(eck3) {
     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 = Q;
 
     Q->C_x = 0.42223820031577120149;
@@ -69,7 +69,7 @@ PJ *PROJECTION(eck3) {
 PJ *PROJECTION(kav7) {
     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 = Q;
 
     /* Defined twice in original code - Using 0.866...,
@@ -87,7 +87,7 @@ PJ *PROJECTION(kav7) {
 PJ *PROJECTION(wag6) {
     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 = Q;
 
     Q->C_x = 0.94745;
@@ -102,7 +102,7 @@ PJ *PROJECTION(wag6) {
 PJ *PROJECTION(putp1) {
     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 = Q;
 
     Q->C_x = 1.89490;
diff --git a/src/projections/eqc.cpp b/src/projections/eqc.cpp
index 9ebc9286..fd385bb2 100644
--- a/src/projections/eqc.cpp
+++ b/src/projections/eqc.cpp
@@ -41,11 +41,14 @@ static PJ_LP eqc_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
 PJ *PROJECTION(eqc) {
     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 = Q;
 
     if ((Q->rc = cos(pj_param(P->ctx, P->params, "rlat_ts").f)) <= 0.)
-        return pj_default_destructor (P, PJD_ERR_LAT_TS_LARGER_THAN_90);
+    {
+        proj_log_error(P, _("Invalid value for lat_ts: |lat_ts| should be <= 90°"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     P->inv = eqc_s_inverse;
     P->fwd = eqc_s_forward;
     P->es = 0.;
diff --git a/src/projections/eqdc.cpp b/src/projections/eqdc.cpp
index 28767d74..4f49c136 100644
--- a/src/projections/eqdc.cpp
+++ b/src/projections/eqdc.cpp
@@ -79,20 +79,32 @@ PJ *PROJECTION(eqdc) {
 
     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 = Q;
     P->destructor = destructor;
 
     Q->phi1 = pj_param(P->ctx, P->params, "rlat_1").f;
     Q->phi2 = pj_param(P->ctx, P->params, "rlat_2").f;
-    if (fabs(Q->phi1) > M_HALFPI || fabs(Q->phi2) > M_HALFPI)
-        return destructor(P, PJD_ERR_LAT_LARGER_THAN_90);
 
+    if (fabs(Q->phi1) > M_HALFPI)
+    {
+        proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be <= 90°"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
+
+    if (fabs(Q->phi2) > M_HALFPI)
+    {
+        proj_log_error(P, _("Invalid value for lat_2: |lat_2| should be <= 90°"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     if (fabs(Q->phi1 + Q->phi2) < EPS10)
-        return destructor (P, PJD_ERR_CONIC_LAT_EQUAL);
+    {
+        proj_log_error(P, _("Invalid value for lat_1 and lat_2: |lat_1 + lat_2| should be > 0"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     if (!(Q->en = pj_enfn(P->es)))
-        return destructor(P, ENOMEM);
+        return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     sinphi = sin(Q->phi1);
     Q->n = sinphi;
@@ -111,7 +123,8 @@ PJ *PROJECTION(eqdc) {
                 (pj_mlfn(Q->phi2, sinphi, cosphi, Q->en) - ml1);
             if (Q->n == 0) {
                 // Not quite, but es is very close to 1...
-                return destructor(P, PJD_ERR_INVALID_ECCENTRICITY);
+                proj_log_error(P, _("Invalid value for eccentricity"));
+                return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
             }
         }
         Q->c = ml1 + m1 / Q->n;
@@ -121,7 +134,10 @@ PJ *PROJECTION(eqdc) {
         if (secant)
             Q->n = (cosphi - cos(Q->phi2)) / (Q->phi2 - Q->phi1);
         if (Q->n == 0)
-            return destructor (P, PJD_ERR_CONIC_LAT_EQUAL);
+        {
+            proj_log_error(P, _("Invalid value for lat_1 and lat_2: lat_1 + lat_2 should be > 0"));
+            return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
         Q->c = Q->phi1 + cos(Q->phi1) / Q->n;
         Q->rho0 = Q->c - P->phi0;
     }
diff --git a/src/projections/eqearth.cpp b/src/projections/eqearth.cpp
index 2ef2775b..9600e039 100644
--- a/src/projections/eqearth.cpp
+++ b/src/projections/eqearth.cpp
@@ -110,7 +110,7 @@ static PJ_LP eqearth_e_inverse (PJ_XY xy, PJ *P) {           /* Ellipsoidal/sphe
     }
 
     if( i == 0 ) {
-        proj_context_errno_set( P->ctx, PJD_ERR_NON_CONVERGENT );
+        proj_context_errno_set( P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN );
         return lp;
     }
 
@@ -145,7 +145,7 @@ static PJ *destructor (PJ *P, int errlev) { /* Destructor */
 PJ *PROJECTION(eqearth) {
     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 = Q;
     P->destructor = destructor;
     P->fwd = eqearth_e_forward;
@@ -156,7 +156,7 @@ PJ *PROJECTION(eqearth) {
     if (P->es != 0.0) {
        Q->apa = pj_authset(P->es); /* For auth_lat(). */
        if (nullptr == Q->apa)
-          return destructor(P, ENOMEM);
+          return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
        Q->qp = pj_qsfn(1.0, P->e, P->one_es); /* For auth_lat(). */
        Q->rqda = sqrt(0.5*Q->qp); /* Authalic radius divided by major axis */
     }
diff --git a/src/projections/fouc_s.cpp b/src/projections/fouc_s.cpp
index f7607635..5a560d97 100644
--- a/src/projections/fouc_s.cpp
+++ b/src/projections/fouc_s.cpp
@@ -57,12 +57,15 @@ static PJ_LP fouc_s_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
 PJ *PROJECTION(fouc_s) {
     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 = Q;
 
     Q->n = pj_param(P->ctx, P->params, "dn").f;
     if (Q->n < 0. || Q->n > 1.)
-        return pj_default_destructor (P, PJD_ERR_N_OUT_OF_RANGE);
+    {
+        proj_log_error(P, _("Invalid value for n: it should be in [0,1] range."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     Q->n1 = 1. - Q->n;
     P->es = 0;
diff --git a/src/projections/geos.cpp b/src/projections/geos.cpp
index 5de4c7ca..8d05dd24 100644
--- a/src/projections/geos.cpp
+++ b/src/projections/geos.cpp
@@ -99,7 +99,7 @@ static PJ_XY geos_e_forward (PJ_LP lp, PJ *P) {          /* Ellipsoidal, forward
 
     /* Check visibility. */
     if (((Q->radius_g - Vx) * Vx - Vy * Vy - Vz * Vz * Q->radius_p_inv2) < 0.) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
 
@@ -138,7 +138,7 @@ static PJ_LP geos_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
     b = 2 * Q->radius_g * Vx;
     const double det = (b * b) - 4 * a * Q->C;
     if (det < 0.) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
 
@@ -178,7 +178,7 @@ static PJ_LP geos_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inverse
     b   = 2 * Q->radius_g * Vx;
     const double det = (b * b) - 4 * a * Q->C;
     if (det < 0.) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
 
@@ -201,7 +201,7 @@ PJ *PROJECTION(geos) {
     char *sweep_axis;
     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 = Q;
 
     Q->h = pj_param(P->ctx, P->params, "dh").f;
@@ -212,7 +212,10 @@ PJ *PROJECTION(geos) {
     else {
         if ((sweep_axis[0] != 'x' && sweep_axis[0] != 'y') ||
             sweep_axis[1] != '\0')
-            return pj_default_destructor (P, PJD_ERR_INVALID_SWEEP_AXIS);
+        {
+            proj_log_error(P, _("Invalid value for sweep: it should be equal to x or y."));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
 
         if (sweep_axis[0] == 'x')
           Q->flip_axis = 1;
@@ -222,7 +225,10 @@ PJ *PROJECTION(geos) {
 
     Q->radius_g_1 = Q->h / P->a;
     if ( Q->radius_g_1 <= 0 || Q->radius_g_1 > 1e10 )
-        return pj_default_destructor (P, PJD_ERR_INVALID_H);
+    {
+        proj_log_error(P, _("Invalid value for h."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     Q->radius_g = 1. + Q->radius_g_1;
     Q->C  = Q->radius_g * Q->radius_g - 1.0;
     if (P->es != 0.0) {
diff --git a/src/projections/gn_sinu.cpp b/src/projections/gn_sinu.cpp
index ef312613..5d3f9491 100644
--- a/src/projections/gn_sinu.cpp
+++ b/src/projections/gn_sinu.cpp
@@ -46,7 +46,7 @@ static PJ_LP gn_sinu_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inve
     } else if ((s - EPS10) < M_HALFPI) {
         lp.lam = 0.;
     } else {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
     }
 
     return lp;
@@ -71,7 +71,7 @@ static PJ_XY gn_sinu_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forw
                 break;
         }
         if (!i) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
 
@@ -123,12 +123,12 @@ static void setup(PJ *P) {
 PJ *PROJECTION(sinu) {
     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 = Q;
     P->destructor = destructor;
 
     if (!(Q->en = pj_enfn(P->es)))
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     if (P->es != 0.0) {
         P->inv = gn_sinu_e_inverse;
@@ -145,7 +145,7 @@ PJ *PROJECTION(sinu) {
 PJ *PROJECTION(eck6) {
     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 = Q;
     P->destructor = destructor;
 
@@ -160,7 +160,7 @@ PJ *PROJECTION(eck6) {
 PJ *PROJECTION(mbtfps) {
     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 = Q;
     P->destructor = destructor;
 
@@ -175,17 +175,33 @@ PJ *PROJECTION(mbtfps) {
 PJ *PROJECTION(gn_sinu) {
     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 = Q;
     P->destructor = destructor;
 
-    if (pj_param(P->ctx, P->params, "tn").i && pj_param(P->ctx, P->params, "tm").i) {
-        Q->n = pj_param(P->ctx, P->params, "dn").f;
-        Q->m = pj_param(P->ctx, P->params, "dm").f;
-        if (Q->n <= 0 || Q->m < 0)
-            return destructor (P, PJD_ERR_INVALID_M_OR_N);
-    } else
-        return destructor (P, PJD_ERR_INVALID_M_OR_N);
+    if (!pj_param(P->ctx, P->params, "tn").i )
+    {
+        proj_log_error(P, _("Missing parameter n."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
+    }
+    if (!pj_param(P->ctx, P->params, "tm").i )
+    {
+        proj_log_error(P, _("Missing parameter m."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
+    }
+
+    Q->n = pj_param(P->ctx, P->params, "dn").f;
+    Q->m = pj_param(P->ctx, P->params, "dm").f;
+    if (Q->n <= 0)
+    {
+        proj_log_error(P, _("Invalid value for n: it should be > 0."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
+    if (Q->m < 0)
+    {
+        proj_log_error(P, _("Invalid value for m: it should be >= 0."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     setup(P);
 
diff --git a/src/projections/gnom.cpp b/src/projections/gnom.cpp
index 9abbb7ce..0d53cfab 100644
--- a/src/projections/gnom.cpp
+++ b/src/projections/gnom.cpp
@@ -54,7 +54,7 @@ static PJ_XY gnom_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
     }
 
     if (xy.y <= EPS10) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
 
@@ -126,7 +126,7 @@ static PJ_LP gnom_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
 PJ *PROJECTION(gnom) {
     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 = Q;
 
     if (fabs(fabs(P->phi0) - M_HALFPI) < EPS10) {
diff --git a/src/projections/goode.cpp b/src/projections/goode.cpp
index c0afd2d8..1107d203 100644
--- a/src/projections/goode.cpp
+++ b/src/projections/goode.cpp
@@ -64,7 +64,7 @@ static PJ *destructor (PJ *P, int errlev) {              /* Destructor */
 PJ *PROJECTION(goode) {
     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 = Q;
     P->destructor = destructor;
 
@@ -72,14 +72,14 @@ PJ *PROJECTION(goode) {
     Q->sinu = pj_sinu(nullptr);
     Q->moll = pj_moll(nullptr);
     if (Q->sinu == nullptr || Q->moll == nullptr)
-        return destructor (P, ENOMEM);
+        return destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     Q->sinu->es = 0.;
     Q->sinu->ctx = P->ctx;
     Q->moll->ctx = P->ctx;
     Q->sinu = pj_sinu(Q->sinu);
     Q->moll = pj_moll(Q->moll);
     if (Q->sinu == nullptr || Q->moll == nullptr)
-        return destructor (P, ENOMEM);
+        return destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     P->fwd = goode_s_forward;
     P->inv = goode_s_inverse;
diff --git a/src/projections/gstmerc.cpp b/src/projections/gstmerc.cpp
index b21f6ffd..8957d05d 100644
--- a/src/projections/gstmerc.cpp
+++ b/src/projections/gstmerc.cpp
@@ -56,7 +56,7 @@ static PJ_LP gstmerc_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inve
 PJ *PROJECTION(gstmerc) {
     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 = Q;
 
     Q->lamc = P->lam0;
diff --git a/src/projections/hammer.cpp b/src/projections/hammer.cpp
index d9bcafc7..5a183082 100644
--- a/src/projections/hammer.cpp
+++ b/src/projections/hammer.cpp
@@ -28,7 +28,7 @@ static PJ_XY hammer_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwa
     lp.lam *= Q->w;
     double denom = 1. + cosphi * cos(lp.lam);
     if( denom == 0.0 ) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return proj_coord_error().xy;
     }
     d = sqrt(2./denom);
@@ -47,7 +47,7 @@ static PJ_LP hammer_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
     if (fabs(2.*z*z-1.) < EPS) {
         lp.lam = HUGE_VAL;
         lp.phi = HUGE_VAL;
-        proj_errno_set(P, PJD_ERR_LAT_OR_LON_EXCEED_LIMIT);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
     } else {
         lp.lam = aatan2(Q->w * xy.x * z,2. * z * z - 1)/Q->w;
         lp.phi = aasin(P->ctx,z * xy.y);
@@ -59,19 +59,25 @@ static PJ_LP hammer_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
 PJ *PROJECTION(hammer) {
     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 = Q;
 
     if (pj_param(P->ctx, P->params, "tW").i) {
         Q->w = fabs(pj_param(P->ctx, P->params, "dW").f);
         if (Q->w <= 0.)
-            return pj_default_destructor (P, PJD_ERR_W_OR_M_ZERO_OR_LESS);
+        {
+            proj_log_error(P, _("Invalid value for W: it should be > 0"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
     } else
         Q->w = .5;
     if (pj_param(P->ctx, P->params, "tM").i) {
         Q->m = fabs(pj_param(P->ctx, P->params, "dM").f);
         if (Q->m <= 0.)
-            return pj_default_destructor (P, PJD_ERR_W_OR_M_ZERO_OR_LESS);
+        {
+            proj_log_error(P, _("Invalid value for M: it should be > 0"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
     } else
         Q->m = 1.;
 
diff --git a/src/projections/hatano.cpp b/src/projections/hatano.cpp
index c10c4e35..4897435f 100644
--- a/src/projections/hatano.cpp
+++ b/src/projections/hatano.cpp
@@ -47,7 +47,7 @@ static PJ_LP hatano_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
     th = xy.y * ( xy.y < 0. ? RYCS : RYCN);
     if (fabs(th) > 1.) {
         if (fabs(th) > ONETOL) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         } else {
             th = th > 0. ? M_HALFPI : - M_HALFPI;
@@ -61,7 +61,7 @@ static PJ_LP hatano_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
     lp.phi = (th + sin(th)) * (xy.y < 0. ? RCS : RCN);
     if (fabs(lp.phi) > 1.) {
         if (fabs(lp.phi) > ONETOL) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         } else {
             lp.phi = lp.phi > 0. ? M_HALFPI : - M_HALFPI;
diff --git a/src/projections/healpix.cpp b/src/projections/healpix.cpp
index c778f28f..b6863fad 100644
--- a/src/projections/healpix.cpp
+++ b/src/projections/healpix.cpp
@@ -524,7 +524,7 @@ static PJ_LP s_healpix_inverse(PJ_XY xy, PJ *P) { /* sphere */
         PJ_LP lp;
         lp.lam = HUGE_VAL;
         lp.phi = HUGE_VAL;
-        proj_context_errno_set(P->ctx, PJD_ERR_INVALID_X_OR_Y);
+        proj_context_errno_set(P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     return healpix_spherhealpix_e_inverse(xy);
@@ -540,7 +540,7 @@ static PJ_LP e_healpix_inverse(PJ_XY xy, PJ *P) { /* ellipsoid */
     if (in_image(xy.x, xy.y, 0, 0, 0) == 0) {
         lp.lam = HUGE_VAL;
         lp.phi = HUGE_VAL;
-        proj_context_errno_set(P->ctx, PJD_ERR_INVALID_X_OR_Y);
+        proj_context_errno_set(P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     lp = healpix_spherhealpix_e_inverse(xy);
@@ -574,7 +574,7 @@ static PJ_LP s_rhealpix_inverse(PJ_XY xy, PJ *P) { /* sphere */
         PJ_LP lp;
         lp.lam = HUGE_VAL;
         lp.phi = HUGE_VAL;
-        proj_context_errno_set(P->ctx, PJD_ERR_INVALID_X_OR_Y);
+        proj_context_errno_set(P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     xy = combine_caps(xy.x, xy.y, Q->north_square, Q->south_square, 1);
@@ -590,7 +590,7 @@ static PJ_LP e_rhealpix_inverse(PJ_XY xy, PJ *P) { /* ellipsoid */
     if (in_image(xy.x, xy.y, 1, Q->north_square, Q->south_square) == 0) {
         lp.lam = HUGE_VAL;
         lp.phi = HUGE_VAL;
-        proj_context_errno_set(P->ctx, PJD_ERR_INVALID_X_OR_Y);
+        proj_context_errno_set(P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     xy = combine_caps(xy.x, xy.y, Q->north_square, Q->south_square, 1);
@@ -615,7 +615,7 @@ static PJ *destructor (PJ *P, int errlev) {                        /* Destructor
 PJ *PROJECTION(healpix) {
     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 = Q;
     P->destructor = destructor;
 
@@ -625,7 +625,7 @@ PJ *PROJECTION(healpix) {
     if (P->es != 0.0) {
         Q->apa = pj_authset(P->es);             /* For auth_lat(). */
         if (nullptr==Q->apa)
-            return destructor(P, ENOMEM);
+            return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
         Q->qp = pj_qsfn(1.0, P->e, P->one_es);  /* For auth_lat(). */
         P->a = P->a*sqrt(0.5*Q->qp);            /* Set P->a to authalic radius. */
         pj_calc_ellipsoid_params (P, P->a, P->es);  /* Ensure we have a consistent parameter set */
@@ -643,7 +643,7 @@ PJ *PROJECTION(healpix) {
 PJ *PROJECTION(rhealpix) {
     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 = Q;
     P->destructor = destructor;
 
@@ -652,13 +652,19 @@ PJ *PROJECTION(rhealpix) {
 
     /* Check for valid north_square and south_square inputs. */
     if (Q->north_square < 0 || Q->north_square > 3)
-        return destructor (P, PJD_ERR_AXIS);
+    {
+        proj_log_error(P, _("Invalid value for north_square: it should be in [0,3] range."));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     if (Q->south_square < 0 || Q->south_square > 3)
-        return destructor (P, PJD_ERR_AXIS);
+    {
+        proj_log_error(P, _("Invalid value for south_square: it should be in [0,3] range."));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     if (P->es != 0.0) {
         Q->apa = pj_authset(P->es); /* For auth_lat(). */
         if (nullptr==Q->apa)
-            return destructor(P, ENOMEM);
+            return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
         Q->qp = pj_qsfn(1.0, P->e, P->one_es); /* For auth_lat(). */
         P->a = P->a*sqrt(0.5*Q->qp); /* Set P->a to authalic radius. */
         P->ra = 1.0/P->a;
diff --git a/src/projections/igh.cpp b/src/projections/igh.cpp
index 8aaaaba1..9e51addf 100644
--- a/src/projections/igh.cpp
+++ b/src/projections/igh.cpp
@@ -210,7 +210,7 @@ PJ *PROJECTION(igh) {
     PJ_LP lp = { 0, phi_boundary };
     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 = Q;
 
 
@@ -222,7 +222,7 @@ PJ *PROJECTION(igh) {
         !setup_zone(P, Q, 7, pj_sinu,   d20, 0,   d20) ||
         !setup_zone(P, Q, 8, pj_sinu,  d140, 0,  d140))
     {
-       return destructor(P, ENOMEM);
+       return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     }
 
     /* mollweide zones */
@@ -243,7 +243,7 @@ PJ *PROJECTION(igh) {
         !setup_zone(P, Q,11, pj_moll,   d20, -Q->dy0,   d20) ||
         !setup_zone(P, Q,12, pj_moll,  d140, -Q->dy0,  d140))
     {
-       return destructor(P, ENOMEM);
+       return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     }
 
     P->inv = igh_s_inverse;
diff --git a/src/projections/igh_o.cpp b/src/projections/igh_o.cpp
index 80874845..1a7485e1 100644
--- a/src/projections/igh_o.cpp
+++ b/src/projections/igh_o.cpp
@@ -224,7 +224,7 @@ PJ *PROJECTION(igh_o) {
     PJ_LP lp = { 0, phi_boundary };
     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 = Q;
 
 
@@ -236,13 +236,13 @@ PJ *PROJECTION(igh_o) {
         !setup_zone(P, Q, 8, pj_sinu,   d20, 0,   d20) ||
         !setup_zone(P, Q, 9, pj_sinu,  d150, 0,  d150))
     {
-       return destructor(P, ENOMEM);
+       return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     }
 
 
     /* mollweide zones */
     if (!setup_zone(P, Q, 1, pj_moll,  -d140, 0,  -d140)) {
-       return destructor(P, ENOMEM);
+       return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     }
 
     /* y0 ? */
@@ -260,7 +260,7 @@ PJ *PROJECTION(igh_o) {
         !setup_zone(P, Q, 11, pj_moll,   d20, -Q->dy0,   d20)  ||
         !setup_zone(P, Q, 12, pj_moll,  d150, -Q->dy0,  d150))
     {
-       return destructor(P, ENOMEM);
+       return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     }
 
     P->inv = igh_o_s_inverse;
diff --git a/src/projections/imw_p.cpp b/src/projections/imw_p.cpp
index 6e82d287..6f0bfe5f 100644
--- a/src/projections/imw_p.cpp
+++ b/src/projections/imw_p.cpp
@@ -34,15 +34,27 @@ static int phi12(PJ *P, double *del, double *sig) {
     struct pj_opaque *Q = static_cast<struct pj_opaque*>(P->opaque);
     int err = 0;
 
-    if (!pj_param(P->ctx, P->params, "tlat_1").i ||
-        !pj_param(P->ctx, P->params, "tlat_2").i) {
-        err = PJD_ERR_LAT_1_2_UNSPECIFIED;
-    } else {
+    if (!pj_param(P->ctx, P->params, "tlat_1").i )
+    {
+        proj_log_error(P, _("Missing parameter: lat_1 should be specified"));
+        err = PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE;
+    }
+    else if ( !pj_param(P->ctx, P->params, "tlat_2").i)
+    {
+        proj_log_error(P, _("Missing parameter: lat_2 should be specified"));
+        err = PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE;
+    }
+    else
+    {
         Q->phi_1 = pj_param(P->ctx, P->params, "rlat_1").f;
         Q->phi_2 = pj_param(P->ctx, P->params, "rlat_2").f;
         *del = 0.5 * (Q->phi_2 - Q->phi_1);
         *sig = 0.5 * (Q->phi_2 + Q->phi_1);
-        err = (fabs(*del) < EPS || fabs(*sig) < EPS) ? PJD_ERR_ABS_LAT1_EQ_ABS_LAT2 : 0;
+        err = (fabs(*del) < EPS || fabs(*sig) < EPS) ? PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE : 0;
+        if( err )
+        {
+            proj_log_error(P, _("Illegal value for lat_1 and lat_2: |lat_1 - lat_2| and |lat_1 + lat_2| should be > 0"));
+        }
     }
     return err;
 }
@@ -120,7 +132,7 @@ static PJ_LP imw_p_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, invers
         if( denom != 0 || fabs(t.y - xy.y) > TOL )
         {
             if( denom == 0 ) {
-                proj_errno_set(P, PJD_ERR_NON_CONVERGENT);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return proj_coord_error().lp;
             }
             lp.phi = ((lp.phi - Q->phi_1) * (xy.y - yc) / denom) + Q->phi_1;
@@ -133,7 +145,7 @@ static PJ_LP imw_p_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, invers
 
     if( i == N_MAX_ITER )
     {
-        proj_errno_set(P, PJD_ERR_NON_CONVERGENT);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return proj_coord_error().lp;
     }
 
@@ -171,10 +183,10 @@ PJ *PROJECTION(imw_p) {
     int err;
     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 = Q;
 
-    if (!(Q->en = pj_enfn(P->es))) return pj_default_destructor (P, ENOMEM);
+    if (!(Q->en = pj_enfn(P->es))) return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     if( (err = phi12(P, &del, &sig)) != 0) {
         return destructor(P, err);
     }
diff --git a/src/projections/isea.cpp b/src/projections/isea.cpp
index 77a5689b..7a782f3d 100644
--- a/src/projections/isea.cpp
+++ b/src/projections/isea.cpp
@@ -1026,7 +1026,7 @@ static PJ_XY isea_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
     try {
         out = isea_forward(&Q->dgg, &in);
     } catch( const char* ) {
-        proj_errno_set(P, PJD_ERR_NON_CONVERGENT);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return proj_coord_error().xy;
     }
 
@@ -1041,7 +1041,7 @@ PJ *PROJECTION(isea) {
     char *opt;
     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 = Q;
 
 
@@ -1059,7 +1059,8 @@ PJ *PROJECTION(isea) {
         } else if (!strcmp(opt, "pole")) {
             isea_orient_pole(&Q->dgg);
         } else {
-            return pj_default_destructor(P, PJD_ERR_ELLIPSOID_USE_REQUIRED);
+            proj_log_error(P, _("Invalid value for orient: only isea or pole are supported"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
         }
     }
 
@@ -1089,8 +1090,8 @@ PJ *PROJECTION(isea) {
             Q->dgg.output = ISEA_HEX;
         }
         else {
-            /* TODO verify error code.  Possibly eliminate magic */
-            return pj_default_destructor(P, PJD_ERR_ELLIPSOID_USE_REQUIRED);
+            proj_log_error(P, _("Invalid value for mode: only plane, di, dd or hex are supported"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
         }
     }
 
diff --git a/src/projections/krovak.cpp b/src/projections/krovak.cpp
index adc039fe..2afe3672 100644
--- a/src/projections/krovak.cpp
+++ b/src/projections/krovak.cpp
@@ -181,7 +181,7 @@ static PJ_LP krovak_e_inverse (PJ_XY xy, PJ *P) {                /* Ellipsoidal,
         fi1 = lp.phi;
     }
     if( i == 0 )
-        proj_context_errno_set( P->ctx, PJD_ERR_NON_CONVERGENT );
+        proj_context_errno_set( P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN );
 
    lp.lam -= P->lam0;
 
@@ -193,7 +193,7 @@ PJ *PROJECTION(krovak) {
     double u0, n0, g;
     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 = Q;
 
     /* we want Bessel as fixed ellipsoid */
@@ -225,7 +225,8 @@ PJ *PROJECTION(krovak) {
     g = pow( (1. + P->e * sin(P->phi0)) / (1. - P->e * sin(P->phi0)) , Q->alpha * P->e / 2. );
     double tan_half_phi0_plus_pi_4 = tan(P->phi0 / 2. + M_PI_4);
     if( tan_half_phi0_plus_pi_4 == 0.0 ) {
-        return pj_default_destructor(P, PJD_ERR_INVALID_ARG);
+        proj_log_error(P, _("Invalid value for lat_0: lat_0 + PI/4 should be different from 0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
     Q->k = tan( u0 / 2. + M_PI_4) / pow  (tan_half_phi0_plus_pi_4 , Q->alpha) * g;
     n0 = sqrt(1. - P->es) / (1. - P->es * pow(sin(P->phi0), 2));
diff --git a/src/projections/labrd.cpp b/src/projections/labrd.cpp
index 4fbcf460..b17e71e9 100644
--- a/src/projections/labrd.cpp
+++ b/src/projections/labrd.cpp
@@ -107,11 +107,12 @@ PJ *PROJECTION(labrd) {
     double Az, sinp, R, N, t;
     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 = Q;
 
     if (P->phi0 == 0.) {
-        return pj_default_destructor(P, PJD_ERR_LAT_0_IS_ZERO);
+        proj_log_error(P, _("Invalid value for lat_0: lat_0 should be different from 0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
 
     Az = pj_param(P->ctx, P->params, "razi").f;
diff --git a/src/projections/laea.cpp b/src/projections/laea.cpp
index 2d19cab1..5054e8ff 100644
--- a/src/projections/laea.cpp
+++ b/src/projections/laea.cpp
@@ -65,7 +65,7 @@ static PJ_XY laea_e_forward (PJ_LP lp, PJ *P) {          /* Ellipsoidal, forward
         break;
     }
     if (fabs(b) < EPS10) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
 
@@ -111,7 +111,7 @@ static PJ_XY laea_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
         xy.y = 1. + Q->sinb1 * sinphi + Q->cosb1 * cosphi * coslam;
 oblcon:
         if (xy.y <= EPS10) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         xy.y = sqrt(2. / xy.y);
@@ -124,7 +124,7 @@ oblcon:
         /*-fallthrough*/
     case S_POLE:
         if (fabs(lp.phi + P->phi0) < EPS10) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         xy.y = M_FORTPI - lp.phi * .5;
@@ -193,7 +193,7 @@ static PJ_LP laea_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
 
     rh = hypot(xy.x, xy.y);
     if ((lp.phi = rh * .5 ) > 1.) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     lp.phi = 2. * asin(lp.phi);
@@ -244,13 +244,14 @@ PJ *PROJECTION(laea) {
     double t;
     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 = Q;
     P->destructor = destructor;
 
     t = fabs(P->phi0);
     if (t > M_HALFPI + EPS10 ) {
-        return destructor(P, PJD_ERR_LAT_LARGER_THAN_90);
+        proj_log_error(P, _("Invalid value for lat_0: |lat_0| should be <= 90°"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
     if (fabs(t - M_HALFPI) < EPS10)
         Q->mode = P->phi0 < 0. ? S_POLE : N_POLE;
@@ -266,7 +267,7 @@ PJ *PROJECTION(laea) {
         Q->mmf = .5 / (1. - P->es);
         Q->apa = pj_authset(P->es);
         if (nullptr==Q->apa)
-            return destructor(P, ENOMEM);
+            return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
         switch (Q->mode) {
         case N_POLE:
         case S_POLE:
diff --git a/src/projections/lagrng.cpp b/src/projections/lagrng.cpp
index 1029bf8d..fa680643 100644
--- a/src/projections/lagrng.cpp
+++ b/src/projections/lagrng.cpp
@@ -35,7 +35,7 @@ static PJ_XY lagrng_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwa
         lp.lam *= Q->rw;
         c = 0.5 * (v + 1./v) + cos(lp.lam);
         if (c < TOL) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         xy.x = 2. * sin(lp.lam) / c;
@@ -59,7 +59,7 @@ static PJ_LP lagrng_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
         y2m = 2. - xy.y;
         c = y2p * y2m - x2;
         if (fabs(c) < TOL) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         }
         lp.phi = 2. * atan(pow((y2p * y2p + x2) / (Q->a2 * (y2m * y2m + x2)), Q->hw)) - M_HALFPI;
@@ -73,7 +73,7 @@ PJ *PROJECTION(lagrng) {
     double sin_phi1;
     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 = Q;
 
     if( pj_param(P->ctx, P->params, "tW").i )
@@ -81,13 +81,19 @@ PJ *PROJECTION(lagrng) {
     else
         Q->w = 2;
     if (Q->w <= 0)
-        return pj_default_destructor(P, PJD_ERR_W_OR_M_ZERO_OR_LESS);
+    {
+        proj_log_error(P, _("Invalid value for W: it should be > 0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     Q->hw = 0.5 * Q->w;
     Q->rw = 1. / Q->w;
     Q->hrw = 0.5 * Q->rw;
     sin_phi1 = sin(pj_param(P->ctx, P->params, "rlat_1").f);
     if (fabs(fabs(sin_phi1) - 1.) < TOL)
-        return pj_default_destructor(P, PJD_ERR_LAT_LARGER_THAN_90);
+    {
+        proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be < 90°"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     Q->a1 = pow((1. - sin_phi1)/(1. + sin_phi1), Q->hrw);
     Q->a2 = Q->a1 * Q->a1;
diff --git a/src/projections/lcc.cpp b/src/projections/lcc.cpp
index 525281f4..42d8b2c9 100644
--- a/src/projections/lcc.cpp
+++ b/src/projections/lcc.cpp
@@ -27,7 +27,7 @@ static PJ_XY lcc_e_forward (PJ_LP lp, PJ *P) {          /* Ellipsoidal, forward
 
     if (fabs(fabs(lp.phi) - M_HALFPI) < EPS10) {
         if ((lp.phi * Q->n) <= 0.) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         rho = 0.;
@@ -62,7 +62,7 @@ static PJ_LP lcc_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inverse
         if (P->es != 0.) {
             lp.phi = pj_phi2(P->ctx, pow(rho / Q->c, 1./Q->n), P->e);
             if (lp.phi == HUGE_VAL) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return lp;
             }
 
@@ -83,7 +83,7 @@ PJ *PROJECTION(lcc) {
     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 = Q;
 
     Q->phi1 = pj_param(P->ctx, P->params, "rlat_1").f;
@@ -94,37 +94,45 @@ PJ *PROJECTION(lcc) {
         if (!pj_param(P->ctx, P->params, "tlat_0").i)
             P->phi0 = Q->phi1;
     }
-    if (fabs(Q->phi1) > M_HALFPI || fabs(Q->phi2) > M_HALFPI)
-        return pj_default_destructor(P, PJD_ERR_LAT_LARGER_THAN_90);
+
     if (fabs(Q->phi1 + Q->phi2) < EPS10)
-        return pj_default_destructor(P, PJD_ERR_CONIC_LAT_EQUAL);
+    {
+        proj_log_error(P, _("Invalid value for lat_1 and lat_2: |lat_1 + lat_2| should be > 0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     Q->n = sinphi = sin(Q->phi1);
     cosphi = cos(Q->phi1);
+
+    if( fabs(cosphi) < EPS10 || fabs(Q->phi1) >= M_PI_2 ) {
+        proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be < 90°"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
+    if( fabs(cos(Q->phi2)) < EPS10 || fabs(Q->phi2) >= M_PI_2 ) {
+        proj_log_error(P, _("Invalid value for lat_2: |lat_2| should be < 90°"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
+
     secant = fabs(Q->phi1 - Q->phi2) >= EPS10;
     if (P->es != 0.) {
         double ml1, m1;
 
         m1 = pj_msfn(sinphi, cosphi, P->es);
-        if( fabs(Q->phi1) == M_HALFPI ) {
-            return pj_default_destructor(P, PJD_ERR_LAT_1_OR_2_ZERO_OR_90);
-        }
         ml1 = pj_tsfn(Q->phi1, sinphi, P->e);
         if (secant) { /* secant cone */
             sinphi = sin(Q->phi2);
             Q->n = log(m1 / pj_msfn(sinphi, cos(Q->phi2), P->es));
             if (Q->n == 0) {
                 // Not quite, but es is very close to 1...
-                return pj_default_destructor(P, PJD_ERR_INVALID_ECCENTRICITY);
-            }
-            if( fabs(Q->phi2) == M_HALFPI ) {
-              return pj_default_destructor(P, PJD_ERR_LAT_1_OR_2_ZERO_OR_90);
+                proj_log_error(P, _("Invalid value for eccentricity"));
+                return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
             }
             const double ml2 = pj_tsfn(Q->phi2, sinphi, P->e);
             const double denom = log(ml1 / ml2);
             if( denom == 0 ) {
                 // Not quite, but es is very close to 1...
-                return pj_default_destructor(P, PJD_ERR_INVALID_ECCENTRICITY);
+                proj_log_error(P, _("Invalid value for eccentricity"));
+                return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
             }
             Q->n /= denom;
         }
@@ -133,9 +141,6 @@ PJ *PROJECTION(lcc) {
         Q->rho0 *= (fabs(fabs(P->phi0) - M_HALFPI) < EPS10) ? 0. :
             pow(pj_tsfn(P->phi0, sin(P->phi0), P->e), Q->n);
     } else {
-        if( fabs(cosphi) < EPS10 || fabs(cos(Q->phi2)) < EPS10 ) {
-            return pj_default_destructor(P, PJD_ERR_LAT_1_OR_2_ZERO_OR_90);
-        }
         if (secant)
             Q->n = log(cosphi / cos(Q->phi2)) /
                log(tan(M_FORTPI + .5 * Q->phi2) /
@@ -143,7 +148,8 @@ PJ *PROJECTION(lcc) {
         if( Q->n == 0 ) {
             // Likely reason is that phi1 / phi2 are too close to zero.
             // Can be reproduced with +proj=lcc +a=1 +lat_2=.0000001
-            return pj_default_destructor(P, PJD_ERR_CONIC_LAT_EQUAL);
+            proj_log_error(P, _("Invalid value for lat_1 and lat_2: |lat_1 + lat_2| should be > 0"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
         }
         Q->c = cosphi * pow(tan(M_FORTPI + .5 * Q->phi1), Q->n) / Q->n;
         Q->rho0 = (fabs(fabs(P->phi0) - M_HALFPI) < EPS10) ? 0. :
diff --git a/src/projections/lcca.cpp b/src/projections/lcca.cpp
index 53646fc6..6f962699 100644
--- a/src/projections/lcca.cpp
+++ b/src/projections/lcca.cpp
@@ -112,7 +112,7 @@ static PJ_LP lcca_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inverse
         if (fabs(dif) < DEL_TOL) break;
     }
     if (!i) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     lp.phi = pj_inv_mlfn(P->ctx, S + Q->M0, P->es, Q->en);
@@ -137,15 +137,16 @@ PJ *PROJECTION(lcca) {
     double s2p0, N0, R0, tan0;
     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 = Q;
 
     (Q->en = pj_enfn(P->es));
     if (!Q->en)
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     if (P->phi0 == 0.) {
-        return destructor(P, PJD_ERR_LAT_0_IS_ZERO);
+        proj_log_error(P, _("Invalid value for lat_0: it should be different from 0."));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
     Q->l = sin(P->phi0);
     Q->M0 = pj_mlfn(P->phi0, Q->l, cos(P->phi0), Q->en);
diff --git a/src/projections/loxim.cpp b/src/projections/loxim.cpp
index 64124bdd..e0b62f1b 100644
--- a/src/projections/loxim.cpp
+++ b/src/projections/loxim.cpp
@@ -58,14 +58,16 @@ static PJ_LP loxim_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
 PJ *PROJECTION(loxim) {
     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 = Q;
 
     Q->phi1 = pj_param(P->ctx, P->params, "rlat_1").f;
     Q->cosphi1 = cos(Q->phi1);
     if (Q->cosphi1 < EPS)
-        return pj_default_destructor(P, PJD_ERR_LAT_LARGER_THAN_90);
-
+    {
+        proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be < 90°"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     Q->tanphi1 = tan(M_FORTPI + 0.5 * Q->phi1);
 
diff --git a/src/projections/lsat.cpp b/src/projections/lsat.cpp
index a811a3a6..ad056da5 100644
--- a/src/projections/lsat.cpp
+++ b/src/projections/lsat.cpp
@@ -136,7 +136,7 @@ static PJ_LP lsat_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inverse
     sppsq = spp * spp;
     const double denom = 1. - sppsq * (1. + Q->u);
     if( denom == 0.0 ) {
-        proj_errno_set(P, PJD_ERR_INVALID_X_OR_Y);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return proj_coord_error().lp;
     }
     lamt = atan(((1. - sppsq * P->rone_es) * tan(lamdp) *
@@ -160,16 +160,23 @@ PJ *PROJECTION(lsat) {
     double lam, alf, esc, ess;
     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 = Q;
 
     land = pj_param(P->ctx, P->params, "ilsat").i;
     if (land <= 0 || land > 5)
-        return pj_default_destructor(P, PJD_ERR_LSAT_NOT_IN_RANGE);
+    {
+        proj_log_error(P, _("Invalid value for lsat: lsat should be in [1, 5] range"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     path = pj_param(P->ctx, P->params, "ipath").i;
-    if (path <= 0 || path > (land <= 3 ? 251 : 233))
-        return pj_default_destructor(P, PJD_ERR_PATH_NOT_IN_RANGE);
+    const int maxPathVal = (land <= 3 ? 251 : 233);
+    if (path <= 0 || path > maxPathVal)
+    {
+        proj_log_error(P, _("Invalid value for path: path should be in [1, %d] range"), maxPathVal);
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     if (land <= 3) {
         P->lam0 = DEG_TO_RAD * 128.87 - M_TWOPI / 251. * path;
diff --git a/src/projections/mbtfpp.cpp b/src/projections/mbtfpp.cpp
index cc01cb40..bfa869f9 100644
--- a/src/projections/mbtfpp.cpp
+++ b/src/projections/mbtfpp.cpp
@@ -32,7 +32,7 @@ static PJ_LP mbtfpp_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
     lp.phi = xy.y / FYC;
     if (fabs(lp.phi) >= 1.) {
         if (fabs(lp.phi) > ONEEPS) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         } else {
             lp.phi = (lp.phi < 0.) ? -M_HALFPI : M_HALFPI;
@@ -45,7 +45,7 @@ static PJ_LP mbtfpp_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
     lp.phi = sin(lp.phi) / CSy;
     if (fabs(lp.phi) >= 1.) {
         if (fabs(lp.phi) > ONEEPS) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         } else {
             lp.phi = (lp.phi < 0.) ? -M_HALFPI : M_HALFPI;
diff --git a/src/projections/mbtfpq.cpp b/src/projections/mbtfpq.cpp
index 5c7f8ca6..7d44b5ba 100644
--- a/src/projections/mbtfpq.cpp
+++ b/src/projections/mbtfpq.cpp
@@ -42,7 +42,7 @@ static PJ_LP mbtfpq_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
     lp.phi = RYC * xy.y;
     if (fabs(lp.phi) > 1.) {
         if (fabs(lp.phi) > ONETOL) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         }
         else if (lp.phi < 0.) {
@@ -61,7 +61,7 @@ static PJ_LP mbtfpq_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
     lp.phi = RC * (t + sin(lp.phi));
     if (fabs(lp.phi) > 1.)
         if (fabs(lp.phi) > ONETOL) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         }
         else            lp.phi = lp.phi < 0. ? -M_HALFPI : M_HALFPI;
diff --git a/src/projections/merc.cpp b/src/projections/merc.cpp
index 3a0ed7b4..7fd3dff9 100644
--- a/src/projections/merc.cpp
+++ b/src/projections/merc.cpp
@@ -53,7 +53,10 @@ PJ *PROJECTION(merc) {
     if( (is_phits = pj_param(P->ctx, P->params, "tlat_ts").i) ) {
         phits = fabs(pj_param(P->ctx, P->params, "rlat_ts").f);
         if (phits >= M_HALFPI)
-            return pj_default_destructor(P, PJD_ERR_LAT_TS_LARGER_THAN_90);
+        {
+            proj_log_error(P, _("Invalid value for lat_ts: |lat_ts| should be <= 90°"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
     }
 
     if (P->es != 0.0) { /* ellipsoid */
diff --git a/src/projections/misrsom.cpp b/src/projections/misrsom.cpp
index d7e199f2..23376789 100644
--- a/src/projections/misrsom.cpp
+++ b/src/projections/misrsom.cpp
@@ -155,7 +155,7 @@ static PJ_LP misrsom_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inve
     sppsq = spp * spp;
     const double denom = 1. - sppsq * (1. + Q->u);
     if( denom == 0.0 ) {
-        proj_errno_set(P, PJD_ERR_NON_CONVERGENT);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return proj_coord_error().lp;
     }
     lamt = atan(((1. - sppsq * P->rone_es) * tan(lamdp) *
@@ -180,12 +180,15 @@ PJ *PROJECTION(misrsom) {
 
     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 = Q;
 
     path = pj_param(P->ctx, P->params, "ipath").i;
     if (path <= 0 || path > 233)
-        return pj_default_destructor(P, PJD_ERR_PATH_NOT_IN_RANGE);
+    {
+        proj_log_error(P, _("Invalid value for path: path should be in [1, 233] range"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     P->lam0 = DEG_TO_RAD * 129.3056 - M_TWOPI / 233. * path;
     alf = 98.30382 * DEG_TO_RAD;
diff --git a/src/projections/mod_ster.cpp b/src/projections/mod_ster.cpp
index 0c30b7b6..237ff75a 100644
--- a/src/projections/mod_ster.cpp
+++ b/src/projections/mod_ster.cpp
@@ -37,7 +37,7 @@ static PJ_XY mod_ster_e_forward (PJ_LP lp, PJ *P) {          /* Ellipsoidal, for
     cchi = cos(chi);
     const double denom = 1. + Q->schio * schi + Q->cchio * cchi * coslon;
     if( denom == 0 ) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     s = 2. / denom;
@@ -136,7 +136,7 @@ PJ *PROJECTION(mil_os) {
 
     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 = Q;
 
     Q->n = 2;
@@ -159,7 +159,7 @@ PJ *PROJECTION(lee_os) {
 
     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 = Q;
 
     Q->n = 2;
@@ -184,7 +184,7 @@ PJ *PROJECTION(gs48) {
 
     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 = Q;
 
     Q->n = 4;
@@ -219,7 +219,7 @@ PJ *PROJECTION(alsk) {
 
     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 = Q;
 
     Q->n = 5;
@@ -267,7 +267,7 @@ PJ *PROJECTION(gs50) {
 
     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 = Q;
 
     Q->n = 9;
diff --git a/src/projections/moll.cpp b/src/projections/moll.cpp
index 4864c8e1..523de210 100644
--- a/src/projections/moll.cpp
+++ b/src/projections/moll.cpp
@@ -79,7 +79,7 @@ static PJ * setup(PJ *P, double p) {
 PJ *PROJECTION(moll) {
     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 = Q;
 
     return setup(P, M_HALFPI);
@@ -89,7 +89,7 @@ PJ *PROJECTION(moll) {
 PJ *PROJECTION(wag4) {
     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 = Q;
 
     return setup(P, M_PI/3.);
@@ -98,7 +98,7 @@ PJ *PROJECTION(wag4) {
 PJ *PROJECTION(wag5) {
     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 = Q;
 
     P->es = 0;
diff --git a/src/projections/natearth.cpp b/src/projections/natearth.cpp
index e1f71089..f83c8467 100644
--- a/src/projections/natearth.cpp
+++ b/src/projections/natearth.cpp
@@ -82,7 +82,7 @@ static PJ_LP natearth_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inv
         }
     }
     if( i == 0 )
-        proj_context_errno_set( P->ctx, PJD_ERR_NON_CONVERGENT );
+        proj_context_errno_set( P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN );
     lp.phi = yc;
 
     /* longitude */
diff --git a/src/projections/natearth2.cpp b/src/projections/natearth2.cpp
index e4516a0a..8bef168d 100644
--- a/src/projections/natearth2.cpp
+++ b/src/projections/natearth2.cpp
@@ -76,7 +76,7 @@ static PJ_LP natearth2_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, in
         }
     }
     if( i == 0 )
-        proj_context_errno_set( P->ctx, PJD_ERR_NON_CONVERGENT );
+        proj_context_errno_set( P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN );
     lp.phi = yc;
 
     /* longitude */
diff --git a/src/projections/nsper.cpp b/src/projections/nsper.cpp
index 951111ac..5f76d9b0 100644
--- a/src/projections/nsper.cpp
+++ b/src/projections/nsper.cpp
@@ -66,7 +66,7 @@ static PJ_XY nsper_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwar
         break;
     }
     if (xy.y < Q->rp) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     xy.y = Q->pn1 / (Q->p - xy.y);
@@ -120,7 +120,7 @@ static PJ_LP nsper_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
         double cosz, sinz;
         sinz = 1. - rh * rh * Q->pfact;
         if (sinz < 0.) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         }
         sinz = (Q->p - sqrt(sinz)) / (Q->pn1 / rh + rh / Q->pn1);
@@ -166,7 +166,10 @@ static PJ *setup(PJ *P) {
     }
     Q->pn1 = Q->height / P->a; /* normalize by radius */
     if ( Q->pn1 <= 0 || Q->pn1 > 1e10 )
-        return pj_default_destructor (P, PJD_ERR_INVALID_H);
+    {
+        proj_log_error(P, _("Invalid value for h"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     Q->p = 1. + Q->pn1;
     Q->rp = 1. / Q->p;
     Q->h = 1. / Q->pn1;
@@ -182,7 +185,7 @@ static PJ *setup(PJ *P) {
 PJ *PROJECTION(nsper) {
     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 = Q;
 
     Q->tilt = 0;
@@ -196,7 +199,7 @@ PJ *PROJECTION(tpers) {
 
     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 = Q;
 
     omega = pj_param(P->ctx, P->params, "rtilt").f;
diff --git a/src/projections/ob_tran.cpp b/src/projections/ob_tran.cpp
index 86798e0a..abab5835 100644
--- a/src/projections/ob_tran.cpp
+++ b/src/projections/ob_tran.cpp
@@ -180,26 +180,33 @@ PJ *PROJECTION(ob_tran) {
 
     struct pj_opaque *Q = static_cast<struct pj_opaque*>(calloc (1, sizeof (struct pj_opaque)));
     if (nullptr==Q)
-        return destructor(P, ENOMEM);
+        return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     P->opaque = Q;
     P->destructor = destructor;
 
     /* get name of projection to be translated */
     if (pj_param(P->ctx, P->params, "so_proj").s == nullptr)
-        return destructor(P, PJD_ERR_NO_ROTATION_PROJ);
+    {
+        proj_log_error(P, _("Missing parameter: o_proj"));
+        return destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
+    }
 
     /* Create the target projection object to rotate */
     args = ob_tran_target_params (P->params);
     /* avoid endless recursion */
     if (args.argv == nullptr ) {
-        return destructor(P, PJD_ERR_FAILED_TO_FIND_PROJ);
+        proj_log_error(P, _("Failed to find projection to be rotated"));
+        return destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
     }
     R = proj_create_argv (P->ctx, args.argc, args.argv);
     free (args.argv);
 
     if (nullptr==R)
-        return destructor (P, PJD_ERR_UNKNOWN_PROJECTION_ID);
+    {
+        proj_log_error(P, _("Projection to be rotated is unknown"));
+        return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     Q->link = R;
 
     if (pj_param(P->ctx, P->params, "to_alpha").i) {
@@ -210,7 +217,10 @@ PJ *PROJECTION(ob_tran) {
         alpha   = pj_param(P->ctx, P->params, "ro_alpha").f;
 
         if (fabs(fabs(phic) - M_HALFPI) <= TOL)
-            return destructor(P, PJD_ERR_LAT_0_OR_ALPHA_EQ_90);
+        {
+            proj_log_error(P, _("Invalid value for lat_c: |lat_c| should be < 90°"));
+            return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
 
         Q->lamp = lamc + aatan2(-cos(alpha), -sin(alpha) * sin(phic));
         phip = aasin(P->ctx,cos(phic) * sin(alpha));
@@ -225,9 +235,27 @@ PJ *PROJECTION(ob_tran) {
         lam2 = pj_param(P->ctx, P->params, "ro_lon_2").f;
         phi2 = pj_param(P->ctx, P->params, "ro_lat_2").f;
         con = fabs(phi1);
-        if (fabs(phi1 - phi2) <= TOL || con <= TOL ||
-            fabs(con - M_HALFPI) <= TOL || fabs(fabs(phi2) - M_HALFPI) <= TOL)
-                return destructor(P, PJD_ERR_LAT_1_OR_2_ZERO_OR_90);
+
+        if (fabs(phi1) > M_HALFPI - TOL)
+        {
+            proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be < 90°"));
+            return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
+        if (fabs(phi2) > M_HALFPI - TOL)
+        {
+            proj_log_error(P, _("Invalid value for lat_2: |lat_2| should be < 90°"));
+            return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
+        if (fabs(phi1 - phi2) < TOL)
+        {
+            proj_log_error(P, _("Invalid value for lat_1 and lat_2: lat_1 should be different from lat_2"));
+            return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
+        if (con < TOL)
+        {
+            proj_log_error(P, _("Invalid value for lat_1: lat_1 should be different from zero"));
+            return destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
 
         Q->lamp = atan2(cos(phi1) * sin(phi2) * cos(lam1) -
             sin(phi1) * cos(phi2) * cos(lam2),
diff --git a/src/projections/ocea.cpp b/src/projections/ocea.cpp
index c78e1ebc..febebcc0 100644
--- a/src/projections/ocea.cpp
+++ b/src/projections/ocea.cpp
@@ -54,7 +54,7 @@ PJ *PROJECTION(ocea) {
 
     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 = Q;
 
     Q->rok = 1. / P->k0;
diff --git a/src/projections/oea.cpp b/src/projections/oea.cpp
index 46c00d16..2d16d529 100644
--- a/src/projections/oea.cpp
+++ b/src/projections/oea.cpp
@@ -60,27 +60,34 @@ static PJ_LP oea_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
 PJ *PROJECTION(oea) {
     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 = Q;
 
-    if (((Q->n = pj_param(P->ctx, P->params, "dn").f) <= 0.) ||
-        ((Q->m = pj_param(P->ctx, P->params, "dm").f) <= 0.)) {
-            return pj_default_destructor(P, PJD_ERR_INVALID_M_OR_N);
-    } else {
-        Q->theta = pj_param(P->ctx, P->params, "rtheta").f;
-        Q->sp0 = sin(P->phi0);
-        Q->cp0 = cos(P->phi0);
-        Q->rn = 1./ Q->n;
-        Q->rm = 1./ Q->m;
-        Q->two_r_n = 2. * Q->rn;
-        Q->two_r_m = 2. * Q->rm;
-        Q->hm = 0.5 * Q->m;
-        Q->hn = 0.5 * Q->n;
-        P->fwd = oea_s_forward;
-        P->inv = oea_s_inverse;
-        P->es = 0.;
+    if (((Q->n = pj_param(P->ctx, P->params, "dn").f) <= 0.) )
+    {
+        proj_log_error(P, _("Invalid value for n: it should be > 0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
 
+    if (((Q->m = pj_param(P->ctx, P->params, "dm").f) <= 0.) )
+    {
+        proj_log_error(P, _("Invalid value for m: it should be > 0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
+
+    Q->theta = pj_param(P->ctx, P->params, "rtheta").f;
+    Q->sp0 = sin(P->phi0);
+    Q->cp0 = cos(P->phi0);
+    Q->rn = 1./ Q->n;
+    Q->rm = 1./ Q->m;
+    Q->two_r_n = 2. * Q->rn;
+    Q->two_r_m = 2. * Q->rm;
+    Q->hm = 0.5 * Q->m;
+    Q->hn = 0.5 * Q->n;
+    P->fwd = oea_s_forward;
+    P->inv = oea_s_inverse;
+    P->es = 0.;
+
     return P;
 }
 
diff --git a/src/projections/omerc.cpp b/src/projections/omerc.cpp
index 90067cc3..88d63809 100644
--- a/src/projections/omerc.cpp
+++ b/src/projections/omerc.cpp
@@ -58,7 +58,7 @@ static PJ_XY omerc_e_forward (PJ_LP lp, PJ *P) {          /* Ellipsoidal, forwar
         const double V = sin(Q->B * lp.lam);
         const double U = (S * Q->singam - V * Q->cosgam) / T;
         if (fabs(fabs(U) - 1.0) < EPS) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         v = 0.5 * Q->ArB * log((1. - U)/(1. + U));
@@ -98,7 +98,7 @@ static PJ_LP omerc_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, invers
     }
     Qp = exp(- Q->BrA * v);
     if( Qp == 0 ) {
-        proj_errno_set(P, PJD_ERR_INVALID_X_OR_Y);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return proj_coord_error().lp;
     }
     Sp = .5 * (Qp - 1. / Qp);
@@ -111,7 +111,7 @@ static PJ_LP omerc_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, invers
     } else {
         lp.phi = Q->E / sqrt((1. + Up) / (1. - Up));
         if ((lp.phi = pj_phi2(P->ctx, pow(lp.phi, 1. / Q->B), P->e)) == HUGE_VAL) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         }
         lp.lam = - Q->rB * atan2((Sp * Q->cosgam -
@@ -128,7 +128,7 @@ PJ *PROJECTION(omerc) {
 
     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 = Q;
 
     Q->no_rot = pj_param(P->ctx, P->params, "bno_rot").i;
@@ -154,14 +154,36 @@ PJ *PROJECTION(omerc) {
         phi1 = pj_param(P->ctx, P->params, "rlat_1").f;
         lam2 = pj_param(P->ctx, P->params, "rlon_2").f;
         phi2 = pj_param(P->ctx, P->params, "rlat_2").f;
-        if (fabs(phi1) > M_HALFPI || fabs(phi2) > M_HALFPI)
-            return pj_default_destructor(P, PJD_ERR_LAT_LARGER_THAN_90);
-        if (fabs(phi1 - phi2) <= TOL ||
-            (con = fabs(phi1)) <= TOL ||
-            fabs(con - M_HALFPI) <= TOL ||
-            fabs(fabs(P->phi0) - M_HALFPI) <= TOL ||
-            fabs(fabs(phi2) - M_HALFPI) <= TOL)
-                return pj_default_destructor(P, PJD_ERR_LAT_0_OR_ALPHA_EQ_90);
+        con = fabs(phi1);
+
+        if (fabs(phi1) > M_HALFPI - TOL)
+        {
+            proj_log_error(P, _("Invalid value for lat_1: |lat_1| should be < 90°"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
+        if (fabs(phi2) > M_HALFPI - TOL)
+        {
+            proj_log_error(P, _("Invalid value for lat_2: |lat_2| should be < 90°"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
+
+        if (fabs(phi1 - phi2) <= TOL )
+        {
+            proj_log_error(P, _("Invalid value for lat_1/lat_2: lat_1 should be different from lat_2"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
+
+        if (con <= TOL )
+        {
+            proj_log_error(P, _("Invalid value for lat_1: lat_1 should be different from 0"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
+
+        if (fabs(fabs(P->phi0) - M_HALFPI) <= TOL)
+        {
+            proj_log_error(P, _("Invalid value for lat_01: |lat_0| should be < 90°"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
     }
     com = sqrt(P->one_es);
     if (fabs(P->phi0) > EPS) {
@@ -193,9 +215,13 @@ PJ *PROJECTION(omerc) {
                 gamma = alpha_c;
         } else
             alpha_c = aasin(P->ctx, D*sin(gamma0 = gamma));
-        if( fabs(fabs(P->phi0) - M_HALFPI) <= TOL ) {
-            return pj_default_destructor(P, PJD_ERR_LAT_0_OR_ALPHA_EQ_90);
+
+        if (fabs(fabs(P->phi0) - M_HALFPI) <= TOL)
+        {
+            proj_log_error(P, _("Invalid value for lat_01: |lat_0| should be < 90°"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
         }
+
         P->lam0 = lamc - aasin(P->ctx, .5 * (F - 1. / F) *
            tan(gamma0)) / Q->B;
     } else {
@@ -205,7 +231,8 @@ PJ *PROJECTION(omerc) {
         p = (L - H) / (L + H);
         if( p == 0 ) {
             // Not quite, but es is very close to 1...
-            return pj_default_destructor(P, PJD_ERR_INVALID_ECCENTRICITY);
+            proj_log_error(P, _("Invalid value for eccentricity"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
         }
         J = Q->E * Q->E;
         J = (J - L * H) / (J + L * H);
@@ -217,7 +244,8 @@ PJ *PROJECTION(omerc) {
            J * tan(.5 * Q->B * (lam1 - lam2)) / p) / Q->B);
         const double denom = F - 1. / F;
         if( denom == 0 ) {
-            return pj_default_destructor(P, PJD_ERR_INVALID_ECCENTRICITY);
+            proj_log_error(P, _("Invalid value for eccentricity"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
         }
         gamma0 = atan(2. * sin(Q->B * adjlon(lam1 - P->lam0)) / denom);
         gamma = alpha_c = aasin(P->ctx, D * sin(gamma0));
diff --git a/src/projections/ortho.cpp b/src/projections/ortho.cpp
index 4417dac7..206abb69 100644
--- a/src/projections/ortho.cpp
+++ b/src/projections/ortho.cpp
@@ -29,7 +29,7 @@ struct pj_opaque {
 #define EPS10 1.e-10
 
 static PJ_XY forward_error(PJ *P, PJ_LP lp, PJ_XY xy) {
-    proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+    proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
     proj_log_trace(P, "Coordinate (%.3f, %.3f) is on the unprojected hemisphere",
                    proj_todeg(lp.lam), proj_todeg(lp.phi));
     return xy;
@@ -88,7 +88,7 @@ static PJ_LP ortho_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
     sinc = rh;
     if (sinc > 1.) {
         if ((sinc - 1.) > EPS10) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             proj_log_trace(P, "Point (%.3f, %.3f) is outside the projection boundary");
             return lp;
         }
@@ -176,7 +176,7 @@ static PJ_LP ortho_e_inverse (PJ_XY xy, PJ *P) {           /* Ellipsoidal, inver
         const double rh2 = SQ(xy.x) + SQ(xy.y);
         if (rh2 >= 1. - 1e-15) {
             if ((rh2 - 1.) > EPS10) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 proj_log_trace(P, "Point (%.3f, %.3f) is outside the projection boundary");
                 lp.lam = HUGE_VAL; lp.phi = HUGE_VAL;
                 return lp;
@@ -200,7 +200,7 @@ static PJ_LP ortho_e_inverse (PJ_XY xy, PJ *P) {           /* Ellipsoidal, inver
 
         // Equation of the ellipse
         if( SQ(xy.x) + SQ(xy.y * (P->a / P->b)) > 1 + 1e-11 ) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             proj_log_trace(P, "Point (%.3f, %.3f) is outside the projection boundary");
             lp.lam = HUGE_VAL; lp.phi = HUGE_VAL;
             return lp;
@@ -228,7 +228,7 @@ static PJ_LP ortho_e_inverse (PJ_XY xy, PJ *P) {           /* Ellipsoidal, inver
     xy_recentered.x = xy.x;
     xy_recentered.y = (xy.y - Q->y_shift) / Q->y_scale;
     if( SQ(xy.x) + SQ(xy_recentered.y) > 1 + 1e-11 ) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         proj_log_trace(P, "Point (%.3f, %.3f) is outside the projection boundary");
         lp.lam = HUGE_VAL; lp.phi = HUGE_VAL;
         return lp;
@@ -273,7 +273,7 @@ static PJ_LP ortho_e_inverse (PJ_XY xy, PJ *P) {           /* Ellipsoidal, inver
             return lp;
         }
     }
-    proj_context_errno_set(P->ctx, PJD_ERR_NON_CONVERGENT);
+    proj_context_errno_set(P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
     return lp;
 }
 
@@ -281,7 +281,7 @@ static PJ_LP ortho_e_inverse (PJ_XY xy, PJ *P) {           /* Ellipsoidal, inver
 PJ *PROJECTION(ortho) {
     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 = Q;
 
     Q->sinph0 = sin(P->phi0);
diff --git a/src/projections/patterson.cpp b/src/projections/patterson.cpp
index 32544580..d24ee98d 100644
--- a/src/projections/patterson.cpp
+++ b/src/projections/patterson.cpp
@@ -100,7 +100,7 @@ static PJ_LP patterson_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, in
         }
     }
     if( i == 0 )
-        proj_context_errno_set( P->ctx, PJD_ERR_NON_CONVERGENT );
+        proj_context_errno_set( P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN );
     lp.phi = yc;
 
     /* longitude */
diff --git a/src/projections/poly.cpp b/src/projections/poly.cpp
index 4ea95cc7..99b6772e 100644
--- a/src/projections/poly.cpp
+++ b/src/projections/poly.cpp
@@ -80,7 +80,7 @@ static PJ_LP poly_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inverse
             const double cp = cos(lp.phi);
             const double s2ph = sp * cp;
             if (fabs(cp) < ITOL) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return lp;
             }
             double mlp = sqrt(1. - P->es * sp * sp);
@@ -97,7 +97,7 @@ static PJ_LP poly_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inverse
                 break;
         }
         if (!i) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         }
         const double c = sin(lp.phi);
@@ -128,7 +128,7 @@ static PJ_LP poly_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inverse
                 break;
             --i;
             if( i == 0 ) {
-                proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+                proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
                 return lp;
             }
         }
@@ -156,14 +156,14 @@ static PJ *destructor(PJ *P, int errlev) {
 PJ *PROJECTION(poly) {
     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 = Q;
     P->destructor = destructor;
 
     if (P->es != 0.0) {
         if (!(Q->en = pj_enfn(P->es)))
-            return pj_default_destructor (P, ENOMEM);
+            return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
         Q->ml0 = pj_mlfn(P->phi0, sin(P->phi0), cos(P->phi0), Q->en);
         P->inv = poly_e_inverse;
         P->fwd = poly_e_forward;
diff --git a/src/projections/putp3.cpp b/src/projections/putp3.cpp
index 09763851..3554909e 100644
--- a/src/projections/putp3.cpp
+++ b/src/projections/putp3.cpp
@@ -40,7 +40,7 @@ static PJ_LP putp3_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
 PJ *PROJECTION(putp3) {
     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 = Q;
 
     Q->A = 4. * RPISQ;
@@ -55,7 +55,7 @@ PJ *PROJECTION(putp3) {
 PJ *PROJECTION(putp3p) {
     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 = Q;
 
     Q->A = 2. * RPISQ;
diff --git a/src/projections/putp4p.cpp b/src/projections/putp4p.cpp
index 8df18972..1c9a763e 100644
--- a/src/projections/putp4p.cpp
+++ b/src/projections/putp4p.cpp
@@ -47,7 +47,7 @@ static PJ_LP putp4p_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, inver
 PJ *PROJECTION(putp4p) {
     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 = Q;
 
     Q->C_x = 0.874038744;
@@ -64,7 +64,7 @@ PJ *PROJECTION(putp4p) {
 PJ *PROJECTION(weren) {
     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 = Q;
 
     Q->C_x = 1.;
diff --git a/src/projections/putp5.cpp b/src/projections/putp5.cpp
index 5e70382d..a6aed94e 100644
--- a/src/projections/putp5.cpp
+++ b/src/projections/putp5.cpp
@@ -45,7 +45,7 @@ static PJ_LP putp5_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
 PJ *PROJECTION(putp5) {
     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 = Q;
 
     Q->A = 2.;
@@ -62,7 +62,7 @@ PJ *PROJECTION(putp5) {
 PJ *PROJECTION(putp5p) {
     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 = Q;
 
     Q->A = 1.5;
diff --git a/src/projections/putp6.cpp b/src/projections/putp6.cpp
index da8c0a7c..63253fbd 100644
--- a/src/projections/putp6.cpp
+++ b/src/projections/putp6.cpp
@@ -61,7 +61,7 @@ static PJ_LP putp6_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
 PJ *PROJECTION(putp6) {
     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 = Q;
 
     Q->C_x = 1.01346;
@@ -81,7 +81,7 @@ PJ *PROJECTION(putp6) {
 PJ *PROJECTION(putp6p) {
     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 = Q;
 
     Q->C_x = 0.44329;
diff --git a/src/projections/qsc.cpp b/src/projections/qsc.cpp
index dd9ce965..920e93b0 100644
--- a/src/projections/qsc.cpp
+++ b/src/projections/qsc.cpp
@@ -379,7 +379,7 @@ static PJ_LP qsc_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inverse
 PJ *PROJECTION(qsc) {
     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 = Q;
 
     P->inv = qsc_e_inverse;
diff --git a/src/projections/robin.cpp b/src/projections/robin.cpp
index 6a1405b6..4dfc306c 100644
--- a/src/projections/robin.cpp
+++ b/src/projections/robin.cpp
@@ -86,7 +86,7 @@ static PJ_XY robin_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwar
     dphi = fabs(lp.phi);
     i = isnan(lp.phi) ? -1 : lround(floor(dphi * C1 + 1e-15));
     if( i < 0 ){
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     if (i >= NODES) i = NODES;
@@ -109,7 +109,7 @@ static PJ_LP robin_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
     lp.phi = fabs(xy.y / FYC);
     if (lp.phi >= 1.) { /* simple pathologic cases */
         if (lp.phi > ONEEPS) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         }
         else {
@@ -120,7 +120,7 @@ static PJ_LP robin_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
         /* in Y space, reduce to table interval */
         long i = isnan(lp.phi) ? -1 : lround(floor(lp.phi * NODES));
         if( i < 0 || i >= NODES ) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return lp;
         }
         for (;;) {
@@ -138,12 +138,12 @@ static PJ_LP robin_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
                 break;
         }
         if( iters == 0 )
-            proj_context_errno_set( P->ctx, PJD_ERR_NON_CONVERGENT );
+            proj_context_errno_set( P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN );
         lp.phi = (5 * i + t) * DEG_TO_RAD;
         if (xy.y < 0.) lp.phi = -lp.phi;
         lp.lam /= V(X[i], t);
         if( fabs(lp.lam) > M_PI ) {
-            proj_errno_set(P, PJD_ERR_LAT_OR_LON_EXCEED_LIMIT);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             lp = proj_coord_error().lp;
         }
     }
diff --git a/src/projections/rouss.cpp b/src/projections/rouss.cpp
index 2eb13b3d..195b90b3 100644
--- a/src/projections/rouss.cpp
+++ b/src/projections/rouss.cpp
@@ -95,7 +95,7 @@ static PJ *destructor (PJ *P, int errlev) {
     if (static_cast<struct pj_opaque*>(P->opaque)->en)
         free (static_cast<struct pj_opaque*>(P->opaque)->en);
 
-    return pj_default_destructor (P, ENOMEM);
+    return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 }
 
 
@@ -104,11 +104,11 @@ PJ *PROJECTION(rouss) {
 
     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 = Q;
 
     if (!((Q->en = proj_mdist_ini(P->es))))
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     es2 = sin(P->phi0);
     Q->s0 = proj_mdist(P->phi0, es2, cos(P->phi0), Q->en);
diff --git a/src/projections/rpoly.cpp b/src/projections/rpoly.cpp
index e3f09c59..0c55954d 100644
--- a/src/projections/rpoly.cpp
+++ b/src/projections/rpoly.cpp
@@ -46,7 +46,7 @@ static PJ_XY rpoly_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwar
 PJ *PROJECTION(rpoly) {
     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 = Q;
 
     Q->phi1 = fabs(pj_param(P->ctx, P->params, "rlat_ts").f);
diff --git a/src/projections/sch.cpp b/src/projections/sch.cpp
index 359e8efc..d10ccf6c 100644
--- a/src/projections/sch.cpp
+++ b/src/projections/sch.cpp
@@ -131,7 +131,7 @@ static PJ *setup(PJ *P) { /* general initialization */
     // Pass a dummy ellipsoid definition that will be overridden just afterwards
     Q->cart = proj_create(P->ctx, "+proj=cart +a=1");
     if (Q->cart == nullptr)
-        return destructor(P, ENOMEM);
+        return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     /* inherit ellipsoid definition from P to Q->cart */
     pj_inherit_ellipsoid_def (P, Q->cart);
@@ -154,7 +154,7 @@ static PJ *setup(PJ *P) { /* general initialization */
     /* Set up local sphere at the given peg point */
     Q->cart_sph = proj_create(P->ctx, "+proj=cart +a=1");
     if (Q->cart_sph == nullptr)
-        return destructor(P, ENOMEM);
+        return destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     pj_calc_ellipsoid_params(Q->cart_sph, Q->rcurv, 0);
 
     /* Set up the transformation matrices */
@@ -186,7 +186,7 @@ static PJ *setup(PJ *P) { /* general initialization */
 PJ *PROJECTION(sch) {
     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 = Q;
     P->destructor = destructor;
 
@@ -196,21 +196,24 @@ PJ *PROJECTION(sch) {
     if (pj_param(P->ctx, P->params, "tplat_0").i)
         Q->plat = pj_param(P->ctx, P->params, "rplat_0").f;
     else {
-        return pj_default_destructor(P, PJD_ERR_FAILED_TO_FIND_PROJ);
+        proj_log_error(P, _("Missing parameter plat_0."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
     }
 
     /* Check if peg longitude was defined */
     if (pj_param(P->ctx, P->params, "tplon_0").i)
         Q->plon = pj_param(P->ctx, P->params, "rplon_0").f;
     else {
-        return pj_default_destructor(P, PJD_ERR_FAILED_TO_FIND_PROJ);
+        proj_log_error(P, _("Missing parameter plon_0."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
     }
 
     /* Check if peg heading is defined */
     if (pj_param(P->ctx, P->params, "tphdg_0").i)
         Q->phdg = pj_param(P->ctx, P->params, "rphdg_0").f;
     else {
-        return pj_default_destructor(P, PJD_ERR_FAILED_TO_FIND_PROJ);
+        proj_log_error(P, _("Missing parameter phdg_0."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
     }
 
 
diff --git a/src/projections/sconics.cpp b/src/projections/sconics.cpp
index c12b05a2..9084404c 100644
--- a/src/projections/sconics.cpp
+++ b/src/projections/sconics.cpp
@@ -48,15 +48,28 @@ static int phi12(PJ *P, double *del) {
     double p1, p2;
     int err = 0;
 
-    if (!pj_param(P->ctx, P->params, "tlat_1").i ||
-        !pj_param(P->ctx, P->params, "tlat_2").i) {
-        err = -41;
-    } else {
+    if (!pj_param(P->ctx, P->params, "tlat_1").i )
+    {
+        proj_log_error(P, _("Missing parameter: lat_1 should be specified"));
+        err = PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE;
+    }
+    else if ( !pj_param(P->ctx, P->params, "tlat_2").i)
+    {
+        proj_log_error(P, _("Missing parameter: lat_2 should be specified"));
+        err = PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE;
+    }
+    else
+    {
         p1 = pj_param(P->ctx, P->params, "rlat_1").f;
         p2 = pj_param(P->ctx, P->params, "rlat_2").f;
         *del = 0.5 * (p2 - p1);
-        static_cast<struct pj_opaque*>(P->opaque)->sig = 0.5 * (p2 + p1);
-        err = (fabs(*del) < EPS || fabs(static_cast<struct pj_opaque*>(P->opaque)->sig) < EPS) ? PJD_ERR_ABS_LAT1_EQ_ABS_LAT2 : 0;
+        const double sig = 0.5 * (p2 + p1);
+        static_cast<struct pj_opaque*>(P->opaque)->sig = sig;
+        err = (fabs(*del) < EPS || fabs(sig) < EPS) ? PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE : 0;
+        if( err )
+        {
+            proj_log_error(P, _("Illegal value for lat_1 and lat_2: |lat_1 - lat_2| and |lat_1 + lat_2| should be > 0"));
+        }
     }
     return err;
 }
@@ -119,7 +132,7 @@ static PJ *setup(PJ *P, enum Type type) {
     int err;
     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 = Q;
     Q->type = type;
 
@@ -167,8 +180,10 @@ static PJ *setup(PJ *P, enum Type type) {
         Q->c1 = 1./tan (Q->sig);
         del = P->phi0 - Q->sig;
         if (fabs (del) - EPS10 >= M_HALFPI)
-            return pj_default_destructor(P, PJD_ERR_LAT_0_HALF_PI_FROM_MEAN);
-
+        {
+            proj_log_error(P, _("Invalid value for lat_0/lat_1/lat_2: |lat_0 - 0.5 * (lat_1 + lat_2)| should be < 90°"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+        }
         Q->rho_0 = Q->c2 * (Q->c1 - tan (del));
         break;
 
diff --git a/src/projections/somerc.cpp b/src/projections/somerc.cpp
index a184500c..af8c0b17 100644
--- a/src/projections/somerc.cpp
+++ b/src/projections/somerc.cpp
@@ -62,7 +62,7 @@ static PJ_LP somerc_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, inver
         lp.phi = phip;
         lp.lam = lamp / Q->c;
     } else {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
     return (lp);
@@ -73,7 +73,7 @@ PJ *PROJECTION(somerc) {
     double cp, phip0, sp;
     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 = Q;
 
 
diff --git a/src/projections/stere.cpp b/src/projections/stere.cpp
index ad1caae2..4646db3d 100644
--- a/src/projections/stere.cpp
+++ b/src/projections/stere.cpp
@@ -60,7 +60,7 @@ static PJ_XY stere_e_forward (PJ_LP lp, PJ *P) {          /* Ellipsoidal, forwar
         const double denom = Q->cosX1 * (1. + Q->sinX1 * sinX +
            Q->cosX1 * cosX * coslam);
         if( denom == 0 ) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return proj_coord_error().xy;
         }
         A = Q->akm1 / denom;
@@ -117,7 +117,7 @@ static PJ_XY stere_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwar
         xy.y = 1. + sinph0 * sinphi + cosph0 * cosphi * coslam;
 oblcon:
         if (xy.y <= EPS10) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         xy.y = Q->akm1 / xy.y;
@@ -131,7 +131,7 @@ oblcon:
         /*-fallthrough*/
     case S_POLE:
         if (fabs (lp.phi - M_HALFPI) < TOL) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         xy.y = Q->akm1 * tan (M_FORTPI + .5 * lp.phi);
@@ -190,7 +190,7 @@ static PJ_LP stere_e_inverse (PJ_XY xy, PJ *P) {          /* Ellipsoidal, invers
         phi_l = lp.phi;
     }
 
-    proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+    proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
     return lp;
 }
 
@@ -304,7 +304,7 @@ static PJ *setup(PJ *P) {                   /* general initialization */
 PJ *PROJECTION(stere) {
     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 = Q;
 
     Q->phits = pj_param (P->ctx, P->params, "tlat_ts").i ?
@@ -317,13 +317,14 @@ PJ *PROJECTION(stere) {
 PJ *PROJECTION(ups) {
     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 = Q;
 
     /* International Ellipsoid */
     P->phi0 = pj_param(P->ctx, P->params, "bsouth").i ? - M_HALFPI: M_HALFPI;
     if (P->es == 0.0) {
-        return pj_default_destructor (P, PJD_ERR_ELLIPSOID_USE_REQUIRED);
+        proj_log_error(P, _("Invalid value for es: only ellipsoidal formulation supported"));
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
     P->k0 = .994;
     P->x0 = 2000000.;
diff --git a/src/projections/sterea.cpp b/src/projections/sterea.cpp
index 4dd22d2f..28fdea2e 100644
--- a/src/projections/sterea.cpp
+++ b/src/projections/sterea.cpp
@@ -55,7 +55,7 @@ static PJ_XY sterea_e_forward (PJ_LP lp, PJ *P) {          /* Ellipsoidal, forwa
     cosl = cos(lp.lam);
     const double denom = 1. + Q->sinc0 * sinc + Q->cosc0 * cosc * cosl;
     if( denom == 0.0 ) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return proj_coord_error().xy;
     }
     k = P->k0 * Q->R2 / denom;
@@ -103,12 +103,12 @@ PJ *PROJECTION(sterea) {
     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 = Q;
 
     Q->en = pj_gauss_ini(P->e, P->phi0, &(Q->phic0), &R);
     if (nullptr==Q->en)
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
     Q->sinc0 = sin (Q->phic0);
     Q->cosc0 = cos (Q->phic0);
diff --git a/src/projections/sts.cpp b/src/projections/sts.cpp
index 75190e85..cdd59044 100644
--- a/src/projections/sts.cpp
+++ b/src/projections/sts.cpp
@@ -72,7 +72,7 @@ static PJ *setup(PJ *P, double p, double q, int mode) {
 PJ *PROJECTION(fouc) {
     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 = Q;
     return setup(P, 2., 2., 1);
 }
@@ -82,7 +82,7 @@ PJ *PROJECTION(fouc) {
 PJ *PROJECTION(kav5) {
     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 = Q;
 
     return setup(P, 1.50488, 1.35439, 0);
@@ -93,7 +93,7 @@ PJ *PROJECTION(kav5) {
 PJ *PROJECTION(qua_aut) {
     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 = Q;
     return setup(P, 2., 2., 0);
 }
@@ -103,7 +103,7 @@ PJ *PROJECTION(qua_aut) {
 PJ *PROJECTION(mbt_s) {
     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 = Q;
     return setup(P, 1.48875, 1.36509, 0);
 }
diff --git a/src/projections/tcc.cpp b/src/projections/tcc.cpp
index 9413b567..c53bed05 100644
--- a/src/projections/tcc.cpp
+++ b/src/projections/tcc.cpp
@@ -16,7 +16,7 @@ static PJ_XY tcc_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forward
     const double b = cos (lp.phi) * sin (lp.lam);
     const double bt = 1. - b * b;
     if (bt < EPS10) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     xy.x = b / sqrt(bt);
diff --git a/src/projections/tmerc.cpp b/src/projections/tmerc.cpp
index 8f897061..3093e745 100644
--- a/src/projections/tmerc.cpp
+++ b/src/projections/tmerc.cpp
@@ -89,7 +89,7 @@ static PJ_XY approx_e_fwd (PJ_LP lp, PJ *P)
     if( lp.lam < -M_HALFPI || lp.lam > M_HALFPI ) {
         xy.x = HUGE_VAL;
         xy.y = HUGE_VAL;
-        proj_context_errno_set( P->ctx, PJD_ERR_LAT_OR_LON_EXCEED_LIMIT );
+        proj_context_errno_set( P->ctx, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN );
         return xy;
     }
 
@@ -123,7 +123,7 @@ static PJ_XY tmerc_spherical_fwd (PJ_LP lp, PJ *P) {
     cosphi = cos(lp.phi);
     b = cosphi * sin (lp.lam);
     if (fabs (fabs (b) - 1.) <= EPS10) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
 
@@ -138,7 +138,7 @@ static PJ_XY tmerc_spherical_fwd (PJ_LP lp, PJ *P) {
     }
     else if (b >= 1.) {
         if ((b - 1.) > EPS10) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         else xy.y = 0.;
@@ -190,7 +190,7 @@ static PJ_LP tmerc_spherical_inv (PJ_XY xy, PJ *P) {
 
     h = exp(xy.x / Q->esp);
     if( h == 0 ) {
-        proj_errno_set(P, PJD_ERR_INVALID_X_OR_Y);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return proj_coord_error().lp;
     }
     g = .5 * (h - 1. / h);
@@ -224,7 +224,7 @@ static PJ *setup_approx(PJ *P) {
 
     if (P->es != 0.0) {
         if (!(Q->en = pj_enfn(P->es)))
-            return pj_default_destructor(P, ENOMEM);
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
 
         Q->ml0 = pj_mlfn(P->phi0, sin(P->phi0), cos(P->phi0), Q->en);
         Q->esp = P->es / (1. - P->es);
@@ -587,7 +587,7 @@ static PJ *setup(PJ *P, TMercAlgo eAlg) {
 
     struct tmerc_data *Q = static_cast<struct tmerc_data*>(calloc (1, sizeof (struct tmerc_data)));
     if (nullptr==Q)
-        return pj_default_destructor (P, ENOMEM);
+        return pj_default_destructor (P, PROJ_ERR_INVALID_OP /*ENOMEM*/);
     P->opaque = Q;
 
     if( P->es == 0 )
@@ -701,14 +701,18 @@ PJ *PROJECTION(tmerc) {
 
     TMercAlgo algo;
     if( !getAlgoFromParams(P, algo) )
-        return pj_default_destructor(P, PJD_ERR_INVALID_ARG);
+    {
+        proj_log_error(P, _("Invalid value for algo"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     return setup(P, algo);
 }
 
 
 PJ *PROJECTION(etmerc) {
     if (P->es == 0.0) {
-        return pj_default_destructor(P, PJD_ERR_ELLIPSOID_USE_REQUIRED);
+        proj_log_error(P, _("Invalid value for eccentricity: it should not be zero"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
 
    return setup (P, TMercAlgo::PODER_ENGSAGER);
@@ -720,10 +724,12 @@ PJ *PROJECTION(etmerc) {
 PJ *PROJECTION(utm) {
     long zone;
     if (P->es == 0.0) {
-        return pj_default_destructor(P, PJD_ERR_ELLIPSOID_USE_REQUIRED);
+        proj_log_error(P, _("Invalid value for eccentricity: it should not be zero"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
     if (P->lam0 < -1000.0 || P->lam0 > 1000.0) {
-        return pj_default_destructor(P, PJD_ERR_INVALID_UTM_ZONE);
+        proj_log_error(P, _("Invalid value for lon_0"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
 
     P->y0 = pj_param (P->ctx, P->params, "bsouth").i ? 10000000. : 0.;
@@ -734,7 +740,8 @@ PJ *PROJECTION(utm) {
         if (zone > 0 && zone <= 60)
             --zone;
         else {
-            return pj_default_destructor(P, PJD_ERR_INVALID_UTM_ZONE);
+            proj_log_error(P, _("Invalid value for zone"));
+            return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
         }
     }
     else /* nearest central meridian input */
@@ -751,6 +758,9 @@ PJ *PROJECTION(utm) {
 
     TMercAlgo algo;
     if( !getAlgoFromParams(P, algo) )
-        return pj_default_destructor(P, PJD_ERR_INVALID_ARG);
+    {
+        proj_log_error(P, _("Invalid value for algo"));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
     return setup(P, algo);
 }
diff --git a/src/projections/tobmerc.cpp b/src/projections/tobmerc.cpp
index f05a9b6b..13633a91 100644
--- a/src/projections/tobmerc.cpp
+++ b/src/projections/tobmerc.cpp
@@ -20,7 +20,7 @@ static PJ_XY tobmerc_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forw
       // it's not even that large, merely 38.025...).  Even if the logic was
       // such that phi was strictly equal to pi/2, allowing xy.y = inf would be
       // a reasonable result.
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
 
diff --git a/src/projections/tpeqd.cpp b/src/projections/tpeqd.cpp
index 90efb395..d6d8e790 100644
--- a/src/projections/tpeqd.cpp
+++ b/src/projections/tpeqd.cpp
@@ -66,7 +66,7 @@ PJ *PROJECTION(tpeqd) {
     double lam_1, lam_2, phi_1, phi_2, A12;
     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 = Q;
 
 
@@ -77,7 +77,10 @@ PJ *PROJECTION(tpeqd) {
     lam_2 = pj_param(P->ctx, P->params, "rlon_2").f;
 
     if (phi_1 == phi_2 && lam_1 == lam_2)
-        return pj_default_destructor(P, PJD_ERR_CONTROL_POINT_NO_DIST);
+    {
+        proj_log_error(P, _("Invalid value for lat_1/lon_1/lat_2/lon_2: the 2 points should be distinct."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
 
     P->lam0  = adjlon (0.5 * (lam_1 + lam_2));
     Q->dlam2 = adjlon (lam_2 - lam_1);
@@ -92,7 +95,8 @@ PJ *PROJECTION(tpeqd) {
     Q->z02 = aacos(P->ctx, Q->sp1 * Q->sp2 + Q->cp1 * Q->cp2 * cos (Q->dlam2));
     if( Q->z02 == 0.0 ) {
         // Actually happens when both lat_1 = lat_2 and |lat_1| = 90
-        return pj_default_destructor(P, PJD_ERR_LAT_1_OR_2_ZERO_OR_90);
+        proj_log_error(P, _("Invalid value for lat_1 and lat_2: their absolute value should be < 90°."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
     Q->hz0 = .5 * Q->z02;
     A12 = atan2(Q->cp2 * sin (Q->dlam2),
diff --git a/src/projections/urm5.cpp b/src/projections/urm5.cpp
index c3021841..25db4391 100644
--- a/src/projections/urm5.cpp
+++ b/src/projections/urm5.cpp
@@ -32,22 +32,29 @@ PJ *PROJECTION(urm5) {
     double alpha, t;
     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 = Q;
 
-    if (pj_param(P->ctx, P->params, "tn").i) {
-        Q->n = pj_param(P->ctx, P->params, "dn").f;
-        if (Q->n <= 0. || Q->n > 1.)
-            return pj_default_destructor(P, PJD_ERR_N_OUT_OF_RANGE);
-    } else {
-            return pj_default_destructor(P, PJD_ERR_N_OUT_OF_RANGE);
+    if (!pj_param(P->ctx, P->params, "tn").i )
+    {
+        proj_log_error(P, _("Missing parameter n."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
     }
+
+    Q->n = pj_param(P->ctx, P->params, "dn").f;
+    if (Q->n <= 0. || Q->n > 1.)
+    {
+        proj_log_error(P, _("Invalid value for n: it should be in ]0,1] range."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
+    }
+
     Q->q3 = pj_param(P->ctx, P->params, "dq").f / 3.;
     alpha = pj_param(P->ctx, P->params, "ralpha").f;
     t = Q->n * sin (alpha);
     const double denom = sqrt (1. - t * t);
     if( denom == 0 ) {
-        return pj_default_destructor(P, PJD_ERR_LAT_0_OR_ALPHA_EQ_90);
+        proj_log_error(P, _("Invalid value for n / alpha: n * sin(|alpha|) should be < 1."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
     Q->m = cos (alpha) / denom;
     Q->rmn = 1. / (Q->m * Q->n);
diff --git a/src/projections/urmfps.cpp b/src/projections/urmfps.cpp
index 5d689f9f..36c2b7d1 100644
--- a/src/projections/urmfps.cpp
+++ b/src/projections/urmfps.cpp
@@ -49,16 +49,21 @@ static PJ *setup(PJ *P) {
 PJ *PROJECTION(urmfps) {
     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 = Q;
 
-    if (pj_param(P->ctx, P->params, "tn").i) {
-        static_cast<struct pj_opaque*>(P->opaque)->n = pj_param(P->ctx, P->params, "dn").f;
-        if (static_cast<struct pj_opaque*>(P->opaque)->n <= 0. || static_cast<struct pj_opaque*>(P->opaque)->n > 1.)
-            return pj_default_destructor(P, PJD_ERR_N_OUT_OF_RANGE);
-    } else {
-        return pj_default_destructor(P, PJD_ERR_N_OUT_OF_RANGE);
+    if (!pj_param(P->ctx, P->params, "tn").i )
+    {
+        proj_log_error(P, _("Missing parameter n."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_MISSING_ARG);
+    }
+
+    Q->n = pj_param(P->ctx, P->params, "dn").f;
+    if (Q->n <= 0. || Q->n > 1.)
+    {
+        proj_log_error(P, _("Invalid value for n: it should be in ]0,1] range."));
+        return pj_default_destructor(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);
     }
 
     return setup(P);
@@ -68,7 +73,7 @@ PJ *PROJECTION(urmfps) {
 PJ *PROJECTION(wag1) {
     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 = Q;
 
     static_cast<struct pj_opaque*>(P->opaque)->n = 0.8660254037844386467637231707;
diff --git a/src/projections/vandg.cpp b/src/projections/vandg.cpp
index 107fc3b9..603aa35c 100644
--- a/src/projections/vandg.cpp
+++ b/src/projections/vandg.cpp
@@ -19,7 +19,7 @@ static PJ_XY vandg_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwar
     // Comments tie this formulation to Snyder (1987), p. 241.
     p2 = fabs(lp.phi / M_HALFPI); // sin(theta) from (29-6)
     if ((p2 - TOL) > 1.) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return xy;
     }
     if (p2 > 1.)
@@ -56,7 +56,7 @@ static PJ_XY vandg_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwar
         // y from (29-2) has been expressed in terms of x here
         xy.y = 1. - xy.y * (xy.y + 2. * al);
         if (xy.y < -TOL) {
-            proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+            proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
             return xy;
         }
         if (xy.y < 0.)
@@ -95,7 +95,7 @@ static PJ_LP vandg_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
     d = C2_27 * c2 * c2 * c2 + (c0 * c0 - THIRD * c2 * c1) / c3; // d (29-14)
     const double al_mul_m = al * m;                              // a1*m1
     if( fabs(al_mul_m) < 1e-16 ) {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return proj_coord_error().lp;
     }
     d = 3. * d /al_mul_m;       // cos(3*theta1) (29-17)
@@ -109,7 +109,7 @@ static PJ_LP vandg_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
         lp.lam = fabs(xy.x) <= TOL ? 0. :
            .5 * (r - PISQ + (t <= 0. ? 0. : sqrt(t))) / xy.x;
     } else {
-        proj_errno_set(P, PJD_ERR_TOLERANCE_CONDITION);
+        proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_OUTSIDE_PROJECTION_DOMAIN);
         return lp;
     }
 
diff --git a/src/projections/vandg2.cpp b/src/projections/vandg2.cpp
index cd7e7b6c..d3067952 100644
--- a/src/projections/vandg2.cpp
+++ b/src/projections/vandg2.cpp
@@ -55,7 +55,7 @@ static PJ_XY vandg2_s_forward (PJ_LP lp, PJ *P) {           /* Spheroidal, forwa
 PJ *PROJECTION(vandg2) {
     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 = Q;
 
     Q->vdg3 = 0;
@@ -67,7 +67,7 @@ PJ *PROJECTION(vandg2) {
 PJ *PROJECTION(vandg3) {
     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 = Q;
 
     Q->vdg3 = 1;
diff --git a/src/projections/wag3.cpp b/src/projections/wag3.cpp
index ed3250ef..c7308c51 100644
--- a/src/projections/wag3.cpp
+++ b/src/projections/wag3.cpp
@@ -37,7 +37,7 @@ PJ *PROJECTION(wag3) {
 	double ts;
     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 = Q;
 
diff --git a/src/projections/wink1.cpp b/src/projections/wink1.cpp
index f4ffafe3..0e68c1ab 100644
--- a/src/projections/wink1.cpp
+++ b/src/projections/wink1.cpp
@@ -35,7 +35,7 @@ static PJ_LP wink1_s_inverse (PJ_XY xy, PJ *P) {           /* Spheroidal, invers
 PJ *PROJECTION(wink1) {
     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 = Q;
 
 	static_cast<struct pj_opaque*>(P->opaque)->cosphi1 = cos (pj_param(P->ctx, P->params, "rlat_ts").f);
diff --git a/src/projections/wink2.cpp b/src/projections/wink2.cpp
index b5b1e812..d3ba49d5 100644
--- a/src/projections/wink2.cpp
+++ b/src/projections/wink2.cpp
@@ -55,7 +55,7 @@ static PJ_LP wink2_s_inverse(PJ_XY xy, PJ *P)
 PJ *PROJECTION(wink2) {
     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 = Q;
 
     static_cast<struct pj_opaque*>(P->opaque)->cosphi1 = cos(pj_param(P->ctx, P->params, "rlat_1").f);