Blender V5.3
idprop_utils.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10#include <cstdio>
11#include <cstring>
12
13#include "BLI_dynstr.hh"
14#include "BLI_listbase.hh"
15#include "BLI_string.hh"
16
17#include "DNA_ID.h"
18
19#include "BKE_idprop.hh"
20#include "BKE_idtype.hh"
21
22#include "MEM_guardedalloc.h"
23
24#include "BLI_strict_flags.hh" /* IWYU pragma: keep. Keep last. */
25
26namespace blender {
27
28/* -------------------------------------------------------------------- */
36
37struct ReprState {
38 void (*str_append_fn)(void *user_data, const char *str, uint str_len);
39 void *user_data;
40 /* Big enough to format any primitive type. */
41 char buf[128];
42};
43
45 const char *str,
46 const uint str_len,
47 bool quote)
48{
49 if (quote) {
50 state->str_append_fn(state->user_data, "\"", 1);
51 }
52 uint i_prev = 0, i = 0;
53 while (i < str_len) {
54 const char c = str[i];
55 if (c == '"') {
56 if (i_prev != i) {
57 state->str_append_fn(state->user_data, str + i_prev, i - i_prev);
58 }
59 state->str_append_fn(state->user_data, "\\\"", 2);
60 i_prev = i + 1;
61 }
62 else if (c == '\\') {
63 if (i_prev != i) {
64 state->str_append_fn(state->user_data, str + i_prev, i - i_prev);
65 }
66 state->str_append_fn(state->user_data, "\\\\", 2);
67 i_prev = i + 1;
68 }
69 else if (c < 32) {
70 if (i_prev != i) {
71 state->str_append_fn(state->user_data, str + i_prev, i - i_prev);
72 }
73 char buf[5];
74 uint len = uint(SNPRINTF_RLEN(buf, "\\x%02x", c));
75 BLI_assert(len == 4);
76 state->str_append_fn(state->user_data, buf, len);
77 i_prev = i + 1;
78 }
79 i++;
80 }
81 state->str_append_fn(state->user_data, str + i_prev, i - i_prev);
82 if (quote) {
83 state->str_append_fn(state->user_data, "\"", 1);
84 }
85}
86
88{
89/* NOTE: 'strlen' will be calculated at compile time for literals. */
90#define STR_APPEND_STR(str) state->str_append_fn(state->user_data, str, uint(strlen(str)))
91
92#define STR_APPEND_STR_QUOTE(str) idp_str_append_escape(state, str, uint(strlen(str)), true)
93#define STR_APPEND_STR_LEN_QUOTE(str, str_len) idp_str_append_escape(state, str, str_len, true)
94
95#define STR_APPEND_FMT(format, ...) \
96 state->str_append_fn( \
97 state->user_data, state->buf, uint(SNPRINTF_RLEN(state->buf, format, __VA_ARGS__)))
98
99 switch (prop->type) {
100 case IDP_STRING: {
101 STR_APPEND_STR_LEN_QUOTE(IDP_string_get(prop), uint(std::max(0, prop->len - 1)));
102 break;
103 }
104 case IDP_INT: {
105 if (const IDPropertyUIDataEnumItem *item = prop->ui_data ? IDP_EnumItemFind(prop) : nullptr)
106 {
107 STR_APPEND_STR_QUOTE(item->name);
108 }
109 else {
110 STR_APPEND_FMT("%d", IDP_int_get(prop));
111 }
112 break;
113 }
114 case IDP_FLOAT: {
115 STR_APPEND_FMT("%g", double(IDP_float_get(prop)));
116 break;
117 }
118 case IDP_DOUBLE: {
119 STR_APPEND_FMT("%g", IDP_double_get(prop));
120 break;
121 }
122 case IDP_BOOLEAN: {
123 STR_APPEND_FMT("%s", IDP_bool_get(prop) ? "True" : "False");
124 break;
125 }
126 case IDP_ARRAY: {
127 STR_APPEND_STR("[");
128 switch (prop->subtype) {
129 case IDP_INT:
130 for (const int *v = static_cast<const int *>(prop->data.pointer), *v_end = v + prop->len;
131 v != v_end;
132 v++)
133 {
134 if (v != prop->data.pointer) {
135 STR_APPEND_STR(", ");
136 }
137 STR_APPEND_FMT("%d", *v);
138 }
139 break;
140 case IDP_FLOAT:
141 for (const float *v = static_cast<const float *>(prop->data.pointer),
142 *v_end = v + prop->len;
143 v != v_end;
144 v++)
145 {
146 if (v != prop->data.pointer) {
147 STR_APPEND_STR(", ");
148 }
149 STR_APPEND_FMT("%g", double(*v));
150 }
151 break;
152 case IDP_DOUBLE:
153 for (const double *v = static_cast<const double *>(prop->data.pointer),
154 *v_end = v + prop->len;
155 v != v_end;
156 v++)
157 {
158 if (v != prop->data.pointer) {
159 STR_APPEND_STR(", ");
160 }
161 STR_APPEND_FMT("%g", *v);
162 }
163 break;
164 case IDP_BOOLEAN:
165 for (const double *v = static_cast<const double *>(prop->data.pointer),
166 *v_end = v + prop->len;
167 v != v_end;
168 v++)
169 {
170 if (v != prop->data.pointer) {
171 STR_APPEND_STR(", ");
172 }
173 STR_APPEND_FMT("%s", IDP_bool_get(prop) ? "True" : "False");
174 }
175 break;
176 }
177 STR_APPEND_STR("]");
178 break;
179 }
180 case IDP_IDPARRAY: {
181 STR_APPEND_STR("[");
182 for (const IDProperty *v = static_cast<const IDProperty *>(prop->data.pointer),
183 *v_end = v + prop->len;
184 v != v_end;
185 v++)
186 {
187 if (v != prop->data.pointer) {
188 STR_APPEND_STR(", ");
189 }
191 }
192 STR_APPEND_STR("]");
193 break;
194 }
195 case IDP_GROUP: {
196 STR_APPEND_STR("{");
197 for (const IDProperty &subprop : prop->data.group) {
198 if (&subprop != prop->data.group.first()) {
199 STR_APPEND_STR(", ");
200 }
201 STR_APPEND_STR_QUOTE(subprop.name);
202 STR_APPEND_STR(": ");
203 idp_repr_fn_recursive(state, &subprop);
204 }
205 STR_APPEND_STR("}");
206 break;
207 }
208 case IDP_ID: {
209 const ID *id = static_cast<const ID *>(prop->data.pointer);
210 if (id != nullptr) {
211 STR_APPEND_STR("bpy.data.");
213 STR_APPEND_STR("[");
214 STR_APPEND_STR_QUOTE(id->name + 2);
215 STR_APPEND_STR("]");
216 }
217 else {
218 STR_APPEND_STR("None");
219 }
220 break;
221 }
222 default: {
224 break;
225 }
226 }
227
228#undef STR_APPEND_STR
229#undef STR_APPEND_STR_QUOTE
230#undef STR_APPEND_STR_LEN_QUOTE
231#undef STR_APPEND_FMT
232}
233
234void IDP_repr_fn(const IDProperty *prop,
235 void (*str_append_fn)(void *user_data, const char *str, uint str_len),
236 void *user_data)
237{
239 state.str_append_fn = str_append_fn;
240 state.user_data = user_data;
242}
243
244static void repr_str(void *user_data, const char *str, uint len)
245{
246 BLI_dynstr_nappend(static_cast<DynStr *>(user_data), str, int(len));
247}
248
249char *IDP_reprN(const IDProperty *prop, uint *r_len)
250{
251 DynStr *ds = BLI_dynstr_new();
252 IDP_repr_fn(prop, repr_str, ds);
253 char *cstring = BLI_dynstr_get_cstring(ds);
254 if (r_len != nullptr) {
255 *r_len = uint(BLI_dynstr_get_len(ds));
256 }
257 BLI_dynstr_free(ds);
258 return cstring;
259}
260
261void IDP_print(const IDProperty *prop)
262{
263 char *repr = IDP_reprN(prop, nullptr);
264 printf("IDProperty(%p): ", prop);
265 puts(repr);
266 MEM_delete(repr);
267}
268
269const char *IDP_type_str(const eIDPropertyType type, const short sub_type)
270{
271 switch (type) {
272 case IDP_STRING:
273 switch (sub_type) {
275 return "String";
277 return "Bytes";
278 default:
279 return "String";
280 }
281 case IDP_INT:
282 return "Int";
283 case IDP_FLOAT:
284 return "Float";
285 case IDP_ARRAY:
286 switch (sub_type) {
287 case IDP_INT:
288 return "Array (Int)";
289 case IDP_FLOAT:
290 return "Array (Float)";
291 case IDP_DOUBLE:
292 return "Array (Double)";
293 case IDP_BOOLEAN:
294 return "Array (Boolean)";
295 default:
296 return "Array";
297 }
298 case IDP_GROUP:
299 return "Group";
300 case IDP_ID:
301 return "ID";
302 case IDP_DOUBLE:
303 return "Double";
304 case IDP_IDPARRAY:
305 return "Array of Properties";
306 case IDP_BOOLEAN:
307 return "Boolean";
308 }
310 return "Unknown";
311}
312
313const char *IDP_type_str(const IDProperty *prop)
314{
315 return IDP_type_str(eIDPropertyType(prop->type), prop->subtype);
316}
317
319
320} // namespace blender
#define IDP_float_get(prop)
#define IDP_int_get(prop)
#define IDP_string_get(prop)
#define IDP_double_get(prop)
#define IDP_bool_get(prop)
A dynamically sized string ADT.
#define SNPRINTF_RLEN(dst, format,...)
ID and Library types, which are fundamental for SDNA.
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define str(s)
#define STR_APPEND_STR_LEN_QUOTE(str, str_len)
#define STR_APPEND_FMT(format,...)
#define STR_APPEND_STR_QUOTE(str)
#define STR_APPEND_STR(str)
const int state
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void IDP_print(const IDProperty *prop)
unsigned int uint
Definition BKE_text.h:55
void BLI_dynstr_nappend(DynStr *__restrict ds, const char *cstr, int len) ATTR_NONNULL()
Definition BLI_dynstr.cc:77
ATTR_WARN_UNUSED_RESULT const BMVert * v
static void idp_repr_fn_recursive(ReprState *state, const IDProperty *prop)
static void repr_str(void *user_data, const char *str, uint len)
void BLI_dynstr_free(DynStr *ds) ATTR_NONNULL()
static void idp_str_append_escape(ReprState *state, const char *str, const uint str_len, bool quote)
const char * BKE_idtype_idcode_to_name_plural(short idcode)
Definition idtype.cc:268
char * BLI_dynstr_get_cstring(const DynStr *ds) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
@ IDP_STRING_SUB_UTF8
@ IDP_STRING_SUB_BYTE
char * IDP_reprN(const IDProperty *prop, uint *r_len)
const char * IDP_type_str(eIDPropertyType type, short sub_type)
void IDP_repr_fn(const IDProperty *prop, void(*str_append_fn)(void *user_data, const char *str, uint str_len), void *user_data)
ID_Type GS(const char *name)
Definition DNA_ID.h:410
const IDPropertyUIDataEnumItem * IDP_EnumItemFind(const IDProperty *prop)
Definition idprop.cc:543
int BLI_dynstr_get_len(const DynStr *ds) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
DynStr * BLI_dynstr_new() ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
Definition BLI_dynstr.cc:39
ListBaseT< struct IDProperty > group
Definition DNA_ID.h:133
IDPropertyUIData * ui_data
Definition DNA_ID.h:171
eIDPropertyType type
Definition DNA_ID.h:145
IDPropertyData data
Definition DNA_ID.h:157
void(*) str_append_fn(void *user_data, const char *str, uint str_len)