Debian Codegraph @

modules/lsp-runtime-lib/include/private/fmt/xpm/XPM2StreamParser.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: 22 янв. 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_XPM2STREAMPARSER_H_
23 #define PRIVATE_FMT_XPM_XPM2STREAMPARSER_H_
24
25 #include <lsp-plug.in/runtime/version.h>
26 #include <lsp-plug.in/fmt/xpm/Parser.h>
27 #include <lsp-plug.in/stdlib/string.h>
28
29 #include <private/fmt/xpm/Tokenizer.h>
30 #include <private/fmt/xpm/utils.h>
31
32 namespace lsp
33 {
34 namespace xpm
35 {
36 /**
37 * Parser for XPM2 streaming format
38 */
39 class LSP_HIDDEN_MODIFIER XPM2StreamParser: 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 static const char * const postfixes[];
52
53 private:
54 Tokenizer *pTokenizer;
55 header_t sHeader;
56 state_t enState;
57 size_t nColors;
58 size_t nRows;
59
60 private:
61 status_t do_close()
62 {
63 if (pTokenizer == NULL)
64 return STATUS_OK;
65
66 status_t res = pTokenizer->close();
67 delete pTokenizer;
68 pTokenizer = NULL;
69
70 return res;
71 }
72
73 public:
74 explicit XPM2StreamParser(Tokenizer * tokenizer)
75 {
76 pTokenizer = tokenizer;
77
78 sHeader.version = VERSION_XPM2;
79 sHeader.width = 0;
80 sHeader.height = 0;
81 sHeader.num_colors = 0;
82 sHeader.chars_per_pixel = 0;
83 sHeader.x_hotspot = 0;
84 sHeader.y_hotspot = 0;
85 sHeader.has_extensions = false;
86
87 enState = ST_HEADER;
88 nColors = 0;
89 nRows = 0;
90 }
91
92 virtual ~XPM2StreamParser() override
93 {
94 do_close();
95 }
96
97 public:
98 virtual status_t close() override
99 {
100 return do_close();
101 }
102
103 virtual status_t read_header(header_t *dst) override
104 {
105 if (pTokenizer == NULL)
106 return STATUS_CLOSED;
107 if (dst == NULL)
108 return STATUS_BAD_ARGUMENTS;
109
110 // Header already parsed?
111 if (enState != ST_HEADER)
112 {
113 *dst = sHeader;
114 return STATUS_OK;
115 }
116
117 // Read header contents
118 status_t res;
119 const char *tvalue = NULL;
120 if ((res = pTokenizer->read_line(tvalue)) != STATUS_OK)
121 return res;
122
123 if ((tvalue = parse_xpm_header(sHeader, tvalue)) == NULL)
124 return STATUS_CORRUPTED_FILE;
125 if ((*tvalue) != '\0')
126 return STATUS_CORRUPTED_FILE;
127
128 // Check that values are in valid ranges
129 if (!verify_xpm_header(sHeader))
130 return STATUS_CORRUPTED_FILE;
131
132 // Return header and update state
133 *dst = sHeader;
134 enState = ST_COLORS;
135
136 return STATUS_OK;
137 }
138
139 virtual status_t read_color(Color *dst) override
140 {
141 if (pTokenizer == NULL)
142 return STATUS_CLOSED;
143 if (dst == NULL)
144 return STATUS_BAD_ARGUMENTS;
145
146 // Check that there are still colors available
147 if (enState != ST_COLORS)
148 return (nColors >= sHeader.num_colors) ? STATUS_NOT_FOUND : STATUS_BAD_STATE;
149 else if (nColors >= sHeader.num_colors)
150 {
151 enState = ST_PIXELS;
152 return STATUS_NOT_FOUND;
153 }
154
155 Color tmp;
156
157 // Read color line
158 status_t res;
159 const char *tvalue = NULL;
160 if ((res = pTokenizer->read_line(tvalue)) != STATUS_OK)
161 return res;
162
163 // Parse color
164 tvalue = parse_color(tmp, tvalue, sHeader.chars_per_pixel);
165 if ((tvalue == NULL) || (*tvalue != '\0'))
166 return STATUS_CORRUPTED_FILE;
167
168 if ((++nColors) >= sHeader.num_colors)
169 enState = ST_PIXELS;
170
171 // All seems to be OK
172 if (dst != NULL)
173 tmp.swap(dst);
174
175 return STATUS_OK;
176 }
177
178 virtual status_t read_line(char *dst) override
179 {
180 if (pTokenizer == NULL)
181 return STATUS_CLOSED;
182 if (dst == NULL)
183 return STATUS_BAD_ARGUMENTS;
184
185 // Check that there are still pixels available
186 if (enState != ST_PIXELS)
187 return (nRows >= sHeader.height) ? STATUS_NOT_FOUND : STATUS_BAD_STATE;
188 else if (nRows >= sHeader.height)
189 {
190 enState = ST_EXTENSIONS;
191 return STATUS_NOT_FOUND;
192 }
193
194 // Read pixel line
195 status_t res;
196 const char *tvalue = NULL;
197 if ((res = pTokenizer->read_line(tvalue)) != STATUS_OK)
198 return res;
199
200 const size_t row_size = sHeader.width * sHeader.chars_per_pixel;
201 if (strlen(tvalue) != row_size)
202 return STATUS_CORRUPTED_FILE;
203
204 // Commit result and update state
205 if (dst != NULL)
206 memcpy(dst, tvalue, row_size);
207
208 if ((++nRows) >= sHeader.height)
209 enState = (sHeader.has_extensions) ? ST_EXTENSIONS : ST_EOF;
210
211 return STATUS_OK;
212 }
213
214 virtual status_t read_ext(Extension *dst) override
215 {
216 if (pTokenizer == NULL)
217 return STATUS_CLOSED;
218 if (dst == NULL)
219 return STATUS_BAD_ARGUMENTS;
220
221 // Check that there are still pixels available
222 if (enState < ST_EXTENSIONS)
223 return STATUS_BAD_STATE;
224 else if (enState > ST_EXTENSIONS)
225 return STATUS_NOT_FOUND;
226
227 // Read extension
228 Extension tmp;
229 status_t res;
230 const char *tvalue = NULL;
231 if ((res = pTokenizer->read_line(tvalue)) != STATUS_OK)
232 {
233 if (res == STATUS_EOF)
234 {
235 enState = ST_EOF;
236 return STATUS_NOT_FOUND;
237 }
238 return res;
239 }
240
241 // XPMEXT token
242 if ((tvalue = match_prefix(tvalue, "XPMEXT")) == NULL)
243 return STATUS_CORRUPTED_FILE;
244 if (!is_blank(*tvalue++))
245 return STATUS_CORRUPTED_FILE;
246
247 // Extension name
248 const char *id = parse_identifier(tvalue);
249 if ((id == NULL) || (id <= tvalue))
250 return STATUS_CORRUPTED_FILE;
251 if (!tmp.set_name(tvalue, id - tvalue))
252 return STATUS_NO_MEM;
253
254 // Extension data
255 tvalue = id;
256 if (*tvalue == '\0')
257 {
258 // Multiline extension
259 size_t lines = 0;
260 while (true)
261 {
262 // Read extension line
263 if ((res = pTokenizer->read_line(tvalue)) != STATUS_OK)
264 return res;
265
266 // End of extension lines?
267 if (strcmp(tvalue, "XPMENDEXT") == 0)
268 {
269 if (lines <= 0)
270 return STATUS_CORRUPTED_FILE;
271 break;
272 }
273
274 if (!tmp.add_row(tvalue))
275 return STATUS_NO_MEM;
276 ++lines;
277 }
278 }
279 else if (is_blank(*tvalue))
280 {
281 // Single-line extension
282 ++tvalue;
283 if (!tmp.add_row(tvalue))
284 return STATUS_NO_MEM;
285 }
286 else
287 return STATUS_CORRUPTED_FILE;
288
289 // All seems to be OK
290 if (dst != NULL)
291 tmp.swap(dst);
292
293 return STATUS_OK;
294 }
295
296 };
297
298 } /* namespace xpm */
299 } /* namespace lsp */
300
301
302 #endif /* PRIVATE_FMT_XPM_XPM2STREAMPARSER_H_ */