Remove use of aborts from shortest.c and route.c;

make sure return values from Proutespline and Pshortest are handled

diff --git a/lib/common/routespl.c b/lib/common/routespl.c
index 78b8ce56e807bac4123a796eaf1547347266e3ed..5b171bf120c020f191e7e3e996288c71524cd9a4 100644 (file)
--- a/lib/common/routespl.c
+++ b/lib/common/routespl.c
@@ -240,7 +240,7 @@ simpleSplineRoute (pointf tp, pointf hp, Ppoly_t poly, int* n_spl_pts,
     eps[0].y = tp.y;
     eps[1].x = hp.x;
     eps[1].y = hp.y;
-    if (Pshortestpath(&poly, eps, &pl) == -1)
+    if (Pshortestpath(&poly, eps, &pl) < 0)
         return NULL;
 
     if (polyline)
@@ -268,7 +268,7 @@ simpleSplineRoute (pointf tp, pointf hp, Ppoly_t poly, int* n_spl_pts,
        } else
 #endif
            evs[1].x = evs[1].y = 0;
-       if (Proutespline(edges, poly.pn, pl, evs, &spl) == -1)
+       if (Proutespline(edges, poly.pn, pl, evs, &spl) < 0)
             return NULL;
     }
 
@@ -483,7 +483,7 @@ static pointf *_routesplines(path * pp, int *npoints, int polyline)
     poly.ps = polypoints, poly.pn = pi;
     eps[0].x = pp->start.p.x, eps[0].y = pp->start.p.y;
     eps[1].x = pp->end.p.x, eps[1].y = pp->end.p.y;
-    if (Pshortestpath(&poly, eps, &pl) == -1) {
+    if (Pshortestpath(&poly, eps, &pl) < 0) {
        agerr(AGERR, "in routesplines, Pshortestpath failed\n");
        longjmp (jbuf, 1);
     }
@@ -517,7 +517,7 @@ static pointf *_routesplines(path * pp, int *npoints, int polyline)
        } else
            evs[1].x = evs[1].y = 0;
 
