git.roojs.org Git - gnome.gobject-introspection/blob - girepository/girnode.c

   1 /* GObject introspection: Typelib creation
   2  *
   3  * Copyright (C) 2005 Matthias Clasen
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "girmodule.h"
  26 #include "girnode.h"
  27 #include "gtypelib.h"
  28
  29 static gulong string_count = 0;
  30 static gulong unique_string_count = 0;
  31 static gulong string_size = 0;
  32 static gulong unique_string_size = 0;
  33 static gulong types_count = 0;
  34 static gulong unique_types_count = 0;
  35
  36 void
  37 _g_irnode_init_stats (void)
  38 {
  39   string_count = 0;
  40   unique_string_count = 0;
  41   string_size = 0;
  42   unique_string_size = 0;
  43   types_count = 0;
  44   unique_types_count = 0;
  45 }
  46
  47 void
  48 _g_irnode_dump_stats (void)
  49 {
  50   g_message ("%lu strings (%lu before sharing), %lu bytes (%lu before sharing)",
  51              unique_string_count, string_count, unique_string_size, string_size);
  52   g_message ("%lu types (%lu before sharing)", unique_types_count, types_count);
  53 }
  54
  55 #define ALIGN_VALUE(this, boundary) \
  56   (( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))
  57
  58
  59 const gchar *
  60 g_ir_node_type_to_string (GIrNodeTypeId type)
  61 {
  62   switch (type)
  63     {
  64     case G_IR_NODE_FUNCTION:
  65       return "function";
  66     case G_IR_NODE_CALLBACK:
  67       return "callback";
  68     case G_IR_NODE_PARAM:
  69       return "param";
  70     case G_IR_NODE_TYPE:
  71       return "type";
  72     case G_IR_NODE_OBJECT:
  73       return "object";
  74     case G_IR_NODE_INTERFACE:
  75       return "interface";
  76     case G_IR_NODE_SIGNAL:
  77       return "signal";
  78     case G_IR_NODE_PROPERTY:
  79       return "property";
  80     case G_IR_NODE_VFUNC:
  81       return "vfunc";
  82     case G_IR_NODE_FIELD:
  83       return "field";
  84     case G_IR_NODE_ENUM:
  85       return "enum";
  86     case G_IR_NODE_FLAGS:
  87       return "flags";
  88     case G_IR_NODE_BOXED:
  89       return "boxed";
  90     case G_IR_NODE_STRUCT:
  91       return "struct";
  92     case G_IR_NODE_VALUE:
  93       return "value";
  94     case G_IR_NODE_CONSTANT:
  95       return "constant";
  96     case G_IR_NODE_ERROR_DOMAIN:
  97       return "error-domain";
  98     case G_IR_NODE_XREF:
  99       return "xref";
 100     case G_IR_NODE_UNION:
 101       return "union";
 102     default:
 103       return "unknown";
 104     }
 105 }
 106
 107 GIrNode *
 108 g_ir_node_new (GIrNodeTypeId type)
 109 {
 110   GIrNode *node = NULL;
 111
 112   switch (type)
 113     {
 114    case G_IR_NODE_FUNCTION:
 115    case G_IR_NODE_CALLBACK:
 116       node = g_malloc0 (sizeof (GIrNodeFunction));
 117       break;
 118
 119    case G_IR_NODE_PARAM:
 120       node = g_malloc0 (sizeof (GIrNodeParam));
 121       break;
 122
 123    case G_IR_NODE_TYPE:
 124       node = g_malloc0 (sizeof (GIrNodeType));
 125       break;
 126
 127     case G_IR_NODE_OBJECT:
 128     case G_IR_NODE_INTERFACE:
 129       node = g_malloc0 (sizeof (GIrNodeInterface));
 130       break;
 131
 132     case G_IR_NODE_SIGNAL:
 133       node = g_malloc0 (sizeof (GIrNodeSignal));
 134       break;
 135
 136     case G_IR_NODE_PROPERTY:
 137       node = g_malloc0 (sizeof (GIrNodeProperty));
 138       break;
 139
 140     case G_IR_NODE_VFUNC:
 141       node = g_malloc0 (sizeof (GIrNodeFunction));
 142       break;
 143
 144     case G_IR_NODE_FIELD:
 145       node = g_malloc0 (sizeof (GIrNodeField));
 146       break;
 147
 148     case G_IR_NODE_ENUM:
 149     case G_IR_NODE_FLAGS:
 150       node = g_malloc0 (sizeof (GIrNodeEnum));
 151       break;
 152
 153     case G_IR_NODE_BOXED:
 154       node = g_malloc0 (sizeof (GIrNodeBoxed));
 155       break;
 156
 157     case G_IR_NODE_STRUCT:
 158       node = g_malloc0 (sizeof (GIrNodeStruct));
 159       break;
 160
 161     case G_IR_NODE_VALUE:
 162       node = g_malloc0 (sizeof (GIrNodeValue));
 163       break;
 164
 165     case G_IR_NODE_CONSTANT:
 166       node = g_malloc0 (sizeof (GIrNodeConstant));
 167       break;
 168
 169     case G_IR_NODE_ERROR_DOMAIN:
 170       node = g_malloc0 (sizeof (GIrNodeErrorDomain));
 171       break;
 172
 173     case G_IR_NODE_XREF:
 174       node = g_malloc0 (sizeof (GIrNodeXRef));
 175       break;
 176
 177     case G_IR_NODE_UNION:
 178       node = g_malloc0 (sizeof (GIrNodeUnion));
 179       break;
 180
 181     default:
 182       g_error ("Unhandled node type %d\n", type);
 183       break;
 184     }
 185
 186   node->type = type;
 187
 188   return node;
 189 }
 190
 191 void
 192 g_ir_node_free (GIrNode *node)
 193 {
 194   GList *l;
 195
 196   if (node == NULL)
 197     return;
 198
 199   switch (node->type)
 200     {
 201     case G_IR_NODE_FUNCTION:
 202     case G_IR_NODE_CALLBACK:
 203       {
 204         GIrNodeFunction *function = (GIrNodeFunction *)node;
 205
 206         g_free (node->name);
 207         g_free (function->symbol);
 208         g_ir_node_free ((GIrNode *)function->result);
 209         for (l = function->parameters; l; l = l->next)
 210           g_ir_node_free ((GIrNode *)l->data);
 211         g_list_free (function->parameters);
 212       }
 213       break;
 214
 215     case G_IR_NODE_TYPE:
 216       {
 217         GIrNodeType *type = (GIrNodeType *)node;
 218
 219         g_free (node->name);
 220         g_ir_node_free ((GIrNode *)type->parameter_type1);
 221         g_ir_node_free ((GIrNode *)type->parameter_type2);
 222
 223         g_free (type->interface);
 224         g_strfreev (type->errors);
 225
 226       }
 227       break;
 228
 229     case G_IR_NODE_PARAM:
 230       {
 231         GIrNodeParam *param = (GIrNodeParam *)node;
 232
 233         g_free (node->name);
 234         g_ir_node_free ((GIrNode *)param->type);
 235       }
 236       break;
 237
 238     case G_IR_NODE_PROPERTY:
 239       {
 240         GIrNodeProperty *property = (GIrNodeProperty *)node;
 241
 242         g_free (node->name);
 243         g_ir_node_free ((GIrNode *)property->type);
 244       }
 245       break;
 246
 247     case G_IR_NODE_SIGNAL:
 248       {
 249         GIrNodeSignal *signal = (GIrNodeSignal *)node;
 250
 251         g_free (node->name);
 252         for (l = signal->parameters; l; l = l->next)
 253           g_ir_node_free ((GIrNode *)l->data);
 254         g_list_free (signal->parameters);
 255         g_ir_node_free ((GIrNode *)signal->result);
 256       }
 257       break;
 258
 259     case G_IR_NODE_VFUNC:
 260       {
 261         GIrNodeVFunc *vfunc = (GIrNodeVFunc *)node;
 262
 263         g_free (node->name);
 264         for (l = vfunc->parameters; l; l = l->next)
 265           g_ir_node_free ((GIrNode *)l->data);
 266         g_list_free (vfunc->parameters);
 267         g_ir_node_free ((GIrNode *)vfunc->result);
 268       }
 269       break;
 270
 271     case G_IR_NODE_FIELD:
 272       {
 273         GIrNodeField *field = (GIrNodeField *)node;
 274
 275         g_free (node->name);
 276         g_ir_node_free ((GIrNode *)field->type);
 277       }
 278       break;
 279
 280     case G_IR_NODE_OBJECT:
 281     case G_IR_NODE_INTERFACE:
 282       {
 283         GIrNodeInterface *iface = (GIrNodeInterface *)node;
 284
 285         g_free (node->name);
 286         g_free (iface->gtype_name);
 287         g_free (iface->gtype_init);
 288
 289         g_free (iface->parent);
 290
 291         for (l = iface->interfaces; l; l = l->next)
 292           g_free ((GIrNode *)l->data);
 293         g_list_free (iface->interfaces);
 294
 295         for (l = iface->members; l; l = l->next)
 296           g_ir_node_free ((GIrNode *)l->data);
 297         g_list_free (iface->members);
 298
 299       }
 300       break;
 301
 302     case G_IR_NODE_VALUE:
 303       {
 304         g_free (node->name);
 305       }
 306       break;
 307
 308     case G_IR_NODE_ENUM:
 309     case G_IR_NODE_FLAGS:
 310       {
 311         GIrNodeEnum *enum_ = (GIrNodeEnum *)node;
 312
 313         g_free (node->name);
 314         g_free (enum_->gtype_name);
 315         g_free (enum_->gtype_init);
 316
 317         for (l = enum_->values; l; l = l->next)
 318           g_ir_node_free ((GIrNode *)l->data);
 319         g_list_free (enum_->values);
 320       }
 321       break;
 322
 323     case G_IR_NODE_BOXED:
 324       {
 325         GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
 326
 327         g_free (node->name);
 328         g_free (boxed->gtype_name);
 329         g_free (boxed->gtype_init);
 330
 331         for (l = boxed->members; l; l = l->next)
 332           g_ir_node_free ((GIrNode *)l->data);
 333         g_list_free (boxed->members);
 334       }
 335       break;
 336
 337     case G_IR_NODE_STRUCT:
 338       {
 339         GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
 340
 341         g_free (node->name);
 342         g_free (struct_->gtype_name);
 343         g_free (struct_->gtype_init);
 344
 345         for (l = struct_->members; l; l = l->next)
 346           g_ir_node_free ((GIrNode *)l->data);
 347         g_list_free (struct_->members);
 348       }
 349       break;
 350
 351     case G_IR_NODE_CONSTANT:
 352       {
 353         GIrNodeConstant *constant = (GIrNodeConstant *)node;
 354
 355         g_free (node->name);
 356         g_free (constant->value);
 357         g_ir_node_free ((GIrNode *)constant->type);
 358       }
 359       break;
 360
 361     case G_IR_NODE_ERROR_DOMAIN:
 362       {
 363         GIrNodeErrorDomain *domain = (GIrNodeErrorDomain *)node;
 364
 365         g_free (node->name);
 366         g_free (domain->getquark);
 367         g_free (domain->codes);
 368       }
 369       break;
 370
 371     case G_IR_NODE_XREF:
 372       {
 373         GIrNodeXRef *xref = (GIrNodeXRef *)node;
 374
 375         g_free (node->name);
 376         g_free (xref->namespace);
 377       }
 378       break;
 379
 380     case G_IR_NODE_UNION:
 381       {
 382         GIrNodeUnion *union_ = (GIrNodeUnion *)node;
 383
 384         g_free (node->name);
 385         g_free (union_->gtype_name);
 386         g_free (union_->gtype_init);
 387
 388         g_ir_node_free ((GIrNode *)union_->discriminator_type);
 389         for (l = union_->members; l; l = l->next)
 390           g_ir_node_free ((GIrNode *)l->data);
 391         for (l = union_->discriminators; l; l = l->next)
 392           g_ir_node_free ((GIrNode *)l->data);
 393       }
 394       break;
 395
 396     default:
 397       g_error ("Unhandled node type %d\n", node->type);
 398       break;
 399     }
 400
 401   g_free (node);
 402 }
 403
 404 /* returns the fixed size of the blob */
 405 guint32
 406 g_ir_node_get_size (GIrNode *node)
 407 {
 408   GList *l;
 409   gint size, n;
 410
 411   switch (node->type)
 412     {
 413     case G_IR_NODE_CALLBACK:
 414       size = 12;
 415       break;
 416
 417     case G_IR_NODE_FUNCTION:
 418       size = 16;
 419       break;
 420
 421     case G_IR_NODE_PARAM:
 422       size = 12;
 423       break;
 424
 425     case G_IR_NODE_TYPE:
 426       size = 4;
 427       break;
 428
 429     case G_IR_NODE_OBJECT:
 430       {
 431         GIrNodeInterface *iface = (GIrNodeInterface *)node;
 432
 433         n = g_list_length (iface->interfaces);
 434         size = 32 + 2 * (n + (n % 2));
 435
 436         for (l = iface->members; l; l = l->next)
 437           size += g_ir_node_get_size ((GIrNode *)l->data);
 438       }
 439       break;
 440
 441     case G_IR_NODE_INTERFACE:
 442       {
 443         GIrNodeInterface *iface = (GIrNodeInterface *)node;
 444
 445         n = g_list_length (iface->prerequisites);
 446         size = 28 + 2 * (n + (n % 2));
 447
 448         for (l = iface->members; l; l = l->next)
 449           size += g_ir_node_get_size ((GIrNode *)l->data);
 450       }
 451       break;
 452
 453     case G_IR_NODE_ENUM:
 454     case G_IR_NODE_FLAGS:
 455       {
 456         GIrNodeEnum *enum_ = (GIrNodeEnum *)node;
 457
 458         size = 20;
 459         for (l = enum_->values; l; l = l->next)
 460           size += g_ir_node_get_size ((GIrNode *)l->data);
 461       }
 462       break;
 463
 464     case G_IR_NODE_VALUE:
 465       size = 12;
 466       break;
 467
 468     case G_IR_NODE_STRUCT:
 469       {
 470         GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
 471
 472         size = 20;
 473         for (l = struct_->members; l; l = l->next)
 474           size += g_ir_node_get_size ((GIrNode *)l->data);
 475       }
 476       break;
 477
 478     case G_IR_NODE_BOXED:
 479       {
 480         GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
 481
 482         size = 20;
 483         for (l = boxed->members; l; l = l->next)
 484           size += g_ir_node_get_size ((GIrNode *)l->data);
 485       }
 486       break;
 487
 488     case G_IR_NODE_PROPERTY:
 489       size = 12;
 490       break;
 491
 492     case G_IR_NODE_SIGNAL:
 493       size = 12;
 494       break;
 495
 496     case G_IR_NODE_VFUNC:
 497       size = 16;
 498       break;
 499
 500     case G_IR_NODE_FIELD:
 501       size = 12;
 502       break;
 503
 504     case G_IR_NODE_CONSTANT:
 505       size = 20;
 506       break;
 507
 508     case G_IR_NODE_ERROR_DOMAIN:
 509       size = 16;
 510       break;
 511
 512     case G_IR_NODE_XREF:
 513       size = 0;
 514       break;
 515
 516     case G_IR_NODE_UNION:
 517       {
 518         GIrNodeUnion *union_ = (GIrNodeUnion *)node;
 519
 520         size = 28;
 521         for (l = union_->members; l; l = l->next)
 522           size += g_ir_node_get_size ((GIrNode *)l->data);
 523         for (l = union_->discriminators; l; l = l->next)
 524           size += g_ir_node_get_size ((GIrNode *)l->data);
 525       }
 526       break;
 527
 528     default:
 529       g_error ("Unhandled node type '%s'\n",
 530                g_ir_node_type_to_string (node->type));
 531       size = 0;
 532     }
 533
 534   g_debug ("node %p type '%s' size %d", node,
 535            g_ir_node_type_to_string (node->type), size);
 536
 537   return size;
 538 }
 539
 540 /* returns the full size of the blob including variable-size parts */
 541 static guint32
 542 g_ir_node_get_full_size_internal (GIrNode *parent,
 543                                   GIrNode *node)
 544 {
 545   GList *l;
 546   gint size, n;
 547
 548   if (node == NULL && parent != NULL)
 549     g_error ("Caught NULL node, parent=%s", parent->name);
 550
 551   g_debug ("node %p type '%s'", node,
 552            g_ir_node_type_to_string (node->type));
 553
 554   switch (node->type)
 555     {
 556     case G_IR_NODE_CALLBACK:
 557       {
 558         GIrNodeFunction *function = (GIrNodeFunction *)node;
 559         size = 12;
 560         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 561         for (l = function->parameters; l; l = l->next)
 562           {
 563             size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 564           }
 565         size += g_ir_node_get_full_size_internal (node, (GIrNode *)function->result);
 566       }
 567       break;
 568
 569     case G_IR_NODE_FUNCTION:
 570       {
 571         GIrNodeFunction *function = (GIrNodeFunction *)node;
 572         size = 24;
 573         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 574         size += ALIGN_VALUE (strlen (function->symbol) + 1, 4);
 575         for (l = function->parameters; l; l = l->next)
 576           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 577         size += g_ir_node_get_full_size_internal (node, (GIrNode *)function->result);
 578       }
 579       break;
 580
 581     case G_IR_NODE_PARAM:
 582       {
 583         GIrNodeParam *param = (GIrNodeParam *)node;
 584
 585         size = 12;
 586         if (node->name)
 587           size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 588         size += g_ir_node_get_full_size_internal (node, (GIrNode *)param->type);
 589       }
 590       break;
 591
 592     case G_IR_NODE_TYPE:
 593       {
 594         GIrNodeType *type = (GIrNodeType *)node;
 595         if (type->tag < GI_TYPE_TAG_ARRAY)
 596           size = 4;
 597         else
 598           {
 599             g_debug ("node %p type tag '%s'", node,
 600                      g_type_tag_to_string (type->tag));
 601
 602             switch (type->tag)
 603               {
 604               case GI_TYPE_TAG_ARRAY:
 605                 size = 4 + 4;
 606                 if (type->parameter_type1)
 607                   size += g_ir_node_get_full_size_internal (node, (GIrNode *)type->parameter_type1);
 608                 break;
 609               case GI_TYPE_TAG_INTERFACE:
 610                 size = 4 + 4;
 611                 break;
 612               case GI_TYPE_TAG_GLIST:
 613               case GI_TYPE_TAG_GSLIST:
 614                 size = 4 + 4;
 615                 if (type->parameter_type1)
 616                   size += g_ir_node_get_full_size_internal (node, (GIrNode *)type->parameter_type1);
 617                 break;
 618               case GI_TYPE_TAG_GHASH:
 619                 size = 4 + 4 + 4;
 620                 if (type->parameter_type1)
 621                   size += g_ir_node_get_full_size_internal (node, (GIrNode *)type->parameter_type1);
 622                 if (type->parameter_type2)
 623                   size += g_ir_node_get_full_size_internal (node, (GIrNode *)type->parameter_type2);
 624                 break;
 625               case GI_TYPE_TAG_ERROR:
 626                 {
 627                   gint n;
 628
 629                   if (type->errors)
 630                     n = g_strv_length (type->errors);
 631                   else
 632                     n = 0;
 633
 634                   size = 4 + 4 + 2 * (n + n % 2);
 635                 }
 636                 break;
 637               default:
 638                 g_error ("Unknown type tag %d\n", type->tag);
 639                 break;
 640               }
 641           }
 642       }
 643       break;
 644
 645     case G_IR_NODE_OBJECT:
 646       {
 647         GIrNodeInterface *iface = (GIrNodeInterface *)node;
 648
 649         n = g_list_length (iface->interfaces);
 650         size = 32;
 651         if (iface->parent)
 652           size += ALIGN_VALUE (strlen (iface->parent) + 1, 4);
 653         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 654         size += ALIGN_VALUE (strlen (iface->gtype_name) + 1, 4);
 655         if (iface->gtype_init)
 656           size += ALIGN_VALUE (strlen (iface->gtype_init) + 1, 4);
 657         size += ALIGN_VALUE ( + 1, 4);
 658         size += 2 * (n + (n % 2));
 659
 660         for (l = iface->members; l; l = l->next)
 661           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 662       }
 663       break;
 664
 665     case G_IR_NODE_INTERFACE:
 666       {
 667         GIrNodeInterface *iface = (GIrNodeInterface *)node;
 668
 669         n = g_list_length (iface->prerequisites);
 670         size = 28;
 671         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 672         size += ALIGN_VALUE (strlen (iface->gtype_name) + 1, 4);
 673         size += ALIGN_VALUE (strlen (iface->gtype_init) + 1, 4);
 674         size += 2 * (n + (n % 2));
 675
 676         for (l = iface->members; l; l = l->next)
 677           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 678       }
 679       break;
 680
 681     case G_IR_NODE_ENUM:
 682     case G_IR_NODE_FLAGS:
 683       {
 684         GIrNodeEnum *enum_ = (GIrNodeEnum *)node;
 685
 686         size = 20;
 687         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 688         if (enum_->gtype_name)
 689           {
 690             size += ALIGN_VALUE (strlen (enum_->gtype_name) + 1, 4);
 691             size += ALIGN_VALUE (strlen (enum_->gtype_init) + 1, 4);
 692           }
 693
 694         for (l = enum_->values; l; l = l->next)
 695           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 696       }
 697       break;
 698
 699     case G_IR_NODE_VALUE:
 700       {
 701         size = 12;
 702         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 703       }
 704       break;
 705
 706     case G_IR_NODE_STRUCT:
 707       {
 708         GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
 709
 710         size = 20;
 711         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 712         if (struct_->gtype_name)
 713           size += ALIGN_VALUE (strlen (struct_->gtype_name) + 1, 4);
 714         if (struct_->gtype_init)
 715           size += ALIGN_VALUE (strlen (struct_->gtype_init) + 1, 4);
 716         for (l = struct_->members; l; l = l->next)
 717           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 718       }
 719       break;
 720
 721     case G_IR_NODE_BOXED:
 722       {
 723         GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
 724
 725         size = 20;
 726         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 727         if (boxed->gtype_name)
 728           {
 729             size += ALIGN_VALUE (strlen (boxed->gtype_name) + 1, 4);
 730             size += ALIGN_VALUE (strlen (boxed->gtype_init) + 1, 4);
 731           }
 732         for (l = boxed->members; l; l = l->next)
 733           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 734       }
 735       break;
 736
 737     case G_IR_NODE_PROPERTY:
 738       {
 739         GIrNodeProperty *prop = (GIrNodeProperty *)node;
 740
 741         size = 12;
 742         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 743         size += g_ir_node_get_full_size_internal (node, (GIrNode *)prop->type);
 744       }
 745       break;
 746
 747     case G_IR_NODE_SIGNAL:
 748       {
 749         GIrNodeSignal *signal = (GIrNodeSignal *)node;
 750
 751         size = 12;
 752         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 753         for (l = signal->parameters; l; l = l->next)
 754           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 755         size += g_ir_node_get_full_size_internal (node, (GIrNode *)signal->result);
 756       }
 757       break;
 758
 759     case G_IR_NODE_VFUNC:
 760       {
 761         GIrNodeVFunc *vfunc = (GIrNodeVFunc *)node;
 762
 763         size = 16;
 764         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 765         for (l = vfunc->parameters; l; l = l->next)
 766           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 767         size += g_ir_node_get_full_size_internal (node, (GIrNode *)vfunc->result);
 768       }
 769       break;
 770
 771     case G_IR_NODE_FIELD:
 772       {
 773         GIrNodeField *field = (GIrNodeField *)node;
 774
 775         size = 12;
 776         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 777         size += g_ir_node_get_full_size_internal (node, (GIrNode *)field->type);
 778       }
 779       break;
 780
 781     case G_IR_NODE_CONSTANT:
 782       {
 783         GIrNodeConstant *constant = (GIrNodeConstant *)node;
 784
 785         size = 20;
 786         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 787         /* FIXME non-string values */
 788         size += ALIGN_VALUE (strlen (constant->value) + 1, 4);
 789         size += g_ir_node_get_full_size_internal (node, (GIrNode *)constant->type);
 790       }
 791       break;
 792
 793     case G_IR_NODE_ERROR_DOMAIN:
 794       {
 795         GIrNodeErrorDomain *domain = (GIrNodeErrorDomain *)node;
 796
 797         size = 16;
 798         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 799         size += ALIGN_VALUE (strlen (domain->getquark) + 1, 4);
 800       }
 801       break;
 802
 803     case G_IR_NODE_XREF:
 804       {
 805         GIrNodeXRef *xref = (GIrNodeXRef *)node;
 806
 807         size = 0;
 808         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 809         size += ALIGN_VALUE (strlen (xref->namespace) + 1, 4);
 810       }
 811       break;
 812
 813     case G_IR_NODE_UNION:
 814       {
 815         GIrNodeUnion *union_ = (GIrNodeUnion *)node;
 816
 817         size = 28;
 818         size += ALIGN_VALUE (strlen (node->name) + 1, 4);
 819         if (union_->gtype_name)
 820           size += ALIGN_VALUE (strlen (union_->gtype_name) + 1, 4);
 821         if (union_->gtype_init)
 822           size += ALIGN_VALUE (strlen (union_->gtype_init) + 1, 4);
 823         for (l = union_->members; l; l = l->next)
 824           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 825         for (l = union_->discriminators; l; l = l->next)
 826           size += g_ir_node_get_full_size_internal (node, (GIrNode *)l->data);
 827       }
 828       break;
 829
 830     default:
 831       g_error ("Unknown type tag %d\n", node->type);
 832       size = 0;
 833     }
 834
 835   g_debug ("node %s%s%s%p type '%s' full size %d",
 836            node->name ? "'" : "",
 837            node->name ? node->name : "",
 838            node->name ? "' " : "",
 839            node, g_ir_node_type_to_string (node->type), size);
 840
 841   return size;
 842 }
 843
 844 guint32
 845 g_ir_node_get_full_size (GIrNode *node)
 846 {
 847   return g_ir_node_get_full_size_internal (NULL, node);
 848 }
 849
 850 int
 851 g_ir_node_cmp (GIrNode *node,
 852                 GIrNode *other)
 853 {
 854   if (node->type < other->type)
 855     return -1;
 856   else if (node->type > other->type)
 857     return 1;
 858   else
 859     return strcmp (node->name, other->name);
 860 }
 861
 862 gboolean
 863 g_ir_node_can_have_member (GIrNode    *node)
 864 {
 865   switch (node->type)
 866     {
 867     case G_IR_NODE_OBJECT:
 868     case G_IR_NODE_INTERFACE:
 869     case G_IR_NODE_BOXED:
 870     case G_IR_NODE_STRUCT:
 871     case G_IR_NODE_UNION:
 872       return TRUE;
 873     /* list others individually rather than with default: so that compiler
 874      * warns if new node types are added without adding them to the switch
 875      */
 876     case G_IR_NODE_INVALID:
 877     case G_IR_NODE_FUNCTION:
 878     case G_IR_NODE_CALLBACK:
 879     case G_IR_NODE_ENUM:
 880     case G_IR_NODE_FLAGS:
 881     case G_IR_NODE_CONSTANT:
 882     case G_IR_NODE_ERROR_DOMAIN:
 883     case G_IR_NODE_PARAM:
 884     case G_IR_NODE_TYPE:
 885     case G_IR_NODE_PROPERTY:
 886     case G_IR_NODE_SIGNAL:
 887     case G_IR_NODE_VALUE:
 888     case G_IR_NODE_VFUNC:
 889     case G_IR_NODE_FIELD:
 890     case G_IR_NODE_XREF:
 891       return FALSE;
 892     };
 893   return FALSE;
 894 }
 895
 896 void
 897 g_ir_node_add_member (GIrNode         *node,
 898                       GIrNodeFunction *member)
 899 {
 900   g_return_if_fail (node != NULL);
 901   g_return_if_fail (member != NULL);
 902
 903   switch (node->type)
 904     {
 905     case G_IR_NODE_OBJECT:
 906     case G_IR_NODE_INTERFACE:
 907       {
 908         GIrNodeInterface *iface = (GIrNodeInterface *)node;
 909         iface->members =
 910           g_list_insert_sorted (iface->members, member,
 911                                 (GCompareFunc) g_ir_node_cmp);
 912         break;
 913       }
 914     case G_IR_NODE_BOXED:
 915       {
 916         GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
 917         boxed->members =
 918           g_list_insert_sorted (boxed->members, member,
 919                                 (GCompareFunc) g_ir_node_cmp);
 920         break;
 921       }
 922     case G_IR_NODE_STRUCT:
 923       {
 924         GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
 925         struct_->members =
 926           g_list_insert_sorted (struct_->members, member,
 927                                 (GCompareFunc) g_ir_node_cmp);
 928         break;
 929       }
 930     case G_IR_NODE_UNION:
 931       {
 932         GIrNodeUnion *union_ = (GIrNodeUnion *)node;
 933         union_->members =
 934           g_list_insert_sorted (union_->members, member,
 935                                 (GCompareFunc) g_ir_node_cmp);
 936         break;
 937       }
 938     default:
 939       g_error ("Cannot add a member to unknown type tag type %d\n",
 940                node->type);
 941       break;
 942     }
 943 }
 944
 945 const gchar *
 946 g_ir_node_param_direction_string (GIrNodeParam * node)
 947 {
 948   if (node->out)
 949     {
 950       if (node->in)
 951         return "in-out";
 952       else
 953         return "out";
 954     }
 955   return "in";
 956 }
 957
 958 static gint64
 959 parse_int_value (const gchar *str)
 960 {
 961   return strtoll (str, NULL, 0);
 962 }
 963
 964 static guint64
 965 parse_uint_value (const gchar *str)
 966 {
 967   return strtoull (str, NULL, 0);
 968 }
 969
 970 static gdouble
 971 parse_float_value (const gchar *str)
 972 {
 973   return strtod (str, NULL);
 974 }
 975
 976 static gboolean
 977 parse_boolean_value (const gchar *str)
 978 {
 979   if (strcmp (str, "TRUE") == 0)
 980     return TRUE;
 981
 982   if (strcmp (str, "FALSE") == 0)
 983     return FALSE;
 984
 985   return parse_int_value (str) ? TRUE : FALSE;
 986 }
 987
 988 static GIrNode *
 989 find_entry_node (GIrModule   *module,
 990                  GList       *modules,
 991                  const gchar *name,
 992                  guint16     *idx)
 993
 994 {
 995   GList *l;
 996   gint i;
 997   gchar **names;
 998   gint n_names;
 999   GIrNode *result = NULL;
1000
1001   g_assert (name != NULL);
1002   g_assert (strlen (name) > 0);
1003
1004   names = g_strsplit (name, ".", 0);
1005   n_names = g_strv_length (names);
1006   if (n_names > 2)
1007     g_error ("Too many name parts");
1008
1009   for (l = module->entries, i = 1; l; l = l->next, i++)
1010     {
1011       GIrNode *node = (GIrNode *)l->data;
1012
1013       if (n_names > 1)
1014         {
1015           if (node->type != G_IR_NODE_XREF)
1016             continue;
1017
1018           if (((GIrNodeXRef *)node)->namespace == NULL ||
1019               strcmp (((GIrNodeXRef *)node)->namespace, names[0]) != 0)
1020             continue;
1021         }
1022
1023       if (strcmp (node->name, names[n_names - 1]) == 0)
1024         {
1025           if (idx)
1026             *idx = i;
1027
1028           result = node;
1029           goto out;
1030         }
1031     }
1032
1033   if (n_names > 1)
1034     {
1035       GIrNode *node = g_ir_node_new (G_IR_NODE_XREF);
1036
1037       ((GIrNodeXRef *)node)->namespace = g_strdup (names[0]);
1038       node->name = g_strdup (names[1]);
1039
1040       module->entries = g_list_append (module->entries, node);
1041
1042       if (idx)
1043         *idx = g_list_length (module->entries);
1044
1045       result = node;
1046
1047       g_debug ("Creating XREF: %s %s", names[0], names[1]);
1048
1049       goto out;
1050     }
1051
1052   g_warning ("Entry '%s' not found", name);
1053
1054  out:
1055
1056   g_strfreev (names);
1057
1058   return result;
1059 }
1060
1061 static guint16
1062 find_entry (GIrModule   *module,
1063             GList       *modules,
1064             const gchar *name)
1065 {
1066   guint16 idx = 0;
1067
1068   find_entry_node (module, modules, name, &idx);
1069
1070   return idx;
1071 }
1072
1073 static GIrNode *
1074 find_name_in_module (GIrModule   *module,
1075                      const gchar *name)
1076 {
1077   GList *l;
1078
1079   for (l = module->entries; l; l = l->next)
1080     {
1081       GIrNode *node = (GIrNode *)l->data;
1082
1083       if (strcmp (node->name, name) == 0)
1084         return node;
1085     }
1086
1087   return NULL;
1088 }
1089
1090 gboolean
1091 g_ir_find_node (GIrModule  *module,
1092                 GList      *modules,
1093                 const char *name,
1094                 GIrNode   **node_out,
1095                 GIrModule **module_out)
1096 {
1097   char **names = g_strsplit (name, ".", 0);
1098   gint n_names = g_strv_length (names);
1099   GIrNode *node = NULL;
1100   GList *l;
1101
1102   if (n_names == 0)
1103     {
1104       g_warning ("Name can't be empty");
1105       goto out;
1106     }
1107
1108   if (n_names > 2)
1109     {
1110       g_warning ("Too many name parts in '%s'", name);
1111       goto out;
1112     }
1113
1114   if (n_names == 1)
1115     {
1116       *module_out = module;
1117       node = find_name_in_module (module, names[0]);
1118     }
1119   else if (strcmp (names[0], module->name) == 0)
1120     {
1121       *module_out = module;
1122       node = find_name_in_module (module, names[1]);
1123     }
1124   else
1125     {
1126       for (l = module->include_modules; l; l = l->next)
1127         {
1128           GIrModule *m = l->data;
1129
1130           if (strcmp (names[0], m->name) == 0)
1131             {
1132               *module_out = m;
1133               node = find_name_in_module (m, names[1]);
1134               goto out;
1135             }
1136         }
1137
1138       for (l = modules; l; l = l->next)
1139         {
1140           GIrModule *m = l->data;
1141
1142           if (strcmp (names[0], m->name) == 0)
1143             {
1144               *module_out = m;
1145               node = find_name_in_module (m, names[1]);
1146               goto out;
1147             }
1148         }
1149     }
1150
1151  out:
1152   g_strfreev (names);
1153
1154   *node_out = node;
1155
1156   return node != NULL;
1157 }
1158
1159 static void
1160 serialize_type (GIrModule    *module,
1161                 GList        *modules,
1162                 GIrNodeType  *node,
1163                 GString      *str)
1164 {
1165   gint i;
1166   const gchar* basic[] = {
1167     "void",
1168     "boolean",
1169     "int8",
1170     "uint8",
1171     "int16",
1172     "uint16",
1173     "int32",
1174     "uint32",
1175     "int64",
1176     "uint64",
1177     "int",
1178     "uint",
1179     "long",
1180     "ulong",
1181     "ssize",
1182     "size",
1183     "float",
1184     "double",
1185     "utf8",
1186     "filename",
1187     "string",
1188     "sequence",
1189     "any"
1190   };
1191
1192   if (node->tag < GI_TYPE_TAG_ARRAY)
1193     {
1194       g_string_append_printf (str, "%s", basic[node->tag]);
1195     }
1196   else if (node->tag == GI_TYPE_TAG_ARRAY)
1197     {
1198       serialize_type (module, modules, node->parameter_type1, str);
1199       g_string_append (str, "[");
1200
1201       if (node->has_length)
1202         g_string_append_printf (str, "length=%d", node->length);
1203       else if (node->has_size)
1204         g_string_append_printf (str, "fixed-size=%d", node->size);
1205
1206       if (node->zero_terminated)
1207         g_string_append_printf (str, "%szero-terminated=1",
1208                                 node->has_length ? "," : "");
1209
1210       g_string_append (str, "]");
1211     }
1212   else if (node->tag == GI_TYPE_TAG_INTERFACE)
1213     {
1214       GIrNode *iface;
1215       gchar *name;
1216
1217       iface = find_entry_node (module, modules, node->interface, NULL);
1218       if (iface)
1219         {
1220           if (iface->type == G_IR_NODE_XREF)
1221             g_string_append_printf (str, "%s.", ((GIrNodeXRef *)iface)->namespace);
1222           name = iface->name;
1223         }
1224       else
1225         {
1226           g_warning ("Interface for type reference %s not found", node->interface);
1227           name = node->interface;
1228         }
1229
1230       g_string_append_printf (str, "%s", name);
1231     }
1232   else if (node->tag == GI_TYPE_TAG_GLIST)
1233     {
1234       g_string_append (str, "GList");
1235       if (node->parameter_type1)
1236         {
1237           g_string_append (str, "<");
1238           serialize_type (module, modules, node->parameter_type1, str);
1239           g_string_append (str, ">");
1240         }
1241     }
1242   else if (node->tag == GI_TYPE_TAG_GSLIST)
1243     {
1244       g_string_append (str, "GSList");
1245       if (node->parameter_type1)
1246         {
1247           g_string_append (str, "<");
1248           serialize_type (module, modules, node->parameter_type1, str);
1249           g_string_append (str, ">");
1250         }
1251     }
1252   else if (node->tag == GI_TYPE_TAG_GHASH)
1253     {
1254       g_string_append (str, "GHashTable<");
1255       if (node->parameter_type1)
1256         {
1257           g_string_append (str, "<");
1258           serialize_type (module, modules, node->parameter_type1, str);
1259           g_string_append (str, ",");
1260           serialize_type (module, modules, node->parameter_type2, str);
1261           g_string_append (str, ">");
1262         }
1263     }
1264   else if (node->tag == GI_TYPE_TAG_ERROR)
1265     {
1266       g_string_append (str, "GError");
1267       if (node->errors)
1268         {
1269           g_string_append (str, "<");
1270           for (i = 0; node->errors[i]; i++)
1271             {
1272               if (i > 0)
1273                 g_string_append (str, ",");
1274               g_string_append (str, node->errors[i]);
1275             }
1276           g_string_append (str, ">");
1277         }
1278     }
1279 }
1280
1281 static void
1282 g_ir_node_build_members (GList         **members,
1283                          GIrNodeTypeId   type,
1284                          guint16        *count,
1285                          GIrModule      *module,
1286                          GList          *modules,
1287                          GHashTable     *strings,
1288                          GHashTable     *types,
1289                          guchar         *data,
1290                          guint32        *offset,
1291                          guint32        *offset2)
1292 {
1293   GList *l = *members;
1294
1295   while (l)
1296     {
1297       GIrNode *member = (GIrNode *)l->data;
1298       GList *next = l->next;
1299
1300       if (member->type == type)
1301         {
1302           (*count)++;
1303           g_ir_node_build_typelib (member, module, modules, strings,
1304                                    types, data, offset, offset2);
1305           *members = g_list_delete_link (*members, l);
1306         }
1307       l = next;
1308     }
1309 }
1310
1311 static void
1312 g_ir_node_check_unhandled_members (GList         **members,
1313                                    GIrNodeTypeId   container_type)
1314 {
1315 #if 0
1316   if (*members)
1317     {
1318       GList *l;
1319
1320       for (l = *members; l; l = l->next)
1321         {
1322           GIrNode *member = (GIrNode *)l->data;
1323           g_printerr ("Unhandled '%s' member '%s' type '%s'\n",
1324                       g_ir_node_type_to_string (container_type),
1325                       member->name,
1326                       g_ir_node_type_to_string (member->type));
1327         }
1328
1329       g_list_free (*members);
1330       *members = NULL;
1331
1332       g_error ("Unhandled members. Aborting.");
1333     }
1334 #else
1335   g_list_free (*members);
1336   *members = NULL;
1337 #endif
1338 }
1339
1340 void
1341 g_ir_node_build_typelib (GIrNode    *node,
1342                          GIrModule  *module,
1343                          GList      *modules,
1344                          GHashTable *strings,
1345                          GHashTable *types,
1346                          guchar     *data,
1347                          guint32    *offset,
1348                          guint32    *offset2)
1349 {
1350   GList *l;
1351   guint32 old_offset = *offset;
1352   guint32 old_offset2 = *offset2;
1353
1354   g_assert (node != NULL);
1355
1356   g_debug ("build_typelib: %s%s(%s)",
1357            node->name ? node->name : "",
1358            node->name ? " " : "",
1359            g_ir_node_type_to_string (node->type));
1360
1361   g_ir_node_compute_offsets (node, module, modules);
1362
1363   switch (node->type)
1364     {
1365     case G_IR_NODE_TYPE:
1366       {
1367         GIrNodeType *type = (GIrNodeType *)node;
1368         SimpleTypeBlob *blob = (SimpleTypeBlob *)&data[*offset];
1369
1370         *offset += 4;
1371
1372         if (type->tag < GI_TYPE_TAG_ARRAY ||
1373             type->tag == GI_TYPE_TAG_UTF8 ||
1374             type->tag == GI_TYPE_TAG_FILENAME)
1375           {
1376             blob->reserved = 0;
1377             blob->reserved2 = 0;
1378             blob->pointer = type->is_pointer;
1379             blob->reserved3 = 0;
1380             blob->tag = type->tag;
1381           }
1382         else
1383           {
1384             GString *str;
1385             gchar *s;
1386             gpointer value;
1387
1388             str = g_string_new (0);
1389             serialize_type (module, modules, type, str);
1390             s = g_string_free (str, FALSE);
1391
1392             types_count += 1;
1393             value = g_hash_table_lookup (types, s);
1394             if (value)
1395               {
1396                 blob->offset = GPOINTER_TO_UINT (value);
1397                 g_free (s);
1398               }
1399             else
1400               {
1401                 unique_types_count += 1;
1402                 g_hash_table_insert (types, s, GUINT_TO_POINTER(*offset2));
1403
1404                 blob->offset = *offset2;
1405                 switch (type->tag)
1406                   {
1407                   case GI_TYPE_TAG_ARRAY:
1408                     {
1409                       ArrayTypeBlob *array = (ArrayTypeBlob *)&data[*offset2];
1410                       guint32 pos;
1411
1412                       array->pointer = 1;
1413                       array->reserved = 0;
1414                       array->tag = type->tag;
1415                       array->zero_terminated = type->zero_terminated;
1416                       array->has_length = type->has_length;
1417                       array->has_size = type->has_size;
1418                       array->reserved2 = 0;
1419                       if (array->has_length)
1420                         array->length = type->length;
1421                       else if (array->has_size)
1422                         array->size  = type->size;
1423                       else
1424                         array->length = -1;
1425
1426                       pos = *offset2 + 4;
1427                       *offset2 += 8;
1428
1429                       g_ir_node_build_typelib ((GIrNode *)type->parameter_type1,
1430                                                module, modules, strings, types,
1431                                                data, &pos, offset2);
1432                     }
1433                     break;
1434
1435                   case GI_TYPE_TAG_INTERFACE:
1436                     {
1437                       InterfaceTypeBlob *iface = (InterfaceTypeBlob *)&data[*offset2];
1438                       *offset2 += 4;
1439
1440                       iface->pointer = type->is_pointer;
1441                       iface->reserved = 0;
1442                       iface->tag = type->tag;
1443                       iface->reserved2 = 0;
1444                       iface->interface = find_entry (module, modules, type->interface);
1445
1446                     }
1447                     break;
1448
1449                   case GI_TYPE_TAG_GLIST:
1450                   case GI_TYPE_TAG_GSLIST:
1451                     {
1452                       ParamTypeBlob *param = (ParamTypeBlob *)&data[*offset2];
1453                       guint32 pos;
1454
1455                       param->pointer = 1;
1456                       param->reserved = 0;
1457                       param->tag = type->tag;
1458                       param->reserved2 = 0;
1459                       param->n_types = 1;
1460
1461                       pos = *offset2 + 4;
1462                       *offset2 += 8;
1463
1464                       g_ir_node_build_typelib ((GIrNode *)type->parameter_type1,
1465                                                module, modules, strings, types,
1466                                                data, &pos, offset2);
1467                     }
1468                     break;
1469
1470                   case GI_TYPE_TAG_GHASH:
1471                     {
1472                       ParamTypeBlob *param = (ParamTypeBlob *)&data[*offset2];
1473                       guint32 pos;
1474
1475                       param->pointer = 1;
1476                       param->reserved = 0;
1477                       param->tag = type->tag;
1478                       param->reserved2 = 0;
1479                       param->n_types = 2;
1480
1481                       pos = *offset2 + 4;
1482                       *offset2 += 12;
1483
1484                       g_ir_node_build_typelib ((GIrNode *)type->parameter_type1,
1485                                                module, modules, strings, types,
1486                                                data, &pos, offset2);
1487                       g_ir_node_build_typelib ((GIrNode *)type->parameter_type2,
1488                                                module, modules, strings, types,
1489                                                data, &pos, offset2);
1490                     }
1491                     break;
1492
1493                   case GI_TYPE_TAG_ERROR:
1494                     {
1495                       ErrorTypeBlob *blob = (ErrorTypeBlob *)&data[*offset2];
1496                       gint i;
1497
1498                       blob->pointer = 1;
1499                       blob->reserved = 0;
1500                       blob->tag = type->tag;
1501                       blob->reserved2 = 0;
1502                       if (type->errors)
1503                         blob->n_domains = g_strv_length (type->errors);
1504                       else
1505                         blob->n_domains = 0;
1506
1507                       *offset2 = ALIGN_VALUE (*offset2 + 4 + 2 * blob->n_domains, 4);
1508                       for (i = 0; i < blob->n_domains; i++)
1509                         blob->domains[i] = find_entry (module, modules, type->errors[i]);
1510                     }
1511                     break;
1512
1513                   default:
1514                     g_error ("Unknown type tag %d\n", type->tag);
1515                     break;
1516                   }
1517               }
1518           }
1519       }
1520       break;
1521
1522     case G_IR_NODE_FIELD:
1523       {
1524         GIrNodeField *field = (GIrNodeField *)node;
1525         FieldBlob *blob;
1526
1527         blob = (FieldBlob *)&data[*offset];
1528         *offset += 8;
1529
1530         blob->name = write_string (node->name, strings, data, offset2);
1531         blob->readable = field->readable;
1532         blob->writable = field->writable;
1533         blob->reserved = 0;
1534         blob->bits = 0;
1535         if (field->offset >= 0)
1536           blob->struct_offset = field->offset;
1537         else
1538           blob->struct_offset = 0xFFFF; /* mark as unknown */
1539
1540         g_ir_node_build_typelib ((GIrNode *)field->type,
1541                                  module, modules, strings, types,
1542                                  data, offset, offset2);
1543       }
1544       break;
1545
1546     case G_IR_NODE_PROPERTY:
1547       {
1548         GIrNodeProperty *prop = (GIrNodeProperty *)node;
1549         PropertyBlob *blob = (PropertyBlob *)&data[*offset];
1550         *offset += 8;
1551
1552         blob->name = write_string (node->name, strings, data, offset2);
1553         blob->deprecated = prop->deprecated;
1554         blob->readable = prop->readable;
1555         blob->writable = prop->writable;
1556         blob->construct = prop->construct;
1557         blob->construct_only = prop->construct_only;
1558         blob->reserved = 0;
1559
1560         g_ir_node_build_typelib ((GIrNode *)prop->type,
1561                                  module, modules, strings, types,
1562                                  data, offset, offset2);
1563       }
1564       break;
1565
1566     case G_IR_NODE_FUNCTION:
1567       {
1568         FunctionBlob *blob = (FunctionBlob *)&data[*offset];
1569         SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1570         GIrNodeFunction *function = (GIrNodeFunction *)node;
1571         guint32 signature;
1572         gint n;
1573
1574         signature = *offset2;
1575         n = g_list_length (function->parameters);
1576
1577         *offset += 16;
1578         *offset2 += 8 + n * 12;
1579
1580         blob->blob_type = BLOB_TYPE_FUNCTION;
1581         blob->deprecated = function->deprecated;
1582         blob->setter = function->is_setter;
1583         blob->getter = function->is_getter;
1584         blob->constructor = function->is_constructor;
1585         blob->wraps_vfunc = function->wraps_vfunc;
1586         blob->throws = function->throws;
1587         blob->index = 0;
1588         blob->name = write_string (node->name, strings, data, offset2);
1589         blob->symbol = write_string (function->symbol, strings, data, offset2);
1590         blob->signature = signature;
1591
1592         g_debug ("building function '%s'", function->symbol);
1593
1594         g_ir_node_build_typelib ((GIrNode *)function->result->type,
1595                                  module, modules, strings, types,
1596                                  data, &signature, offset2);
1597
1598         blob2->may_return_null = function->result->allow_none;
1599         blob2->caller_owns_return_value = function->result->transfer;
1600         blob2->caller_owns_return_container = function->result->shallow_transfer;
1601         blob2->reserved = 0;
1602         blob2->n_arguments = n;
1603
1604         signature += 4;
1605
1606         for (l = function->parameters; l; l = l->next)
1607           {
1608             GIrNode *param = (GIrNode *)l->data;
1609
1610             g_ir_node_build_typelib (param,
1611                                      module, modules, strings, types,
1612                                      data, &signature, offset2);
1613           }
1614
1615       }
1616       break;
1617
1618     case G_IR_NODE_CALLBACK:
1619       {
1620         CallbackBlob *blob = (CallbackBlob *)&data[*offset];
1621         SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1622         GIrNodeFunction *function = (GIrNodeFunction *)node;
1623         guint32 signature;
1624         gint n;
1625
1626         signature = *offset2;
1627         n = g_list_length (function->parameters);
1628
1629         *offset += 12;
1630         *offset2 += 8 + n * 12;
1631
1632         blob->blob_type = BLOB_TYPE_CALLBACK;
1633         blob->deprecated = function->deprecated;
1634         blob->reserved = 0;
1635         blob->name = write_string (node->name, strings, data, offset2);
1636         blob->signature = signature;
1637
1638         g_ir_node_build_typelib ((GIrNode *)function->result->type,
1639                                  module, modules, strings, types,
1640                                  data, &signature, offset2);
1641
1642         blob2->may_return_null = function->result->allow_none;
1643         blob2->caller_owns_return_value = function->result->transfer;
1644         blob2->caller_owns_return_container = function->result->shallow_transfer;
1645         blob2->reserved = 0;
1646         blob2->n_arguments = n;
1647
1648         signature += 4;
1649
1650         for (l = function->parameters; l; l = l->next)
1651           {
1652             GIrNode *param = (GIrNode *)l->data;
1653
1654             g_ir_node_build_typelib (param,
1655                                      module, modules, strings, types,
1656                                      data, &signature, offset2);
1657           }
1658       }
1659       break;
1660
1661     case G_IR_NODE_SIGNAL:
1662       {
1663         SignalBlob *blob = (SignalBlob *)&data[*offset];
1664         SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1665         GIrNodeSignal *signal = (GIrNodeSignal *)node;
1666         guint32 signature;
1667         gint n;
1668
1669         signature = *offset2;
1670         n = g_list_length (signal->parameters);
1671
1672         *offset += 12;
1673         *offset2 += 8 + n * 12;
1674
1675         blob->deprecated = signal->deprecated;
1676         blob->run_first = signal->run_first;
1677         blob->run_last = signal->run_last;
1678         blob->run_cleanup = signal->run_cleanup;
1679         blob->no_recurse = signal->no_recurse;
1680         blob->detailed = signal->detailed;
1681         blob->action = signal->action;
1682         blob->no_hooks = signal->no_hooks;
1683         blob->has_class_closure = 0; /* FIXME */
1684         blob->true_stops_emit = 0; /* FIXME */
1685         blob->reserved = 0;
1686         blob->class_closure = 0; /* FIXME */
1687         blob->name = write_string (node->name, strings, data, offset2);
1688         blob->signature = signature;
1689
1690         g_ir_node_build_typelib ((GIrNode *)signal->result->type,
1691                                  module, modules, strings, types,
1692                                  data, &signature, offset2);
1693
1694         blob2->may_return_null = signal->result->allow_none;
1695         blob2->caller_owns_return_value = signal->result->transfer;
1696         blob2->caller_owns_return_container = signal->result->shallow_transfer;
1697         blob2->reserved = 0;
1698         blob2->n_arguments = n;
1699
1700         signature += 4;
1701
1702         for (l = signal->parameters; l; l = l->next)
1703           {
1704             GIrNode *param = (GIrNode *)l->data;
1705
1706             g_ir_node_build_typelib (param, module, modules, strings, types,
1707                                      data, &signature, offset2);
1708           }
1709       }
1710       break;
1711
1712     case G_IR_NODE_VFUNC:
1713       {
1714         VFuncBlob *blob = (VFuncBlob *)&data[*offset];
1715         SignatureBlob *blob2 = (SignatureBlob *)&data[*offset2];
1716         GIrNodeVFunc *vfunc = (GIrNodeVFunc *)node;
1717         guint32 signature;
1718         gint n;
1719
1720         signature = *offset2;
1721         n = g_list_length (vfunc->parameters);
1722
1723         *offset += 16;
1724         *offset2 += 8 + n * 12;
1725
1726         blob->name = write_string (node->name, strings, data, offset2);
1727         blob->must_chain_up = 0; /* FIXME */
1728         blob->must_be_implemented = 0; /* FIXME */
1729         blob->must_not_be_implemented = 0; /* FIXME */
1730         blob->class_closure = 0; /* FIXME */
1731         blob->reserved = 0;
1732
1733         blob->struct_offset = vfunc->offset;
1734         blob->reserved2 = 0;
1735         blob->signature = signature;
1736
1737         g_ir_node_build_typelib ((GIrNode *)vfunc->result->type,
1738                                  module, modules, strings, types,
1739                                  data, &signature, offset2);
1740
1741         blob2->may_return_null = vfunc->result->allow_none;
1742         blob2->caller_owns_return_value = vfunc->result->transfer;
1743         blob2->caller_owns_return_container = vfunc->result->shallow_transfer;
1744         blob2->reserved = 0;
1745         blob2->n_arguments = n;
1746
1747         signature += 4;
1748
1749         for (l = vfunc->parameters; l; l = l->next)
1750           {
1751             GIrNode *param = (GIrNode *)l->data;
1752
1753             g_ir_node_build_typelib (param, module, modules, strings,
1754                                      types, data, &signature, offset2);
1755           }
1756       }
1757       break;
1758
1759     case G_IR_NODE_PARAM:
1760       {
1761         ArgBlob *blob = (ArgBlob *)&data[*offset];
1762         GIrNodeParam *param = (GIrNodeParam *)node;
1763
1764         *offset += 8;
1765
1766         blob->name = write_string (node->name, strings, data, offset2);
1767         blob->in = param->in;
1768         blob->out = param->out;
1769         blob->dipper = param->dipper;
1770         blob->allow_none = param->allow_none;
1771         blob->optional = param->optional;
1772         blob->transfer_ownership = param->transfer;
1773         blob->transfer_container_ownership = param->shallow_transfer;
1774         blob->return_value = param->retval;
1775         blob->reserved = 0;
1776
1777         g_ir_node_build_typelib ((GIrNode *)param->type, module, modules,
1778                                  strings, types, data, offset, offset2);
1779       }
1780       break;
1781
1782     case G_IR_NODE_STRUCT:
1783       {
1784         StructBlob *blob = (StructBlob *)&data[*offset];
1785         GIrNodeStruct *struct_ = (GIrNodeStruct *)node;
1786         GList *members;
1787
1788         blob->blob_type = BLOB_TYPE_STRUCT;
1789         blob->deprecated = struct_->deprecated;
1790         blob->reserved = 0;
1791         blob->name = write_string (node->name, strings, data, offset2);
1792         if (struct_->gtype_name)
1793           {
1794             blob->unregistered = FALSE;
1795             blob->gtype_name = write_string (struct_->gtype_name, strings, data, offset2);
1796             blob->gtype_init = write_string (struct_->gtype_init, strings, data, offset2);
1797           }
1798         else
1799           {
1800             blob->unregistered = TRUE;
1801             blob->gtype_name = 0;
1802             blob->gtype_init = 0;
1803           }
1804
1805         blob->n_fields = 0;
1806         blob->n_methods = 0;
1807
1808         *offset += 20;
1809
1810         members = g_list_copy (struct_->members);
1811
1812         g_ir_node_build_members (&members, G_IR_NODE_FIELD, &blob->n_fields,
1813                                  module, modules, strings,
1814                                  types, data, offset, offset2);
1815
1816         g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_methods,
1817                                  module, modules, strings,
1818                                  types, data, offset, offset2);
1819
1820         g_ir_node_check_unhandled_members (&members, node->type);
1821
1822         g_assert (members == NULL);
1823       }
1824       break;
1825
1826     case G_IR_NODE_BOXED:
1827       {
1828         StructBlob *blob = (StructBlob *)&data[*offset];
1829         GIrNodeBoxed *boxed = (GIrNodeBoxed *)node;
1830         GList *members;
1831
1832         blob->blob_type = BLOB_TYPE_BOXED;
1833         blob->deprecated = boxed->deprecated;
1834         blob->unregistered = FALSE;
1835         blob->reserved = 0;
1836         blob->name = write_string (node->name, strings, data, offset2);
1837         blob->gtype_name = write_string (boxed->gtype_name, strings, data, offset2);
1838         blob->gtype_init = write_string (boxed->gtype_init, strings, data, offset2);
1839
1840         blob->n_fields = 0;
1841         blob->n_methods = 0;
1842
1843         *offset += 20;
1844
1845         members = g_list_copy (boxed->members);
1846
1847         g_ir_node_build_members (&members, G_IR_NODE_FIELD, &blob->n_fields,
1848                                  module, modules, strings,
1849                                  types, data, offset, offset2);
1850
1851         g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_methods,
1852                                  module, modules, strings,
1853                                  types, data, offset, offset2);
1854
1855         g_ir_node_check_unhandled_members (&members, node->type);
1856
1857         g_assert (members == NULL);
1858       }
1859       break;
1860
1861     case G_IR_NODE_UNION:
1862       {
1863         UnionBlob *blob = (UnionBlob *)&data[*offset];
1864         GIrNodeUnion *union_ = (GIrNodeUnion *)node;
1865         GList *members;
1866
1867         blob->blob_type = BLOB_TYPE_UNION;
1868         blob->deprecated = union_->deprecated;
1869         blob->reserved = 0;
1870         blob->name = write_string (node->name, strings, data, offset2);
1871         if (union_->gtype_name)
1872           {
1873             blob->unregistered = FALSE;
1874             blob->gtype_name = write_string (union_->gtype_name, strings, data, offset2);
1875             blob->gtype_init = write_string (union_->gtype_init, strings, data, offset2);
1876           }
1877         else
1878           {
1879             blob->unregistered = TRUE;
1880             blob->gtype_name = 0;
1881             blob->gtype_init = 0;
1882           }
1883
1884         blob->n_fields = 0;
1885         blob->n_functions = 0;
1886
1887         blob->discriminator_offset = union_->discriminator_offset;
1888
1889         if (union_->discriminator_type)
1890           {
1891             *offset += 24;
1892             blob->discriminated = TRUE;
1893             g_ir_node_build_typelib ((GIrNode *)union_->discriminator_type,
1894                                      module, modules, strings, types,
1895                                      data, offset, offset2);
1896           }
1897         else
1898           {
1899             *offset += 28;
1900             blob->discriminated = FALSE;
1901             blob->discriminator_type.offset = 0;
1902           }
1903
1904         members = g_list_copy (union_->members);
1905
1906         g_ir_node_build_members (&members, G_IR_NODE_FIELD, &blob->n_fields,
1907                                  module, modules, strings,
1908                                  types, data, offset, offset2);
1909
1910         g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_functions,
1911                                  module, modules, strings,
1912                                  types, data, offset, offset2);
1913
1914         g_ir_node_check_unhandled_members (&members, node->type);
1915
1916         g_assert (members == NULL);
1917
1918         if (union_->discriminator_type)
1919           {
1920             for (l = union_->discriminators; l; l = l->next)
1921               {
1922                 GIrNode *member = (GIrNode *)l->data;
1923
1924                 g_ir_node_build_typelib (member, module, modules, strings,
1925                                          types, data, offset, offset2);
1926               }
1927           }
1928       }
1929       break;
1930
1931     case G_IR_NODE_ENUM:
1932     case G_IR_NODE_FLAGS:
1933       {
1934         EnumBlob *blob = (EnumBlob *)&data[*offset];
1935         GIrNodeEnum *enum_ = (GIrNodeEnum *)node;
1936
1937         *offset += 20;
1938
1939         if (node->type == G_IR_NODE_ENUM)
1940           blob->blob_type = BLOB_TYPE_ENUM;
1941         else
1942           blob->blob_type = BLOB_TYPE_FLAGS;
1943
1944         blob->deprecated = enum_->deprecated;
1945         blob->reserved = 0;
1946         blob->name = write_string (node->name, strings, data, offset2);
1947         if (enum_->gtype_name)
1948           {
1949             blob->unregistered = FALSE;
1950             blob->gtype_name = write_string (enum_->gtype_name, strings, data, offset2);
1951             blob->gtype_init = write_string (enum_->gtype_init, strings, data, offset2);
1952           }
1953         else
1954           {
1955             blob->unregistered = TRUE;
1956             blob->gtype_name = 0;
1957             blob->gtype_init = 0;
1958           }
1959
1960         blob->n_values = 0;
1961         blob->reserved2 = 0;
1962
1963         for (l = enum_->values; l; l = l->next)
1964           {
1965             GIrNode *value = (GIrNode *)l->data;
1966
1967             blob->n_values++;
1968             g_ir_node_build_typelib (value, module, modules, strings, types,
1969                                      data, offset, offset2);
1970           }
1971       }
1972       break;
1973
1974     case G_IR_NODE_OBJECT:
1975       {
1976         ObjectBlob *blob = (ObjectBlob *)&data[*offset];
1977         GIrNodeInterface *object = (GIrNodeInterface *)node;
1978         GList *members;
1979
1980         blob->blob_type = BLOB_TYPE_OBJECT;
1981         blob->abstract = object->abstract;
1982         blob->deprecated = object->deprecated;
1983         blob->reserved = 0;
1984         blob->name = write_string (node->name, strings, data, offset2);
1985         blob->gtype_name = write_string (object->gtype_name, strings, data, offset2);
1986         blob->gtype_init = write_string (object->gtype_init, strings, data, offset2);
1987         if (object->parent)
1988           blob->parent = find_entry (module, modules, object->parent);
1989         else
1990           blob->parent = 0;
1991
1992         blob->n_interfaces = 0;
1993         blob->n_fields = 0;
1994         blob->n_properties = 0;
1995         blob->n_methods = 0;
1996         blob->n_signals = 0;
1997         blob->n_vfuncs = 0;
1998         blob->n_constants = 0;
1999
2000         *offset += 32;
2001         for (l = object->interfaces; l; l = l->next)
2002           {
2003             blob->n_interfaces++;
2004             *(guint16*)&data[*offset] = find_entry (module, modules, (gchar *)l->data);
2005             *offset += 2;
2006           }
2007
2008         members = g_list_copy (object->members);
2009
2010         *offset = ALIGN_VALUE (*offset, 4);
2011         g_ir_node_build_members (&members, G_IR_NODE_FIELD, &blob->n_fields,
2012                                  module, modules, strings,
2013                                  types, data, offset, offset2);
2014
2015         *offset = ALIGN_VALUE (*offset, 4);
2016         g_ir_node_build_members (&members, G_IR_NODE_PROPERTY, &blob->n_properties,
2017                                  module, modules, strings,
2018                                  types, data, offset, offset2);
2019
2020         *offset = ALIGN_VALUE (*offset, 4);
2021         g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_methods,
2022                                  module, modules, strings,
2023                                  types, data, offset, offset2);
2024
2025         *offset = ALIGN_VALUE (*offset, 4);
2026         g_ir_node_build_members (&members, G_IR_NODE_SIGNAL, &blob->n_signals,
2027                                  module, modules, strings,
2028                                  types, data, offset, offset2);
2029
2030         *offset = ALIGN_VALUE (*offset, 4);
2031         g_ir_node_build_members (&members, G_IR_NODE_VFUNC, &blob->n_vfuncs,
2032                                  module, modules, strings,
2033                                  types, data, offset, offset2);
2034
2035         *offset = ALIGN_VALUE (*offset, 4);
2036         g_ir_node_build_members (&members, G_IR_NODE_CONSTANT, &blob->n_constants,
2037                                  module, modules, strings,
2038                                  types, data, offset, offset2);
2039
2040         g_ir_node_check_unhandled_members (&members, node->type);
2041
2042         g_assert (members == NULL);
2043       }
2044       break;
2045
2046     case G_IR_NODE_INTERFACE:
2047       {
2048         InterfaceBlob *blob = (InterfaceBlob *)&data[*offset];
2049         GIrNodeInterface *iface = (GIrNodeInterface *)node;
2050         GList *members;
2051
2052         blob->blob_type = BLOB_TYPE_INTERFACE;
2053         blob->deprecated = iface->deprecated;
2054         blob->reserved = 0;
2055         blob->name = write_string (node->name, strings, data, offset2);
2056         blob->gtype_name = write_string (iface->gtype_name, strings, data, offset2);
2057         blob->gtype_init = write_string (iface->gtype_init, strings, data, offset2);
2058         blob->n_prerequisites = 0;
2059         blob->n_properties = 0;
2060         blob->n_methods = 0;
2061         blob->n_signals = 0;
2062         blob->n_vfuncs = 0;
2063         blob->n_constants = 0;
2064
2065         *offset += 28;
2066         for (l = iface->prerequisites; l; l = l->next)
2067           {
2068             blob->n_prerequisites++;
2069             *(guint16*)&data[*offset] = find_entry (module, modules, (gchar *)l->data);
2070             *offset += 2;
2071           }
2072
2073         members = g_list_copy (iface->members);
2074
2075         *offset = ALIGN_VALUE (*offset, 4);
2076         g_ir_node_build_members (&members, G_IR_NODE_PROPERTY, &blob->n_properties,
2077                                  module, modules, strings,
2078                                  types, data, offset, offset2);
2079
2080         *offset = ALIGN_VALUE (*offset, 4);
2081         g_ir_node_build_members (&members, G_IR_NODE_FUNCTION, &blob->n_methods,
2082                                  module, modules, strings,
2083                                  types, data, offset, offset2);
2084
2085         *offset = ALIGN_VALUE (*offset, 4);
2086         g_ir_node_build_members (&members, G_IR_NODE_SIGNAL, &blob->n_signals,
2087                                  module, modules, strings,
2088                                  types, data, offset, offset2);
2089
2090         *offset = ALIGN_VALUE (*offset, 4);
2091         g_ir_node_build_members (&members, G_IR_NODE_VFUNC, &blob->n_vfuncs,
2092                                  module, modules, strings,
2093                                  types, data, offset, offset2);
2094
2095         *offset = ALIGN_VALUE (*offset, 4);
2096         g_ir_node_build_members (&members, G_IR_NODE_CONSTANT, &blob->n_constants,
2097                                  module, modules, strings,
2098                                  types, data, offset, offset2);
2099
2100         g_ir_node_check_unhandled_members (&members, node->type);
2101
2102         g_assert (members == NULL);
2103       }
2104       break;
2105
2106
2107     case G_IR_NODE_VALUE:
2108       {
2109         GIrNodeValue *value = (GIrNodeValue *)node;
2110         ValueBlob *blob = (ValueBlob *)&data[*offset];
2111         *offset += 12;
2112
2113         blob->deprecated = value->deprecated;
2114         blob->reserved = 0;
2115         blob->name = write_string (node->name, strings, data, offset2);
2116         blob->value = value->value;
2117       }
2118       break;
2119
2120     case G_IR_NODE_ERROR_DOMAIN:
2121       {
2122         GIrNodeErrorDomain *domain = (GIrNodeErrorDomain *)node;
2123         ErrorDomainBlob *blob = (ErrorDomainBlob *)&data[*offset];
2124         *offset += 16;
2125
2126         blob->blob_type = BLOB_TYPE_ERROR_DOMAIN;
2127         blob->deprecated = domain->deprecated;
2128         blob->reserved = 0;
2129         blob->name = write_string (node->name, strings, data, offset2);
2130         blob->get_quark = write_string (domain->getquark, strings, data, offset2);
2131         blob->error_codes = find_entry (module, modules, domain->codes);
2132         blob->reserved2 = 0;
2133       }
2134       break;
2135
2136     case G_IR_NODE_CONSTANT:
2137       {
2138         GIrNodeConstant *constant = (GIrNodeConstant *)node;
2139         ConstantBlob *blob = (ConstantBlob *)&data[*offset];
2140         guint32 pos;
2141
2142         pos = *offset + 8;
2143         *offset += 20;
2144
2145         blob->blob_type = BLOB_TYPE_CONSTANT;
2146         blob->deprecated = constant->deprecated;
2147         blob->reserved = 0;
2148         blob->name = write_string (node->name, strings, data, offset2);
2149
2150         blob->offset = *offset2;
2151         switch (constant->type->tag)
2152           {
2153           case GI_TYPE_TAG_BOOLEAN:
2154             blob->size = 4;
2155             *(gboolean*)&data[blob->offset] = parse_boolean_value (constant->value);
2156             break;
2157             case GI_TYPE_TAG_INT8:
2158             blob->size = 1;
2159               *(gint8*)&data[blob->offset] = (gint8) parse_int_value (constant->value);
2160             break;
2161           case GI_TYPE_TAG_UINT8:
2162             blob->size = 1;
2163             *(guint8*)&data[blob->offset] = (guint8) parse_uint_value (constant->value);
2164             break;
2165           case GI_TYPE_TAG_INT16:
2166             blob->size = 2;
2167             *(gint16*)&data[blob->offset] = (gint16) parse_int_value (constant->value);
2168             break;
2169           case GI_TYPE_TAG_UINT16:
2170             blob->size = 2;
2171             *(guint16*)&data[blob->offset] = (guint16) parse_uint_value (constant->value);
2172             break;
2173           case GI_TYPE_TAG_INT32:
2174             blob->size = 4;
2175             *(gint32*)&data[blob->offset] = (gint32) parse_int_value (constant->value);
2176             break;
2177           case GI_TYPE_TAG_UINT32:
2178             blob->size = 4;
2179             *(guint32*)&data[blob->offset] = (guint32) parse_uint_value (constant->value);
2180             break;
2181           case GI_TYPE_TAG_INT64:
2182             blob->size = 8;
2183             *(gint64*)&data[blob->offset] = (gint64) parse_int_value (constant->value);
2184             break;
2185           case GI_TYPE_TAG_UINT64:
2186             blob->size = 8;
2187             *(guint64*)&data[blob->offset] = (guint64) parse_uint_value (constant->value);
2188             break;
2189           case GI_TYPE_TAG_INT:
2190             blob->size = sizeof (gint);
2191             *(gint*)&data[blob->offset] = (gint) parse_int_value (constant->value);
2192             break;
2193           case GI_TYPE_TAG_UINT:
2194             blob->size = sizeof (guint);
2195             *(gint*)&data[blob->offset] = (guint) parse_uint_value (constant->value);
2196             break;
2197           case GI_TYPE_TAG_SSIZE: /* FIXME */
2198           case GI_TYPE_TAG_LONG:
2199             blob->size = sizeof (glong);
2200             *(glong*)&data[blob->offset] = (glong) parse_int_value (constant->value);
2201             break;
2202           case GI_TYPE_TAG_SIZE: /* FIXME */
2203           case GI_TYPE_TAG_TIME_T:
2204           case GI_TYPE_TAG_ULONG:
2205             blob->size = sizeof (gulong);
2206             *(gulong*)&data[blob->offset] = (gulong) parse_uint_value (constant->value);
2207             break;
2208           case GI_TYPE_TAG_FLOAT:
2209             blob->size = sizeof (gfloat);
2210             *(gfloat*)&data[blob->offset] = (gfloat) parse_float_value (constant->value);
2211             break;
2212           case GI_TYPE_TAG_DOUBLE:
2213             blob->size = sizeof (gdouble);
2214             *(gdouble*)&data[blob->offset] = (gdouble) parse_float_value (constant->value);
2215             break;
2216           case GI_TYPE_TAG_UTF8:
2217           case GI_TYPE_TAG_FILENAME:
2218             blob->size = strlen (constant->value) + 1;
2219             memcpy (&data[blob->offset], constant->value, blob->size);
2220             break;
2221           }
2222         *offset2 += ALIGN_VALUE (blob->size, 4);
2223
2224         g_ir_node_build_typelib ((GIrNode *)constant->type, module, modules,
2225                                  strings, types, data, &pos, offset2);
2226       }
2227       break;
2228     default:
2229       g_assert_not_reached ();
2230     }
2231
2232   g_debug ("node %s%s%s%p type '%s', offset %d -> %d, offset2 %d -> %d",
2233            node->name ? "'" : "",
2234            node->name ? node->name : "",
2235            node->name ? "' " : "",
2236            node, g_ir_node_type_to_string (node->type),
2237            old_offset, *offset, old_offset2, *offset2);
2238
2239   if (*offset2 - old_offset2 + *offset - old_offset > g_ir_node_get_full_size (node))
2240     g_error ("exceeding space reservation !!");
2241 }
2242
2243 /* if str is already in the pool, return previous location, otherwise write str
2244  * to the typelib at offset, put it in the pool and update offset. If the
2245  * typelib is not large enough to hold the string, reallocate it.
2246  */
2247 guint32
2248 write_string (const gchar *str,
2249               GHashTable  *strings,
2250               guchar      *data,
2251               guint32     *offset)
2252 {
2253   gpointer value;
2254   guint32 start;
2255
2256   string_count += 1;
2257   string_size += strlen (str);
2258
2259   value = g_hash_table_lookup (strings, str);
2260
2261   if (value)
2262     return GPOINTER_TO_UINT (value);
2263
2264   unique_string_count += 1;
2265   unique_string_size += strlen (str);
2266
2267   g_hash_table_insert (strings, (gpointer)str, GUINT_TO_POINTER (*offset));
2268
2269   start = *offset;
2270   *offset = ALIGN_VALUE (start + strlen (str) + 1, 4);
2271
2272   strcpy ((gchar*)&data[start], str);
2273
2274   return start;
2275 }
2276