Debian Codegraph @

modules/lsp-runtime-lib/include/private/fmt/xpm/utils.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: 21 янв. 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_UTILS_H_
23 #define PRIVATE_FMT_XPM_UTILS_H_
24
25 #include <lsp-plug.in/runtime/version.h>
26 #include <lsp-plug.in/fmt/xpm/ColorItem.h>
27 #include <lsp-plug.in/fmt/xpm/Header.h>
28
29 namespace lsp
30 {
31 namespace xpm
32 {
33
34 static inline uint32_t hex_digit(char c)
35 {
36 if ((c >= '0') && (c <= '9'))
37 return c - '0';
38 if ((c >= 'a') && (c <= 'f'))
39 return c - 'a' + 10;
40 if ((c >= 'A') && (c <= 'F'))
41 return c - 'A' + 10;
42 return 0x10;
43 }
44
45 static inline bool is_space(char c)
46 {
47 switch (c)
48 {
49 case ' ':
50 case '\n':
51 case '\r':
52 case '\t':
53 case '\v':
54 return true;
55 default:
56 break;
57 }
58 return false;
59 }
60
61 static inline bool is_blank(char c)
62 {
63 switch (c)
64 {
65 case ' ':
66 case '\t':
67 return true;
68 default:
69 break;
70 }
71 return false;
72 }
73
74 static inline bool is_digit(char c)
75 {
76 return (c >= '0') && (c <= '9');
77 }
78
79 static inline bool is_alpha(char c)
80 {
81 return ((c >= 'a') && (c <= 'z')) ||
82 ((c >= 'A') && (c <= 'Z')) ||
83 (c == '_');
84 }
85
86 static inline bool is_alphadigit(char c)
87 {
88 return is_digit(c) || is_alpha(c);
89 }
90
91 static const char *skip_whitespace(const char *value)
92 {
93 while (true)
94 {
95 const char ch = *value;
96 switch (ch)
97 {
98 case ' ':
99 case '\t':
100 case '\r':
101 case '\v':
102 ++value;
103 break;
104 default:
105 return value;
106 }
107 }
108 }
109
110 const char *match_prefix(const char *str, const char *expected)
111 {
112 while (true)
113 {
114 const char ch = *expected;
115 if (ch == '\0')
116 return str;
117 if (*str != ch)
118 return NULL;
119
120 ++expected;
121 ++str;
122 }
123 }
124
125 const char *advance(const char *str, size_t count)
126 {
127 for (size_t i=0; i<count; ++i)
128 {
129 if (*(str++) == '\0')
130 return NULL;
131 }
132
133 return str;
134 }
135
136 static const char *parse_int(size_t *out, const char *value)
137 {
138 size_t res = 0;
139 size_t digits = 0;
140
141 for (; *value != '\0'; ++value)
142 {
143 if (!is_digit(*value))
144 {
145 if (digits <= 0)
146 return NULL;
147 break;
148 }
149
150 // Update value and check for overflow
151 res = (res * 10) + (*value - '0');
152 if (++digits >= 9)
153 return NULL;
154 }
155
156 *out = res;
157 return value;
158 }
159
160 static const char *parse_identifier(const char *str)
161 {
162 if (!is_alpha(*str))
163 return NULL;
164
165 ++str;
166 while (is_alphadigit(*str))
167 ++str;
168
169 return str;
170 }
171
172 static const char *parse_color_name(const char *str)
173 {
174 while (true)
175 {
176 str = parse_identifier(str);
177 if (str == NULL)
178 return NULL;
179
180 // Perform look-ahead of additional word in color name
181 if (str[0] != ' ')
182 return str;
183
184 switch (str[1])
185 {
186 case 'm':
187 case 's':
188 case 'c':
189 if ((str[2] == '\0') || (is_blank(str[2])))
190 return str;
191 ++str;
192 break;
193
194 case 'g':
195 if ((str[2] == '\0') || (is_blank(str[2])))
196 return str;
197 if (str[2] != '4')
198 {
199 ++str;
200 break;
201 }
202 if ((str[3] == '\0') || (is_blank(str[3])))
203 return str;
204 ++str;
205 break;
206
207 default:
208 if (!is_alpha(str[1]))
209 return str;
210 break;
211 }
212 }
213 }
214
215 static const char *parse_color_item(ColorItem & v, const char *str)
216 {
217 const char * const begin = str;
218
219 if (*str == '#')
220 {
221 // Parse hexadecimal value
222 ++str;
223 uint32_t code;
224 uint64_t color = 0;
225
226 while ((code = hex_digit(*str)) < 0x10)
227 {
228 if ((str - begin) >= 13)
229 return NULL;
230
231 ++str;
232 color = (color << 4) | code;
233 }
234
235 // Check that color is valid
236 const size_t len = str - begin;
237 if (len == 7)
238 {
239 v.set_rgb24(uint32_t(color));
240 return str;
241 }
242 else if (len == 13)
243 {
244 v.set_rgb48(uint64_t(color));
245 return str;
246 }
247
248 return NULL;
249 }
250
251 str = parse_color_name(begin);
252 if (str == begin)
253 return NULL;
254
255 return (v.set_name(begin, str - begin)) ? str : NULL;
256 }
257
258 static const char *parse_color(Color & c, const char *str, size_t chars_per_color)
259 {
260 enum flags_t
261 {
262 F_MONO = 1 << 0,
263 F_SYMBOLIC = 1 << 1,
264 F_GRAY4 = 1 << 2,
265 F_GRAY = 1 << 3,
266 F_COLOR = 1 << 4
267 };
268
269 // Color code
270 const char *code = str;
271 if ((str = advance(str, chars_per_color)) == NULL)
272 return NULL;
273 if (!c.set_code(code, chars_per_color))
274 return NULL;
275
276 // Visuals
277 size_t flags = 0;
278 while (true)
279 {
280 str = skip_whitespace(str);
281 switch (*str)
282 {
283 case '\0':
284 return (flags == 0) ? NULL : str;
285
286 case 'm': // Mono
287 if (flags & F_MONO)
288 return NULL;
289 flags |= F_MONO;
290 str = skip_whitespace(str + 1);
291 if ((str = parse_color_item(c.mono_visual(), str)) == NULL)
292 return NULL;
293 break;
294
295 case 's': // Symbolic
296 if (flags & F_SYMBOLIC)
297 return NULL;
298 flags |= F_SYMBOLIC;
299 str = skip_whitespace(str + 1);
300 if ((str = parse_color_item(c.symbolic_visual(), str)) == NULL)
301 return NULL;
302 break;
303
304 case 'c': // Color
305 if (flags & F_COLOR)
306 return NULL;
307 flags |= F_COLOR;
308 str = skip_whitespace(str + 1);
309 if ((str = parse_color_item(c.color_visual(), str)) == NULL)
310 return NULL;
311 break;
312
313 case 'g': // Gray, Gray4
314 if (str[1] == '4') // Gray4
315 {
316 if (flags & F_GRAY4)
317 return NULL;
318 flags |= F_GRAY4;
319 str = skip_whitespace(str + 2);
320 if ((str = parse_color_item(c.gray4_visual(), str)) == NULL)
321 return NULL;
322 }
323 else
324 {
325 if (flags & F_GRAY)
326 return NULL;
327 flags |= F_GRAY;
328 str = skip_whitespace(str + 1);
329 if ((str = parse_color_item(c.gray_visual(), str)) == NULL)
330 return NULL;
331 }
332 break;
333
334 default: // Invalid character
335 return NULL;
336 }
337 }
338 }
339
340 static const char *parse_xpm_header(header_t & hdr, const char * str)
341 {
342 // Width
343 str = skip_whitespace(str);
344 if ((str = parse_int(&hdr.width, str)) == NULL)
345 return NULL;
346
347 // Height
348 str = skip_whitespace(str);
349 if ((str = parse_int(&hdr.height, str)) == NULL)
350 return NULL;
351
352 // Colors
353 str = skip_whitespace(str);
354 if ((str = parse_int(&hdr.num_colors, str)) == NULL)
355 return NULL;
356
357 // Chars per pixel
358 str = skip_whitespace(str);
359 if ((str = parse_int(&hdr.chars_per_pixel, str)) == NULL)
360 return NULL;
361
362 // Optional x_hotspot and y_hotspot
363 str = skip_whitespace(str);
364 const char *hspot = parse_int(&hdr.x_hotspot, str);
365 if (hspot != NULL)
366 {
367 hspot = skip_whitespace(hspot);
368 if ((hspot = parse_int(&hdr.y_hotspot, hspot)) == NULL)
369 return NULL;
370 str = hspot;
371 }
372 else
373 {
374 hdr.x_hotspot = 0;
375 hdr.y_hotspot = 0;
376 }
377
378 // Optional XPMEXT signature
379 str = skip_whitespace(str);
380 const char *xpmext = match_prefix(str, "XPMEXT");
381 if (xpmext != NULL)
382 {
383 hdr.has_extensions = true;
384 str = xpmext;
385 }
386 else
387 hdr.has_extensions = false;
388
389 return skip_whitespace(str);
390 }
391
392 static inline bool verify_xpm_header(const header_t & hdr)
393 {
394 return
395 (hdr.width > 0) &&
396 (hdr.height > 0) &&
397 (hdr.num_colors > 0) &&
398 (hdr.chars_per_pixel > 0) &&
399 (hdr.chars_per_pixel <= 12) &&
400 (hdr.x_hotspot < hdr.width) &&
401 (hdr.y_hotspot < hdr.height);
402 }
403
404 } /* namespace xpm */
405 } /* namespace lsp */
406
407 #endif /* PRIVATE_FMT_XPM_UTILS_H_ */