1 /*
2 * Copyright (c) 2023 - 2024 the ThorVG project. All rights reserved.
3
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10
11 * The above copyright notice and this permission notice shall be included in all
12 * copies or substantial portions of the Software.
13
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 * SOFTWARE.
21 */
22
23 #include "../../lv_conf_internal.h"
24 #if LV_USE_THORVG_INTERNAL
25
26 /*
27 * Copyright (c) 2020 Samsung Electronics Co., Ltd. All rights reserved.
28
29 * Permission is hereby granted, free of charge, to any person obtaining a copy
30 * of this software and associated documentation files (the "Software"), to deal
31 * in the Software without restriction, including without limitation the rights
32 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
33 * copies of the Software, and to permit persons to whom the Software is
34 * furnished to do so, subject to the following conditions:
35
36 * The above copyright notice and this permission notice shall be included in
37 * all copies or substantial portions of the Software.
38
39 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
40 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
41 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
42 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
43 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
44 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
45 * SOFTWARE.
46 */
47
48 #include "tvgLottieParserHandler.h"
49
50
51 /************************************************************************/
52 /* Internal Class Implementation */
53 /************************************************************************/
54
55 static const int PARSE_FLAGS = kParseDefaultFlags | kParseInsituFlag;
56
57
58 /************************************************************************/
59 /* External Class Implementation */
60 /************************************************************************/
61
62
enterArray()63 bool LookaheadParserHandler::enterArray()
64 {
65 if (state != kEnteringArray) {
66 Error();
67 return false;
68 }
69 parseNext();
70 return true;
71 }
72
73
nextArrayValue()74 bool LookaheadParserHandler::nextArrayValue()
75 {
76 if (state == kExitingArray) {
77 parseNext();
78 return false;
79 }
80 //SPECIAL CASE: same as nextObjectKey()
81 if (state == kExitingObject) return false;
82 if (state == kError || state == kHasKey) {
83 Error();
84 return false;
85 }
86 return true;
87 }
88
89
getInt()90 int LookaheadParserHandler::getInt()
91 {
92 if (state != kHasNumber) {
93 Error();
94 return 0;
95 }
96 auto result = val.GetInt();
97 parseNext();
98 return result;
99 }
100
101
getFloat()102 float LookaheadParserHandler::getFloat()
103 {
104 if (state != kHasNumber) {
105 Error();
106 return 0;
107 }
108 auto result = val.GetFloat();
109 parseNext();
110 return result;
111 }
112
113
getString()114 const char* LookaheadParserHandler::getString()
115 {
116 if (state != kHasString) {
117 Error();
118 return nullptr;
119 }
120 auto result = val.GetString();
121 parseNext();
122 return result;
123 }
124
125
getStringCopy()126 char* LookaheadParserHandler::getStringCopy()
127 {
128 auto str = getString();
129 if (str) return strdup(str);
130 return nullptr;
131 }
132
133
getBool()134 bool LookaheadParserHandler::getBool()
135 {
136 if (state != kHasBool) {
137 Error();
138 return false;
139 }
140 auto result = val.GetBool();
141 parseNext();
142 return result;
143 }
144
145
getNull()146 void LookaheadParserHandler::getNull()
147 {
148 if (state != kHasNull) {
149 Error();
150 return;
151 }
152 parseNext();
153 }
154
155
parseNext()156 bool LookaheadParserHandler::parseNext()
157 {
158 if (reader.HasParseError()) {
159 Error();
160 return false;
161 }
162 if (!reader.IterativeParseNext<PARSE_FLAGS>(iss, *this)) {
163 Error();
164 return false;
165 }
166 return true;
167 }
168
169
enterObject()170 bool LookaheadParserHandler::enterObject()
171 {
172 if (state != kEnteringObject) {
173 Error();
174 return false;
175 }
176 parseNext();
177 return true;
178 }
179
180
peekType()181 int LookaheadParserHandler::peekType()
182 {
183 if (state >= kHasNull && state <= kHasKey) return val.GetType();
184 if (state == kEnteringArray) return kArrayType;
185 if (state == kEnteringObject) return kObjectType;
186 return -1;
187 }
188
189
skipOut(int depth)190 void LookaheadParserHandler::skipOut(int depth)
191 {
192 do {
193 if (state == kEnteringArray || state == kEnteringObject) ++depth;
194 else if (state == kExitingArray || state == kExitingObject) --depth;
195 else if (state == kError) return;
196 parseNext();
197 } while (depth > 0);
198 }
199
200
nextObjectKey()201 const char* LookaheadParserHandler::nextObjectKey()
202 {
203 if (state == kHasKey) {
204 auto result = val.GetString();
205 parseNext();
206 return result;
207 }
208
209 /* SPECIAL CASE: The parser works with a predefined rule that it will be only
210 while (nextObjectKey()) for each object but in case of our nested group
211 object we can call multiple time nextObjectKey() while exiting the object
212 so ignore those and don't put parser in the error state. */
213 if (state == kExitingArray || state == kEnteringObject) return nullptr;
214
215 if (state != kExitingObject) {
216 Error();
217 return nullptr;
218 }
219
220 parseNext();
221 return nullptr;
222 }
223
224
skip(const char * key)225 void LookaheadParserHandler::skip(const char* key)
226 {
227 //if (key) TVGLOG("LOTTIE", "Skipped parsing value = %s", key);
228
229 if (peekType() == kArrayType) {
230 enterArray();
231 skipOut(1);
232 } else if (peekType() == kObjectType) {
233 enterObject();
234 skipOut(1);
235 } else {
236 skipOut(0);
237 }
238 }
239
240 #endif /* LV_USE_THORVG_INTERNAL */
241
242