-       if (Proutespline(edges, poly.pn, pl, evs, &spl) == -1) {
+       if (Proutespline(edges, poly.pn, pl, evs, &spl) < 0) {
            agerr(AGERR, "in routesplines, Proutespline failed\n");
            longjmp (jbuf, 1);
        }

diff --git a/lib/fdpgen/clusteredges.c b/lib/fdpgen/clusteredges.c
index 8953b610d63ee2ba51a3ce37fe31e03c85cc6e42..487903e8ddaee0e9ad7a3d1d143a53ca224779b1 100644 (file)
--- a/lib/fdpgen/clusteredges.c
+++ b/lib/fdpgen/clusteredges.c
@@ -275,8 +275,14 @@ int compoundEdges(graph_t * g, expand_t* pm, int edgetype)
                makeSelfArcs(P, e, GD_nodesep(g));
            } else if (ED_count(e)) {
                objl = objectList(e, pm);
-               if (Plegal_arrangement(objl->obs, objl->cnt))
+               if (Plegal_arrangement(objl->obs, objl->cnt)) {
                    vconfig = Pobsopen(objl->obs, objl->cnt);
+                   if (!vconfig) {
+                       agerr(AGWARN, "compoundEdges: could not construct obstacles - falling back to straight line edges\n");
+                       rv = 1;
+                       continue;
+                   }
+               }
                else {
                    if (Verbose)
                        fprintf(stderr,

diff --git a/lib/neatogen/multispline.c b/lib/neatogen/multispline.c
index 7d0bdc65fc872b915162da4e89674e7786cb4b9c..cfe62e6a3e6ec6143f15563dfaddf95f726a2c9b 100644 (file)
--- a/lib/neatogen/multispline.c
+++ b/lib/neatogen/multispline.c
@@ -859,7 +859,7 @@ genroute(graph_t* g, tripoly_t * trip, int s, int t, edge_t * e, int doPolyline)
 {
     pointf eps[2];
     Pvector_t evs[2];
-    pointf **cpts;             /* lists of control points */
+    pointf **cpts = NULL;              /* lists of control points */
     Ppoly_t poly;
     Ppolyline_t pl, spl;
     int i, j;
@@ -868,14 +868,21 @@ genroute(graph_t* g, tripoly_t * trip, int s, int t, edge_t * e, int doPolyline)
     int pn;
     int mult = ED_count(e);
     node_t* head = aghead(e);
+    int rv = 0;
 
+    poly.ps = NULL;
+    pl.pn = 0;
     eps[0].x = trip->poly.ps[s].x, eps[0].y = trip->poly.ps[s].y;
     eps[1].x = trip->poly.ps[t].x, eps[1].y = trip->poly.ps[t].y;
-    Pshortestpath(&(trip->poly), eps, &pl);
+    if (Pshortestpath(&(trip->poly), eps, &pl) < 0) {
+       agerr(AGWARN, "Could not create control points for multiple spline for edge (%s,%s)\n", agnameof(agtail(e)), agnameof(aghead(e)));
+       rv = 1;
+       goto finish;
+    }
 
     if (pl.pn == 2) {
        makeStraightEdge(agraphof(head), e, doPolyline);
-       return 0;
+       goto finish;
     }
 
     evs[0].x = evs[0].y = 0;
@@ -888,7 +895,11 @@ genroute(graph_t* g, tripoly_t * trip, int s, int t, edge_t * e, int doPolyline)
            medges[j].b = poly.ps[(j + 1) % poly.pn];
        }
        tweakPath (poly, s, t, pl);
-       Proutespline(medges, poly.pn, pl, evs, &spl);
+       if (Proutespline(medges, poly.pn, pl, evs, &spl) < 0) {
+           agerr(AGWARN, "Could not create control points for multiple spline for edge (%s,%s)\n", agnameof(agtail(e)), agnameof(aghead(e)));
+           rv = 1;
+           goto finish;
+       }
        finishEdge (g, e, spl, aghead(e) != head, eps[0], eps[1]);
        free(medges);
 
@@ -903,7 +914,8 @@ genroute(graph_t* g, tripoly_t * trip, int s, int t, edge_t * e, int doPolyline)
            mkCtrlPts(t, mult+1, pl.ps[i], pl.ps[i + 1], pl.ps[i + 2], trip);
        if (!cpts[i]) {
            agerr(AGWARN, "Could not create control points for multiple spline for edge (%s,%s)\n", agnameof(agtail(e)), agnameof(aghead(e)));
-           return 1;
+           rv = 1;
+           goto finish;
        }
     }
 
@@ -919,7 +931,11 @@ genroute(graph_t* g, tripoly_t * trip, int s, int t, edge_t * e, int doPolyline)
        for (j = 1; j < pl.pn - 1; j++) {
            poly.ps[pn - j] = cpts[j - 1][i + 1];
        }
-       Pshortestpath(&poly, eps, &mmpl);
+       if (Pshortestpath(&poly, eps, &mmpl) < 0) {
+           agerr(AGWARN, "Could not create control points for multiple spline for edge (%s,%s)\n", agnameof(agtail(e)), agnameof(aghead(e)));
+           rv = 1;
+           goto finish;
+       }
 
        if (doPolyline) {
            make_polyline (mmpl, &spl);
@@ -930,19 +946,27 @@ genroute(graph_t* g, tripoly_t * trip, int s, int t, edge_t * e, int doPolyline)
                medges[j].b = poly.ps[(j + 1) % poly.pn];
            }
            tweakPath (poly, 0, pl.pn-1, mmpl);
-           Proutespline(medges, poly.pn, mmpl, evs, &spl);
+           if (Proutespline(medges, poly.pn, mmpl, evs, &spl) < 0) {
+               agerr(AGWARN, "Could not create control points for multiple spline for edge (%s,%s)\n", 
+                   agnameof(agtail(e)), agnameof(aghead(e)));
+               rv = 1;
+               goto finish;
+           }
        }
        finishEdge (g, e, spl, aghead(e) != head, eps[0], eps[1]);
 
        e = ED_to_virt(e);
     }
 
-    for (i = 0; i < pl.pn - 2; i++)
-       free(cpts[i]);
-    free(cpts);
+finish :
+    if (cpts) {
+       for (i = 0; i < pl.pn - 2; i++)
+           free(cpts[i]);
+       free(cpts);
+    }
     free(medges);
     free(poly.ps);
