Debian Codegraph @

modules/lsp-runtime-lib/include/private/fmt/xpm/XPM3BuiltinParser.h

raw
1 /*
2 * Copyright (C) 2026 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2026 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 23 янв. 2026 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #ifndef PRIVATE_FMT_XPM_XPM3BUILTINPARSER_H_
23 #define PRIVATE_FMT_XPM_XPM3BUILTINPARSER_H_
24
25
26 #include <lsp-plug.in/runtime/version.h>
27 #include <lsp-plug.in/fmt/xpm/Parser.h>
28 #include <lsp-plug.in/stdlib/string.h>
29
30 #include <private/fmt/xpm/utils.h>
31
32 namespace lsp
33 {
34 namespace xpm
35 {
36 /**
37 * Parser for XPM3 built-in format
38 */
39 class LSP_HIDDEN_MODIFIER XPM3BuiltinParser: public Parser
40 {
41 private:
42 enum state_t
43 {
44 ST_HEADER,
45 ST_COLORS,
46 ST_PIXELS,
47 ST_EXTENSIONS,
48 ST_EOF
49 };
50
51 private:
52 header_t sHeader;
53 const char * const *vLines;
54 state_t enState;
55 size_t nColors;
56 size_t nRows;
57 size_t nLines;
58
59 private:
60 inline const char *get_line()
61 {
62 if (nLines <= 0)
63 return NULL;
64 --nLines;
65 return *(vLines++);
66 }
67
68 public:
69 XPM3BuiltinParser(const char * const * lines, size_t count)
70 {
71 sHeader.version = VERSION_XPM3;
72 sHeader.width = 0;
73 sHeader.height = 0;
74 sHeader.num_colors = 0;
75 sHeader.chars_per_pixel = 0;
76 sHeader.x_hotspot = 0;
77 sHeader.y_hotspot = 0;
78 sHeader.has_extensions = false;
79
80 vLines = lines;
81 enState = ST_HEADER;
82 nColors = 0;
83 nRows = 0;
84 nLines = count;
85 }
86
87 virtual ~XPM3BuiltinParser()
88 {
89 vLines = NULL;
90 }
91
92 public:
93 virtual status_t read_header(header_t *dst) override
94 {
95 if (vLines == NULL)
96 return STATUS_CLOSED;
97 if (dst == NULL)
98 return STATUS_BAD_ARGUMENTS;
99
100 // Header already parsed?
101 if (enState != ST_HEADER)
102 {
103 *dst = sHeader;
104 return STATUS_OK;
105 }
106
107 // Read header contents
108 const char *tvalue = get_line();
109 if (tvalue == NULL)
110 return STATUS_CORRUPTED_FILE;
111
112 if ((tvalue = parse_xpm_header(sHeader, tvalue)) == NULL)
113 return STATUS_CORRUPTED_FILE;
114 if ((*tvalue) != '\0')
115 return STATUS_CORRUPTED_FILE;
116
117 // Check that values are in valid ranges
118 if (!verify_xpm_header(sHeader))
119 return STATUS_CORRUPTED_FILE;
120
121 // Return header and update state
122 *dst = sHeader;
123 enState = ST_COLORS;
124
125 return STATUS_OK;
126 }
127
128 virtual status_t read_color(Color *dst) override
129 {
130 if (vLines == NULL)
131 return STATUS_CLOSED;
132 if (dst == NULL)
133 return STATUS_BAD_ARGUMENTS;
134
135 // Check that there are still colors available
136 if (enState != ST_COLORS)
137 return (nColors >= sHeader.num_colors) ? STATUS_NOT_FOUND : STATUS_BAD_STATE;
138 else if (nColors >= sHeader.num_colors)
139 {
140 enState = ST_PIXELS;
141 return STATUS_NOT_FOUND;
142 }
143
144 Color tmp;
145
146 // Read color line
147 const char *tvalue = get_line();
148 if (tvalue == NULL)
149 return STATUS_CORRUPTED_FILE;
150
151 // Parse color
152 tvalue = parse_color(tmp, tvalue, sHeader.chars_per_pixel);
153 if ((tvalue == NULL) || (*tvalue != '\0'))
154 return STATUS_CORRUPTED_FILE;
155
156 if ((++nColors) >= sHeader.num_colors)
157 enState = ST_PIXELS;
158
159 // All seems to be OK
160 if (dst != NULL)
161 tmp.swap(dst);
162
163 return STATUS_OK;
164 }
165
166 virtual status_t read_line(char *dst) override
167 {
168 if (vLines == NULL)
169 return STATUS_CLOSED;
170 if (dst == NULL)
171 return STATUS_BAD_ARGUMENTS;
172
173 // Check that there are still pixels available
174 if (enState != ST_PIXELS)
175 return (nRows >= sHeader.height) ? STATUS_NOT_FOUND : STATUS_BAD_STATE;
176 else if (nRows >= sHeader.height)
177 {
178 enState = ST_EXTENSIONS;
179 return STATUS_NOT_FOUND;
180 }
181
182 // Read pixel line
183 const char *tvalue = get_line();
184 if (tvalue == NULL)
185 return STATUS_CORRUPTED_FILE;
186
187 const size_t row_size = sHeader.width * sHeader.chars_per_pixel;
188 if (strlen(tvalue) != row_size)
189 return STATUS_CORRUPTED_FILE;
190
191 // Commit result and update state
192 if (dst != NULL)
193 memcpy(dst, tvalue, row_size);
194
195 if ((++nRows) >= sHeader.height)
196 enState = (sHeader.has_extensions) ? ST_EXTENSIONS : ST_EOF;
197
198 return STATUS_OK;
199 }
200
201 virtual status_t read_ext(Extension *dst) override
202 {
203 if (vLines == NULL)
204 return STATUS_CLOSED;
205 if (dst == NULL)
206 return STATUS_BAD_ARGUMENTS;
207
208 // Check that there are still pixels available
209 if (enState < ST_EXTENSIONS)
210 return STATUS_BAD_STATE;
211 else if (enState > ST_EXTENSIONS)
212 return STATUS_NOT_FOUND;
213
214 // Read extension
215 Extension tmp;
216 const char *tvalue = get_line();
217 if (tvalue == NULL)
218 {
219 enState = ST_EOF;
220 return STATUS_NOT_FOUND;
221 }
222
223 // XPMEXT token
224 if ((tvalue = match_prefix(tvalue, "XPMEXT")) == NULL)
225 return STATUS_CORRUPTED_FILE;
226 if (!is_blank(*tvalue++))
227 return STATUS_CORRUPTED_FILE;
228
229 // Extension name
230 const char *id = parse_identifier(tvalue);
231 if ((id == NULL) || (id <= tvalue))
232 return STATUS_CORRUPTED_FILE;
233 if (!tmp.set_name(tvalue, id - tvalue))
234 return STATUS_NO_MEM;
235
236 // Extension data
237 tvalue = id;
238 if (*tvalue == '\0')
239 {
240 // Multiline extension
241 size_t lines = 0;
242 while (true)
243 {
244 // Read extension line
245 if ((tvalue = get_line()) == NULL)
246 return STATUS_CORRUPTED_FILE;
247
248 // End of extension lines?
249 if (strcmp(tvalue, "XPMENDEXT") == 0)
250 {
251 if (lines <= 0)
252 return STATUS_CORRUPTED_FILE;
253 break;
254 }
255
256 if (!tmp.add_row(tvalue))
257 return STATUS_NO_MEM;
258 ++lines;
259 }
260 }
261 else if (is_blank(*tvalue))
262 {
263 // Single-line extension
264 ++tvalue;
265 if (!tmp.add_row(tvalue))
266 return STATUS_NO_MEM;
267 }
268 else
269 return STATUS_CORRUPTED_FILE;
270
271 // All seems to be OK
272 if (dst != NULL)
273 tmp.swap(dst);
274
275 return STATUS_OK;
276 }
277
278 virtual status_t close() override
279 {
280 vLines = NULL;
281
282 return STATUS_OK;
283 }
284 };
285
286 } /* namespace xpm */
287 } /* namespace lsp */
288
289
290 #endif /* PRIVATE_FMT_XPM_XPM3BUILTINPARSER_H_ */