test parsepath

src/utils/SkParsePath.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkParse.h"
 #include "SkParsePath.h"
 
@@ skipping 22 matching lines @@
 }
 
 static const char* skip_ws(const char str[]) {
     SkASSERT(str);
     while (is_ws(*str))
         str++;
     return str;
 }
 
 static const char* skip_sep(const char str[]) {
-    SkASSERT(str);
+    if (!str) {
+        return nullptr;
+    }
     while (is_sep(*str))
         str++;
     return str;
 }
 
 static const char* find_points(const char str[], SkPoint value[], int count,
                                bool isRelative, SkPoint* relative) {
     str = SkParse::FindScalars(str, &value[0].fX, count * 2);
     if (isRelative) {
         for (int index = 0; index < count; index++) {
             value[index].fX += relative->fX;
             value[index].fY += relative->fY;
         }
     }
     return str;
 }
 
 static const char* find_scalar(const char str[], SkScalar* value,
                                bool isRelative, SkScalar relative) {
     str = SkParse::FindScalar(str, value);
+    if (!str) {
+        return nullptr;
+    }
     if (isRelative) {
         *value += relative;
     }
     str = skip_sep(str);
     return str;
 }
 
 bool SkParsePath::FromSVGString(const char data[], SkPath* result) {
     SkPath path;
-    SkPoint f = {0, 0};
+    SkPoint first = {0, 0};
     SkPoint c = {0, 0};
     SkPoint lastc = {0, 0};
     SkPoint points[3];
     char op = '\0';
     char previousOp = '\0';
     bool relative = false;
     for (;;) {
         if (!data) {
             // Truncated data
             return false;
@@ skipping 16 matching lines @@
                 op = (char) to_upper(op);
                 relative = true;
             }
             data++;
             data = skip_sep(data);
         }
         switch (op) {
             case 'M':
                 data = find_points(data, points, 1, relative, &c);
                 path.moveTo(points[0]);
+                previousOp = '\0';
                 op = 'L';
                 c = points[0];
                 break;
             case 'L':
                 data = find_points(data, points, 1, relative, &c);
                 path.lineTo(points[0]);
                 c = points[0];
                 break;
             case 'H': {
                 SkScalar x;
@@ skipping 20 matching lines @@
             cubicCommon:
                 path.cubicTo(points[0], points[1], points[2]);
                 lastc = points[1];
                 c = points[2];
                 break;
             case 'Q':  // Quadratic Bezier Curve
                 data = find_points(data, points, 2, relative, &c);
                 goto quadraticCommon;
             case 'T':
                 data = find_points(data, &points[1], 1, relative, &c);
-                points[0] = points[1];
+                points[0] = c;
                 if (previousOp == 'Q' || previousOp == 'T') {
-                    points[0].fX = c.fX * 2 - lastc.fX;
-                    points[0].fY = c.fY * 2 - lastc.fY;
+                    points[0].fX -= lastc.fX - c.fX;
+                    points[0].fY -= lastc.fY - c.fY;
                 }
             quadraticCommon:
                 path.quadTo(points[0], points[1]);
                 lastc = points[0];
                 c = points[1];
                 break;
             case 'A': {
                 SkPoint radii;
-                data = find_points(data, &radii, 1, false, nullptr);
                 SkScalar angle, largeArc, sweep;
-                data = find_scalar(data, &angle, false, 0);
-                data = find_scalar(data, &largeArc, false, 0);
-                data = find_scalar(data, &sweep, false, 0);
-                data = find_points(data, &points[0], 1, relative, &c);
-                path.arcTo(radii, angle, (SkPath::ArcSize) SkToBool(largeArc),
-                        (SkPath::Direction) !SkToBool(sweep), points[0]);
+                if ((data = find_points(data, &radii, 1, false, nullptr))
+                        && (data = skip_sep(data))
+                        && (data = find_scalar(data, &angle, false, 0))
+                        && (data = skip_sep(data))
+                        && (data = find_scalar(data, &largeArc, false, 0))
+                        && (data = skip_sep(data))
+                        && (data = find_scalar(data, &sweep, false, 0))
+                        && (data = skip_sep(data))
+                        && (data = find_points(data, &points[0], 1, relative, &c))) {
+                    path.arcTo(radii, angle, (SkPath::ArcSize) SkToBool(largeArc),
+                            (SkPath::Direction) !SkToBool(sweep), points[0]);
+                    path.getLastPt(&c);
+                }
                 } break;
             case 'Z':
                 path.close();
-#if 0   // !!! still a bug?
-                if (fPath.isEmpty() && (f.fX != 0 || f.fY != 0)) {
-                    c.fX -= SkScalar.Epsilon;   // !!! enough?
-                    fPath.moveTo(c);
-                    fPath.lineTo(f);
-                    fPath.close();
-                }
-#endif
-                c = f;
-                op = '\0';
+                c = first;
                 break;
             case '~': {
                 SkPoint args[2];
                 data = find_points(data, args, 2, false, nullptr);
                 path.moveTo(args[0].fX, args[0].fY);
                 path.lineTo(args[1].fX, args[1].fY);
             } break;
             default:
                 return false;
         }
         if (previousOp == 0) {
-            f = c;
+            first = c;
         }
         previousOp = op;
     }
     // we're good, go ahead and swap in the result
     result->swap(path);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 53 matching lines @@
             case SkPath::kClose_Verb:
                 stream.write("Z", 1);
                 break;
             case SkPath::kDone_Verb:
                 str->resize(stream.getOffset());
                 stream.copyTo(str->writable_str());
             return;
         }
     }
 }