-    return 0;
+    return rv;
 }
 
 #define NSMALL -0.0000000001

diff --git a/lib/neatogen/neatosplines.c b/lib/neatogen/neatosplines.c
index 2210db4441105a2e9ddae3f2b2c323c1db824b6f..0b5b37d8a19d88c0a54fdb9d2a4d3060b3439c00 100644 (file)
--- a/lib/neatogen/neatosplines.c
+++ b/lib/neatogen/neatosplines.c
@@ -567,7 +567,10 @@ void makeSpline(graph_t* g, edge_t * e, Ppoly_t ** obs, int npoly, boolean chkPt
     make_barriers(obs, npoly, pp, qp, &barriers, &n_barriers);
     slopes[0].x = slopes[0].y = 0.0;
     slopes[1].x = slopes[1].y = 0.0;
-    Proutespline(barriers, n_barriers, line, slopes, &spline);
+    if (Proutespline(barriers, n_barriers, line, slopes, &spline) < 0) {
+       agerr (AGERR, "makeSpline: failed to make spline edge (%s,%s)\n", agnameof(agtail(e)), agnameof(aghead(e)));
+       return;
+    }
 
     /* north why did you ever use int coords */
     if (Verbose > 1)

diff --git a/lib/pathplan/route.c b/lib/pathplan/route.c
index 8538e6fab2bdae50e9cd2048692fb5d4d214aa11..70ae5fa5d1288b6c44e029f37c5c9b3758aa7584 100644 (file)
--- a/lib/pathplan/route.c
+++ b/lib/pathplan/route.c
@@ -14,6 +14,7 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <setjmp.h>
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>
 #endif
@@ -57,6 +58,8 @@ typedef struct elist_t {
     struct elist_t *next, *prev;
 } elist_t;
 
+static jmp_buf jbuf;
+
 #if 0
 static p2e_t *p2es;
 static int p2en;
@@ -103,6 +106,12 @@ static void listreplace(Pedge_t *, Pedge_t *);
 static void listinsert(Pedge_t *, Ppoint_t);
 #endif
 
+/* Proutespline:
+ * Given a set of edgen line segments edges as obstacles, a template
+ * path input, and endpoint vectors evs, construct a spline fitting the
+ * input and endpoing vectors, and return in output.
+ * Return 0 on success and -1 on failure, including no memory.
+ */
 int Proutespline(Pedge_t * edges, int edgen, Ppolyline_t input,
                 Ppoint_t * evs, Ppolyline_t * output)
 {
@@ -124,7 +133,7 @@ int Proutespline(Pedge_t * edges, int edgen, Ppolyline_t input,
 #if 0
     if (!(p2es = (p2e_t *) malloc(sizeof(p2e_t) * (p2en = edgen * 2)))) {
        prerror("cannot malloc p2es");
-       abort();
+       return -1;
     }
     for (ei = 0, p2ei = 0; ei < edgen; ei++) {
        if (edges[ei].a.x == edges[ei].b.x
@@ -159,6 +168,9 @@ int Proutespline(Pedge_t * edges, int edgen, Ppolyline_t input,
        }
     }
 #endif
+    if (setjmp(jbuf))
+       return -1;
+
     /* generate the splines */
     evs[0] = normv(evs[0]);
     evs[1] = normv(evs[1]);
@@ -517,13 +529,13 @@ static void growops(int newopn)
     if (!ops) {
        if (!(ops = (Ppoint_t *) malloc(POINTSIZE * newopn))) {
            prerror("cannot malloc ops");
-           abort();
+           longjmp(jbuf,1);
        }
     } else {
        if (!(ops = (Ppoint_t *) realloc((void *) ops,
                                         POINTSIZE * newopn))) {
            prerror("cannot realloc ops");
-           abort();
+           longjmp(jbuf,1);
        }
     }
     opn = newopn;

diff --git a/lib/pathplan/shortest.c b/lib/pathplan/shortest.c
index 922d079b9833cfe2c2f30d8ff26082d56a7923fa..fb47d68cded7e19a2834296b0cc7f81822c61066 100644 (file)
--- a/lib/pathplan/shortest.c
+++ b/lib/pathplan/shortest.c
@@ -14,6 +14,7 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <setjmp.h>
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>
 #endif
@@ -69,6 +70,7 @@ typedef struct deque_t {
     int pnlpn, fpnlpi, lpnlpi, apex;
 } deque_t;
 
+static jmp_buf jbuf;
 static pointnlink_t *pnls, **pnlps;
 static int pnln, pnll;
 
@@ -100,6 +102,11 @@ static void growtris(int);
 static void growdq(int);
 static void growops(int);
 
+/* Pshortestpath:
+ * Find a shortest path contained in the polygon polyp going between the
+ * points supplied in eps. The resulting polyline is stored in output.
+ * Return 0 on success, -1 on bad input, -2 on memory allocation problem. 
+ */
 int Pshortestpath(Ppoly_t * polyp, Ppoint_t * eps, Ppolyline_t * output)
 {
     int pi, minpi;
@@ -114,6 +121,8 @@ int Pshortestpath(Ppoly_t * polyp, Ppoint_t * eps, Ppolyline_t * output)
     int pnli;
 #endif
 
+    if (setjmp(jbuf))
+       return -2;
     /* make space */
     growpnls(polyp->pn);
     pnll = 0;
@@ -512,23 +521,23 @@ static void growpnls(int newpnln)
     if (!pnls) {
        if (!(pnls = (pointnlink_t *) malloc(POINTNLINKSIZE * newpnln))) {
            prerror("cannot malloc pnls");
-           abort();
+           longjmp(jbuf,1);
        }
        if (!(pnlps = (pointnlink_t **) malloc(POINTNLINKPSIZE * newpnln))) {
            prerror("cannot malloc pnlps");
-           abort();
+           longjmp(jbuf,1);
        }
     } else {
        if (!(pnls = (pointnlink_t *) realloc((void *) pnls,
                                              POINTNLINKSIZE * newpnln))) {
            prerror("cannot realloc pnls");
-           abort();
+           longjmp(jbuf,1);
        }
        if (!(pnlps = (pointnlink_t **) realloc((void *) pnlps,
                                                POINTNLINKPSIZE *
                                                newpnln))) {
            prerror("cannot realloc pnlps");
-           abort();
+           longjmp(jbuf,1);
        }
     }
     pnln = newpnln;
@@ -541,13 +550,13 @@ static void growtris(int newtrin)
     if (!tris) {
        if (!(tris = (triangle_t *) malloc(TRIANGLESIZE * newtrin))) {
            prerror("cannot malloc tris");
-           abort();
+           longjmp(jbuf,1);
        }
     } else {
        if (!(tris = (triangle_t *) realloc((void *) tris,
                                            TRIANGLESIZE * newtrin))) {
            prerror("cannot realloc tris");
-           abort();
+           longjmp(jbuf,1);
        }
     }
     trin = newtrin;
@@ -562,14 +571,14 @@ static void growdq(int newdqn)
            (dq.pnlps =
             (pointnlink_t **) malloc(POINTNLINKPSIZE * newdqn))) {
            prerror("cannot malloc dq.pnls");
-           abort();
+           longjmp(jbuf,1);
        }
     } else {
        if (!(dq.pnlps = (pointnlink_t **) realloc((void *) dq.pnlps,
                                                   POINTNLINKPSIZE *
                                                   newdqn))) {
            prerror("cannot realloc dq.pnls");
-           abort();
+           longjmp(jbuf,1);
        }
     }
     dq.pnlpn = newdqn;
@@ -582,13 +591,13 @@ static void growops(int newopn)
     if (!ops) {
        if (!(ops = (Ppoint_t *) malloc(POINTSIZE * newopn))) {
            prerror("cannot malloc ops");
-           abort();
+           longjmp(jbuf,1);
        }
     } else {
        if (!(ops = (Ppoint_t *) realloc((void *) ops,
                                         POINTSIZE * newopn))) {
            prerror("cannot realloc ops");
-           abort();
+           longjmp(jbuf,1);
        }
     }
     opn = newopn;