1 /* GObject introspection: Typelib creation
3 * Copyright (C) 2005 Matthias Clasen
4 * Copyright (C) 2008,2009 Red Hat, Inc.
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 02111-1307, USA.
26 #include "girmodule.h"
30 static gulong string_count = 0;
31 static gulong unique_string_count = 0;
32 static gulong string_size = 0;
33 static gulong unique_string_size = 0;
34 static gulong types_count = 0;
35 static gulong unique_types_count = 0;
38 _g_irnode_init_stats (void)
41 unique_string_count = 0;
43 unique_string_size = 0;
45 unique_types_count = 0;
49 _g_irnode_dump_stats (void)
51 g_message ("%lu strings (%lu before sharing), %lu bytes (%lu before sharing)",
52 unique_string_count, string_count, unique_string_size, string_size);
53 g_message ("%lu types (%lu before sharing)", unique_types_count, types_count);
56 #define DO_ALIGNED_COPY(dest_addr, value, type) \
60 memcpy(dest_addr, &tmp_var, sizeof(type)); \
63 #define ALIGN_VALUE(this, boundary) \
64 (( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))
68 g_ir_node_type_to_string (GIrNodeTypeId type)
72 case G_IR_NODE_FUNCTION:
74 case G_IR_NODE_CALLBACK:
80 case G_IR_NODE_OBJECT:
82 case G_IR_NODE_INTERFACE:
84 case G_IR_NODE_SIGNAL:
86 case G_IR_NODE_PROPERTY:
98 case G_IR_NODE_STRUCT:
100 case G_IR_NODE_VALUE:
102 case G_IR_NODE_CONSTANT:
104 case G_IR_NODE_ERROR_DOMAIN:
105 return "error-domain";
108 case G_IR_NODE_UNION:
116 g_ir_node_new (GIrNodeTypeId type)
118 GIrNode *node = NULL;
122 case G_IR_NODE_FUNCTION:
123 case G_IR_NODE_CALLBACK:
124 node = g_malloc0 (sizeof (GIrNodeFunction));
127 case G_IR_NODE_PARAM:
128 node = g_malloc0 (sizeof (GIrNodeParam));
132 node = g_malloc0 (sizeof (GIrNodeType));
135 case G_IR_NODE_OBJECT:
136 case G_IR_NODE_INTERFACE:
137 node = g_malloc0 (sizeof (GIrNodeInterface));
140 case G_IR_NODE_SIGNAL:
141 node = g_malloc0 (sizeof (GIrNodeSignal));
144 case G_IR_NODE_PROPERTY:
145 node = g_malloc0 (sizeof (GIrNodeProperty));
148 case G_IR_NODE_VFUNC:
149 node = g_malloc0 (sizeof (GIrNodeFunction));
152 case G_IR_NODE_FIELD:
153 node = g_malloc0 (sizeof (GIrNodeField));
157 case G_IR_NODE_FLAGS:
158 node = g_malloc0 (sizeof (GIrNodeEnum));
161 case G_IR_NODE_BOXED:
162 node = g_malloc0 (sizeof (GIrNodeBoxed));
165 case G_IR_NODE_STRUCT:
166 node = g_malloc0 (sizeof (GIrNodeStruct));
169 case G_IR_NODE_VALUE:
170 node = g_malloc0 (sizeof (GIrNodeValue));
173 case G_IR_NODE_CONSTANT:
174 node = g_malloc0 (sizeof (GIrNodeConstant));
177 case G_IR_NODE_ERROR_DOMAIN:
178 node = g_malloc0 (sizeof (GIrNodeErrorDomain));
182 node = g_malloc0 (sizeof (GIrNodeXRef));
185 case G_IR_NODE_UNION:
186 node = g_malloc0 (sizeof (GIrNodeUnion));
190 g_error ("Unhandled node type %d\n", type);
196 node->attributes = g_hash_table_new_full (g_str_hash, g_str_equal,
203 g_ir_node_free (GIrNode *node)
212 case G_IR_NODE_FUNCTION:
213 case G_IR_NODE_CALLBACK:
215 GIrNodeFunction *function = (GIrNodeFunction *)node;
218 g_free (function->symbol);
219 g_ir_node_free ((GIrNode *)function->result);
220 for (l = function->parameters; l; l = l->next)
221 g_ir_node_free ((GIrNode *)l->data);
222 g_list_free (function->parameters);
228 GIrNodeType *type = (GIrNodeType *)node;
231 g_ir_node_free ((GIrNode *)type->parameter_type1);
232 g_ir_node_free ((GIrNode *)type->parameter_type2);
234 g_free (type->interface);
235 g_strfreev (type->errors);
240 case G_IR_NODE_PARAM:
242 GIrNodeParam *param = (GIrNodeParam *)node;
245 g_ir_node_free ((GIrNode *)param->type);
249 case G_IR_NODE_PROPERTY:
251 GIrNodeProperty *property = (GIrNodeProperty *)node;
254 g_ir_node_free ((GIrNode *)property->type);
258 case G_IR_NODE_SIGNAL:
260 GIrNodeSignal *signal = (GIrNodeSignal *)node;
263 for (l = signal->parameters; l; l = l->next)
264 g_ir_node_free ((GIrNode *)l->data);
265 g_list_free (signal->parameters);
266 g_ir_node_free ((GIrNode *)signal->result);
270 case G_IR_NODE_VFUNC:
272 GIrNodeVFunc *vfunc = (GIrNodeVFunc *)node;
275 g_free (vfunc->invoker);
276 for (l = vfunc->parameters; l; l = l->next)
277 g_ir_node_free ((GIrNode *)l->data);
278 g_list_free (vfunc->parameters);
279 g_ir_node_free ((GIrNode *)vfunc->result);
283 case G_IR_NODE_FIELD:
285 GIrNodeField *field = (GIrNodeField *)node;
288 g_ir_node_free ((GIrNode *)field->type);
289 g_ir_node_free ((GIrNode *)field->callback);
293 case G_IR_NODE_OBJECT:
294 case G_IR_NODE_INTERFACE:
296 GIrNodeInterface *iface = (GIrNodeInterface *)node;
299 g_free (iface->gtype_name);
300 g_free (iface->gtype_init);
303 g_free (iface->glib_type_struct);
304 g_free (iface->parent);
306 for (l = iface->interfaces; l; l = l->next)
307 g_free ((GIrNode *)l->data);
308 g_list_free (iface->interfaces);
310 for (l = iface->members; l; l = l->next)
311 g_ir_node_free ((GIrNode *)l->data);
312 g_list_free (iface->members);
317 case G_IR_NODE_VALUE:
324 case G_IR_NODE_FLAGS:
326 GIrNodeEnum *enum_ = (GIrNodeEnum *)node;
329 g_free (enum_->gtype_name);
330 g_free (enum_->gtype_init);
332 for (l = enum_->values; l; l = l->next)
333 g_ir_node_free ((GIrNode *)l->data);
334 g_list_free (enum_->values);
338 case G_IR_NODE_BOXED:
340 GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
343 g_free (boxed->gtype_name);
344 g_free (boxed->gtype_init);
346 for (l = boxed->members; l; l = l->next)
347 g_ir_node_free ((GIrNode *)l->data);
348 g_list_free (boxed->members);
352 case G_IR_NODE_STRUCT:
354 GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
357 g_free (struct_->gtype_name);
358 g_free (struct_->gtype_init);
360 for (l = struct_->members; l; l = l->next)
361 g_ir_node_free ((GIrNode *)l->data);
362 g_list_free (struct_->members);
366 case G_IR_NODE_CONSTANT:
368 GIrNodeConstant *constant = (GIrNodeConstant *)node;
371 g_free (constant->value);
372 g_ir_node_free ((GIrNode *)constant->type);
376 case G_IR_NODE_ERROR_DOMAIN:
378 GIrNodeErrorDomain *domain = (GIrNodeErrorDomain *)node;
381 g_free (domain->getquark);
382 g_free (domain->codes);
388 GIrNodeXRef *xref = (GIrNodeXRef *)node;
391 g_free (xref->namespace);
395 case G_IR_NODE_UNION:
397 GIrNodeUnion *union_ = (GIrNodeUnion *)node;
400 g_free (union_->gtype_name);
401 g_free (union_->gtype_init);
403 g_ir_node_free ((GIrNode *)union_->discriminator_type);
404 for (l = union_->members; l; l = l->next)
405 g_ir_node_free ((GIrNode *)l->data);
406 for (l = union_->discriminators; l; l = l->next)
407 g_ir_node_free ((GIrNode *)l->data);
412 g_error ("Unhandled node type %d\n", node->type);
416 g_hash_table_destroy (node->attributes);
421 /* returns the fixed size of the blob */
423 g_ir_node_get_size (GIrNode *node)
430 case G_IR_NODE_CALLBACK:
431 size = sizeof (CallbackBlob);
434 case G_IR_NODE_FUNCTION:
435 size = sizeof (FunctionBlob);
438 case G_IR_NODE_PARAM:
439 /* See the comment in the G_IR_NODE_PARAM/ArgBlob writing below */
440 size = sizeof (ArgBlob) - sizeof (SimpleTypeBlob);
444 size = sizeof (SimpleTypeBlob);
447 case G_IR_NODE_OBJECT:
449 GIrNodeInterface *iface = (GIrNodeInterface *)node;
451 n = g_list_length (iface->interfaces);
452 size = sizeof (ObjectBlob) + 2 * (n + (n % 2));
454 for (l = iface->members; l; l = l->next)
455 size += g_ir_node_get_size ((GIrNode *)l->data);
459 case G_IR_NODE_INTERFACE:
461 GIrNodeInterface *iface = (GIrNodeInterface *)node;
463 n = g_list_length (iface->prerequisites);
464 size = sizeof (InterfaceBlob) + 2 * (n + (n % 2));
466 for (l = iface->members; l; l = l->next)
467 size += g_ir_node_get_size ((GIrNode *)l->data);
472 case G_IR_NODE_FLAGS:
474 GIrNodeEnum *enum_ = (GIrNodeEnum *)node;
476 size = sizeof (EnumBlob);
477 for (l = enum_->values; l; l = l->next)
478 size += g_ir_node_get_size ((GIrNode *)l->data);
482 case G_IR_NODE_VALUE:
483 size = sizeof (ValueBlob);
486 case G_IR_NODE_STRUCT:
488 GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
490 size = sizeof (StructBlob);
491 for (l = struct_->members; l; l = l->next)
492 size += g_ir_node_get_size ((GIrNode *)l->data);
496 case G_IR_NODE_BOXED:
498 GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
500 size = sizeof (StructBlob);
501 for (l = boxed->members; l; l = l->next)
502 size += g_ir_node_get_size ((GIrNode *)l->data);
506 case G_IR_NODE_PROPERTY:
507 size = sizeof (PropertyBlob);
510 case G_IR_NODE_SIGNAL:
511 size = sizeof (SignalBlob);
514 case G_IR_NODE_VFUNC:
515 size = sizeof (VFuncBlob);
518 case G_IR_NODE_FIELD:
520 GIrNodeField *field = (GIrNodeField *)node;
522 size = sizeof (FieldBlob);
524 size += g_ir_node_get_size ((GIrNode *)field->callback);
528 case G_IR_NODE_CONSTANT:
529 size = sizeof (ConstantBlob);
532 case G_IR_NODE_ERROR_DOMAIN:
533 size = sizeof (ErrorDomainBlob);
540 case G_IR_NODE_UNION:
542 GIrNodeUnion *union_ = (GIrNodeUnion *)node;
544 size = sizeof (UnionBlob);
545 for (l = union_->members; l; l = l->next)
546 size += g_ir_node_get_size ((GIrNode *)l->data);
547 for (l = union_->discriminators; l; l = l->next)
548 size += g_ir_node_get_size ((GIrNode *)l->data);
553 g_error ("Unhandled node type '%s'\n",
554 g_ir_node_type_to_string (node->type));
558 g_debug ("node %p type '%s' size %d", node,
559 g_ir_node_type_to_string (node->type), size);
565 add_attribute_size (gpointer key, gpointer value, gpointer data)
567 const gchar *key_str = key;
568 const gchar *value_str = value;
571 *size_p += sizeof (AttributeBlob);
572 *size_p += ALIGN_VALUE (strlen (key_str) + 1, 4);
573 *size_p += ALIGN_VALUE (strlen (value_str) + 1, 4);
576 /* returns the full size of the blob including variable-size parts */
578 g_ir_node_get_full_size_internal (GIrNode *parent,
584 if (node == NULL && parent != NULL)
585 g_error ("Caught NULL node, parent=%s", parent->name);
587 g_debug ("node %p type '%s'", node,
588 g_ir_node_type_to_string (node->type));
592 case G_IR_NODE_CALLBACK:
594 GIrNodeFunction *function = (GIrNodeFunction *)node;
595 size = sizeof (CallbackBlob);
596 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
597 for (l = function->parameters; l; l = l->next)
599 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
601 size += g_ir_node_get_full_size_internal (node, (GIrNode *)function->result);
605 case G_IR_NODE_FUNCTION:
607 GIrNodeFunction *function = (GIrNodeFunction *)node;
608 size = sizeof (FunctionBlob);
609 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
610 size += ALIGN_VALUE (strlen (function->symbol) + 1, 4);
611 for (l = function->parameters; l; l = l->next)
612 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
613 size += g_ir_node_get_full_size_internal (node, (GIrNode *)function->result);
617 case G_IR_NODE_PARAM:
619 GIrNodeParam *param = (GIrNodeParam *)node;
621 /* See the comment in the G_IR_NODE_PARAM/ArgBlob writing below */
622 size = sizeof (ArgBlob) - sizeof (SimpleTypeBlob);
624 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
625 size += g_ir_node_get_full_size_internal (node, (GIrNode *)param->type);
631 GIrNodeType *type = (GIrNodeType *)node;
632 size = sizeof (SimpleTypeBlob);
633 if (type->tag >= GI_TYPE_TAG_ARRAY)
635 g_debug ("node %p type tag '%s'", node,
636 g_type_tag_to_string (type->tag));
640 case GI_TYPE_TAG_ARRAY:
641 size = sizeof (ArrayTypeBlob);
642 if (type->parameter_type1)
643 size += g_ir_node_get_full_size_internal (node, (GIrNode *)type->parameter_type1);
645 case GI_TYPE_TAG_INTERFACE:
646 size += sizeof (InterfaceTypeBlob);
648 case GI_TYPE_TAG_GLIST:
649 case GI_TYPE_TAG_GSLIST:
650 size += sizeof (ParamTypeBlob);
651 if (type->parameter_type1)
652 size += g_ir_node_get_full_size_internal (node, (GIrNode *)type->parameter_type1);
654 case GI_TYPE_TAG_GHASH:
655 size += sizeof (ParamTypeBlob) * 2;
656 if (type->parameter_type1)
657 size += g_ir_node_get_full_size_internal (node, (GIrNode *)type->parameter_type1);
658 if (type->parameter_type2)
659 size += g_ir_node_get_full_size_internal (node, (GIrNode *)type->parameter_type2);
661 case GI_TYPE_TAG_ERROR:
666 n = g_strv_length (type->errors);
670 size += sizeof (ErrorTypeBlob) + 2 * (n + n % 2);
674 g_error ("Unknown type tag %d\n", type->tag);
681 case G_IR_NODE_OBJECT:
683 GIrNodeInterface *iface = (GIrNodeInterface *)node;
685 n = g_list_length (iface->interfaces);
686 size = sizeof(ObjectBlob);
688 size += ALIGN_VALUE (strlen (iface->parent) + 1, 4);
689 if (iface->glib_type_struct)
690 size += ALIGN_VALUE (strlen (iface->glib_type_struct) + 1, 4);
691 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
692 size += ALIGN_VALUE (strlen (iface->gtype_name) + 1, 4);
693 if (iface->gtype_init)
694 size += ALIGN_VALUE (strlen (iface->gtype_init) + 1, 4);
695 size += 2 * (n + (n % 2));
697 for (l = iface->members; l; l = l->next)
698 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
702 case G_IR_NODE_INTERFACE:
704 GIrNodeInterface *iface = (GIrNodeInterface *)node;
706 n = g_list_length (iface->prerequisites);
707 size = sizeof (InterfaceBlob);
708 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
709 size += ALIGN_VALUE (strlen (iface->gtype_name) + 1, 4);
710 size += ALIGN_VALUE (strlen (iface->gtype_init) + 1, 4);
711 size += 2 * (n + (n % 2));
713 for (l = iface->members; l; l = l->next)
714 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
719 case G_IR_NODE_FLAGS:
721 GIrNodeEnum *enum_ = (GIrNodeEnum *)node;
723 size = sizeof (EnumBlob);
724 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
725 if (enum_->gtype_name)
727 size += ALIGN_VALUE (strlen (enum_->gtype_name) + 1, 4);
728 size += ALIGN_VALUE (strlen (enum_->gtype_init) + 1, 4);
731 for (l = enum_->values; l; l = l->next)
732 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
736 case G_IR_NODE_VALUE:
738 size = sizeof (ValueBlob);
739 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
743 case G_IR_NODE_STRUCT:
745 GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
747 size = sizeof (StructBlob);
748 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
749 if (struct_->gtype_name)
750 size += ALIGN_VALUE (strlen (struct_->gtype_name) + 1, 4);
751 if (struct_->gtype_init)
752 size += ALIGN_VALUE (strlen (struct_->gtype_init) + 1, 4);
753 for (l = struct_->members; l; l = l->next)
754 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
758 case G_IR_NODE_BOXED:
760 GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
762 size = sizeof (StructBlob);
763 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
764 if (boxed->gtype_name)
766 size += ALIGN_VALUE (strlen (boxed->gtype_name) + 1, 4);
767 size += ALIGN_VALUE (strlen (boxed->gtype_init) + 1, 4);
769 for (l = boxed->members; l; l = l->next)
770 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
774 case G_IR_NODE_PROPERTY:
776 GIrNodeProperty *prop = (GIrNodeProperty *)node;
778 size = sizeof (PropertyBlob);
779 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
780 size += g_ir_node_get_full_size_internal (node, (GIrNode *)prop->type);
784 case G_IR_NODE_SIGNAL:
786 GIrNodeSignal *signal = (GIrNodeSignal *)node;
788 size = sizeof (SignalBlob);
789 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
790 for (l = signal->parameters; l; l = l->next)
791 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
792 size += g_ir_node_get_full_size_internal (node, (GIrNode *)signal->result);
796 case G_IR_NODE_VFUNC:
798 GIrNodeVFunc *vfunc = (GIrNodeVFunc *)node;
800 size = sizeof (VFuncBlob);
801 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
802 for (l = vfunc->parameters; l; l = l->next)
803 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
804 size += g_ir_node_get_full_size_internal (node, (GIrNode *)vfunc->result);
808 case G_IR_NODE_FIELD:
810 GIrNodeField *field = (GIrNodeField *)node;
812 size = sizeof (FieldBlob);
813 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
815 size += g_ir_node_get_full_size_internal (node, (GIrNode *)field->callback);
817 size += g_ir_node_get_full_size_internal (node, (GIrNode *)field->type);
821 case G_IR_NODE_CONSTANT:
823 GIrNodeConstant *constant = (GIrNodeConstant *)node;
825 size = sizeof (ConstantBlob);
826 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
827 /* FIXME non-string values */
828 size += ALIGN_VALUE (strlen (constant->value) + 1, 4);
829 size += g_ir_node_get_full_size_internal (node, (GIrNode *)constant->type);
833 case G_IR_NODE_ERROR_DOMAIN:
835 GIrNodeErrorDomain *domain = (GIrNodeErrorDomain *)node;
837 size = sizeof (ErrorDomainBlob);
838 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
839 size += ALIGN_VALUE (strlen (domain->getquark) + 1, 4);
845 GIrNodeXRef *xref = (GIrNodeXRef *)node;
848 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
849 size += ALIGN_VALUE (strlen (xref->namespace) + 1, 4);
853 case G_IR_NODE_UNION:
855 GIrNodeUnion *union_ = (GIrNodeUnion *)node;
857 size = sizeof (UnionBlob);
858 size += ALIGN_VALUE (strlen (node->name) + 1, 4);
859 if (union_->gtype_name)
860 size += ALIGN_VALUE (strlen (union_->gtype_name) + 1, 4);
861 if (union_->gtype_init)
862 size += ALIGN_VALUE (strlen (union_->gtype_init) + 1, 4);
863 for (l = union_->members; l; l = l->next)
864 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
865 for (l = union_->discriminators; l; l = l->next)
866 size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
871 g_error ("Unknown type tag %d\n", node->type);
875 g_debug ("node %s%s%s%p type '%s' full size %d",
876 node->name ? "'" : "",
877 node->name ? node->name : "",
878 node->name ? "' " : "",
879 node, g_ir_node_type_to_string (node->type), size);
885 g_ir_node_get_full_size (GIrNode *node)
887 return g_ir_node_get_full_size_internal (NULL, node);
891 g_ir_node_get_attribute_size (GIrNode *node)
894 g_hash_table_foreach (node->attributes, add_attribute_size, &size);
899 g_ir_node_cmp (GIrNode *node,
902 if (node->type < other->type)
904 else if (node->type > other->type)
907 return strcmp (node->name, other->name);
911 g_ir_node_can_have_member (GIrNode *node)
915 case G_IR_NODE_OBJECT:
916 case G_IR_NODE_INTERFACE:
917 case G_IR_NODE_BOXED:
918 case G_IR_NODE_STRUCT:
919 case G_IR_NODE_UNION:
921 /* list others individually rather than with default: so that compiler
922 * warns if new node types are added without adding them to the switch
924 case G_IR_NODE_INVALID:
925 case G_IR_NODE_FUNCTION:
926 case G_IR_NODE_CALLBACK:
928 case G_IR_NODE_FLAGS:
929 case G_IR_NODE_CONSTANT:
930 case G_IR_NODE_ERROR_DOMAIN:
931 case G_IR_NODE_PARAM:
933 case G_IR_NODE_PROPERTY:
934 case G_IR_NODE_SIGNAL:
935 case G_IR_NODE_VALUE:
936 case G_IR_NODE_VFUNC:
937 case G_IR_NODE_FIELD:
945 g_ir_node_add_member (GIrNode *node,
946 GIrNodeFunction *member)
948 g_return_if_fail (node != NULL);
949 g_return_if_fail (member != NULL);
953 case G_IR_NODE_OBJECT:
954 case G_IR_NODE_INTERFACE:
956 GIrNodeInterface *iface = (GIrNodeInterface *)node;
958 g_list_insert_sorted (iface->members, member,
959 (GCompareFunc) g_ir_node_cmp);
962 case G_IR_NODE_BOXED:
964 GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
966 g_list_insert_sorted (boxed->members, member,
967 (GCompareFunc) g_ir_node_cmp);
970 case G_IR_NODE_STRUCT:
972 GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
974 g_list_insert_sorted (struct_->members, member,
975 (GCompareFunc) g_ir_node_cmp);
978 case G_IR_NODE_UNION:
980 GIrNodeUnion *union_ = (GIrNodeUnion *)node;
982 g_list_insert_sorted (union_->members, member,
983 (GCompareFunc) g_ir_node_cmp);
987 g_error ("Cannot add a member to unknown type tag type %d\n",
994 g_ir_node_param_direction_string (GIrNodeParam * node)
1007 parse_int_value (const gchar *str)
1009 return strtoll (str, NULL, 0);
1013 parse_uint_value (const gchar *str)
1015 return strtoull (str, NULL, 0);
1019 parse_float_value (const gchar *str)
1021 return strtod (str, NULL);
1025 parse_boolean_value (const gchar *str)
1027 if (strcmp (str, "TRUE") == 0)
1030 if (strcmp (str, "FALSE") == 0)
1033 return parse_int_value (str) ? TRUE : FALSE;
1037 find_entry_node (GIrModule *module,
1047 GIrNode *result = NULL;
1049 g_assert (name != NULL);
1050 g_assert (strlen (name) > 0);
1052 names = g_strsplit (name, ".", 0);
1053 n_names = g_strv_length (names);
1055 g_error ("Too many name parts");
1057 for (l = module->entries, i = 1; l; l = l->next, i++)
1059 GIrNode *node = (GIrNode *)l->data;
1063 if (node->type != G_IR_NODE_XREF)
1066 if (((GIrNodeXRef *)node)->namespace == NULL ||
1067 strcmp (((GIrNodeXRef *)node)->namespace, names[0]) != 0)
1071 if (strcmp (node->name, names[n_names - 1]) == 0)
1083 GIrNode *node = g_ir_node_new (G_IR_NODE_XREF);
1085 ((GIrNodeXRef *)node)->namespace = g_strdup (names[0]);
1086 node->name = g_strdup (names[1]);
1088 module->entries = g_list_append (module->entries, node);
1091 *idx = g_list_length (module->entries);
1095 g_debug ("Creating XREF: %s %s", names[0], names[1]);
1100 g_ir_module_fatal (module, 0, "Type reference '%s' not found", name);
1110 find_entry (GIrModule *module,
1116 find_entry_node (module, modules, name, &idx);
1122 find_name_in_module (GIrModule *module,
1127 for (l = module->entries; l; l = l->next)
1129 GIrNode *node = (GIrNode *)l->data;
1131 if (strcmp (node->name, name) == 0)
1139 g_ir_find_node (GIrModule *module,
1143 GIrModule **module_out)
1145 char **names = g_strsplit (name, ".", 0);
1146 gint n_names = g_strv_length (names);
1147 GIrNode *node = NULL;
1152 g_warning ("Name can't be empty");
1158 g_warning ("Too many name parts in '%s'", name);
1164 *module_out = module;
1165 node = find_name_in_module (module, names[0]);
1167 else if (strcmp (names[0], module->name) == 0)
1169 *module_out = module;
1170 node = find_name_in_module (module, names[1]);
1174 for (l = module->include_modules; l; l = l->next)
1176 GIrModule *m = l->data;
1178 if (strcmp (names[0], m->name) == 0)
1181 node = find_name_in_module (m, names[1]);
1186 for (l = modules; l; l = l->next)
1188 GIrModule *m = l->data;
1190 if (strcmp (names[0], m->name) == 0)
1193 node = find_name_in_module (m, names[1]);
1204 return node != NULL;
1208 get_index_of_member_type (GIrNodeInterface *node,
1215 for (l = node->members; l; l = l->next)
1217 GIrNode *node = l->data;
1219 if (node->type != type)
1224 if (strcmp (node->name, name) == 0)
1232 serialize_type (GIrModule *module,
1238 const gchar* basic[] = {
1265 if (node->tag < GI_TYPE_TAG_ARRAY)
1267 g_string_append_printf (str, "%s%s", basic[node->tag],
1268 node->is_pointer ? "*" : "");
1270 else if (node->tag == GI_TYPE_TAG_ARRAY)
1272 serialize_type (module, modules, node->parameter_type1, str);
1273 g_string_append (str, "[");
1275 if (node->has_length)
1276 g_string_append_printf (str, "length=%d", node->length);
1277 else if (node->has_size)
1278 g_string_append_printf (str, "fixed-size=%d", node->size);
1280 if (node->zero_terminated)
1281 g_string_append_printf (str, "%szero-terminated=1",
1282 node->has_length ? "," : "");
1284 g_string_append (str, "]");
1286 else if (node->tag == GI_TYPE_TAG_INTERFACE)
1291 iface = find_entry_node (module, modules, node->interface, NULL);
1294 if (iface->type == G_IR_NODE_XREF)
1295 g_string_append_printf (str, "%s.", ((GIrNodeXRef *)iface)->namespace);
1300 g_warning ("Interface for type reference %s not found", node->interface);
1301 name = node->interface;
1304 g_string_append_printf (str, "%s%s", name,
1305 node->is_pointer ? "*" : "");
1307 else if (node->tag == GI_TYPE_TAG_GLIST)
1309 g_string_append (str, "GList");
1310 if (node->parameter_type1)
1312 g_string_append (str, "<");
1313 serialize_type (module, modules, node->parameter_type1, str);
1314 g_string_append (str, ">");
1317 else if (node->tag == GI_TYPE_TAG_GSLIST)
1319 g_string_append (str, "GSList");
1320 if (node->parameter_type1)
1322 g_string_append (str, "<");
1323 serialize_type (module, modules, node->parameter_type1, str);
1324 g_string_append (str, ">");
1327 else if (node->tag == GI_TYPE_TAG_GHASH)
1329 g_string_append (str, "GHashTable<");
1330 if (node->parameter_type1)
1332 g_string_append (str, "<");
1333 serialize_type (module, modules, node->parameter_type1, str);
1334 g_string_append (str, ",");
1335 serialize_type (module, modules, node->parameter_type2, str);
1336 g_string_append (str, ">");
1339 else if (node->tag == GI_TYPE_TAG_ERROR)
1341 g_string_append (str, "GError");
1344 g_string_append (str, "<");
1345 for (i = 0; node->errors[i]; i++)
1348 g_string_append (str, ",");
1349 g_string_append (str, node->errors[i]);
1351 g_string_append (str, ">");
1357 g_ir_node_build_members (GList **members,
1361 GIrTypelibBuild *build,
1365 GList *l = *members;
1369 GIrNode *member = (GIrNode *)l->data;
1370 GList *next = l->next;
1372 if (member->type == type)
1375 g_ir_node_build_typelib (member, parent, build, offset, offset2);
1376 *members = g_list_delete_link (*members, l);
1383 g_ir_node_check_unhandled_members (GList **members,
1384 GIrNodeTypeId container_type)
1391 for (l = *members; l; l = l->next)
1393 GIrNode *member = (GIrNode *)l->data;
1394 g_printerr ("Unhandled '%s' member '%s' type '%s'\n",
1395 g_ir_node_type_to_string (container_type),
1397 g_ir_node_type_to_string (member->type));
1400 g_list_free (*members);
1403 g_error ("Unhandled members. Aborting.");
1406 g_list_free (*members);
1412 g_ir_node_build_typelib (GIrNode *node,
1414 GIrTypelibBuild *build,
1418 GIrModule *module = build->module;
1419 GList *modules = build->modules;
1420 GHashTable *strings = build->strings;
1421 GHashTable *types = build->types;
1422 guchar *data = build->data;
1424 guint32 old_offset = *offset;
1425 guint32 old_offset2 = *offset2;
1427 g_assert (node != NULL);
1429 g_debug ("build_typelib: %s%s(%s)",
1430 node->name ? node->name : "",
1431 node->name ? " " : "",
1432 g_ir_node_type_to_string (node->type));
1434 g_ir_node_compute_offsets (node, module, modules);
1436 /* We should only be building each node once. If we do a typelib expansion, we also
1437 * reset the offset in girmodule.c.
1439 g_assert (node->offset == 0);
1440 node->offset = *offset;
1441 build->offset_ordered_nodes = g_list_prepend (build->offset_ordered_nodes, node);
1443 build->n_attributes += g_hash_table_size (node->attributes);
1447 case G_IR_NODE_TYPE:
1449 GIrNodeType *type = (GIrNodeType *)node;
1450 SimpleTypeBlob *blob = (SimpleTypeBlob *)&data[*offset];
1452 *offset += sizeof (SimpleTypeBlob);
1454 if (type->tag < GI_TYPE_TAG_ARRAY ||
1455 type->tag == GI_TYPE_TAG_UTF8 ||
1456 type->tag == GI_TYPE_TAG_FILENAME)
1458 blob->flags.reserved = 0;
1459 blob->flags.reserved2 = 0;
1460 blob->flags.pointer = type->is_pointer;
1461 blob->flags.reserved3 = 0;
1462 blob->flags.tag = type->tag;
1470 str = g_string_new (0);
1471 serialize_type (module, modules, type, str);
1472 s = g_string_free (str, FALSE);
1475 value = g_hash_table_lookup (types, s);
1478 blob->offset = GPOINTER_TO_UINT (value);
1483 unique_types_count += 1;
1484 g_hash_table_insert (types, s, GUINT_TO_POINTER(*offset2));
1486 blob->offset = *offset2;
1489 case GI_TYPE_TAG_ARRAY:
1491 ArrayTypeBlob *array = (ArrayTypeBlob *)&data[*offset2];
1495 array->reserved = 0;
1496 array->tag = type->tag;
1497 array->zero_terminated = type->zero_terminated;
1498 array->has_length = type->has_length;
1499 array->has_size = type->has_size;
1500 array->reserved2 = 0;
1501 if (array->has_length)
1502 array->dimensions.length = type->length;
1503 else if (array->has_size)
1504 array->dimensions.size = type->size;
1506 array->dimensions.length = -1;
1508 pos = *offset2 + G_STRUCT_OFFSET (ArrayTypeBlob, type);
1509 *offset2 += sizeof (ArrayTypeBlob);
1511 g_ir_node_build_typelib ((GIrNode *)type->parameter_type1,
1512 node, build, &pos, offset2);
1516 case GI_TYPE_TAG_INTERFACE:
1518 InterfaceTypeBlob *iface = (InterfaceTypeBlob *)&data[*offset2];
1519 *offset2 += sizeof (InterfaceTypeBlob);
1521 iface->pointer = type->is_pointer;
1522 iface->reserved = 0;
1523 iface->tag = type->tag;
1524 iface->reserved2 = 0;
1525 iface->interface = find_entry (module, modules, type->interface);
1530 case GI_TYPE_TAG_GLIST:
1531 case GI_TYPE_TAG_GSLIST:
1533 ParamTypeBlob *param = (ParamTypeBlob *)&data[*offset2];
1537 param->reserved = 0;
1538 param->tag = type->tag;
1539 param->reserved2 = 0;
1542 pos = *offset2 + G_STRUCT_OFFSET (ParamTypeBlob, type);
1543 *offset2 += sizeof (ParamTypeBlob) + sizeof (SimpleTypeBlob);
1545 g_ir_node_build_typelib ((GIrNode *)type->parameter_type1,
1546 node, build, &pos, offset2);
1550 case GI_TYPE_TAG_GHASH:
1552 ParamTypeBlob *param = (ParamTypeBlob *)&data[*offset2];
1556 param->reserved = 0;
1557 param->tag = type->tag;
1558 param->reserved2 = 0;
1561 pos = *offset2 + G_STRUCT_OFFSET (ParamTypeBlob, type);
1562 *offset2 += sizeof (ParamTypeBlob) + sizeof (SimpleTypeBlob)*2;
1564 g_ir_node_build_typelib ((GIrNode *)type->parameter_type1,
1565 node, build, &pos, offset2);
1566 g_ir_node_build_typelib ((GIrNode *)type->parameter_type2,
1567 node, build, &pos, offset2);
1571 case GI_TYPE_TAG_ERROR:
1573 ErrorTypeBlob *blob = (ErrorTypeBlob *)&data[*offset2];
1578 blob->tag = type->tag;
1579 blob->reserved2 = 0;
1581 blob->n_domains = g_strv_length (type->errors);
1583 blob->n_domains = 0;
1585 *offset2 = ALIGN_VALUE (*offset2 + G_STRUCT_OFFSET (ErrorTypeBlob, domains)
1586 + 2 * blob->n_domains, 4);
1587 for (i = 0; i < blob->n_domains; i++)
1588 blob->domains[i] = find_entry (module, modules, type->errors[i]);
1593 g_error ("Unknown type tag %d\n", type->tag);
1601 case G_IR_NODE_FIELD:
1603 GIrNodeField *field = (GIrNodeField *)node;
1606 blob = (FieldBlob *)&data[*offset];
1608 blob->name = write_string (node->name, strings, data, offset2);
1609 blob->readable = field->readable;
1610 blob->writable = field->writable;
1613 if (field->offset >= 0)
1614 blob->struct_offset = field->offset;
1616 blob->struct_offset = 0xFFFF; /* mark as unknown */
1618 if (field->callback)
1620 blob->has_embedded_type = TRUE;
1621 blob->type.offset = GI_INFO_TYPE_CALLBACK;
1622 *offset += sizeof (FieldBlob);
1623 g_ir_node_build_typelib ((GIrNode *)field->callback,
1624 node, build, offset, offset2);
1628 blob->has_embedded_type = FALSE;
1629 /* We handle the size member specially below, so subtract it */
1630 *offset += sizeof (FieldBlob) - sizeof (SimpleTypeBlob);
1631 g_ir_node_build_typelib ((GIrNode *)field->type,
1632 node, build, offset, offset2);
1637 case G_IR_NODE_PROPERTY:
1639 GIrNodeProperty *prop = (GIrNodeProperty *)node;
1640 PropertyBlob *blob = (PropertyBlob *)&data[*offset];
1641 /* We handle the size member specially below, so subtract it */
1642 *offset += sizeof (PropertyBlob) - sizeof (SimpleTypeBlob);
1644 blob->name = write_string (node->name, strings, data, offset2);
1645 blob->deprecated = prop->deprecated;
1646 blob->readable = prop->readable;
1647 blob->writable = prop->writable;
1648 blob->construct = prop->construct;
1649 blob->construct_only = prop->construct_only;
1652 g_ir_node_build_typelib ((GIrNode *)prop->type,
1653 node, build, offset, offset2);
1657 case G_IR_NODE_FUNCTION:
1659 FunctionBlob *blob = (FunctionBlob *)&data[*offset];
1660 SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1661 GIrNodeFunction *function = (GIrNodeFunction *)node;
1665 signature = *offset2;
1666 n = g_list_length (function->parameters);
1668 *offset += sizeof (FunctionBlob);
1669 *offset2 += sizeof (SignatureBlob) + n * sizeof (ArgBlob);
1671 blob->blob_type = BLOB_TYPE_FUNCTION;
1672 blob->deprecated = function->deprecated;
1673 blob->is_static = !function->is_method;
1674 blob->setter = function->is_setter;
1675 blob->getter = function->is_getter;
1676 blob->constructor = function->is_constructor;
1677 blob->wraps_vfunc = function->wraps_vfunc;
1678 blob->throws = function->throws;
1680 blob->name = write_string (node->name, strings, data, offset2);
1681 blob->symbol = write_string (function->symbol, strings, data, offset2);
1682 blob->signature = signature;
1684 g_debug ("building function '%s'", function->symbol);
1686 g_ir_node_build_typelib ((GIrNode *)function->result->type,
1687 node, build, &signature, offset2);
1689 blob2->may_return_null = function->result->allow_none;
1690 blob2->caller_owns_return_value = function->result->transfer;
1691 blob2->caller_owns_return_container = function->result->shallow_transfer;
1692 blob2->reserved = 0;
1693 blob2->n_arguments = n;
1697 for (l = function->parameters; l; l = l->next)
1699 GIrNode *param = (GIrNode *)l->data;
1701 g_ir_node_build_typelib (param, node, build, &signature, offset2);
1707 case G_IR_NODE_CALLBACK:
1709 CallbackBlob *blob = (CallbackBlob *)&data[*offset];
1710 SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1711 GIrNodeFunction *function = (GIrNodeFunction *)node;
1715 signature = *offset2;
1716 n = g_list_length (function->parameters);
1718 *offset += sizeof (CallbackBlob);
1719 *offset2 += sizeof (SignatureBlob) + n * sizeof (ArgBlob);
1721 blob->blob_type = BLOB_TYPE_CALLBACK;
1722 blob->deprecated = function->deprecated;
1724 blob->name = write_string (node->name, strings, data, offset2);
1725 blob->signature = signature;
1727 g_ir_node_build_typelib ((GIrNode *)function->result->type,
1728 node, build, &signature, offset2);
1730 blob2->may_return_null = function->result->allow_none;
1731 blob2->caller_owns_return_value = function->result->transfer;
1732 blob2->caller_owns_return_container = function->result->shallow_transfer;
1733 blob2->reserved = 0;
1734 blob2->n_arguments = n;
1738 for (l = function->parameters; l; l = l->next)
1740 GIrNode *param = (GIrNode *)l->data;
1742 g_ir_node_build_typelib (param, node, build, &signature, offset2);
1747 case G_IR_NODE_SIGNAL:
1749 SignalBlob *blob = (SignalBlob *)&data[*offset];
1750 SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1751 GIrNodeSignal *signal = (GIrNodeSignal *)node;
1755 signature = *offset2;
1756 n = g_list_length (signal->parameters);
1758 *offset += sizeof (SignalBlob);
1759 *offset2 += sizeof (SignatureBlob) + n * sizeof (ArgBlob);
1761 blob->deprecated = signal->deprecated;
1762 blob->run_first = signal->run_first;
1763 blob->run_last = signal->run_last;
1764 blob->run_cleanup = signal->run_cleanup;
1765 blob->no_recurse = signal->no_recurse;
1766 blob->detailed = signal->detailed;
1767 blob->action = signal->action;
1768 blob->no_hooks = signal->no_hooks;
1769 blob->has_class_closure = 0; /* FIXME */
1770 blob->true_stops_emit = 0; /* FIXME */
1772 blob->class_closure = 0; /* FIXME */
1773 blob->name = write_string (node->name, strings, data, offset2);
1774 blob->signature = signature;
1776 g_ir_node_build_typelib ((GIrNode *)signal->result->type,
1777 node, build, &signature, offset2);
1779 blob2->may_return_null = signal->result->allow_none;
1780 blob2->caller_owns_return_value = signal->result->transfer;
1781 blob2->caller_owns_return_container = signal->result->shallow_transfer;
1782 blob2->reserved = 0;
1783 blob2->n_arguments = n;
1787 for (l = signal->parameters; l; l = l->next)
1789 GIrNode *param = (GIrNode *)l->data;
1791 g_ir_node_build_typelib (param, node, build, &signature, offset2);
1796 case G_IR_NODE_VFUNC:
1798 VFuncBlob *blob = (VFuncBlob *)&data[*offset];
1799 SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1800 GIrNodeVFunc *vfunc = (GIrNodeVFunc *)node;
1804 signature = *offset2;
1805 n = g_list_length (vfunc->parameters);
1807 *offset += sizeof (VFuncBlob);
1808 *offset2 += sizeof (SignatureBlob) + n * sizeof (ArgBlob);
1810 blob->name = write_string (node->name, strings, data, offset2);
1811 blob->must_chain_up = 0; /* FIXME */
1812 blob->must_be_implemented = 0; /* FIXME */
1813 blob->must_not_be_implemented = 0; /* FIXME */
1814 blob->class_closure = 0; /* FIXME */
1819 int index = get_index_of_member_type ((GIrNodeInterface*)parent, G_IR_NODE_FUNCTION, vfunc->invoker);
1822 g_error ("Unknown member function %s for vfunc %s", vfunc->invoker, node->name);
1824 blob->invoker = (guint) index;
1827 blob->invoker = 0x3ff; /* max of 10 bits */
1829 blob->struct_offset = vfunc->offset;
1830 blob->reserved2 = 0;
1831 blob->signature = signature;
1833 g_ir_node_build_typelib ((GIrNode *)vfunc->result->type,
1834 node, build, &signature, offset2);
1836 blob2->may_return_null = vfunc->result->allow_none;
1837 blob2->caller_owns_return_value = vfunc->result->transfer;
1838 blob2->caller_owns_return_container = vfunc->result->shallow_transfer;
1839 blob2->reserved = 0;
1840 blob2->n_arguments = n;
1844 for (l = vfunc->parameters; l; l = l->next)
1846 GIrNode *param = (GIrNode *)l->data;
1848 g_ir_node_build_typelib (param, node, build, &signature, offset2);
1853 case G_IR_NODE_PARAM:
1855 ArgBlob *blob = (ArgBlob *)&data[*offset];
1856 GIrNodeParam *param = (GIrNodeParam *)node;
1858 /* The offset for this one is smaller than the struct because
1859 * we recursively build the simple type inline here below.
1861 *offset += sizeof (ArgBlob) - sizeof (SimpleTypeBlob);
1863 blob->name = write_string (node->name, strings, data, offset2);
1864 blob->in = param->in;
1865 blob->out = param->out;
1866 blob->dipper = param->dipper;
1867 blob->allow_none = param->allow_none;
1868 blob->optional = param->optional;
1869 blob->transfer_ownership = param->transfer;
1870 blob->transfer_container_ownership = param->shallow_transfer;
1871 blob->return_value = param->retval;
1872 blob->scope = param->scope;
1874 blob->closure = param->closure;
1875 blob->destroy = param->destroy;
1877 g_ir_node_build_typelib ((GIrNode *)param->type, node, build, offset, offset2);
1881 case G_IR_NODE_STRUCT:
1883 StructBlob *blob = (StructBlob *)&data[*offset];
1884 GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
1887 blob->blob_type = BLOB_TYPE_STRUCT;
1888 blob->deprecated = struct_->deprecated;
1889 blob->is_gtype_struct = struct_->is_gtype_struct;
1891 blob->name = write_string (node->name, strings, data, offset2);
1892 blob->alignment = struct_->alignment;
1893 blob->size = struct_->size;
1895 if (struct_->gtype_name)
1897 blob->unregistered = FALSE;
1898 blob->gtype_name = write_string (struct_->gtype_name, strings, data, offset2);
1899 blob->gtype_init = write_string (struct_->gtype_init, strings, data, offset2);
1903 blob->unregistered = TRUE;
1904 blob->gtype_name = 0;
1905 blob->gtype_init = 0;
1909 blob->n_methods = 0;
1911 *offset += sizeof (StructBlob);
1913 members = g_list_copy (struct_->members);
1915 g_ir_node_build_members (&members, G_IR_NODE_FIELD, &blob->n_fields,
1916 node, build, offset, offset2);
1918 g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_methods,
1919 node, build, offset, offset2);
1921 g_ir_node_check_unhandled_members (&members, node->type);
1923 g_assert (members == NULL);
1927 case G_IR_NODE_BOXED:
1929 StructBlob *blob = (StructBlob *)&data[*offset];
1930 GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
1933 blob->blob_type = BLOB_TYPE_BOXED;
1934 blob->deprecated = boxed->deprecated;
1935 blob->unregistered = FALSE;
1937 blob->name = write_string (node->name, strings, data, offset2);
1938 blob->gtype_name = write_string (boxed->gtype_name, strings, data, offset2);
1939 blob->gtype_init = write_string (boxed->gtype_init, strings, data, offset2);
1940 blob->alignment = boxed->alignment;
1941 blob->size = boxed->size;
1944 blob->n_methods = 0;
1946 *offset += sizeof (StructBlob);
1948 members = g_list_copy (boxed->members);
1950 g_ir_node_build_members (&members, G_IR_NODE_FIELD, &blob->n_fields,
1951 node, build, offset, offset2);
1953 g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_methods,
1954 node, build, offset, offset2);
1956 g_ir_node_check_unhandled_members (&members, node->type);
1958 g_assert (members == NULL);
1962 case G_IR_NODE_UNION:
1964 UnionBlob *blob = (UnionBlob *)&data[*offset];
1965 GIrNodeUnion *union_ = (GIrNodeUnion *)node;
1968 blob->blob_type = BLOB_TYPE_UNION;
1969 blob->deprecated = union_->deprecated;
1971 blob->name = write_string (node->name, strings, data, offset2);
1972 blob->alignment = union_->alignment;
1973 blob->size = union_->size;
1974 if (union_->gtype_name)
1976 blob->unregistered = FALSE;
1977 blob->gtype_name = write_string (union_->gtype_name, strings, data, offset2);
1978 blob->gtype_init = write_string (union_->gtype_init, strings, data, offset2);
1982 blob->unregistered = TRUE;
1983 blob->gtype_name = 0;
1984 blob->gtype_init = 0;
1988 blob->n_functions = 0;
1990 blob->discriminator_offset = union_->discriminator_offset;
1992 /* We don't support Union discriminators right now. */
1994 if (union_->discriminator_type)
1997 blob->discriminated = TRUE;
1998 g_ir_node_build_typelib ((GIrNode *)union_->discriminator_type,
1999 build, offset, offset2);
2004 *offset += sizeof (UnionBlob);
2005 blob->discriminated = FALSE;
2006 blob->discriminator_type.offset = 0;
2008 members = g_list_copy (union_->members);
2010 g_ir_node_build_members (&members, G_IR_NODE_FIELD, &blob->n_fields,
2011 node, build, offset, offset2);
2013 g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_functions,
2014 node, build, offset, offset2);
2016 g_ir_node_check_unhandled_members (&members, node->type);
2018 g_assert (members == NULL);
2020 if (union_->discriminator_type)
2022 for (l = union_->discriminators; l; l = l->next)
2024 GIrNode *member = (GIrNode *)l->data;
2026 g_ir_node_build_typelib (member, node, build, offset, offset2);
2032 case G_IR_NODE_ENUM:
2033 case G_IR_NODE_FLAGS:
2035 EnumBlob *blob = (EnumBlob *)&data[*offset];
2036 GIrNodeEnum *enum_ = (GIrNodeEnum *)node;
2038 *offset += sizeof (EnumBlob);
2040 if (node->type == G_IR_NODE_ENUM)
2041 blob->blob_type = BLOB_TYPE_ENUM;
2043 blob->blob_type = BLOB_TYPE_FLAGS;
2045 blob->deprecated = enum_->deprecated;
2047 blob->storage_type = enum_->storage_type;
2048 blob->name = write_string (node->name, strings, data, offset2);
2049 if (enum_->gtype_name)
2051 blob->unregistered = FALSE;
2052 blob->gtype_name = write_string (enum_->gtype_name, strings, data, offset2);
2053 blob->gtype_init = write_string (enum_->gtype_init, strings, data, offset2);
2057 blob->unregistered = TRUE;
2058 blob->gtype_name = 0;
2059 blob->gtype_init = 0;
2063 blob->reserved2 = 0;
2065 for (l = enum_->values; l; l = l->next)
2067 GIrNode *value = (GIrNode *)l->data;
2070 g_ir_node_build_typelib (value, node, build, offset, offset2);
2075 case G_IR_NODE_OBJECT:
2077 ObjectBlob *blob = (ObjectBlob *)&data[*offset];
2078 GIrNodeInterface *object = (GIrNodeInterface *)node;
2081 blob->blob_type = BLOB_TYPE_OBJECT;
2082 blob->abstract = object->abstract;
2083 blob->deprecated = object->deprecated;
2085 blob->name = write_string (node->name, strings, data, offset2);
2086 blob->gtype_name = write_string (object->gtype_name, strings, data, offset2);
2087 blob->gtype_init = write_string (object->gtype_init, strings, data, offset2);
2089 blob->parent = find_entry (module, modules, object->parent);
2092 if (object->glib_type_struct)
2093 blob->gtype_struct = find_entry (module, modules, object->glib_type_struct);
2095 blob->gtype_struct = 0;
2097 blob->n_interfaces = 0;
2099 blob->n_properties = 0;
2100 blob->n_methods = 0;
2101 blob->n_signals = 0;
2103 blob->n_constants = 0;
2105 *offset += sizeof(ObjectBlob);
2106 for (l = object->interfaces; l; l = l->next)
2108 blob->n_interfaces++;
2109 *(guint16*)&data[*offset] = find_entry (module, modules, (gchar *)l->data);
2113 members = g_list_copy (object->members);
2115 *offset = ALIGN_VALUE (*offset, 4);
2116 g_ir_node_build_members (&members, G_IR_NODE_FIELD, &blob->n_fields,
2117 node, build, offset, offset2);
2119 *offset = ALIGN_VALUE (*offset, 4);
2120 g_ir_node_build_members (&members, G_IR_NODE_PROPERTY, &blob->n_properties,
2121 node, build, offset, offset2);
2123 *offset = ALIGN_VALUE (*offset, 4);
2124 g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_methods,
2125 node, build, offset, offset2);
2127 *offset = ALIGN_VALUE (*offset, 4);
2128 g_ir_node_build_members (&members, G_IR_NODE_SIGNAL, &blob->n_signals,
2129 node, build, offset, offset2);
2131 *offset = ALIGN_VALUE (*offset, 4);
2132 g_ir_node_build_members (&members, G_IR_NODE_VFUNC, &blob->n_vfuncs,
2133 node, build, offset, offset2);
2135 *offset = ALIGN_VALUE (*offset, 4);
2136 g_ir_node_build_members (&members, G_IR_NODE_CONSTANT, &blob->n_constants,
2137 node, build, offset, offset2);
2139 g_ir_node_check_unhandled_members (&members, node->type);
2141 g_assert (members == NULL);
2145 case G_IR_NODE_INTERFACE:
2147 InterfaceBlob *blob = (InterfaceBlob *)&data[*offset];
2148 GIrNodeInterface *iface = (GIrNodeInterface *)node;
2151 blob->blob_type = BLOB_TYPE_INTERFACE;
2152 blob->deprecated = iface->deprecated;
2154 blob->name = write_string (node->name, strings, data, offset2);
2155 blob->gtype_name = write_string (iface->gtype_name, strings, data, offset2);
2156 blob->gtype_init = write_string (iface->gtype_init, strings, data, offset2);
2157 if (iface->glib_type_struct)
2158 blob->gtype_struct = find_entry (module, modules, iface->glib_type_struct);
2160 blob->gtype_struct = 0;
2161 blob->n_prerequisites = 0;
2162 blob->n_properties = 0;
2163 blob->n_methods = 0;
2164 blob->n_signals = 0;
2166 blob->n_constants = 0;
2168 *offset += sizeof (InterfaceBlob);
2169 for (l = iface->prerequisites; l; l = l->next)
2171 blob->n_prerequisites++;
2172 *(guint16*)&data[*offset] = find_entry (module, modules, (gchar *)l->data);
2176 members = g_list_copy (iface->members);
2178 *offset = ALIGN_VALUE (*offset, 4);
2179 g_ir_node_build_members (&members, G_IR_NODE_PROPERTY, &blob->n_properties,
2180 node, build, offset, offset2);
2182 *offset = ALIGN_VALUE (*offset, 4);
2183 g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_methods,
2184 node, build, offset, offset2);
2186 *offset = ALIGN_VALUE (*offset, 4);
2187 g_ir_node_build_members (&members, G_IR_NODE_SIGNAL, &blob->n_signals,
2188 node, build, offset, offset2);
2190 *offset = ALIGN_VALUE (*offset, 4);
2191 g_ir_node_build_members (&members, G_IR_NODE_VFUNC, &blob->n_vfuncs,
2192 node, build, offset, offset2);
2194 *offset = ALIGN_VALUE (*offset, 4);
2195 g_ir_node_build_members (&members, G_IR_NODE_CONSTANT, &blob->n_constants,
2196 node, build, offset, offset2);
2198 g_ir_node_check_unhandled_members (&members, node->type);
2200 g_assert (members == NULL);
2205 case G_IR_NODE_VALUE:
2207 GIrNodeValue *value = (GIrNodeValue *)node;
2208 ValueBlob *blob = (ValueBlob *)&data[*offset];
2209 *offset += sizeof (ValueBlob);
2211 blob->deprecated = value->deprecated;
2213 blob->name = write_string (node->name, strings, data, offset2);
2214 blob->value = value->value;
2218 case G_IR_NODE_ERROR_DOMAIN:
2220 GIrNodeErrorDomain *domain = (GIrNodeErrorDomain *)node;
2221 ErrorDomainBlob *blob = (ErrorDomainBlob *)&data[*offset];
2222 *offset += sizeof (ErrorDomainBlob);
2224 blob->blob_type = BLOB_TYPE_ERROR_DOMAIN;
2225 blob->deprecated = domain->deprecated;
2227 blob->name = write_string (node->name, strings, data, offset2);
2228 blob->get_quark = write_string (domain->getquark, strings, data, offset2);
2229 blob->error_codes = find_entry (module, modules, domain->codes);
2230 blob->reserved2 = 0;
2234 case G_IR_NODE_CONSTANT:
2236 GIrNodeConstant *constant = (GIrNodeConstant *)node;
2237 ConstantBlob *blob = (ConstantBlob *)&data[*offset];
2240 pos = *offset + G_STRUCT_OFFSET (ConstantBlob, type);
2241 *offset += sizeof (ConstantBlob);
2243 blob->blob_type = BLOB_TYPE_CONSTANT;
2244 blob->deprecated = constant->deprecated;
2246 blob->name = write_string (node->name, strings, data, offset2);
2248 blob->offset = *offset2;
2249 switch (constant->type->tag)
2251 case GI_TYPE_TAG_BOOLEAN:
2253 *(gboolean*)&data[blob->offset] = parse_boolean_value (constant->value);
2255 case GI_TYPE_TAG_INT8:
2257 *(gint8*)&data[blob->offset] = (gint8) parse_int_value (constant->value);
2259 case GI_TYPE_TAG_UINT8:
2261 *(guint8*)&data[blob->offset] = (guint8) parse_uint_value (constant->value);
2263 case GI_TYPE_TAG_INT16:
2265 *(gint16*)&data[blob->offset] = (gint16) parse_int_value (constant->value);
2267 case GI_TYPE_TAG_UINT16:
2269 *(guint16*)&data[blob->offset] = (guint16) parse_uint_value (constant->value);
2271 case GI_TYPE_TAG_INT32:
2273 *(gint32*)&data[blob->offset] = (gint32) parse_int_value (constant->value);
2275 case GI_TYPE_TAG_UINT32:
2277 *(guint32*)&data[blob->offset] = (guint32) parse_uint_value (constant->value);
2279 case GI_TYPE_TAG_INT64:
2281 DO_ALIGNED_COPY(&data[blob->offset], parse_int_value (constant->value), gint64);
2283 case GI_TYPE_TAG_UINT64:
2285 DO_ALIGNED_COPY(&data[blob->offset], parse_uint_value (constant->value), guint64);
2287 case GI_TYPE_TAG_SHORT:
2288 blob->size = sizeof (gshort);
2289 *(gshort*)&data[blob->offset] = (gshort) parse_int_value (constant->value);
2291 case GI_TYPE_TAG_USHORT:
2292 blob->size = sizeof (gushort);
2293 *(gushort*)&data[blob->offset] = (gushort) parse_uint_value (constant->value);
2295 case GI_TYPE_TAG_INT:
2296 blob->size = sizeof (gint);
2297 *(gint*)&data[blob->offset] = (gint) parse_int_value (constant->value);
2299 case GI_TYPE_TAG_UINT:
2300 blob->size = sizeof (guint);
2301 *(gint*)&data[blob->offset] = (guint) parse_uint_value (constant->value);
2303 case GI_TYPE_TAG_SSIZE: /* FIXME */
2304 case GI_TYPE_TAG_LONG:
2305 blob->size = sizeof (glong);
2306 DO_ALIGNED_COPY(&data[blob->offset], parse_int_value (constant->value), glong);
2308 case GI_TYPE_TAG_SIZE: /* FIXME */
2309 case GI_TYPE_TAG_TIME_T:
2310 case GI_TYPE_TAG_ULONG:
2311 blob->size = sizeof (gulong);
2312 DO_ALIGNED_COPY(&data[blob->offset], parse_uint_value (constant->value), gulong);
2314 case GI_TYPE_TAG_FLOAT:
2315 blob->size = sizeof (gfloat);
2316 DO_ALIGNED_COPY(&data[blob->offset], parse_float_value (constant->value), gfloat);
2318 case GI_TYPE_TAG_DOUBLE:
2319 blob->size = sizeof (gdouble);
2320 DO_ALIGNED_COPY(&data[blob->offset], parse_float_value (constant->value), gdouble);
2322 case GI_TYPE_TAG_UTF8:
2323 case GI_TYPE_TAG_FILENAME:
2324 blob->size = strlen (constant->value) + 1;
2325 memcpy (&data[blob->offset], constant->value, blob->size);
2328 *offset2 += ALIGN_VALUE (blob->size, 4);
2330 g_ir_node_build_typelib ((GIrNode *)constant->type, node, build, &pos, offset2);
2334 g_assert_not_reached ();
2337 g_debug ("node %s%s%s%p type '%s', offset %d -> %d, offset2 %d -> %d",
2338 node->name ? "'" : "",
2339 node->name ? node->name : "",
2340 node->name ? "' " : "",
2341 node, g_ir_node_type_to_string (node->type),
2342 old_offset, *offset, old_offset2, *offset2);
2344 if (*offset2 - old_offset2 + *offset - old_offset > g_ir_node_get_full_size (node))
2345 g_error ("exceeding space reservation; offset: %d (prev %d) offset2: %d (prev %d) nodesize: %d",
2346 *offset, old_offset, *offset2, old_offset2, g_ir_node_get_full_size (node));
2349 /* if str is already in the pool, return previous location, otherwise write str
2350 * to the typelib at offset, put it in the pool and update offset. If the
2351 * typelib is not large enough to hold the string, reallocate it.
2354 write_string (const gchar *str,
2355 GHashTable *strings,
2363 string_size += strlen (str);
2365 value = g_hash_table_lookup (strings, str);
2368 return GPOINTER_TO_UINT (value);
2370 unique_string_count += 1;
2371 unique_string_size += strlen (str);
2373 g_hash_table_insert (strings, (gpointer)str, GUINT_TO_POINTER (*offset));
2376 *offset = ALIGN_VALUE (start + strlen (str) + 1, 4);
2378 strcpy ((gchar*)&data[start], str);