change suspicious loop exit condition in nad_cvt (#634)

* change suspicious loop exit condition in nad_cvt

* touch up nad_cvt.c

* ...and remove tabs

1 files changed, 62 insertions, 60 deletions

diff --git a/src/nad_cvt.c b/src/nad_cvt.c
index f48f9e0d..c913511f 100644
--- a/src/nad_cvt.c
+++ b/src/nad_cvt.c
@@ -1,68 +1,70 @@
 #define PJ_LIB__
-#include <projects.h>
-#define MAX_TRY 9
+#include "projects.h"
+#define MAX_ITERATIONS 10
 #define TOL 1e-12
-	LP
-nad_cvt(LP in, int inverse, struct CTABLE *ct) {
-	LP t, tb;
 
-	if (in.lam == HUGE_VAL)
-		return in;
-	/* normalize input to ll origin */
-	tb = in;
-	tb.lam -= ct->ll.lam;
-	tb.phi -= ct->ll.phi;
-	tb.lam = adjlon(tb.lam - M_PI) + M_PI;
-	t = nad_intr(tb, ct);
-	if (inverse) {
-		LP del, dif;
-		int i = MAX_TRY;
+LP nad_cvt(LP in, int inverse, struct CTABLE *ct) {
+    LP t, tb,del, dif;
+    int i = MAX_ITERATIONS;
+    const double toltol = TOL*TOL;
 
-		if (t.lam == HUGE_VAL) return t;
-		t.lam = tb.lam + t.lam;
-		t.phi = tb.phi - t.phi;
+    if (in.lam == HUGE_VAL)
+        return in;
 
-		do {
-			del = nad_intr(t, ct);
+    /* normalize input to ll origin */
+    tb = in;
+    tb.lam -= ct->ll.lam;
+    tb.phi -= ct->ll.phi;
+    tb.lam = adjlon (tb.lam - M_PI) + M_PI;
 
-                        /* This case used to return failure, but I have
-                           changed it to return the first order approximation
-                           of the inverse shift.  This avoids cases where the
-                           grid shift *into* this grid came from another grid.
-                           While we aren't returning optimally correct results
-                           I feel a close result in this case is better than
-                           no result.  NFW
-                           To demonstrate use -112.5839956 49.4914451 against
-                           the NTv2 grid shift file from Canada. */
-			if (del.lam == HUGE_VAL) 
-                        {
-                            if( getenv( "PROJ_DEBUG" ) != NULL )
-                                fprintf( stderr, 
-                                         "Inverse grid shift iteration failed, presumably at grid edge.\n"
-                                         "Using first approximation.\n" );
-                            /* return del */;
-                            break;
-                        }
+    t = nad_intr (tb, ct);
+    if (t.lam == HUGE_VAL)
+        return t;
 
-			t.lam -= dif.lam = t.lam - del.lam - tb.lam;
-			t.phi -= dif.phi = t.phi + del.phi - tb.phi;
-		} while (i-- && fabs(dif.lam) > TOL && fabs(dif.phi) > TOL);
-		if (i < 0) {
-                    if( getenv( "PROJ_DEBUG" ) != NULL )
-                        fprintf( stderr, 
-                                 "Inverse grid shift iterator failed to converge.\n" );
-                    t.lam = t.phi = HUGE_VAL;
-                    return t;
-		}
-		in.lam = adjlon(t.lam + ct->ll.lam);
-		in.phi = t.phi + ct->ll.phi;
-	} else {
-		if (t.lam == HUGE_VAL)
-			in = t;
-		else {
-			in.lam -= t.lam;
-			in.phi += t.phi;
-		}
-	}
-	return in;
+    if (!inverse) {
+        in.lam -= t.lam;
+        in.phi += t.phi;
+        return in;
+    }
+
+    t.lam = tb.lam + t.lam;
+    t.phi = tb.phi - t.phi;
+
+    do {
+        del = nad_intr(t, ct);
+
+        /* This case used to return failure, but I have
+           changed it to return the first order approximation
+           of the inverse shift.  This avoids cases where the
+           grid shift *into* this grid came from another grid.
+           While we aren't returning optimally correct results
+           I feel a close result in this case is better than
+           no result.  NFW
+           To demonstrate use -112.5839956 49.4914451 against
+           the NTv2 grid shift file from Canada. */
+        if (del.lam == HUGE_VAL)
+            break;
+
+        dif.lam = t.lam - del.lam - tb.lam;
+           dif.phi = t.phi + del.phi - tb.phi;
+        t.lam -= dif.lam;
+        t.phi -= dif.phi;
+
+    } while (--i && (dif.lam*dif.lam + dif.phi*dif.phi > toltol)); /* prob. slightly faster than hypot() */
+
+    if (i==0) {
+        /* If we had access to a context, this should go through pj_log, and we should set ctx->errno */
+        if (getenv ("PROJ_DEBUG"))
+            fprintf( stderr, "Inverse grid shift iterator failed to converge.\n" );
+        t.lam = t.phi = HUGE_VAL;
+        return t;
+    }
+
+    /* and again: pj_log and ctx->errno */
+    if (del.lam==HUGE_VAL && getenv ("PROJ_DEBUG"))
+        fprintf (stderr, "Inverse grid shift iteration failed, presumably at grid edge.\nUsing first approximation.\n");
+
+    in.lam = adjlon (t.lam + ct->ll.lam);
+    in.phi = t.phi + ct->ll.phi;
+    return in;
 }