Branch data Line data Source code
1 : : /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
2 : : * GObject introspection: Typelib creation
3 : : *
4 : : * Copyright (C) 2005 Matthias Clasen
5 : : * Copyright (C) 2008,2009 Red Hat, Inc.
6 : : *
7 : : * SPDX-License-Identifier: LGPL-2.1-or-later
8 : : *
9 : : * This library is free software; you can redistribute it and/or
10 : : * modify it under the terms of the GNU Lesser General Public
11 : : * License as published by the Free Software Foundation; either
12 : : * version 2 of the License, or (at your option) any later version.
13 : : *
14 : : * This library is distributed in the hope that it will be useful,
15 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 : : * Lesser General Public License for more details.
18 : : *
19 : : * You should have received a copy of the GNU Lesser General Public
20 : : * License along with this library; if not, write to the
21 : : * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 : : * Boston, MA 02111-1307, USA.
23 : : */
24 : :
25 : : #include "config.h"
26 : :
27 : : #include "girnode-private.h"
28 : : #include "girepository-private.h"
29 : : #include "gitypelib-internal.h"
30 : :
31 : : #include <stdio.h>
32 : : #include <stdlib.h>
33 : : #include <string.h>
34 : :
35 : : #ifdef _MSC_VER
36 : : #define strtoll _strtoi64
37 : : #define strtoull _strtoui64
38 : : #endif
39 : :
40 : : static gulong string_count = 0;
41 : : static gulong unique_string_count = 0;
42 : : static gulong string_size = 0;
43 : : static gulong unique_string_size = 0;
44 : : static gulong types_count = 0;
45 : : static gulong unique_types_count = 0;
46 : :
47 : : void
48 : 43 : gi_ir_node_init_stats (void)
49 : : {
50 : 43 : string_count = 0;
51 : 43 : unique_string_count = 0;
52 : 43 : string_size = 0;
53 : 43 : unique_string_size = 0;
54 : 43 : types_count = 0;
55 : 43 : unique_types_count = 0;
56 : 43 : }
57 : :
58 : : void
59 : 26 : gi_ir_node_dump_stats (void)
60 : : {
61 : 26 : g_message ("%lu strings (%lu before sharing), %lu bytes (%lu before sharing)",
62 : 13 : unique_string_count, string_count, unique_string_size, string_size);
63 : 26 : g_message ("%lu types (%lu before sharing)", unique_types_count, types_count);
64 : 26 : }
65 : :
66 : : #define DO_ALIGNED_COPY(dest_addr, value, type) \
67 : : do { \
68 : : type tmp_var; \
69 : : tmp_var = value; \
70 : : memcpy(dest_addr, &tmp_var, sizeof(type)); \
71 : : } while(0)
72 : :
73 : : #define ALIGN_VALUE(this, boundary) \
74 : : (( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))
75 : :
76 : :
77 : : const char *
78 : 4615452 : gi_ir_node_type_to_string (GIIrNodeTypeId type)
79 : : {
80 : 4615452 : switch (type)
81 : : {
82 : 194690 : case GI_IR_NODE_FUNCTION:
83 : 386143 : return "function";
84 : 51031 : case GI_IR_NODE_CALLBACK:
85 : 101974 : return "callback";
86 : 739724 : case GI_IR_NODE_PARAM:
87 : 1470870 : return "param";
88 : 1070910 : case GI_IR_NODE_TYPE:
89 : 2130272 : return "type";
90 : 7812 : case GI_IR_NODE_OBJECT:
91 : 15570 : return "object";
92 : 2088 : case GI_IR_NODE_INTERFACE:
93 : 4140 : return "interface";
94 : 5456 : case GI_IR_NODE_SIGNAL:
95 : 10868 : return "signal";
96 : 18678 : case GI_IR_NODE_PROPERTY:
97 : 37312 : return "property";
98 : 36344 : case GI_IR_NODE_VFUNC:
99 : 72644 : return "vfunc";
100 : 97581 : case GI_IR_NODE_FIELD:
101 : 194986 : return "field";
102 : 3393 : case GI_IR_NODE_ENUM:
103 : 6777 : return "enum";
104 : 3429 : case GI_IR_NODE_FLAGS:
105 : 6858 : return "flags";
106 : 1890 : case GI_IR_NODE_BOXED:
107 : 3780 : return "boxed";
108 : 15858 : case GI_IR_NODE_STRUCT:
109 : 31608 : return "struct";
110 : 58608 : case GI_IR_NODE_VALUE:
111 : 117205 : return "value";
112 : 11736 : case GI_IR_NODE_CONSTANT:
113 : 23427 : return "constant";
114 : 292 : case GI_IR_NODE_XREF:
115 : 550 : return "xref";
116 : 234 : case GI_IR_NODE_UNION:
117 : 468 : return "union";
118 : 0 : default:
119 : 0 : return "unknown";
120 : : }
121 : 2295698 : }
122 : :
123 : : GIIrNode *
124 : 610013 : gi_ir_node_new (GIIrNodeTypeId type,
125 : : GIIrModule *module)
126 : : {
127 : 610013 : GIIrNode *node = NULL;
128 : :
129 : 610013 : switch (type)
130 : : {
131 : 37656 : case GI_IR_NODE_FUNCTION:
132 : : case GI_IR_NODE_CALLBACK:
133 : 75201 : node = g_malloc0 (sizeof (GIIrNodeFunction));
134 : 75201 : break;
135 : :
136 : 107040 : case GI_IR_NODE_PARAM:
137 : 213692 : node = g_malloc0 (sizeof (GIIrNodeParam));
138 : 213692 : break;
139 : :
140 : 124995 : case GI_IR_NODE_TYPE:
141 : 249577 : node = g_malloc0 (sizeof (GIIrNodeType));
142 : 249577 : break;
143 : :
144 : 991 : case GI_IR_NODE_OBJECT:
145 : : case GI_IR_NODE_INTERFACE:
146 : 1977 : node = g_malloc0 (sizeof (GIIrNodeInterface));
147 : 1977 : break;
148 : :
149 : 421 : case GI_IR_NODE_SIGNAL:
150 : 840 : node = g_malloc0 (sizeof (GIIrNodeSignal));
151 : 840 : break;
152 : :
153 : 1435 : case GI_IR_NODE_PROPERTY:
154 : 2868 : node = g_malloc0 (sizeof (GIIrNodeProperty));
155 : 2868 : break;
156 : :
157 : 2794 : case GI_IR_NODE_VFUNC:
158 : 5586 : node = g_malloc0 (sizeof (GIIrNodeFunction));
159 : 5586 : break;
160 : :
161 : 10788 : case GI_IR_NODE_FIELD:
162 : 21568 : node = g_malloc0 (sizeof (GIIrNodeField));
163 : 21568 : break;
164 : :
165 : 1291 : case GI_IR_NODE_ENUM:
166 : : case GI_IR_NODE_FLAGS:
167 : 2582 : node = g_malloc0 (sizeof (GIIrNodeEnum));
168 : 2582 : break;
169 : :
170 : 280 : case GI_IR_NODE_BOXED:
171 : 560 : node = g_malloc0 (sizeof (GIIrNodeBoxed));
172 : 560 : break;
173 : :
174 : 2472 : case GI_IR_NODE_STRUCT:
175 : 4938 : node = g_malloc0 (sizeof (GIIrNodeStruct));
176 : 4938 : break;
177 : :
178 : 12433 : case GI_IR_NODE_VALUE:
179 : 24867 : node = g_malloc0 (sizeof (GIIrNodeValue));
180 : 24867 : break;
181 : :
182 : 2645 : case GI_IR_NODE_CONSTANT:
183 : 5276 : node = g_malloc0 (sizeof (GIIrNodeConstant));
184 : 5276 : break;
185 : :
186 : 146 : case GI_IR_NODE_XREF:
187 : 275 : node = g_malloc0 (sizeof (GIIrNodeXRef));
188 : 275 : break;
189 : :
190 : 103 : case GI_IR_NODE_UNION:
191 : 206 : node = g_malloc0 (sizeof (GIIrNodeUnion));
192 : 206 : break;
193 : :
194 : 0 : default:
195 : 0 : g_error ("Unhandled node type %d", type);
196 : 0 : break;
197 : : }
198 : :
199 : 610013 : node->type = type;
200 : 610013 : node->module = module;
201 : 610013 : node->offset = 0;
202 : 610013 : node->attributes = g_hash_table_new_full (g_str_hash, g_str_equal,
203 : : g_free, g_free);
204 : :
205 : 610013 : return node;
206 : : }
207 : :
208 : : void
209 : 1365669 : gi_ir_node_free (GIIrNode *node)
210 : : {
211 : : GList *l;
212 : :
213 : 1365669 : if (node == NULL)
214 : 755656 : return;
215 : :
216 : 610013 : switch (node->type)
217 : : {
218 : 37656 : case GI_IR_NODE_FUNCTION:
219 : : case GI_IR_NODE_CALLBACK:
220 : : {
221 : 75201 : GIIrNodeFunction *function = (GIIrNodeFunction *)node;
222 : :
223 : 75201 : g_free (node->name);
224 : 75201 : g_free (function->symbol);
225 : 75201 : g_free (function->property);
226 : 75201 : g_free (function->async_func);
227 : 75201 : g_free (function->sync_func);
228 : 75201 : g_free (function->finish_func);
229 : 75201 : gi_ir_node_free ((GIIrNode *)function->result);
230 : 197009 : for (l = function->parameters; l; l = l->next)
231 : 121808 : gi_ir_node_free ((GIIrNode *)l->data);
232 : 75201 : g_list_free (function->parameters);
233 : : }
234 : 75201 : break;
235 : :
236 : 124995 : case GI_IR_NODE_TYPE:
237 : : {
238 : 249577 : GIIrNodeType *type = (GIIrNodeType *)node;
239 : :
240 : 249577 : g_free (node->name);
241 : 249577 : gi_ir_node_free ((GIIrNode *)type->parameter_type1);
242 : 249577 : gi_ir_node_free ((GIIrNode *)type->parameter_type2);
243 : :
244 : 249577 : g_free (type->giinterface);
245 : 249577 : g_strfreev (type->errors);
246 : 249577 : g_free (type->unparsed);
247 : : }
248 : 249577 : break;
249 : :
250 : 107040 : case GI_IR_NODE_PARAM:
251 : : {
252 : 213692 : GIIrNodeParam *param = (GIIrNodeParam *)node;
253 : :
254 : 213692 : g_free (node->name);
255 : 213692 : gi_ir_node_free ((GIIrNode *)param->type);
256 : : }
257 : 213692 : break;
258 : :
259 : 1435 : case GI_IR_NODE_PROPERTY:
260 : : {
261 : 2868 : GIIrNodeProperty *property = (GIIrNodeProperty *)node;
262 : :
263 : 2868 : g_free (node->name);
264 : 2868 : g_free (property->setter);
265 : 2868 : g_free (property->getter);
266 : 2868 : gi_ir_node_free ((GIIrNode *)property->type);
267 : : }
268 : 2868 : break;
269 : :
270 : 421 : case GI_IR_NODE_SIGNAL:
271 : : {
272 : 840 : GIIrNodeSignal *signal = (GIIrNodeSignal *)node;
273 : :
274 : 840 : g_free (node->name);
275 : 1912 : for (l = signal->parameters; l; l = l->next)
276 : 1072 : gi_ir_node_free ((GIIrNode *)l->data);
277 : 840 : g_list_free (signal->parameters);
278 : 840 : gi_ir_node_free ((GIIrNode *)signal->result);
279 : : }
280 : 840 : break;
281 : :
282 : 2794 : case GI_IR_NODE_VFUNC:
283 : : {
284 : 5586 : GIIrNodeVFunc *vfunc = (GIIrNodeVFunc *)node;
285 : :
286 : 5586 : g_free (node->name);
287 : 5586 : g_free (vfunc->async_func);
288 : 5586 : g_free (vfunc->sync_func);
289 : 5586 : g_free (vfunc->finish_func);
290 : 5586 : g_free (vfunc->invoker);
291 : 14771 : for (l = vfunc->parameters; l; l = l->next)
292 : 9185 : gi_ir_node_free ((GIIrNode *)l->data);
293 : 5586 : g_list_free (vfunc->parameters);
294 : 5586 : gi_ir_node_free ((GIIrNode *)vfunc->result);
295 : : }
296 : 5586 : break;
297 : :
298 : 10788 : case GI_IR_NODE_FIELD:
299 : : {
300 : 21568 : GIIrNodeField *field = (GIIrNodeField *)node;
301 : :
302 : 21568 : g_free (node->name);
303 : 21568 : gi_ir_node_free ((GIIrNode *)field->type);
304 : 21568 : gi_ir_node_free ((GIIrNode *)field->callback);
305 : : }
306 : 21568 : break;
307 : :
308 : 991 : case GI_IR_NODE_OBJECT:
309 : : case GI_IR_NODE_INTERFACE:
310 : : {
311 : 1977 : GIIrNodeInterface *iface = (GIIrNodeInterface *)node;
312 : :
313 : 1977 : g_free (node->name);
314 : 1977 : g_free (iface->gtype_name);
315 : 1977 : g_free (iface->gtype_init);
316 : 1977 : g_free (iface->ref_func);
317 : 1977 : g_free (iface->unref_func);
318 : 1977 : g_free (iface->set_value_func);
319 : 1977 : g_free (iface->get_value_func);
320 : :
321 : :
322 : 1977 : g_free (iface->glib_type_struct);
323 : 1977 : g_free (iface->parent);
324 : :
325 : 2628 : for (l = iface->interfaces; l; l = l->next)
326 : 651 : g_free ((GIIrNode *)l->data);
327 : 1977 : g_list_free (iface->interfaces);
328 : :
329 : 1977 : g_list_free_full (iface->prerequisites, g_free);
330 : :
331 : 31084 : for (l = iface->members; l; l = l->next)
332 : 29107 : gi_ir_node_free ((GIIrNode *)l->data);
333 : 1977 : g_list_free (iface->members);
334 : :
335 : : }
336 : 1977 : break;
337 : :
338 : 12433 : case GI_IR_NODE_VALUE:
339 : : {
340 : 24867 : g_free (node->name);
341 : : }
342 : 24867 : break;
343 : :
344 : 1291 : case GI_IR_NODE_ENUM:
345 : : case GI_IR_NODE_FLAGS:
346 : : {
347 : 2582 : GIIrNodeEnum *enum_ = (GIIrNodeEnum *)node;
348 : :
349 : 2582 : g_free (node->name);
350 : 2582 : g_free (enum_->gtype_name);
351 : 2582 : g_free (enum_->gtype_init);
352 : 2582 : g_free (enum_->error_domain);
353 : :
354 : 27449 : for (l = enum_->values; l; l = l->next)
355 : 24867 : gi_ir_node_free ((GIIrNode *)l->data);
356 : 2582 : g_list_free (enum_->values);
357 : :
358 : 2764 : for (l = enum_->methods; l; l = l->next)
359 : 182 : gi_ir_node_free ((GIIrNode *)l->data);
360 : 2582 : g_list_free (enum_->methods);
361 : : }
362 : 2582 : break;
363 : :
364 : 280 : case GI_IR_NODE_BOXED:
365 : : {
366 : 560 : GIIrNodeBoxed *boxed = (GIIrNodeBoxed *)node;
367 : :
368 : 560 : g_free (node->name);
369 : 560 : g_free (boxed->gtype_name);
370 : 560 : g_free (boxed->gtype_init);
371 : :
372 : 592 : for (l = boxed->members; l; l = l->next)
373 : 32 : gi_ir_node_free ((GIIrNode *)l->data);
374 : 560 : g_list_free (boxed->members);
375 : : }
376 : 560 : break;
377 : :
378 : 2472 : case GI_IR_NODE_STRUCT:
379 : : {
380 : 4938 : GIIrNodeStruct *struct_ = (GIIrNodeStruct *)node;
381 : :
382 : 4938 : g_free (node->name);
383 : 4938 : g_free (struct_->gtype_name);
384 : 4938 : g_free (struct_->gtype_init);
385 : 4938 : g_free (struct_->copy_func);
386 : 4938 : g_free (struct_->free_func);
387 : :
388 : 51724 : for (l = struct_->members; l; l = l->next)
389 : 46786 : gi_ir_node_free ((GIIrNode *)l->data);
390 : 4938 : g_list_free (struct_->members);
391 : : }
392 : 4938 : break;
393 : :
394 : 2645 : case GI_IR_NODE_CONSTANT:
395 : : {
396 : 5276 : GIIrNodeConstant *constant = (GIIrNodeConstant *)node;
397 : :
398 : 5276 : g_free (node->name);
399 : 5276 : g_free (constant->value);
400 : 5276 : gi_ir_node_free ((GIIrNode *)constant->type);
401 : : }
402 : 5276 : break;
403 : :
404 : 146 : case GI_IR_NODE_XREF:
405 : : {
406 : 275 : GIIrNodeXRef *xref = (GIIrNodeXRef *)node;
407 : :
408 : 275 : g_free (node->name);
409 : 275 : g_free (xref->namespace);
410 : : }
411 : 275 : break;
412 : :
413 : 103 : case GI_IR_NODE_UNION:
414 : : {
415 : 206 : GIIrNodeUnion *union_ = (GIIrNodeUnion *)node;
416 : :
417 : 206 : g_free (node->name);
418 : 206 : g_free (union_->gtype_name);
419 : 206 : g_free (union_->gtype_init);
420 : 206 : g_free (union_->copy_func);
421 : 206 : g_free (union_->free_func);
422 : :
423 : 206 : gi_ir_node_free ((GIIrNode *)union_->discriminator_type);
424 : 206 : g_clear_list (&union_->members, (GDestroyNotify) gi_ir_node_free);
425 : 206 : g_clear_list (&union_->discriminators, (GDestroyNotify) gi_ir_node_free);
426 : : }
427 : 206 : break;
428 : :
429 : 0 : default:
430 : 0 : g_error ("Unhandled node type %d", node->type);
431 : 0 : break;
432 : : }
433 : :
434 : 610013 : g_hash_table_destroy (node->attributes);
435 : :
436 : 610013 : g_free (node);
437 : 681729 : }
438 : :
439 : : /* returns the fixed size of the blob */
440 : : uint32_t
441 : 94286 : gi_ir_node_get_size (GIIrNode *node)
442 : : {
443 : : GList *l;
444 : : size_t size, n;
445 : :
446 : 94286 : switch (node->type)
447 : : {
448 : 4099 : case GI_IR_NODE_CALLBACK:
449 : 8190 : size = sizeof (CallbackBlob);
450 : 8190 : break;
451 : :
452 : 18372 : case GI_IR_NODE_FUNCTION:
453 : 36439 : size = sizeof (FunctionBlob);
454 : 36439 : break;
455 : :
456 : 0 : case GI_IR_NODE_PARAM:
457 : : /* See the comment in the GI_IR_NODE_PARAM/ArgBlob writing below */
458 : 0 : size = sizeof (ArgBlob) - sizeof (SimpleTypeBlob);
459 : 0 : break;
460 : :
461 : 0 : case GI_IR_NODE_TYPE:
462 : 0 : size = sizeof (SimpleTypeBlob);
463 : 0 : break;
464 : :
465 : 868 : case GI_IR_NODE_OBJECT:
466 : : {
467 : 1730 : GIIrNodeInterface *iface = (GIIrNodeInterface *)node;
468 : :
469 : 1730 : n = g_list_length (iface->interfaces);
470 : 1730 : size = sizeof (ObjectBlob) + 2 * (n + (n % 2));
471 : :
472 : 26144 : for (l = iface->members; l; l = l->next)
473 : 24414 : size += gi_ir_node_get_size ((GIIrNode *)l->data);
474 : : }
475 : 1730 : break;
476 : :
477 : 232 : case GI_IR_NODE_INTERFACE:
478 : : {
479 : 460 : GIIrNodeInterface *iface = (GIIrNodeInterface *)node;
480 : :
481 : 460 : n = g_list_length (iface->prerequisites);
482 : 460 : size = sizeof (InterfaceBlob) + 2 * (n + (n % 2));
483 : :
484 : 9972 : for (l = iface->members; l; l = l->next)
485 : 9512 : size += gi_ir_node_get_size ((GIIrNode *)l->data);
486 : : }
487 : 460 : break;
488 : :
489 : 758 : case GI_IR_NODE_ENUM:
490 : : case GI_IR_NODE_FLAGS:
491 : : {
492 : 1515 : GIIrNodeEnum *enum_ = (GIIrNodeEnum *)node;
493 : :
494 : 1515 : size = sizeof (EnumBlob);
495 : 12170 : for (l = enum_->values; l; l = l->next)
496 : 10655 : size += gi_ir_node_get_size ((GIIrNode *)l->data);
497 : 1683 : for (l = enum_->methods; l; l = l->next)
498 : 168 : size += gi_ir_node_get_size ((GIIrNode *)l->data);
499 : : }
500 : 1515 : break;
501 : :
502 : 5328 : case GI_IR_NODE_VALUE:
503 : 10655 : size = sizeof (ValueBlob);
504 : 10655 : break;
505 : :
506 : 1762 : case GI_IR_NODE_STRUCT:
507 : : {
508 : 3512 : GIIrNodeStruct *struct_ = (GIIrNodeStruct *)node;
509 : :
510 : 3512 : size = sizeof (StructBlob);
511 : 26822 : for (l = struct_->members; l; l = l->next)
512 : 23310 : size += gi_ir_node_get_size ((GIIrNode *)l->data);
513 : : }
514 : 3512 : break;
515 : :
516 : 210 : case GI_IR_NODE_BOXED:
517 : : {
518 : 420 : GIIrNodeBoxed *boxed = (GIIrNodeBoxed *)node;
519 : :
520 : 420 : size = sizeof (StructBlob);
521 : 444 : for (l = boxed->members; l; l = l->next)
522 : 24 : size += gi_ir_node_get_size ((GIIrNode *)l->data);
523 : : }
524 : 420 : break;
525 : :
526 : 1698 : case GI_IR_NODE_PROPERTY:
527 : 3392 : size = sizeof (PropertyBlob);
528 : 3392 : break;
529 : :
530 : 496 : case GI_IR_NODE_SIGNAL:
531 : 988 : size = sizeof (SignalBlob);
532 : 988 : break;
533 : :
534 : 3304 : case GI_IR_NODE_VFUNC:
535 : 6604 : size = sizeof (VFuncBlob);
536 : 6604 : break;
537 : :
538 : 8871 : case GI_IR_NODE_FIELD:
539 : : {
540 : 17726 : GIIrNodeField *field = (GIIrNodeField *)node;
541 : :
542 : 17726 : size = sizeof (FieldBlob);
543 : 17726 : if (field->callback)
544 : 7066 : size += gi_ir_node_get_size ((GIIrNode *)field->callback);
545 : : }
546 : 17726 : break;
547 : :
548 : 1304 : case GI_IR_NODE_CONSTANT:
549 : 2603 : size = sizeof (ConstantBlob);
550 : 2603 : break;
551 : :
552 : 0 : case GI_IR_NODE_XREF:
553 : 0 : size = 0;
554 : 0 : break;
555 : :
556 : 26 : case GI_IR_NODE_UNION:
557 : : {
558 : 52 : GIIrNodeUnion *union_ = (GIIrNodeUnion *)node;
559 : :
560 : 52 : size = sizeof (UnionBlob);
561 : 430 : for (l = union_->members; l; l = l->next)
562 : 378 : size += gi_ir_node_get_size ((GIIrNode *)l->data);
563 : 52 : for (l = union_->discriminators; l; l = l->next)
564 : 0 : size += gi_ir_node_get_size ((GIIrNode *)l->data);
565 : : }
566 : 52 : break;
567 : :
568 : 0 : default:
569 : 0 : g_error ("Unhandled node type '%s'", gi_ir_node_type_to_string (node->type));
570 : 0 : size = 0;
571 : 0 : }
572 : :
573 : 141244 : g_debug ("node %p type '%s' size %zu", node,
574 : 46958 : gi_ir_node_type_to_string (node->type), size);
575 : :
576 : 94286 : g_assert (size <= G_MAXUINT32);
577 : :
578 : 94286 : return (guint32) size;
579 : : }
580 : :
581 : : static void
582 : 42620 : add_attribute_size (gpointer key, gpointer value, gpointer data)
583 : : {
584 : 42620 : const char *key_str = key;
585 : 42620 : const char *value_str = value;
586 : 42620 : size_t *size_p = data;
587 : :
588 : 42620 : *size_p += sizeof (AttributeBlob);
589 : 42620 : *size_p += ALIGN_VALUE (strlen (key_str) + 1, 4);
590 : 42620 : *size_p += ALIGN_VALUE (strlen (value_str) + 1, 4);
591 : 42620 : }
592 : :
593 : : /* returns the full size of the blob including variable-size parts (including attributes) */
594 : : static uint32_t
595 : 1919468 : gi_ir_node_get_full_size_internal (GIIrNode *parent,
596 : : GIIrNode *node)
597 : : {
598 : : GList *l;
599 : : size_t size, n;
600 : :
601 : 1919468 : g_assert (node != NULL);
602 : :
603 : 2874176 : g_debug ("node %p type '%s'", node,
604 : 954708 : gi_ir_node_type_to_string (node->type));
605 : :
606 : 1919468 : switch (node->type)
607 : : {
608 : 19367 : case GI_IR_NODE_CALLBACK:
609 : : {
610 : 38702 : GIIrNodeFunction *function = (GIIrNodeFunction *)node;
611 : 38702 : size = sizeof (CallbackBlob);
612 : 38702 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
613 : 139250 : for (l = function->parameters; l; l = l->next)
614 : : {
615 : 100548 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
616 : 50241 : }
617 : 38702 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)function->result);
618 : : }
619 : 38702 : break;
620 : :
621 : 69787 : case GI_IR_NODE_FUNCTION:
622 : : {
623 : 138413 : GIIrNodeFunction *function = (GIIrNodeFunction *)node;
624 : 138413 : size = sizeof (FunctionBlob);
625 : 138413 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
626 : 138413 : size += ALIGN_VALUE (strlen (function->symbol) + 1, 4);
627 : 340701 : for (l = function->parameters; l; l = l->next)
628 : 202288 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
629 : 138413 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)function->result);
630 : : }
631 : 138413 : break;
632 : :
633 : 325513 : case GI_IR_NODE_PARAM:
634 : : {
635 : 647265 : GIIrNodeParam *param = (GIIrNodeParam *)node;
636 : :
637 : : /* See the comment in the GI_IR_NODE_PARAM/ArgBlob writing below */
638 : 647265 : size = sizeof (ArgBlob) - sizeof (SimpleTypeBlob);
639 : 647265 : if (node->name)
640 : 439782 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
641 : 647265 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)param->type);
642 : : }
643 : 647265 : break;
644 : :
645 : 455679 : case GI_IR_NODE_TYPE:
646 : : {
647 : 906477 : GIIrNodeType *type = (GIIrNodeType *)node;
648 : 906477 : size = sizeof (SimpleTypeBlob);
649 : 906477 : if (!GI_TYPE_TAG_IS_BASIC (type->tag))
650 : : {
651 : 611070 : g_debug ("node %p type tag '%s'", node,
652 : 203003 : gi_type_tag_to_string (type->tag));
653 : :
654 : 408067 : switch (type->tag)
655 : : {
656 : 13415 : case GI_TYPE_TAG_ARRAY:
657 : 26740 : size = sizeof (ArrayTypeBlob);
658 : 26740 : if (type->parameter_type1)
659 : 26740 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)type->parameter_type1);
660 : 26740 : break;
661 : 186824 : case GI_TYPE_TAG_INTERFACE:
662 : 371735 : size += sizeof (InterfaceTypeBlob);
663 : 371735 : break;
664 : 3037 : case GI_TYPE_TAG_GLIST:
665 : : case GI_TYPE_TAG_GSLIST:
666 : 6016 : size += sizeof (ParamTypeBlob);
667 : 6016 : if (type->parameter_type1)
668 : 6016 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)type->parameter_type1);
669 : 6016 : break;
670 : 945 : case GI_TYPE_TAG_GHASH:
671 : 1890 : size += sizeof (ParamTypeBlob) * 2;
672 : 1890 : if (type->parameter_type1)
673 : 1890 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)type->parameter_type1);
674 : 1890 : if (type->parameter_type2)
675 : 1890 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)type->parameter_type2);
676 : 1890 : break;
677 : 843 : case GI_TYPE_TAG_ERROR:
678 : 1686 : size += sizeof (ErrorTypeBlob);
679 : 1686 : break;
680 : 0 : default:
681 : 0 : g_error ("Unknown type tag %d", type->tag);
682 : 0 : break;
683 : : }
684 : 203003 : }
685 : : }
686 : 906477 : break;
687 : :
688 : 2604 : case GI_IR_NODE_OBJECT:
689 : : {
690 : 5190 : GIIrNodeInterface *iface = (GIIrNodeInterface *)node;
691 : :
692 : 5190 : n = g_list_length (iface->interfaces);
693 : 5190 : size = sizeof(ObjectBlob);
694 : 5190 : if (iface->parent)
695 : 5106 : size += ALIGN_VALUE (strlen (iface->parent) + 1, 4);
696 : 5190 : if (iface->glib_type_struct)
697 : 3378 : size += ALIGN_VALUE (strlen (iface->glib_type_struct) + 1, 4);
698 : 5190 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
699 : 5190 : size += ALIGN_VALUE (strlen (iface->gtype_name) + 1, 4);
700 : 5190 : if (iface->gtype_init)
701 : 5190 : size += ALIGN_VALUE (strlen (iface->gtype_init) + 1, 4);
702 : 5190 : if (iface->ref_func)
703 : 36 : size += ALIGN_VALUE (strlen (iface->ref_func) + 1, 4);
704 : 5190 : if (iface->unref_func)
705 : 36 : size += ALIGN_VALUE (strlen (iface->unref_func) + 1, 4);
706 : 5190 : if (iface->set_value_func)
707 : 36 : size += ALIGN_VALUE (strlen (iface->set_value_func) + 1, 4);
708 : 5190 : if (iface->get_value_func)
709 : 36 : size += ALIGN_VALUE (strlen (iface->get_value_func) + 1, 4);
710 : 5190 : size += 2 * (n + (n % 2));
711 : :
712 : 78432 : for (l = iface->members; l; l = l->next)
713 : 73242 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
714 : : }
715 : 5190 : break;
716 : :
717 : 696 : case GI_IR_NODE_INTERFACE:
718 : : {
719 : 1380 : GIIrNodeInterface *iface = (GIIrNodeInterface *)node;
720 : :
721 : 1380 : n = g_list_length (iface->prerequisites);
722 : 1380 : size = sizeof (InterfaceBlob);
723 : 1380 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
724 : 1380 : size += ALIGN_VALUE (strlen (iface->gtype_name) + 1, 4);
725 : 1380 : size += ALIGN_VALUE (strlen (iface->gtype_init) + 1, 4);
726 : 1380 : size += 2 * (n + (n % 2));
727 : :
728 : 29916 : for (l = iface->members; l; l = l->next)
729 : 28536 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
730 : : }
731 : 1380 : break;
732 : :
733 : 2274 : case GI_IR_NODE_ENUM:
734 : : case GI_IR_NODE_FLAGS:
735 : : {
736 : 4545 : GIIrNodeEnum *enum_ = (GIIrNodeEnum *)node;
737 : :
738 : 4545 : size = sizeof (EnumBlob);
739 : 4545 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
740 : 4545 : if (enum_->gtype_name)
741 : : {
742 : 3150 : size += ALIGN_VALUE (strlen (enum_->gtype_name) + 1, 4);
743 : 3150 : size += ALIGN_VALUE (strlen (enum_->gtype_init) + 1, 4);
744 : 1575 : }
745 : 4545 : if (enum_->error_domain)
746 : 486 : size += ALIGN_VALUE (strlen (enum_->error_domain) + 1, 4);
747 : :
748 : 36510 : for (l = enum_->values; l; l = l->next)
749 : 31965 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
750 : 5049 : for (l = enum_->methods; l; l = l->next)
751 : 504 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
752 : : }
753 : 4545 : break;
754 : :
755 : 21312 : case GI_IR_NODE_VALUE:
756 : : {
757 : 42620 : size = sizeof (ValueBlob);
758 : 42620 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
759 : : }
760 : 42620 : break;
761 : :
762 : 5286 : case GI_IR_NODE_STRUCT:
763 : : {
764 : 10536 : GIIrNodeStruct *struct_ = (GIIrNodeStruct *)node;
765 : :
766 : 10536 : size = sizeof (StructBlob);
767 : 10536 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
768 : 10536 : if (struct_->gtype_name)
769 : 1266 : size += ALIGN_VALUE (strlen (struct_->gtype_name) + 1, 4);
770 : 10536 : if (struct_->gtype_init)
771 : 1266 : size += ALIGN_VALUE (strlen (struct_->gtype_init) + 1, 4);
772 : 10536 : if (struct_->copy_func)
773 : 108 : size += ALIGN_VALUE (strlen (struct_->copy_func) + 1, 4);
774 : 10536 : if (struct_->free_func)
775 : 108 : size += ALIGN_VALUE (strlen (struct_->free_func) + 1, 4);
776 : 80466 : for (l = struct_->members; l; l = l->next)
777 : 69930 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
778 : : }
779 : 10536 : break;
780 : :
781 : 630 : case GI_IR_NODE_BOXED:
782 : : {
783 : 1260 : GIIrNodeBoxed *boxed = (GIIrNodeBoxed *)node;
784 : :
785 : 1260 : size = sizeof (StructBlob);
786 : 1260 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
787 : 1260 : if (boxed->gtype_name)
788 : : {
789 : 1260 : size += ALIGN_VALUE (strlen (boxed->gtype_name) + 1, 4);
790 : 1260 : size += ALIGN_VALUE (strlen (boxed->gtype_init) + 1, 4);
791 : 630 : }
792 : 1332 : for (l = boxed->members; l; l = l->next)
793 : 72 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
794 : : }
795 : 1260 : break;
796 : :
797 : 6792 : case GI_IR_NODE_PROPERTY:
798 : : {
799 : 13568 : GIIrNodeProperty *prop = (GIIrNodeProperty *)node;
800 : :
801 : 13568 : size = sizeof (PropertyBlob);
802 : 13568 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
803 : 13568 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)prop->type);
804 : : }
805 : 13568 : break;
806 : :
807 : 1984 : case GI_IR_NODE_SIGNAL:
808 : : {
809 : 3952 : GIIrNodeSignal *signal = (GIIrNodeSignal *)node;
810 : :
811 : 3952 : size = sizeof (SignalBlob);
812 : 3952 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
813 : 9040 : for (l = signal->parameters; l; l = l->next)
814 : 5088 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
815 : 3952 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)signal->result);
816 : : }
817 : 3952 : break;
818 : :
819 : 13216 : case GI_IR_NODE_VFUNC:
820 : : {
821 : 26416 : GIIrNodeVFunc *vfunc = (GIIrNodeVFunc *)node;
822 : :
823 : 26416 : size = sizeof (VFuncBlob);
824 : 26416 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
825 : 70104 : for (l = vfunc->parameters; l; l = l->next)
826 : 43688 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
827 : 26416 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)vfunc->result);
828 : : }
829 : 26416 : break;
830 : :
831 : 35484 : case GI_IR_NODE_FIELD:
832 : : {
833 : 70904 : GIIrNodeField *field = (GIIrNodeField *)node;
834 : :
835 : 70904 : size = sizeof (FieldBlob);
836 : 70904 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
837 : 70904 : if (field->callback)
838 : 28264 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)field->callback);
839 : : else
840 : 42640 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)field->type);
841 : : }
842 : 70904 : break;
843 : :
844 : 3912 : case GI_IR_NODE_CONSTANT:
845 : : {
846 : 7809 : GIIrNodeConstant *constant = (GIIrNodeConstant *)node;
847 : :
848 : 7809 : size = sizeof (ConstantBlob);
849 : 7809 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
850 : : /* FIXME non-string values */
851 : 7809 : size += ALIGN_VALUE (strlen (constant->value) + 1, 4);
852 : 7809 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)constant->type);
853 : : }
854 : 7809 : break;
855 : :
856 : 146 : case GI_IR_NODE_XREF:
857 : : {
858 : 275 : GIIrNodeXRef *xref = (GIIrNodeXRef *)node;
859 : :
860 : 275 : size = 0;
861 : 275 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
862 : 275 : size += ALIGN_VALUE (strlen (xref->namespace) + 1, 4);
863 : : }
864 : 275 : break;
865 : :
866 : 78 : case GI_IR_NODE_UNION:
867 : : {
868 : 156 : GIIrNodeUnion *union_ = (GIIrNodeUnion *)node;
869 : :
870 : 156 : size = sizeof (UnionBlob);
871 : 156 : size += ALIGN_VALUE (strlen (node->name) + 1, 4);
872 : 156 : if (union_->gtype_name)
873 : 0 : size += ALIGN_VALUE (strlen (union_->gtype_name) + 1, 4);
874 : 156 : if (union_->gtype_init)
875 : 0 : size += ALIGN_VALUE (strlen (union_->gtype_init) + 1, 4);
876 : 156 : if (union_->copy_func)
877 : 0 : size += ALIGN_VALUE (strlen (union_->copy_func) + 1, 4);
878 : 156 : if (union_->free_func)
879 : 0 : size += ALIGN_VALUE (strlen (union_->free_func) + 1, 4);
880 : 1290 : for (l = union_->members; l; l = l->next)
881 : 1134 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
882 : 156 : for (l = union_->discriminators; l; l = l->next)
883 : 0 : size += gi_ir_node_get_full_size_internal (node, (GIIrNode *)l->data);
884 : : }
885 : 156 : break;
886 : :
887 : 0 : default:
888 : 0 : g_error ("Unknown type tag %d", node->type);
889 : 0 : size = 0;
890 : 0 : }
891 : :
892 : 1919468 : g_debug ("node %s%s%s%p type '%s' full size %zu",
893 : 954708 : node->name ? "'" : "",
894 : 954708 : node->name ? node->name : "",
895 : 954708 : node->name ? "' " : "",
896 : 954708 : node, gi_ir_node_type_to_string (node->type), size);
897 : :
898 : 1919468 : g_hash_table_foreach (node->attributes, add_attribute_size, &size);
899 : :
900 : 1919468 : g_assert (size <= G_MAXUINT32);
901 : :
902 : 1919468 : return size;
903 : : }
904 : :
905 : : uint32_t
906 : 378908 : gi_ir_node_get_full_size (GIIrNode *node)
907 : : {
908 : 378908 : return gi_ir_node_get_full_size_internal (NULL, node);
909 : : }
910 : :
911 : : int
912 : 0 : gi_ir_node_cmp (GIIrNode *node,
913 : : GIIrNode *other)
914 : : {
915 : 0 : if (node->type < other->type)
916 : 0 : return -1;
917 : 0 : else if (node->type > other->type)
918 : 0 : return 1;
919 : : else
920 : 0 : return strcmp (node->name, other->name);
921 : 0 : }
922 : :
923 : : gboolean
924 : 0 : gi_ir_node_can_have_member (GIIrNode *node)
925 : : {
926 : 0 : switch (node->type)
927 : : {
928 : 0 : case GI_IR_NODE_OBJECT:
929 : : case GI_IR_NODE_INTERFACE:
930 : : case GI_IR_NODE_BOXED:
931 : : case GI_IR_NODE_STRUCT:
932 : : case GI_IR_NODE_UNION:
933 : 0 : return TRUE;
934 : : /* list others individually rather than with default: so that compiler
935 : : * warns if new node types are added without adding them to the switch
936 : : */
937 : 0 : case GI_IR_NODE_INVALID:
938 : : case GI_IR_NODE_FUNCTION:
939 : : case GI_IR_NODE_CALLBACK:
940 : : case GI_IR_NODE_ENUM:
941 : : case GI_IR_NODE_FLAGS:
942 : : case GI_IR_NODE_CONSTANT:
943 : : case GI_IR_NODE_INVALID_0:
944 : : case GI_IR_NODE_PARAM:
945 : : case GI_IR_NODE_TYPE:
946 : : case GI_IR_NODE_PROPERTY:
947 : : case GI_IR_NODE_SIGNAL:
948 : : case GI_IR_NODE_VALUE:
949 : : case GI_IR_NODE_VFUNC:
950 : : case GI_IR_NODE_FIELD:
951 : : case GI_IR_NODE_XREF:
952 : 0 : return FALSE;
953 : 0 : default:
954 : : g_assert_not_reached ();
955 : 0 : };
956 : 0 : return FALSE;
957 : 0 : }
958 : :
959 : : void
960 : 0 : gi_ir_node_add_member (GIIrNode *node,
961 : : GIIrNodeFunction *member)
962 : : {
963 : 0 : g_return_if_fail (node != NULL);
964 : 0 : g_return_if_fail (member != NULL);
965 : :
966 : 0 : switch (node->type)
967 : : {
968 : 0 : case GI_IR_NODE_OBJECT:
969 : : case GI_IR_NODE_INTERFACE:
970 : : {
971 : 0 : GIIrNodeInterface *iface = (GIIrNodeInterface *)node;
972 : 0 : iface->members =
973 : 0 : g_list_insert_sorted (iface->members, member,
974 : : (GCompareFunc) gi_ir_node_cmp);
975 : 0 : break;
976 : : }
977 : 0 : case GI_IR_NODE_BOXED:
978 : : {
979 : 0 : GIIrNodeBoxed *boxed = (GIIrNodeBoxed *)node;
980 : 0 : boxed->members =
981 : 0 : g_list_insert_sorted (boxed->members, member,
982 : : (GCompareFunc) gi_ir_node_cmp);
983 : 0 : break;
984 : : }
985 : 0 : case GI_IR_NODE_STRUCT:
986 : : {
987 : 0 : GIIrNodeStruct *struct_ = (GIIrNodeStruct *)node;
988 : 0 : struct_->members =
989 : 0 : g_list_insert_sorted (struct_->members, member,
990 : : (GCompareFunc) gi_ir_node_cmp);
991 : 0 : break;
992 : : }
993 : 0 : case GI_IR_NODE_UNION:
994 : : {
995 : 0 : GIIrNodeUnion *union_ = (GIIrNodeUnion *)node;
996 : 0 : union_->members =
997 : 0 : g_list_insert_sorted (union_->members, member,
998 : : (GCompareFunc) gi_ir_node_cmp);
999 : 0 : break;
1000 : : }
1001 : 0 : default:
1002 : 0 : g_error ("Cannot add a member to unknown type tag type %d",
1003 : 0 : node->type);
1004 : 0 : break;
1005 : : }
1006 : 0 : }
1007 : :
1008 : : const char *
1009 : 0 : gi_ir_node_param_direction_string (GIIrNodeParam * node)
1010 : : {
1011 : 0 : if (node->out)
1012 : : {
1013 : 0 : if (node->in)
1014 : 0 : return "in-out";
1015 : : else
1016 : 0 : return "out";
1017 : : }
1018 : 0 : return "in";
1019 : 0 : }
1020 : :
1021 : : static int64_t
1022 : 615 : parse_int_value (const char *str)
1023 : : {
1024 : 615 : return g_ascii_strtoll (str, NULL, 0);
1025 : : }
1026 : :
1027 : : static uint64_t
1028 : 42 : parse_uint_value (const char *str)
1029 : : {
1030 : 42 : return g_ascii_strtoull (str, NULL, 0);
1031 : : }
1032 : :
1033 : : static double
1034 : 48 : parse_float_value (const char *str)
1035 : : {
1036 : 48 : return g_ascii_strtod (str, NULL);
1037 : : }
1038 : :
1039 : : static gboolean
1040 : 36 : parse_boolean_value (const char *str)
1041 : : {
1042 : 36 : if (g_ascii_strcasecmp (str, "TRUE") == 0)
1043 : 18 : return TRUE;
1044 : :
1045 : 18 : if (g_ascii_strcasecmp (str, "FALSE") == 0)
1046 : 18 : return FALSE;
1047 : :
1048 : 0 : return parse_int_value (str) ? TRUE : FALSE;
1049 : 18 : }
1050 : :
1051 : : static GIIrNode *
1052 : 75829 : find_entry_node (GIIrTypelibBuild *build,
1053 : : const char *name,
1054 : : uint16_t *idx)
1055 : :
1056 : : {
1057 : 75829 : GIIrModule *module = build->module;
1058 : : GList *l;
1059 : : size_t i;
1060 : : unsigned int n_names;
1061 : : char **names;
1062 : 75829 : GIIrNode *result = NULL;
1063 : :
1064 : 75829 : g_assert (name != NULL);
1065 : 75829 : g_assert (strlen (name) > 0);
1066 : :
1067 : 75829 : names = g_strsplit (name, ".", 0);
1068 : 75829 : n_names = g_strv_length (names);
1069 : 75829 : if (n_names > 2)
1070 : 0 : g_error ("Too many name parts");
1071 : :
1072 : 20296407 : for (l = module->entries, i = 1; l; l = l->next, i++)
1073 : : {
1074 : 20296132 : GIIrNode *node = (GIIrNode *)l->data;
1075 : :
1076 : 20296132 : if (n_names > 1)
1077 : : {
1078 : 6048837 : if (node->type != GI_IR_NODE_XREF)
1079 : 5986686 : continue;
1080 : :
1081 : 62151 : if (((GIIrNodeXRef *)node)->namespace == NULL ||
1082 : 62151 : strcmp (((GIIrNodeXRef *)node)->namespace, names[0]) != 0)
1083 : 23408 : continue;
1084 : 19041 : }
1085 : :
1086 : 14286038 : if (strcmp (node->name, names[n_names - 1]) == 0)
1087 : : {
1088 : 75554 : if (idx)
1089 : 11348 : *idx = i;
1090 : :
1091 : 75554 : result = node;
1092 : 75554 : goto out;
1093 : : }
1094 : 7085644 : }
1095 : :
1096 : 275 : if (n_names > 1)
1097 : : {
1098 : 275 : GIIrNode *node = gi_ir_node_new (GI_IR_NODE_XREF, module);
1099 : :
1100 : 275 : ((GIIrNodeXRef *)node)->namespace = g_strdup (names[0]);
1101 : 275 : node->name = g_strdup (names[1]);
1102 : :
1103 : 275 : module->entries = g_list_append (module->entries, node);
1104 : :
1105 : 275 : if (idx)
1106 : 29 : *idx = g_list_length (module->entries);
1107 : :
1108 : 275 : result = node;
1109 : :
1110 : 275 : g_debug ("Creating XREF: %s %s", names[0], names[1]);
1111 : :
1112 : 275 : goto out;
1113 : : }
1114 : :
1115 : :
1116 : 0 : gi_ir_module_fatal (build, 0, "type reference '%s' not found", name);
1117 : 38131 : out:
1118 : :
1119 : 75829 : g_strfreev (names);
1120 : :
1121 : 75829 : return result;
1122 : : }
1123 : :
1124 : : static uint16_t
1125 : 11377 : find_entry (GIIrTypelibBuild *build,
1126 : : const char *name)
1127 : : {
1128 : 11377 : uint16_t idx = 0;
1129 : :
1130 : 11377 : find_entry_node (build, name, &idx);
1131 : :
1132 : 11377 : return idx;
1133 : : }
1134 : :
1135 : : static GIIrModule *
1136 : 887 : find_namespace (GIIrModule *module,
1137 : : const char *name)
1138 : : {
1139 : : GIIrModule *target;
1140 : : GList *l;
1141 : :
1142 : 887 : if (strcmp (module->name, name) == 0)
1143 : 0 : return module;
1144 : :
1145 : 938 : for (l = module->include_modules; l; l = l->next)
1146 : : {
1147 : 887 : GIIrModule *submodule = l->data;
1148 : :
1149 : 887 : if (strcmp (submodule->name, name) == 0)
1150 : 819 : return submodule;
1151 : :
1152 : 68 : target = find_namespace (submodule, name);
1153 : 68 : if (target)
1154 : 17 : return target;
1155 : 18 : }
1156 : 51 : return NULL;
1157 : 430 : }
1158 : :
1159 : : GIIrNode *
1160 : 1711 : gi_ir_find_node (GIIrTypelibBuild *build,
1161 : : GIIrModule *src_module,
1162 : : const char *name)
1163 : : {
1164 : : GList *l;
1165 : 1711 : GIIrNode *return_node = NULL;
1166 : 1711 : char **names = g_strsplit (name, ".", 0);
1167 : 1711 : unsigned n_names = g_strv_length (names);
1168 : : const char *target_name;
1169 : : GIIrModule *target_module;
1170 : :
1171 : 1711 : if (n_names == 1)
1172 : : {
1173 : 892 : target_module = src_module;
1174 : 892 : target_name = name;
1175 : 446 : }
1176 : : else
1177 : : {
1178 : 819 : target_module = find_namespace (build->module, names[0]);
1179 : 819 : target_name = names[1];
1180 : : }
1181 : :
1182 : : /* find_namespace() may return NULL. */
1183 : 1711 : if (target_module == NULL)
1184 : 0 : goto done;
1185 : :
1186 : 259132 : for (l = target_module->entries; l; l = l->next)
1187 : : {
1188 : 259132 : GIIrNode *node = (GIIrNode *)l->data;
1189 : :
1190 : 259132 : if (strcmp (node->name, target_name) == 0)
1191 : : {
1192 : 1711 : return_node = node;
1193 : 1711 : break;
1194 : : }
1195 : 128876 : }
1196 : :
1197 : 0 : done:
1198 : 1711 : g_strfreev (names);
1199 : :
1200 : 1711 : return return_node;
1201 : : }
1202 : :
1203 : : static int
1204 : 17424 : get_index_of_member_type (GIIrNodeInterface *node,
1205 : : GIIrNodeTypeId type,
1206 : : const char *name)
1207 : : {
1208 : 17424 : int index = -1;
1209 : : GList *l;
1210 : :
1211 : 696538 : for (l = node->members; l; l = l->next)
1212 : : {
1213 : 696478 : GIIrNode *member_node = l->data;
1214 : :
1215 : 696478 : if (member_node->type != type)
1216 : 376382 : continue;
1217 : :
1218 : 320096 : index++;
1219 : :
1220 : 320096 : if (strcmp (member_node->name, name) == 0)
1221 : 17364 : break;
1222 : 150922 : }
1223 : :
1224 : 17424 : return index;
1225 : : }
1226 : :
1227 : : static int
1228 : 3828 : get_index_for_function (GIIrTypelibBuild *build,
1229 : : GIIrNode *parent,
1230 : : const char *name)
1231 : : {
1232 : 3828 : if (parent == NULL)
1233 : : {
1234 : 228 : uint16_t index = find_entry (build, name);
1235 : 228 : if (index == 0)
1236 : 0 : return -1;
1237 : :
1238 : 228 : return index;
1239 : : }
1240 : :
1241 : 3600 : int index = get_index_of_member_type ((GIIrNodeInterface *) parent, GI_IR_NODE_FUNCTION, name);
1242 : 3600 : if (index != -1)
1243 : 3600 : return index;
1244 : :
1245 : 0 : return -1;
1246 : 1896 : }
1247 : :
1248 : : static void
1249 : 75342 : serialize_type (GIIrTypelibBuild *build,
1250 : : GIIrNodeType *node,
1251 : : GString *str)
1252 : : {
1253 : : size_t i;
1254 : :
1255 : 75342 : if (GI_TYPE_TAG_IS_BASIC (node->tag))
1256 : : {
1257 : 6244 : g_string_append_printf (str, "%s%s", gi_type_tag_to_string (node->tag),
1258 : 4168 : node->is_pointer ? "*" : "");
1259 : 2076 : }
1260 : 71174 : else if (node->tag == GI_TYPE_TAG_ARRAY)
1261 : : {
1262 : 4934 : if (node->array_type == GI_ARRAY_TYPE_C)
1263 : : {
1264 : 4316 : serialize_type (build, node->parameter_type1, str);
1265 : 4316 : g_string_append (str, "[");
1266 : :
1267 : 4316 : if (node->has_length)
1268 : 2096 : g_string_append_printf (str, "length=%d", node->length);
1269 : 2220 : else if (node->has_size)
1270 : 418 : g_string_append_printf (str, "fixed-size=%" G_GSIZE_FORMAT, node->size);
1271 : :
1272 : 4316 : if (node->zero_terminated)
1273 : 2675 : g_string_append_printf (str, "%szero-terminated=1",
1274 : 1786 : node->has_length ? "," : "");
1275 : :
1276 : 4316 : g_string_append (str, "]");
1277 : 4316 : if (node->is_pointer)
1278 : 5859 : g_string_append (str, "*");
1279 : 2148 : }
1280 : 618 : else if (node->array_type == GI_ARRAY_TYPE_BYTE_ARRAY)
1281 : : {
1282 : : /* We on purpose skip serializing parameter_type1, which should
1283 : : always be void*
1284 : : */
1285 : 765 : g_string_append (str, "GByteArray");
1286 : 255 : }
1287 : : else
1288 : : {
1289 : 108 : if (node->array_type == GI_ARRAY_TYPE_ARRAY)
1290 : 54 : g_string_append (str, "GArray");
1291 : : else
1292 : 108 : g_string_append (str, "GPtrArray");
1293 : 108 : if (node->parameter_type1)
1294 : : {
1295 : 108 : g_string_append (str, "<");
1296 : 108 : serialize_type (build, node->parameter_type1, str);
1297 : 162 : g_string_append (str, ">");
1298 : 54 : }
1299 : : }
1300 : 2457 : }
1301 : 66240 : else if (node->tag == GI_TYPE_TAG_INTERFACE)
1302 : : {
1303 : : GIIrNode *iface;
1304 : : char *name;
1305 : :
1306 : 64452 : iface = find_entry_node (build, node->giinterface, NULL);
1307 : 64452 : if (iface)
1308 : : {
1309 : 64452 : if (iface->type == GI_IR_NODE_XREF)
1310 : 6966 : g_string_append_printf (str, "%s.", ((GIIrNodeXRef *)iface)->namespace);
1311 : 64452 : name = iface->name;
1312 : 32049 : }
1313 : : else
1314 : : {
1315 : 0 : g_warning ("Interface for type reference %s not found", node->giinterface);
1316 : 0 : name = node->giinterface;
1317 : : }
1318 : :
1319 : 96501 : g_string_append_printf (str, "%s%s", name,
1320 : 64452 : node->is_pointer ? "*" : "");
1321 : 32049 : }
1322 : 1788 : else if (node->tag == GI_TYPE_TAG_GLIST)
1323 : : {
1324 : 1062 : g_string_append (str, "GList");
1325 : 1062 : if (node->parameter_type1)
1326 : : {
1327 : 1062 : g_string_append (str, "<");
1328 : 1062 : serialize_type (build, node->parameter_type1, str);
1329 : 1599 : g_string_append (str, ">");
1330 : 525 : }
1331 : 525 : }
1332 : 726 : else if (node->tag == GI_TYPE_TAG_GSLIST)
1333 : : {
1334 : 72 : g_string_append (str, "GSList");
1335 : 72 : if (node->parameter_type1)
1336 : : {
1337 : 72 : g_string_append (str, "<");
1338 : 72 : serialize_type (build, node->parameter_type1, str);
1339 : 108 : g_string_append (str, ">");
1340 : 36 : }
1341 : 36 : }
1342 : 654 : else if (node->tag == GI_TYPE_TAG_GHASH)
1343 : : {
1344 : 342 : g_string_append (str, "GHashTable");
1345 : 342 : if (node->parameter_type1)
1346 : : {
1347 : 342 : g_string_append (str, "<");
1348 : 342 : serialize_type (build, node->parameter_type1, str);
1349 : 342 : g_string_append (str, ",");
1350 : 342 : serialize_type (build, node->parameter_type2, str);
1351 : 513 : g_string_append (str, ">");
1352 : 171 : }
1353 : 171 : }
1354 : 312 : else if (node->tag == GI_TYPE_TAG_ERROR)
1355 : : {
1356 : 312 : g_string_append (str, "GError");
1357 : 312 : if (node->errors)
1358 : : {
1359 : 0 : g_string_append (str, "<");
1360 : 0 : for (i = 0; node->errors[i]; i++)
1361 : : {
1362 : 0 : if (i > 0)
1363 : 0 : g_string_append (str, ",");
1364 : 0 : g_string_append (str, node->errors[i]);
1365 : 0 : }
1366 : 0 : g_string_append (str, ">");
1367 : 0 : }
1368 : 156 : }
1369 : 75342 : }
1370 : :
1371 : : static void
1372 : 20648 : gi_ir_node_build_members (GList **members,
1373 : : GIIrNodeTypeId type,
1374 : : uint16_t *count,
1375 : : GIIrNode *parent,
1376 : : GIIrTypelibBuild *build,
1377 : : uint32_t *offset,
1378 : : uint32_t *offset2,
1379 : : uint16_t *count2)
1380 : : {
1381 : 20648 : GList *l = *members;
1382 : :
1383 : 150596 : while (l)
1384 : : {
1385 : 129948 : GIIrNode *member = (GIIrNode *)l->data;
1386 : 129948 : GList *next = l->next;
1387 : :
1388 : 129948 : if (member->type == type)
1389 : : {
1390 : 57638 : (*count)++;
1391 : 57638 : gi_ir_node_build_typelib (member, parent, build, offset, offset2, count2);
1392 : 57638 : *members = g_list_delete_link (*members, l);
1393 : 28682 : }
1394 : 129948 : l = next;
1395 : : }
1396 : 20648 : }
1397 : :
1398 : : static void
1399 : 6174 : gi_ir_node_check_unhandled_members (GList **members,
1400 : : GIIrNodeTypeId container_type)
1401 : : {
1402 : : #if 0
1403 : : if (*members)
1404 : : {
1405 : : GList *l;
1406 : :
1407 : : for (l = *members; l; l = l->next)
1408 : : {
1409 : : GIIrNode *member = (GIIrNode *)l->data;
1410 : : g_printerr ("Unhandled '%s' member '%s' type '%s'\n",
1411 : : gi_ir_node_type_to_string (container_type),
1412 : : member->name,
1413 : : gi_ir_node_type_to_string (member->type));
1414 : : }
1415 : :
1416 : : g_list_free (*members);
1417 : : *members = NULL;
1418 : :
1419 : : g_error ("Unhandled members. Aborting.");
1420 : : }
1421 : : #else
1422 : 6174 : g_list_free (*members);
1423 : 6174 : *members = NULL;
1424 : : #endif
1425 : 6174 : }
1426 : :
1427 : : void
1428 : 341115 : gi_ir_node_build_typelib (GIIrNode *node,
1429 : : GIIrNode *parent,
1430 : : GIIrTypelibBuild *build,
1431 : : uint32_t *offset,
1432 : : uint32_t *offset2,
1433 : : uint16_t *count2)
1434 : : {
1435 : : gboolean appended_stack;
1436 : 341115 : GHashTable *strings = build->strings;
1437 : 341115 : GHashTable *types = build->types;
1438 : 341115 : uint8_t *data = build->data;
1439 : : GList *l;
1440 : 341115 : uint32_t old_offset = *offset;
1441 : 341115 : uint32_t old_offset2 = *offset2;
1442 : :
1443 : 341115 : g_assert (node != NULL);
1444 : :
1445 : 341115 : g_debug ("build_typelib: %s%s(%s)",
1446 : 169662 : node->name ? node->name : "",
1447 : 169662 : node->name ? " " : "",
1448 : 169662 : gi_ir_node_type_to_string (node->type));
1449 : :
1450 : 341115 : if (build->stack)
1451 : 322356 : appended_stack = node != (GIIrNode*)build->stack->data;
1452 : : else
1453 : 18759 : appended_stack = TRUE;
1454 : 341115 : if (appended_stack)
1455 : 341115 : build->stack = g_list_prepend (build->stack, node);
1456 : :
1457 : 341115 : gi_ir_node_compute_offsets (build, node);
1458 : :
1459 : : /* We should only be building each node once. If we do a typelib expansion, we also
1460 : : * reset the offset in girmodule.c.
1461 : : */
1462 : 341115 : g_assert (node->offset == 0);
1463 : 341115 : node->offset = *offset;
1464 : 341115 : build->nodes_with_attributes = g_list_prepend (build->nodes_with_attributes, node);
1465 : :
1466 : 341115 : build->n_attributes += g_hash_table_size (node->attributes);
1467 : :
1468 : 341115 : switch (node->type)
1469 : : {
1470 : 79776 : case GI_IR_NODE_TYPE:
1471 : : {
1472 : 158659 : GIIrNodeType *type = (GIIrNodeType *)node;
1473 : 158659 : SimpleTypeBlob *blob = (SimpleTypeBlob *)&data[*offset];
1474 : :
1475 : 158659 : *offset += sizeof (SimpleTypeBlob);
1476 : :
1477 : 158659 : if (GI_TYPE_TAG_IS_BASIC (type->tag))
1478 : : {
1479 : 89559 : blob->flags.reserved = 0;
1480 : 89559 : blob->flags.reserved2 = 0;
1481 : 89559 : blob->flags.pointer = type->is_pointer;
1482 : 89559 : blob->flags.reserved3 = 0;
1483 : 89559 : blob->flags.tag = type->tag;
1484 : 44518 : }
1485 : : else
1486 : : {
1487 : : GString *str;
1488 : : gpointer value;
1489 : :
1490 : 69100 : str = g_string_new (0);
1491 : 69100 : serialize_type (build, type, str);
1492 : :
1493 : 69100 : types_count += 1;
1494 : 69100 : value = g_hash_table_lookup (types, str->str);
1495 : 69100 : if (value)
1496 : : {
1497 : 60602 : blob->offset = GPOINTER_TO_UINT (value);
1498 : 60602 : g_string_free (g_steal_pointer (&str), TRUE);
1499 : 30154 : }
1500 : : else
1501 : : {
1502 : 8498 : unique_types_count += 1;
1503 : 12709 : g_hash_table_insert (types, g_string_free_and_steal (g_steal_pointer (&str)),
1504 : 8498 : GUINT_TO_POINTER(*offset2));
1505 : :
1506 : 8498 : blob->offset = *offset2;
1507 : 8498 : switch (type->tag)
1508 : : {
1509 : 636 : case GI_TYPE_TAG_ARRAY:
1510 : : {
1511 : 1257 : ArrayTypeBlob *array = (ArrayTypeBlob *)&data[*offset2];
1512 : : uint32_t pos;
1513 : :
1514 : 1257 : array->pointer = type->is_pointer;
1515 : 1257 : array->reserved = 0;
1516 : 1257 : array->tag = type->tag;
1517 : 1257 : array->zero_terminated = type->zero_terminated;
1518 : 1257 : array->has_length = type->has_length;
1519 : 1257 : array->has_size = type->has_size;
1520 : 1257 : array->array_type = type->array_type;
1521 : 1257 : array->reserved2 = 0;
1522 : 1257 : if (array->has_length)
1523 : 722 : array->dimensions.length = type->length;
1524 : 535 : else if (array->has_size)
1525 : 230 : array->dimensions.size = type->size;
1526 : :
1527 : 1257 : pos = *offset2 + G_STRUCT_OFFSET (ArrayTypeBlob, type);
1528 : 1257 : *offset2 += sizeof (ArrayTypeBlob);
1529 : :
1530 : 1878 : gi_ir_node_build_typelib ((GIIrNode *)type->parameter_type1,
1531 : 621 : node, build, &pos, offset2, NULL);
1532 : : }
1533 : 1257 : break;
1534 : :
1535 : 3478 : case GI_TYPE_TAG_INTERFACE:
1536 : : {
1537 : 6903 : InterfaceTypeBlob *iface = (InterfaceTypeBlob *)&data[*offset2];
1538 : 6903 : *offset2 += sizeof (InterfaceTypeBlob);
1539 : :
1540 : 6903 : iface->pointer = type->is_pointer;
1541 : 6903 : iface->reserved = 0;
1542 : 6903 : iface->tag = type->tag;
1543 : 6903 : iface->reserved2 = 0;
1544 : 6903 : iface->interface = find_entry (build, type->giinterface);
1545 : :
1546 : : }
1547 : 6903 : break;
1548 : :
1549 : 146 : case GI_TYPE_TAG_GLIST:
1550 : : case GI_TYPE_TAG_GSLIST:
1551 : : {
1552 : 284 : ParamTypeBlob *param = (ParamTypeBlob *)&data[*offset2];
1553 : : uint32_t pos;
1554 : :
1555 : 284 : param->pointer = 1;
1556 : 284 : param->reserved = 0;
1557 : 284 : param->tag = type->tag;
1558 : 284 : param->reserved2 = 0;
1559 : 284 : param->n_types = 1;
1560 : :
1561 : 284 : pos = *offset2 + G_STRUCT_OFFSET (ParamTypeBlob, type);
1562 : 284 : *offset2 += sizeof (ParamTypeBlob) + sizeof (SimpleTypeBlob);
1563 : :
1564 : 422 : gi_ir_node_build_typelib ((GIIrNode *)type->parameter_type1,
1565 : 138 : node, build, &pos, offset2, NULL);
1566 : : }
1567 : 284 : break;
1568 : :
1569 : 18 : case GI_TYPE_TAG_GHASH:
1570 : : {
1571 : 36 : ParamTypeBlob *param = (ParamTypeBlob *)&data[*offset2];
1572 : : uint32_t pos;
1573 : :
1574 : 36 : param->pointer = 1;
1575 : 36 : param->reserved = 0;
1576 : 36 : param->tag = type->tag;
1577 : 36 : param->reserved2 = 0;
1578 : 36 : param->n_types = 2;
1579 : :
1580 : 36 : pos = *offset2 + G_STRUCT_OFFSET (ParamTypeBlob, type);
1581 : 36 : *offset2 += sizeof (ParamTypeBlob) + sizeof (SimpleTypeBlob)*2;
1582 : :
1583 : 54 : gi_ir_node_build_typelib ((GIIrNode *)type->parameter_type1,
1584 : 18 : node, build, &pos, offset2, NULL);
1585 : 54 : gi_ir_node_build_typelib ((GIIrNode *)type->parameter_type2,
1586 : 18 : node, build, &pos, offset2, NULL);
1587 : : }
1588 : 36 : break;
1589 : :
1590 : 9 : case GI_TYPE_TAG_ERROR:
1591 : : {
1592 : 18 : ErrorTypeBlob *error_blob = (ErrorTypeBlob *)&data[*offset2];
1593 : :
1594 : 18 : error_blob->pointer = 1;
1595 : 18 : error_blob->reserved = 0;
1596 : 18 : error_blob->tag = type->tag;
1597 : 18 : error_blob->reserved2 = 0;
1598 : 18 : error_blob->n_domains = 0;
1599 : :
1600 : 18 : *offset2 += sizeof (ErrorTypeBlob);
1601 : : }
1602 : 18 : break;
1603 : :
1604 : 0 : default:
1605 : 0 : g_error ("Unknown type tag %d", type->tag);
1606 : 0 : break;
1607 : : }
1608 : : }
1609 : : }
1610 : : }
1611 : 158659 : break;
1612 : :
1613 : 8871 : case GI_IR_NODE_FIELD:
1614 : : {
1615 : 17726 : GIIrNodeField *field = (GIIrNodeField *)node;
1616 : : FieldBlob *blob;
1617 : :
1618 : 17726 : blob = (FieldBlob *)&data[*offset];
1619 : :
1620 : 17726 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
1621 : 17726 : blob->readable = field->readable;
1622 : 17726 : blob->writable = field->writable;
1623 : 17726 : blob->reserved = 0;
1624 : 17726 : blob->bits = 0;
1625 : 17726 : if (field->offset_state == GI_IR_OFFSETS_COMPUTED)
1626 : 17726 : blob->struct_offset = field->offset;
1627 : : else
1628 : 0 : blob->struct_offset = 0xFFFF; /* mark as unknown */
1629 : :
1630 : 17726 : if (field->callback)
1631 : : {
1632 : 7066 : blob->has_embedded_type = TRUE;
1633 : 7066 : blob->type.offset = GI_INFO_TYPE_CALLBACK;
1634 : 7066 : *offset += sizeof (FieldBlob);
1635 : 10597 : gi_ir_node_build_typelib ((GIIrNode *)field->callback,
1636 : 3531 : node, build, offset, offset2, NULL);
1637 : : /* Fields with callbacks are bigger than normal, update count2
1638 : : * as an extra hint which represents the number of fields which are
1639 : : * callbacks. This allows us to gain constant time performance in the
1640 : : * repository for skipping over the fields section.
1641 : : */
1642 : 7066 : if (count2)
1643 : 0 : (*count2)++;
1644 : 3531 : }
1645 : : else
1646 : : {
1647 : 10660 : blob->has_embedded_type = FALSE;
1648 : : /* We handle the size member specially below, so subtract it */
1649 : 10660 : *offset += sizeof (FieldBlob) - sizeof (SimpleTypeBlob);
1650 : 15984 : gi_ir_node_build_typelib ((GIIrNode *)field->type,
1651 : 5324 : node, build, offset, offset2, NULL);
1652 : : }
1653 : : }
1654 : 17726 : break;
1655 : :
1656 : 1698 : case GI_IR_NODE_PROPERTY:
1657 : : {
1658 : 3392 : GIIrNodeProperty *prop = (GIIrNodeProperty *)node;
1659 : 3392 : PropertyBlob *blob = (PropertyBlob *)&data[*offset];
1660 : : /* We handle the size member specially below, so subtract it */
1661 : 3392 : *offset += sizeof (PropertyBlob) - sizeof (SimpleTypeBlob);
1662 : :
1663 : 3392 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
1664 : 3392 : blob->deprecated = prop->deprecated;
1665 : 3392 : blob->readable = prop->readable;
1666 : 3392 : blob->writable = prop->writable;
1667 : 3392 : blob->construct = prop->construct;
1668 : 3392 : blob->construct_only = prop->construct_only;
1669 : 3392 : blob->transfer_ownership = prop->transfer;
1670 : 3392 : blob->transfer_container_ownership = prop->shallow_transfer;
1671 : 3392 : blob->reserved = 0;
1672 : :
1673 : 3392 : if (prop->setter != NULL)
1674 : : {
1675 : 1416 : int index = get_index_of_member_type ((GIIrNodeInterface*)parent,
1676 : : GI_IR_NODE_FUNCTION,
1677 : 944 : prop->setter);
1678 : 944 : if (index == -1)
1679 : : {
1680 : 0 : g_error ("Unknown setter %s for property %s:%s", prop->setter, parent->name, node->name);
1681 : 0 : }
1682 : :
1683 : 944 : blob->setter = (uint16_t) index;
1684 : 472 : }
1685 : : else
1686 : 2448 : blob->setter = ACCESSOR_SENTINEL;
1687 : :
1688 : 3392 : if (prop->getter != NULL)
1689 : : {
1690 : 3556 : int index = get_index_of_member_type ((GIIrNodeInterface*)parent,
1691 : : GI_IR_NODE_FUNCTION,
1692 : 2372 : prop->getter);
1693 : 2372 : if (index == -1)
1694 : : {
1695 : 0 : g_error ("Unknown getter %s for property %s:%s", prop->getter, parent->name, node->name);
1696 : 0 : }
1697 : :
1698 : 2372 : blob->getter = (uint16_t) index;
1699 : 1184 : }
1700 : : else
1701 : 1020 : blob->getter = ACCESSOR_SENTINEL;
1702 : :
1703 : 5086 : gi_ir_node_build_typelib ((GIIrNode *)prop->type,
1704 : 1694 : node, build, offset, offset2, NULL);
1705 : : }
1706 : 3392 : break;
1707 : :
1708 : 18372 : case GI_IR_NODE_FUNCTION:
1709 : : {
1710 : 36439 : FunctionBlob *blob = (FunctionBlob *)&data[*offset];
1711 : 36439 : SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1712 : 36439 : GIIrNodeFunction *function = (GIIrNodeFunction *)node;
1713 : : uint32_t signature;
1714 : : unsigned int n;
1715 : :
1716 : 36439 : signature = *offset2;
1717 : 36439 : n = g_list_length (function->parameters);
1718 : :
1719 : 36439 : *offset += sizeof (FunctionBlob);
1720 : 36439 : *offset2 += sizeof (SignatureBlob) + n * sizeof (ArgBlob);
1721 : :
1722 : 36439 : blob->blob_type = BLOB_TYPE_FUNCTION;
1723 : 36439 : blob->deprecated = function->deprecated;
1724 : 36439 : blob->is_static = !function->is_method;
1725 : 36439 : blob->setter = FALSE;
1726 : 36439 : blob->getter = FALSE;
1727 : 36439 : blob->constructor = function->is_constructor;
1728 : 36439 : blob->wraps_vfunc = function->wraps_vfunc;
1729 : 36439 : blob->throws = function->throws; /* Deprecated. Also stored in SignatureBlob. */
1730 : 36439 : blob->index = 0;
1731 : 36439 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
1732 : 36439 : blob->symbol = gi_ir_write_string (function->symbol, strings, data, offset2);
1733 : 36439 : blob->signature = signature;
1734 : 36439 : blob->finish = ASYNC_SENTINEL;
1735 : 36439 : blob->sync_or_async = ASYNC_SENTINEL;
1736 : 36439 : blob->is_async = function->is_async;
1737 : :
1738 : 36439 : if (function->is_async)
1739 : : {
1740 : 1584 : if (function->sync_func != NULL)
1741 : : {
1742 : 546 : int sync_index =
1743 : 1650 : get_index_for_function (build,
1744 : 546 : parent,
1745 : 1104 : function->sync_func);
1746 : :
1747 : 1104 : if (sync_index == -1)
1748 : : {
1749 : 0 : g_error ("Unknown sync function %s:%s",
1750 : 0 : parent->name, function->sync_func);
1751 : 0 : }
1752 : :
1753 : 1104 : blob->sync_or_async = (uint16_t) sync_index;
1754 : 546 : }
1755 : :
1756 : 1584 : if (function->finish_func != NULL)
1757 : : {
1758 : 786 : int finish_index =
1759 : 2370 : get_index_for_function (build,
1760 : 786 : parent,
1761 : 1584 : function->finish_func);
1762 : :
1763 : 1584 : if (finish_index == -1)
1764 : : {
1765 : 0 : g_error ("Unknown finish function %s:%s", parent->name, function->finish_func);
1766 : 0 : }
1767 : :
1768 : 1584 : blob->finish = (uint16_t) finish_index;
1769 : 786 : }
1770 : 786 : }
1771 : : else
1772 : : {
1773 : 34855 : if (function->async_func != NULL)
1774 : : {
1775 : 564 : int async_index =
1776 : 1704 : get_index_for_function (build,
1777 : 564 : parent,
1778 : 1140 : function->async_func);
1779 : :
1780 : 1140 : if (async_index == -1)
1781 : : {
1782 : 0 : g_error ("Unknown async function %s:%s", parent->name, function->async_func);
1783 : 0 : }
1784 : :
1785 : 1140 : blob->sync_or_async = (uint16_t) async_index;
1786 : 564 : }
1787 : : }
1788 : :
1789 : :
1790 : 36439 : if (function->is_setter || function->is_getter)
1791 : : {
1792 : 4990 : int index = get_index_of_member_type ((GIIrNodeInterface*)parent,
1793 : : GI_IR_NODE_PROPERTY,
1794 : 3328 : function->property);
1795 : 3328 : if (index == -1)
1796 : : {
1797 : 0 : g_error ("Unknown property %s:%s for accessor %s", parent->name, function->property, function->symbol);
1798 : 0 : }
1799 : :
1800 : 3328 : blob->setter = function->is_setter;
1801 : 3328 : blob->getter = function->is_getter;
1802 : 3328 : blob->index = (uint16_t) index;
1803 : 1662 : }
1804 : :
1805 : : /* function->result is special since it doesn't appear in the serialized format but
1806 : : * we do want the attributes for it to appear
1807 : : */
1808 : 36439 : build->nodes_with_attributes = g_list_prepend (build->nodes_with_attributes, function->result);
1809 : 36439 : build->n_attributes += g_hash_table_size (((GIIrNode *) function->result)->attributes);
1810 : 36439 : g_assert (((GIIrNode *) function->result)->offset == 0);
1811 : 36439 : ((GIIrNode *) function->result)->offset = signature;
1812 : :
1813 : 36439 : g_debug ("building function '%s'", function->symbol);
1814 : :
1815 : 54506 : gi_ir_node_build_typelib ((GIIrNode *)function->result->type,
1816 : 18067 : node, build, &signature, offset2, NULL);
1817 : :
1818 : 36439 : blob2->may_return_null = function->result->nullable;
1819 : 36439 : blob2->caller_owns_return_value = function->result->transfer;
1820 : 36439 : blob2->caller_owns_return_container = function->result->shallow_transfer;
1821 : 36439 : blob2->skip_return = function->result->skip;
1822 : 36439 : blob2->instance_transfer_ownership = function->instance_transfer_full;
1823 : 36439 : blob2->reserved = 0;
1824 : 36439 : blob2->n_arguments = n;
1825 : 36439 : blob2->throws = function->throws;
1826 : :
1827 : 36439 : signature += 4;
1828 : :
1829 : 91087 : for (l = function->parameters; l; l = l->next)
1830 : : {
1831 : 54648 : GIIrNode *param = (GIIrNode *)l->data;
1832 : :
1833 : 54648 : gi_ir_node_build_typelib (param, node, build, &signature, offset2, NULL);
1834 : 27070 : }
1835 : :
1836 : : }
1837 : 36439 : break;
1838 : :
1839 : 4099 : case GI_IR_NODE_CALLBACK:
1840 : : {
1841 : 8190 : CallbackBlob *blob = (CallbackBlob *)&data[*offset];
1842 : 8190 : SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1843 : 8190 : GIIrNodeFunction *function = (GIIrNodeFunction *)node;
1844 : : uint32_t signature;
1845 : : unsigned int n;
1846 : :
1847 : 8190 : signature = *offset2;
1848 : 8190 : n = g_list_length (function->parameters);
1849 : :
1850 : 8190 : *offset += sizeof (CallbackBlob);
1851 : 8190 : *offset2 += sizeof (SignatureBlob) + n * sizeof (ArgBlob);
1852 : :
1853 : 8190 : blob->blob_type = BLOB_TYPE_CALLBACK;
1854 : 8190 : blob->deprecated = function->deprecated;
1855 : 8190 : blob->reserved = 0;
1856 : 8190 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
1857 : 8190 : blob->signature = signature;
1858 : :
1859 : 12281 : gi_ir_node_build_typelib ((GIIrNode *)function->result->type,
1860 : 4091 : node, build, &signature, offset2, NULL);
1861 : :
1862 : 8190 : blob2->may_return_null = function->result->nullable;
1863 : 8190 : blob2->caller_owns_return_value = function->result->transfer;
1864 : 8190 : blob2->caller_owns_return_container = function->result->shallow_transfer;
1865 : 8190 : blob2->reserved = 0;
1866 : 8190 : blob2->n_arguments = n;
1867 : 8190 : blob2->throws = function->throws;
1868 : :
1869 : 8190 : signature += 4;
1870 : :
1871 : 29518 : for (l = function->parameters; l; l = l->next)
1872 : : {
1873 : 21328 : GIIrNode *param = (GIIrNode *)l->data;
1874 : :
1875 : 21328 : gi_ir_node_build_typelib (param, node, build, &signature, offset2, NULL);
1876 : 10655 : }
1877 : : }
1878 : 8190 : break;
1879 : :
1880 : 496 : case GI_IR_NODE_SIGNAL:
1881 : : {
1882 : 988 : SignalBlob *blob = (SignalBlob *)&data[*offset];
1883 : 988 : SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1884 : 988 : GIIrNodeSignal *signal = (GIIrNodeSignal *)node;
1885 : : uint32_t signature;
1886 : : unsigned int n;
1887 : :
1888 : 988 : signature = *offset2;
1889 : 988 : n = g_list_length (signal->parameters);
1890 : :
1891 : 988 : *offset += sizeof (SignalBlob);
1892 : 988 : *offset2 += sizeof (SignatureBlob) + n * sizeof (ArgBlob);
1893 : :
1894 : 988 : blob->deprecated = signal->deprecated;
1895 : 988 : blob->run_first = signal->run_first;
1896 : 988 : blob->run_last = signal->run_last;
1897 : 988 : blob->run_cleanup = signal->run_cleanup;
1898 : 988 : blob->no_recurse = signal->no_recurse;
1899 : 988 : blob->detailed = signal->detailed;
1900 : 988 : blob->action = signal->action;
1901 : 988 : blob->no_hooks = signal->no_hooks;
1902 : 988 : blob->has_class_closure = 0; /* FIXME */
1903 : 988 : blob->true_stops_emit = 0; /* FIXME */
1904 : 988 : blob->reserved = 0;
1905 : 988 : blob->class_closure = 0; /* FIXME */
1906 : 988 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
1907 : 988 : blob->signature = signature;
1908 : :
1909 : : /* signal->result is special since it doesn't appear in the serialized format but
1910 : : * we do want the attributes for it to appear
1911 : : */
1912 : 988 : build->nodes_with_attributes = g_list_prepend (build->nodes_with_attributes, signal->result);
1913 : 988 : build->n_attributes += g_hash_table_size (((GIIrNode *) signal->result)->attributes);
1914 : 988 : g_assert (((GIIrNode *) signal->result)->offset == 0);
1915 : 988 : ((GIIrNode *) signal->result)->offset = signature;
1916 : :
1917 : 1480 : gi_ir_node_build_typelib ((GIIrNode *)signal->result->type,
1918 : 492 : node, build, &signature, offset2, NULL);
1919 : :
1920 : 988 : blob2->may_return_null = signal->result->nullable;
1921 : 988 : blob2->caller_owns_return_value = signal->result->transfer;
1922 : 988 : blob2->caller_owns_return_container = signal->result->shallow_transfer;
1923 : 988 : blob2->instance_transfer_ownership = signal->instance_transfer_full;
1924 : 988 : blob2->reserved = 0;
1925 : 988 : blob2->n_arguments = n;
1926 : :
1927 : 988 : signature += 4;
1928 : :
1929 : 2260 : for (l = signal->parameters; l; l = l->next)
1930 : : {
1931 : 1272 : GIIrNode *param = (GIIrNode *)l->data;
1932 : :
1933 : 1272 : gi_ir_node_build_typelib (param, node, build, &signature, offset2, NULL);
1934 : 636 : }
1935 : : }
1936 : 988 : break;
1937 : :
1938 : 3304 : case GI_IR_NODE_VFUNC:
1939 : : {
1940 : 6604 : VFuncBlob *blob = (VFuncBlob *)&data[*offset];
1941 : 6604 : SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1942 : 6604 : GIIrNodeVFunc *vfunc = (GIIrNodeVFunc *)node;
1943 : : uint32_t signature;
1944 : : unsigned int n;
1945 : :
1946 : 6604 : signature = *offset2;
1947 : 6604 : n = g_list_length (vfunc->parameters);
1948 : :
1949 : 6604 : *offset += sizeof (VFuncBlob);
1950 : 6604 : *offset2 += sizeof (SignatureBlob) + n * sizeof (ArgBlob);
1951 : :
1952 : 6604 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
1953 : 6604 : blob->must_chain_up = 0; /* FIXME */
1954 : 6604 : blob->must_be_implemented = 0; /* FIXME */
1955 : 6604 : blob->must_not_be_implemented = 0; /* FIXME */
1956 : 6604 : blob->class_closure = 0; /* FIXME */
1957 : 6604 : blob->throws = vfunc->throws; /* Deprecated. Also stored in SignatureBlob. */
1958 : 6604 : blob->reserved = 0;
1959 : 6604 : blob->is_async = vfunc->is_async;
1960 : 6604 : blob->finish = ASYNC_SENTINEL;
1961 : 6604 : blob->sync_or_async = ASYNC_SENTINEL;
1962 : :
1963 : 6604 : if (vfunc->invoker)
1964 : : {
1965 : 5104 : int index = get_index_of_member_type ((GIIrNodeInterface*)parent, GI_IR_NODE_FUNCTION, vfunc->invoker);
1966 : 5104 : if (index == -1)
1967 : : {
1968 : 0 : g_error ("Unknown member function %s for vfunc %s", vfunc->invoker, node->name);
1969 : 0 : }
1970 : 5104 : blob->invoker = (uint16_t) index;
1971 : 2550 : }
1972 : : else
1973 : 1500 : blob->invoker = 0x3ff; /* max of 10 bits */
1974 : :
1975 : 6604 : if (vfunc->is_async)
1976 : : {
1977 : 948 : if (vfunc->sync_func != NULL)
1978 : : {
1979 : 282 : int sync_index =
1980 : 846 : get_index_of_member_type ((GIIrNodeInterface *) parent,
1981 : : GI_IR_NODE_VFUNC,
1982 : 564 : vfunc->sync_func);
1983 : :
1984 : 564 : if (sync_index == -1)
1985 : : {
1986 : 0 : g_error ("Unknown sync vfunc %s:%s for accessor %s",
1987 : 0 : parent->name, vfunc->sync_func, vfunc->invoker);
1988 : 0 : }
1989 : :
1990 : 564 : blob->sync_or_async = (uint16_t) sync_index;
1991 : 282 : }
1992 : :
1993 : 948 : if (vfunc->finish_func != NULL)
1994 : : {
1995 : 474 : int finish_index =
1996 : 1422 : get_index_of_member_type ((GIIrNodeInterface *) parent,
1997 : : GI_IR_NODE_VFUNC,
1998 : 948 : vfunc->finish_func);
1999 : :
2000 : 948 : if (finish_index == -1)
2001 : : {
2002 : 0 : g_error ("Unknown finish vfunc %s:%s for function %s",
2003 : 0 : parent->name, vfunc->finish_func, vfunc->invoker);
2004 : 0 : }
2005 : :
2006 : 948 : blob->finish = (uint16_t) finish_index;
2007 : 474 : }
2008 : 474 : }
2009 : : else
2010 : : {
2011 : 5656 : if (vfunc->async_func != NULL)
2012 : : {
2013 : 282 : int async_index =
2014 : 846 : get_index_of_member_type ((GIIrNodeInterface *) parent,
2015 : : GI_IR_NODE_VFUNC,
2016 : 564 : vfunc->async_func);
2017 : 564 : if (async_index == -1)
2018 : : {
2019 : 0 : g_error ("Unknown async vfunc %s:%s for accessor %s",
2020 : 0 : parent->name, vfunc->async_func, vfunc->invoker);
2021 : 0 : }
2022 : :
2023 : 564 : blob->sync_or_async = (uint16_t) async_index;
2024 : 282 : }
2025 : : }
2026 : :
2027 : 6604 : blob->struct_offset = vfunc->offset;
2028 : 6604 : blob->reserved2 = 0;
2029 : 6604 : blob->signature = signature;
2030 : 6604 : blob->is_static = vfunc->is_static;
2031 : :
2032 : 9904 : gi_ir_node_build_typelib ((GIIrNode *)vfunc->result->type,
2033 : 3300 : node, build, &signature, offset2, NULL);
2034 : :
2035 : 6604 : blob2->may_return_null = vfunc->result->nullable;
2036 : 6604 : blob2->caller_owns_return_value = vfunc->result->transfer;
2037 : 6604 : blob2->caller_owns_return_container = vfunc->result->shallow_transfer;
2038 : 6604 : blob2->instance_transfer_ownership = vfunc->instance_transfer_full;
2039 : 6604 : blob2->reserved = 0;
2040 : 6604 : blob2->n_arguments = n;
2041 : 6604 : blob2->throws = vfunc->throws;
2042 : :
2043 : 6604 : signature += 4;
2044 : :
2045 : 17526 : for (l = vfunc->parameters; l; l = l->next)
2046 : : {
2047 : 10922 : GIIrNode *param = (GIIrNode *)l->data;
2048 : :
2049 : 10922 : gi_ir_node_build_typelib (param, node, build, &signature, offset2, NULL);
2050 : 5460 : }
2051 : : }
2052 : 6604 : break;
2053 : :
2054 : 44349 : case GI_IR_NODE_PARAM:
2055 : : {
2056 : 88170 : ArgBlob *blob = (ArgBlob *)&data[*offset];
2057 : 88170 : GIIrNodeParam *param = (GIIrNodeParam *)node;
2058 : :
2059 : : /* The offset for this one is smaller than the struct because
2060 : : * we recursively build the simple type inline here below.
2061 : : */
2062 : 88170 : *offset += sizeof (ArgBlob) - sizeof (SimpleTypeBlob);
2063 : :
2064 : 88170 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
2065 : 88170 : blob->in = param->in;
2066 : 88170 : blob->out = param->out;
2067 : 88170 : blob->caller_allocates = param->caller_allocates;
2068 : 88170 : blob->nullable = param->nullable;
2069 : 88170 : blob->skip = param->skip;
2070 : 88170 : blob->optional = param->optional;
2071 : 88170 : blob->transfer_ownership = param->transfer;
2072 : 88170 : blob->transfer_container_ownership = param->shallow_transfer;
2073 : 88170 : blob->return_value = param->retval;
2074 : 88170 : blob->scope = param->scope;
2075 : 88170 : blob->reserved = 0;
2076 : 88170 : blob->closure = param->closure;
2077 : 88170 : blob->destroy = param->destroy;
2078 : :
2079 : 88170 : gi_ir_node_build_typelib ((GIIrNode *)param->type, node, build, offset, offset2, NULL);
2080 : : }
2081 : 88170 : break;
2082 : :
2083 : 1762 : case GI_IR_NODE_STRUCT:
2084 : : {
2085 : 3512 : StructBlob *blob = (StructBlob *)&data[*offset];
2086 : 3512 : GIIrNodeStruct *struct_ = (GIIrNodeStruct *)node;
2087 : : GList *members;
2088 : :
2089 : 3512 : blob->blob_type = BLOB_TYPE_STRUCT;
2090 : 3512 : blob->foreign = struct_->foreign;
2091 : 3512 : blob->deprecated = struct_->deprecated;
2092 : 3512 : blob->is_gtype_struct = struct_->is_gtype_struct;
2093 : 3512 : blob->reserved = 0;
2094 : 3512 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
2095 : 3512 : blob->alignment = struct_->alignment;
2096 : 3512 : blob->size = struct_->size;
2097 : :
2098 : 3512 : if (struct_->gtype_name)
2099 : : {
2100 : 422 : blob->unregistered = FALSE;
2101 : 422 : blob->gtype_name = gi_ir_write_string (struct_->gtype_name, strings, data, offset2);
2102 : 422 : blob->gtype_init = gi_ir_write_string (struct_->gtype_init, strings, data, offset2);
2103 : 209 : }
2104 : : else
2105 : : {
2106 : 3090 : blob->unregistered = TRUE;
2107 : 3090 : blob->gtype_name = 0;
2108 : 3090 : blob->gtype_init = 0;
2109 : : }
2110 : :
2111 : 3512 : if (struct_->copy_func)
2112 : 36 : blob->copy_func = gi_ir_write_string (struct_->copy_func, strings, data, offset2);
2113 : 3512 : if (struct_->free_func)
2114 : 36 : blob->free_func = gi_ir_write_string (struct_->free_func, strings, data, offset2);
2115 : :
2116 : 3512 : blob->n_fields = 0;
2117 : 3512 : blob->n_methods = 0;
2118 : :
2119 : 3512 : *offset += sizeof (StructBlob);
2120 : :
2121 : 3512 : members = g_list_copy (struct_->members);
2122 : :
2123 : 5262 : gi_ir_node_build_members (&members, GI_IR_NODE_FIELD, &blob->n_fields,
2124 : 1750 : node, build, offset, offset2, NULL);
2125 : :
2126 : 5262 : gi_ir_node_build_members (&members, GI_IR_NODE_FUNCTION, &blob->n_methods,
2127 : 1750 : node, build, offset, offset2, NULL);
2128 : :
2129 : 3512 : gi_ir_node_check_unhandled_members (&members, node->type);
2130 : :
2131 : 3512 : g_assert (members == NULL);
2132 : : }
2133 : 3512 : break;
2134 : :
2135 : 210 : case GI_IR_NODE_BOXED:
2136 : : {
2137 : 420 : StructBlob *blob = (StructBlob *)&data[*offset];
2138 : 420 : GIIrNodeBoxed *boxed = (GIIrNodeBoxed *)node;
2139 : : GList *members;
2140 : :
2141 : 420 : blob->blob_type = BLOB_TYPE_BOXED;
2142 : 420 : blob->deprecated = boxed->deprecated;
2143 : 420 : blob->unregistered = FALSE;
2144 : 420 : blob->reserved = 0;
2145 : 420 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
2146 : 420 : blob->gtype_name = gi_ir_write_string (boxed->gtype_name, strings, data, offset2);
2147 : 420 : blob->gtype_init = gi_ir_write_string (boxed->gtype_init, strings, data, offset2);
2148 : 420 : blob->alignment = boxed->alignment;
2149 : 420 : blob->size = boxed->size;
2150 : :
2151 : 420 : blob->n_fields = 0;
2152 : 420 : blob->n_methods = 0;
2153 : :
2154 : 420 : *offset += sizeof (StructBlob);
2155 : :
2156 : 420 : members = g_list_copy (boxed->members);
2157 : :
2158 : 630 : gi_ir_node_build_members (&members, GI_IR_NODE_FIELD, &blob->n_fields,
2159 : 210 : node, build, offset, offset2, NULL);
2160 : :
2161 : 630 : gi_ir_node_build_members (&members, GI_IR_NODE_FUNCTION, &blob->n_methods,
2162 : 210 : node, build, offset, offset2, NULL);
2163 : :
2164 : 420 : gi_ir_node_check_unhandled_members (&members, node->type);
2165 : :
2166 : 420 : g_assert (members == NULL);
2167 : : }
2168 : 420 : break;
2169 : :
2170 : 26 : case GI_IR_NODE_UNION:
2171 : : {
2172 : 52 : UnionBlob *blob = (UnionBlob *)&data[*offset];
2173 : 52 : GIIrNodeUnion *union_ = (GIIrNodeUnion *)node;
2174 : : GList *members;
2175 : :
2176 : 52 : blob->blob_type = BLOB_TYPE_UNION;
2177 : 52 : blob->deprecated = union_->deprecated;
2178 : 52 : blob->reserved = 0;
2179 : 52 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
2180 : 52 : blob->alignment = union_->alignment;
2181 : 52 : blob->size = union_->size;
2182 : 52 : if (union_->gtype_name)
2183 : : {
2184 : 0 : blob->unregistered = FALSE;
2185 : 0 : blob->gtype_name = gi_ir_write_string (union_->gtype_name, strings, data, offset2);
2186 : 0 : blob->gtype_init = gi_ir_write_string (union_->gtype_init, strings, data, offset2);
2187 : 0 : }
2188 : : else
2189 : : {
2190 : 52 : blob->unregistered = TRUE;
2191 : 52 : blob->gtype_name = 0;
2192 : 52 : blob->gtype_init = 0;
2193 : : }
2194 : :
2195 : 52 : blob->n_fields = 0;
2196 : 52 : blob->n_functions = 0;
2197 : :
2198 : 52 : g_assert (union_->discriminator_offset <= G_MAXINT32);
2199 : 52 : blob->discriminator_offset = (int32_t) union_->discriminator_offset;
2200 : :
2201 : 52 : if (union_->copy_func)
2202 : 0 : blob->copy_func = gi_ir_write_string (union_->copy_func, strings, data, offset2);
2203 : 52 : if (union_->free_func)
2204 : 0 : blob->free_func = gi_ir_write_string (union_->free_func, strings, data, offset2);
2205 : :
2206 : : /* We don't support Union discriminators right now. */
2207 : : /*
2208 : : if (union_->discriminator_type)
2209 : : {
2210 : : *offset += 28;
2211 : : blob->discriminated = TRUE;
2212 : : gi_ir_node_build_typelib ((GIIrNode *)union_->discriminator_type,
2213 : : build, offset, offset2, NULL);
2214 : : }
2215 : : else
2216 : : {
2217 : : */
2218 : 52 : *offset += sizeof (UnionBlob);
2219 : 52 : blob->discriminated = FALSE;
2220 : 52 : blob->discriminator_type.offset = 0;
2221 : :
2222 : 52 : members = g_list_copy (union_->members);
2223 : :
2224 : 78 : gi_ir_node_build_members (&members, GI_IR_NODE_FIELD, &blob->n_fields,
2225 : 26 : node, build, offset, offset2, NULL);
2226 : :
2227 : 78 : gi_ir_node_build_members (&members, GI_IR_NODE_FUNCTION, &blob->n_functions,
2228 : 26 : node, build, offset, offset2, NULL);
2229 : :
2230 : 52 : gi_ir_node_check_unhandled_members (&members, node->type);
2231 : :
2232 : 52 : g_assert (members == NULL);
2233 : :
2234 : 52 : if (union_->discriminator_type)
2235 : : {
2236 : 0 : for (l = union_->discriminators; l; l = l->next)
2237 : : {
2238 : 0 : GIIrNode *member = (GIIrNode *)l->data;
2239 : :
2240 : 0 : gi_ir_node_build_typelib (member, node, build, offset, offset2, NULL);
2241 : 0 : }
2242 : 0 : }
2243 : : }
2244 : 52 : break;
2245 : :
2246 : 758 : case GI_IR_NODE_ENUM:
2247 : : case GI_IR_NODE_FLAGS:
2248 : : {
2249 : 1515 : EnumBlob *blob = (EnumBlob *)&data[*offset];
2250 : 1515 : GIIrNodeEnum *enum_ = (GIIrNodeEnum *)node;
2251 : :
2252 : 1515 : *offset += sizeof (EnumBlob);
2253 : :
2254 : 1515 : if (node->type == GI_IR_NODE_ENUM)
2255 : 753 : blob->blob_type = BLOB_TYPE_ENUM;
2256 : : else
2257 : 762 : blob->blob_type = BLOB_TYPE_FLAGS;
2258 : :
2259 : 1515 : blob->deprecated = enum_->deprecated;
2260 : 1515 : blob->reserved = 0;
2261 : 1515 : blob->storage_type = enum_->storage_type;
2262 : 1515 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
2263 : 1515 : if (enum_->gtype_name)
2264 : : {
2265 : 1050 : blob->unregistered = FALSE;
2266 : 1050 : blob->gtype_name = gi_ir_write_string (enum_->gtype_name, strings, data, offset2);
2267 : 1050 : blob->gtype_init = gi_ir_write_string (enum_->gtype_init, strings, data, offset2);
2268 : 525 : }
2269 : : else
2270 : : {
2271 : 465 : blob->unregistered = TRUE;
2272 : 465 : blob->gtype_name = 0;
2273 : 465 : blob->gtype_init = 0;
2274 : : }
2275 : 1515 : if (enum_->error_domain)
2276 : 162 : blob->error_domain = gi_ir_write_string (enum_->error_domain, strings, data, offset2);
2277 : : else
2278 : 1353 : blob->error_domain = 0;
2279 : :
2280 : 1515 : blob->n_values = 0;
2281 : 1515 : blob->n_methods = 0;
2282 : :
2283 : 12170 : for (l = enum_->values; l; l = l->next)
2284 : : {
2285 : 10655 : GIIrNode *value = (GIIrNode *)l->data;
2286 : :
2287 : 10655 : blob->n_values++;
2288 : 10655 : gi_ir_node_build_typelib (value, node, build, offset, offset2, NULL);
2289 : 5327 : }
2290 : :
2291 : 1683 : for (l = enum_->methods; l; l = l->next)
2292 : : {
2293 : 168 : GIIrNode *method = (GIIrNode *)l->data;
2294 : :
2295 : 168 : blob->n_methods++;
2296 : 168 : gi_ir_node_build_typelib (method, node, build, offset, offset2, NULL);
2297 : 84 : }
2298 : : }
2299 : 1515 : break;
2300 : :
2301 : 868 : case GI_IR_NODE_OBJECT:
2302 : : {
2303 : 1730 : ObjectBlob *blob = (ObjectBlob *)&data[*offset];
2304 : 1730 : GIIrNodeInterface *object = (GIIrNodeInterface *)node;
2305 : : GList *members;
2306 : :
2307 : 1730 : blob->blob_type = BLOB_TYPE_OBJECT;
2308 : 1730 : blob->abstract = object->abstract;
2309 : 1730 : blob->fundamental = object->fundamental;
2310 : 1730 : blob->final_ = object->final_;
2311 : 1730 : blob->deprecated = object->deprecated;
2312 : 1730 : blob->reserved = 0;
2313 : 1730 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
2314 : 1730 : blob->gtype_name = gi_ir_write_string (object->gtype_name, strings, data, offset2);
2315 : 1730 : blob->gtype_init = gi_ir_write_string (object->gtype_init, strings, data, offset2);
2316 : 1730 : if (object->ref_func)
2317 : 12 : blob->ref_func = gi_ir_write_string (object->ref_func, strings, data, offset2);
2318 : 1730 : if (object->unref_func)
2319 : 12 : blob->unref_func = gi_ir_write_string (object->unref_func, strings, data, offset2);
2320 : 1730 : if (object->set_value_func)
2321 : 12 : blob->set_value_func = gi_ir_write_string (object->set_value_func, strings, data, offset2);
2322 : 1730 : if (object->get_value_func)
2323 : 12 : blob->get_value_func = gi_ir_write_string (object->get_value_func, strings, data, offset2);
2324 : 1730 : if (object->parent)
2325 : 1702 : blob->parent = find_entry (build, object->parent);
2326 : : else
2327 : 28 : blob->parent = 0;
2328 : 1730 : if (object->glib_type_struct)
2329 : 1126 : blob->gtype_struct = find_entry (build, object->glib_type_struct);
2330 : : else
2331 : 604 : blob->gtype_struct = 0;
2332 : :
2333 : 1730 : blob->n_interfaces = 0;
2334 : 1730 : blob->n_fields = 0;
2335 : 1730 : blob->n_properties = 0;
2336 : 1730 : blob->n_methods = 0;
2337 : 1730 : blob->n_signals = 0;
2338 : 1730 : blob->n_vfuncs = 0;
2339 : 1730 : blob->n_constants = 0;
2340 : 1730 : blob->n_field_callbacks = 0;
2341 : :
2342 : 1730 : *offset += sizeof(ObjectBlob);
2343 : 2508 : for (l = object->interfaces; l; l = l->next)
2344 : : {
2345 : 778 : blob->n_interfaces++;
2346 : 778 : *(uint16_t *)&data[*offset] = find_entry (build, (char *)l->data);
2347 : 778 : *offset += 2;
2348 : 384 : }
2349 : :
2350 : 1730 : members = g_list_copy (object->members);
2351 : :
2352 : 1730 : *offset = ALIGN_VALUE (*offset, 4);
2353 : 2592 : gi_ir_node_build_members (&members, GI_IR_NODE_FIELD, &blob->n_fields,
2354 : 862 : node, build, offset, offset2, &blob->n_field_callbacks);
2355 : :
2356 : 1730 : *offset = ALIGN_VALUE (*offset, 4);
2357 : 2592 : gi_ir_node_build_members (&members, GI_IR_NODE_PROPERTY, &blob->n_properties,
2358 : 862 : node, build, offset, offset2, NULL);
2359 : :
2360 : 1730 : *offset = ALIGN_VALUE (*offset, 4);
2361 : 2592 : gi_ir_node_build_members (&members, GI_IR_NODE_FUNCTION, &blob->n_methods,
2362 : 862 : node, build, offset, offset2, NULL);
2363 : :
2364 : 1730 : *offset = ALIGN_VALUE (*offset, 4);
2365 : 2592 : gi_ir_node_build_members (&members, GI_IR_NODE_SIGNAL, &blob->n_signals,
2366 : 862 : node, build, offset, offset2, NULL);
2367 : :
2368 : 1730 : *offset = ALIGN_VALUE (*offset, 4);
2369 : 2592 : gi_ir_node_build_members (&members, GI_IR_NODE_VFUNC, &blob->n_vfuncs,
2370 : 862 : node, build, offset, offset2, NULL);
2371 : :
2372 : 1730 : *offset = ALIGN_VALUE (*offset, 4);
2373 : 2592 : gi_ir_node_build_members (&members, GI_IR_NODE_CONSTANT, &blob->n_constants,
2374 : 862 : node, build, offset, offset2, NULL);
2375 : :
2376 : 1730 : gi_ir_node_check_unhandled_members (&members, node->type);
2377 : :
2378 : 1730 : g_assert (members == NULL);
2379 : : }
2380 : 1730 : break;
2381 : :
2382 : 232 : case GI_IR_NODE_INTERFACE:
2383 : : {
2384 : 460 : InterfaceBlob *blob = (InterfaceBlob *)&data[*offset];
2385 : 460 : GIIrNodeInterface *iface = (GIIrNodeInterface *)node;
2386 : : GList *members;
2387 : :
2388 : 460 : blob->blob_type = BLOB_TYPE_INTERFACE;
2389 : 460 : blob->deprecated = iface->deprecated;
2390 : 460 : blob->reserved = 0;
2391 : 460 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
2392 : 460 : blob->gtype_name = gi_ir_write_string (iface->gtype_name, strings, data, offset2);
2393 : 460 : blob->gtype_init = gi_ir_write_string (iface->gtype_init, strings, data, offset2);
2394 : 460 : if (iface->glib_type_struct)
2395 : 448 : blob->gtype_struct = find_entry (build, iface->glib_type_struct);
2396 : : else
2397 : 12 : blob->gtype_struct = 0;
2398 : 460 : blob->n_prerequisites = 0;
2399 : 460 : blob->n_properties = 0;
2400 : 460 : blob->n_methods = 0;
2401 : 460 : blob->n_signals = 0;
2402 : 460 : blob->n_vfuncs = 0;
2403 : 460 : blob->n_constants = 0;
2404 : :
2405 : 460 : *offset += sizeof (InterfaceBlob);
2406 : 652 : for (l = iface->prerequisites; l; l = l->next)
2407 : : {
2408 : 192 : blob->n_prerequisites++;
2409 : 192 : *(uint16_t *)&data[*offset] = find_entry (build, (char *)l->data);
2410 : 192 : *offset += 2;
2411 : 96 : }
2412 : :
2413 : 460 : members = g_list_copy (iface->members);
2414 : :
2415 : 460 : *offset = ALIGN_VALUE (*offset, 4);
2416 : 688 : gi_ir_node_build_members (&members, GI_IR_NODE_PROPERTY, &blob->n_properties,
2417 : 228 : node, build, offset, offset2, NULL);
2418 : :
2419 : 460 : *offset = ALIGN_VALUE (*offset, 4);
2420 : 688 : gi_ir_node_build_members (&members, GI_IR_NODE_FUNCTION, &blob->n_methods,
2421 : 228 : node, build, offset, offset2, NULL);
2422 : :
2423 : 460 : *offset = ALIGN_VALUE (*offset, 4);
2424 : 688 : gi_ir_node_build_members (&members, GI_IR_NODE_SIGNAL, &blob->n_signals,
2425 : 228 : node, build, offset, offset2, NULL);
2426 : :
2427 : 460 : *offset = ALIGN_VALUE (*offset, 4);
2428 : 688 : gi_ir_node_build_members (&members, GI_IR_NODE_VFUNC, &blob->n_vfuncs,
2429 : 228 : node, build, offset, offset2, NULL);
2430 : :
2431 : 460 : *offset = ALIGN_VALUE (*offset, 4);
2432 : 688 : gi_ir_node_build_members (&members, GI_IR_NODE_CONSTANT, &blob->n_constants,
2433 : 228 : node, build, offset, offset2, NULL);
2434 : :
2435 : 460 : gi_ir_node_check_unhandled_members (&members, node->type);
2436 : :
2437 : 460 : g_assert (members == NULL);
2438 : : }
2439 : 460 : break;
2440 : :
2441 : :
2442 : 5328 : case GI_IR_NODE_VALUE:
2443 : : {
2444 : 10655 : GIIrNodeValue *value = (GIIrNodeValue *)node;
2445 : 10655 : ValueBlob *blob = (ValueBlob *)&data[*offset];
2446 : 10655 : *offset += sizeof (ValueBlob);
2447 : :
2448 : 10655 : blob->deprecated = value->deprecated;
2449 : 10655 : blob->reserved = 0;
2450 : 10655 : blob->unsigned_value = value->value >= 0 ? 1 : 0;
2451 : 10655 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
2452 : 10655 : blob->value = (int32_t) value->value;
2453 : : }
2454 : 10655 : break;
2455 : :
2456 : 1304 : case GI_IR_NODE_CONSTANT:
2457 : : {
2458 : 2603 : GIIrNodeConstant *constant = (GIIrNodeConstant *)node;
2459 : 2603 : ConstantBlob *blob = (ConstantBlob *)&data[*offset];
2460 : : uint32_t pos;
2461 : :
2462 : 2603 : pos = *offset + G_STRUCT_OFFSET (ConstantBlob, type);
2463 : 2603 : *offset += sizeof (ConstantBlob);
2464 : :
2465 : 2603 : blob->blob_type = BLOB_TYPE_CONSTANT;
2466 : 2603 : blob->deprecated = constant->deprecated;
2467 : 2603 : blob->reserved = 0;
2468 : 2603 : blob->name = gi_ir_write_string (node->name, strings, data, offset2);
2469 : :
2470 : 2603 : blob->offset = *offset2;
2471 : 2603 : switch (constant->type->tag)
2472 : : {
2473 : 18 : case GI_TYPE_TAG_BOOLEAN:
2474 : 36 : blob->size = 4;
2475 : 36 : *(gboolean*)&data[blob->offset] = parse_boolean_value (constant->value);
2476 : 36 : break;
2477 : 9 : case GI_TYPE_TAG_INT8:
2478 : 18 : blob->size = 1;
2479 : 18 : *(int8_t *)&data[blob->offset] = (int8_t) parse_int_value (constant->value);
2480 : 18 : break;
2481 : 3 : case GI_TYPE_TAG_UINT8:
2482 : 6 : blob->size = 1;
2483 : 6 : *(uint8_t *)&data[blob->offset] = (uint8_t) parse_uint_value (constant->value);
2484 : 6 : break;
2485 : 6 : case GI_TYPE_TAG_INT16:
2486 : 12 : blob->size = 2;
2487 : 12 : *(int16_t *)&data[blob->offset] = (int16_t) parse_int_value (constant->value);
2488 : 12 : break;
2489 : 3 : case GI_TYPE_TAG_UINT16:
2490 : 6 : blob->size = 2;
2491 : 6 : *(uint16_t *)&data[blob->offset] = (uint16_t) parse_uint_value (constant->value);
2492 : 6 : break;
2493 : 273 : case GI_TYPE_TAG_INT32:
2494 : 543 : blob->size = 4;
2495 : 543 : *(int32_t *)&data[blob->offset] = (int32_t) parse_int_value (constant->value);
2496 : 543 : break;
2497 : 3 : case GI_TYPE_TAG_UINT32:
2498 : 6 : blob->size = 4;
2499 : 6 : *(uint32_t*)&data[blob->offset] = (uint32_t) parse_uint_value (constant->value);
2500 : 6 : break;
2501 : 21 : case GI_TYPE_TAG_INT64:
2502 : 42 : blob->size = 8;
2503 : 42 : DO_ALIGNED_COPY (&data[blob->offset], parse_int_value (constant->value), int64_t);
2504 : 42 : break;
2505 : 12 : case GI_TYPE_TAG_UINT64:
2506 : 24 : blob->size = 8;
2507 : 24 : DO_ALIGNED_COPY (&data[blob->offset], parse_uint_value (constant->value), uint64_t);
2508 : 24 : break;
2509 : 0 : case GI_TYPE_TAG_FLOAT:
2510 : 0 : blob->size = sizeof (float);
2511 : 0 : DO_ALIGNED_COPY (&data[blob->offset], (float) parse_float_value (constant->value), float);
2512 : 0 : break;
2513 : 24 : case GI_TYPE_TAG_DOUBLE:
2514 : 48 : blob->size = sizeof (double);
2515 : 48 : DO_ALIGNED_COPY (&data[blob->offset], parse_float_value (constant->value), double);
2516 : 48 : break;
2517 : 932 : case GI_TYPE_TAG_UTF8:
2518 : : case GI_TYPE_TAG_FILENAME:
2519 : 1862 : blob->size = strlen (constant->value) + 1;
2520 : 1862 : memcpy (&data[blob->offset], constant->value, blob->size);
2521 : 1862 : break;
2522 : 0 : default:
2523 : 0 : break;
2524 : : }
2525 : 2603 : *offset2 += ALIGN_VALUE (blob->size, 4);
2526 : :
2527 : 2603 : gi_ir_node_build_typelib ((GIIrNode *)constant->type, node, build, &pos, offset2, NULL);
2528 : : }
2529 : 2603 : break;
2530 : 0 : default:
2531 : : g_assert_not_reached ();
2532 : 0 : }
2533 : :
2534 : 341115 : g_debug ("node %s%s%s%p type '%s', offset %d -> %d, offset2 %d -> %d",
2535 : 169662 : node->name ? "'" : "",
2536 : 169662 : node->name ? node->name : "",
2537 : 169662 : node->name ? "' " : "",
2538 : 169662 : node, gi_ir_node_type_to_string (node->type),
2539 : 169662 : old_offset, *offset, old_offset2, *offset2);
2540 : :
2541 : 341115 : if (*offset2 - old_offset2 + *offset - old_offset > gi_ir_node_get_full_size (node))
2542 : 0 : g_error ("exceeding space reservation; offset: %d (prev %d) offset2: %d (prev %d) nodesize: %d",
2543 : 0 : *offset, old_offset, *offset2, old_offset2, gi_ir_node_get_full_size (node));
2544 : :
2545 : 341115 : if (appended_stack)
2546 : 341115 : build->stack = g_list_delete_link (build->stack, build->stack);
2547 : 341115 : }
2548 : :
2549 : : /* if str is already in the pool, return previous location, otherwise write str
2550 : : * to the typelib at offset, put it in the pool and update offset. If the
2551 : : * typelib is not large enough to hold the string, reallocate it.
2552 : : */
2553 : : uint32_t
2554 : 262009 : gi_ir_write_string (const char *str,
2555 : : GHashTable *strings,
2556 : : uint8_t *data,
2557 : : uint32_t *offset)
2558 : : {
2559 : : uint32_t start;
2560 : : void *value;
2561 : :
2562 : 262009 : string_count += 1;
2563 : 262009 : string_size += strlen (str);
2564 : :
2565 : 262009 : value = g_hash_table_lookup (strings, str);
2566 : :
2567 : 262009 : if (value)
2568 : 145862 : return GPOINTER_TO_UINT (value);
2569 : :
2570 : 116147 : unique_string_count += 1;
2571 : 116147 : unique_string_size += strlen (str);
2572 : :
2573 : 116147 : g_hash_table_insert (strings, (void *)str, GUINT_TO_POINTER (*offset));
2574 : :
2575 : 116147 : start = *offset;
2576 : 116147 : *offset = ALIGN_VALUE (start + strlen (str) + 1, 4);
2577 : :
2578 : 116147 : strcpy ((char *)&data[start], str);
2579 : :
2580 : 116147 : return start;
2581 : 130325 : }
2582 : :
|
