1 /*
2  * Copyright 2011 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 #include "include/utils/SkParse.h"
8 #include "include/utils/SkParsePath.h"
9 
is_between(int c, int min, int max)10 static inline bool is_between(int c, int min, int max) {
11     return (unsigned)(c - min) <= (unsigned)(max - min);
12 }
13 
is_ws(int c)14 static inline bool is_ws(int c) {
15     return is_between(c, 1, 32);
16 }
17 
is_digit(int c)18 static inline bool is_digit(int c) {
19     return is_between(c, '0', '9');
20 }
21 
is_sep(int c)22 static inline bool is_sep(int c) {
23     return is_ws(c) || c == ',';
24 }
25 
is_lower(int c)26 static inline bool is_lower(int c) {
27     return is_between(c, 'a', 'z');
28 }
29 
to_upper(int c)30 static inline int to_upper(int c) {
31     return c - 'a' + 'A';
32 }
33 
skip_ws(const char str[])34 static const char* skip_ws(const char str[]) {
35     SkASSERT(str);
36     while (is_ws(*str))
37         str++;
38     return str;
39 }
40 
skip_sep(const char str[])41 static const char* skip_sep(const char str[]) {
42     if (!str) {
43         return nullptr;
44     }
45     while (is_sep(*str))
46         str++;
47     return str;
48 }
49 
find_points(const char str[], SkPoint value[], int count, bool isRelative, SkPoint* relative)50 static const char* find_points(const char str[], SkPoint value[], int count,
51                                bool isRelative, SkPoint* relative) {
52     str = SkParse::FindScalars(str, &value[0].fX, count * 2);
53     if (isRelative) {
54         for (int index = 0; index < count; index++) {
55             value[index].fX += relative->fX;
56             value[index].fY += relative->fY;
57         }
58     }
59     return str;
60 }
61 
find_scalar(const char str[], SkScalar* value, bool isRelative, SkScalar relative)62 static const char* find_scalar(const char str[], SkScalar* value,
63                                bool isRelative, SkScalar relative) {
64     str = SkParse::FindScalar(str, value);
65     if (!str) {
66         return nullptr;
67     }
68     if (isRelative) {
69         *value += relative;
70     }
71     str = skip_sep(str);
72     return str;
73 }
74 
75 // https://www.w3.org/TR/SVG11/paths.html#PathDataBNF
76 //
77 // flag:
78 //    "0" | "1"
find_flag(const char str[], bool* value)79 static const char* find_flag(const char str[], bool* value) {
80     if (!str) {
81         return nullptr;
82     }
83     if (str[0] != '1' && str[0] != '0') {
84         return nullptr;
85     }
86     *value = str[0] != '0';
87     str = skip_sep(str + 1);
88     return str;
89 }
90 
FromSVGString(const char data[], SkPath* result)91 bool SkParsePath::FromSVGString(const char data[], SkPath* result) {
92     SkPath path;
93     SkPoint first = {0, 0};
94     SkPoint c = {0, 0};
95     SkPoint lastc = {0, 0};
96     SkPoint points[3];
97     char op = '\0';
98     char previousOp = '\0';
99     bool relative = false;
100     for (;;) {
101         if (!data) {
102             // Truncated data
103             return false;
104         }
105         data = skip_ws(data);
106         if (data[0] == '\0') {
107             break;
108         }
109         char ch = data[0];
110         if (is_digit(ch) || ch == '-' || ch == '+' || ch == '.') {
111             if (op == '\0' || op == 'Z') {
112                 return false;
113             }
114         } else if (is_sep(ch)) {
115             data = skip_sep(data);
116         } else {
117             op = ch;
118             relative = false;
119             if (is_lower(op)) {
120                 op = (char) to_upper(op);
121                 relative = true;
122             }
123             data++;
124             data = skip_sep(data);
125         }
126         switch (op) {
127             case 'M':
128                 data = find_points(data, points, 1, relative, &c);
129                 path.moveTo(points[0]);
130                 previousOp = '\0';
131                 op = 'L';
132                 c = points[0];
133                 break;
134             case 'L':
135                 data = find_points(data, points, 1, relative, &c);
136                 path.lineTo(points[0]);
137                 c = points[0];
138                 break;
139             case 'H': {
140                 SkScalar x;
141                 data = find_scalar(data, &x, relative, c.fX);
142                 path.lineTo(x, c.fY);
143                 c.fX = x;
144             } break;
145             case 'V': {
146                 SkScalar y;
147                 data = find_scalar(data, &y, relative, c.fY);
148                 path.lineTo(c.fX, y);
149                 c.fY = y;
150             } break;
151             case 'C':
152                 data = find_points(data, points, 3, relative, &c);
153                 goto cubicCommon;
154             case 'S':
155                 data = find_points(data, &points[1], 2, relative, &c);
156                 points[0] = c;
157                 if (previousOp == 'C' || previousOp == 'S') {
158                     points[0].fX -= lastc.fX - c.fX;
159                     points[0].fY -= lastc.fY - c.fY;
160                 }
161             cubicCommon:
162                 path.cubicTo(points[0], points[1], points[2]);
163                 lastc = points[1];
164                 c = points[2];
165                 break;
166             case 'Q':  // Quadratic Bezier Curve
167                 data = find_points(data, points, 2, relative, &c);
168                 goto quadraticCommon;
169             case 'T':
170                 data = find_points(data, &points[1], 1, relative, &c);
171                 points[0] = c;
172                 if (previousOp == 'Q' || previousOp == 'T') {
173                     points[0].fX -= lastc.fX - c.fX;
174                     points[0].fY -= lastc.fY - c.fY;
175                 }
176             quadraticCommon:
177                 path.quadTo(points[0], points[1]);
178                 lastc = points[0];
179                 c = points[1];
180                 break;
181             case 'A': {
182                 SkPoint radii;
183                 SkScalar angle;
184                 bool largeArc, sweep;
185                 if ((data = find_points(data, &radii, 1, false, nullptr))
186                         && (data = skip_sep(data))
187                         && (data = find_scalar(data, &angle, false, 0))
188                         && (data = skip_sep(data))
189                         && (data = find_flag(data, &largeArc))
190                         && (data = skip_sep(data))
191                         && (data = find_flag(data, &sweep))
192                         && (data = skip_sep(data))
193                         && (data = find_points(data, &points[0], 1, relative, &c))) {
194                     path.arcTo(radii, angle, (SkPath::ArcSize) largeArc,
195                             (SkPathDirection) !sweep, points[0]);
196                     path.getLastPt(&c);
197                 }
198                 } break;
199             case 'Z':
200                 path.close();
201                 c = first;
202                 break;
203             case '~': {
204                 SkPoint args[2];
205                 data = find_points(data, args, 2, false, nullptr);
206                 path.moveTo(args[0].fX, args[0].fY);
207                 path.lineTo(args[1].fX, args[1].fY);
208             } break;
209             default:
210                 return false;
211         }
212         if (previousOp == 0) {
213             first = c;
214         }
215         previousOp = op;
216     }
217     // we're good, go ahead and swap in the result
218     result->swap(path);
219     return true;
220 }
221 
222 ///////////////////////////////////////////////////////////////////////////////
223 
224 #include "include/core/SkStream.h"
225 #include "include/core/SkString.h"
226 #include "src/core/SkGeometry.h"
227 
write_scalar(SkWStream* stream, SkScalar value)228 static void write_scalar(SkWStream* stream, SkScalar value) {
229     char buffer[64];
230 #ifdef SK_BUILD_FOR_WIN
231     int len = _snprintf(buffer, sizeof(buffer), "%g", value);
232 #else
233     int len = snprintf(buffer, sizeof(buffer), "%g", value);
234 #endif
235     char* stop = buffer + len;
236     stream->write(buffer, stop - buffer);
237 }
238 
ToSVGString(const SkPath& path, SkString* str, PathEncoding encoding)239 void SkParsePath::ToSVGString(const SkPath& path, SkString* str, PathEncoding encoding) {
240     SkDynamicMemoryWStream  stream;
241 
242     SkPoint current_point{0,0};
243     const auto rel_selector = encoding == PathEncoding::Relative;
244 
245     const auto append_command = [&](char cmd, const SkPoint pts[], size_t count) {
246         // Use lower case cmds for relative encoding.
247         cmd += 32 * rel_selector;
248         stream.write(&cmd, 1);
249 
250         for (size_t i = 0; i < count; ++i) {
251             const auto pt = pts[i] - current_point;
252             if (i > 0) {
253                 stream.write(" ", 1);
254             }
255             write_scalar(&stream, pt.fX);
256             stream.write(" ", 1);
257             write_scalar(&stream, pt.fY);
258         }
259 
260         SkASSERT(count > 0);
261         // For relative encoding, track the current point (otherwise == origin).
262         current_point = pts[count - 1] * rel_selector;
263     };
264 
265     SkPath::Iter    iter(path, false);
266     SkPoint         pts[4];
267 
268     for (;;) {
269         switch (iter.next(pts)) {
270             case SkPath::kConic_Verb: {
271                 const SkScalar tol = SK_Scalar1 / 1024; // how close to a quad
272                 SkAutoConicToQuads quadder;
273                 const SkPoint* quadPts = quadder.computeQuads(pts, iter.conicWeight(), tol);
274                 for (int i = 0; i < quadder.countQuads(); ++i) {
275                     append_command('Q', &quadPts[i*2 + 1], 2);
276                 }
277             } break;
278            case SkPath::kMove_Verb:
279                 append_command('M', &pts[0], 1);
280                 break;
281             case SkPath::kLine_Verb:
282                 append_command('L', &pts[1], 1);
283                 break;
284             case SkPath::kQuad_Verb:
285                 append_command('Q', &pts[1], 2);
286                 break;
287             case SkPath::kCubic_Verb:
288                 append_command('C', &pts[1], 3);
289                 break;
290             case SkPath::kClose_Verb:
291                 stream.write("Z", 1);
292                 break;
293             case SkPath::kDone_Verb:
294                 str->resize(stream.bytesWritten());
295                 stream.copyTo(str->writable_str());
296             return;
297         }
298     }
299 }
300